UDN
Search public documentation:

DevelopmentKitGemsCanvasKismetNodesKR
English Translation
日本語訳
中国翻译

Interested in the Unreal Engine?
Visit the Unreal Technology site.

Looking for jobs and company info?
Check out the Epic games site.

Questions about support via UDN?
Contact the UDN Staff

UE3 홈 > UDK 젬 > 캔버스(Canavas) 키즈멧 노드 만들기
UE3 홈 > 키즈멧 비주얼 스크립팅 > 캔버스(Canavas) 키즈멧 노드 만들기

캔버스(Canavas) 키즈멧 노드 만들기


문서 변경내역: James Tan 작성. 홍성진 번역.
UDK 2011년 4월 버전으로 최종 테스팅, PC 와 iOS 호환

개요


키즈멧은 개발자가 될수있는 한 빨리 작동되는 간단 프로토타입을 만들고자 할 때 좋은 툴입니다. 이 젬에서는 키즈멧에서 머티리얼, 텍스처, 텍스트를 쉽게 그릴 수 있도록 해 주는 단순한 Canvas 그리기 함수성을 추가해 보겠습니다. 기능이 더 필요하면 이 젬을 확장하면 됩니다. 기존 MobileHUD 방법보다 이 젬이 나은 점은, HUD 서브클래스가 있든 없든 간에 어느 게임타입에서든 작동하는 방법이라는 점입니다.

HUDKismetExampleCanvas.jpg

HUDKismetSeqEvent_RenderHUD


이 키즈멧 시퀸스 이벤트 노드는 HUD 가 프레임을 렌더할 때마다 호출됩니다. 원하는 만큼 만들 수는 있지만, 각 Render HUD 이벤트가 호출될 때 순서를 결정하기가 어렵습니다. (게임 안에서는 일관적일 수 있지만, 그 범위를 넘어서면 그렇지 않을 수 있습니다.)

HUDKismetRenderHUDNode.jpg

소스 코드

이 시퀸스 이벤트의 로직은:
  • 시퀸스 이벤트가 등록되면, 렌더링 프록시가 없는 경우 만듭니다.
  • 렌더링 프록시가 있는 경우, 시퀸스 이벤트를 렌더링 프록시의 렌더링 시퀸스 배열에 추가시킵니다.
  • 프레임을 렌더하기 위해 렌더링 프록시가 호출된 경우, 각 Render HUD 시퀸스 이벤트 속에서 Render 함수를 호출합니다. 그리고서 Render HUD 시퀸스 이벤트는 각 렌더 시퀸스 액션을 반복처리한 다음 찾아낸 것 속에서 Render 함수를 호출합니다.

HUDKismetSeqEvent_RenderHUD.uc
  class HUDKismetSeqEvent_RenderHUD extends SequenceEvent;
  
  var Object PlayerController;
  var Vector CameraPosition;
  var Vector CameraDirection;
  
  event RegisterEvent()
  {
    local WorldInfo WorldInfo;
    local HUDKismetRenderProxy RenderProxy, FoundRenderProxy;
  
    // 월드 인포 구하기
    WorldInfo = class'WorldInfo'.static.GetWorldInfo();
  
    // 월드 인포가 없으면 중단
    if (WorldInfo == None)
    {
      return;
    }
  
    // 이 Render HUD 이벤트에 연결해줄 렌더 프록시 찾기
    ForEach WorldInfo.DynamicActors(class'HUDKismetRenderProxy', FoundRenderProxy)
    {
      RenderProxy = FoundRenderProxy;
      break;
    }
  
    // 렌더 프록시가 없으면 새로 만들기
    if (RenderProxy == None)
    {
      RenderProxy = WorldInfo.Spawn(class'HUDKismetRenderProxy');
    }
  
    // 이 HUD 렌더 시퀸스를 렌더링 프록시에 추가
    if (RenderProxy != None)
    {
      RenderProxy.AddRenderHUDSequenceEvent(Self);
    }
  }
  
  function Render(Canvas Canvas)
  {
    local int i, j;
    local HUDKismetSeqAct_RenderObject RenderObject;
  
    // 출력 링크 렌더
    if (OutputLinks.Length > 0)
    {
      for (i = 0; i < OutputLinks.Length; ++i)
      {
        if (OutputLinks[i].Links.Length > 0)
        {
          for (j = 0; j < OutputLinks[i].Links.Length; ++j)
          {
            RenderObject = HUDKismetSeqAct_RenderObject(OutputLinks[i].Links[j].LinkedOp);
  
            if (RenderObject != None)
            {
              RenderObject.Render(Canvas);
            }
          }
        }
      }
    }
  }
  
  defaultproperties
  {
    ObjName="Render HUD"
    ObjCategory="ExtHUD"
  
    MaxTriggerCount=0
    bPlayerOnly=false
  
    OutputLinks(0)=(LinkDesc="Out")
  
    VariableLinks(0)=(ExpectedType=class'SeqVar_Object',bHidden=true,LinkDesc="PlayerController",bWriteable=true,PropertyName=PlayerController)
    VariableLinks(1)=(ExpectedType=class'SeqVar_Vector',bHidden=true,LinkDesc="Camera Position",bWriteable=true,PropertyName=CameraPosition)
    VariableLinks(2)=(ExpectedType=class'SeqVar_Vector',bHidden=true,LinkDesc="Camera Direction",bWriteable=true,PropertyName=CameraDirection)
  }
  

