UDN

Search public documentation:

DevelopmentKitGemsCanvasKismetNodesJP

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

Unreal Development Kit ホーム > Unreal Development Kit Gems > Canvas Kismet ノードの作成
UE3 ホーム > Kismet ビジュアルスクリプト処理 > Canvas Kismet ノードの作成

Canvas Kismet ノードの作成

2011年4月に UDK について最終テスト実施済み
PC および iOS 対応

Canvas Kismet ノードの作成

概要

開発者ができるだけ素早く作業用プロトタイプを作成しようとする場合、Kismet が素晴らしいツールとなります。本技法では、単純なCanvas 描画機能を Kismet に追加することによって、マテリアルおよびテクスチャ、テキストの描画を容易にします。機能を充実させる必要がある場合は、本技法を拡張させることができます。既存の MobileHUD メソッドに対して本技法を使用することによって生じるメリットとしては、カスタマイズした HUD サブクラスの有無にかかわらず、どのようなゲームタイプにもこのメソッドが利用できるようになるということがあります。

HUDKismetSeqEvent_RenderHUD

Kismet シーケンスイベントノードは、HUD が 1 フレームをレンダリングするたびに呼び出されます。これは好きなだけ多くもつことができますが、各 Render HUD イベントがいつ呼び出されるかという順番を決めるのは難しいです。(1 つのゲーム内では一定ですが、ゲームが変われば一定ではなくなる可能性があります)。

ソースコード

このシーケンスイベントのロジックは以下のとおりです。

シーケンスイベントが登録されると、レンダリングプロキシが見つからない場合、作成されます。
レンダリングプロキシが見つかると、自身をレンダリングプロキシのシーケンス配列に追加します。
フレームをレンダリングするためにレンダリングプロキシが呼び出されると、プロキシは、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;

  // Get the world info
  WorldInfo = class'WorldInfo'.static.GetWorldInfo();

  // Abort if the world info isn't found
  if (WorldInfo == None)
  {
    return;
  }

  // Find a render proxy to associate with this render HUD event
  ForEach WorldInfo.DynamicActors(class'HUDKismetRenderProxy', FoundRenderProxy)
  {
    RenderProxy = FoundRenderProxy;
    break;
  }

  // If a render proxy hasn't been found, then create a render proxy
  if (RenderProxy == None)
  {
    RenderProxy = WorldInfo.Spawn(class'HUDKismetRenderProxy');
  }

  // Add this HUD render sequence to the rendering proxy
  if (RenderProxy != None)
  {
    RenderProxy.AddRenderHUDSequenceEvent(Self);
  }
}

