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

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

游戏引擎

开发平台：

Delphi

C2Core.pas：源码内容
  1. (*
  2.  @Abstract(CAST II Engine core 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 engine core classes
  6. *)
  7. {$Include GDefines.inc}
  8. {$Include C2Defines.inc}
  9. unit C2Core;
  11. interface
  13. uses
  14.   TextFile,
  15.   SysUtils,
  16.   BaseTypes, Basics, Base3D, Timer, OSUtils, BaseClasses, BaseMsg, ItemMsg, BaseGraph, Resources,
  17.   OTypes,
  18.   C2Types, C2Msg, C2Res, CAST2, C2Visual, C2Render, C2Materials, Input;
  20. const
  21.     // script data types
  22.   // 4x4 matrix
  23.   tidMatrix4x4 = 0;
  24.   // Vector
  25.   tidVector4 = 1;
  27. type
  28.   // Sorted items data structure for internal use
  29.   TVisItem = record
  30.     PassIndex, ItemIndex: Word;
  31.   end;
  32.   TSortedItems = array of TVisItem;
  34.   // Temporary class to parse shader constant definitions. Should be replaced with fully-featured script-based implementation.
  35.   TSimpleParser = class(TAbstractCompiler)
  36.     // Simply recognizes some predefined keywords
  37.     function Compile(const Source: AnsiString): OTypes.TRTData; override;
  38.   end;
  40.   // Core class reference
  41.   CCore = class of TCore;
  42.   { @Abstract(Engine core class)
  43.     This class manages subsystems, controls items processing and rendering.
  44.     Its <b>Process()</b> method should be called in main application cycle. }
  45.   TCore = class(TBaseCore)
  46.   private
  47.     FRenderer: C2Render.TRenderer;
  48.     FInput: Input.TController;
  50.     RenderItems: TItems; TotalRenderItems: Integer;
  51.     Lights: TItems; TotalLights: Integer;
  53.     FPSCountEventID: TEventID;
  54.     FFPSCountTimeout, OneOverFPSCountTimeout, LastFPSCountFrame: TTimeUnit;
  56.     LastProcessingTime: array of TTimeUnit;
  58.     SortedItems: TSortedItems;
  60.     Passes: array of TRenderPass; TotalPasses: Integer;                // Sorted passes
  62.     procedure FPSCountEvent(EventID: Integer; const ErrorDelta: TTimeUnit);
  63.     procedure SetFPSCountTimeout(const Value: TTimeUnit);
  65.     procedure SetInput(const Value: Input.TController);
  66.     procedure SetRenderer(const Value: C2Render.TRenderer);
  67.     
  68.     procedure SetShaderConstants(const Pass: TRenderPass; Item: TVisible);
  70.     procedure ResetTechnique(const AMaterial: TMaterial);
  72.     procedure Render(const ThroughCamera, Camera: TCamera; RecursionCounter: Integer);
  73.   protected
  74.     // Clears garbage data. Called automatically
  75.     procedure CollectGarbage; override;
  76.     // Performs clean-up before destruction
  77.     procedure OnDestroy; override;
  78.   public
  79.     // Default material
  80.     DefaultMaterial: TMaterial;
  81.     // If <b>True</b> all input item generate messages not only explicitly bound ones
  82.     CatchAllInput: Boolean;
  84.     constructor Create; override;
  86.     // For internal use only.
  87.     procedure AddPass(const Item: TItem); override;
  88.     // For internal use only.
  89.     procedure RemovePass(const Item: TItem); override;
  91.     procedure HandleMessage(const Msg: TMessage); override;
  93.     // Finds in current scene and applies first found camera with <b>Default</b> property set to <b>True</b>
  94.     procedure ApplyDefaultCamera;
  96.     // Clears current scene
  97.     procedure ClearItems; override;
  99.     // Traces the given ray with the given depth and returns a list of items hit sorted by distance <b>not implemented yet</b>
  100.     function TraceRay(const Ray: TVector3s; Depth: Single; out Items: TItems): Integer;
  102.     // Performs main engine cycle. Items processing, rendering, collision, input, etc. Should be called from main application cycle.
  103.     procedure Process;
  105.     // Renderer subsystem
  106.     property Renderer: C2Render.TRenderer read FRenderer write SetRenderer;
  107.     // Input subsystem
  108.     property Input: Input.TController     read FInput    write SetInput;
  109.     // Time to average frame rate through
  110.     property FPSCountTimeout: TTimeUnit read FFPSCountTimeout write SetFPSCountTimeout;
  111.   end;
  113.   // Returns list of classes introduced by the unit
  114.   function GetUnitClassList: TClassArray;
  116. implementation
  118. function GetUnitClassList: TClassArray;
  119. begin
  120.   Result := GetClassList([TProcessing, TCamera, TMirrorCamera, TLookAtCamera, TLight,
  121.                           TMaterial, TTechnique, TRenderPass]);
  122. end;
  124. { TCore }
  126. const PassesCapacityStep = 4;
  128. procedure TCore.OnDestroy;
  129. var i: Integer;
  130. begin
  131.   if Assigned(DefaultMaterial) then begin
  132.     for i := 0 to DefaultMaterial.TotalTechniques-1 do begin
  133.       DefaultMaterial.Technique[i].Passes[0].Free;
  134.       DefaultMaterial.Technique[i].Free;
  135.     end;
  136.     FreeAndNil(DefaultMaterial);
  137.   end;
  138.   FreeAndNil(FTempItems);
  139.   FreeAndNil(Compiler);
  140.   inherited;
  141. end;
  143. procedure TCore.FPSCountEvent(EventID: Integer; const ErrorDelta: TTimeUnit);
  144. begin
  145.   PerfProfile.FramesPerSecond := (Renderer.FramesRendered - LastFPSCountFrame) * OneOverFPSCountTimeout;
  146.   LastFPSCountFrame := Renderer.FramesRendered;
  147. end;
  149. procedure TCore.SetFPSCountTimeout(const Value: TTimeUnit);
  150. begin
  151.   FFPSCountTimeout       := Value;
  152.   OneOverFPSCountTimeout := 1/Value;
  153.   if FPSCountEventID = eIDNone then
  154.     FPSCountEventID := Timer.SetRecurringEvent(FFPSCountTimeout, FPSCountEvent, 0)
  155.   else
  156.     Timer.SetRecurringEventInterval(FPSCountEventID, FFPSCountTimeout);
  157. end;
  159. procedure TCore.SetInput(const Value: Input.TController);
  160. begin
  161.   if Assigned(FInput) then RemoveSubsystem(FInput);
  162.   FInput := Value;
  163.   if Assigned(FInput) then AddSubsystem(FInput);
  164. end;
  166. procedure TCore.SetRenderer(const Value: C2Render.TRenderer);
  167. begin
  168.   if Assigned(FRenderer) then RemoveSubsystem(FRenderer);
  169.   FRenderer := Value;
  170.   if Assigned(FRenderer) then begin
  171.     AddSubsystem(FRenderer);
  172.     FRenderer.SetPerfProfile(PerfProfile);
  173.   end;
  175.   FTempItems := TTemporaryVisible.Create(Self);
  176. end;
  178. procedure TCore.SetShaderConstants(const Pass: TRenderPass; Item: TVisible);
  179. var i, RegI: Integer;
  181.   function SetConstant(ShaderKind: TShaderKind; BaseRegIndex: Integer; DataDesc: Integer): Integer;            // Dummy code to replace with fully-functional script
  182.   const ZeroPosition: TVector4s = (X: 0; Y: 0; Z: 0; W: 1);
  183.   const ZeroVector:   TVector4s = (X: 0; Y: 0; Z: 0; W: 0);
  184.   var M: TMatrix4s;
  185.   begin
  186.     Result := 1;
  187.     case DataDesc of
  188.       0: begin              // Model matrix
  189.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+0, GetVector4s(Item.Transform._11, Item.Transform._21, Item.Transform._31, Item.Transform._41));
  190.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+1, GetVector4s(Item.Transform._12, Item.Transform._22, Item.Transform._32, Item.Transform._42));
  191.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+2, GetVector4s(Item.Transform._13, Item.Transform._23, Item.Transform._33, Item.Transform._43));
  192.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+3, GetVector4s(Item.Transform._14, Item.Transform._24, Item.Transform._34, Item.Transform._44));
  193.         Result := 4;
  194.       end;
  195.       1: begin              // View matrix
  196.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+0, GetVector4s(Renderer.LastAppliedCamera.ViewMatrix._11, Renderer.LastAppliedCamera.ViewMatrix._21, Renderer.LastAppliedCamera.ViewMatrix._31, Renderer.LastAppliedCamera.ViewMatrix._41));
  197.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+1, GetVector4s(Renderer.LastAppliedCamera.ViewMatrix._12, Renderer.LastAppliedCamera.ViewMatrix._22, Renderer.LastAppliedCamera.ViewMatrix._32, Renderer.LastAppliedCamera.ViewMatrix._42));
  198.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+2, GetVector4s(Renderer.LastAppliedCamera.ViewMatrix._13, Renderer.LastAppliedCamera.ViewMatrix._23, Renderer.LastAppliedCamera.ViewMatrix._33, Renderer.LastAppliedCamera.ViewMatrix._43));
  199.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+3, GetVector4s(Renderer.LastAppliedCamera.ViewMatrix._14, Renderer.LastAppliedCamera.ViewMatrix._24, Renderer.LastAppliedCamera.ViewMatrix._34, Renderer.LastAppliedCamera.ViewMatrix._44));
  200.         Result := 4;
  201.       end;
  202.       2: begin              // Projection matrix
  203.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+0, GetVector4s(Renderer.LastAppliedCamera.ProjMatrix._11, Renderer.LastAppliedCamera.ProjMatrix._21, Renderer.LastAppliedCamera.ProjMatrix._31, Renderer.LastAppliedCamera.ProjMatrix._41));
  204.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+1, GetVector4s(Renderer.LastAppliedCamera.ProjMatrix._12, Renderer.LastAppliedCamera.ProjMatrix._22, Renderer.LastAppliedCamera.ProjMatrix._32, Renderer.LastAppliedCamera.ProjMatrix._42));
  205.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+2, GetVector4s(Renderer.LastAppliedCamera.ProjMatrix._13, Renderer.LastAppliedCamera.ProjMatrix._23, Renderer.LastAppliedCamera.ProjMatrix._33, Renderer.LastAppliedCamera.ProjMatrix._43));
  206.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+3, GetVector4s(Renderer.LastAppliedCamera.ProjMatrix._14, Renderer.LastAppliedCamera.ProjMatrix._24, Renderer.LastAppliedCamera.ProjMatrix._34, Renderer.LastAppliedCamera.ProjMatrix._44));
  207.         Result := 4;
  208.       end;
  209.       3: begin              // Model*View matrix
  210.         M := GetTransposedMatrix4s(MulMatrix4s(Item.Transform, Renderer.LastAppliedCamera.ViewMatrix));
  211.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+0, M.Rows[0]);
  212.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+1, M.Rows[1]);
  213.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+2, M.Rows[2]);
  214.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+3, M.Rows[3]);
  215.         Result := 4;
  216.       end;
  217.       4: begin              // Model*View*Projection matrix
  218.         M := GetTransposedMatrix4s(MulMatrix4s(Item.Transform, Renderer.LastAppliedCamera.TotalMatrix));
  219.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+0, M.Rows[0]);
  220.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+1, M.Rows[1]);
  221.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+2, M.Rows[2]);
  222.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex+3, M.Rows[3]);
  223.         Result := 4;
  224.       end;
  226.       5: if TotalLights > 0 then        // Light[0].Position
  227.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, TLight(Lights[0]).Transform.ViewTranslate4s) else
  228.           Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, ZeroPosition);
  229.       6: if TotalLights > 0 then        // Light[0].Direction
  230.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, TLight(Lights[0]).Transform.ViewForward4s) else
  231.           Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, ZeroVector);
  233.       7: if TotalLights > 0 then        // Light[0].Ambient
  234.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, TLight(Lights[0]).Ambient.RGBA) else
  235.           Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, ZeroVector);
  236.       8: if TotalLights > 0 then        // Light[0].Diffuse
  237.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, TLight(Lights[0]).Diffuse.RGBA) else
  238.           Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, ZeroVector);
  239.       9: if TotalLights > 0 then        // Light[0].Specular
  240.         Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, TLight(Lights[0]).Specular.RGBA) else
  241.           Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, ZeroVector);
  242.       10: Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, Pass.Ambient.RGBA); // Material.Ambient
  244.       11: Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, Pass.Diffuse.RGBA); // Material.Diffuse
  245.       12: Renderer.APIState.SetShaderConstant(ShaderKind, BaseRegIndex, Pass.Specular.RGBA); // Material.Specular
  246.     end;
  247.   end;
  249. begin
  250.   RegI := 0;
  251.   for i := 0 to Pass.TotalVertexShaderConstants-1 do if Assigned(Pass.CompiledVertexShaderConstants[i]) then
  252.     Inc(RegI, SetConstant(skVertex, RegI, Pass.CompiledVertexShaderConstants[i].PIN[0]));
  254.   RegI := 0;
  255.   for i := 0 to Pass.TotalPixelShaderConstants-1 do if Assigned(Pass.CompiledPixelShaderConstants[i]) then
  256.     Inc(RegI, SetConstant(skPixel, RegI, Pass.CompiledPixelShaderConstants[i].PIN[0]));
  257. end;
  259. procedure TCore.Render(const ThroughCamera, Camera: TCamera; RecursionCounter: Integer);
  260. var PassIndex, FirstSortedPass, LastSortedPass: Integer; 
  262.   procedure RenderItem(APass: TRenderPass; AItem: TVisible);
  263.   var l, CurLight: Integer;
  264.   begin
  265.     Inc(PerfProfile.FrustumPassedItems);
  266.     CurLight := 0;
  267.     if APass.LightingState.Enabled and not AItem.CustomLighting then begin
  268.       for l := 0 to TotalLights-1 do
  269.         if TLight(Lights[l]).Enabled and (APass.Group in TLight(Lights[l]).GroupMask) and
  270.            (Sqr(TLight(Lights[l]).Range + AItem.BoundingSphereRadius) >
  271.             SqrMagnitude(SubVector3s(TLight(Lights[l]).GetAbsLocation, AItem.GetAbsLocation))) then begin
  272.           Renderer.ApplyLight(CurLight, TLight(Lights[l]));
  273.           Inc(CurLight);
  274.           if CurLight >= SimultaneousLightSources then Break;
  275.         end;
  276.       for l := CurLight to Renderer.MaxAPILights-1 do Renderer.ApplyLight(l, nil);
  277.     end else if AItem.CustomLighting then begin
  278.       AItem.BeginLighting;
  279.       for l := 0 to TotalLights-1 do
  280.         if TLight(Lights[l]).Enabled and (APass.Group in TLight(Lights[l]).GroupMask) and
  281.            (Sqr(TLight(Lights[l]).Range + AItem.BoundingSphereRadius) >
  282.             SqrMagnitude(SubVector3s(TLight(Lights[l]).GetAbsLocation, AItem.GetAbsLocation))) then begin
  283.           if AItem.CalculateLighting(TLight(Lights[l])) then Inc(CurLight);
  284.           if CurLight >= SimultaneousLightSources then Break;
  285.         end;
  286.     end;
  288.     Renderer.APIState.ApplyCustomTextureMatrices(APass, AItem);
  290.     SetShaderConstants(APass, AItem);
  292.     Renderer.RenderItem(AItem);
  294.     Assert(isVisible in AItem.State, ClassName + '.Render: Rendering an invisible item "' + AItem.GetFullName + '"');
  295.   end;
  297.   procedure AddSortedPass(APass: TRenderPass);
  298.   begin
  299.     if FirstSortedPass < 0 then FirstSortedPass := PassIndex;
  300.     LastSortedPass := PassIndex;
  301.   end;
  303.   procedure DrawSortedPasses;
  304.   var TotalSortedItems: Integer;
  306.     type _QSDataType = TVisItem; _QSValueType = Single;
  307.     procedure SortItems(N: Integer; Values: TSortedItems);
  309.       function _QSGetValue(const V: _QSDataType): _QSValueType;
  310.       begin
  311.         Result := TVisible(Passes[V.PassIndex].Items[V.ItemIndex]).SortValue;
  312.       end;
  314.     {$DEFINE COMPUTABLE}                                 // Set a sort algorithm on computable items
  315.     {$I basics_quicksort.inc}                            // Include the quick sort algorithm
  316.     {$IFNDEF ForCodeNavigationWork} begin end; {$ENDIF}  // Needed for code navigation features to work in Delphi 7
  318.   var i, j: Integer;
  319.   begin
  320.     TotalSortedItems := 0;
  321.     for i := FirstSortedPass to LastSortedPass do for j := 0 to Passes[i].TotalItems-1 do if TVisible(Passes[i].Items[j]).VisibilityCheck(Camera) then begin
  322.       TVisible(Passes[i].Items[j]).CalcSortValue(Camera);
  323.       TVisible(Passes[i].Items[j]).SortValue := TVisible(Passes[i].Items[j]).SortValue + Passes[i].SortBias;
  324.       if Length(SortedItems) <= TotalSortedItems then SetLength(SortedItems, Length(SortedItems) + ItemsCapacityStep);
  325.       with SortedItems[TotalSortedItems] do begin
  326.         PassIndex := i;
  327.         ItemIndex := j;
  328.       end;
  329.       Inc(TotalSortedItems);
  330.     end else Inc(PerfProfile.FrustumCulledItems);
  332.     SortItems(TotalSortedItems, SortedItems);
  334.     Inc(PerfProfile.SortedItems, TotalSortedItems);
  336.     for i := TotalSortedItems-1 downto 0 do begin
  337.       Renderer.APIState.ApplyPass(Passes[SortedItems[i].PassIndex]);
  338.       RenderItem(Passes[SortedItems[i].PassIndex], TVisible(Passes[SortedItems[i].PassIndex].Items[SortedItems[i].ItemIndex]));
  339.     end;
  340.   end;
  342. var LastClearOrder, i, j: Integer; SortedPassesCollect: Boolean; ClearSettings: TClearSettings;
  343. begin
  344.   // Render visible through camera textures
  345. //            if RecursionCounter = 0 then                                         // ToDo: remove it
  347.   for PassIndex := 0 to TotalPasses-1 do if (isVisible in Passes[PassIndex].State) and (Passes[PassIndex].Group in Camera.GroupMask) then begin
  348.     Passes[PassIndex].State := Passes[PassIndex].State - [isVisible];                     // Do not draw this pass within its camera
  349.     for j := 0 to Passes[PassIndex].TotalStages-1 do
  350.       if  (Passes[PassIndex].Stages[j].TextureIndex <> tivNull) and
  351.          ((Passes[PassIndex].Stages[j].TextureIndex <> tivUnresolved) or Renderer.Textures.Resolve(Passes[PassIndex], j)) then
  352.         if (Passes[PassIndex].Stages[j].TextureIndex = tivRenderTarget) and
  353.            (Passes[PassIndex].Stages[j].Camera <> Renderer.MainCamera) and (isVisible in Passes[PassIndex].Stages[j].Camera.State) and
  354.            not Renderer.APIState.IsRenderTargetUptoDate(Passes[PassIndex].Stages[j].Camera) then begin
  355.              Passes[PassIndex].Stages[j].Camera.RenderTargetIndex := Renderer.APIState.FindRenderTarget(Passes[PassIndex].Stages[j].Camera);
  356.              if Passes[PassIndex].Stages[j].Camera.RenderTargetIndex <> -1 then
  357.                Render(Camera, Passes[PassIndex].Stages[j].Camera, RecursionCounter+1);
  358.            end;
  359.     Passes[PassIndex].State := Passes[PassIndex].State + [isVisible];
  360.   end;
  362.   // Render objects by PBR
  363.   Camera.OnApply(ThroughCamera);
  364.   Renderer.ApplyCamera(Camera);
  366.   SortedPassesCollect := False;
  367.   FirstSortedPass := -1;
  368.   LastSortedPass  := -2;
  369.   LastClearOrder  := poPreprocess;
  370.   ClearSettings.ClearFlags := [];
  371.   for PassIndex := 0 to TotalPasses-1 do begin
  372.     Assert(Passes[PassIndex].Order >= LastClearOrder, '');
  373.     // Handle render stage (order) clear settings
  375.     if (Passes[PassIndex].TotalItems > 0) and                                    // Is really need to clear and draw?
  376.        (isVisible in Passes[PassIndex].State) and
  377.        (Passes[PassIndex].Group in Camera.GroupMask) then begin
  379.       for i := LastClearOrder+1 to Passes[PassIndex].Order do begin                // Collect clear settings for all passed render stages
  380.         ClearSettings.ClearFlags   := ClearSettings.ClearFlags + TCASTRootItem(Root).StageSettings[i].ClearFlags;
  381.         ClearSettings.ClearColor   := TCASTRootItem(Root).StageSettings[i].ClearColor;
  382.         ClearSettings.ClearStencil := TCASTRootItem(Root).StageSettings[i].ClearStencil;
  383.         ClearSettings.ClearZ       := TCASTRootItem(Root).StageSettings[i].ClearZ;
  384.       end;
  386.       Renderer.Clear(ClearSettings.ClearFlags, ClearSettings.ClearColor, ClearSettings.ClearZ, ClearSettings.ClearStencil);
  387.       Inc(PerfProfile.ClearCalls, Ord(ClearSettings.ClearFlags <> []));
  388.       LastClearOrder := Passes[PassIndex].Order;
  389.       ClearSettings.ClearFlags := [];                                            // Reset clear settings
  391.       if Passes[PassIndex].Order = SortedPassOrder then begin                    // Sorted passes need to collect
  392.         SortedPassesCollect := True;
  393.         AddSortedPass(Passes[PassIndex]);
  394.       end else begin
  395.         Renderer.APIState.ApplyPass(Passes[PassIndex]);
  396.         for j := 0 to Passes[PassIndex].TotalItems-1 do if TVisible(Passes[PassIndex].Items[j]).VisibilityCheck(Camera) then
  397.           RenderItem(Passes[PassIndex], TVisible(Passes[PassIndex].Items[j])) else
  398.             Inc(PerfProfile.FrustumCulledItems);
  399.       end;
  400.     end;
  401.     // Draw all accumulated sorted items if no more
  402.     if SortedPassesCollect and ((PassIndex >= TotalPasses-1) or (Passes[PassIndex+1].Order <> SortedPassOrder)) then begin
  403.       DrawSortedPasses;                                                      // Draw sorted passes
  404.       SortedPassesCollect := False;
  405.     end;
  406.   end;
  407. end;
  409. constructor TCore.Create;
  410. begin
  411.   inherited;
  413.   FPSCountEventID := eIDNone;
  415.   // Register item classes
  416.   RegisterItemClasses(GlobalClassList.Classes);
  418.   Compiler := TSimpleParser.Create;
  420.   FSharedTesselators := TSharedTesselators.Create;
  421.   FSharedTesselators.Core := Self;
  423.   if Assigned(Screen) then AddSubsystem(Screen);
  425.   if not Assigned(DefaultMaterial) then begin
  426.     DefaultMaterial := TMaterial.Create(Self);
  427.     DefaultMaterial.TotalTechniques := 1;
  429.     DefaultMaterial.Technique[0] := TTechnique.Create(Self);
  430.     DefaultMaterial.Technique[0].TotalPasses := 1;
  431.     DefaultMaterial.Technique[0].Valid := True;
  433.     DefaultMaterial.Technique[0].Passes[0] := TRenderPass.Create(Self);
  434.     DefaultMaterial.Technique[0].Passes[0].Group         := 0;
  435.     DefaultMaterial.Technique[0].Passes[0].ZBufferState  := GetZBufferState(False, tfAlways, 0);
  436.     DefaultMaterial.Technique[0].Passes[0].Order         := poPostProcess;
  437.     DefaultMaterial.Technique[0].Passes[0].LightingState := GetLightingState(slNONE, False, False, GetColor($40404040));
  438.     DefaultMaterial.Technique[0].Passes[0].FillShadeMode := GetFillShadeMode(fmSOLID, smGOURAUD, cmNONE, $FFFFFFFF);
  439.     DefaultMaterial.Technique[0].Passes[0].FogKind       := fkNone;
  440.     DefaultMaterial.Technique[0].Passes[0].TotalStages   := 1;
  441.     DefaultMaterial.Technique[0].Passes[0].Stages[0].ColorArg0 := taDIFFUSE;
  442.     DefaultMaterial.Technique[0].Passes[0].Stages[0].ColorOp := toARG2;
  443.     DefaultMaterial.Technique[0].Passes[0].State := DefaultMaterial.Technique[0].Passes[0].State + [isVisible];
  444.   end;
  446.   CatchAllInput := False;
  448.   FPSCountTimeout := 0.5;
  449. end;
  451. procedure TCore.AddPass(const Item: TItem);
  452. var i: Integer;
  453. begin
  454.   Assert(Item is TRenderPass, Format('%S.%S: Item "%S" of class "%S" is not a render pass', [ClassName, 'AddPass', Item.Name, Item.ClassName]));
  455.   Inc(TotalPasses);
  456.   if Length(Passes) < TotalPasses then SetLength(Passes, Length(Passes) + PassesCapacityStep);
  458.   i := TotalPasses-1;
  459.   while i > 0 do begin
  460.     if TRenderPass(Item).Order >= Passes[i-1].Order then Break;
  461.     Passes[i] := Passes[i-1];
  462.     Dec(i);
  463.   end;
  464.   Passes[i] := TRenderPass(Item);
  465. end;
  467. procedure TCore.RemovePass(const Item: TItem);
  468. var i, RemovedCount: Integer;
  469. begin
  470.   RemovedCount := 0;
  471.   for i := 0 to TotalPasses-1 do begin
  472.     if Passes[i] = Item then Inc(RemovedCount);
  473.     if (RemovedCount > 0) and (i < TotalPasses-1) then Passes[i] := Passes[i + RemovedCount];
  474.   end;
  475.   Dec(TotalPasses, RemovedCount);
  477.   Assert(RemovedCount > 0, ClassName + '.RemovePass: Pass not found');
  478. end;
  480. procedure TCore.HandleMessage(const Msg: TMessage);
  481. begin
  482. //  if Msg = nil then Exit;
  483.   inherited;  
  484. //  if Assigned(Screen)   then Screen.HandleMessage(Msg);
  485. //  if Assigned(Renderer) then Renderer.HandleMessage(Msg);
  486. //  if Assigned(Input)    then Input.HandleMessage(Msg);
  488.   if Msg.ClassType = ItemMsg.TReplaceMsg then with ItemMsg.TReplaceMsg(Msg) do begin
  489. //    if (OldItem is TVisible) and (TVisible(OldItem).Colliding <> nil) then Collidings.Remove(TProcessing(OldItem).Colliding);
  490.   end else if Msg.ClassType = TRequestValidationMsg then begin
  491.     Assert(TRequestValidationMsg(Msg).Item is TMaterial);
  492.     if Assigned(Renderer) and Renderer.ValidateMaterial(TRequestValidationMsg(Msg).Item as TMaterial) then begin
  493. //      ResetTechnique(TMaterial(TRequestValidationMsg(Msg).Item));
  494.       SendMessage(TValidationResultChangedMsg.Create(TRequestValidationMsg(Msg).Item), nil, [mfBroadcast]);
  495.     end;
  497.   end else if Msg.ClassType = ItemMsg.TSceneLoadedMsg then ApplyDefaultCamera;
  498. end;
  500. procedure TCore.ClearItems;
  501. begin
  502.   Lights    := nil;
  503.   RenderItems        := nil;
  504.   LastProcessingTime := nil;
  505.   inherited;
  506.   Passes := nil; TotalPasses := 0;
  507. end;
  509. function TCore.TraceRay(const Ray: TVector3s; Depth: Single; out Items: TItems): Integer;
  510. begin
  511.   Result := 0;
  512. end;
  514. procedure TCore.Process;
  515. var i: Integer; CASTRoot: TCASTRootItem;
  516. begin
  517.   {$IFDEF PROFILE}
  518.   PerfProfile.BeginTiming(Timer, ptFrame);
  519.   {$ENDIF}
  521.   if Assigned(Root) then begin
  522.     Assert(Root is TCASTRootItem, ClassName + '.Process: Root should be an instance of TCASTRootItem or one of its descendants');
  523.     CastRoot := TCASTRootItem(Root);
  525.   // Collision
  526.     {$IFDEF PROFILE} PerfProfile.BeginTiming(Timer, ptCollision); {$ENDIF}
  527.     CastRoot.Collide;
  528.     {$IFDEF PROFILE} PerfProfile.EndTiming(Timer, ptCollision); {$ENDIF}
  529.   // Input
  530.     if Assigned(Input) then begin
  531.       if CatchAllInput then begin
  532.         Input.ProcessInput([ifBound, ifNotBound]);
  533.         Input.InputEventsToMessages;
  534.       end else Input.ProcessInput([ifBound]);
  535.     end;  
  536.   // Processing
  537.     {$IFDEF PROFILE} PerfProfile.BeginTiming(Timer, ptProcessing); {$ENDIF}
  539.     TotalProcessingItems := Root.ExtractByMask([isProcessing], True, ProcessingItems);
  540.     Timer.Process;
  541.     ProcessDeltaTimeBased(Timer.GetInterval(DeltaTimeBasedTimeMark, True) * TimeScale);
  542. {    l := Length(LastProcessingTime);
  543.     if l < Length(ProcessingClasses) then begin
  544.       SetLength(LastProcessingTime, Length(ProcessingClasses));
  545.       for i := l to Length(ProcessingClasses)-1 do LastProcessingTime[i] := LastProcessTime;
  546.     end;
  548.     for i := 0 to Length(ProcessingClasses)-1 do if not Paused or (pfIgnorePause in ProcessingClasses[i].Flags) then begin
  549.       if pfDeltaTimeBased in ProcessingClasses[i].Flags then begin
  550.         for j := 0 to TotalProcessingItems-1 do begin
  551.           Assert(ProcessingItems[j] is TBaseProcessing, ProcessingItems[j].Name + ' is not a descendant of TBaseProcessing');
  552.           if TBaseProcessing(ProcessingItems[j]).ProcessingClass = i then
  553.             TBaseProcessing(ProcessingItems[j]).Process(Timer.LastTime - LastProcessTime);
  554.         end;
  555.       end else begin
  556.         if ThisProcessTime - LastProcessingTime[i] > MaxInterval then LastProcessingTime[i] := ThisProcessTime - MaxInterval;
  558.         while LastProcessingTime[i] + ProcessingClasses[i].Interval <= ThisProcessTime do begin
  559.           for j := 0 to TotalProcessingItems-1 do if ProcessingItems[j] is TBaseProcessing then begin
  560.             Assert(ProcessingItems[j] is TBaseProcessing, ProcessingItems[j].Name + ' is not a descendant of TBaseProcessing');
  561.             if TBaseProcessing(ProcessingItems[j]).ProcessingClass = i then
  562.               TBaseProcessing(ProcessingItems[j]).Process(ProcessingClasses[i].Interval);
  563.           end;
  564.           LastProcessingTime[i] := LastProcessingTime[i] + ProcessingClasses[i].Interval;
  565.         end;
  566.       end;
  567.     end else LastProcessingTime[i] := ThisProcessTime;}
  569.     {$IFDEF PROFILE} PerfProfile.EndTiming(Timer, ptProcessing); {$ENDIF}
  571.   // Render
  572.     {$IFDEF PROFILE} PerfProfile.BeginTiming(Timer, ptRender); {$ENDIF}
  573.     if Assigned(Renderer) and Assigned(Renderer.MainCamera) and Renderer.Active then begin
  575.       // Prepare lights
  576.       if SimultaneousLightSources > 0 then
  577.         TotalLights := Root.ExtractByClass(TLight, Lights) else
  578.           TotalLights := 0;
  579.   //    SimultaneousLightSources := MinI(SimultaneousLightSources, Renderer.MaxAPILights);
  581.       Renderer.StartFrame;
  582.       // Render shared tesselator
  583.       SharedTesselators.Render;
  584.       Render(nil, Renderer.MainCamera, 0);
  585.       SharedTesselators.Reset;
  586.   //    if Screen <> nil then Screen.Render(Renderer);
  587.   {    TotalRenderItems := Root.Extract([tmRender], RenderItems);
  588.       for i := 0 to TotalRenderItems-1 do begin
  589.         (RenderItems[i] as TVisible).OnRender(Renderer.LastAppliedCamera);
  590.         Renderer.RenderItem(RenderItems[i] as TVisible);
  591.       end;}
  592.       if Renderer.DebugOutput then begin
  593.         // Render bounding volumes
  594.         TotalRenderItems := Root.ExtractByMask([isDrawVolumes], False, RenderItems);
  595.         for i := 0 to TotalRenderItems-1 do if RenderItems[i] is TProcessing then begin
  596.           Renderer.RenderItemBox(TProcessing(RenderItems[i]), GetColor($FFFF0000));
  597.           Renderer.RenderItemDebug(TProcessing(RenderItems[i]));
  598.         end;
  599.         // Render picked objects boxes
  600.         TotalRenderItems := Root.ExtractByMask([isPicked], False, RenderItems);
  601.         for i := 0 to TotalRenderItems-1 do if RenderItems[i] is TProcessing then
  602.          Renderer.RenderItemBox(TProcessing(RenderItems[i]), GetColor($FFFFFF00));
  603.       end;
  605.       Renderer.FinishFrame;
  606.     end;
  607.     {$IFDEF PROFILE} PerfProfile.EndTiming(Timer, ptRender); {$ENDIF}
  608.   end;
  610.   ProcessAsyncMessages;
  612.   if Assigned(Root) then CollectGarbage;
  614.   {$IFDEF PROFILE} PerfProfile.EndTiming(Timer, ptFrame); {$ENDIF}
  615. end;
  617. procedure TCore.CollectGarbage;
  618. begin
  619.   Assert(TempItems is TTemporaryVisible);
  620.   TTemporaryVisible(TempItems).Clear;
  621.   inherited;
  622. end;
  624. procedure TCore.ApplyDefaultCamera;
  625. var i, Count: Integer; Cameras: TItems;
  626. begin
  627.   if Renderer = nil then Exit;
  628.   Count := Root.ExtractByClass(TCamera, Cameras);
  629.   i := 0;
  630.   while (i < Count){ and not (Cameras[i] as TCamera).Default} do Inc(i);
  631.   if i < Count then
  632.     Renderer.MainCamera := Cameras[i] as TCamera
  633.   else if Cameras <> nil then
  634.     Renderer.MainCamera := Cameras[0] as TCamera;
  635. end;
  637. procedure TCore.ResetTechnique(const AMaterial: TMaterial);
  638. var i, j, OldTotalPasses, OldTotalItems: Integer;
  639. begin
  640.   i := 0;
  641.   OldTotalPasses := TotalPasses;
  642.   while i < TotalPasses do begin
  643.     j := 0;
  644.     OldTotalItems := Passes[i].TotalItems;
  645.     while j < Passes[i].TotalItems do begin
  646.       if TVIsible(Passes[i].Items[j]).Material = AMaterial then
  647.         TVIsible(Passes[i].Items[j]).CurrentLOD := TVIsible(Passes[i].Items[j]).CurrentLOD;     // To reset current technique
  649.       if Passes[i].TotalItems < OldTotalItems then begin                  // Some items has been removed from the pass
  650.         j := MaxI(0, j - (OldTotalItems - Passes[i].TotalItems));
  651.         OldTotalItems := Passes[i].TotalItems;
  652.       end;
  653.       Inc(j);
  655.     end;
  656.     if TotalPasses < OldTotalPasses then begin                  // Some passes has been removed
  657.       i := MaxI(0, i - (OldTotalPasses - TotalPasses));
  658.       OldTotalPasses := TotalPasses;
  659.     end;
  660.     Inc(i);
  661.   end;
  662. end;
  664. { TSimpleParser }
  666. function TSimpleParser.Compile(const Source: AnsiString): OTypes.TRTData;
  667. begin
  668.   Result := TRTData.Create;
  669.   SetLength(Result.Variables, 13);
  670.   Result.Variables[0].Name   := 'Model';
  671.   Result.Variables[0].TypeID := tidMatrix4x4;
  672.   Result.Variables[1].Name   := 'View';
  673.   Result.Variables[1].TypeID := tidMatrix4x4;
  674.   Result.Variables[2].Name   := 'Projection';
  675.   Result.Variables[2].TypeID := tidMatrix4x4;
  676.   Result.Variables[3].Name   := 'ModelView';
  677.   Result.Variables[3].TypeID := tidMatrix4x4;
  678.   Result.Variables[4].Name   := 'MVP';
  679.   Result.Variables[4].TypeID := tidMatrix4x4;
  681.   Result.Variables[5].Name   := 'Light[0].Position';
  682.   Result.Variables[5].TypeID := tidVector4;
  683.   Result.Variables[6].Name   := 'Light[0].Direction';
  684.   Result.Variables[6].TypeID := tidVector4;
  685.   Result.Variables[7].Name   := 'Light[0].Ambient';
  686.   Result.Variables[7].TypeID := tidVector4;
  687.   Result.Variables[8].Name   := 'Light[0].Diffuse';
  688.   Result.Variables[8].TypeID := tidVector4;
  689.   Result.Variables[9].Name   := 'Light[0].Specular';
  690.   Result.Variables[9].TypeID := tidVector4;
  692.   Result.Variables[10].Name   := 'Material.Ambient';
  693.   Result.Variables[10].TypeID := tidVector4;
  694.   Result.Variables[11].Name   := 'Material.Diffuse';
  695.   Result.Variables[11].TypeID := tidVector4;
  696.   Result.Variables[12].Name   := 'Material.Specular';
  697.   Result.Variables[12].TypeID := tidVector4;
  699.   SetLength(Result.PIN, 1);
  701.   Result.PIN[0] := High(Result.Variables);
  702.   while (Result.PIN[0] >= 0) and (Source <> Result.Variables[Result.PIN[0]].Name) do Dec(Result.PIN[0]);
  703.   if Result.PIN[0] <= 0 then begin
  704.     FreeAndNil(Result);
  705.     LastError := 'Unknown identifier: ' + Source;
  706.     Log.Log(Format('%S.%S: The following error occured while compiling mini-script: "%S"', [ClassName, 'Compile', LastError]), lkError);
  707.   end;
  708. end;
  710. begin
  711.   GlobalClassList.Add('C2Core', GetUnitClassList);
  712. end.