Render HUD 시퀸스 이벤트 추가하기

HUDKismetAddRenderHUDEvent.jpg

HUDKismetRenderProxy


렌더 프록시는 HUD 속에서 찾은 PostRenderActor 배열 속으로 후킹하기 위해 만들어진 액터입니다.

소스 코드

이 렌더 프록시의 로직은:
  • 헬퍼 함수 (AddRenderHUDSequenceEvent) 가 그 내부 배열에 Render HUD 시퀸스 이벤트를 추가합니다. 이는 HUDKismetSeqEvent_RenderHUD 에 의해 호출됩니다.
  • Tick 을 단 한번 사용하면 그 자체가 모든 Player Controller 의 HUD PostRender 액터에 추가됩니다.
  • HUD 의 PostRender 콜 마지막에 PostRenderFor 가 호출됩니다. 그러면 등록된 Render HUD 시퀸스 이벤트 모두에게 렌더링이 전파됩니다.

HUDKismetRenderProxy.uc
  class HUDKismetRenderProxy extends Actor;
  
  // 프록시가 플레이어 콘트롤러에 할당되었는지?
  var bool HasAddedToAllControllers;
  // HUD 렌더 이벤트 목록
  var PrivateWrite array<HUDKismetSeqEvent_RenderHUD> RenderHUDSequenceEvents;
  
  function AddRenderHUDSequenceEvent(HUDKismetSeqEvent_RenderHUD RenderHUDSequenceEvent)
  {
    local int i;
  
    // Render HUD 시퀸스 이벤트가 이미 있는지 검사
    if (RenderHUDSequenceEvents.Length > 0)
    {
      for (i = 0; i < RenderHUDSequenceEvents.Length; ++i)
      {
        if (RenderHUDSequenceEvents[i] == RenderHUDSequenceEvent)
        {
          return;
        }
      }
    }
  
    // Render HUD 시퀸스 이벤트를 배열속에 추가
    RenderHUDSequenceEvents.AddItem(RenderHUDSequenceEvent);
  }
  
  function Tick(float DeltaTime)
  {
    local PlayerController PlayerController;
  
    if (!HasAddedToAllControllers)
    {
      // 렌더 프록시를 모든 로컬 플레이어 콘트롤러에 추가
      ForEach WorldInfo.AllControllers(class'PlayerController', PlayerController)
      {
        if (PlayerController != None && PlayerController.MyHUD != None)
        {
          PlayerController.MyHUD.bShowOverlays = true;
          PlayerController.MyHUD.AddPostRenderedActor(Self);
          HasAddedToAllControllers = true;
        }
      }
    }
  
    Super.Tick(DeltaTime);
  }
  
  simulated event PostRenderFor(PlayerController PC, Canvas Canvas, Vector CameraPosition, Vector CameraDir)
  {
    local int i;
  
    // 캔버스가 사용불가 상태거나, 렌더할 시퀸스 이벤트가 없는 경우 중단
    if (Canvas == None || RenderHUDSequenceEvents.Length <= 0)
    {
      return;
    }
  
    // 각 HUD 렌더 시퀸스에 대해, 렌더 전파
    for (i = 0; i < RenderHUDSequenceEvents.Length; ++i)
    {
      if (RenderHUDSequenceEvents[i] != None)
      {
        // 키즈멧용 플레이어 콘트롤러 전달
        RenderHUDSequenceEvents[i].PlayerController = PC;
        // 키즈멧용 카메라 위치 전달
        RenderHUDSequenceEvents[i].CameraPosition = CameraPosition;
        // 키즈멧용 카메라 방향 전달
        RenderHUDSequenceEvents[i].CameraDirection = CameraDir;
        // 렌더 콜 전달
        RenderHUDSequenceEvents[i].Render(Canvas);
      }
    }
  }
  
  defaultproperties
  {
    bPostRenderIfNotVisible=true
  }
  

