开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
C2Materials.pas
资源名称：CAST2SDK.rar　[点击查看]
上传用户：yj_qiu
上传日期：2022-08-08
资源大小：23636k
文件大小：52k
源码类别：

游戏引擎

开发平台：

Delphi

C2Materials.pas：源码内容
  1. (*
  2.  @Abstract(CAST II Engine materials unit)
  3.  (C) 2006 George "Mirage" Bakhtadze. <a href="http://www.casteng.com">www.casteng.com</a> <br>
  4.  The source code may be used under either MPL 1.1 or LGPL 2.1 license. See included license.txt file <br>
  5.  Unit contains material base class
  6. *)
  7. {$Include GDefines.inc}
  8. {$Include C2Defines.inc}
  9. unit C2Materials;
  11. interface
  13. uses
  14.   TextFile,
  15.   BaseTypes, Basics, BaseMsg, Props, OTypes, BaseClasses, Resources, ItemMsg,
  16.   C2Types, CAST2, C2Res, C2Msg;
  18. const
  19.   // Color mask
  20.   cmAlpha = 1; cmRed = 2; cmGreen = 4; cmBlue = 8;
  22.     // Texture index special values
  23.   // Texture unresolved yet or its resolution failed
  24.   tivUnresolved   = -1;
  25.   // No texture specified for the given stage
  26.   tivNull         = -2;
  27.   // Texture is a render target
  28.   tivRenderTarget = -16;
  29.     // Shader index special values
  30.   // Shader unresolved yet or its resolution failed
  31.   sivUnresolved   = -1;
  32.   // No Shader specified for the given render pass
  33.   sivNull         = -2;
  34.   // Texture matrix type enumeration string
  35.   TextureMatrixTypesEnum = 'None' + StringDelimiter +
  36.                            'Camera inverse' + StringDelimiter + 'Mirror' + StringDelimiter + 'Shadow map' + StringDelimiter +
  37.                            'Scale' + StringDelimiter +
  38.                            'Custom';
  39.   // Pass running conditions enumeration string
  40.   TPassConditionsEnum = 'Once' + StringDelimiter + 'For each light';
  42. type
  43.   // Pass running conditions enumeration
  44.   TPassCondition = (// Run the pass once for an item
  45.                     pcOnce,
  46.                     // Run the pass for each light affecting the currently rendering item   
  47.                     pcEachLight);
  49.   TBlendingState = record
  50.     Enabled: Boolean;
  51.     CRC, AlphaRef, ATestFunc, SrcBlend, DestBlend, Operation: Integer;
  52.   end;
  54.   TZBufferState = record
  55.     CRC, ZTestFunc, ZBias: Integer;
  56.     ZWrite: Boolean;
  57.   end;
  59.   TFillShadeMode = record
  60.     CRC, FillMode, ShadeMode, CullMode: Integer;
  61.     ColorMask: Cardinal;
  62.   end;
  64.   TStencilState = record
  65.     CRC, SFailOp, ZFailOp, PassOp, STestFunc: Integer;
  66.   end;
  68.   TTWrapCoordSet = array[0..MaxTextureCoordSets-1] of Cardinal;
  69.   TTextureWrap = record
  70.     CRC: Cardinal;
  71.     CoordSet: TTWrapCoordSet;
  72.   end;
  74.   TLightingState = record
  75.     CRC: Integer;
  76.     GlobalAmbient: BaseTypes.TColor;
  77.     SpecularMode: SmallInt;
  78.     NormalizeNormals, Enabled: Boolean;
  79.   end;
  81.   TPointEdgeState = record
  82.     CRC: Integer;
  83.     PointSprite, PointScale, EdgeAntialias: Boolean;
  84.   end;
  86.   // Texture matrix setting
  87.   TTextureMatrixType = (// No texture matrix
  88.                         tmNone,
  89.                         // Inverse camera view matrix
  90.                         tmCameraInverse,
  91.                         { Predefined texture matrix for a mirror implementation
  92.                         }
  93.                         tmMirror,
  94.                         { Predefined texture matrix for shadow maps implementation
  95.                         }
  96.                         tmShadowMap,
  97.                         // Scale matrix by <b>TextureMatrixBias</b>
  98.                         tmScale,
  99.                         // Texture matrix for the given coordinate set will be retrieved from the item currently drawn with the @Link(RetrieveTextureMatrix) delegate
  100.                         tmCustom);
  102.   TStage = record
  103.     TextureIndex: Integer;                          // can be tivUnresolved, tivNull, tivRenderTarget
  104.     ColorArg0, AlphaArg0: Longword;
  105.     ColorOp, ColorArg1, ColorArg2: Longword; InvertColorArg1, InvertColorArg2: Boolean;
  106.     AlphaOp, AlphaArg1, AlphaArg2: Longword; InvertAlphaArg1, InvertAlphaArg2: Boolean;
  107.     TAddressing: Longword; StoreToTemp: Boolean;
  108.     MipLODBias: Single;
  109.     MaxMipLevel, MaxAnisotropy, Filtering: Longword;
  110.     UVSource, TTransform: Longword;                 // Texture coordinates source, transform and wrapping
  111.     TextureBorder: BaseTypes.TColor;
  112.     TextureMatrixType: TTextureMatrixType;
  113.     TextureMatrixBias: Single;
  114.     Camera: TCamera;
  115.   end;
  117.   TRenderPass = class(TItem)
  118.   public
  119.     // SortBias is added to any sorted item's SortValue 
  120.     SortBias: Single;
  121.     Group: TPassGroup;
  122.     BlendingState: TBlendingState;
  123.     FillShadeMode: TFillShadeMode;
  124.     ZBufferState : TZBufferState;
  125.     StencilState : TStencilState;
  126.     StencilRef, StencilMask, StencilWriteMask: Integer;
  128.     TextureFactor: BaseTypes.TColor;    
  129.     TextureWrap  : TTextureWrap;
  131.     Ambient, Diffuse, Specular, Emissive: BaseTypes.TColor4S;
  132.     Power: Single;
  133.     LightingState: TLightingState;
  134.     Stages: array of TStage;
  136.     FogKind: Integer;
  137.     FogStart, FogEnd, FogDensity: Single;
  138.     FogColor: BaseTypes.TColor;
  139.     PointSize, MinPointSize, MaxPointSize: Single;
  140.     PointScaleA, PointScaleB, PointScaleC: Single;
  141.     PointEdgeState: TPointEdgeState;
  142.     LinePattern: Longword;
  144.     VertexShaderIndex, PixelShaderIndex: Integer;   /// can be sivUnresolved, sivNull
  145.     VertexDeclaration: TVertexDeclaration;
  147.     ApplyCondition: TPassCondition;
  149.     Items: TItems; TotalItems: Integer;                               // Items using this pass
  150.     constructor Create(AManager: TItemsManager); override;
  151.     destructor Destroy; override;
  153.     procedure AddProperties(const Result: Props.TProperties); override;
  154.     procedure SetProperties(Properties: Props.TProperties); override;
  156.     /// For internal use only.
  157.     function AddItem(const Item: TItem): Integer;
  158.     /// For internal use only.
  159.     function RemoveItem(const Index: Integer): Boolean;
  161.     /// Called from TRenderer.ResolveTexture. For internal use only.
  162.     function ResolveTexture(const Index: Integer; out Texture: Resources.TImageResource): Boolean;
  163.     function ResolveVertexShader(var Shader: C2Res.TShaderResource): Boolean;
  164.     function ResolvePixelShader(var Shader: C2Res.TShaderResource): Boolean;
  165.   private
  166.       ResolvedTexture: Resources.TImageResource;  // Obsolete?
  167.     ResolvedVertexShader, ResolvedPixelShader: C2Res.TShaderResource;
  168.     FOrder: Integer;
  169.     FTotalVertexStreams, FStream0Elements: Integer;
  170.     FVertexShaderConstants, FPixelShaderConstants: TAnsiStringArray;
  171.     FCompiledVertexShaderConstants, FCompiledPixelShaderConstants: array of OTypes.TRTData;
  172.     function GetTotalStages: Integer;
  173.     procedure SetTotalStages(const Value: Integer);
  174.     function GetItemIndex(const Item: TItem): Integer;
  175.     procedure SetOrder(const Value: Integer);
  176.     function GetTotalPixelShaderConstants: Integer;
  177.     function GetTotalVertexShaderConstants: Integer;
  178.     procedure SetTotalPixelShaderConstants(const Value: Integer);
  179.     procedure SetTotalVertexShaderConstants(const Value: Integer);
  180.     function GetPixelShaderConstant(Index: Integer): string;
  181.     function GetVertexShaderConstant(Index: Integer): string;
  182.     procedure SetPixelShaderConstant(Index: Integer; const Value: string);
  183.     procedure SetVertexShaderConstant(Index: Integer; const Value: string);
  184.     function GetCompiledPixelShaderConstants(Index: Integer): OTypes.TRTData;
  185.     function GetCompiledVertexShaderConstants(Index: Integer): OTypes.TRTData;
  186.   public
  187.     procedure HandleMessage(const Msg: TMessage); override;
  189.     procedure RequestValidation;
  191.     property TotalStages: Integer read GetTotalStages write SetTotalStages;
  192.     property Order: Integer read FOrder write SetOrder;
  194.     property TotalVertexShaderConstants: Integer read GetTotalVertexShaderConstants write SetTotalVertexShaderConstants;
  195.     property TotalPixelShaderConstants: Integer read GetTotalPixelShaderConstants write SetTotalPixelShaderConstants;
  196.     property VertexShaderConstant[Index: Integer]: string read GetVertexShaderConstant write SetVertexShaderConstant;
  197.     property PixelShaderConstant[Index: Integer]: string read GetPixelShaderConstant write SetPixelShaderConstant;
  198.     property CompiledVertexShaderConstants[Index: Integer]: OTypes.TRTData read GetCompiledVertexShaderConstants;
  199.     property CompiledPixelShaderConstants[Index: Integer]:  OTypes.TRTData read GetCompiledPixelShaderConstants;
  200.   end;
  202.   TTechnique = class(TItem)
  203.   private
  204.     FTotalPasses: Integer;
  205.     PassesCache: array of TRenderPass;
  206.     FValid: Boolean;
  207.     procedure SetTotalPasses(const Value: Integer);
  208.     function GetPass(Index: Integer): TRenderPass;
  209.     procedure SetPass(Index: Integer; const Value: TRenderPass);
  210.   protected
  211.     procedure SetState(const Value: TItemFlags); override;
  212.   public
  213.     LOD: Integer;
  214.     constructor Create(AManager: TItemsManager); override;
  215.     procedure AddProperties(const Result: Props.TProperties); override;
  216.     procedure SetProperties(Properties: Props.TProperties); override;
  218.     property TotalPasses: Integer read FTotalPasses write SetTotalPasses;
  219.     property Passes[Index: Integer]: TRenderPass read GetPass write SetPass; default;
  220.     property Valid: Boolean read FValid write FValid;
  221.   end;
  223.   TMaterial = class(TItem)
  224.     procedure AddProperties(const Result: Props.TProperties); override;
  225.     procedure SetProperties(Properties: Props.TProperties); override;
  226.     function GetTechniqueByLOD(Lod: Single): TTechnique;
  227.   private
  228.     FTotalTechniques: Integer;
  229.     function GetTechnique(Index: Integer): TTechnique;
  230.     procedure SetTechnique(Index: Integer; const Value: TTechnique);
  231.     procedure SetTotalTechniques(const Value: Integer);
  232.     function PassBelongs(AItem: TItem): Boolean;
  233.   public
  234.     procedure OnSceneLoaded; override;
  235.     procedure HandleMessage(const Msg: TMessage); override;
  237.     property TotalTechniques: Integer read FTotalTechniques write SetTotalTechniques;
  238.     property Technique[Index: Integer]: TTechnique read GetTechnique write SetTechnique; default;
  239.   end;
  241.   function GetPointEdgeState(PointSprite, PointScale, EdgeAntialias: Boolean): TPointEdgeState;
  242.   function GetBlendingState(Enabled: Boolean; SrcBlend, DestBlend, AlphaRef, ATestFunc, Operation: Integer): TBlendingState;
  243.   function GetZBufferState(ZWrite: Boolean; ZTestFunc, ZBias: Integer): TZBufferState;
  244.   function GetFillShadeMode(FillMode, ShadeMode, CullMode: Integer; ColorMask: Cardinal): TFillShadeMode;
  245.   function GetStencilstate(SFailOp, ZFailOp, PassOp, STestFunc: Integer): TStencilState;
  246.   function GetTextureWrap(Set0, Set1, Set2, Set3, Set4, Set5, Set6, Set7: Cardinal): TTextureWrap;
  247.   function GetLightingState(SpecularMode: Integer; NormalizeNormals, Enabled: Boolean; GlobalAmbient: BaseTypes.TColor): TLightingState;
  249. implementation
  251. uses SysUtils;
  253. function GetPointEdgeState(PointSprite, PointScale, EdgeAntialias: Boolean): TPointEdgeState;
  254. begin
  255.   Result.PointSprite   := PointSprite;
  256.   Result.PointScale    := PointScale;
  257.   Result.EdgeAntialias := EdgeAntialias;
  258.   Result.CRC           := Ord(EdgeAntialias) shl 2 + Ord(PointScale) shl 1 + Ord(PointSprite);
  259. end;
  261. function GetBlendingState(Enabled: Boolean; SrcBlend, DestBlend, AlphaRef, ATestFunc, Operation: Integer): TBlendingState;
  262. begin
  263.   Result.Enabled   := Enabled;
  264.   Result.SrcBlend  := SrcBlend;
  265.   Result.DestBlend := DestBlend;
  266.   Result.AlphaRef  := AlphaRef;
  267.   Result.ATestFunc := ATestFunc;
  268.   Result.Operation := Operation;
  269.   Result.CRC       := AlphaRef shl 24 + Ord(Enabled) shl 23 + Operation shl 18 + ATestFunc shl 12 + SrcBlend shl 6 + DestBlend;
  270. end;
  272. function GetZBufferState(ZWrite: Boolean; ZTestFunc, ZBias: Integer): TZBufferState;
  273. begin
  274.   Result.ZWrite    := ZWrite;
  275.   Result.ZTestFunc := ZTestFunc;
  276.   Result.ZBias     := ZBias;
  277.   Result.CRC       := Ord(ZWrite) shl 15 + ZTestFunc shl 8 + ZBias;
  278. end;
  280. function GetFillShadeMode(FillMode, ShadeMode, CullMode: Integer; ColorMask: Cardinal): TFillShadeMode;
  281. begin
  282.   Result.FillMode  := FillMode;
  283.   Result.ShadeMode := ShadeMode;
  284.   Result.CullMode  := CullMode;
  285.   Result.ColorMask := ColorMask;
  286.   Result.CRC       := Integer(ColorMask shl 16) + CullMode shl 12 + ShadeMode shl 4 + FillMode;
  287. end;
  289. function GetStencilstate(SFailOp, ZFailOp, PassOp, STestFunc: Integer): TStencilState;
  290. begin
  291.   Result.SFailOp   := SFailOp;
  292.   Result.ZFailOp   := ZFailOp;
  293.   Result.PassOp    := PassOp;
  294.   Result.STestFunc := STestFunc;
  295.   Result.CRC       := STestFunc shl 24 + PassOp shl 16 + ZFailOp shl 8 + SFailOp;
  296. end;
  298. function GetTextureWrap(Set0, Set1, Set2, Set3, Set4, Set5, Set6, Set7: Cardinal): TTextureWrap;
  299. begin
  300.   Result.CoordSet[0] := Set0;
  301.   Result.CoordSet[1] := Set1;
  302.   Result.CoordSet[2] := Set2;
  303.   Result.CoordSet[3] := Set3;
  304.   Result.CoordSet[4] := Set4;
  305.   Result.CoordSet[5] := Set5;
  306.   Result.CoordSet[6] := Set6;
  307.   Result.CoordSet[7] := Set7;
  308.   Result.CRC  := Set7 shl 28 + Set6 shl 24 + Set5 shl 20 + Set4 shl 16 + Set3 shl 12 + Set2 shl 8 + Set1 shl 4 + Set0;
  309. end;
  311. function GetLightingState(SpecularMode: Integer; NormalizeNormals, Enabled: Boolean; GlobalAmbient: BaseTypes.TColor): TLightingState;
  312. begin
  313.   Result.SpecularMode     := SpecularMode;
  314.   Result.NormalizeNormals := NormalizeNormals;
  315.   Result.Enabled          := Enabled;
  316.   Result.GlobalAmbient    := GlobalAmbient;
  317.   Result.CRC              := Ord(SpecularMode) shl 2 + Ord(NormalizeNormals) shl 1 + Ord(Enabled);
  318. end;
  320. { TRenderPass }
  322. constructor TRenderPass.Create(AManager: TItemsManager);
  323. begin
  324.   inherited;
  325.   FOrder           := poNormal;
  326.   SortBias         := 0;
  327.   BlendingState    := GetBlendingState(False, bmONE, bmZERO, 0, tfALWAYS, boADD);
  328.   FillShadeMode    := GetFillShadeMode(fmDEFAULT, smGOURAUD, cmCAMERADEFAULT, $FFFFFFFF);
  329.   ZBufferState     := GetZBufferState(True, tfLESSEQUAL, 0);
  330.   StencilState     := GetStencilstate(soKEEP, soKEEP, soKEEP, tfALWAYS);
  331.   StencilRef       := 0;
  332.   StencilMask      := -1;
  333.   StencilWriteMask := -1;
  335.   TextureFactor.C   := $00000000;
  336.   TextureWrap       := GetTextureWrap(0, 0, 0, 0, 0, 0, 0, 0);
  338.   Ambient          := GetColor4S(0.5, 0.5, 0.5, 0.5);
  339.   Diffuse          := GetColor4S(0.5, 0.5, 0.5, 0.5);
  340.   Specular         := GetColor4S(0.0, 0.0, 0.0, 0.0);
  341.   Power            := 0;
  342.   LightingState    := GetLightingState(slACCURATE, False, True, GetColor($40404040));
  344.   Group           := 0;
  345.   FogKind         := fkVertex;
  346.   FogStart        := 0;
  347.   FogEnd          := 10000;
  348.   FogDensity      := 1;
  349.   FogColor.C      := $808080FF;
  350.   PointSize       := 1;
  351.   LinePattern     := 0;
  352.   MinPointSize    := 0;
  353.   MaxPointSize    := 10000;
  354.   PointScaleA     := 1;
  355.   PointScaleB     := 0;
  356.   PointScaleC     := 0;
  357.   PointEdgeState  := GetPointEdgeState(False, False, False);
  359.   VertexShaderIndex := sivNull;
  360.   PixelShaderIndex  := sivNull;
  362.   FTotalVertexStreams := 1;
  363.   FStream0Elements    := 0;
  365.   TotalStages := 1;
  366. end;
  368. destructor TRenderPass.Destroy;
  369. var i: Integer;
  370. begin
  371.   VertexDeclaration := nil;
  372.   Items             := nil;
  374.   for i := 0 to High(FVertexShaderConstants) do FVertexShaderConstants[i] := '';
  375.   FVertexShaderConstants := nil;
  376.   for i := 0 to High(FPixelShaderConstants) do  FPixelShaderConstants[i]  := '';
  377.   FPixelShaderConstants := nil;
  378.   for i := 0 to High(FCompiledVertexShaderConstants) do FreeAndNil(FCompiledVertexShaderConstants[i]);
  379.   FCompiledVertexShaderConstants := nil;
  380.   for i := 0 to High(FCompiledPixelShaderConstants) do FreeAndNil(FCompiledPixelShaderConstants[i]);
  381.   FCompiledPixelShaderConstants := nil;
  383.   inherited;
  384. end;
  386. procedure TRenderPass.AddProperties(const Result: Props.TProperties);
  387. var j, k: Integer; LevelStr: string[50];
  388. begin
  389.   inherited;
  390.   if Assigned(Result) then begin
  391.     Result.AddEnumerated('Group', [], Group, PassGroupsEnum);
  393.     Result.AddEnumerated('RenderOrder',             [], Order, PassOrdersEnum);
  394.     Result.Add('RenderSort bias',        vtSingle,  [], FloatToStr(SortBias), '');
  395.     Result.AddEnumerated('RenderFace culling',      [], FillShadeMode.CullMode,  CullModesEnum);
  396.     Result.Add('RenderColor write mask', vtColor,   [], '#' + IntToHex(FillShadeMode.ColorMask, 8), '');
  398.     Result.Add('Blend',                    vtBoolean, [], OnOffStr[BlendingState.Enabled], '');
  399.     Result.AddEnumerated('BlendOperation',           [], BlendingState.Operation, BlendOpsEnum);
  400.     Result.AddEnumerated('BlendSource',              [], BlendingState.SrcBlend,  BlendArgumentsEnum);
  401.     Result.AddEnumerated('BlendDestination',         [], BlendingState.DestBlend, BlendArgumentsEnum);
  402.     Result.AddEnumerated('BlendAlpha test function', [], BlendingState.ATestFunc, TestFuncsEnum);
  403.     Result.Add('BlendAlpha reference',     vtInt,    [], IntToStr(BlendingState.AlphaRef), '0-255');
  405.     Result.AddEnumerated('RenderFill mode',         [], FillShadeMode.FillMode,  FillModesEnum);
  406.     Result.AddEnumerated('RenderShade mode',        [], FillShadeMode.ShadeMode, ShadeModesEnum);
  408.     Result.AddEnumerated('Z bufferTest function',  [], ZBufferState.ZTestFunc, TestFuncsEnum);
  409.     Result.Add('Z bufferBias',          vtInt,     [], IntToStr(ZBufferState.ZBias),  '');
  410.     Result.Add('Z bufferWrite',         vtBoolean, [], OnOffStr[ZBufferState.ZWrite], '');
  412.     Result.AddEnumerated('StencilOn stencil fail', [], StencilState.SFailOp,   StencilOpsEnum);
  413.     Result.AddEnumerated('StencilOn Z fail',       [], StencilState.ZFailOp,   StencilOpsEnum);
  414.     Result.AddEnumerated('StencilOn pass',         [], StencilState.PassOp,    StencilOpsEnum);
  415.     Result.AddEnumerated('StencilTest function',   [], StencilState.STestFunc, TestFuncsEnum);
  417.     Result.Add('StencilReference',  vtInt, [], IntToStr(StencilRef),       '0-255');
  418.     Result.Add('StencilMask',       vtInt, [], IntToStr(StencilMask),      '');
  419.     Result.Add('StencilWrite mask', vtInt, [], IntToStr(StencilWriteMask), '');
  421.     AddColor4sProperty(Result, 'TextureFactor', ColorTo4S(TextureFactor));
  423.     for j := 0 to MaxTextureCoordSets-1 do begin
  424.       LevelStr := 'TextureCoord set ' + IntToStr(j) + '';
  425.       Result.Add(LevelStr + 'Wrap U',  vtBoolean, [], OnOffStr[TextureWrap.CoordSet[j] and twUCoord > 0],   '');
  426.       Result.Add(LevelStr + 'Wrap V',  vtBoolean, [], OnOffStr[TextureWrap.CoordSet[j] and twVCoord > 0],   '');
  427.       Result.Add(LevelStr + 'Wrap W',  vtBoolean, [], OnOffStr[TextureWrap.CoordSet[j] and twWCoord > 0],   '');
  428.       Result.Add(LevelStr + 'Wrap W2', vtBoolean, [], OnOffStr[TextureWrap.CoordSet[j] and twW2Coord > 0],  '');
  429.     end;
  431.     Result.Add('Lighting', vtBoolean, [], OnOffStr[LightingState.Enabled], '');
  433.     AddColor4sProperty(Result, 'LightingAmbient',  Ambient);
  434.     AddColor4sProperty(Result, 'LightingDiffuse',  Diffuse);
  435.     AddColor4sProperty(Result, 'LightingSpecular', Specular);
  436.     AddColor4sProperty(Result, 'LightingEmissive', Emissive);
  438.     Result.Add('LightingSpecularPower', vtSingle, [], FloatToStr(Power), '0-100');
  439.     Result.AddEnumerated('LightingSpecularMode',         [], LightingState.SpecularMode, SpecularEnum);
  440.     Result.Add('LightingNormalize normals',    vtBoolean, [], OnOffStr[LightingState.NormalizeNormals], '');
  442.     AddColor4sProperty(Result, 'Global ambient', ColorTo4S(LightingState.GlobalAmbient));
  444.     AddColor4sProperty(Result, 'FogColor', ColorTo4S(FogColor));
  446.     Result.AddEnumerated('FogType', [], FogKind, FogKindsEnum);
  447.     Result.Add('FogStart',   vtSingle,  [], FloatToStr(FogStart),   '0.1-100');
  448.     Result.Add('FogEnd',     vtSingle,  [], FloatToStr(FogEnd),     '50-1000');
  449.     Result.Add('FogDensity', vtSingle,  [], FloatToStr(FogDensity), '1-10');
  451.     Result.Add('PointSprites', vtBoolean, [], OnOffStr[PointEdgeState.PointSprite], '');
  452.     Result.Add('PointScaling', vtBoolean, [], OnOffStr[PointEdgeState.PointScale], '');
  454.     Result.Add('PointSize',     vtSingle, [], FloatToStr(PointSize),    '0.01-10');
  455.     Result.Add('PointSize min', vtSingle, [], FloatToStr(MinPointSize), '0.01-10');
  456.     Result.Add('PointSize max', vtSingle, [], FloatToStr(MaxPointSize), '0.01-10');
  458.     Result.Add('PointScale A', vtSingle, [], FloatToStr(PointScaleA), '0.01-10');
  459.     Result.Add('PointScale B', vtSingle, [], FloatToStr(PointScaleB), '0.01-10');
  460.     Result.Add('PointScale C', vtSingle, [], FloatToStr(PointScaleC), '0.01-10');
  462.     Result.Add('Line pattern', vtNat, [], IntToStr(LinePattern), '');
  464.     Result.Add('Edge antialiasing', vtBoolean, [], OnOffStr[PointEdgeState.EdgeAntialias], '');
  466.     Result.Add('Total stages', vtNat, [], IntToStr(TotalStages), '');
  468.     Result.Add('ShadersVertexDeclarationTotal streams', vtInt, [], IntToStr(FTotalVertexStreams), '');
  469.     for j := 0 to FTotalVertexStreams-1 do begin
  470.       LevelStr := 'ShadersVertexDeclarationStream #' + IntToStr(j) + '';
  471.       Result.Add(LevelStr + 'Total elements', vtInt, [], IntToStr(FStream0Elements), '');
  472.       for k := 0 to FStream0Elements-1 do Result.AddEnumerated(LevelStr + '#' + IntToStr(k) + 'Data type', [], Ord(VertexDeclaration[k]), VertexDataTypesEnum);
  473.     end;
  475.     Result.Add('ShadersVertexTotal constants', vtInt, [], IntToStr(TotalVertexShaderConstants), '');
  476.     Result.Add('ShadersPixelTotal constants',  vtInt, [], IntToStr(TotalPixelShaderConstants), '');
  478.     for j := 0 to TotalVertexShaderConstants-1 do
  479.       Result.Add('ShadersVertexConstants#' + IntToStr(j), vtString, [], FVertexShaderConstants[j], '');
  481.     for j := 0 to TotalPixelShaderConstants-1 do
  482.       Result.Add('ShadersPixelConstants#' + IntToStr(j), vtString, [], FPixelShaderConstants[j], '');
  483.   end;
  485.   AddItemLink(Result, 'ShadersVertex', [], 'TShaderResource');
  486.   AddItemLink(Result, 'ShadersPixel',  [], 'TShaderResource');
  488.   for j := 0 to TotalStages-1 do begin
  489.     LevelStr := 'Stage #' + IntToStr(j) + '';
  491.     AddItemLink(Result, LevelStr + 'Texture', [], 'TItem');
  493.     if Assigned(Result) then begin
  494.       Result.AddEnumerated(LevelStr + 'ColorOperation',  [], Stages[j].ColorOp,   ColorOpsEnum);
  495.       Result.AddEnumerated(LevelStr + 'ColorArgument 0', [], Stages[j].ColorArg0, ColorArgsEnum);
  496.       Result.AddEnumerated(LevelStr + 'ColorArgument 1', [], Stages[j].ColorArg1, ColorArgsEnum);
  497.       Result.AddEnumerated(LevelStr + 'ColorArgument 2', [], Stages[j].ColorArg2, ColorArgsEnum);
  498.       Result.Add(LevelStr + 'ColorInvert Arg1', vtBoolean, [], OnOffStr[Stages[j].InvertColorArg1], '');
  499.       Result.Add(LevelStr + 'ColorInvert Arg2', vtBoolean, [], OnOffStr[Stages[j].InvertColorArg2], '');
  500.       Result.AddEnumerated(LevelStr + 'AlphaOperation',  [], Stages[j].AlphaOp,   AlphaOpsEnum);
  501.       Result.AddEnumerated(LevelStr + 'AlphaArgument 0', [], Stages[j].AlphaArg0, AlphaArgsEnum);
  502.       Result.AddEnumerated(LevelStr + 'AlphaArgument 1', [], Stages[j].AlphaArg1, AlphaArgsEnum);
  503.       Result.AddEnumerated(LevelStr + 'AlphaArgument 2', [], Stages[j].AlphaArg2, AlphaArgsEnum);
  504.       Result.Add(LevelStr + 'AlphaInvert Arg1', vtBoolean, [], OnOffStr[Stages[j].InvertColorArg1], '');
  505.       Result.Add(LevelStr + 'AlphaInvert Arg2', vtBoolean, [], OnOffStr[Stages[j].InvertColorArg2], '');
  507.       Result.AddEnumerated(LevelStr + 'AdressingU', [],  Stages[j].TAddressing and $00F,        TexAdrsEnum);
  508.       Result.AddEnumerated(LevelStr + 'AdressingV', [], (Stages[j].TAddressing and $0F0) shr 4, TexAdrsEnum);
  509.       Result.AddEnumerated(LevelStr + 'AdressingW', [], (Stages[j].TAddressing and $F00) shr 8, TexAdrsEnum);
  511.       Result.Add(LevelStr + 'Store in Temp register', vtBoolean, [], OnOffStr[Stages[j].StoreToTemp], '');
  513.       Result.AddEnumerated(LevelStr + 'FilteringMin', [],  Stages[j].Filtering and $00F,        TexFiltersEnum);
  514.       Result.AddEnumerated(LevelStr + 'FilteringMax', [], (Stages[j].Filtering and $0F0) shr 4, TexFiltersEnum);
  515.       Result.AddEnumerated(LevelStr + 'FilteringMip', [], (Stages[j].Filtering and $F00) shr 8, TexFiltersEnum);
  516.       Result.Add(LevelStr + 'FilteringMip LOD bias',   vtSingle, [], FloatToStr(Stages[j].MipLODBias),  '');
  517.       Result.Add(LevelStr + 'FilteringMax mip level',  vtInt,    [], IntToStr(Stages[j].MaxMipLevel),   '');
  518.       Result.Add(LevelStr + 'FilteringMax anisotropy', vtInt,    [], IntToStr(Stages[j].MaxAnisotropy), '');
  520.       AddColor4sProperty(Result, LevelStr + 'Texture border', ColorTo4S(Stages[j].TextureBorder));
  522.       Result.Add(LevelStr + 'Texture coordsSet', vtNat, [], IntToStr(Stages[j].UVSource and $F), '');
  524.       Result.AddEnumerated(LevelStr + 'Texture coordsGeneration',  [], Stages[j].UVSource shr 4, TexCoordsGenEnum);
  525.       Result.AddEnumerated(LevelStr + 'Texture coordsTransform',   [], Stages[j].TTransform and $F, 'None&U&U, V&U, V, W, &U, V, W, W2');
  526.       Result.AddEnumerated(LevelStr + 'Texture coordsMatrix type', [], Ord(Stages[j].TextureMatrixType), TextureMatrixTypesEnum);
  527.       Result.Add(LevelStr + 'Texture coordsMatrix bias', vtSingle, [], FloatToStr(Stages[j].TextureMatrixBias), '-1-1');
  529.       Result.Add(LevelStr + 'Texture coordsProjected', vtBoolean, [], OnOffStr[Stages[j].TTransform and $80 > 0], '');
  530.     end;
  531.   end;
  532. end;
  534. procedure TRenderPass.SetProperties(Properties: Props.TProperties);
  535. var j, k: Integer; LevelStr: string[50];
  536. begin
  537.   inherited;
  539.   if Properties.Valid('Group') then Group := Properties.GetAsInteger('Group');
  541.   if Properties.Valid('RenderOrder')            then Order    := Properties.GetAsInteger('RenderOrder');
  542.   if Properties.Valid('RenderSort bias')        then SortBias := StrToFloatDef(Properties['RenderSort bias'], 0);
  543.   if Properties.Valid('RenderFace culling')     then FillShadeMode.CullMode  :=          Properties.GetAsInteger('RenderFace culling');
  544.   if Properties.Valid('RenderColor write mask') then FillShadeMode.ColorMask := Longword(Properties.GetAsInteger('RenderColor write mask'));
  546.   if Properties.Valid('Blend')                     then BlendingState.Enabled   := Properties.GetAsInteger('Blend') > 0;
  547.   if Properties.Valid('BlendOperation')           then BlendingState.Operation := Properties.GetAsInteger('BlendOperation');
  548.   if Properties.Valid('BlendSource')              then BlendingState.SrcBlend  := Properties.GetAsInteger('BlendSource');
  549.   if Properties.Valid('BlendDestination')         then BlendingState.DestBlend := Properties.GetAsInteger('BlendDestination');
  550.   if Properties.Valid('BlendAlpha test function') then BlendingState.ATestFunc := Properties.GetAsInteger('BlendAlpha test function');
  551.   if Properties.Valid('BlendAlpha reference')     then BlendingState.AlphaRef  := StrToIntDef(Properties[ 'BlendAlpha reference'], 0);
  552.   BlendingState := GetBlendingState(BlendingState.Enabled, BlendingState.SrcBlend, BlendingState.DestBlend, BlendingState.AlphaRef, BlendingState.ATestFunc, BlendingState.Operation);
  554.   if Properties.Valid('RenderFill mode')  then FillShadeMode.FillMode  := Properties.GetAsInteger('RenderFill mode');
  555.   if Properties.Valid('RenderShade mode') then FillShadeMode.ShadeMode := Properties.GetAsInteger('RenderShade mode');
  557.   FillShadeMode := GetFillShadeMode(FillShadeMode.FillMode, FillShadeMode.ShadeMode, FillShadeMode.CullMode, FillShadeMode.ColorMask);
  559.   if Properties.Valid('Z bufferTest function') then ZBufferState.ZTestFunc := Properties.GetAsInteger('Z bufferTest function');
  560.   if Properties.Valid('Z bufferBias')          then ZBufferState.ZBias     := StrToIntDef(Properties[ 'Z bufferBias'], 0);
  561.   if Properties.Valid('Z bufferWrite')         then ZBufferState.ZWrite    := Properties.GetAsInteger('Z bufferWrite') > 0;
  562.   ZBufferState := GetZBufferState(ZBufferState.ZWrite, ZBufferState.ZTestFunc, ZBufferState.ZBias);
  564.   if Properties.Valid('StencilOn stencil fail') then StencilState.SFailOp   := Properties.GetAsInteger('StencilOn stencil fail');
  565.   if Properties.Valid('StencilOn Z fail')       then StencilState.ZFailOp   := Properties.GetAsInteger('StencilOn Z fail');
  566.   if Properties.Valid('StencilOn pass')         then StencilState.PassOp    := Properties.GetAsInteger('StencilOn pass');
  567.   if Properties.Valid('StencilTest function')   then StencilState.STestFunc := Properties.GetAsInteger('StencilTest function');
  568.   StencilState := GetStencilstate(StencilState.SFailOp, StencilState.ZFailOp, StencilState.PassOp, StencilState.STestFunc);
  570.   if Properties.Valid('StencilReference')  then StencilRef       := StrToIntDef(Properties['StencilReference'], 0);
  571.   if Properties.Valid('StencilMask')       then StencilMask      := StrToIntDef(Properties['StencilMask'], -1);
  572.   if Properties.Valid('StencilWrite mask') then StencilWriteMask := StrToIntDef(Properties['StencilWrite mask'], -1);
  574.   SetColorProperty(Properties, 'TextureFactor', TextureFactor);
  576.   for j := 0 to MaxTextureCoordSets-1 do begin
  577.     LevelStr := 'TextureCoord set ' + IntToStr(j) + '';
  578.     if Properties.Valid(LevelStr + 'Wrap U') then
  579.      if Properties.GetAsInteger(LevelStr + 'Wrap U') > 0 then
  580.       TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] or twUCoord else
  581.        TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] and not twUCoord;
  582.     if Properties.Valid(LevelStr + 'Wrap V') then
  583.      if Properties.GetAsInteger(LevelStr + 'Wrap V') > 0 then
  584.       TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] or twVCoord else
  585.        TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] and not twVCoord;
  586.     if Properties.Valid(LevelStr + 'Wrap W') then
  587.      if Properties.GetAsInteger(LevelStr + 'Wrap W') > 0 then
  588.       TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] or twWCoord else
  589.        TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] and not twWCoord;
  590.     if Properties.Valid(LevelStr + 'Wrap W2') then
  591.      if Properties.GetAsInteger(LevelStr + 'Wrap W2') > 0 then
  592.       TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] or twW2Coord else
  593.        TextureWrap.CoordSet[j] := TextureWrap.CoordSet[j] and not twW2Coord;
  594.   end;
  595.   TextureWrap := GetTextureWrap(TextureWrap.CoordSet[0], TextureWrap.CoordSet[1], TextureWrap.CoordSet[2], TextureWrap.CoordSet[3],
  596.                                 TextureWrap.CoordSet[4], TextureWrap.CoordSet[5], TextureWrap.CoordSet[6], TextureWrap.CoordSet[7]);
  598.   SetColor4sProperty(Properties, 'LightingAmbient',  Ambient);
  599.   SetColor4sProperty(Properties, 'LightingDiffuse',  Diffuse);
  600.   SetColor4sProperty(Properties, 'LightingSpecular', Specular);
  601.   SetColor4sProperty(Properties, 'LightingEmissive', Emissive);
  603.   if Properties.Valid('Lighting')                   then LightingState.Enabled          := Properties.GetAsInteger('Lighting') > 0;
  604.   if Properties.Valid('LightingSpecularPower') then Power := StrToFloatDef(Properties['LightingSpecularPower'], 0);
  605.   if Properties.Valid('LightingSpecularMode')     then LightingState.SpecularMode     := Properties.GetAsInteger('LightingSpecularMode');
  606.   if Properties.Valid('LightingNormalize normals') then LightingState.NormalizeNormals := Properties.GetAsInteger('LightingNormalize normals') > 0;
  607.   SetColorProperty(Properties, 'Global ambient', LightingState.GlobalAmbient);
  609.   LightingState := GetLightingState(LightingState.SpecularMode, LightingState.NormalizeNormals, LightingState.Enabled, LightingState.GlobalAmbient);
  611.   SetColorProperty(Properties, 'FogColor', FogColor);
  612.   if Properties.Valid('FogType')    then FogKind    := Properties.GetAsInteger('FogType');
  613.   if Properties.Valid('FogStart')   then FogStart   := StrToFloatDef(Properties['FogStart'],   0);
  614.   if Properties.Valid('FogEnd')     then FogEnd     := StrToFloatDef(Properties['FogEnd'],     10000);
  615.   if Properties.Valid('FogDensity') then FogDensity := StrToFloatDef(Properties['FogDensity'], 1);
  617.   if Properties.Valid('PointSprites') then PointEdgeState.PointSprite := Properties.GetAsInteger('PointSprites') > 0;
  618.   if Properties.Valid('PointScaling') then PointEdgeState.PointScale  := Properties.GetAsInteger('PointScaling') > 0;
  620.   if Properties.Valid('PointSize')     then PointSize    := StrToFloatDef(Properties['PointSize'],   1);
  621.   if Properties.Valid('PointSize min') then MinPointSize := StrToFloatDef(Properties['PointSize min'], 0);
  622.   if Properties.Valid('PointSize max') then MaxPointSize := StrToFloatDef(Properties['PointSize max'], 1000);
  624.   if Properties.Valid('PointScale A') then PointScaleA := StrToFloatDef(Properties['PointScale A'], 1);
  625.   if Properties.Valid('PointScale B') then PointScaleB := StrToFloatDef(Properties['PointScale B'], 0);
  626.   if Properties.Valid('PointScale C') then PointScaleC := StrToFloatDef(Properties['PointScale C'], 0);
  628.   if Properties.Valid('Line pattern') then LinePattern := StrToIntDef(Properties['Line pattern'], 0);
  630.   if Properties.Valid('Edge antialiasing') then PointEdgeState.EdgeAntialias := Properties.GetAsInteger('Edge antialiasing') > 0;
  631.   PointEdgeState := GetPointEdgeState(PointEdgeState.PointSprite, PointEdgeState.PointScale, PointEdgeState.EdgeAntialias);
  633.   // Shaders
  634.   LevelStr := 'ShadersVertexDeclarationTotal streams';
  635.   if Properties.Valid(LevelStr) then FTotalVertexStreams := Properties.GetAsInteger(LevelStr);
  637.   for j := 0 to FTotalVertexStreams-1 do begin
  638.     LevelStr := 'ShadersVertexDeclarationStream #' + IntToStr(j) + '';
  639.     if Properties.Valid(LevelStr + 'Total elements') then begin
  640.       FStream0Elements := Properties.GetAsInteger(LevelStr + 'Total elements');
  641.       SetLength(VertexDeclaration, FStream0Elements);
  642.     end;
  643.     for k := 0 to FStream0Elements-1 do
  644.       if Properties.Valid(LevelStr + '#' + IntToStr(k) + 'Data type') then VertexDeclaration[k] := TVertexDataType(Properties.GetAsInteger(LevelStr + '#' + IntToStr(k) + 'Data type'));
  645.   end;
  647.   LevelStr := 'ShadersVertexTotal constants';
  648.   if Properties.Valid(LevelStr) then TotalVertexShaderConstants := Properties.GetAsInteger(LevelStr);
  650.   LevelStr := 'ShadersPixelTotal constants';
  651.   if Properties.Valid(LevelStr) then TotalPixelShaderConstants := Properties.GetAsInteger(LevelStr);
  653.   for j := 0 to TotalVertexShaderConstants-1 do begin
  654.     LevelStr := 'ShadersVertexConstants#' + IntToStr(j);
  655.     if Properties.Valid(LevelStr) then
  656.       VertexShaderConstant[j] := Properties[LevelStr];
  657.   end;
  659.   for j := 0 to TotalPixelShaderConstants-1 do begin
  660.     LevelStr := 'ShadersPixelConstants#' + IntToStr(j);
  661.     if Properties.Valid(LevelStr) then
  662.       PixelShaderConstant[j] := Properties[LevelStr];
  663.   end;
  664.   
  665.   if Properties.Valid('ShadersVertex') then begin
  666.     if SetLinkProperty('ShadersVertex', Properties['ShadersVertex']) then
  667.       VertexShaderIndex := sivUnresolved;
  668.     if (Properties['ShadersVertex'] = '') then VertexShaderIndex := sivNull;
  669.   end;
  670.         
  671.   if Properties.Valid('ShadersPixel')  then begin
  672.     if SetLinkProperty('ShadersPixel', Properties['ShadersPixel']) then
  673.       PixelShaderIndex := sivUnresolved;
  674.     if (Properties['ShadersPixel'] = '') then PixelShaderIndex := sivNull;
  675.   end;
  677.   // Texture stages        
  678.   if Properties.Valid('Total stages') then TotalStages := Properties.GetAsInteger('Total stages');
  680.   for j := 0 to TotalStages-1 do begin
  681.     LevelStr := 'Stage #' + IntToStr(j) + '';
  683.     if Properties.Valid(LevelStr + 'Texture') then
  684.       if (Properties[LevelStr + 'Texture'] = '') then begin
  685.         Stages[j].TextureIndex := tivNull;
  686.         SetLinkProperty(LevelStr + 'Texture', '');
  687.       end else if SetLinkProperty(LevelStr + 'Texture', Properties[LevelStr + 'Texture']) then
  688.         Stages[j].TextureIndex := tivUnresolved;
  690.     if Properties.Valid(LevelStr + 'ColorOperation')   then Stages[j].ColorOp         := Properties.GetAsInteger(LevelStr + 'ColorOperation');
  691.     if Properties.Valid(LevelStr + 'ColorArgument 0')  then Stages[j].ColorArg0       := Properties.GetAsInteger(LevelStr + 'ColorArgument 0');
  692.     if Properties.Valid(LevelStr + 'ColorArgument 1')  then Stages[j].ColorArg1       := Properties.GetAsInteger(LevelStr + 'ColorArgument 1');
  693.     if Properties.Valid(LevelStr + 'ColorArgument 2')  then Stages[j].ColorArg2       := Properties.GetAsInteger(LevelStr + 'ColorArgument 2');
  694.     if Properties.Valid(LevelStr + 'ColorInvert Arg1') then Stages[j].InvertColorArg1 := Properties.GetAsInteger(LevelStr + 'ColorInvert Arg1') > 0;
  695.     if Properties.Valid(LevelStr + 'ColorInvert Arg2') then Stages[j].InvertColorArg2 := Properties.GetAsInteger(LevelStr + 'ColorInvert Arg2') > 0;
  697.     if Properties.Valid(LevelStr + 'AlphaOperation')   then Stages[j].AlphaOp         := Properties.GetAsInteger(LevelStr + 'AlphaOperation');
  698.     if Properties.Valid(LevelStr + 'AlphaArgument 0')  then Stages[j].AlphaArg0       := Properties.GetAsInteger(LevelStr + 'AlphaArgument 0');
  699.     if Properties.Valid(LevelStr + 'AlphaArgument 1')  then Stages[j].AlphaArg1       := Properties.GetAsInteger(LevelStr + 'AlphaArgument 1');
  700.     if Properties.Valid(LevelStr + 'AlphaArgument 2')  then Stages[j].AlphaArg2       := Properties.GetAsInteger(LevelStr + 'AlphaArgument 2');
  701.     if Properties.Valid(LevelStr + 'AlphaInvert Arg1') then Stages[j].InvertAlphaArg1 := Properties.GetAsInteger(LevelStr + 'AlphaInvert Arg1') > 0;
  702.     if Properties.Valid(LevelStr + 'AlphaInvert Arg2') then Stages[j].InvertAlphaArg2 := Properties.GetAsInteger(LevelStr + 'AlphaInvert Arg2') > 0;
  704.     if Properties.Valid(LevelStr + 'AdressingU') then Stages[j].TAddressing := (Stages[j].TAddressing and not $00F) or Cardinal(Properties.GetAsInteger(LevelStr + 'AdressingU'));
  705.     if Properties.Valid(LevelStr + 'AdressingV') then Stages[j].TAddressing := (Stages[j].TAddressing and not $0F0) or Cardinal(Properties.GetAsInteger(LevelStr + 'AdressingV')) shl 4;
  706.     if Properties.Valid(LevelStr + 'AdressingW') then Stages[j].TAddressing := (Stages[j].TAddressing and not $F00) or Cardinal(Properties.GetAsInteger(LevelStr + 'AdressingW')) shl 8;
  708.     if Properties.Valid(LevelStr + 'Store in Temp register') then Stages[j].StoreToTemp := Properties.GetAsInteger(LevelStr + 'Store in Temp register') > 0;
  710.     if Properties.Valid(LevelStr + 'FilteringMin') then Stages[j].Filtering := (Stages[j].Filtering and not $00F) or Cardinal(Properties.GetAsInteger(LevelStr + 'FilteringMin'));
  711.     if Properties.Valid(LevelStr + 'FilteringMax') then Stages[j].Filtering := (Stages[j].Filtering and not $0F0) or Cardinal(Properties.GetAsInteger(LevelStr + 'FilteringMax')) shl 4;
  712.     if Properties.Valid(LevelStr + 'FilteringMip') then Stages[j].Filtering := (Stages[j].Filtering and not $F00) or Cardinal(Properties.GetAsInteger(LevelStr + 'FilteringMip')) shl 8;
  713.     if Properties.Valid(LevelStr + 'FilteringMip LOD bias')   then Stages[j].MipLODBias  := StrToFloatDef(Properties[LevelStr + 'FilteringMip LOD bias'], 0);
  714.     if Properties.Valid(LevelStr + 'FilteringMax mip level')  then Stages[j].MaxMipLevel := Properties.GetAsInteger(LevelStr + 'FilteringMax mip level');
  715.     if Properties.Valid(LevelStr + 'FilteringMax anisotropy') then Stages[j].MaxAnisotropy := Properties.GetAsInteger(LevelStr + 'FilteringMax anisotropy');
  717.     SetColorProperty(Properties, LevelStr + 'Texture border', Stages[j].TextureBorder);
  719.     if Properties.Valid(LevelStr + 'Texture coordsSet')        then Stages[j].UVSource := (Stages[j].UVSource and not $0F) or Cardinal(Properties.GetAsInteger(LevelStr + 'Texture coordsSet'));
  720.     if Properties.Valid(LevelStr + 'Texture coordsGeneration') then Stages[j].UVSource := (Stages[j].UVSource and not $F0) or Cardinal(Properties.GetAsInteger(LevelStr + 'Texture coordsGeneration')) shl 4;
  722.     if Properties.Valid(LevelStr + 'Texture coordsTransform')   then Stages[j].TTransform        := (Stages[j].TTransform and not $0F) or Cardinal(Properties.GetAsInteger(LevelStr + 'Texture coordsTransform'));
  723.     if Properties.Valid(LevelStr + 'Texture coordsMatrix type') then Stages[j].TextureMatrixType := TTextureMatrixType(Properties.GetAsInteger(LevelStr + 'Texture coordsMatrix type'));
  724.     if Properties.Valid(LevelStr + 'Texture coordsMatrix bias') then Stages[j].TextureMatrixBias := StrToFloatDef(Properties[LevelStr + 'Texture coordsMatrix bias'], 0);
  726.     if Properties.Valid(LevelStr + 'Texture coordsProjected')   then Stages[j].TTransform        := (Stages[j].TTransform and not $80) or Cardinal(Properties.GetAsInteger(LevelStr + 'Texture coordsProjected')) shl 7;
  727.   end;
  729.   RequestValidation;
  730. end;
  732. function TRenderPass.GetTotalStages: Integer;
  733. begin
  734.   Result := Length(Stages);
  735. end;
  737. procedure TRenderPass.SetTotalStages(const Value: Integer);
  738. var i: Integer; OldTotalStages: Integer;
  739. begin
  740.   OldTotalStages := TotalStages;
  741.   SetLength(Stages, Value);
  742.   for i := OldTotalStages to Value-1 do begin
  743.     Stages[i].TextureIndex      := tivNull;
  744.     Stages[i].ColorOp           := toMODULATE;
  745.     Stages[i].ColorArg1         := taTexture;
  746.     Stages[i].ColorArg2         := taDiffuse;
  747.     Stages[i].InvertColorArg1   := False;
  748.     Stages[i].InvertColorArg2   := False;
  749.     Stages[i].AlphaOp           := toDISABLE;
  750.     Stages[i].AlphaArg1         := taTexture;
  751.     Stages[i].AlphaArg2         := taDiffuse;
  752.     Stages[i].InvertAlphaArg1   := False;
  753.     Stages[i].InvertAlphaArg2   := False;
  754.     Stages[i].TAddressing       := 0;
  755.     Stages[i].StoreToTemp       := False;
  756.     Stages[i].Filtering         := $222;
  757.     Stages[i].UVSource          := 0;
  758.     Stages[i].TTransform        := 2;
  759.     Stages[i].TextureMatrixType := tmNone;
  760.     Stages[i].TextureMatrixBias := 0;
  761.   end;
  762.   BuildItemLinks;
  763. end;
  765. function TRenderPass.AddItem(const Item: TItem): Integer;
  766. begin
  767.   Assert(GetItemIndex(Item) = -1, ClassName + '.AddItem: Item already exists');
  768.   if TotalItems = 0 then (FManager as CAST2.TBaseCore).AddPass(Self);
  769.   Inc(TotalItems);
  770.   if Length(Items) < TotalItems then SetLength(Items, Length(Items) + ItemsCapacityStep);
  771.   Items[TotalItems-1] := Item;
  772.   Result := TotalItems-1;
  773. end;
  775. function TRenderPass.RemoveItem(const Index: Integer): Boolean;
  776. // Returns true if item relocation in Items array occured
  777. begin
  778.   Assert((Index >= 0) and (Index < TotalItems), ClassName + '.RemoveItem: Invalid index "' + IntToStr(Index) + '"');
  779.   Dec(TotalItems);
  780.   Items[Index] := Items[TotalItems];
  781.   Result := Index <> TotalItems;
  782.   if TotalItems = 0 then (FManager as CAST2.TBaseCore).RemovePass(Self);
  783. end;
  785. function TRenderPass.ResolveTexture(const Index: Integer; out Texture: Resources.TImageResource): Boolean;
  786. var Item: TItem;
  787. begin
  788.   Result := ResolveLink('Stage #' + IntToStr(Index) + 'Texture', Item);
  789.   if Item is TImageResource then begin
  790.     Texture := Item as Resources.TImageResource;
  791.     Stages[Index].Camera := nil;
  792.     ResolvedTexture := Texture;
  793.   end else if Item is TCamera then begin
  794.     Stages[Index].TextureIndex := tivRenderTarget;
  795.     Stages[Index].Camera := Item as TCamera;
  796.   end;
  797. end;
  799. function TRenderPass.ResolveVertexShader(var Shader: TShaderResource): Boolean;
  800. var Item: TItem;
  801. begin
  802.   Result := ResolveLink('ShadersVertex', Item);
  803.   Shader := Item as TShaderResource;
  804.   ResolvedVertexShader := Shader;
  805. end;
  807. function TRenderPass.ResolvePixelShader(var Shader: TShaderResource): Boolean;
  808. var Item: TItem;
  809. begin
  810.   Result := ResolveLink('ShadersPixel', Item);
  811.   Shader := Item as TShaderResource;
  812.   ResolvedPixelShader := Shader;
  813. end;
  815. function TRenderPass.GetItemIndex(const Item: TItem): Integer;
  816. begin
  817.   Result := 0;
  818.   while Result < TotalItems do begin
  819.     if Items[Result] = Item then Exit;
  820.     Inc(Result);
  821.   end;
  822.   Result := -1;
  823. end;
  825. procedure TRenderPass.SetOrder(const Value: Integer);
  826. begin
  827.   if Value = FOrder then Exit;
  828.   FOrder := Value;
  829.   if (TotalItems > 0) and (FManager <> nil) then begin                 // For pass reordering in core
  830.     (FManager as CAST2.TBaseCore).RemovePass(Self);
  831.     (FManager as CAST2.TBaseCore).AddPass(Self);
  832.   end;
  833. end;
  835. function TRenderPass.GetTotalPixelShaderConstants: Integer;
  836. begin
  837.   Result := Length(FPixelShaderConstants);
  838. end;
  840. function TRenderPass.GetTotalVertexShaderConstants: Integer;
  841. begin
  842.   Result := Length(FVertexShaderConstants);
  843. end;
  845. procedure TRenderPass.SetTotalPixelShaderConstants(const Value: Integer);
  846. begin
  847.   SetLength(FPixelShaderConstants, Value);
  848.   SetLength(FCompiledPixelShaderConstants, Value);
  849.   RequestValidation;
  850. end;
  852. procedure TRenderPass.SetTotalVertexShaderConstants(const Value: Integer);
  853. begin
  854.   SetLength(FVertexShaderConstants, Value);
  855.   SetLength(FCompiledVertexShaderConstants, Value);
  856.   RequestValidation;
  857. end;
  859. function TRenderPass.GetPixelShaderConstant(Index: Integer): string;
  860. begin
  861.   Result := FPixelShaderConstants[Index];
  862. end;
  864. function TRenderPass.GetVertexShaderConstant(Index: Integer): string;
  865. begin
  866.   Result := FVertexShaderConstants[Index];
  867. end;
  869. procedure TRenderPass.SetVertexShaderConstant(Index: Integer; const Value: string);
  870. begin
  871.   if (Index >= 0) or (Index < TotalVertexShaderConstants) then begin
  872.     FVertexShaderConstants[Index] := Value;
  873.     FCompiledVertexShaderConstants[Index] := FManager.Compiler.Compile(Value);
  874.   end else Log.Log(Format('%S.%S: Invalid index', [ClassName, 'SetVertexShaderConstant']), lkError);
  875. end;
  877. procedure TRenderPass.SetPixelShaderConstant(Index: Integer; const Value: string);
  878. begin
  879.   if (Index >= 0) or (Index < TotalPixelShaderConstants) then begin
  880.     FPixelShaderConstants[Index] := Value;
  881.     FCompiledPixelShaderConstants[Index] := FManager.Compiler.Compile(Value);
  882.   end else Log.Log(Format('%S.%S: Invalid index', [ClassName, 'SetPixelShaderConstant']), lkError);
  883. end;
  885. function TRenderPass.GetCompiledVertexShaderConstants(Index: Integer): OTypes.TRTData;
  886. begin
  887.   Result := FCompiledVertexShaderConstants[Index];
  888. end;
  890. function TRenderPass.GetCompiledPixelShaderConstants(Index: Integer): OTypes.TRTData;
  891. begin
  892.   Result := FCompiledPixelShaderConstants[Index];
  893. end;
  895. procedure TRenderPass.HandleMessage(const Msg: TMessage);
  896. var i: Integer;
  897. begin
  898.   inherited;
  899.   if Msg.ClassType = TDataModifyMsg then begin
  900.     if TDataModifyMsg(Msg).Data = Pointer(ResolvedVertexShader) then VertexShaderIndex := sivUnresolved;
  901.     if TDataModifyMsg(Msg).Data = Pointer(ResolvedPixelShader) then  PixelShaderIndex  := sivUnresolved;
  902. //    if TDataModifyMsg(Msg).Data = ResolvedTexture     then  texVertexShaderIndex := sivUnresolved;
  903.   end else if Msg.ClassType = TRemoveFromSceneMsg then with TRemoveFromSceneMsg(Msg) do
  904.     for i := 0 to TotalStages-1 do
  905.       if (Item = Stages[i].Camera) and (Item is TCamera) then begin
  906.         Stages[i].TextureIndex := tivUnresolved;
  907.         SetLinkProperty('Stage #' + IntToStr(i) + 'Texture', Stages[i].Camera.GetFullName);
  908.         Stages[i].Camera       := nil;
  909.       end;
  910. end;
  912. procedure TRenderPass.RequestValidation;
  913. begin
  914.   if not FManager.IsSceneLoading and Assigned(FManager.Root) then
  915.     SendMessage(TRenderPassModifiedMsg.Create(Self), nil, [mfBroadcast]);
  916. end;
  918. { TTechnique }
  920. procedure TTechnique.SetState(const Value: TItemFlags);
  921. var Modified: Boolean;
  922. begin
  923.   Modified := (isVisible in State) and not (isVisible in Value) or
  924.               not (isVisible in State) and (isVisible in Value);
  925.   inherited;
  926.   if Modified and not FManager.IsSceneLoading and Assigned(FManager.Root) then
  927.     SendMessage(TRenderPassModifiedMsg.Create(Passes[0]), nil, [mfBroadcast]);
  928. end;
  930. constructor TTechnique.Create(AManager: TItemsManager);
  931. begin
  932.   inherited;
  933.   TotalPasses := 0;
  934.   LOD         := 0;
  935.   Valid       := False;
  936.   Include(FState, isVisible);
  937. end;
  939. procedure TTechnique.AddProperties(const Result: Props.TProperties);
  940. var i: Integer;
  941. begin
  942.   inherited;
  944.   if Assigned(Result) then begin
  945.     Result.Add('Total passes', vtInt, [], IntToStr(TotalPasses),  '');
  946.     Result.Add('LOD',  vtInt,    [], IntToStr(LOD),  '');
  947.   end;  
  949.   for i := 0 to TotalPasses-1 do
  950.     AddItemLink(Result, Format('Pass #%D', [i]), [], 'TRenderPass');
  951. end;
  953. procedure TTechnique.SetProperties(Properties: Props.TProperties);
  954. var ItemProps: Props.TProperties;
  956.   function GetPassIndex(const Name: string): Integer;
  957.   begin
  958.     Result := TotalPasses-1;
  959.     while (Result >= 0) and (ItemProps[Format('Pass #%D', [Result])] <> Name) do Dec(Result);
  960.   end;
  962. var i, Ind: Integer; PropName: string;
  964. begin
  965.   inherited;
  967. //  Include(FState, isVisible);
  969.   if Properties.Valid('Total passes') then TotalPasses := StrToIntDef(Properties['Total passes'], TotalPasses);
  971.   ItemProps := Props.TProperties.Create;
  972.   AddProperties(ItemProps);
  974.   for i := 0 to TotalPasses-1 do if Properties.Valid(Format('Pass #%D', [i])) then begin
  975.     PropName := Format('Pass #%D', [i]);
  976.     Ind := GetPassIndex(Properties[PropName]);
  977.     if (Ind = -1) or (Ind = i) then
  978.       SetLinkProperty(PropName, Properties[PropName])
  979.     else Log.Log('TTechnique.SetProperties: Duplicate pass in technique: "' + Properties[PropName], lkError);
  980.   end;
  982.   FreeAndNil(ItemProps);
  984.   if Properties.Valid('LOD') then LOD := StrToIntDef(Properties['LOD'], 0);
  985. end;
  987. procedure TTechnique.SetTotalPasses(const Value: Integer);
  988. begin
  989.   if not FManager.IsSceneLoading and Assigned(FManager.Root) then
  990.     SendMessage(TTechniqueModificationBeginMsg.Create(Self), nil, [mfBroadcast]);
  991.   FTotalPasses := Value;
  992.   SetLength(PassesCache, FTotalPasses);
  993.   BuildItemLinks;
  994.   if not FManager.IsSceneLoading and Assigned(FManager.Root) then
  995.     SendMessage(TTechniqueModificationEndMsg.Create(Self), nil, [mfBroadcast]);
  996. end;
  998. function TTechnique.GetPass(Index: Integer): TRenderPass;
  999. var Item: TItem;
  1000. begin
  1001.   if PassesCache[Index] <> nil then
  1002.     Result := PassesCache[Index] else begin
  1003.       ResolveLink(Format('Pass #%D', [Index]), Item);
  1004.       PassesCache[Index] := Item as TRenderPass;
  1005.       Result := PassesCache[Index]
  1006.     end;
  1007. end;
  1009. procedure TTechnique.SetPass(Index: Integer; const Value: TRenderPass);
  1010. begin
  1011.   if not FManager.IsSceneLoading and Assigned(FManager.Root) then
  1012.     SendMessage(TTechniqueModificationBeginMsg.Create(Self), nil, [mfBroadcast]);
  1013.   SetLinkedObject(Format('Pass #%D', [Index]), Value);
  1014.   if not FManager.IsSceneLoading and Assigned(FManager.Root) then
  1015.     SendMessage(TTechniqueModificationEndMsg.Create(Self), nil, [mfBroadcast]);
  1016. end;
  1018. { TMaterial }
  1020. procedure TMaterial.AddProperties(const Result: Props.TProperties);
  1021. var i: Integer;
  1022. begin
  1023.   inherited;
  1025.   if Assigned(Result) then Result.Add('Total techniques', vtInt, [], IntToStr(TotalTechniques),  '');
  1027.   for i := 0 to TotalTechniques-1 do
  1028.     AddItemLink(Result, Format('Technique #%D', [i]), [], 'TTechnique');
  1029. end;
  1031. procedure TMaterial.SetProperties(Properties: Props.TProperties);
  1032. var i: Integer;
  1033. begin
  1034.   inherited;
  1035.   if Properties.Valid('Total techniques') then
  1036.     TotalTechniques := StrToIntDef(Properties['Total techniques'], TotalTechniques);
  1038.   for i := 0 to TotalTechniques-1 do if Properties.Valid(Format('Technique #%D', [i])) then
  1039.     SetLinkProperty(Format('Technique #%D', [i]), Properties[Format('Technique #%D', [i])]);
  1040. end;
  1042. function TMaterial.GetTechniqueByLOD(Lod: Single): TTechnique;
  1043. var i: Integer;
  1044. begin
  1045.   Result := nil;
  1046.   i := 0;
  1047.   while (i < TotalTechniques) and
  1048.         ( not (isVisible in Technique[i].State) or not Technique[i].Valid or (Technique[i].LOD <> Round(Lod)) ) do Inc(i);
  1049.   if i < TotalTechniques then Result := Technique[i];
  1050. end;
  1052. function TMaterial.GetTechnique(Index: Integer): TTechnique;
  1053. var Item: TItem;
  1054. begin
  1055.   ResolveLink(Format('Technique #%D', [Index]), Item);
  1056.   Result := Item as TTechnique;
  1057. end;
  1059. procedure TMaterial.SetTechnique(Index: Integer; const Value: TTechnique);
  1060. begin
  1061.   SetLinkedObject(Format('Technique #%D', [Index]), Value);
  1062. end;
  1064. procedure TMaterial.SetTotalTechniques(const Value: Integer);
  1065. begin
  1066.   FTotalTechniques := Value;
  1067.   BuildItemLinks;
  1068. end;
  1070. function TMaterial.PassBelongs(AItem: TItem): Boolean;
  1072.   function BelongsToTechnique(Tech: TTechnique): Boolean;
  1073.   var i: Integer;
  1074.   begin
  1075.     Result := False;
  1076.     if not Assigned(Tech) then Exit;
  1077.     i := Tech.TotalPasses-1;
  1078.     while (i >= 0) and (Tech.Passes[i] <> AItem) do Dec(i);
  1079.     Result := i >= 0;
  1080.   end;
  1082. var i: Integer;
  1083. begin
  1084.   i := TotalTechniques-1;
  1085.   while (i >= 0) and not BelongsToTechnique(Technique[i]) do Dec(i);
  1086.   Result := i >= 0;
  1087. end;
  1089. procedure TMaterial.HandleMessage(const Msg: TMessage);
  1090. begin
  1091.   inherited;
  1092.   if (Msg.ClassType = TRenderReinitMsg) or
  1093.     ((Msg.ClassType = TRenderPassModifiedMsg) and PassBelongs(TRenderPassModifiedMsg(Msg).Item)) then
  1094.     SendMessage(TRequestValidationMsg.Create(Self), nil, [mfCore]);
  1095. end;
  1097. procedure TMaterial.OnSceneLoaded;
  1098. begin
  1099.   inherited;
  1100.   SendMessage(TRequestValidationMsg.Create(Self), nil, [mfCore]);
  1101. end;
  1103. end.