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

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

游戏引擎

开发平台：

Delphi

C2Render.pas：源码内容
  1. (*
  2.  @Abstract(CAST II Engine render 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 API-independent basic renderer classes
  6. *)
  7. {$Include GDefines.inc}
  8. {$Include C2Defines.inc}
  9. unit C2Render;
  11. interface
  13. uses
  14.   SysUtils,
  15.   BaseTypes, BaseMsg, Basics, Base3D, OSUtils, Base2D, Resources,
  16.   TextFile,
  17.   BaseClasses, ItemMsg, C2Types, CAST2, C2Visual, C2Materials, C2DebugTess, C2Res, C2Msg;
  19. const
  20.   // max X coordinate of window to consider it off-screen
  21.   OffScreenX = -10000;
  22.   // max Y coordinate of window to consider it off-screen
  23.   OffScreenY = -10000;
  25.   // Maximum number of vertex buffer with different vertex sizes
  26.   MaxVertexBuffers = 64;
  27.   // Size of indices
  28.   IndicesSize = 2;
  30. type
  31.   { Data structure used to represent a locked rectangular area of some data
  32.     Data  - pointer to actual data
  33.     Pitch - offset in bytes between two rows of data }
  34.   TLockedRectData = record
  35.     Data:  Pointer;
  36.     Pitch: Integer;
  37.   end;
  38.   // Renderer states
  39.   TRendererState = (// Renderer is ready
  40.                     rsOK,
  41.                     // Renderer is in process of initialization
  42.                     rsNotReady,
  43.                     // Renderer has lost device and will try to restore it (DirectX-specific)
  44.                     rsLost,
  45.                     // Renderer has not been initialized
  46.                     rsNotInitialized);
  48. {  // Create viewport results
  49.   TViewportCreateResult = (// Success
  50.                            cvOK,
  51.                            // Device has been lost (DirectX-specific)
  52.                            cvLost,
  53.                            // Error occured
  54.                            cvError);}
  56.   // Hardware acceleration level (DirectX only)
  57.   THWAccelLevel = (// Software vertex processing
  58.                   haSoftwareVP,
  59.                   // Mixed vertex processing
  60.                   haMixedVP,
  61.                   // Hardware vertex processing
  62.                   haHardwareVP,
  63.                   // Pure device
  64.                   haPureDevice);
  66.   TAppRequirementsFlag = (// Use stencil buffering
  67.                           arUseStencil,
  68.                           // Use Z-buffering
  69.                           arUseZBuffer,
  70.                           // Forces vertcial syncronization on
  71.                           arForceVSync,
  72.                           // Forces vertcial syncronization off
  73.                           arForceNoVSync,
  74.                           // Tells API that it will be used from several threads
  75.                           arMultithreadedRender,
  76.                           // Tells API to not change FPU state within its routines
  77.                           arPreserveFPU,
  78.                           // Includes modes with all refresh rates in available video modes list
  79.                           arModesUseRefresh,
  80.                           // Tells API that backbuffer contents should not be changed or discarded between frames. May be slow on some configurations.
  81.                           arPreserveBackBuffer,
  82.                           // Tells API that backbuffer should be lockable
  83.                           arLockableBackBuffer);
  85.   { Application requirements record. These values can be changed before renderer initialization to change its behaviour. <br>
  86.     <b>Flags</b>                - <b>[arUseStencil, arUseZBuffer]</b> by default. <br>
  87.     <b>MinYResolution</b>       - minimal vertical resolution of modes to iclude in available video modes list. <b>480</b> by default. <br>
  88.     <b>HWAccelerationLevel</b>  - level of hardware acceleration required. <b>haMixedVP</b> by default. <br>
  89.     <b>TotalBackBuffers</b>     - number of back buffers required. <b>1</b> by default. }
  90.   TAppRequirements = record
  91.     Flags: set of TAppRequirementsFlag;
  92.     MinYResolution: Cardinal;
  93.     HWAccelerationLevel: THWAccelLevel;
  94.     TotalBackBuffers: Cardinal;
  95.   end;
  97.   { Video mode data structure. <br>
  98.     <b>Width, Height</b> - horizontal and vertical resolution. <br>
  99.     <b>RefreshRate</b>   - refresh rate. <br>
  100.     <b>Format</b>        - pixel format. }
  101.   TVideoMode = packed record
  102.     Width, Height: Integer;
  103.     RefreshRate  : Integer;
  104.     Format       : Integer;
  105.   end;
  106.   // Array of video modes
  107.   TVideoModes = array of TVideoMode;
  109.   // Gamma ramp
  110.   TGammaRamp = record
  111.     R, G, B: array[0..255] of Word;
  112.   end;
  114.   // Viewport
  115.   TViewPort = packed record
  116.     X, Y, Width, Height: Longword;
  117.     MinZ, MaxZ: Single;
  118.   end;
  120.   // Texture option flags
  121.   TTextureOptionFlag = (// Texture should be immediately loaded
  122.                         toImmediateLoad,
  123.                         // Texture is not managed by an API [b](currently unsupported)[/b]
  124.                         toNonAPIManaged,
  125.                         // Texture is a cube map [b](currently unsupported)[/b]
  126.                         toCubeMap,
  127.                         // Texture is procedurally generated at runtime
  128.                         toProcedural);
  129.   // Texture option set
  130.   TTextureOptions = set of TTextureOptionFlag;
  131.   // Texture
  132.   TTexture = record
  133.     Texture: Pointer;
  134.     Format : Cardinal;
  135.     Options: TTextureOptions;
  136.     Width, Height, Depth, Levels: Integer;
  137.     LastUseFrame: Integer;
  138.     Resource: TImageResource;
  139.   end;
  141.   // Render target
  142.   TRenderTarget = record
  143.     ColorBuffer, DepthBuffer, ColorTexture, DepthTexture: Pointer;
  144.     ColorFormat, DepthFormat, ActualColorFormat, ActualDepthFormat: Integer;
  145.     Width, Height: Integer;
  146.     LastUpdateFrame, LastUseFrame: Integer;
  147.     IsDepthTexture: Boolean;
  148.   end;
  149.   TRenderTargets = array of TRenderTarget;
  151.   // Shader
  152.   TShader = record
  153.     Shader: Integer;                                  // API-specific shader ID
  154.     LastUseFrame: Integer;
  155.     Resource: TShaderResource;
  156.   end;
  157.   TShaders = array of TShader;
  159.   // Renderer errors enumeration type
  160.   TRendererError = (// No error
  161.                     reNone,
  162.                     // Number of texture stages in a pass exceeding renderer capabilities (see @Link(MaxTextureStages))
  163.                     reTooManyStages,
  164.                     // Number of textures used in a pass exceeding renderer capabilities (see @Link(MaxTexturesPerPass))
  165.                     reTooManyTextures,
  166.                     // Vertex shader compilation failed
  167.                     reVertexShaderAssembleFail,
  168.                     // Vertex shader creation failed
  169.                     reVertexShaderCreateFail,
  170.                     // Pixel shader compilation failed
  171.                     rePixelShaderAssembleFail,
  172.                     // Pixel shader creation failed
  173.                     rePixelShaderCreateFail,
  174.                     // Depth textures unsupported
  175.                     reNoDepthTextures);
  177.   TRenderer = class;
  179.   // API-specific vertex and index buffers management class
  180.   TAPIBuffers = class
  181.   protected
  182.     // Reference to renderer object
  183.     Renderer: TRenderer;
  184.   public
  185.     constructor Create(ARenderer: TRenderer);
  186.     destructor Destroy; override;
  187.     // Returns a flexible vrtex format code from CAST vertex format
  188. //    function GetFVF(CastVertexFormat: Cardinal): Cardinal; virtual; abstract;
  189.     { Creates a vertex buffer with the given size in bytes and returns its internal index or -1 if creation fails.
  190.       If <b>Static</b> is <b>False</b> the buffer will be optimized to store dynamic geometry. }
  191.     function CreateVertexBuffer(Size: Integer; Static: Boolean): Integer; virtual; abstract;
  192.     { Creates an index buffer with the given size in bytes and returns its internal index or -1 if creation fails
  193.       If <b>Static</b> is <b>False</b> the buffer will be optimized to store dynamic data. }
  194.     function CreateIndexBuffer(Size: Integer; Static: Boolean): Integer; virtual; abstract;
  195.     // Changes size of the given vertex buffer to the given size and returns <b>True</b> if success
  196.     function ResizeVertexBuffer(Index: Integer; NewSize: Integer): Boolean; virtual; abstract;
  197.     // Changes size of the given index buffer to the given size and returns <b>True</b> if success
  198.     function ResizeIndexBuffer(Index: Integer; NewSize: Integer): Boolean; virtual; abstract;
  199.     { Locks the given range in a vertex buffer with the given index and returns a write-only pointer to the range data or <b>nil</b> if lock fails.
  200.       If <b>DiscardExisting</b> is <b>True</b> existing data in the buffer will be discarded to avoid stalls. }
  201.     function LockVertexBuffer(Index: Integer; Offset, Size: Integer; DiscardExisting: Boolean): Pointer; virtual; abstract;
  202.     { Locks the given range in a index buffer with the given index and returns a write-only pointer to the range data or <b>nil</b> if lock fails.
  203.       If <b>DiscardExisting</b> is <b>True</b> existing data in the buffer will be discarded to avoid stalls. }
  204.     function LockIndexBuffer(Index: Integer; Offset, Size: Integer; DiscardExisting: Boolean): Pointer; virtual; abstract;
  205.     // Unlocks a previously locked vertex buffer
  206.     procedure UnlockVertexBuffer(Index: Integer); virtual; abstract;
  207.     // Unlocks a previously locked index buffer
  208.     procedure UnlockIndexBuffer(Index: Integer); virtual; abstract;
  209.     // Attaches a vertex buffer to the specified data stream and returns <b>True</b> if success. <b>VertexSize</b> should match the size of the data in the buffer.
  210.     function AttachVertexBuffer(Index, StreamIndex: Integer; VertexSize: Integer): Boolean; virtual; abstract;
  211.     // Attaches an index buffer and returns <b>True</b> if success. <b>StartingVertex</b> will be added to all indices read from the index buffer.
  212.     function AttachIndexBuffer(Index: Integer; StartingVertex: Integer): Boolean; virtual; abstract;
  213.     // Frees all allocated buffers. All internal indices returned before this call become invalid.
  214.     procedure Clear; virtual; abstract;
  215.   end;
  217.   // API-independent buffer structure
  218.   TBuffer = record
  219.     Index, Size: Integer;
  220.     Position: Integer;
  221.     ResetCounter: Integer;
  222.   end;
  223.   // API independent vertex and index buffers management class
  224.   TBuffers = class
  225.   private
  226.     Buffers: array[TTesselationBuffer, Boolean, 0..MaxVertexBuffers-1] of TBuffer;
  227.     ResetCounter: Integer;
  228.     Renderer: TRenderer;
  229.     procedure ResetBuffers;
  230.   public
  231.     constructor Create(ARenderer: TRenderer);
  232.     destructor Destroy; override;
  233.     // Puts the given tesselator to an appropriate buffer pair
  234.     function Put(Tesselator: TTesselator): Boolean;
  235.     // Clears and reallocates all allocated buffers
  236.     procedure Reset;
  237.   end;
  239.   TTextureArray = array of TTexture;
  241.   TTextures = class
  242.   private
  243.   protected
  244.     Renderer: TRenderer;
  245.     FTextures: TTextureArray;
  246.     // Returns <b>True</b> if the specified texture is not initialized
  247.     function IsEmpty(const Element: TTexture): Boolean;
  248.     // Deletes all textures
  249.     procedure FreeAll;
  250.     // Calls an API to create API-specific texture object 
  251.     function APICreateTexture(Index: Integer): Boolean; virtual; abstract;
  252.     // Calls an API to destroy API-specific texture object
  253.     procedure APIDeleteTexture(Index: Integer); virtual; abstract;
  254.   public
  255.     destructor Destroy; override;
  256.     // Handles some related messages
  257.     procedure HandleMessage(const Msg: TMessage);
  258.     // Adds a new texture entry. Does not create any API-specific objects.
  259.     function NewTexture(Resource: TImageResource; Options: TTextureOptions): Integer;
  260.     // Adds a new procedural texture entry. Does not create any API-specific objects.
  261.     function NewProceduralTexture(AFormat: Cardinal; AWidth, AHeight, ADepth, ALevels: Integer; Options: TTextureOptions): Integer;
  262.     // Loads the specified by index texture from its associated resource. Returns <b>True</b> if success.
  263.     function Load(Index: Integer): Boolean;
  264.     // Unloads the specified by index texture from API. <b>Currently not implemented.</b>
  265.     procedure Unload(Index: Integer); virtual; abstract;
  266.     // Updates the specified rectangle of the specified by index texture in API from the given pointer. Returns <b>True</b> if success.
  267.     function Update(Index: Integer; Src: Pointer; Rect: BaseTypes.PRect3D): Boolean; virtual; abstract;
  268.     // Reads the specified rectangle of the specified by index texture in API to the given pointer. Returns <b>True</b> if success. <b>Currently not implemented.</b>
  269.     function Read(Index: Integer; Dest: Pointer; Rect: BaseTypes.PRect3D): Boolean; virtual; abstract;
  270.     // Removes the specified texture
  271.     procedure Delete(Index: Integer); 
  272.     // Resolves a texture for the given pass. Used internally.
  273.     function Resolve(Pass: TRenderPass; StageIndex: Integer): Boolean;
  274.     // Applies texture with the specified index to the specified API stage
  275.     procedure Apply(Stage, Index: Integer); virtual; abstract;
  276.     // Locks the specified area of the specified level of the specified texture. This call should be accompanied by a corresponding @Link(Unlock) call.
  277.     function Lock(AIndex, AMipLevel: Integer; const ARect: BaseTypes.PRect; out LockRectData: TLockedRectData; LockFlags: TLockFlags): Boolean; virtual; abstract;
  278.     // Unlocks previously locked texture
  279.     procedure UnLock(AIndex, AMipLevel: Integer); virtual; abstract;
  280.   end;
  282.   // API-dependent class which wraps render state
  283.   TAPIStateWrapper = class
  284.   private
  285.     DefaultCamera: TCamera;
  286.     function NewRenderTarget(const Camera: TCamera): Integer;
  287.     function CreateShader(var Shaders: TShaders; Item: TShaderResource): Integer;
  288.     procedure RemoveRenderTarget(Index: Integer);
  289.   protected
  290.     // Reference to renderer
  291.     Renderer: TRenderer;
  292.     // Last renderer error. Used for pass validation.
  293.     LastError: TRendererError;
  294.     //    TotalTextures: Integer;
  295.     // Render targets
  296.     FRenderTargets: TRenderTargets;
  297.     // Shaders
  298.       public                 // ToFix: make it protected
  299.         FVertexShaders, FPixelShaders: TShaders;
  300.       protected
  302.     // Current camera (same as Renderer.@Link(LastAppliedCamera))
  303.     Camera: CAST2.TCamera;
  304.     // True if texture matrix was set for a certain stage
  305.     StageMatrixSet: array[0..7] of Boolean;
  306.     // Clip planes state
  307.     ClipPlanesState: Cardinal;
  309.     // Performance profile
  310.     FPerfProfile: TPerfProfile;
  312.     // Returns <b>True</b> if the specified render target is not initialized
  313.     function IsRenderTargetEmpty(const Element: TRenderTarget): Boolean;
  314.     // Returns <b>True</b> if the specified shader is not initialized
  315.     function IsShaderEmpty(const Element: TShader): Boolean;
  317.     // Calls an API to create a render target with given parameters. DepthStencil surface will be created if <b>ADepthFormat</b> is other than @Link(pfUndefined). Returns <b>True</b> if success.
  318.     function APICreateRenderTarget(Index, Width, Height: Integer; AColorFormat, ADepthFormat: Cardinal): Boolean; virtual; abstract;
  319.     // Ensures that all parameters are correct and supported and calls @Link(APICreateRenderTarget). Returns <b>True</b> if a render target been created.
  320.     function CreateRenderTarget(Index, Width, Height: Integer; AColorFormat, ADepthFormat: Cardinal; ADepthTexture: Boolean): Boolean;
  321.     // Destroys the specified by index render target
  322.     procedure DestroyRenderTarget(Index: Integer); virtual; abstract;
  323.       public        // ToFix: make it protected
  324.         // Return a render target for the given camera. If render target does not exists the function creates it.
  325.         function FindRenderTarget(const ACamera: TCamera): Integer;
  326.         // Returns <b>True</b> if there is no need to update render target texture associated with Camera
  327.         function IsRenderTargetUptoDate(const ACamera: TCamera): Boolean;
  328.       protected
  329.     // Sets current render target to the one associated with <b>Camera</b>. Returns <b>True</b> if actual change was made.
  330.     function SetRenderTarget(const ACamera: TCamera; TextureTarget: Boolean): Boolean; virtual; abstract;
  332.       public        // ToFix: make it protected
  333.         // Resolves a vertex shader for the given pass. Used internally.
  334.         function ResolveVertexShader(Pass: TRenderPass): Boolean;
  335.       protected
  336.     // Resolves a pixel shader for the given pass. Used internally.
  337.     function ResolvePixelShader(Pass: TRenderPass): Boolean;
  338.     // Creates a vertex shader from the resource with the given vertex declaration
  339.     function CreateVertexShader(Item: TShaderResource; Declaration: TVertexDeclaration): Integer; virtual;
  340.     // Creates a pixel shader from the resource
  341.     function CreatePixelShader(Item: TShaderResource): Integer; virtual;
  343.     // Calls an API to set a shader constant
  344.     procedure APISetShaderConstant(const Constant: TShaderConstant); overload; virtual; abstract;
  345.     // Calls an API to set a shader constant. <b>ShaderKind</b> - kind of shader, <b>ShaderRegister</b> - index of 4-component vector register to set, <b>Vector</b> - new value of the register.
  346.     procedure APISetShaderConstant(ShaderKind: TShaderKind; ShaderRegister: Integer; const Vector: TShaderRegisterType); overload; virtual; abstract;
  348.     { Calls an API to validate the specified pass. Returns <b>True</b> if the pass is can be handled by current hardware.
  349.       Otherwise returns <b>False</b> and fills <b>ResultStr</b> a text representation of the error occured. }
  350.     function APIValidatePass(const Pass: TRenderPass; out ResultStr: string): Boolean; virtual; abstract;
  352.     // Applies texture matrix of each texture stage of the specified render pass
  353.     procedure ApplyTextureMatrices(const Pass: TRenderPass); virtual; abstract;
  354.     // Applies current clipping planes
  355.     procedure ApplyClipPlanes;
  357.     // Handle removal or replace of some item from scene
  358.     procedure HandleItemReplace(OldItem, NewItem: TItem); virtual;
  359.     // Handle data change of renderer-related items
  360.     procedure HandleDataChange(Data: Pointer); virtual;
  361.   public
  362.     // Vertex shader usage flag. Used internally.
  363.     VertexShaderFlag,
  364.     // Pixel shader usage flag. Used internally.
  365.     PixelShaderFlag: Boolean;
  366.     constructor Create;
  367.     destructor Destroy; override;
  369.     // Handles some related messages
  370.     procedure HandleMessage(const Msg: TMessage);
  372.     // Sets fog kind, color, start/end and density
  373.     procedure SetFog(Kind: Cardinal; Color: BaseTypes.TColor; AFogStart, AFogEnd, ADensity: Single); virtual; abstract;
  374.     // Sets alpha blending mode and alpha test settings
  375.     procedure SetBlending(Enabled: Boolean; SrcBlend, DestBlend, AlphaRef, ATestFunc, Operation: Integer); virtual; abstract;
  376.     // Sets Z-buffer related values
  377.     procedure SetZBuffer(ZTestFunc, ZBias: Integer; ZWrite: Boolean); virtual; abstract;
  378.     // Sets culling, shading and filling modes as well as color write mask
  379.     procedure SetCullAndFillMode(FillMode, ShadeMode, CullMode: Integer; ColorMask: Cardinal); virtual; abstract;
  380.     // Sets stencil state
  381.     procedure SetStencilState(SFailOp, ZFailOp, PassOp, STestFunc: Integer); virtual; abstract;
  382.     // Sets stencil reference value and masks
  383.     procedure SetStencilValues(SRef, SMask, SWriteMask: Integer); virtual; abstract;
  384.     // Sets texture wrapping mode
  385.     procedure SetTextureWrap(const CoordSet: TTWrapCoordSet); virtual; abstract;
  386.     // Set lighting settings
  387.     procedure SetLighting(Enable: Boolean; AAmbient: BaseTypes.TColor; SpecularMode: Integer; NormalizeNormals: Boolean); virtual; abstract;
  388.     // Sets edge and points settings
  389.     procedure SetEdgePoint(PointSprite, PointScale, EdgeAntialias: Boolean); virtual; abstract;
  390.     // Sets texture factor color
  391.     procedure SetTextureFactor(ATextureFactor: BaseTypes.TColor); virtual; abstract;
  392.     // Sets API-level material (ambient, diffuse, specular and emissive colors and specular power)
  393.     procedure SetMaterial(const AAmbient, ADiffuse, ASpecular, AEmissive: BaseTypes.TColor4S; APower: Single); virtual; abstract;
  394.     // Sets points size parameters
  395.     procedure SetPointValues(APointSize, AMinPointSize, AMaxPointSize, APointScaleA, APointScaleB, APointScaleC: Single); virtual; abstract;
  396.     // Sets line pattern
  397.     procedure SetLinePattern(ALinePattern: Longword); virtual; abstract;
  399.     // Applies a clipping plane
  400.     procedure SetClipPlane(Index: Cardinal; Plane: PPlane); virtual; abstract;
  402.     // Sets a shader constant
  403.     procedure SetShaderConstant(const Constant: TShaderConstant); overload;
  404.     // Sets a shader constant. <b>ShaderKind</b> - kind of shader, <b>ShaderRegister</b> - index of 4-component vector register to set, <b>Vector</b> - new value of the register.
  405.     procedure SetShaderConstant(ShaderKind: TShaderKind; ShaderRegister: Integer; const Vector: TShaderRegisterType); overload;
  407.     // Validate the specified pass. Returns <b>True</b> if the pass is valid
  408.     function ValidatePass(const Pass: TRenderPass): Boolean;
  410.     // Applies the specified render pass
  411.     procedure ApplyPass(const Pass: TRenderPass); virtual; abstract;
  412.     // Applies item-specific custom texture matrix of each texture stage of the specified render pass
  413.     procedure ApplyCustomTextureMatrices(const Pass: TRenderPass; Item: TVisible); virtual; abstract;
  414.   end;
  416.   { @Abstract(Renderer class)
  417.     Contains API-independent routines and an interface fo API-dependent ones }
  418.   TRenderer = class(TSubsystem)
  419.   private
  420.     procedure SetDebugOutput(const Value: Boolean);
  421.     function GetAdapterName(Index: Cardinal): string;
  422.     function GetVideoMode(Index: Cardinal): TVideoMode;
  424.     function GetRenderTargetsAllocated: Integer;
  425.   protected
  426.     // This record passed to tesselators buffer filling methods
  427.     TesselationParams: TTesselationParameters;
  428.     // Performance profile
  429.     FPerfProfile: TPerfProfile;
  430.     // Number of frames rendered
  431.     FFramesRendered: Integer;
  433.     // API-specific buffer management object
  434.     APIBuffers: TAPIBuffers;
  435.     // API-independent buffer management object
  436.     Buffers: TBuffers;
  437.     
  438.     // Reference to items manager
  439.     Manager: TItemsManager;
  441.     // Current video adapter
  442.     FCurrentAdapter,
  443.     // Number of video adapters in system
  444.     FTotalAdapters: Cardinal;
  445.     // Names of video adapters in system
  446.     FAdapterNames: array of string;
  448.     // Current video mode index in @Link(FVideoModes) array
  449.     FCurrentVideoMode,
  450.     // Number of video modes available
  451.     FTotalVideoModes: Cardinal;
  452.     // Video modes available
  453.     FVideoModes: TVideoModes;
  454.     // Current desktop video mde
  455.     DesktopVideoMode: TVideoMode;
  457.     // Handle of render window
  458.     RenderWindowHandle: Cardinal;
  459.     // Current viewport
  460.     ViewPort: TViewPort;
  461.     // Full screen mode state
  462.     FFullScreen,
  463.     // Debug output state
  464.     FDebugOutput: Boolean;
  466.     // Tesselators for primitives used in debug rendering
  467.     DebugTesselators: array of TTesselator;
  468.     // Material for debug rendering
  469.     DebugMaterial: TMaterial;
  471.     // Last applied camera
  472.     FLastAppliedCamera,
  473.     // Top-level camera through which a scene is visible for user
  474.     FMainCamera: CAST2.TCamera;
  475.     // Current gamma ramp
  476.     GammaRamp: TGammaRamp;
  478.     // Current renderer state
  479.     FState: TRendererState;
  480.     // Current depth of Z-buffer
  481.     FCurrentZBufferDepth: Cardinal;
  483.     // Rendering area in windowed mode
  484.     FWindowedRect: TRect;
  485.     // Window style in not full-screen mode
  486.     FNormalWindowStyle: Cardinal;
  488.     // For internal use only
  489.     procedure InternalInit;
  490.     // For internal use only
  491.     procedure InternalDeInit; virtual;
  492.     // For internal use only
  493.     function InternalGetIndexBufferIndex(Static: Boolean; BufferIndex: Integer): Integer;
  494.     // Calls an API to initialize render device for rendering to the specified window or specified video mode
  495.     function APICreateDevice(WindowHandle, AVideoMode: Cardinal; AFullScreen: Boolean): Boolean; virtual; abstract;
  497.     // Calls an API to set item's transformation, some FVF-related states
  498.     procedure APIPrepareFVFStates(Item: TVisible); virtual; abstract;
  500.     { Returns <b>True</b> if a pixel format is available and can be used as a texture, render target or depth-stencil buffer.
  501.       <b>RTFormat</b> is used only with depth-stencil usage to determine whether the supported depth-stencil format can be used with the given render target format. }
  502.     function APICheckFormat(const Format, Usage, RTFormat: Cardinal): Boolean; virtual; abstract;
  503.     // Returns CAST pixel format from an API-specific one
  504.     function APIToPixelFormat(Format: Cardinal): Cardinal;
  505.     // Toggles fullscreen mode
  506.     procedure SetFullScreen(const FScreen: Boolean); virtual;
  507.     // Prepares render window for windowed rendering
  508.     function PrepareWindow: Boolean;
  509.   public
  510.     // Renderer performs rendering only if this variable is <b>True</b>. <b>Active</b> is set automatically in response on window minimization or switching to another application in fullscreen mode.
  511.     Active: Boolean;
  512.     // Current render window width
  513.     RenderWidth,
  514.     // Current render window height
  515.     RenderHeight: Integer;
  516.     // If set to True data existing in vertex/index buffers are always considered as valid and no tesselation will be performed
  517.     DisableTesselation: Boolean;
  519.     // Application requirements record. These values can be changed before renderer initialization to change its behaviour.
  520.     AppRequirements: TAppRequirements;
  522.       // Capabilites
  523.     // Maximum number of light sources simultaneously handled by hardware T&L (fixed function pipeline only)
  524.     MaxHardwareLights,
  525.     // Maximum number of light sources which may be simultaneously set through API
  526.     MaxAPILights: Cardinal;
  527.     // Maximum supported texture width
  528.     MaxTextureWidth,
  529.     // Maximum supported texture height
  530.     MaxTextureHeight: Integer;
  531.     // Maximum number of textures which may be used in a pass
  532.     MaxTexturesPerPass,
  533.     // Maximum number of texture stages which may be used in a pass
  534.     MaxTextureStages: Integer;
  535.     // Maximum number of primitives per single API call (DIP)
  536.     MaxPrimitiveCount,
  537.     // Maximum index value in index buffer
  538.     MaxVertexIndex: Integer;
  539.     // Maximum number of user clipping planes
  540.     MaxClipPlanes: Integer;
  541.     // <b>True</b> if even transformed vertices are clipped by hardware (DirectX only, seems incorrect)
  542.     HardwareClipping,
  543.     // <b>True</b> if w-buffering is supported
  544.     WBuffering,
  545.     // <b>True</b> if only power of two-sized textures are supported
  546.     Power2Textures,
  547.     // <b>True</b> if only square textures are supported
  548.     SquareTextures,
  549.     // <b>True</b> if depth textures are supported
  550.     DepthTextures: Boolean;
  551.     // Maximum point size
  552.     MaxPointSize: Single;
  554.     // Major vertex shader version
  555.     VertexShaderVersionMajor,
  556.     // Minor vertex shader version
  557.     VertexShaderVersionMinor,
  558.     // Major pixel shader version
  559.     PixelShaderVersionMajor,
  560.     // Minor pixel shader version
  561.     PixelShaderVersionMinor: Integer;
  562.     // Max vertex shader constants
  563.     MaxVertexShaderConsts: Integer;
  565.     // Textures
  566.     Textures: TTextures;
  567.     // Reference to API state wrapper object
  568.     APIState: TAPIStateWrapper;
  569.     // Bias matrix used to remap texture coordinates for mirror and shadow map modes
  570.     BiasMat: TMatrix4s;
  571.     constructor Create(AManager: TItemsManager); virtual;
  572.     destructor Destroy; override;
  573.     // Sets performance profile
  574.     procedure SetPerfProfile(APerfProfile: TPerfProfile); virtual;
  576.     // Sets video adapter
  577.     procedure SetVideoAdapter(Adapter: Cardinal);
  578.     // Build available video modes list
  579.     procedure BuildModeList; virtual; abstract;
  580.     // Initializes debug tesselators and material
  581.     procedure InitDebugRender(ADebugMaterial: TMaterial); virtual;
  582.     // Returns <b>True</b> if the renderer is ready to render
  583.     function IsReady: Boolean;
  585.     // Adjusts gamma ramp
  586.     procedure SetGamma(Gamma, Contrast, Brightness: Single); virtual;
  588.     // Default message handling
  589.     procedure HandleMessage(const Msg: TMessage); override;
  591.     // Checks capabilities
  592.     procedure CheckCaps; virtual; abstract;
  593.     // Checks available texture formats
  594.     procedure CheckTextureFormats; virtual; abstract;
  595.     { Checks if the given pixel format is supported for the given usage. RTFormat is used only with depth-stencil
  596.       usage to determine whether the supported depth-stencil format can be used with the given render target format.
  597.       Returns False if the pixel format is unsupported. Also fills NewFormat with suggested substitue or with pfUndefined if no suitable substitution found. }
  598.     function CheckFormat(const Format, Usage, RTFormat: Cardinal; out NewFormat: Integer): Boolean; virtual;
  600.     // Validates all techniques of the given material for current hardware configuration. Returns <b>True</b> if the set of available techniques changed during validation.
  601.     function ValidateMaterial(const Material: TMaterial): Boolean;
  603.     // Initializes render device to render to the specified window or specified mode
  604.     function CreateDevice(WindowHandle, AVideoMode: Cardinal; AFullScreen: Boolean): Boolean;
  605.     // Restores render device with the specified video mode (if fullscreen)
  606.     function RestoreDevice(AVideoMode: Cardinal; AFullScreen: Boolean): Boolean; virtual;
  608.     // Starts a rendering cycle
  609.     procedure StartFrame; virtual;
  610.     // Ends a rendering cycle
  611.     procedure FinishFrame; virtual; abstract;
  613.     // Clear the specified parts of current render target with the specified values
  614.     procedure Clear(Flags: TClearFlagsSet; Color: BaseTypes.TColor; Z: Single; Stencil: Cardinal); virtual; abstract;
  616.     // Apply a light source with the specified index
  617.     procedure ApplyLight(Index: Integer; const ALight: TLight); virtual; abstract;
  619.     // Applies render target settings, transformations, clear settings of the given camera to the renderer
  620.     procedure ApplyCamera(Camera: CAST2.TCamera); virtual;
  622.     // Projects <b>Vector</b> with @Link(MainCamera) and returns the result in <b>Projected</b>
  623.     procedure ProjectToScreen(out Projected: TVector4s; const Vector: TVector3s);
  625.     // Sets render viewport
  626.     procedure SetViewPort(const X, Y, Width, Height: Integer; const MinZ, MaxZ: Single); virtual;
  628.     // Performs necessary API calls to render a piece of triangles
  629.     procedure APIRenderStrip(Tesselator: TTesselator; StripIndex: Integer); virtual; abstract;
  630.     // Performs necessary API calls to render a piece of indexed triangles
  631.     procedure APIRenderIndexedStrip(Tesselator: TTesselator; StripIndex: Integer); virtual; abstract;
  632.     // Renders the specified tesselator
  633.     procedure RenderTesselator(Tesselator: TTesselator);
  634.     // Ensures that vertex/index buffers contains an up-to-date representation of the specified item, calls @Link(APIPrepareItem()) and renders it's tesselator
  635.     procedure RenderItem(Item: TVisible);
  636.     // Renders item's bounding box
  637.     procedure RenderItemBox(Item: CAST2.TProcessing; Color: BaseTypes.TColor); virtual; abstract;
  638.     // Renders item's debug information (currently colliding volumes if present)
  639.     procedure RenderItemDebug(Item: CAST2.TProcessing); virtual; abstract;
  640.     
  642.     // Full screen mode state
  643.     property FullScreen: Boolean read FFullScreen write SetFullScreen;
  644.     // Debug output state
  645.     property DebugOutput: Boolean read FDebugOutput write SetDebugOutput;
  647.     // Number of frames rendered
  648.     property FramesRendered: Integer read FFramesRendered;
  650.     // Camera through which a scene is rendered. Can't be changed during frame visulization.
  651.     property MainCamera:   CAST2.TCamera read FMainCamera write FMainCamera;
  652.     // Currently applyed camera. May change during frame visulization (if render to texture used).
  653.     property LastAppliedCamera: CAST2.TCamera read FLastAppliedCamera;
  655.     // Number of video adapters in system
  656.     property TotalAdapters: Cardinal read FTotalAdapters;
  657.     // Current video adapter
  658.     property CurrentAdapter: Cardinal read FCurrentAdapter;
  659.     // Names of video adapters in system by index
  660.     property AdapterName[Index: Cardinal]: string read GetAdapterName;
  662.     // Number of video modes available
  663.     property TotalVideoModes: Cardinal read FTotalVideoModes;
  664.     // Current video mode index in @Link(FVideoModes) array
  665.     property CurrentVideoMode: Cardinal read FCurrentVideoMode;
  666.     // Video modes available by index
  667.     property VideoMode[Index: Cardinal]: TVideoMode read GetVideoMode;
  669.     // Current renderer state
  670.     property State: TRendererState read FState;
  671.     // Rendering area in windowed mode
  672.     property WindowedRect: TRect read FWindowedRect;
  673.     // Current depth of Z-buffer
  674.     property CurrentZBufferDepth: Cardinal read FCurrentZBufferDepth;
  675.     // Additional render targets currently allocated
  676.     property TotalRenderTargets: Integer read GetRenderTargetsAllocated;
  677.   end;
  679. implementation
  681. const
  682.   // Debug tesselator indices
  683.   dtiBox = 0; dtiSphere = 1;
  685. type
  686.   TRenderTargetEmptyDelegate = function(const Element: TRenderTarget): Boolean of object;
  687.   TTextureEmptyDelegate      = function(const Element: TTexture): Boolean of object;
  688.   TShaderEmptyDelegate       = function(const Element: TShader): Boolean of object;
  690. function ResourceAdd_RenderTarget(var Elements: TRenderTargets; IsEmpty: TRenderTargetEmptyDelegate): Integer;
  691. begin {$Include C2RenderResourceAdd.Inc} end;
  693. function ResourceAdd_Texture(var Elements: TTextureArray; IsEmpty: TTextureEmptyDelegate): Integer;
  694. begin {$Include C2RenderResourceAdd.Inc} end;
  696. function ResourceAdd_Shader(var Elements: TShaders; IsEmpty: TShaderEmptyDelegate): Integer;
  697. begin {$Include C2RenderResourceAdd.Inc} end;
  699. { TAPIBuffers }
  701. constructor TAPIBuffers.Create(ARenderer: TRenderer);
  702. begin
  703.   Renderer := ARenderer;
  704. end;
  706. destructor TAPIBuffers.Destroy;
  707. begin
  708.   Clear;
  709.   inherited;
  710. end;
  712. { TBuffers }
  714. procedure TBuffers.ResetBuffers;
  715. var i: TTesselationBuffer; j: Integer;
  716. begin
  717.   for i := Low(TTesselationBuffer) to High(TTesselationBuffer) do for j := 0 to High(Buffers[i, True]) do begin
  718.     Buffers[i, False, j].Index        :=-1;
  719.     Buffers[i, False, j].Size         := 0;
  720.     Buffers[i, False, j].Position     := 0;
  721.     Buffers[i, False, j].ResetCounter := 0;
  723.     Buffers[i, True, j].Index        :=-1;
  724.     Buffers[i, True, j].Size         := 0;
  725.     Buffers[i, True, j].Position     := 0;
  726.     Buffers[i, True, j].ResetCounter := 0;
  727.   end;
  728. end;
  730. constructor TBuffers.Create(ARenderer: TRenderer);
  731. begin
  732.   ResetCounter := 1;
  733.   Renderer := ARenderer;
  734.   ResetBuffers;
  735. end;
  737. destructor TBuffers.Destroy;
  738. begin
  739. //  Reset;
  740.   inherited;
  741. end;
  743. function TBuffers.Put(Tesselator: TTesselator): Boolean;
  744. const
  745.   BufName: array[TTesselationBuffer] of string[6] = ('vertex',  'index');
  746.   BufTypeName: array[Boolean]         of string[7] = ('dynamic', 'static');
  747.   DefaultBufferSize: array[Boolean, TTesselationBuffer] of Integer = ((4096*4, 4096*4), (4096, 4096));
  748.   MaxBufferSize: array[Boolean, TTesselationBuffer] of Integer = ((65536*8, 65536), (65536*32, 65536*8));
  749. var
  750.   TesselatorMaxAmount, ElementSize: array[TTesselationBuffer] of Integer;
  751.   PTR: PByte; BufIndex, Amount: Integer;
  753.   function PutToBuffer(BufferType: TTesselationBuffer; Static: Boolean): Boolean;
  755.     procedure ResetAndPlaceFirst;
  756.     begin
  757.       Buffers[BufferType, Static, BufIndex].Position := TesselatorMaxAmount[BufferType];    // Increase by max amount of elements
  758.       Inc(Buffers[BufferType, Static, BufIndex].ResetCounter);
  759.       Tesselator.TesselationStatus[BufferType].Offset := 0;
  760.       Tesselator.TesselationStatus[BufferType].LastResetCounter := ResetCounter;
  761.       Tesselator.TesselationStatus[BufferType].LastBufferResetCounter := Buffers[BufferType, Static, BufIndex].ResetCounter;
  762.       Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].BufferResetsCount[Static]);
  763.     end;
  765.     function CreateBuffer: Boolean;
  766.     begin
  767.       case BufferType of
  768.         tbVertex: Buffers[BufferType, Static, BufIndex].Index := Renderer.APIBuffers.CreateVertexBuffer(Buffers[BufferType, Static, BufIndex].Size, Static);
  769.         tbIndex:  Buffers[BufferType, Static, BufIndex].Index := Renderer.APIBuffers.CreateIndexBuffer( Buffers[BufferType, Static, BufIndex].Size, Static);
  770.       end;
  771.       Result := Buffers[BufferType, Static, BufIndex].Index <> -1;
  772.       if Result then Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].BufferSize[Static], Buffers[BufferType, Static, BufIndex].Size);
  773.     end;
  775.     function ResizeBuffer(NewBufferSize: Integer): Boolean;
  776.     begin
  777.       Result := False;
  778.       case BufferType of
  779.         tbVertex: Result := Renderer.APIBuffers.ResizeVertexBuffer(Buffers[BufferType, Static, BufIndex].Index, NewBufferSize);
  780.         tbIndex:  Result := Renderer.APIBuffers.ResizeIndexBuffer( Buffers[BufferType, Static, BufIndex].Index, NewBufferSize);
  781.       end;
  782.       if Result then begin
  783.         Dec(Renderer.FPerfProfile.BuffersProfile[BufferType].BufferSize[Static], Buffers[BufferType, Static, BufIndex].Size);
  784.         Buffers[BufferType, Static, BufIndex].Size := NewBufferSize;
  785.         Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].BufferSize[Static], Buffers[BufferType, Static, BufIndex].Size);
  786.       end;
  787.     end;
  789.   var Discard: Boolean; NewSize: Integer;
  790.   begin
  791.     Result := True;
  792.     // Check if tesselation not needed
  793.     if ( Static and                                                                    // not needed for dynamic buffers
  794.          (Tesselator.TesselationStatus[BufferType].Status = tsTesselated) and
  795.          (Renderer.DisableTesselation or (Tesselator.GetUpdatedElements(BufferType, Renderer.TesselationParams) = 0)) and
  796.          (Tesselator.TesselationStatus[BufferType].LastResetCounter >= ResetCounter) and
  797.          (Tesselator.TesselationStatus[BufferType].LastBufferResetCounter >= Buffers[BufferType, Static, BufIndex].ResetCounter) ) then begin
  798.          Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].TesselationsBypassed);
  799.          Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].BytesBypassed, TesselatorMaxAmount[BufferType] * ElementSize[BufferType]);
  800.          Exit;
  801.        end;
  803.     Result := False;
  805.     // Check if the tesselator never tesselated since last reset/discard or changed its size
  806.     if not Static or
  807.        (Tesselator.TesselationStatus[BufferType].Status = tsMaxSizeChanged) or
  808.        (Tesselator.TesselationStatus[BufferType].LastResetCounter < ResetCounter) or
  809.        (Tesselator.TesselationStatus[BufferType].LastBufferResetCounter < Buffers[BufferType, Static, BufIndex].ResetCounter) then begin
  811.       if Static and (Tesselator.TesselationStatus[BufferType].Status = tsMaxSizeChanged) then begin
  812.         {$IFDEF DEBUGMODE}
  813.         Log.Log('TBuffers.Put: A size-changing tesselator placed in a static buffer. Discarding buffer contents...', lkWarning);
  814.         {$ENDIF}
  815.         ResetAndPlaceFirst;
  816.         Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].TesselationsPerformed[Static]);
  817.       end else begin
  818.         Tesselator.TesselationStatus[BufferType].Offset           := Buffers[BufferType, Static, BufIndex].Position;
  819.         Tesselator.TesselationStatus[BufferType].LastResetCounter := ResetCounter;
  820.         Tesselator.TesselationStatus[BufferType].LastBufferResetCounter := Buffers[BufferType, Static, BufIndex].ResetCounter;
  821.         Inc(Buffers[BufferType, Static, BufIndex].Position, TesselatorMaxAmount[BufferType]);                 // Increase by max amount of elements
  822.         Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].TesselationsPerformed[Static]);
  823.       end;
  824.     end;
  826.     // Allocate a buffer if needed
  827.     if Buffers[BufferType, Static, BufIndex].Index = -1 then begin
  828.       Buffers[BufferType, Static, BufIndex].Size := MaxI(DefaultBufferSize[Static, BufferType], TesselatorMaxAmount[BufferType]) * ElementSize[BufferType];
  829.       if not CreateBuffer then Exit;
  830.     end;
  832.     Discard := False;
  834.     // Check buffer size and remaining space
  835.     if ((Tesselator.TesselationStatus[BufferType].Offset + TesselatorMaxAmount[BufferType]) * ElementSize[BufferType] > Buffers[BufferType, Static, BufIndex].Size) then
  836.       if Static or (TesselatorMaxAmount[BufferType] * ElementSize[BufferType] > Buffers[BufferType, Static, BufIndex].Size) then begin
  837.         // Resize buffer
  838.         NewSize := (Tesselator.TesselationStatus[BufferType].Offset * Ord(Static) + TesselatorMaxAmount[BufferType]) * ElementSize[BufferType];
  839.         Log.Log(Format('TBuffers.Put: Insufficient %S %S buffer size: Buffer: [%D], will try to resize to %D',
  840.                        [BufTypeName[Static], BufName[BufferType], Buffers[BufferType, Static, BufIndex].Size,
  841.                          NewSize]), lkNotice);
  843.         if NewSize <= MaxBufferSize[Static, BufferType] * ElementSize[BufferType] then begin
  844.           if not ResizeBuffer(NewSize) then Exit;
  845.           ResetAndPlaceFirst;
  846.         end else begin
  847.           Log.Log(Format('TBuffers.Put: Resize failed: Maximum %S %S buffer size reached: [%D], needed: [%D]',
  848.                          [BufTypeName[Static], BufName[BufferType], MaxBufferSize[Static, BufferType] * ElementSize[BufferType], NewSize]), lkError);
  849.           Exit;
  850.         end;
  851.       end else begin
  852.         // Reset buffer to beginning
  853.         Discard := True;
  854.         ResetAndPlaceFirst;
  855.       end;
  857.     // Lock and tesselate
  858.     case BufferType of
  859.       tbVertex: begin
  860. //        Log.Log('*** VB lock ***', lkDebug);
  861.         PTR := Renderer.APIBuffers.LockVertexBuffer(Buffers[BufferType, Static, BufIndex].Index,
  862.                                                     Tesselator.TesselationStatus[BufferType].Offset * ElementSize[BufferType],
  863.                                                     TesselatorMaxAmount[BufferType] * ElementSize[BufferType],
  864.                                                     Discard);
  865.         if PTR = nil then Exit;
  867.         Amount := Tesselator.Tesselate(Renderer.TesselationParams, PTR);
  868.         Renderer.APIBuffers.UnlockVertexBuffer(Buffers[BufferType, Static, BufIndex].Index);
  870.         Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].BytesWritten[Static], Amount * ElementSize[BufferType]);
  871. //        Log.Log('*** VB unlock ***', lkdebug);
  872.         Assert(Amount <= TesselatorMaxAmount[BufferType], Format('TBuffers.Put: Tesselated amount %D is greater then maximal %D', [Amount, TesselatorMaxAmount[BufferType]]));
  873.       end;
  874.       tbIndex: begin
  875. //        Log.Log('*** IB lock ***', lkdebug);
  876.         PTR := Renderer.APIBuffers.LockIndexBuffer(Buffers[BufferType, Static, BufIndex].Index,
  877.                                                    Tesselator.TesselationStatus[BufferType].Offset * ElementSize[BufferType],
  878.                                                    TesselatorMaxAmount[BufferType] * ElementSize[BufferType],
  879.                                                    Discard);
  880.         if PTR = nil then Exit;
  881.         Amount := Tesselator.SetIndices(PTR);
  882.         TesselatorMaxAmount[BufferType] := Amount;
  883.         Renderer.APIBuffers.UnlockIndexBuffer(Buffers[BufferType, Static, BufIndex].Index);
  884. //        Log.Log('*** IB unlock ***', lkdebug);
  885.       end;
  886.     end;
  887.     Inc(Renderer.FPerfProfile.BuffersProfile[BufferType].BytesWritten[Static], Amount * ElementSize[BufferType]);
  889.     Result := TesselatorMaxAmount[BufferType] <> 0;
  890.   end;
  892. var i: TTesselationBuffer;
  894. begin
  895.   Tesselator.TesselationStatus[tbVertex].BufferIndex := Tesselator.VertexSize div 4;
  896.   Tesselator.TesselationStatus[tbIndex].BufferIndex  := 0;
  898.   ElementSize[tbVertex] := Tesselator.VertexSize;
  899.   ElementSize[tbIndex]  := IndicesSize;
  901.   for i := Low(TTesselationBuffer) to High(TTesselationBuffer) do begin
  902.     BufIndex := Tesselator.TesselationStatus[i].BufferIndex;
  903.     TesselatorMaxAmount[i] := Tesselator.GetMaxAmount(i);
  905.     if TesselatorMaxAmount[i] <> 0 then
  906.       Result := PutToBuffer(i, Tesselator.TesselationStatus[i].TesselatorType = ttStatic) else
  907.         Result := (i <> tbVertex);                      // No vertices
  909.     if not Result then Break;
  910.   end;
  912.   if Result then
  913.     Renderer.APIBuffers.AttachVertexBuffer(Buffers[tbVertex, Tesselator.TesselationStatus[tbVertex].TesselatorType = ttStatic, Tesselator.TesselationStatus[tbVertex].BufferIndex].Index, 0, Tesselator.VertexSize);
  914. end;
  916. procedure TBuffers.Reset;
  917. begin
  918.   Inc(ResetCounter);
  919.   ResetBuffers;
  920.   Renderer.FPerfProfile.OnBuffersReset;
  921.   Renderer.APIBuffers.Clear;
  922. end;
  924. { TAPIStateWrapper }
  926. function TAPIStateWrapper.CreateShader(var Shaders: TShaders; Item: TShaderResource): Integer;
  927. begin
  928.   Result := tivUnresolved;
  929.   // Check if resource is valid
  930.   if Item = nil then begin
  931.     {$IFDEF LOGGING} Log.Log('TRenderer.CreateShader: no resource specified', lkError); {$ENDIF}
  932.     Exit;
  933.   end;
  935.   Result := High(Shaders);
  936.   while (Result >= 0) and (Shaders[Result].Resource <> Item) do Dec(Result);
  938.   if Result >= 0 then Exit;                            // A shader from the given resource already created
  940.   SetLength(Shaders, Length(Shaders) + 1);
  941.   Result := High(Shaders);
  943.   Shaders[Result].Shader   := tivUnresolved;
  944.   Shaders[Result].Resource := Item;
  945. end;
  947. function TAPIStateWrapper.IsRenderTargetEmpty(const Element: TRenderTarget): Boolean;
  948. begin Result := not Assigned(Element.ColorBuffer) and not Assigned(Element.DepthBuffer); end;
  950. function TAPIStateWrapper.IsShaderEmpty(const Element: TShader): Boolean;
  951. begin Result := not Assigned(Element.Resource); end;
  953. function TAPIStateWrapper.ResolveVertexShader(Pass: TRenderPass): Boolean;
  954. var ShaderResource: TShaderResource;
  955. begin
  956.   Pass.ResolveVertexShader(ShaderResource);
  957.   if (Pass.VertexShaderIndex = sivUnresolved) and Assigned(ShaderResource) then
  958.     Pass.VertexShaderIndex := CreateVertexShader(ShaderResource, Pass.VertexDeclaration);
  959.   Result := Pass.VertexShaderIndex <> tivUnresolved;
  960. end;
  962. function TAPIStateWrapper.ResolvePixelShader(Pass: TRenderPass): Boolean;
  963. var ShaderResource: TShaderResource;
  964. begin
  965.   Pass.ResolvePixelShader(ShaderResource);
  966.   if (Pass.PixelShaderIndex = sivUnresolved) and Assigned(ShaderResource) then
  967.     Pass.PixelShaderIndex := CreatePixelShader(ShaderResource);
  968.   Result := Pass.PixelShaderIndex <> tivUnresolved;
  969. end;
  971. function TAPIStateWrapper.CreateVertexShader(Item: TShaderResource; Declaration: TVertexDeclaration): Integer;
  972. begin
  973.   Result := CreateShader(FVertexShaders, Item);
  974. end;
  976. function TAPIStateWrapper.CreatePixelShader(Item: TShaderResource): Integer;
  977. begin
  978.   Result := CreateShader(FPixelShaders, Item);
  979. end;
  981. procedure TAPIStateWrapper.ApplyClipPlanes;
  982. var i: Integer; m: TMatrix4s; Plane: TPlane;
  983. begin
  984.   if VertexShaderFlag then begin                           // Transform clip planes if programmable vertex pipeline used
  985.     for i := 0 to MaxClipPlanes-1 do
  986.       if Assigned(Renderer.LastAppliedCamera) and Assigned(Renderer.LastAppliedCamera.ClipPlanes[i]) then begin
  987.         Plane := Camera.ClipPlanes[i]^;
  989.         m := Camera.TotalMatrix;
  991.         m := InvertMatrix4s(m);
  992.         m := GetTransposedMatrix4s(m);
  993.         Plane.V := Transform4Vector4s(m, Plane.V);
  995.         SetClipPlane(i, @Plane);
  996.       end else SetClipPlane(i, nil);
  997.   end else if Assigned(Camera) then for i := 0 to MaxClipPlanes-1 do SetClipPlane(i, Camera.ClipPlanes[i]);
  998. end;
  1000. procedure TAPIStateWrapper.HandleItemReplace(OldItem, NewItem: TItem);
  1001. var i: Integer;
  1002. begin
  1003.   if not Assigned(OldItem) then Exit;
  1004.   for i := High(FVertexShaders) downto 0 do if FVertexShaders[i].Resource = OldItem then FVertexShaders[i].Resource := NewItem as TShaderResource;
  1005.   for i := High(FPixelShaders)  downto 0 do if FPixelShaders[i].Resource  = OldItem then FPixelShaders[i].Resource  := NewItem as TShaderResource;
  1006.   if OldItem = Camera then if Assigned(NewItem) then Camera := NewItem as TCamera else Camera := DefaultCamera;
  1007. end;
  1009. procedure TAPIStateWrapper.HandleDataChange(Data: Pointer);
  1010. var i: Integer;
  1011. begin
  1012.   for i := 0 to High(FVertexShaders) do if FVertexShaders[i].Resource = TShaderResource(Data) then
  1013. end;
  1015. constructor TAPIStateWrapper.Create;
  1016. begin
  1017.   inherited;
  1018.   DefaultCamera := TCamera.Create(nil);
  1019.   DefaultCamera.DefaultFillMode := fmSOLID;
  1020.   DefaultCamera.DefaultCullMode := cmCCW;
  1021. end;
  1023. destructor TAPIStateWrapper.Destroy;
  1024. begin
  1025.   FreeAndNil(DefaultCamera);
  1026.   inherited;
  1027. end;
  1029. procedure TAPIStateWrapper.HandleMessage(const Msg: TMessage);
  1030. begin
  1031.   if (Msg.ClassType = TSceneClearMsg) then begin
  1032.     Camera := DefaultCamera;
  1033.   end else if Msg.ClassType = TDataModifyMsg then begin
  1034.     HandleDataChange(TDataModifyMsg(Msg).Data);
  1035.   end else if (Msg.ClassType = TRemoveFromSceneMsg) or (Msg.ClassType = TDestroyMsg) then HandleItemReplace(TItemNotificationMessage(Msg).Item, nil);
  1036. end;
  1038. procedure TAPIStateWrapper.SetShaderConstant(const Constant: TShaderConstant);
  1039. begin
  1040.   APISetShaderConstant(Constant);
  1041. end;
  1043. procedure TAPIStateWrapper.SetShaderConstant(ShaderKind: TShaderKind; ShaderRegister: Integer; const Vector: TShaderRegisterType);
  1044. begin
  1045.   APISetShaderConstant(ShaderKind, ShaderRegister, Vector); 
  1046. end;
  1048. function TAPIStateWrapper.ValidatePass(const Pass: TRenderPass): Boolean;
  1049. const ResultID: array[Boolean] of string[4] = ('Fail', 'OK');
  1050. var ResultStr: string;
  1051. begin
  1052.   Result := True;
  1053.   if not Assigned(Pass) then Exit;
  1054.   ResultStr := '';
  1055.   {$IFDEF DEBUGMODE}
  1056.   Log.Log('  Validating pass "' + Pass.Name + '"...');
  1057.   {$ENDIF}
  1058.   LastError := reNone;
  1059.   ApplyPass(Pass);
  1060.   if LastError <> reNone then begin
  1061.     case LastError of
  1062.       reTooManyStages:   ResultStr := ' (too many stages)';
  1063.       reTooManyTextures: ResultStr := ' (too many textures)';
  1064.       reVertexShaderAssembleFail: ResultStr := ' (failed to assemble vertex shader)';
  1065.       reVertexShaderCreateFail:   ResultStr := ' (failed to create vertex shader)';
  1066.       rePixelShaderAssembleFail:  ResultStr := ' (failed to assemble pixel shader)';
  1067.       rePixelShaderCreateFail:    ResultStr := ' (failed to create pixel shader)';
  1068.       reNoDepthTextures:          ResultStr := ' (depth textures are not supported)';
  1069.     end;
  1070.     Result := False;
  1071.   end else Result := APIValidatePass(Pass, ResultStr);
  1073.   Log.Log('  Pass validation result: ' + ResultID[Result] + ResultStr);
  1074. end;
  1076. { TRenderer }
  1078. function TRenderer.GetAdapterName(Index: Cardinal): string;
  1079. begin
  1080.   Result := '';
  1081.   if Index < FTotalAdapters then Result := FAdapterNames[Index];
  1082. end;
  1084. function TRenderer.GetVideoMode(Index: Cardinal): TVideoMode;
  1085. begin
  1086.   Assert(Index < FTotalVideoModes, ClassName + '.GetVideoMode: Invalid index');
  1087. //  if Index < FTotalVideoModes then
  1088.   Result := FVideoModes[Index];
  1089. //   else Result := DesktopVideoMode;
  1090. end;
  1092. // Render target operations
  1094. function TAPIStateWrapper.NewRenderTarget(const Camera: TCamera): Integer;
  1095. begin
  1096.   Result := ResourceAdd_RenderTarget(FRenderTargets, {$IFDEF OBJFPCEnable}@{$ENDIF}IsRenderTargetEmpty);
  1098.   if CreateRenderTarget(Result, Camera.RenderTargetWidth, Camera.RenderTargetHeight, Camera.RTColorFormat, Camera.RTDepthFormat, Camera.IsDepthTexture) then begin
  1099.     Camera.ColorFormat := FRenderTargets[Result].ActualColorFormat;
  1100.     Camera.DepthFormat := FRenderTargets[Result].ActualDepthFormat;
  1101.   end else Result := -1; 
  1102. end;
  1104. procedure TAPIStateWrapper.RemoveRenderTarget(Index: Integer);
  1105. begin
  1106.   Assert((Index >= 0) and (Index <= High(FRenderTargets)));
  1107.   DestroyRenderTarget(Index);
  1108.   FRenderTargets[Index].ColorBuffer  := nil;
  1109.   FRenderTargets[Index].DepthBuffer  := nil;
  1110.   FRenderTargets[Index].ColorTexture := nil;
  1111.   FRenderTargets[Index].DepthTexture := nil;
  1112.   FRenderTargets[Index].LastUpdateFrame := -1;
  1113.   FRenderTargets[Index].IsDepthTexture := False;
  1114. end;
  1116. function TAPIStateWrapper.FindRenderTarget(const ACamera: TCamera): Integer;
  1117. begin
  1118.   Result := ACamera.RenderTargetIndex;
  1119.   if (Result <> -1) and
  1120.     ((ACamera.RenderTargetWidth <> FRenderTargets[Result].Width)   or (ACamera.RenderTargetHeight <> FRenderTargets[Result].Height) or
  1121.      (ACamera.RTColorFormat <> FRenderTargets[Result].ColorFormat) or (ACamera.RTDepthFormat <> FRenderTargets[Result].DepthFormat)) then begin
  1122.     RemoveRenderTarget(Result);
  1123.     Result := -1;
  1124.   end;                                           
  1125.   if Result = -1 then Result := NewRenderTarget(ACamera);
  1126. end;
  1128. function TAPIStateWrapper.IsRenderTargetUptoDate(const ACamera: TCamera): Boolean;
  1129. begin
  1130.   Result := (ACamera.RenderTargetIndex >= 0) and (ACamera.RenderTargetIndex <= High(FRenderTargets)) and
  1131.             (Renderer.FramesRendered - FRenderTargets[ACamera.RenderTargetIndex].LastUpdateFrame <= ACamera.FrameSkip);
  1132. end;
  1134. function TRenderer.GetRenderTargetsAllocated: Integer;
  1135. begin
  1136.   if Assigned(APIState) then Result := Length(APIState.FRenderTargets) else Result := 0;
  1137. end;
  1139. procedure TRenderer.InternalDeInit;
  1140. var i: Integer;
  1141. begin
  1142.   {$IFDEF LOGGING}
  1143.   Log.Log('Shutting down ' + ClassName, lkNotice);
  1144.   {$ENDIF}
  1145.   for i := 0 to Length(DebugTesselators)-1 do DebugTesselators[i].Free;
  1146.   DebugTesselators := nil;
  1147.   FreeAndNil(Buffers);
  1148.   FreeAndNil(Textures);
  1149.   FreeAndNil(APIState);
  1150. end;
  1152. function TRenderer.InternalGetIndexBufferIndex(Static: Boolean; BufferIndex: Integer): Integer;
  1153. begin
  1154.   Result := Buffers.Buffers[tbIndex, Static, BufferIndex].Index;
  1155. end;
  1157. procedure TRenderer.SetDebugOutput(const Value: Boolean);
  1158. begin
  1159.   FDebugOutput := Value;
  1160.   if FDebugOutput then begin
  1161.     if (DebugTesselators = nil) or (DebugMaterial = nil) then begin
  1162.       FDebugOutput := False;
  1163.       ErrorHandler(TError.Create(ClassName + '.SetDebugOutput: Debug render has not been initialized'));
  1164.     end;
  1165.   end;
  1166. end;
  1168. function TRenderer.APIToPixelFormat(Format: Cardinal): Cardinal;
  1169. var i: Integer;
  1170. begin
  1171.   Result := pfUndefined;
  1172.   for i := 0 to High(PFormats) do if PFormats[i] = Format then begin
  1173.     Result := i;
  1174.     Exit;
  1175.   end;
  1176. end;
  1178. procedure TRenderer.SetFullScreen(const FScreen: Boolean);
  1179. begin
  1180.   if FFullScreen = FScreen then Exit;
  1181.   if State <> rsNotReady then RestoreDevice(FCurrentVideoMode, FScreen);
  1182. end;
  1184. constructor TRenderer.Create(AManager: TItemsManager);
  1185. begin
  1186.   Assert(Assigned(AManager), Format('%S.%S: AManager should be assigned', [ClassName, 'Create']));
  1187.   Manager := AManager;
  1189.   AppRequirements.MinYResolution       := 480;
  1190.   AppRequirements.HWAccelerationLevel  := haMixedVP;
  1191.   AppRequirements.TotalBackBuffers     := 1;
  1192.   AppRequirements.Flags                := [arUseStencil, arUseZBuffer];
  1194.   FCurrentVideoMode := $FFFFFFFF;
  1195.   FFramesRendered   := 0;
  1197.   BiasMat._11 := 0.5; BiasMat._12 := 0.0; BiasMat._13 := 0.0;        BiasMat._14 := 0.0;
  1198.   BiasMat._21 := 0.0; BiasMat._22 :=-0.5; BiasMat._23 := 0.0;        BiasMat._24 := 0.0;
  1199.   BiasMat._31 := 0.0; BiasMat._32 := 0.0; BiasMat._33 := 1 shl 24-1; BiasMat._34 := 0.0;
  1200.   BiasMat._41 := 0.0; BiasMat._42 := 0.0; BiasMat._43 := 0.0;        BiasMat._44 := 1.0;
  1202.   Buffers := TBuffers.Create(Self);
  1203. end;
  1205. procedure TRenderer.SetVideoAdapter(Adapter: Cardinal);
  1206. begin
  1207.   if Adapter >= FTotalAdapters then Exit;                  // ToDo: make error handling
  1208.   FCurrentAdapter := Adapter;
  1209.   BuildModeList;
  1210.   FState          := rsNotReady;
  1211. end;
  1213. procedure TRenderer.InitDebugRender(ADebugMaterial: TMaterial);
  1214. begin
  1215.   SetLength(DebugTesselators, 2);
  1216.   DebugTesselators[dtiBox]    := TBoxTesselator.Create;
  1217.   DebugTesselators[dtiSphere] := TSphereTesselator.Create;
  1219.   DebugMaterial := ADebugMaterial;
  1221.   FDebugOutput := True;
  1222. end;
  1224. function TRenderer.IsReady: Boolean;
  1225. begin
  1226.   Result := State = rsOK;
  1227. end;
  1229. procedure TRenderer.SetGamma(Gamma, Contrast, Brightness: Single);
  1230. var i: Integer; k: Single; Value: Word;
  1231. begin
  1232.   {$IFDEF LOGGING}
  1233.   if (Abs(Gamma - 1) > 0.7) or (Abs(Contrast - 1) > 0.7) or (Abs(Brightness - 1) > 0.7) then
  1234.     Log.Log(Format('%S.SetGamma: Extreme values: Gamma - %F, Contrast - %F, Brightness - %F', [ClassName, Gamma, Contrast, Brightness]), lkWarning);
  1235.   {$ENDIF}
  1236.   for i := 0 to 255 do begin
  1237.     k := i/255.0;
  1238.     if i > 0 then k := Basics.Power(k, 1/Basics.MaxS(BaseTypes.Epsilon, Gamma));
  1239.     Value := Trunc(0.5 + MinS(65535, MaxS(0, (k*Contrast+(Brightness-1))*65535)));
  1241.     GammaRamp.R[i] := Value;
  1242.     GammaRamp.G[i] := Value;
  1243.     GammaRamp.B[i] := Value;
  1244.   end;
  1245. end;
  1247. procedure TRenderer.HandleMessage(const Msg: TMessage);
  1248. begin
  1249.   if (State = rsNotReady) or (State = rsNotInitialized) then Exit;
  1250.   if Msg.ClassType = TWindowActivateMsg then begin
  1251.     if not Active then begin
  1252.       Active := True;
  1253. //      ShowWindow(RenderWindowHandle, SW_SHOWDEFAULT);
  1254.       RestoreDevice(FCurrentVideoMode, FFullScreen);
  1255.     end;
  1256.   end else if Msg.ClassType = TWindowDeactivateMsg then begin
  1257.     if FullScreen then Active := False;
  1258.   end else if Msg.ClassType = TWindowResizeMsg then with TWindowResizeMsg(Msg) do begin
  1259.     if (State <> rsNotReady) then begin
  1260.       if not Active then begin
  1261.         Active := True;
  1262.         RestoreDevice(FCurrentVideoMode, FFullScreen);
  1263.       end else if not FullScreen then begin
  1264.         {if Active then }RestoreDevice(FCurrentVideoMode, FFullScreen)
  1265. //         else PrepareWindow;
  1266.       end;
  1267.       if Assigned(MainCamera) and (NewHeight <> 0) then
  1268.         MainCamera.SetScreenDimensions(Round(NewWidth), Round(NewHeight), True);
  1269.     end;
  1270.   end else if Msg.ClassType = TWindowMoveMsg then begin
  1271.     if not FullScreen then PrepareWindow;
  1272.   end else if Msg.ClassType = TWindowMinimizeMsg then begin
  1273.     Active := False;
  1274.   end else if (Msg.ClassType = TSceneClearMsg) then begin
  1275.     MainCamera := nil;
  1276.     FLastAppliedCamera := nil;
  1277.   end else begin
  1278.     if (Msg.ClassType = TRemoveFromSceneMsg) or (Msg.ClassType = TDestroyMsg) then with TItemNotificationMessage(Msg) do if Item = MainCamera then MainCamera := nil;
  1279.   end;
  1281.   APIState.HandleMessage(Msg);
  1282.   Textures.HandleMessage(Msg);
  1283. end;
  1285. function TRenderer.CheckFormat(const Format, Usage, RTFormat: Cardinal; out NewFormat: Integer): Boolean;
  1286. {  pfUndefined    = 0; pfR8G8B8    = 1; pfA8R8G8B8  = 2; pfX8R8G8B8  = 3;
  1287.   pfR5G6B5       = 4; pfX1R5G5B5  = 5; pfA1R5G5B5  = 6; pfA4R4G4B4  = 7;
  1288.   pfA8           = 8; pfX4R4G4B4  = 9; pfA8P8      = 10; pfP8       = 11; pfL8     = 12; pfA8L8      = 13; pfA4L4 = 14;
  1289.   pfV8U8         = 15; pfL6V5U5   = 16; pfX8L8V8U8 = 17; pfQ8W8V8U8 = 18; pfV16U16 = 19; pfW11V11U10 = 20;
  1290.   pfD16_LOCKABLE = 21; pfD32      = 22; pfD15S1    = 23; pfD24S8    = 24; pfD16    = 25; pfD24X8     = 26; pfD24X4S4 = 27;
  1291.   pfB8G8R8       = 28; pfA8B8G8R8 = 29;
  1292.   pfAuto = $FFFFFFFF;}
  1293. const
  1294.   SubstFormats = 19; SubstVariants = 7;
  1295.   FormatSubst: array[0..SubstFormats-1, 0..SubstVariants-1] of Cardinal = (
  1296.  (pfR8G8B8,       pfX8R8G8B8, pfA8B8G8R8, pfB8G8R8,   pfR5G6B5,   pfX1R5G5B5, pfA4R4G4B4),
  1297.  (pfA8R8G8B8,     pfA8B8G8R8, pfA4R4G4B4, pfA1R5G5B5, pfX8R8G8B8, pfR8G8B8,   pfR5G6B5),
  1298.  (pfX8R8G8B8,     pfA8R8G8B8, pfR8G8B8,   pfB8G8R8,   pfA8B8G8R8, pfR5G6B5,   pfX1R5G5B5),
  1299.  (pfR5G6B5,       pfX1R5G5B5, pfA1R5G5B5, pfX8R8G8B8, pfA8R8G8B8, pfB8G8R8,   pfA4R4G4B4),
  1300.  (pfX1R5G5B5,     pfR5G6B5,   pfA1R5G5B5, pfX8R8G8B8, pfR8G8B8,   pfB8G8R8,   pfA4R4G4B4),
  1301.  (pfA1R5G5B5,     pfA4R4G4B4, pfA8R8G8B8, pfA8B8G8R8, pfR5G6B5,   pfX8R8G8B8, pfR8G8B8),
  1302.  (pfA4R4G4B4,     pfA1R5G5B5, pfA8R8G8B8, pfA8B8G8R8, pfR5G6B5,   pfX8R8G8B8, pfR8G8B8),
  1303.  (pfX4R4G4B4,     pfR5G6B5,   pfA1R5G5B5, pfX8R8G8B8, pfR8G8B8,   pfB8G8R8,   pfA4R4G4B4),
  1304.  (pfB8G8R8,       pfA8B8G8R8, pfR8G8B8,   pfX8R8G8B8, pfR5G6B5,   pfX1R5G5B5, pfA4R4G4B4),
  1305.  (pfA8B8G8R8,     pfA8R8G8B8, pfA4R4G4B4, pfA1R5G5B5, pfX8R8G8B8, pfB8G8R8,   pfR5G6B5),
  1307.  (pfA8,           pfL8,       pfA8L8,     pfA8P8,     pfA8R8G8B8, pfA8B8G8R8, pfA4R4G4B4),
  1308.  (pfL8,           pfA8,       pfA8L8,     pfA8P8,     pfR8G8B8,   pfB8G8R8,   pfR5G6B5),
  1310.  (pfD16_LOCKABLE, pfD16,      pfD15S1,    pfD24X8,    pfD24X4S4,  pfD32,      pfD24S8),
  1311.  (pfD32,          pfD24X8,    pfATIDF24,  pfD24S8,    pfD16,      pfD15S1,    pfD16_LOCKABLE),
  1312.  (pfD15S1,        pfD24X4S4,  pfD24S8,    pfD16,      pfD32,      pfD24X8,    pfD16_LOCKABLE),
  1313.  (pfD24S8,        pfD24X4S4,  pfD15S1,    pfD32,      pfATIDF24,  pfD16,      pfATIDF16),
  1314.  (pfD16,          pfD15S1,    pfD24X8,    pfATIDF16,  pfD32,      pfD24S8,    pfD16_LOCKABLE),
  1315.  (pfD24X8,        pfD32,      pfD24X4S4,  pfD24S8,    pfD16,      pfD15S1,    pfD16_LOCKABLE),
  1316.  (pfD24X4S4,      pfD24S8,    pfD15S1,    pfD32,      pfD24X8,    pfD16,      pfD16_LOCKABLE)
  1317.  );
  1318. var i, j: Integer;
  1319. begin
  1320.   NewFormat := Format;
  1321.   Result := APICheckFormat(NewFormat, Usage, RTFormat);
  1322.   if Result then Exit;
  1324.   NewFormat := pfUndefined;
  1326.   i := SubstFormats-1;
  1327.   while (i >= 0) and not (Format = FormatSubst[i, 0]) do Dec(i);
  1328.   if i < 0 then Exit;
  1330.   j := 0;
  1331.   while (j < SubstVariants) and not APICheckFormat(FormatSubst[i, j], Usage, RTFormat) do Inc(j);
  1332.   if j < SubstVariants then NewFormat := FormatSubst[i, j];
  1333. end;
  1335. function TRenderer.ValidateMaterial(const Material: TMaterial): Boolean;
  1337.   function ValidateTechnique(const Technique: TTechnique): Boolean;
  1338.   var i: Integer;
  1339.   begin
  1340.     i := Technique.TotalPasses-1;
  1341.     while (i >= 0) and APIState.ValidatePass(Technique.Passes[i]) do Dec(i);
  1342.     Result := i < 0;
  1343.     Technique.Valid := Result and (isVisible in Technique.State);
  1344.   end;
  1346. var i: Integer; OldValid: Boolean;
  1347. begin
  1348.   Result := False;
  1349.   Log.Log('Validating material "' + Material.Name + '"...');
  1350.   for i := 0 to Material.TotalTechniques-1 do if Assigned(Material.Technique[i]) then begin
  1351.     OldValid := Material.Technique[i].Valid;
  1352.     if not ValidateTechnique(Material.Technique[i]) then
  1353.       Log.Log('Technique "' + Material.Technique[i].Name + '" did not pass validation', lkWarning);
  1354.     Result := Result or (OldValid <> Material.Technique[i].Valid);
  1355.   end;
  1356. end;
  1358. function TRenderer.PrepareWindow: Boolean;
  1359. var TempRect: OSUtils.TRect;
  1360. begin
  1361.   Assert(not FFullScreen, ClassName + '.PrepareWindow: FullScreen # False');
  1363.   Result := False;
  1364. //  if (WindowedRect.Left = WindowedRect.Right) or (WindowedRect.Top = WindowedRect.Bottom) then
  1365.   GetWindowRect(RenderWindowHandle, TempRect);
  1367.   if (TempRect.Left < OffScreenX) and (TempRect.Right < OffScreenX) or (TempRect.Top < OffScreenY) and (TempRect.Bottom < OffScreenY) then begin
  1368.     {$IFDEF LOGGING} Log.Log(ClassName + '.PrepareWindow: Windowed viewport is off-screen', lkError); {$ENDIF}
  1369.     FState := rsLost;
  1370.     Exit;
  1371.   end;
  1373.   FWindowedRect := TempRect;
  1375.   {$IFNDEF DEBUGMODE}
  1376. //  SetWindowLong(RenderWindowHandle, GWL_STYLE, FNormalWindowStyle);
  1377.   {$ENDIF}
  1378. //  SetWindowPos(RenderWindowHandle, HWND_NOTOPMOST, WindowedRect.Left, WindowedRect.Top, WindowedRect.Right-WindowedRect.Left, WindowedRect.Bottom-WindowedRect.Top, SWP_DRAWFRAME or SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOMOVE);
  1380.   GetClientRect(RenderWindowHandle, TempRect);
  1382.   if (TempRect.Right - TempRect.Left <= 0) or (TempRect.Bottom - TempRect.Top <= 0) then begin
  1383.     {$IFDEF LOGGING}
  1384.     Log.Log(ClassName + '.PrepareWindow: Viewport''s client area is missing', lkError);
  1385.     {$ENDIF}
  1386. //      State := rsTryToRestore;
  1387.     Exit;
  1388.   end;
  1390. //  WindowBorderWidth := ClientRect.Left - WindowedRect.Left + (WindowedRect.Right - ClientRect.Right);
  1391. //  WindowBorderHeight := ClientRect.Top - WindowedRect.Top + (WindowedRect.Bottom - ClientRect.Bottom);
  1392.   RenderWidth  := TempRect.Right;
  1393.   RenderHeight := TempRect.Bottom;
  1395.   if Assigned(MainCamera) then MainCamera.SetScreenDimensions(RenderWidth, RenderHeight, True);
  1397.   Result := True;
  1398. end;
  1400. function TRenderer.CreateDevice(WindowHandle, AVideoMode: Cardinal; AFullScreen: Boolean): Boolean;
  1401. begin
  1402.   Log.Log('Render device creation', lkNotice);
  1403.   if APICreateDevice(WindowHandle, AVideoMode, AFullScreen) then begin
  1404.     Log.Log('Render device succesfully created');
  1405.     CheckCaps;
  1406.     Result := True;
  1407.     Manager.SendMessage(TRenderReinitMsg.Create, nil, [mfCore, mfBroadcast]);
  1408.     Manager.SendMessage(TWindowResizeMsg.Create(0, 0, RenderWidth, RenderHeight), nil, [mfCore]);   // For correct screen and GUI subsystems initialization
  1409.   end else begin
  1410.     Log.Log('Render device creation failed', lkError);
  1411.     Result := False;
  1412.   end;
  1413. end;
  1415. function TRenderer.RestoreDevice(AVideoMode: Cardinal; AFullScreen: Boolean): Boolean;
  1416. begin
  1417.   Result := True;
  1418.   if Assigned(Manager.Root) then Manager.SendMessage(TRenderReinitMsg.Create, nil, [mfCore, mfBroadcast]);
  1419. end;
  1421. procedure TRenderer.ApplyCamera(Camera: CAST2.TCamera);
  1422. begin
  1423.   if Camera <> FLastAppliedCamera then begin
  1424.     APIState.SetRenderTarget(Camera, Camera <> MainCamera);
  1425.     if Camera <> MainCamera then begin
  1426.       Camera.SetScreenDimensions(Camera.RenderTargetWidth, Camera.RenderTargetHeight, False);
  1427. //    Camera.ColorFormat := Camera.RTColorFormat;
  1428. //    Camera.DepthFormat := Camera.RTDepthFormat;
  1429.     end;
  1430.   end;
  1431.   FLastAppliedCamera := Camera;
  1432.   TesselationParams.Camera := FLastAppliedCamera;
  1433.   if Assigned(APIState) then begin
  1434.     APIState.Camera := Camera;
  1435.     APIState.ApplyClipPlanes;
  1436.   end;
  1437.   if Assigned(Camera) then Clear(Camera.ClearSettings.ClearFlags, Camera.ClearSettings.ClearColor, Camera.ClearSettings.ClearZ, Camera.ClearSettings.ClearStencil);
  1438. end;
  1440. procedure TRenderer.ProjectToScreen(out Projected: TVector4s; const Vector: TVector3s);
  1441. var TRHW: Single;
  1442. begin
  1443.   if not Assigned(MainCamera) then Exit;
  1445.   Projected := Transform4Vector3s(MainCamera.TotalMatrix, Vector);
  1447.   if Projected.W = 0 then Projected.W := -0.000001;
  1449.   TRHW := 1/Projected.W;
  1450.   Projected.X := MainCamera.RenderWidth  shr 1 + MainCamera.RenderWidth  shr 1*Projected.X * TRHW;
  1451.   Projected.Y := MainCamera.RenderHeight shr 1 - MainCamera.RenderHeight shr 1*Projected.Y * TRHW;
  1452. end;
  1454. procedure TRenderer.SetViewPort(const X, Y, Width, Height: Integer; const MinZ, MaxZ: Single);
  1455. begin
  1456.   ViewPort.X := X; ViewPort.Y := Y;
  1457.   ViewPort.Width := Width; ViewPort.Height := Height;
  1458.   ViewPort.MinZ := MinZ; ViewPort.MaxZ := MaxZ;
  1459. end;
  1461. procedure TRenderer.RenderTesselator(Tesselator: TTesselator);
  1462. var i: Integer;
  1463. begin
  1464.   if Tesselator.TotalIndices > 0 then begin
  1465.     for i := Tesselator.TotalStrips - 1 downto 0 do APIRenderIndexedStrip(Tesselator, i);
  1466.   end else for i := Tesselator.TotalStrips - 1 downto 0 do APIRenderStrip(Tesselator, i);
  1467. end;
  1469. destructor TRenderer.Destroy;
  1470. begin
  1471.   InternalDeInit;
  1472.   inherited;
  1473. end;
  1475. function TAPIStateWrapper.CreateRenderTarget(Index, Width, Height: Integer; AColorFormat, ADepthFormat: Cardinal; ADepthTexture: Boolean): Boolean;
  1476. const Usage: array[False..True] of Cardinal = (fuDEPTHSTENCIL, fuDEPTHTEXTURE);
  1477. begin
  1478.   Result := True;
  1480.   FRenderTargets[Index].Width           := Width;
  1481.   FRenderTargets[Index].Height          := Height;
  1482.   FRenderTargets[Index].LastUseFrame    := Renderer.FramesRendered;
  1483.   FRenderTargets[Index].LastUpdateFrame := -1;
  1484.   FRenderTargets[Index].ColorFormat     := AColorFormat;
  1485.   FRenderTargets[Index].DepthFormat     := ADepthFormat;
  1486.   FRenderTargets[Index].IsDepthTexture  := ADepthTexture;
  1488.   // Check pixel format
  1489.   if not Renderer.CheckFormat(FRenderTargets[Index].ColorFormat, fuRENDERTARGET, pfUndefined, FRenderTargets[Index].ActualColorFormat) then begin
  1490.     if FRenderTargets[Index].ActualColorFormat = pfUndefined then begin
  1491.       Log.Log('TAPIStateWrapper.AddRenderTarget: Can''t find an appropriate pixel format for render target (initial format "'  + PixelFormatToStr(FRenderTargets[Index].ColorFormat) + '")', lkError);
  1492.       Result := False;
  1493.     end else
  1494.       Log.Log('TAPIStateWrapper.AddRenderTarget: Unsupported pixel format "' + PixelFormatToStr(FRenderTargets[Index].ColorFormat) +
  1495.               '" of a render target. Switching to format "' + PixelFormatToStr(FRenderTargets[Index].ActualColorFormat) + '".', lkWarning);
  1496.   end;
  1497.   // Check depth format
  1498.   if not Renderer.CheckFormat(FRenderTargets[Index].DepthFormat, Usage[ADepthTexture], FRenderTargets[Index].ActualColorFormat, FRenderTargets[Index].ActualDepthFormat) then begin
  1499.     if FRenderTargets[Index].ActualDepthFormat = pfUndefined then begin
  1500.       Log.Log('TAPIStateWrapper.AddRenderTarget: Can''t find an appropriate depth-stencil surface format for render target (initial format "'  + PixelFormatToStr(FRenderTargets[Index].DepthFormat) + '")', lkError);
  1501.     end else
  1502.       Log.Log('TAPIStateWrapper.AddRenderTarget: Unsupported depth-stencil surface format "' + PixelFormatToStr(FRenderTargets[Index].DepthFormat) +
  1503.               '" of a render target. Switching to format "' + PixelFormatToStr(FRenderTargets[Index].ActualDepthFormat) + '".', lkWarning);
  1504.   end;
  1506.   if not Result or not APICreateRenderTarget(Index, FRenderTargets[Index].Width, FRenderTargets[Index].Height, FRenderTargets[Index].ActualColorFormat, FRenderTargets[Index].ActualDepthFormat) then begin
  1507.     Result := False;
  1508.     RemoveRenderTarget(Index);
  1509.   end;// else Log.Log('****************: Created depth-stencil surface format "' + PixelFormatToStr(FRenderTargets[Index].ActualDepthFormat));
  1510. end;
  1512. procedure TRenderer.StartFrame;
  1513. begin
  1514.   Assert(Assigned(MainCamera), 'TRenderer.StartFrame: MainCamera is undefined');
  1515.   MainCamera.SetScreenDimensions(RenderWidth, RenderHeight, True);                         // ToDo: Remove
  1516.   // Zero out statistics
  1517.   Assert(Assigned(FPerfProfile), Format('%S.%S: FPerfProfile should be assigned', [ClassName, 'StartFrame']));
  1518.   FPerfProfile.OnFrameStart;
  1519. //  MainCamera.ColorFormat := FCurrentZBufferDepth
  1520. end;
  1522. procedure TRenderer.InternalInit;
  1523. begin
  1524.   APIState.Renderer := Self;
  1525.   Textures.Renderer := Self;
  1526. end;
  1528. procedure TRenderer.SetPerfProfile(APerfProfile: TPerfProfile);
  1529. begin
  1530.   FPerfProfile := APerfProfile;
  1531.   Assert(Assigned(APIState), Format('%S.%S: APIState should be assigned for this call', [ClassName, 'SetPerfProfile']));
  1532.   APIState.FPerfProfile := APerfProfile;
  1533. end;
  1535. procedure TRenderer.RenderItem(Item: TVisible);
  1536. var i: Integer; ItemShaderConstants: TShaderConstants;
  1537. begin
  1538.   if not IsReady then Exit;
  1539.   if not Assigned(Item.CurrentTesselator) or not Assigned(Item.CurTechnique) or (Item.CurTechnique.TotalPasses = 0) then Exit;
  1541.   TesselationParams.ModelMatrix := Item.Transform;
  1543.   // Buffers switching and setting
  1544.   if not Buffers.Put(Item.CurrentTesselator) or (Item.CurrentTesselator.TotalPrimitives = 0) then Exit;
  1546.   if not APIState.VertexShaderFlag then APIPrepareFVFStates(Item);
  1547.   if APIState.VertexShaderFlag or APIState.PixelShaderFlag then begin
  1548.     Item.RetrieveShaderConstants(ItemShaderConstants);
  1549.     if Assigned(ItemShaderConstants) then
  1550.       for i := 0 to High(ItemShaderConstants) do
  1551.         APIState.SetShaderConstant(ItemShaderConstants[i]);
  1552.   end;
  1554.   if not Item.CurrentTesselator.ManualRender then
  1555.     RenderTesselator(Item.CurrentTesselator)
  1556.   else
  1557.     Item.CurrentTesselator.DoManualRender(Item);
  1558. end;
  1560. { TTextures }
  1562. function TTextures.IsEmpty(const Element: TTexture): Boolean;
  1563. begin Result := Element.Format = pfUndefined; end;// not Assigned(Element.Resource); end;
  1565. function TTextures.NewTexture(Resource: TImageResource; Options: TTextureOptions): Integer;
  1566. begin
  1567.   Result := tivUnresolved;
  1568.   // Check if the resource is valid
  1569.   if not Assigned(Resource) or (Resource.Format = pfUndefined) then begin
  1570.     Log.Log('TTextures.NewTexture: invalid or no resource specified', lkError);
  1571.     Exit;
  1572.   end;
  1574.   if (toProcedural in Options) then begin
  1575.     Log.Log('TTextures.NewTexture: for procedural textures NewProceduralTexture() should be used', lkError);
  1576.     Exit;
  1577.   end;
  1579.   if Assigned(Resource) then begin                                      // Check if the resource already loaded as a texture
  1580.     Result := High(FTextures);
  1581.     while (Result >= 0) and (FTextures[Result].Resource <> Resource) do Dec(Result);
  1583.     if Result >= 0 then Exit;
  1585.     {$IFDEF DEBUG}
  1586.     Log.Log('TRenderer.AddTexture: Loading resource "' + Resource.GetFullName + '" as a texture', lkDebug);
  1587.     {$ENDIF}
  1588.   end;
  1590.   Result := ResourceAdd_Texture(FTextures, {$IFDEF OBJFPCEnable}@{$ENDIF}IsEmpty);
  1592.   FTextures[Result].Format   := Resource.Format;            
  1593.   FTextures[Result].Resource := Resource;
  1594.   FTextures[Result].Options  := Options;
  1595.   FTextures[Result].Texture  := nil;
  1597.   if (toImmediateLoad in Options) and not Load(Result) then begin
  1598.     FTextures[Result].Resource := nil;
  1599.     FTextures[Result].Format   := pfUndefined;
  1600.   end;
  1601. end;
  1603. function TTextures.NewProceduralTexture(AFormat: Cardinal; AWidth, AHeight, ADepth, ALevels: Integer; Options: TTextureOptions): Integer;
  1604. begin
  1605.   Result := ResourceAdd_Texture(FTextures, {$IFDEF OBJFPCEnable}@{$ENDIF}IsEmpty);
  1607.   FTextures[Result].Resource := nil;
  1608.   FTextures[Result].Texture  := nil;
  1609.   FTextures[Result].Options  := Options + [toProcedural];
  1610.   FTextures[Result].Format   := AFormat;
  1611.   FTextures[Result].Width    := AWidth;
  1612.   FTextures[Result].Height   := AHeight;
  1613.   FTextures[Result].Depth    := ADepth;
  1614.   FTextures[Result].Levels   := ALevels;
  1616.   if not APICreateTexture(Result) then Result := tivNull;
  1617. end;
  1619. procedure TTextures.Delete(Index: Integer);
  1620. begin
  1621. //  Dec(TotalTextures);
  1622.   FTextures[Index].Resource := nil;
  1623.   FTextures[Index].Format   := pfUndefined;
  1624. //  if Index < TotalTextures then FTextures[Index] := FTextures[TotalTextures]
  1625. end;
  1627. procedure TTextures.FreeAll;
  1628. var i: Integer;
  1629. begin
  1630.   for i := High(FTextures) downto 0 do if not IsEmpty(FTextures[i]) then Delete(i);
  1631. end;
  1633. destructor TTextures.Destroy;
  1634. begin
  1635.   FreeAll;
  1636.   inherited;
  1637. end;
  1639. procedure TTextures.HandleMessage(const Msg: TMessage);
  1640. var i: Integer;
  1641. begin
  1642.   if (Msg.ClassType = TResourceModifyMsg) then begin
  1643.     for i := 0 to High(FTextures) do if FTextures[i].Resource = TResourceModifyMsg(Msg).Resource then Load(i);
  1644.   end else if (Msg.ClassType = TRemoveFromSceneMsg) or (Msg.ClassType = TDestroyMsg) then
  1645.     for i := High(FTextures) downto 0 do if FTextures[i].Resource = TItemNotificationMessage(Msg).Item then
  1646.       FTextures[i].Resource := nil;
  1647. //  HandleItemReplace(TItemNotificationMessage(Msg).Item, nil);
  1648. end;
  1650. function TTextures.Load(Index: Integer): Boolean;
  1651. var
  1652. {  i, j, k, w, h: Integer;
  1653.   FData, CData: Pointer; DataSize, DataOfs, TextureDataOfs: Integer;
  1654.   MipmapGenFilter: TImageFilterFunction;}
  1656.   Image: TImageResource;
  1657.   Width, Height: Cardinal;
  1658.   TotalPixels: Integer;
  1659.   TargetFormat: Integer;
  1660.   Data: Pointer;
  1661. begin
  1662.   Result := False;
  1663.   // * check dimensions
  1664.   // * check format
  1665.   Image := FTextures[Index].Resource;
  1666.   if not Assigned(Image) then begin
  1667.     Log.Log(Format('%S.%S: Resource of texture #%D is not assigned', [ClassName, 'Load', Index]));
  1668.     Exit;
  1669.   end;
  1671.   // Now check if texture with such dimensions is supported
  1672.   Width  := MinI(Renderer.MaxTextureWidth,  Image.Width);
  1673.   Height := MinI(Renderer.MaxTextureHeight, Image.Height);
  1674.   if Renderer.SquareTextures then begin
  1675.     Width  := MaxI(Width, Height);
  1676.     Height := Width;
  1677.   end;
  1678.   // Compute total size of the texture with mipmaps
  1679.   Assert((Image.DataSize mod GetBytesPerPixel(Image.Format)) = 0);
  1680.   TotalPixels := Image.DataSize div GetBytesPerPixel(Image.Format);
  1682.   // Check if texture with such format is supported
  1683.   if not Renderer.CheckFormat(Image.Format, fuTexture, pfUndefined, TargetFormat) then begin
  1684.     if TargetFormat = pfUndefined then begin
  1685.       Log.Log(Format('%S.%S: Can''t find appropriate texture format (initial format "%S") for resource "%S"',
  1686.                      [ClassName, 'LoadTexture', PixelFormatToStr(Image.Format), Image.GetFullName]), lkError);
  1687. //      if Assigned(CData) then FreeMem(CData);
  1688.       Exit;
  1689.     end else if TargetFormat <> Image.Format then begin
  1690.       Log.Log(Format('%S.%S: Unsupported image format "%S" of resource "%S". Switching to format "%S",',
  1691.                      [ClassName, 'LoadTexture', PixelFormatToStr(Image.Format), Image.GetFullName, PixelFormatToStr(TargetFormat)]), lkWarning);
  1692.     end;
  1693.   end;
  1695.   if Assigned(FTextures[Index].Texture) and                           // Allocated API texture
  1696.    ((FTextures[Index].Width <> Width) or (FTextures[Index].Height <> Height) or
  1697.     (FTextures[Index].Levels <> Image.ActualLevels) or
  1698.     (GetBytesPerPixel(FTextures[Index].Format) <> GetBytesPerPixel(TargetFormat))) then begin
  1699.       Log.Log(Format('%S.%S: Image resource changed. Recreating API texture.',
  1700.                      [ClassName, 'LoadTexture']), lkWarning);
  1701.       APIDeleteTexture(Index);
  1702.     end;
  1704.   FTextures[Index].Width  := Width;
  1705.   FTextures[Index].Height := Height;
  1706.   FTextures[Index].Format := TargetFormat;
  1707.   FTextures[Index].Levels := Image.ActualLevels; 
  1709.   if TargetFormat <> Image.Format then begin
  1710.     GetMem(Data, TotalPixels * GetBytesPerPixel(TargetFormat));
  1711.     ConvertImage(Image.Format, TargetFormat, TotalPixels, Image.Data, 0, nil, Data);
  1712.     Update(Index, Data, nil);
  1713.     FreeMem(Data);
  1714.   end else Update(Index, Image.Data, nil);
  1716.   Result := True;
  1717. end;
  1719. function TTextures.Resolve(Pass: TRenderPass; StageIndex: Integer): Boolean;
  1720. var TextureResource: TImageResource;
  1721. begin
  1722.   Result := False;
  1723.   if Pass.ResolveTexture(StageIndex, TextureResource) then begin
  1724.     if Pass.Stages[StageIndex].TextureIndex = tivUnresolved then
  1725.       Pass.Stages[StageIndex].TextureIndex := NewTexture(TextureResource, []);
  1726.     Result := Pass.Stages[StageIndex].TextureIndex <> tivUnresolved;
  1727.   end;
  1728. end;
  1730. end.