HUDKismetSeqAct_RenderObject


다른 모든 렌더 키즈멧 시퀸스 액션이 서브클래싱하는 앱스트랙트(abstract, 추상) 키즈멧 시퀸스입니다.

소스 코드

이 앱스트랙트 시퀸스 액션의 로직은:
  • Render 함수가 호출되면, 그 호출을 연결된 자식 모두에게 전파합니다.

HUDKismetSeqAct_RenderObject.uc
  class HUDKismetSeqAct_RenderObject extends SequenceAction
    abstract;
  
  function Render(Canvas Canvas)
  {
    local int i, j;
    local HUDKismetSeqAct_RenderObject RenderObject;
  
    // 렌더링 콜을 다른 모든 자식 링크에 전파
    if (OutputLinks.Length > 0)
    {
      for (i = 0; i < OutputLinks.Length; ++i)
      {
        if (OutputLinks[i].Links.Length > 0)
        {
          for (j = 0; j < OutputLinks[i].Links.Length; ++j)
          {
            RenderObject = HUDKismetSeqAct_RenderObject(OutputLinks[i].Links[j].LinkedOp);
  
            if (RenderObject != None)
            {
              RenderObject.Render(Canvas);
            }
          }
        }
      }
    }
  }
  
  defaultproperties
  {
    VariableLinks.Empty
  }
  

HUDKismetSeqAct_RenderTexture


이 키즈멧 시퀸스 액션은 캔버스 위에 텍스처를 렌더합니다.

HUDKismetRenderTextureNode.jpg

소스 코드

이 시퀸스 액션의 로직은:
  • 렌더링 전, 실제 또는 상대 크기를 사용하거나, 실제 또는 상대 위치를 사용해서 캔버스가 사용가능한지 검사해 봅니다.
  • 사용자가 Texture 키즈멧 변수 노드에 연결했다면, 그것을 우선시합니다.
  • 렌더링 위치를 계산합니다.
  • 렌더링 크기를 계산합니다.
  • 텍스처 렌더링 바운드를 계산합니다.
  • 사용자가 설정한 여러가지 프로퍼티에 따라 텍스처를 평소처럼 또는 늘리거나 회전시켜서 렌더합니다.