function Render(Canvas Canvas)
{
  local int i, j;
  local HUDKismetSeqAct_RenderObject RenderObject;

  // Render output links
  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 シーケンスイベントを追加する

HUDKismetRenderProxy

レンダリングプロキシは、各 HUD 内にある PostRenderActor 配列にフックされるために作成されるアクタです。

ソースコード

このレンダリングプロキシのロジックは次のとおりです。

ヘルパー関数 (AddRenderHUDSequenceEvent) が、レンダリング HUD シーケンスイベントをその内部配列に追加する。これは、 HUDKismetSeqEvent_RenderHUD によって呼び出されます。
Tick が 1 回使用され、Player Controllerの HUD PostRender アクタのすべてに自身が加えられる。
PostRenderFor が、HUD の PostRender コールの最後に呼び出される。これによって、すべての登録されている Render HUD シーケンスイベントにレンダリングがプロパゲートされる。

HUDKismetRenderProxy.uc

class HUDKismetRenderProxy extends Actor;

// Has the proxy been assigned to player controllers yet?
var bool HasAddedToAllControllers;
// List of HUD render events
var PrivateWrite array<HUDKismetSeqEvent_RenderHUD> RenderHUDSequenceEvents;

function AddRenderHUDSequenceEvent(HUDKismetSeqEvent_RenderHUD RenderHUDSequenceEvent)
{
  local int i;

  // Check if the Render HUD sequence event already exists
  if (RenderHUDSequenceEvents.Length > 0)
  {
    for (i = 0; i < RenderHUDSequenceEvents.Length; ++i)
    {
      if (RenderHUDSequenceEvents[i] == RenderHUDSequenceEvent)
      {
        return;
      }
    }
  }

  // Add the render HUD sequence event into the array
  RenderHUDSequenceEvents.AddItem(RenderHUDSequenceEvent);
}

function Tick(float DeltaTime)
{
  local PlayerController PlayerController;

  if (!HasAddedToAllControllers)
  {
    // Add the render proxy to all of the local player controllers
    ForEach WorldInfo.AllControllers(class'PlayerController', PlayerController)
    {
      if (PlayerController != None && PlayerController.MyHUD != None)
      {
        PlayerController.MyHUD.AddPostRenderedActor(Self);
        HasAddedToAllControllers = true;
      }
    }
  }

  Super.Tick(DeltaTime);
}

simulated event PostRenderFor(PlayerController PC, Canvas Canvas, Vector CameraPosition, Vector CameraDir)
{
  local int i;

  // Abort if the canvas is invalid, or there is no sequence events to render
  if (Canvas == None || RenderHUDSequenceEvents.Length <= 0)
  {
    return;
  }

  // For each HUD render sequence, propagate the render
  for (i = 0; i < RenderHUDSequenceEvents.Length; ++i)
  {
    if (RenderHUDSequenceEvents[i] != None)
    {
      // Pass the player controller for Kismet
      RenderHUDSequenceEvents[i].PlayerController = PC;
      // Pass the camera position for Kismet
      RenderHUDSequenceEvents[i].CameraPosition = CameraPosition;
      // Pass the camera direction for Kismet
      RenderHUDSequenceEvents[i].CameraDirection = CameraDir;
      // Pass the render call
      RenderHUDSequenceEvents[i].Render(Canvas);
    }
  }
}

defaultproperties
{
  bPostRenderIfNotVisible=true
}

HUDKismetSeqAct_RenderObject

これは、抽象的な Kismet シーケンスアクションです。他のすべてのレンダリング Kismet シーケンスアクションによってサブクラス化されます。

ソースコード

この抽象的なシーケンスアクションのロジックは次のとおりです。

Render 関数が呼び出されると、あらゆる関連づけられた子にプロパゲートされます。

HUDKismetSeqAct_RenderObject.uc

class HUDKismetSeqAct_RenderObject extends SequenceAction
  abstract;

function Render(Canvas Canvas)
{
  local int i, j;
  local HUDKismetSeqAct_RenderObject RenderObject;

  // Propagate the rendering call to all other child links
  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

この Kismet シーケンスアクションは、テクスチャを Canvas 上にレンダリングします。

ソースコード

このシーケンスのロジックは次のとおりです。

レンダリング前に、Canvas が有効であるか否かをチェックする。そのためには、実際のサイズか相対的なサイズのどちらかを使用するか、実際の位置か相対的な位置のどちらかを使用する。
ユーザーによって Texture Kismet 変数ノードに接続されている場合、Texture プロパティ値はこれによってオーバーライドされる。
レンダリング位置を計算する。
レンダリングサイズを計算する。
テクスチャのレンダリング範囲を計算する。
ユーザーによって設定された各種プロパティに応じて、拡張、または、回転して、あるいは、通常どおりにテクスチャをレンダリングする。

HUDKismetSeqAct_RenderTexture.uc

class HUDKismetSeqAct_RenderTexture extends HUDKismetSeqAct_RenderObject;

struct TextureRotation
{
  // Amount to rotate the texture in Unreal units (65536 == 360 degrees)
  var() int Rotation;
  // Relative point to perform the rotation (0.5f is at the center)
  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
  }
};

// Condition to using actual size coordinates
var bool UsingActualSize;
// Condition to using relative size coordinates
var bool UsingRelativeSize;
// Condition to using actual position coordinates
var bool UsingActualPosition;
// Condition to using relative position coordinates
var bool UsingRelativePosition;
// Condition to using the stretched method
var bool UsingStretched;

// Texture to render. Overrided if the user sets the texture variable link
var(RenderTexture) Object Texture;
// Actual size to render the texture
var(RenderTexture) IntPoint ActualSize<EditCondition=UsingActualSize>;
// Relative size, to the viewport resolution, to render the texture
var(RenderTexture) Vector2D RelativeSize<EditCondition=UsingRelativeSize>;
// Actual position to render the texture
var(RenderTexture) IntPoint ActualPosition<EditCondition=UsingActualPosition>;
// Relative position, to the viewport resolution, to render the texture
var(RenderTexture) Vector2D RelativePosition<EditCondition=UsingRelativePosition>;
// Rotation of the texture to render
var(RenderTexture) TextureRotation Rotation;
// Coordinates of the texture to render
var(RenderTexture) TextureCoords Coords;
// Color to render the texture
var(RenderTexture) Color RenderColor<DisplayName=Color>;
// Stretched properties when rendering the texture
var(RenderTexture) TextureStretched Stretched<EditCondition=UsingStretched>;

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))
  {
    // Check if the user has set the texture kismet node link
    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)
    {
      // Calculate the position
      if (UsingRelativePosition)
      {
        RenderPosition.X = Canvas.ClipX * RelativePosition.X;
        RenderPosition.Y = Canvas.ClipY * RelativePosition.Y;
      }
      else
      {
        RenderPosition = ActualPosition;
      }

      // Calculate the size
      if (UsingRelativeSize)
      {
        RenderSize.X = Canvas.ClipX * RelativeSize.X;
        RenderSize.Y = Canvas.ClipY * RelativeSize.Y;
      }
      else
      {
        RenderSize = ActualSize;
      }

      // Calculate the texture width
      UL = (Coords.UL == -1) ? RenderTexture.SizeX : int(Coords.UL);
      // Calculate the texture height
      VL = (Coords.VL == -1) ? RenderTexture.SizeY : int(Coords.VL);

      // Set the position to render
      Canvas.SetPos(RenderPosition.X, RenderPosition.Y);
      // Set the draw color
      Canvas.SetDrawColor(RenderColor.R, RenderColor.G, RenderColor.B, RenderColor.A);

      if (UsingStretched)
      {
        // Render the texture stretched
        Canvas.DrawTileStretched(RenderTexture, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL,, Stretched.StretchHorizontally, Stretched.StretchVertically, Stretched.ScalingFactor);
      }
      else
      {
        if (Rotation.Rotation == 0)
        {
          // Render the texture normally
          Canvas.DrawTile(RenderTexture, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL);
       }
        else
        {
          // Render the texture rotated
        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 シーケンスアクションを追加する

Render Texture のプロパティ

Texture (テクスチャ) - レンダリング対象のテクスチャです。Texture Kismet 変数ノードがユーザーによって設定されている場合、このプロパティはオーバーライドされます。
Actual Size (実際のサイズ) - テクスチャをレンダリングするサイズです。単位はピクセルです。
Relative Size (相対的サイズ) - ビューポート解像度を基準にした、テクスチャのレンダリングサイズです。
Actual Position (実際の位置) - テクスチャをレンダリングする位置です。単位はピクセルです。
Relative Position (相対的位置) - ビューポート解像度を基準にした、テクスチャのレンダリング位置です。
Rotation (回転)
- Rotation (回転) - テクスチャを回転させる角度です。単位は、Unreal Unitです。65536 uu (Unreal Unit) = 360 度
- Anchor (アンカー) - テクスチャを回転させる相対的な位置です。0.5f = センター
Coords (座標) - レンダリングするサブテクスチャの座標です。テクスチャ全体をレンダリングするには、デフォルトのままにしておきます。
Color (カラー) - テクスチャをレンダリングするためのカラーです。
Stretched (伸張)
- StretchHorizontal (水平の伸張) - テクスチャが水平に伸張するようにします。
- StretchVertically (垂直の伸張) - テクスチャが垂直に伸張するようにします。
- ScalingFactor (スケーリング係数) - 伸張のスケーリングを変更します。

HUDKismetSeqAct_RenderMaterial

この Kismet シーケンスアクションは、マテリアルを Canvas 上にレンダリングします。

ソースコード

このシーケンスのロジックは次のとおりです。

Render 関数が呼び出されると、Canvas が有効であるか否かをチェックする。そのためには、実際のサイズか相対的なサイズのどちらかを使用するか、実際の位置か相対的な位置のどちらかを使用する。
ユーザーによってマテリアル Kismet 変数ノードが設定されているか否かをチェックする。ユーザーが MaterialInstanceActor を使用している場合は、その中にあるマテリアルインスタンス定数を取得する。そうでない場合は、マテリアルインターフェースセットを取得する。
位置を計算する。
サイズを計算する。
座標を計算する。
マテリアルを通常どおりまたは回転させてレンダリングする。

HUDKismetSeqAct_RenderMaterial.uc

class HUDKismetSeqAct_RenderMaterial extends HUDKismetSeqAct_RenderObject
  DependsOn(HUDKismetSeqAct_RenderTexture);

// Condition to using actual size coordinates
var bool UsingActualSize;
// Condition to using relative size coordinates
var bool UsingRelativeSize;
// Condition to using actual position coordinates
var bool UsingActualPosition;
// Condition to using relative position coordinates
var bool UsingRelativePosition;

// Material to render. Overrided if the user sets the material variable link
var(RenderMaterial) Object Material;
// Actual size to render the material
var(RenderMaterial) IntPoint ActualSize<EditCondition=UsingActualSize>;
// Relative size, to the viewport resolution, to render the material
var(RenderMaterial) Vector2D RelativeSize<EditCondition=UsingRelativeSize>;
// Actual position to render the material
var(RenderMaterial) IntPoint ActualPosition<EditCondition=UsingActualPosition>;
// Relative position, to the viewport resolution, to render the material
var(RenderMaterial) Vector2D RelativePosition<EditCondition=UsingRelativePosition>;
// Rotation of the material to render
var(RenderMaterial) TextureRotation Rotation;
// Coordinates of the material to render
var(RenderMaterial) TextureCoords Coords;

function Render(Canvas Canvas)
{
  local IntPoint RenderPosition;
  local IntPoint RenderSize;
  local MaterialInterface RenderMaterial;
  local int UL;
  local int VL;
  local Rotator R;
  local SeqVar_Object SeqVar_Object;

  if (Canvas != None && (UsingActualSize || UsingRelativeSize) && (UsingActualPosition || UsingRelativePosition))
  {
    // Check if the user has set the material kismet node link
    if (VariableLinks[0].LinkedVariables.Length > 0)
    {
      SeqVar_Object = SeqVar_Object(VariableLinks[0].LinkedVariables[0]);

      if (SeqVar_Object != None)
      {
        if (MaterialInterface(SeqVar_Object.GetObjectValue()) != None)
        {
          RenderMaterial = MaterialInterface(SeqVar_Object.GetObjectValue());
        }
        else if (MaterialInstanceActor(SeqVar_Object.GetObjectValue()) != None)
        {
          RenderMaterial = MaterialInstanceActor(SeqVar_Object.GetObjectValue()).MatInst;
        }
      }
    }
    else
    {
      if (MaterialInterface(Material) != None)
      {
        RenderMaterial = MaterialInterface(Material);
      }
      else if (MaterialInstanceActor(Material) != None)
      {
        RenderMaterial = MaterialInstanceActor(Material).MatInst;
      }
    }

    if (RenderMaterial != None)
    {
      // Calculate the position
      if (UsingRelativePosition)
      {
        RenderPosition.X = Canvas.ClipX * RelativePosition.X;
        RenderPosition.Y = Canvas.ClipY * RelativePosition.Y;
      }
      else
      {
        RenderPosition = ActualPosition;
      }

      // Calculate the size
      if (UsingRelativeSize)
      {
        RenderSize.X = Canvas.ClipX * RelativeSize.X;
        RenderSize.Y = Canvas.ClipY * RelativeSize.Y;
      }
      else
      {
        RenderSize = ActualSize;
      }

      // Calculate the texture width
      UL = (Coords.UL == -1) ? 1.f : Coords.UL;
      // Calculate the texture height
      VL = (Coords.VL == -1) ? 1.f : Coords.VL;

      // Set the position to render
      Canvas.SetPos(RenderPosition.X, RenderPosition.Y);

      if (Rotation.Rotation == 0)
      {
        // Render the material normally
        Canvas.DrawMaterialTile(RenderMaterial, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL);
      }
      else
      {
        // Render the material rotated
        R.Pitch = 0;
        R.Yaw = Rotation.Rotation;
        R.Roll = 0;
        Canvas.DrawRotatedMaterialTile(RenderMaterial, R, RenderSize.X, RenderSize.Y, Coords.U, Coords.V, UL, VL, Rotation.Anchor.X, Rotation.Anchor.Y);
      }
    }
  }

  Super.Render(Canvas);
}

defaultproperties
{
  ObjName="Render Material"
  ObjCategory="ExtHUD"

  VariableLinks(0)=(ExpectedType=class'SeqVar_Object',LinkDesc="Material",PropertyName=Material)
}

Render Material シーケンスアクションを追加する

Render Material のプロパティ

Material (マテリアル) - レンダリング対象のマテリアルです。ユーザーによって Material Kismet ノードが設定されている場合、このマテリアルはオーバーライドされます。
Actual Size (実際のサイズ) - マテリアルをレンダリングするサイズです。単位はピクセルです。
Actual Size (相対的なサイズ) - ビューポートの解像度を基準にした、マテリアルをレンダリングするサイズです。
Actual Position (実際の位置) - マテリアルをレンダリングする位置です。単位はピクセルです。
Relative Position (相対的な位置) - ビューポートの解像度を基準にした、マテリアルをレンダリングする位置です。
Rotation (回転)
- Rotation (回転) - テクスチャを回転させる角度です。単位は、Unreal Unitです。65536 uu (Unreal Unit) = 360 度
- Anchor (アンカー) - テクスチャを回転させる相対的な位置です。 0.5f = センター
Coords (座標) - レンダリングするサブテクスチャの座標です。テクスチャ全体をレンダリングするには、デフォルトのままにしておきます。

HUDKismetSeqAct_RenderText

この Kismet シーケンスアクションは、Canvas 上にテキストをレンダリングします。

ソースコード

このシーケンスのロジックは次のとおりです。

Render 関数が呼び出されると、Canvas が有効であるか否か、フォントが有効であるか否かをチェックする。そのためには、ローカライズされていないテキストかローカライズされたテキストのいずれか、または、実際の位置か相対的な位置のいずれかを使用する。
レンダリングするテキストを取得する。テキスト / ローカライズされたテキスト Kismet 変数ノードがユーザーによって設定されている場合はオーバーライドされる。これらのうちどちらかを使用する場合は、必ず、それぞれのチェックボックスにチェックを入れ、入力フィールドはブランクのままにしておく必要があります。
左上隅の位置合わせに基づき、初期位置を計算する。
フォントを設定し、テキストのサイズを取得する。
水平および垂直の位置合わせプロパティに基づき、位置をオフセットする。
テキストをレンダリングする。

HUDKismetSeqAct_RenderText.uc

class HUDKismetSeqAct_RenderText extends HUDKismetSeqAct_RenderObject;

// Horizontal alignment options
enum EHorizontalAlignment
{
  EHA_Left<DisplayName=Left>,
  EHA_Center<DisplayName=Center>,
  EHA_Right<DisplayName=Right>
};

// Vertical alignment options
enum EVerticalAlignment
{
  EVA_Top<DisplayName=Top>,
  EVA_Middle<DisplayName=Middle>,
  EVA_Bottom<DisplayName=Bottom>
};

// Condition to using actual position coordinates
var bool UsingActualPosition;
// Condition to using relative position coordinates
var bool UsingRelativePosition;
// Condition to using non localized text (raw input)
var bool UsingNonLocalizedText;
// Condition to using localized text
var bool UsingLocalizedText;

// Actual position to render the texture
var(RenderText) IntPoint ActualPosition<EditCondition=UsingActualPosition>;
// Relative position, to the viewport resolution, to render the texture
var(RenderText) Vector2D RelativePosition<EditCondition=UsingRelativePosition>;
// Color to render the text
var(RenderText) Color RenderColor<DisplayName=Color>;
// Raw text to render
var(RenderText) String Text<EditCondition=UsingNonLocalizedText>;
// Localization path to get the text from to render
var(RenderText) String LocalizedText<EditCondition=UsingLocalizedText>;
// Horizontal alignment
var(RenderText) EHorizontalAlignment HorizontalAlignment;
// Vertical alignment
var(RenderText) EVerticalAlignment VerticalAlignment;
// Font to render the text
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))
  {
    // Get the render text
    if (UsingNonLocalizedText)
    {
      // Check if the user has set the text variable link
      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
    {
      // Check if the user has set the localized text variable link
      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 != "")
    {
      // Calculate the position
      if (UsingRelativePosition)
      {
        RenderPosition.X = Canvas.ClipX * RelativePosition.X;
        RenderPosition.Y = Canvas.ClipY * RelativePosition.Y;
      }
      else
      {
        RenderPosition = ActualPosition;
      }

      // Set the font
      Canvas.Font = Font;
      // Calculate the size of the text
      Canvas.TextSize(RenderText, TextWidth, TextHeight);

      // Handle the horizontal alignment
      if (HorizontalAlignment == EHA_Center)
      {
        RenderPosition.X -= (TextWidth * 0.5f);
      }
      else if (HorizontalAlignment == EHA_Right)
      {
        RenderPosition.X -= TextWidth;
      }

      // Handle the vertical alignment
      if (VerticalAlignment == EVA_Middle)
      {
        RenderPosition.Y -= (TextHeight * 0.5f);
      }
      else if (VerticalAlignment == EVA_Bottom)
      {
        RenderPosition.Y -= TextHeight;
      }

      // Set the canvas position
      Canvas.SetPos(RenderPosition.X, RenderPosition.Y);
      // Set the text color
      Canvas.SetDrawColor(RenderColor.R, RenderColor.G, RenderColor.B, RenderColor.A);
      // Render the text
      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 シーケンスアクションを追加する

Render Text のプロパティ

Actual Position (実際の位置) - マテリアルをレンダリングする位置です。単位はピクセルです。
Relative Position (相対的な位置) - ビューポートの解像度を基準にした、マテリアルをレンダリングする位置です。
Color (カラー) - テキストをレンダリングするためのカラーです。
Text (テキスト) - レンダリング対象のテキストです。Text Kismet 変数ノードがユーザーによって設定されている場合は、オーバーライドされます。
Localized Text (ローカライズされたテキスト) - レンダリング対象のローカライズされたテキストです。 Localized Text Kismet 変数ノードがユーザーによって設定されている場合は、オーバーライドされます。
Horizontal Alignment (水平の位置合わせ) - テキストをレンダリングするための水平の位置合わせです。
Vertical Alignment (垂直の位置合わせ) - テキストをレンダリングするための垂直の位置合わせです。
Font (フォント) - テキストをレンダリングするためのフォントです。

使用例

次の Kismet のレイアウトは、このページ冒頭のスクリーンショットを作成するために使用されたものです。

ダウンロード

ここから、コンテンツ / ソースコードをダウンロードすることができます。 (CanvasKismetNodes.zip)

Canvas Kismet ノードの作成

概要

HUDKismetSeqEvent_RenderHUD

ソースコード

Render HUD シーケンスイベントを追加する

HUDKismetRenderProxy

ソースコード

HUDKismetSeqAct_RenderObject

ソースコード

HUDKismetSeqAct_RenderTexture

ソースコード

Render Texture シーケンスアクションを追加する

Render Texture のプロパティ

関連テーマ

HUDKismetSeqAct_RenderMaterial

ソースコード

Render Material シーケンスアクションを追加する

Render Material のプロパティ

関連テーマ

HUDKismetSeqAct_RenderText

ソースコード

Render Text シーケンスアクションを追加する

Render Text のプロパティ

関連テーマ

使用例

関連テーマ

ダウンロード