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

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

游戏引擎

开发平台：

Delphi

C2FX.pas：源码内容
  1. (*
  2.  @Abstract(CAST II Engine special effects 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 item and tesselator classes for basic special effects
  6. *)
  7. {$Include GDefines.inc}
  8. {$Include C2Defines.inc}
  9. unit C2FX;
  11. interface
  13. uses SysUtils, BaseTypes, Basics, BaseCont, Base3D, Props, BaseClasses, C2Types, CAST2, C2Visual, Resources;
  15. const
  16.   // Fade states
  17.   fsNone = 0; fsFadeIn = 1; fsFadeOut = 2;
  19. type
  20.   T3DLineMesh = class(TTesselator)
  21.     Size1, Size2, Len, VScale: Single;
  22.     Color1, Color2: BaseTypes.TColor;
  23.     constructor Create; override;
  24.     procedure Init; override;
  25.     function RetrieveParameters(out Parameters: Pointer; Internal: Boolean): Integer; override;
  26.     function Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer; override;
  27.   protected
  28.     Point1, Point2: TVector4s;
  29.     ModelMatrix: ^TMatrix4s;
  30.     FSize1, FSize2, FLen, FVScale: Single;
  31.     FColor1, FColor2: BaseTypes.TColor;
  32.   end;
  34.   T3DLine = class(TVisible)
  35.     function GetTesselatorClass: CTesselator; override;
  36.     procedure AddProperties(const Result: Props.TProperties); override;
  37.     procedure SetProperties(Properties: Props.TProperties); override;
  38.   protected
  39.     function GetColor1: BaseTypes.TColor;
  40.     procedure SetColor1(const Value: BaseTypes.TColor);
  41.     function GetColor2: BaseTypes.TColor;
  42.     procedure SetColor2(const Value: BaseTypes.TColor);
  43.     function GetLength: Single;
  44.     procedure SetLength(const Value: Single);
  45.   public
  46.     constructor Create(AManager: TItemsManager); override;
  47.     function VisibilityCheck(const Camera: TCamera): Boolean; override;
  48.     property Color1: BaseTypes.TColor read GetColor1 write SetColor1;
  49.     property Color2: BaseTypes.TColor read GetColor2 write SetColor2;
  50.     property Len: Single read GetLength write SetLength;
  51.   end;
  53.   TBackgroundTesselator = class(TTesselator)
  54.   protected
  55.     Cols, Rows: Integer;
  56.   public
  57.     Zoom, UOfs, VOfs: Single;
  58.     Angle: Integer;
  59.     Color: BaseTypes.TColor;
  60.     constructor Create; override;
  61.     function IsSameItem(AItem: TReferencedItem): Boolean; override;
  62.     procedure Init; override;
  64.     procedure AddProperties(const Result: Props.TProperties; const PropNamePrefix: TNameString); override;
  65.     procedure SetProperties(Properties: Props.TProperties; const PropNamePrefix: TNameString); override;
  67.     function Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer; override;
  68.     function SetIndices(IBPTR: Pointer): Integer; override;
  69.   end;
  71.   // Shows a full-screen quad with color depending on processing time.
  72.   // If AutoStop is True processing automatically stops when it reaches half of specified gradient.
  73.   TFader = class(TVisible)
  74.   private
  75.     AutoStopNeeded: Boolean;
  76.     procedure SetColor(const Value: TColor);
  77.   public
  78.     // Color gradient
  79.     Colors: TSampledGradient;
  80.     // Stop at half (probably when full visible) 
  81.     AutoStop: Boolean;
  82.     constructor Create(AManager: TItemsManager); override;
  83.     destructor Destroy; override;
  84.     
  85.     function VisibilityCheck(const Camera: TCamera): Boolean; override;
  86.     function GetTesselatorClass: CTesselator; override;
  87.     procedure Show; override;
  88.     procedure Process(const DeltaT: Single); override;
  89.     procedure AddProperties(const Result: Props.TProperties); override;
  90.     procedure SetProperties(Properties: Props.TProperties); override;
  91.   end;
  93.   TBackground = class(TVisible)
  94.   protected
  95.     function GetAngle: Integer;
  96.     function GetColor: BaseTypes.TColor;
  97.     function GetZoom: Single;
  98.     procedure SetColor(const Value: BaseTypes.TColor);
  99.     procedure SetAngle(const Value: Integer);
  100.     procedure SetZoom(const Value: Single);
  101.   public
  102.     constructor Create(AManager: TItemsManager); override;
  103.     function VisibilityCheck(const Camera: TCamera): Boolean; override;
  104.     function GetTesselatorClass: CTesselator; override;
  106.     procedure AddProperties(const Result: Props.TProperties); override;
  107.     procedure SetProperties(Properties: Props.TProperties); override;
  108.     property Angle: Integer read GetAngle write SetAngle;
  109.     property Zoom: Single read GetZoom write SetZoom;
  110.   end;
  112.   TBillboardMesh = class(TTesselator)
  113.     MaxFrame: Integer;
  114.     UVMap: TUVMap;
  115.     constructor Create; override;
  117.     procedure AddProperties(const Result: Props.TProperties; const PropNamePrefix: TNameString); override;
  118.     procedure SetProperties(Properties: Props.TProperties; const PropNamePrefix: TNameString); override;
  120.     function Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer; override;
  121.     procedure SetFrame(const Value: Integer); virtual;
  122.     protected
  123.       FColor: TColor;
  124.       FWidth, FHeight: Single;
  125.       FFrame: Integer;
  126.     public
  127.       property Frame: Integer read FFrame write SetFrame;
  128.   end;
  130.   TBillboard = class(TVisible)
  131.   protected
  132.     AnimTime: Single;
  133.   public
  134.     AnimRate: Single;
  135.     AnimRepeat, HideAtEnd: Boolean;
  136.     constructor Create(AManager: TItemsManager); override;
  137.     function VisibilityCheck(const Camera: TCamera): Boolean; override;
  138.     function GetTesselatorClass: CTesselator; override;
  139.     procedure ResolveLinks; override;
  141.     procedure Process(const DeltaT: Single); override;
  143.     procedure AddProperties(const Result: Props.TProperties); override;
  144.     procedure SetProperties(Properties: Props.TProperties); override;
  145.   end;
  147.   TSplashTesselator = class(TTesselator)
  148.   private
  149.   public
  150.     Color: TColor;
  151.     Size: Single;
  152.     constructor Create; override;
  153.     function IsSameItem(AItem: TReferencedItem): Boolean; override;
  154.     function GetBoundingBox: TBoundingBox; override;
  155.     function Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer; override;
  156.   end;
  158.   TSplash = class(TVisible)
  159.   public
  160.     Color: TSampledGradient;
  161.     Size: TSampledFloats;
  162.     constructor Create(AManager: TItemsManager); override;
  163.     destructor Destroy; override;
  165.     function GetTesselatorClass: CTesselator; override;
  166.     procedure AddProperties(const Result: Props.TProperties); override;
  167.     procedure SetProperties(Properties: Props.TProperties); override;
  169.     procedure Process(const DeltaT: Single); override;
  170.   end;
  172.   // Returns list of classes introduced by the unit
  173.   function GetUnitClassList: TClassArray;
  175. implementation
  177. function GetUnitClassList: TClassArray;
  178. begin
  179.   Result := GetClassList([T3DLine, TFader, TBackground, TBillboard, TSplash]);
  180. end;
  182. { T3DLineTesselator }
  184. constructor T3DLineMesh.Create;
  185. begin
  186.   inherited;
  188.   Len      := 1;
  189.   Color1.C := $80808080;
  190.   Color2.C := $80808080;
  191.   Size1    := 0.05;  Size2 := 0.05;
  192.   VScale   := 1;
  194.   Init;
  196.   PrimitiveType := ptTRIANGLEFAN;
  197.   InitVertexFormat(GetVertexFormat(False, False, True, False, False, 0, [2]));
  199.   TotalVertices   := 6;
  200.   TotalPrimitives := 4;
  201. end;
  203. procedure T3DLineMesh.Init;
  204. begin
  205.   inherited;
  206.   Point1 := GetVector4s(0, 0, 0, 1); Point2 := GetVector4s(0, 0, FLen, 1);
  207. end;
  209. function T3DLineMesh.RetrieveParameters(out Parameters: Pointer; Internal: Boolean): Integer;
  210. begin
  211.   Result := 6;
  212.   if Internal then Parameters := @FSize1 else Parameters := @Size1;
  213. end;
  215. function T3DLineMesh.Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer;
  216. var
  217.   Trans1, Trans2: TVector4s;
  218.   V, N, Cam: TVector3s;
  219.   l, d, e: Single;
  220. begin
  221. //  Cam := CutVector3s(Transform4Vector4s(ModelMatrix^, ExpandVector3s(Camera.Position)));
  222. //  Cam := GetVector3s(Params.Camera.Location.X, Camera.Location.Y, Camera.Location.Z);
  223.   Cam := Params.Camera.GetAbsLocation;
  224. //  Cam := ScaleVector3s(Camera.ViewOrigin, -1);
  225. //  Cam := ScaleVector3s( Transform3Vector3s(InvertMatrix3s(CutMatrix3s(Params.Camera.ViewMatrix)), Params.Camera.ViewOrigin), -1);
  227.   Trans1 := Transform4Vector4s(ModelMatrix^, Point1);
  228.   Trans2 := Transform4Vector4s(ModelMatrix^, Point2);
  230. //  Trans1 := CutVector3s(Point1); Trans2 := CutVector3s(Point2);
  232.   N := SubVector4s(Trans2, Trans1).XYZ;                                   // Line vector in world
  233.   V := GetVector3s(- Trans1.X + Cam.X, - Trans1.Y + Cam.Y, - Trans1.Z + Cam.Z);    // From Point1 to camera
  234. {  W := N;
  235.   d := DotProductVector3s(N, V);                                                   // V projected to N
  236.   e := DotProductVector3s(N, W);
  237.   I := AddVector3s(Trans1.XYZ, ScaleVector3s(W, d/e));
  239.   N := CrossProductVector3s(GetVector3s(I.X - Cam.X, I.Y - Cam.Y, I.Z - Cam.Z), N);}
  241.   N := CrossProductVector3s(V, N);
  243.   N := Transform3Vector3s(InvertMatrix3s(CutMatrix3s(ModelMatrix^)), N);
  245.   l := InvSqrt(SqrMagnitude(N));
  247. //  N := GetVector3s(1, 0, 0); l := 1;
  249. //  1           2
  250. //        0
  251. //  4           3
  253.   SetVertexDataC((Point1.X + Point2.X) * 0.5, (Point1.Y + Point2.Y) * 0.5, (Point1.Z + Point2.Z) * 0.5, 0, VBPtr);
  254.   SetVertexDataD(BlendColor(FColor1, FColor2, 0.5), 0, VBPtr);
  255.   SetVertexDataUV(0.5, FVScale * 0.5, 0, VBPtr);
  257.   SetVertexDataC(Point1.X - N.X * l * FSize1, Point1.Y - N.Y * l * FSize1, Point1.Z - N.Z * l * FSize1, 1, VBPtr);
  258.   SetVertexDataD(FColor1, 1, VBPtr);
  259.   SetVertexDataUV(0, FVScale, 1, VBPtr);
  261.   SetVertexDataC(Point2.X - N.X * l * FSize2, Point2.Y - N.Y * l * FSize2, Point2.Z - N.Z * l * FSize2, 2, VBPtr);
  262.   SetVertexDataD(FColor2, 2, VBPtr);
  263.   SetVertexDataUV(0, 0 + 0*0.5, 2, VBPtr);
  265.   {  SetVertexDataC(Point2.X, Point2.Y, Point2.Z, 3, VBPtr);
  266.   SetVertexDataD(FColor2*0 + $FF008080, 3, VBPtr);
  267.   SetVertexDataUV(0.5, 0, 3, VBPtr);}
  269.   SetVertexDataC(Point1.X + N.X * l * FSize1, Point1.Y + N.Y * l * FSize1, Point1.Z + N.Z * l * FSize1, 4, VBPtr);
  270.   SetVertexDataD(FColor1, 4, VBPtr);
  271.   SetVertexDataUV(1, FVScale, 4, VBPtr);
  273.   SetVertexDataC(Point2.X + N.X * l * FSize2, Point2.Y + N.Y * l * FSize2, Point2.Z + N.Z * l * FSize2, 3, VBPtr);
  274.   SetVertexDataD(FColor2, 3, VBPtr);
  275.   SetVertexDataUV(1, 0, 3, VBPtr);
  277.   SetVertexDataC(Point1.X - N.X * l * FSize1, Point1.Y - N.Y * l * FSize1, Point1.Z - N.Z * l * FSize1, 5, VBPtr);
  278.   SetVertexDataD(FColor1, 5, VBPtr);
  279.   SetVertexDataUV(0, FVScale, 5, VBPtr);
  281. //  TesselationStatus[tbVertex].Status := tsTesselated;
  282.   LastTotalVertices := TotalVertices;
  283.   Result := LastTotalVertices;
  284. end;
  286. { T3DLine }
  288. function T3DLine.GetTesselatorClass: CTesselator; begin Result := T3DLineMesh; end;
  290. procedure T3DLine.AddProperties(const Result: Props.TProperties);
  291. var Mesh: T3DLineMesh;
  292. begin
  293.   inherited;
  294.   if not Assigned(Result) then Exit;
  296.   if not (CurrentTesselator is T3DLineMesh) then Exit;
  297.   Mesh := CurrentTesselator as T3DLineMesh;
  299.   Result.Add('GeometryLength',    vtSingle, [], FloatToStr(Mesh.Len), '');
  301.   AddColorProperty(Result, 'Color1', Mesh.Color1);
  302.   AddColorProperty(Result, 'Color2', Mesh.Color2);
  304.   Result.Add('GeometrySize near', vtSingle, [], FloatToStr(Mesh.Size1), '');
  305.   Result.Add('GeometrySize far',  vtSingle, [], FloatToStr(Mesh.Size2), '');
  307.   Result.Add('TextureV scale',   vtSingle, [], FloatToStr(Mesh.VScale), '');
  308. end;
  310. procedure T3DLine.SetProperties(Properties: Props.TProperties);
  311. var Mesh: T3DLineMesh;
  312. begin
  313.   inherited;
  315.   if not (CurrentTesselator is T3DLineMesh) then Exit;
  316.   Mesh := CurrentTesselator as T3DLineMesh;
  318.   if Properties.Valid('GeometryLength')    then  Mesh.Len := StrToFloatDef(Properties['GeometryLength'], 0);
  320.   SetColorProperty(Properties, 'Color1', Mesh.Color1);
  321.   SetColorProperty(Properties, 'Color2', Mesh.Color2);
  323.   if Properties.Valid('GeometrySize near') then Mesh.Size1 := StrToFloatDef(Properties['GeometrySize near'], 0);
  324.   if Properties.Valid('GeometrySize far')  then Mesh.Size2 := StrToFloatDef(Properties['GeometrySize far'],  0);
  326.   if Properties.Valid('TextureV scale')   then Mesh.VScale := StrToFloatDef(Properties['TextureV scale'], 0);
  328.   Mesh.ModelMatrix := @FTransform;
  330.   CurrentTesselator.Init;
  331. end;
  333. function T3DLine.VisibilityCheck(const Camera: TCamera): Boolean;
  334. begin
  335.   Result := inherited VisibilityCheck(Camera);
  336.   ComputeTransform;
  337. end;
  339. function T3DLine.GetColor1: BaseTypes.TColor;
  340. begin
  341.   if CurrentTesselator is T3DLineMesh then
  342.    Result := (CurrentTesselator as T3DLineMesh).Color1 else
  343.     Result.C := 0;
  344. end;
  346. procedure T3DLine.SetColor1(const Value: BaseTypes.TColor);
  347. begin
  348.   if not (CurrentTesselator is T3DLineMesh) then Exit;
  349.   (CurrentTesselator as T3DLineMesh).Color1 := Value;
  350.   CurrentTesselator.Init;
  351. end;
  353. function T3DLine.GetColor2: BaseTypes.TColor;
  354. begin
  355.   if CurrentTesselator is T3DLineMesh then
  356.    Result := (CurrentTesselator as T3DLineMesh).Color2 else
  357.     Result.C := 0;
  358. end;
  360. procedure T3DLine.SetColor2(const Value: BaseTypes.TColor);
  361. begin
  362.   if not (CurrentTesselator is T3DLineMesh) then Exit;
  363.   (CurrentTesselator as T3DLineMesh).Color2 := Value;
  364.   CurrentTesselator.Init;
  365. end;
  367. procedure T3DLine.SetLength(const Value: Single);
  368. begin
  369.   if not (CurrentTesselator is T3DLineMesh) then Exit;
  370.   (CurrentTesselator as T3DLineMesh).Len := Value;
  371.   CurrentTesselator.Init;
  372. end;
  374. function T3DLine.GetLength: Single;
  375. begin
  376.   if CurrentTesselator is T3DLineMesh then
  377.    Result := (CurrentTesselator as T3DLineMesh).Len else
  378.     Result := 0;
  379. end;
  381. constructor T3DLine.Create(AManager: TItemsManager);
  382. begin
  383.   inherited;
  384. end;
  386. { TBackgroundTesselator }
  388. constructor TBackgroundTesselator.Create;
  389. begin
  390.   inherited;
  391.   Zoom  := 1;
  392.   Cols  := 2;
  393.   Rows  := 2;
  394.   Angle := 0;
  395.   Color.C := $FF808080;
  396.   UOfs := 0;
  397.   VOfs := 0;
  399.   TesselationStatus[tbVertex].TesselatorType := ttDynamic;
  401.   PrimitiveType := ptTRIANGLELIST;
  402.   InitVertexFormat(GetVertexFormat(True, False, True, False, False, 0, [2]));
  404.   Init;
  405. end;
  407. function TBackgroundTesselator.IsSameItem(AItem: TReferencedItem): Boolean;
  408. begin
  409.   Result := False;
  410. end;
  412. procedure TBackgroundTesselator.Init;
  413. begin
  414.   inherited;
  415.   TotalVertices    := (Cols)*(Rows);
  416.   TotalIndices     := (Rows-1)*(Cols-1)*2*3;
  417.   TotalPrimitives  := (Rows-1)*(Cols-1)*2;
  418.   IndexingVertices := TotalVertices;
  420.   Invalidate([tbVertex, tbIndex], True);
  421. end;
  423. procedure TBackgroundTesselator.AddProperties(const Result: Props.TProperties; const PropNamePrefix: TNameString);
  424. begin
  425.   inherited;
  426.   if not Assigned(Result) then Exit;
  427.   Result.Add(PropNamePrefix + 'Columns',  vtNat,    [], IntToStr(Cols), '');
  428.   Result.Add(PropNamePrefix + 'Rows',     vtNat,    [], IntToStr(Rows), '');
  429.   Result.Add(PropNamePrefix + 'U offset', vtSingle, [], FloatToStr(UOfs), '');
  430.   Result.Add(PropNamePrefix + 'V offset', vtSingle, [], FloatToStr(VOfs), '');
  431. end;
  433. procedure TBackgroundTesselator.SetProperties(Properties: Props.TProperties; const PropNamePrefix: TNameString);
  434. begin
  435.   inherited;
  436.   if Properties.Valid(PropNamePrefix + 'Columns')  then Cols := StrToIntDef(Properties[PropNamePrefix + 'Columns'], 0);
  437.   if Properties.Valid(PropNamePrefix + 'Rows')     then Rows := StrToIntDef(Properties[PropNamePrefix + 'Rows'],    0);
  438.   if Properties.Valid(PropNamePrefix + 'U offset') then UOfs := StrToFloatDef(Properties[PropNamePrefix + 'U offset'], 0);
  439.   if Properties.Valid(PropNamePrefix + 'V offset') then VOfs := StrToFloatDef(Properties[PropNamePrefix + 'V offset'], 0);
  440. end;
  442. function TBackgroundTesselator.Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer;
  443. var
  444.   i, j: Integer;
  445.   OOZoom, OOCols, OORows: Single;
  446. begin
  447.   Result := 0;
  448.   if (Cols < 2) or (Rows < 2) then Exit;
  449.   OOZoom := 1/Zoom; OOCols := 1/(Cols-1); OORows := 1/(Rows-1);     // Some optimizations
  450.   for j := 0 to Rows-1 do for i := 0 to Cols-1 do begin
  451.     SetVertexDataCRHW((i * OOCols) * Params.Camera.RenderWidth, (j * OORows) * Params.Camera.RenderHeight, 0, 0.001, j*Cols+i, VBPTR);
  452.     SetVertexDataD(Color, j*Cols+i, VBPTR);
  453.     SetVertexDataUV( ( (i * OOCols) * SinTable[(Angle + CosTabOffs) and (SinTableSize-1)] +
  454.                        (j * OORows) * SinTable[(Angle) and (SinTableSize-1)] ) * OOZoom + UOfs,
  455.                      ( (j * OORows) * SinTable[(Angle + CosTabOffs) and (SinTableSize-1)] -
  456.                        (i * OOCols) * SinTable[(Angle) and (SinTableSize-1)] ) * OOZoom + VOfs,
  457.                      j*Cols+i, VBPTR);
  458.   end;
  459.   TesselationStatus[tbVertex].Status := tsTesselated;
  460.   Result := TotalVertices;
  461.   LastTotalVertices := TotalVertices;
  462. end;
  464. function TBackgroundTesselator.SetIndices(IBPTR: Pointer): Integer;
  465. var i, j: Integer;
  466. begin
  467.   for j := 0 to Rows-2 do begin
  468.     for i := 0 to Cols-2 do begin
  469.       TWordBuffer(IBPTR^)[(j*(Cols-1)+i)*6+0] := (j+0)*(Cols)+i;
  470.       TWordBuffer(IBPTR^)[(j*(Cols-1)+i)*6+1] := (j+0)*(Cols)+i+1;
  471.       TWordBuffer(IBPTR^)[(j*(Cols-1)+i)*6+2] := (j+1)*(Cols)+i;
  472.       TWordBuffer(IBPTR^)[(j*(Cols-1)+i)*6+3] := (j+1)*(Cols)+i;
  473.       TWordBuffer(IBPTR^)[(j*(Cols-1)+i)*6+4] := (j+0)*(Cols)+i+1;
  474.       TWordBuffer(IBPTR^)[(j*(Cols-1)+i)*6+5] := (j+1)*(Cols)+i+1
  475.     end;
  476.   end;
  477.   TesselationStatus[tbIndex].Status := tsTesselated;
  478.   Result := TotalIndices;
  479. end;
  481. { TFader }
  483. procedure TFader.SetColor(const Value: BaseTypes.TColor);
  484. var Mesh: TBackgroundTesselator;
  485. begin
  486.   if CurrentTesselator is TBackgroundTesselator then
  487.     Mesh := CurrentTesselator as TBackgroundTesselator
  488.   else
  489.     Exit;
  490.   Mesh.Color := Value;
  491.   Mesh.Invalidate([tbVertex], False);
  492. end;
  494. constructor TFader.Create(AManager: TItemsManager);
  495. begin
  496.   inherited;
  497.   Colors := TSampledGradient.Create;
  498.   Colors.MaxX := 2;
  499. end;
  501. destructor TFader.Destroy;
  502. begin
  503.   FreeAndNil(Colors);
  504.   inherited;
  505. end;
  507. function TFader.GetTesselatorClass: CTesselator; begin Result := TBackgroundTesselator; end;
  509. function TFader.VisibilityCheck(const Camera: TCamera): Boolean;
  510. begin
  511.   Result := True;
  512. end;
  514. procedure TFader.Show;
  515. begin
  516.   inherited;
  517.   ResetProcessedTime();
  518.   Resume();
  519.   AutoStopNeeded := AutoStop;
  520. end;
  522. procedure TFader.AddProperties(const Result: Props.TProperties);
  523. begin
  524.   inherited;
  525.   if not Assigned(Result) then Exit;
  526.   Colors.AddAsProperty(Result, 'Color');
  527.   Result.Add('Auto stop', vtBoolean, [], OnOffStr[AutoStop], '');
  528. end;
  530. procedure TFader.SetProperties(Properties: Props.TProperties);
  531. begin
  532.   inherited;
  533.   Colors.SetFromProperty(Properties, 'Color');
  534.   if Properties.Valid('Auto stop') then AutoStop := Properties.GetAsInteger('Auto stop') > 0;
  535. end;
  537. procedure TFader.Process(const DeltaT: Single);
  538. begin
  539.   inherited;
  540.   SetColor(Colors.Value[TimeProcessed]);
  541.   if AutoStopNeeded and (TimeProcessed > Colors.MaxX * 0.5) then begin
  542.     Pause();
  543.     AutoStopNeeded := False;
  544.   end;
  545. end;
  547. { TBackground }
  549. function TBackground.GetAngle: Integer;
  550. begin
  551.   if CurrentTesselator is TBackgroundTesselator then Result := TBackgroundTesselator(CurrentTesselator).Angle else Result := 0;
  552. end;
  554. function TBackground.GetColor: BaseTypes.TColor;
  555. begin
  556.   if CurrentTesselator is TBackgroundTesselator then Result := TBackgroundTesselator(CurrentTesselator).Color else Result.C := $FF808080;
  557. end;
  559. function TBackground.GetZoom: Single;
  560. begin
  561.   if CurrentTesselator is TBackgroundTesselator then Result := TBackgroundTesselator(CurrentTesselator).Zoom else Result := 1;
  562. end;
  564. procedure TBackground.SetAngle(const Value: Integer);
  565. begin
  566.   if CurrentTesselator is TBackgroundTesselator then (CurrentTesselator as TBackgroundTesselator).Angle := Value;
  567.   CurrentTesselator.Init;
  568. end;
  570. procedure TBackground.SetColor(const Value: BaseTypes.TColor);
  571. begin
  572.   if CurrentTesselator is TBackgroundTesselator then (CurrentTesselator as TBackgroundTesselator).Color := Value;
  573.   CurrentTesselator.Init;
  574. end;
  576. procedure TBackground.SetZoom(const Value: Single);
  577. begin
  578.   if CurrentTesselator is TBackgroundTesselator then (CurrentTesselator as TBackgroundTesselator).Zoom := Value;
  579.   CurrentTesselator.Init;
  580. end;
  582. constructor TBackground.Create(AManager: TItemsManager);
  583. begin
  584.   inherited;
  585. end;
  587. function TBackground.GetTesselatorClass: CTesselator; begin Result := TBackgroundTesselator; end;
  589. function TBackground.VisibilityCheck(const Camera: TCamera): Boolean;
  590. begin
  591.   Result := True;
  592. end;
  594. procedure TBackground.AddProperties(const Result: Props.TProperties);
  595. var Mesh: TBackgroundTesselator;
  596. begin
  597.   inherited;
  598.   if not Assigned(Result) then Exit;
  599.   if CurrentTesselator is TBackgroundTesselator then Mesh := CurrentTesselator as TBackgroundTesselator else begin
  600.     AddErrorProperty(Result, 'Tesselator is undefined');
  601.     Exit;
  602.   end;
  604.   AddColorProperty(Result, 'Color', Mesh.Color);
  605.   Result.Add('Angle',   vtInt,    [], IntToStr(Mesh.Angle), '');
  606.   Result.Add('Zoom',    vtSingle, [], FloatToStr(Mesh.Zoom), '');
  607. end;
  609. procedure TBackground.SetProperties(Properties: Props.TProperties);
  610. var Mesh: TBackgroundTesselator;
  611. begin
  612.   inherited;
  613.   if CurrentTesselator is TBackgroundTesselator then Mesh := CurrentTesselator as TBackgroundTesselator else Exit;
  615.   SetColorProperty(Properties, 'Color', Mesh.Color);
  616.   if Properties.Valid('Angle')   then Mesh.Angle := StrToIntDef(Properties['Angle'],   0);
  617.   if Properties.Valid('Zoom')    then Mesh.Zoom  := StrToFloatDef(Properties['Zoom'],  0);
  619.   Mesh.Init;
  620. end;
  622. { TBillboardMesh }
  624. constructor TBillboardMesh.Create;
  625. begin
  626.   inherited;
  627.   TesselationStatus[tbVertex].TesselatorType := ttDynamic;
  628.   PrimitiveType := ptTRIANGLESTRIP;
  629.   InitVertexFormat(GetVertexFormat(True, False, True, False, False, 0, [2]));
  631.   TotalIndices    := 0;
  632.   TotalVertices   := 4;
  633.   TotalPrimitives := 2;
  634.   IndexingVertices := 4;
  636.   Invalidate([tbVertex, tbIndex], True);
  638.   MaxFrame := 0;
  639.   UVMap := GetDefaultUVMap;
  640. end;
  642. procedure TBillboardMesh.AddProperties(const Result: Props.TProperties; const PropNamePrefix: TNameString);
  643. begin
  644.   inherited;
  645.   if not Assigned(Result) then Exit;
  646.   Result.Add(PropNamePrefix + 'Width',  vtSingle, [], FloatToStr(FWidth), '');
  647.   Result.Add(PropNamePrefix + 'Height', vtSingle, [], FloatToStr(FHeight), '');
  648.   Result.Add('Frame', vtInt, [], IntToStr(FFrame), '0-' + IntToStr(MaxFrame));
  649.   AddColorProperty(Result, PropNamePrefix + 'Color', FColor);
  650. end;
  652. procedure TBillboardMesh.SetProperties(Properties: Props.TProperties; const PropNamePrefix: TNameString);
  653. begin
  654.   inherited;
  655.   if Properties.Valid(PropNamePrefix + 'Width')  then FWidth  := StrToFloatDef(Properties[PropNamePrefix + 'Width'],  0);
  656.   if Properties.Valid(PropNamePrefix + 'Height') then FHeight := StrToFloatDef(Properties[PropNamePrefix + 'Height'], 0);
  657.   if Properties.Valid('Frame') then FFrame := StrToIntDef(Properties['Frame'], 0);
  658.   SetColorProperty(Properties, PropNamePrefix + 'Color', FColor);
  659. end;
  661. function TBillboardMesh.Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer;
  662. var Transformed: TVector4s; Location: TVector3s; TRHW, SizeX, SizeY: Single;
  663. begin
  664.   Result := 0;
  665.   LastTotalVertices := 0;
  667.   if FFrame > MaxFrame then Exit;
  669. //  Location := Transform4Vector33s({InvertAffineMatrix4s(} Params.Camera.ViewMatrix, Vec3s(0, 0, 0));
  670.   with Params.ModelMatrix do Location := GetVector3s(_41, _42, _43);
  672.   Transformed := Transform4Vector3s(Params.Camera.TotalMatrix, Location);
  673.   if Transformed.W < epsilon then Exit;
  675.   TRHW := 1/Transformed.W;
  676.   SizeX := Params.Camera.RenderWidth *0.5;
  677.   SizeY := Params.Camera.RenderHeight*0.5;
  679.   Transformed.X := SizeX * (1 + Transformed.X * TRHW);
  680.   Transformed.Y := SizeY * (1 - Transformed.Y * TRHW);
  682.   SizeX := FWidth  * TRHW * SizeX;
  683.   SizeY := FHeight * TRHW * SizeY * Params.Camera.CurrentAspectRatio;
  685.   with Params.Camera do Transformed.Z := 0.002+0*(ZFar/(ZFar-ZNear))*(1-ZNear/(Transformed.Z));
  687.   SetVertexDataCRHW(Transformed.X - SizeX, Transformed.Y - SizeY, Transformed.Z, TRHW, 0, VBPTR);
  688.   SetVertexDataD(FColor, 0, VBPTR);
  689.   SetVertexDataUV(UVMap[FFrame].U, UVMap[FFrame].V, 0, VBPTR);
  691.   SetVertexDataCRHW(Transformed.X + SizeX, Transformed.Y - SizeY, Transformed.Z, TRHW, 1, VBPTR);
  692.   SetVertexDataD(FColor, 1, VBPTR);
  693.   SetVertexDataUV(UVMap[FFrame].U + UVMap[FFrame].W, UVMap[FFrame].V, 1, VBPTR);
  695.   SetVertexDataCRHW(Transformed.X - SizeX, Transformed.Y + SizeY, Transformed.Z, TRHW, 2, VBPTR);
  696.   SetVertexDataD(FColor, 2, VBPTR);
  697.   SetVertexDataUV(UVMap[FFrame].U, UVMap[FFrame].V + UVMap[FFrame].H, 2, VBPTR);
  699.   SetVertexDataCRHW(Transformed.X + SizeX, Transformed.Y + SizeY, Transformed.Z, TRHW, 3, VBPTR);
  700.   SetVertexDataD(FColor, 3, VBPTR);
  701.   SetVertexDataUV(UVMap[FFrame].U + UVMap[FFrame].W, UVMap[FFrame].V + UVMap[FFrame].H, 3, VBPTR);
  703.   TesselationStatus[tbVertex].Status := tsChanged;            // The vertex buffer should be updated every frame
  705.   LastTotalVertices := 4;
  706.   Result := LastTotalVertices;
  707. end;
  709. procedure TBillboardMesh.SetFrame(const Value: Integer);
  710. begin
  711.   if (Value = FFrame) then Exit;
  712.   FFrame := ClampI(Value, 0, MaxFrame);
  713. end;
  715. { TBillboard }
  717. constructor TBillboard.Create(AManager: TItemsManager);
  718. begin
  719.   inherited;
  720. end;
  722. function TBillboard.GetTesselatorClass: CTesselator; begin Result := TBillboardMesh; end;
  724. function TBillboard.VisibilityCheck(const Camera: TCamera): Boolean;
  725. begin
  726.   Result := True;                    // ToFix: cull out when behind camera
  727. end;
  729. procedure TBillboard.ResolveLinks;
  730. var Item: TItem; Mesh: TBillboardMesh;
  731. begin
  732.   inherited;
  733.   if CurrentTesselator is TBillboardMesh then Mesh := CurrentTesselator as TBillboardMesh else Exit;
  735.   ResolveLink('UV map', Item);
  736.   if Assigned(Item) then begin
  737.     Mesh.UVMap    := (Item as TUVMapResource).Data;
  738.     Mesh.MaxFrame := (Item as TUVMapResource).TotalElements-1;
  739.   end;
  740. end;
  742. procedure TBillboard.Process(const DeltaT: Single);
  743. var Mesh: TBillboardMesh; NewFrame: Integer;
  744. begin
  745.   inherited;
  746.   AnimTime := AnimTime + DeltaT;
  747.   if CurrentTesselator is TBillboardMesh then begin
  748.     Mesh := CurrentTesselator as TBillboardMesh;
  749.     NewFrame := Round(AnimTime * AnimRate);
  750.     if (Mesh.MaxFrame >= 0) and (NewFrame > Mesh.MaxFrame) then begin
  751.       if AnimRepeat then Mesh.Frame := NewFrame mod (Mesh.MaxFrame+1);
  752.       if HideAtEnd  then State := State - [isVisible];
  753.     end else Mesh.Frame := NewFrame
  754.   end;
  755. end;
  757. procedure TBillboard.AddProperties(const Result: Props.TProperties);
  758. begin
  759.   inherited;
  760.   AddItemLink(Result, 'UV map',  [], 'TUVMapResource');
  762.   if not Assigned(Result) then Exit;
  763.   if not (CurrentTesselator is TBillboardMesh) then begin
  764.     AddErrorProperty(Result, 'Tesselator is undefined');
  765.     Exit;
  766.   end;
  768.   Result.Add('Animation rate',  vtSingle,  [], FloatToStr(AnimRate), '');
  769.   Result.Add('Animation cycle', vtBoolean, [], OnOffStr[AnimRepeat], '');
  770.   Result.Add('Hide at end',     vtBoolean, [], OnOffStr[HideAtEnd],  '');
  771. end;
  773. procedure TBillboard.SetProperties(Properties: Props.TProperties);
  774. begin
  775.   inherited;
  776.   if Properties.Valid('UV map') then SetLinkProperty('UV map', Properties['UV map']);
  778.   if Properties.Valid('Animation rate')  then begin
  779.     AnimRate := StrToFloatDef(Properties['Animation rate'], 0);
  780.     AnimTime := 0;
  781.   end;  
  782.   if Properties.Valid('Animation cycle') then Animrepeat := Properties.GetAsInteger('Animation cycle') > 0;
  783.   if Properties.Valid('Hide at end')     then HideAtEnd  := Properties.GetAsInteger('Hide at end')     > 0;
  784. end;
  786. { TSplashTesselator }
  788. constructor TSplashTesselator.Create;
  789. begin
  790.   inherited;
  791.   PrimitiveType    := ptTRIANGLESTRIP;
  792.   InitVertexFormat(GetVertexFormat(False, False, True, False, False, 0, [2]));
  794.   TotalVertices    := 4;
  795.   TotalPrimitives  := 2;
  797.   Color.C  := $80808080;
  798.   Size     := 1;
  799. end;
  801. function TSplashTesselator.IsSameItem(AItem: TReferencedItem): Boolean;
  802. begin
  803.   Result := False;
  804. end;
  806. function TSplashTesselator.GetBoundingBox: TBoundingBox;
  807. begin
  808.   Result.P1 := GetVector3s(-Size, -Size, 0);
  809.   Result.P2 := GetVector3s( Size,  Size, 0);
  810. end;
  812. function TSplashTesselator.Tesselate(const Params: TTesselationParameters; VBPTR: Pointer): Integer;
  813. begin
  814.   SetVertexDataC(-Size, Size, 0, 0, VBPTR);
  815.   SetVertexDataUV(0, 0, 0, VBPTR);
  816.   SetVertexDataD(Color, 0, VBPTR);
  818.   SetVertexDataC(Size, Size, 0, 1, VBPTR);
  819.   SetVertexDataUV(1, 0, 1, VBPTR);
  820.   SetVertexDataD(Color, 1, VBPTR);
  822.   SetVertexDataC(-Size, -Size, 0, 2, VBPTR);
  823.   SetVertexDataUV(0, 1, 2, VBPTR);
  824.   SetVertexDataD(Color, 2, VBPTR);
  826.   SetVertexDataC(Size, -Size, 0, 3, VBPTR);
  827.   SetVertexDataUV(1, 1, 3, VBPTR);
  828.   SetVertexDataD(Color, 3, VBPTR);
  830.   TesselationStatus[tbVertex].Status := tsTesselated;
  831.   LastTotalVertices := TotalVertices;
  832.   Result            := TotalVertices;
  833. end;
  835. { TSplash }
  837. constructor TSplash.Create(AManager: TItemsManager);
  838. begin
  839.   inherited;
  840.   Color := TSampledGradient.Create;
  841.   Size  := TSampledFloats.Create;
  842. end;
  844. destructor TSplash.Destroy;
  845. begin
  846.   FreeAndNil(Color);
  847.   FreeAndNil(Size);
  848.   inherited;
  849. end;
  851. function TSplash.GetTesselatorClass: CTesselator; begin Result := TSplashTesselator; end;
  853. procedure TSplash.AddProperties(const Result: Props.TProperties);
  855. begin
  856.   inherited;
  857.   if not Assigned(Result) then Exit;
  858.   Color.AddAsProperty(Result, 'Color');
  859.   Size.AddAsProperty(Result, 'Size');
  860. end;
  862. procedure TSplash.SetProperties(Properties: Props.TProperties);
  863. begin
  864.   inherited;
  865.   Color.SetFromProperty(Properties, 'Color');
  866.   Size.SetFromProperty(Properties, 'Size');
  867.   SetMesh;
  868.   ResetProcessedTime;
  869. end;
  871. procedure TSplash.Process(const DeltaT: Single);
  872. var Tesselator: TSplashTesselator;
  873. begin
  874.   inherited;
  875.   if not (CurrentTesselator is TSplashTesselator) then Exit;
  876.   Tesselator := CurrentTesselator as TSplashTesselator;
  877.   Tesselator.Color := Color.Value[TimeProcessed];
  878.   Tesselator.Size  := Size.Value[TimeProcessed];
  879.   Tesselator.Invalidate([tbVertex], False);
  880. end;
  882. begin
  883.   GlobalClassList.Add('C2FX', GetUnitClassList);
  884. end.