HUDKismetSeqAct_RenderTexture.uc
  class HUDKismetSeqAct_RenderTexture extends HUDKismetSeqAct_RenderObject;
  
  struct TextureRotation
  {
    // 언리얼 유닛 단위로 텍스처를 로테이트시킬 양 (65536 == 360 도)
    var() int Rotation;
    // 로테이션 중심점 (0.5f 면 정 가운데)
    var() Vector2D Anchor;
  
    structdefaultproperties
    {
      Anchor=(X=0.5f,Y=0.5f)
    }
  };
  
  struct TextureCoords
  {
    var() float U;
    var() float V;
    var() float UL;
    var() float VL;
  
    structdefaultproperties
    {
      U=0.f
      V=0.f
      UL=-1.f
      VL=-1.f
    }
  };
  
  struct TextureStretched
  {
    var() bool StretchHorizontally;
    var() bool StretchVertically;
    var() float ScalingFactor;
  
    structdefaultproperties
    {
      ScalingFactor=1.f
    }
  };
  
  // 실제 크기 좌표 사용에 대한 조건
  var bool UsingActualSize;
  // 상대 크기 좌표 사용에 대한 조건
  var bool UsingRelativeSize;
  // 실제 위치 좌표 사용에 대한 조건
  var bool UsingActualPosition;
  // 상대 위치 좌표 사용에 대한 조건
  var bool UsingRelativePosition;
  // 늘이는 방법 사용에 대한 조건
  var bool UsingStretched;
  // 블렌드 모드 덮어쓰기에 대한 조건
  var bool OverrideBlendMode;
  
  // 렌더할 텍스처. 사용자가 Texture 변수 링크를 설정했다면 여기다 덮어씁니다.
  var(RenderTexture) Object Texture;
  // 텍스처를 렌더할 실제 크기
  var(RenderTexture) IntPoint ActualSize<EditCondition=UsingActualSize>;
  // 텍스처를 렌더할 뷰포트 해상도에 상대적인 크기
  var(RenderTexture) Vector2D RelativeSize<EditCondition=UsingRelativeSize>;
  // 텍스처를 렌더할 실제 위치
  var(RenderTexture) IntPoint ActualPosition<EditCondition=UsingActualPosition>;
  // 텍스처를 렌더할 뷰포트 해상도에 상대적인 크기
  var(RenderTexture) Vector2D RelativePosition<EditCondition=UsingRelativePosition>;
  // 렌더할 텍스처의 로테이션
  var(RenderTexture) TextureRotation Rotation;
  // 렌더할 텍스처의 좌표
  var(RenderTexture) TextureCoords Coords;
  // 텍스처에 렌더하려는 색
  var(RenderTexture) Color RenderColor<DisplayName=Color>;
  // 텍스처를 렌더링할 때 늘어지는 프로퍼티
  var(RenderTexture) TextureStretched Stretched<EditCondition=UsingStretched>;
  // 텍스처 일부가 렌더링 범위 밖에 있을 때 (회전되거나 늘어나지 않은 텍스처에 대해서만) 잘라줄 것인가?
  var(RenderTexture) bool ClipTile;
  // (회전되거나 늘어나지 않은 것에 대해서만) 텍스처 렌더링용 블렌드 모드 (iOS 상의 머티리얼에 대해서는 항상 덮어씁니다).
  var(RenderTexture) EBlendMode BlendMode<EditCondition=OverrideBlendMode>;
  
  function Render(Canvas Canvas)
  {
    local IntPoint RenderPosition;
    local IntPoint RenderSize;
    local Texture2D RenderTexture;
    local int UL;
    local int VL;
    local Rotator R;
    local SeqVar_Object SeqVar_Object;
  
    if (Canvas != None && (UsingActualSize || UsingRelativeSize) && (UsingActualPosition || UsingRelativePosition))
    {
      // 사용자가 텍스처 키즈멧 노드 링크를 설정했는지 검사
      if (VariableLinks[0].LinkedVariables.Length > 0)
      {
        SeqVar_Object = SeqVar_Object(VariableLinks[0].LinkedVariables[0]);
  
        if (SeqVar_Object != None)
        {
          RenderTexture = Texture2D(SeqVar_Object.GetObjectValue());
        }
      }
      else
      {
        RenderTexture = Texture2D(Texture);
      }
  
      if (RenderTexture != None)
      {
        // 위치 계산
        if (UsingRelativePosition)
        {
          RenderPosition.X = Canvas.ClipX * RelativePosition.X;
          RenderPosition.Y = Canvas.ClipY * RelativePosition.Y;
        }
        else
        {
          RenderPosition = ActualPosition;
        }
  
        // 크기 계산
        if (UsingRelativeSize)
        {
          RenderSize.X = Canvas.ClipX * RelativeSize.X;
          RenderSize.Y = Canvas.ClipY * RelativeSize.Y;
        }
        else
        {
          RenderSize = ActualSize;
        }
  
        // 텍스처 폭 계산
        UL = (Coords.UL == -1) ? RenderTexture.SizeX : int(Coords.UL);
        // 텍스처 높이 계산
        VL = (Coords.VL == -1) ? RenderTexture.SizeY : int(Coords.VL);
  
        // 렌더할 위치 계산
        Canvas.SetPos(RenderPosition.X, RenderPosition.Y);
        // 그릴 색 설정
        Canvas.SetDrawColor(RenderColor.R, RenderColor.G, RenderColor.B, RenderColor.A);
  
        if (UsingStretched)
        {
          // 텍스처 늘여 렌더
          Canvas.DrawTileStretched(RenderTexture, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL,, Stretched.StretchHorizontally, Stretched.StretchVertically, Stretched.ScalingFactor);
        }
        else
        {
          if (Rotation.Rotation == 0)
          {
            // 텍스처 정상적으로 렌더
            if (OverrideBlendMode)
            {
              Canvas.DrawTile(RenderTexture, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL,, ClipTile, BlendMode);
            }
            else
            {
              Canvas.DrawTile(RenderTexture, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL,, ClipTile);
            }
         }
          else
          {
            // 텍스처 회전시켜 렌더
          R.Pitch = 0;
            R.Yaw = Rotation.Rotation;
            R.Roll = 0;
            Canvas.DrawRotatedTile(RenderTexture, R, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL, Rotation.Anchor.X, Rotation.Anchor.Y);
          }
        }
      }
    }
  
    Super.Render(Canvas);
  }
  
  defaultproperties
  {
    RenderColor=(R=255,G=255,B=255,A=255)
  
    ObjName="Render Texture"
    ObjCategory="ExtHUD"
  
    VariableLinks(0)=(ExpectedType=class'SeqVar_Object',LinkDesc="Texture",PropertyName=Texture)
  }
  

Render Texture 시퀸스 액션 추가하기

HUDKismetAddRenderTextureAction.jpg

Render Texture 프로퍼티

  • Texture 텍스처 - 렌더할 텍스처. 사용자가 Texture 키즈멧 변수 노드를 설정했다면 여기다 덮어씁니다.
  • Actual Size 실제 크기 - 텍스처를 렌더할 크기로, 픽셀 단위입니다.
  • Relative Size 상대 크기 - 렌더할 텍스처의 뷰포트 해상도에 상대적인 크기입니다.
  • Actual Position 실제 위치 - 텍스처를 렌더할 위치로, 픽셀 단위입니다.
  • Relative Position 상대 위치 - 렌더할 텍스처의 퓨보트 해상도에 상대적인 위치입니다.
  • Rotation 로테이션
    • Rotation 로테이션 - 텍스처를 회전시킬 각으로 언리얼 단위입니다. 65536 언리얼 유닛은 = 360 도 입니다.
    • Anchor 앵커 - 텍스처를 회전시킬 상대 위치입니다. 0.5f = 센터 입니다.
  • Coords 좌표 - 렌더할 서브 텍스처의 좌표입니다. 전체 텍스처를 렌더하려면 디폴트로 놔두십시오.
  • Color 컬러 - 텍스처를 렌더할 색입니다.
  • Stretched 스트레치
    • StretchHorizontal 가로로 스트레치 - 텍스처를 가로로 늘어질 수 있도록 합니다.
    • StretchVertically 세로로 스트레치 - 텍스처를 세로로 늘어질 수 있도록 합니다.
    • ScalingFactor 스케일 팩터 - 스트레치의 스케일을 변경합니다.
  • ClipTile 클립 타일 - 타일 일부가 화면을 벗어나 있으면 타일 렌더링을 잘라냅니다.
  • BlendMode 블렌드 모드 - 블렌드 모드를 덮어쓸 수 있도록 해 주며, 그렇지 않으면 Canvas 가 적합한 텍스처 타입과 블렌드를 감지할 것입니다.

HUDKismetRenderTextureProperties.jpg

관련 토픽

HUDKismetSeqAct_RenderMaterial


이 키즈멧 시퀸스 액션은 캔버스 위에 머티리얼을 렌더합니다.

HUDKismetRenderMaterialNode.jpg

소스 코드

이 시퀸스 액션의 로직은:
  • Render 함수가 호출되면, 캔버스가 사용가능한지 확인하기 위한 검사를 실제 / 상대 크기 혹은 실제 / 상대 위치를 사용하여 수행합니다.
  • 사용자가 Material 키즈멧 노드 링크를 를 설정했는지 검사합니다. 사용자가 MaterialInstanceActor 를 사용중이라면, 그 속에 있는 머티리얼 인스턴스 불변 값을 구합니다. 아니면 머티리얼 인터페이스 세트를 구합니다.
  • 위치를 계산합니다.
  • 크기를 계산합니다.
  • 좌표를 계산합니다.
  • 머티리얼을 정상적으로 또는 회전시켜 렌더합니다.
    • 플랫폼이 모바일이나 iOS 인 경우, Material 에 정의된 대로 블렌드 모드를 덮어씁니다. 그런 다음 적용 가능하다면 Material 에 저장된 MobileBaseTexture 리퍼런스를 사용하여 RenderTexture 렌더링 함수로 되돌아갑니다.
    • 아니면, 머티리얼을 정상적으로 또는 회전시켜 렌더합니다.

HUDKismetSeqAct_RenderMaterial.uc
  class HUDKismetSeqAct_RenderMaterial extends HUDKismetSeqAct_RenderTexture;
  
  // 렌더할 머티리얼입니다. 사용자가 Material 변수 링크를 설정했다면 여기다 덮어씁니다.
  var(RenderMaterial) Object Material;
  
  function Render(Canvas Canvas)
  {
    local IntPoint RenderPosition;
    local IntPoint RenderSize;
    local MaterialInterface RenderMaterialInterface;
    local Material RenderMaterial;
    local int UL;
    local int VL;
    local Rotator R;
    local SeqVar_Object SeqVar_Object;
    local WorldInfo worldInfo;
  
    // 이 플랫폼에서 실행 허용되었는지 검사합니다.
    WorldInfo = class'WorldInfo'.static.GetWorldInfo();
    if (WorldInfo != None && (WorldInfo.IsConsoleBuild(CONSOLE_Mobile) || WorldInfo.IsConsoleBuild(CONSOLE_IPhone)))
    {
      // 사용자가 Material 키즈멧 노드 링크를 설정했는지 검사합니다.
      if (VariableLinks[0].LinkedVariables.Length > 0)
      {
        SeqVar_Object = SeqVar_Object(VariableLinks[0].LinkedVariables[0]);
  
        if (SeqVar_Object != None)
        {
          if (MaterialInterface(SeqVar_Object.GetObjectValue()) != None)
          {
            RenderMaterialInterface = MaterialInterface(SeqVar_Object.GetObjectValue());
          }
          else if (MaterialInstanceActor(SeqVar_Object.GetObjectValue()) != None)
          {
            RenderMaterialInterface = MaterialInstanceActor(SeqVar_Object.GetObjectValue()).MatInst;
          }
        }
      }
      else
      {
        if (MaterialInterface(Material) != None)
        {
          RenderMaterialInterface = MaterialInterface(Material);
        }
        else if (MaterialInstanceActor(Material) != None)
        {
          RenderMaterialInterface = MaterialInstanceActor(Material).MatInst;
        }
      }
  
      if (RenderMaterialInterface != None)
      {
        RenderMaterial = Material(RenderMaterialInterface);
      if (RenderMaterial != None)
      {
          OverrideBlendMode = true;
          BlendMode = RenderMaterial.BlendMode;
        }
  
        Texture = RenderMaterialInterface.MobileBaseTexture;
  
        if (Texture != None)
        {
          Super.Render(Canvas);
        }
      }
    }
    else
    {
      if (Canvas != None && (UsingActualSize || UsingRelativeSize) && (UsingActualPosition || UsingRelativePosition))
      {
        // 사용자가 머티리얼 키즈멧 노드 링크를 설정했는지 검사합니다.
        if (VariableLinks[0].LinkedVariables.Length > 0)
        {
          SeqVar_Object = SeqVar_Object(VariableLinks[0].LinkedVariables[0]);
  
          if (SeqVar_Object != None)
          {
            if (MaterialInterface(SeqVar_Object.GetObjectValue()) != None)
            {
              RenderMaterialInterface = MaterialInterface(SeqVar_Object.GetObjectValue());
            }
            else if (MaterialInstanceActor(SeqVar_Object.GetObjectValue()) != None)
            {
              RenderMaterialInterface = MaterialInstanceActor(SeqVar_Object.GetObjectValue()).MatInst;
            }
          }
        }
        else
        {
          if (MaterialInterface(Material) != None)
          {
            RenderMaterialInterface = MaterialInterface(Material);
          }
          else if (MaterialInstanceActor(Material) != None)
          {
            RenderMaterialInterface = MaterialInstanceActor(Material).MatInst;
          }
        }
  
        if (RenderMaterialInterface != None)
        {
        // 위치를 계산합니다.
        if (UsingRelativePosition)
        {
          RenderPosition.X = Canvas.ClipX * RelativePosition.X;
          RenderPosition.Y = Canvas.ClipY * RelativePosition.Y;
        }
        else
        {
          RenderPosition = ActualPosition;
        }
  
        // 크기를 계산합니다.
        if (UsingRelativeSize)
        {
          RenderSize.X = Canvas.ClipX * RelativeSize.X;
          RenderSize.Y = Canvas.ClipY * RelativeSize.Y;
        }
        else
        {
          RenderSize = ActualSize;
        }
  
        // 텍스처 폭을 계산합니다.
        UL = (Coords.UL == -1) ? 1.f : Coords.UL;
        // 텍스처 높이를 계산합니다.
        VL = (Coords.VL == -1) ? 1.f : Coords.VL;
  
        // 렌더할 위치를 설정합니다.
        Canvas.SetPos(RenderPosition.X, RenderPosition.Y);
  
        if (Rotation.Rotation == 0)
        {
          // 머티리얼을 정상적으로 렌더합니다.
          Canvas.DrawMaterialTile(RenderMaterial, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL);
        }
        else
        {
          // 머티리얼을 회전시켜 렌더합니다.
          R.Pitch = 0;
          R.Yaw = Rotation.Rotation;
          R.Roll = 0;
            Canvas.DrawRotatedMaterialTile(RenderMaterialInterface, R, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL, Rotation.Anchor.X, Rotation.Anchor.Y);
        }
      }
    }
  
      Super(HUDKismetSeqAct_RenderObject).Render(Canvas);
    }
  }
  
  defaultproperties
  {
    ObjName="Render Material"
    ObjCategory="ExtHUD"
  
    VariableLinks(0)=(ExpectedType=class'SeqVar_Object',LinkDesc="Material",PropertyName=Material)
  }
  

Render Material 시퀸스 액션 추가하기

HUDKismetAddRenderMaterialAction.jpg

Render Material 프로퍼티

  • Material 머티리얼 - 렌더할 머티리얼입니다. 사용자가 Material 키즈멧 노드를 설정했다면 여기다 덮어씁니다.

HUDKismetRenderMaterialProperties.jpg

관련 토픽

HUDKismetSeqAct_RenderText


이 키즈멧 시퀸스 액션은 캔버스 위에 텍스트를 렌더합니다.

HUDKismetRenderTextNode.jpg

소스 코드

이 시퀸스 액션의 로직은:
  • Render 함수가 호출되면 현지화된/되지 않은 텍스트를 사용하여 폰트가 사용가능한지, 실제/상대 위치를 사용하여 캔버스가 사용가능한지 검사해 봅니다.
  • 렌더할 텍스트를 구합니다. 사용자가 Text/Localized Text 키즈멧 변수 노드를 설정했으면 그것이 우선시됩니다. 둘 중 하나를 사용한다면 그에 맞는 체크 박스를 체크하고 필드는 공란으로 놔둬야 합니다.
  • 좌상단 정렬을 통해 초기 위치를 계산합니다.
  • 폰트를 설정하고 텍스처 크기를 구합니다.
  • 가로 세로 정렬 프로퍼티에 따라 위치를 오프셋시킵니다.
  • 텍스트를 렌더합니다.

HUDKismetSeqAct_RenderText.uc
  class HUDKismetSeqAct_RenderText extends HUDKismetSeqAct_RenderObject;
  
  // 가로 정렬 옵션
  enum EHorizontalAlignment
  {
    EHA_Left<DisplayName=Left>,
    EHA_Center<DisplayName=Center>,
    EHA_Right<DisplayName=Right>
  };
  
  // 세로 정렬 옵션
  enum EVerticalAlignment
  {
    EVA_Top<DisplayName=Top>,
    EVA_Middle<DisplayName=Middle>,
    EVA_Bottom<DisplayName=Bottom>
  };
  
  // 실제 위치 좌표 사용에 대한 조건
  var bool UsingActualPosition;
  // 상대 위치 좌표 사용에 대한 조건
  var bool UsingRelativePosition;
  // 현지화되지 않은 (raw 입력) 텍스터 사용에 대한 조건
  var bool UsingNonLocalizedText;
  // 현지화된 텍스트 사용에 대한 조건
  var bool UsingLocalizedText;
  
  // 텍스처를 렌더할 실제 위치
  var(RenderText) IntPoint ActualPosition<EditCondition=UsingActualPosition>;
  // 텍스처를 렌더할 뷰포트 해상도에 상대적인 위치
  var(RenderText) Vector2D RelativePosition<EditCondition=UsingRelativePosition>;
  // 텍스트를 렌더할 색
  var(RenderText) Color RenderColor<DisplayName=Color>;
  // 렌더할 raw 텍스트
  var(RenderText) String Text<EditCondition=UsingNonLocalizedText>;
  // 렌더할 텍스트를 구해올 현지와 경로
  var(RenderText) String LocalizedText<EditCondition=UsingLocalizedText>;
  // 가로 정렬
  var(RenderText) EHorizontalAlignment HorizontalAlignment;
  // 세로 정렬
  var(RenderText) EVerticalAlignment VerticalAlignment;
  // 텍스트를 렌더할 폰트
  var(RenderText) Font Font;
  
  function Render(Canvas Canvas)
  {
    local IntPoint RenderPosition;
    local float TextWidth, TextHeight;
    local String RenderText;
    local SeqVar_String SeqVar_String;
  
    if (Canvas != None && Font != None && (UsingNonLocalizedText || UsingLocalizedText) && (UsingActualPosition || UsingRelativePosition))
    {
      // 렌더 텍스트 구하기
      if (UsingNonLocalizedText)
      {
        // 사용자가 텍스트 변수 링크를 설정했는지 검사
        if (Text ~= "" && VariableLinks[0].LinkedVariables.Length > 0)
        {
          SeqVar_String = SeqVar_String(VariableLinks[0].LinkedVariables[0]);
  
          if (SeqVar_String != None)
          {
            RenderText = SeqVar_String.StrValue;
          }
        }
        else
        {
        RenderText = Text;
        }
      }
      else
      {
        // 사용자가 현지화된 텍스트 변수 링크를 설정했는지 검사
        if (LocalizedText ~= "" && VariableLinks[1].LinkedVariables.Length > 0)
        {
          SeqVar_String = SeqVar_String(VariableLinks[1].LinkedVariables[0]);
  
          if (SeqVar_String != None)
          {
            RenderText = ParseLocalizedPropertyPath(SeqVar_String.StrValue);
          }
        }
        else
        {
          RenderText = ParseLocalizedPropertyPath(LocalizedText);
        }
      }
  
      if (RenderText != "")
      {
        // 위치 계산
        if (UsingRelativePosition)
        {
          RenderPosition.X = Canvas.ClipX * RelativePosition.X;
          RenderPosition.Y = Canvas.ClipY * RelativePosition.Y;
        }
        else
        {
          RenderPosition = ActualPosition;
        }
  
        // 폰트 계산
        Canvas.Font = Font;
        // 텍스트 크기 계산
        Canvas.TextSize(RenderText, TextWidth, TextHeight);
  
        // 가로 정렬 핸들링
        if (HorizontalAlignment == EHA_Center)
        {
          RenderPosition.X -= (TextWidth * 0.5f);
        }
        else if (HorizontalAlignment == EHA_Right)
        {
          RenderPosition.X -= TextWidth;
        }
  
        // 세로 정렬 핸들링
        if (VerticalAlignment == EVA_Middle)
        {
          RenderPosition.Y -= (TextHeight * 0.5f);
        }
        else if (VerticalAlignment == EVA_Bottom)
        {
          RenderPosition.Y -= TextHeight;
        }
  
        // 캔버스 위치 설정
        Canvas.SetPos(RenderPosition.X, RenderPosition.Y);
        // 텍스트 컬러 설정
        Canvas.SetDrawColor(RenderColor.R, RenderColor.G, RenderColor.B, RenderColor.A);
        // 텍스트 렌더
        Canvas.DrawText(RenderText);
      }
    }
  
    Super.Render(Canvas);
  }
  
  defaultproperties
  {
    RenderColor=(R=255,G=255,B=255,A=255)
  
    ObjName="Render Text"
    ObjCategory="ExtHUD"
  
    VariableLinks(0)=(ExpectedType=class'SeqVar_String',LinkDesc="Text",MaxVars=1,PropertyName=Text)
    VariableLinks(1)=(ExpectedType=class'SeqVar_String',LinkDesc="Localized Text",MaxVars=1,PropertyName=LocalizedText)
  }
  

Render Text 시퀸스 액션 추가하기

HUDKismetAddRenderTextAction.jpg

Render Text 프로퍼티

  • Actual Position 실제 위치 - 머티리얼을 렌더할 실제 위치로, 픽셀 단위입니다.
  • Relative Position 상대 위치 - 머티리얼을 렌더할 뷰포트 해상도에 상대적인 위치입니다.
  • Color 컬러 - 텍스트를 렌더할 색입니다.
  • Text 텍스트 - 렌더할 텍스트입니다. 사용자가 Text 키즈멧 변수 노드를 설정했다면 여기다 덮어씁니다.
  • Localized Text 현지화된 텍스트 - 렌더할 현지화 텍스트입니다. 사용자가 Localized Text 키즈멧 변수 노드를 설정했다면 여기다 덮어씁니다.
  • Horizontal Alignment 가로 정렬 - 텍스트를 렌더할 때의 가로 정렬입니다.
  • Vertical Alignment 세로 정렬 - 텍스트를 렌더할 때의 세로 정렬힙니다.
  • Font 폰트 - 텍스트를 렌더할 때의 폰드입니다.

HUDKismetRenderTextProperties.jpg

관련 토픽

사용 예제


이 젬의 맨 위에 있는 스크린샷을 만드는 데 사용한 키즈멧 레이아웃 입니다.

HUDKismetExampleKismet.jpg

관련 토픽


내려받기