/* ** Command & Conquer Renegade(tm) ** Copyright 2025 Electronic Arts Inc. ** ** This program is free software: you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation, either version 3 of the License, or ** (at your option) any later version. ** ** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with this program. If not, see . */ /*********************************************************************************************** *** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S *** *********************************************************************************************** * * * Project Name : ww3d * * * * $Archive:: /Commando/Code/ww3d2/dx8wrapper.h $* * * * Original Author:: Jani Penttinen * * * * $Author:: Patrick $* * * * $Modtime:: 2/26/02 4:04p $* * * * $Revision:: 90 $* * * *---------------------------------------------------------------------------------------------* * Functions: * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #if defined(_MSC_VER) #pragma once #endif #ifndef DX8_WRAPPER_H #define DX8_WRAPPER_H #include "always.h" #include "dllist.h" #include "d3d8.h" #include "matrix4.h" #include "statistics.h" #include "wwstring.h" #include "lightenvironment.h" #include "shader.h" #include "vector4.h" #include "cpudetect.h" #include "dx8caps.h" #include "texture.h" #include "dx8vertexbuffer.h" #include "dx8indexbuffer.h" #include "vertmaterial.h" /* ** Registry value names */ #define VALUE_NAME_RENDER_DEVICE_NAME "RenderDeviceName" #define VALUE_NAME_RENDER_DEVICE_WIDTH "RenderDeviceWidth" #define VALUE_NAME_RENDER_DEVICE_HEIGHT "RenderDeviceHeight" #define VALUE_NAME_RENDER_DEVICE_DEPTH "RenderDeviceDepth" #define VALUE_NAME_RENDER_DEVICE_WINDOWED "RenderDeviceWindowed" #define VALUE_NAME_RENDER_DEVICE_TEXTURE_DEPTH "RenderDeviceTextureDepth" const unsigned MAX_TEXTURE_STAGES=2; enum { BUFFER_TYPE_DX8, BUFFER_TYPE_SORTING, BUFFER_TYPE_DYNAMIC_DX8, BUFFER_TYPE_DYNAMIC_SORTING, BUFFER_TYPE_INVALID }; class VertexMaterialClass; class CameraClass; class LightEnvironmentClass; class RenderDeviceDescClass; class VertexBufferClass; class DynamicVBAccessClass; class IndexBufferClass; class DynamicIBAccessClass; class TextureClass; class LightClass; class SurfaceClass; class DX8Caps; #define DX8_RECORD_MATRIX_CHANGE() matrix_changes++ #define DX8_RECORD_MATERIAL_CHANGE() material_changes++ #define DX8_RECORD_VERTEX_BUFFER_CHANGE() vertex_buffer_changes++ #define DX8_RECORD_INDEX_BUFFER_CHANGE() index_buffer_changes++ #define DX8_RECORD_LIGHT_CHANGE() light_changes++ #define DX8_RECORD_TEXTURE_CHANGE() texture_changes++ #define DX8_RECORD_RENDER_STATE_CHANGE() render_state_changes++ #define DX8_RECORD_TEXTURE_STAGE_STATE_CHANGE() texture_stage_state_changes++ extern unsigned number_of_DX8_calls; extern bool _DX8SingleThreaded; void DX8_Assert(); void Log_DX8_ErrorCode(unsigned res); WWINLINE void DX8_ErrorCode(unsigned res) { if (res==D3D_OK) return; Log_DX8_ErrorCode(res); } #ifdef WWDEBUG #define DX8CALL_HRES(x,res) DX8_Assert(); res = DX8Wrapper::_Get_D3D_Device8()->x; DX8_ErrorCode(res); number_of_DX8_calls++; #define DX8CALL(x) DX8_Assert(); DX8_ErrorCode(DX8Wrapper::_Get_D3D_Device8()->x); number_of_DX8_calls++; #define DX8CALL_D3D(x) DX8_Assert(); DX8_ErrorCode(DX8Wrapper::_Get_D3D8()->x); number_of_DX8_calls++; #define DX8_THREAD_ASSERT() if (_DX8SingleThreaded) { WWASSERT_PRINT(DX8Wrapper::_Get_Main_Thread_ID()==ThreadClass::_Get_Current_Thread_ID(),"DX8Wrapper::DX8 calls must be called from the main thread!"); } #else #define DX8CALL_HRES(x,res) res = DX8Wrapper::_Get_D3D_Device8()->x; number_of_DX8_calls++; #define DX8CALL(x) DX8Wrapper::_Get_D3D_Device8()->x; number_of_DX8_calls++; #define DX8CALL_D3D(x) DX8Wrapper::_Get_D3D8()->x; number_of_DX8_calls++; #define DX8_THREAD_ASSERT() ; #endif struct RenderStateStruct { ShaderClass shader; VertexMaterialClass* material; TextureClass * Textures[MAX_TEXTURE_STAGES]; D3DLIGHT8 Lights[4]; bool LightEnable[4]; Matrix4 world; Matrix4 view; unsigned vertex_buffer_type; unsigned index_buffer_type; unsigned short vba_offset; unsigned short vba_count; unsigned short iba_offset; VertexBufferClass* vertex_buffer; IndexBufferClass* index_buffer; unsigned short index_base_offset; RenderStateStruct(); ~RenderStateStruct(); RenderStateStruct& operator= (const RenderStateStruct& src); }; /** ** DX8Wrapper ** ** DX8 interface wrapper class. This encapsulates the DX8 interface; adding redundant state ** detection, stat tracking, etc etc. In general, we will wrap all DX8 calls with at least ** an WWINLINE function so that we can add stat tracking, etc if needed. Direct access to the ** D3D device will require "friend" status and should be granted only in extreme circumstances :-) */ class DX8Wrapper { enum ChangedStates { WORLD_CHANGED = 1<<0, VIEW_CHANGED = 1<<1, LIGHT0_CHANGED = 1<<2, LIGHT1_CHANGED = 1<<3, LIGHT2_CHANGED = 1<<4, LIGHT3_CHANGED = 1<<5, TEXTURE0_CHANGED= 1<<6, TEXTURE1_CHANGED= 1<<7, TEXTURE2_CHANGED= 1<<8, TEXTURE3_CHANGED= 1<<9, MATERIAL_CHANGED= 1<<14, SHADER_CHANGED = 1<<15, VERTEX_BUFFER_CHANGED = 1<<16, INDEX_BUFFER_CHANGED = 1 << 17, WORLD_IDENTITY= 1<<18, VIEW_IDENTITY= 1<<19, TEXTURES_CHANGED= TEXTURE0_CHANGED|TEXTURE1_CHANGED|TEXTURE2_CHANGED|TEXTURE3_CHANGED, LIGHTS_CHANGED= LIGHT0_CHANGED|LIGHT1_CHANGED|LIGHT2_CHANGED|LIGHT3_CHANGED, }; static void Draw_Sorting_IB_VB( unsigned primitive_type, unsigned short start_index, unsigned short polygon_count, unsigned short min_vertex_index, unsigned short vertex_count); static void Draw( unsigned primitive_type, unsigned short start_index, unsigned short polygon_count, unsigned short min_vertex_index=0, unsigned short vertex_count=0); public: static bool Init(void * hwnd, bool lite = false); static void Shutdown(void); /* ** Some WW3D sub-systems need to be initialized after the device is created and shutdown ** before the device is released. */ static void Do_Onetime_Device_Dependent_Inits(void); static void Do_Onetime_Device_Dependent_Shutdowns(void); static bool Is_Device_Lost() { return IsDeviceLost; } static bool Is_Initted(void) { return IsInitted; } /* ** Rendering */ static void Begin_Scene(void); static void End_Scene(bool flip_frame = true); // Flip until the primary buffer is visible. static void Flip_To_Primary(void); static void Clear(bool clear_color, bool clear_z_stencil, const Vector3 &color, float z=1.0f, unsigned int stencil=0); static void Set_Viewport(CONST D3DVIEWPORT8* pViewport); static void Set_Vertex_Buffer(const VertexBufferClass* vb); static void Set_Vertex_Buffer(const DynamicVBAccessClass& vba); static void Set_Index_Buffer(const IndexBufferClass* ib,unsigned short index_base_offset); static void Set_Index_Buffer(const DynamicIBAccessClass& iba,unsigned short index_base_offset); static void Set_Index_Buffer_Index_Offset(unsigned offset); static void Get_Render_State(RenderStateStruct& state); static void Set_Render_State(const RenderStateStruct& state); static void Release_Render_State(); static void Set_DX8_Material(const D3DMATERIAL8* mat); static void Set_Gamma(float gamma,float bright,float contrast,bool calibrate=true,bool uselimit=true); // Set_ and Get_Transform() functions take the matrix in Westwood convention format. static void Set_DX8_ZBias(int zbias); static void Set_Pseudo_ZBias(int zbias); static void Set_Projection_Transform_With_Z_Bias(const Matrix4& matrix,float znear, float zfar); // pointer to 16 matrices static void Set_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix4& m); static void Set_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix3D& m); static void Get_Transform(D3DTRANSFORMSTATETYPE transform, Matrix4& m); static void Set_World_Identity(); static void Set_View_Identity(); static bool Is_World_Identity(); static bool Is_View_Identity(); // Note that *_DX8_Transform() functions take the matrix in DX8 format - transposed from Westwood convention. static void _Set_DX8_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix4& m); static void _Set_DX8_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix3D& m); static void _Get_DX8_Transform(D3DTRANSFORMSTATETYPE transform, Matrix4& m); static void Set_DX8_Light(int index,D3DLIGHT8* light); static void Set_DX8_Render_State(D3DRENDERSTATETYPE state, unsigned value); static void Set_DX8_Texture_Stage_State(unsigned stage, D3DTEXTURESTAGESTATETYPE state, unsigned value); static void Set_DX8_Texture(unsigned int stage, IDirect3DBaseTexture8* texture); static void Set_Light_Environment(LightEnvironmentClass* light_env); static void Set_Fog(bool enable, const Vector3 &color, float start, float end); static WWINLINE const D3DLIGHT8& Peek_Light(unsigned index); static WWINLINE bool Is_Light_Enabled(unsigned index); // Deferred static void Set_Shader(const ShaderClass& shader); static void Get_Shader(ShaderClass& shader); static void Set_Texture(unsigned stage,TextureClass* texture); static void Set_Material(const VertexMaterialClass* material); static void Set_Light(unsigned index,const D3DLIGHT8* light); static void Set_Light(unsigned index,const LightClass &light); static void Apply_Render_State_Changes(); // Apply deferred render state changes (will be called automatically by Draw...) static void Draw_Triangles( unsigned buffer_type, unsigned short start_index, unsigned short polygon_count, unsigned short min_vertex_index, unsigned short vertex_count); static void Draw_Triangles( unsigned short start_index, unsigned short polygon_count, unsigned short min_vertex_index, unsigned short vertex_count); static void Draw_Strip( unsigned short start_index, unsigned short index_count, unsigned short min_vertex_index, unsigned short vertex_count); /* ** Resources */ static IDirect3DTexture8 * _Create_DX8_Texture( unsigned int width, unsigned int height, WW3DFormat format, TextureClass::MipCountType mip_level_count, D3DPOOL pool=D3DPOOL_MANAGED, bool rendertarget=false); static IDirect3DTexture8 * _Create_DX8_Texture(const char *filename, TextureClass::MipCountType mip_level_count); static IDirect3DTexture8 * _Create_DX8_Texture(IDirect3DSurface8 *surface, TextureClass::MipCountType mip_level_count); static IDirect3DSurface8 * _Create_DX8_Surface(unsigned int width, unsigned int height, WW3DFormat format); static IDirect3DSurface8 * _Create_DX8_Surface(const char *filename); static IDirect3DSurface8 * _Get_DX8_Front_Buffer(); static SurfaceClass * _Get_DX8_Back_Buffer(unsigned int num=0); static void _Copy_DX8_Rects( IDirect3DSurface8* pSourceSurface, CONST RECT* pSourceRectsArray, UINT cRects, IDirect3DSurface8* pDestinationSurface, CONST POINT* pDestPointsArray ); static void _Update_Texture(TextureClass *system, TextureClass *video); static void Flush_DX8_Resource_Manager(unsigned int bytes=0); static unsigned int Get_Free_Texture_RAM(); static unsigned _Get_Main_Thread_ID() { return _MainThreadID; } static const D3DADAPTER_IDENTIFIER8& Get_Current_Adapter_Identifier() { return CurrentAdapterIdentifier; } /* ** Statistics */ static void Begin_Statistics(); static void End_Statistics(); static unsigned Get_Last_Frame_Matrix_Changes(); static unsigned Get_Last_Frame_Material_Changes(); static unsigned Get_Last_Frame_Vertex_Buffer_Changes(); static unsigned Get_Last_Frame_Index_Buffer_Changes(); static unsigned Get_Last_Frame_Light_Changes(); static unsigned Get_Last_Frame_Texture_Changes(); static unsigned Get_Last_Frame_Render_State_Changes(); static unsigned Get_Last_Frame_Texture_Stage_State_Changes(); static unsigned Get_Last_Frame_DX8_Calls(); static unsigned long Get_FrameCount(void); // Needed by shader class static bool Get_Fog_Enable() { return FogEnable; } static D3DCOLOR Get_Fog_Color() { return FogColor; } // Utilities static Vector4 Convert_Color(unsigned color); static unsigned int Convert_Color(const Vector4& color); static unsigned int Convert_Color(const Vector3& color, const float alpha); static void Clamp_Color(Vector4& color); static unsigned int Convert_Color_Clamp(const Vector4& color); static void Set_Alpha (const float alpha, unsigned int &color); static void _Enable_Triangle_Draw(bool enable) { _EnableTriangleDraw=enable; } static bool _Is_Triangle_Draw_Enabled() { return _EnableTriangleDraw; } /* ** Additional swap chain interface ** ** Use this interface to render to multiple windows (in windowed mode). ** To render to an additional window, the sequence of calls should look ** something like this: ** ** DX8Wrapper::Set_Render_Target (swap_chain_ptr); ** ** WW3D::Begin_Render (true, true, Vector3 (0, 0, 0)); ** WW3D::Render (scene, camera, FALSE, FALSE); ** WW3D::End_Render (); ** ** swap_chain_ptr->Present (NULL, NULL, NULL, NULL); ** ** DX8Wrapper::Set_Render_Target ((IDirect3DSurface8 *)NULL); ** */ static IDirect3DSwapChain8 * Create_Additional_Swap_Chain (HWND render_window); /* ** Render target interface. If render target format is WW3D_FORMAT_UNKNOWN, current display format is used. */ static TextureClass * Create_Render_Target (int width, int height, WW3DFormat format); static void Set_Render_Target (TextureClass * texture); static void Set_Render_Target (IDirect3DSurface8 *render_target, bool use_default_depth_buffer = false); static void Set_Render_Target (IDirect3DSwapChain8 *swap_chain); static bool Is_Render_To_Texture(void) { return IsRenderToTexture; } static IDirect3DDevice8* _Get_D3D_Device8() { return D3DDevice; } static IDirect3D8* _Get_D3D8() { return D3DInterface; } static const DX8Caps* Get_Current_Caps() { WWASSERT(CurrentCaps); return CurrentCaps; } static bool Registry_Save_Render_Device( const char * sub_key ); static bool Registry_Load_Render_Device( const char * sub_key, bool resize_window ); static const char* Get_DX8_Render_State_Name(D3DRENDERSTATETYPE state); static const char* Get_DX8_Texture_Stage_State_Name(D3DTEXTURESTAGESTATETYPE state); // Names of the specific values of render states and texture stage states static void Get_DX8_Texture_Stage_State_Value_Name(StringClass& name, D3DTEXTURESTAGESTATETYPE state, unsigned value); static void Get_DX8_Render_State_Value_Name(StringClass& name, D3DRENDERSTATETYPE state, unsigned value); static const char* Get_DX8_Texture_Address_Name(unsigned value); static const char* Get_DX8_Texture_Filter_Name(unsigned value); static const char* Get_DX8_Texture_Arg_Name(unsigned value); static const char* Get_DX8_Texture_Op_Name(unsigned value); static const char* Get_DX8_Texture_Transform_Flag_Name(unsigned value); static const char* Get_DX8_ZBuffer_Type_Name(unsigned value); static const char* Get_DX8_Fill_Mode_Name(unsigned value); static const char* Get_DX8_Shade_Mode_Name(unsigned value); static const char* Get_DX8_Blend_Name(unsigned value); static const char* Get_DX8_Cull_Mode_Name(unsigned value); static const char* Get_DX8_Cmp_Func_Name(unsigned value); static const char* Get_DX8_Fog_Mode_Name(unsigned value); static const char* Get_DX8_Stencil_Op_Name(unsigned value); static const char* Get_DX8_Material_Source_Name(unsigned value); static const char* Get_DX8_Vertex_Blend_Flag_Name(unsigned value); static const char* Get_DX8_Patch_Edge_Style_Name(unsigned value); static const char* Get_DX8_Debug_Monitor_Token_Name(unsigned value); static const char* Get_DX8_Blend_Op_Name(unsigned value); protected: static bool Create_Device(void); static bool Reset_Device(void); static void Release_Device(void); static void Reset_Statistics(); static void Enumerate_Devices(); static void Set_Default_Global_Render_States(void); static void Invalidate_Cached_Render_States(void); /* ** Device Selection Code. ** For backward compatibility, the public interface for these functions is in the ww3d. ** header file. These functions are protected so that we aren't exposing two interfaces. */ static bool Set_Any_Render_Device(void); static bool Set_Render_Device(const char * dev_name,int width=-1,int height=-1,int bits=-1,int windowed=-1,bool resize_window=false); static bool Set_Render_Device(int dev=-1,int resx=-1,int resy=-1,int bits=-1,int windowed=-1,bool resize_window = false); static bool Set_Next_Render_Device(void); static bool Toggle_Windowed(void); static int Get_Render_Device_Count(void); static int Get_Render_Device(void); static const RenderDeviceDescClass & Get_Render_Device_Desc(int deviceidx); static const char * Get_Render_Device_Name(int device_index); static bool Set_Device_Resolution(int width=-1,int height=-1,int bits=-1,int windowed=-1, bool resize_window=false); static void Get_Device_Resolution(int & set_w,int & set_h,int & set_bits,bool & set_windowed); static void Get_Render_Target_Resolution(int & set_w,int & set_h,int & set_bits,bool & set_windowed); static int Get_Device_Resolution_Width(void) { return ResolutionWidth; } static int Get_Device_Resolution_Height(void) { return ResolutionHeight; } static bool Registry_Save_Render_Device( const char *sub_key, int device, int width, int height, int depth, bool windowed, int texture_depth); static bool Registry_Load_Render_Device( const char * sub_key, char *device, int device_len, int &width, int &height, int &depth, int &windowed, int &texture_depth); static bool Is_Windowed(void) { return IsWindowed; } static void Set_Texture_Bitdepth(int depth) { WWASSERT(depth==16 || depth==32); TextureBitDepth = depth; } static int Get_Texture_Bitdepth(void) { return TextureBitDepth; } static void Set_Swap_Interval(int swap); static int Get_Swap_Interval(void); static void Set_Polygon_Mode(int mode); /* ** Internal functions */ static bool Find_Color_And_Z_Mode(int resx,int resy,int bitdepth,D3DFORMAT * set_colorbuffer,D3DFORMAT * set_zmode); static bool Find_Color_Mode(D3DFORMAT colorbuffer, int resx, int resy, UINT *mode); static bool Find_Z_Mode(D3DFORMAT colorbuffer,D3DFORMAT backbuffer, D3DFORMAT *zmode); static bool Test_Z_Mode(D3DFORMAT colorbuffer,D3DFORMAT backbuffer, D3DFORMAT zmode); static void Compute_Caps(WW3DFormat display_format); /* ** Protected Member Variables */ static RenderStateStruct render_state; static unsigned render_state_changed; static bool IsInitted; static bool IsDeviceLost; static void * Hwnd; static unsigned _MainThreadID; static bool _EnableTriangleDraw; static int CurRenderDevice; static int ResolutionWidth; static int ResolutionHeight; static int BitDepth; static int TextureBitDepth; static bool IsWindowed; static D3DMATRIX old_world; static D3DMATRIX old_view; static D3DMATRIX old_prj; static bool world_identity; static unsigned RenderStates[256]; static unsigned TextureStageStates[MAX_TEXTURE_STAGES][32]; static IDirect3DBaseTexture8 * Textures[MAX_TEXTURE_STAGES]; // These fog settings are constant for all objects in a given scene, // unlike the matching renderstates which vary based on shader settings. static bool FogEnable; static D3DCOLOR FogColor; static unsigned matrix_changes; static unsigned material_changes; static unsigned vertex_buffer_changes; static unsigned index_buffer_changes; static unsigned light_changes; static unsigned texture_changes; static unsigned render_state_changes; static unsigned texture_stage_state_changes; static bool CurrentDX8LightEnables[4]; static unsigned long FrameCount; static DX8Caps* CurrentCaps; static D3DADAPTER_IDENTIFIER8 CurrentAdapterIdentifier; static IDirect3D8 * D3DInterface; //d3d8; static IDirect3DDevice8 * D3DDevice; //d3ddevice8; static IDirect3DSurface8 * CurrentRenderTarget; static IDirect3DSurface8 * DefaultRenderTarget; static IDirect3DSurface8 * DefaultDepthBuffer; static bool IsRenderToTexture; static int ZBias; static float ZNear; static float ZFar; static Matrix4 ProjectionMatrix; friend void DX8_Assert(); friend class WW3D; friend class DX8IndexBufferClass; friend class DX8VertexBufferClass; }; WWINLINE void DX8Wrapper::_Set_DX8_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix4& m) { SNAPSHOT_SAY(("DX8 - SetTransform\n")); DX8_RECORD_MATRIX_CHANGE(); DX8CALL(SetTransform(transform,(D3DMATRIX*)&m)); } WWINLINE void DX8Wrapper::_Set_DX8_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix3D& m) { SNAPSHOT_SAY(("DX8 - SetTransform\n")); DX8_RECORD_MATRIX_CHANGE(); DX8CALL(SetTransform(transform,(D3DMATRIX*)&m)); } WWINLINE void DX8Wrapper::_Get_DX8_Transform(D3DTRANSFORMSTATETYPE transform, Matrix4& m) { DX8CALL(GetTransform(transform,(D3DMATRIX*)&m)); } // ---------------------------------------------------------------------------- // // Set the index offset for the current index buffer // // ---------------------------------------------------------------------------- WWINLINE void DX8Wrapper::Set_Index_Buffer_Index_Offset(unsigned offset) { if (render_state.index_base_offset==offset) return; render_state.index_base_offset=offset; render_state_changed|=INDEX_BUFFER_CHANGED; } // ---------------------------------------------------------------------------- // Set the fog settings. This function should be used, rather than setting the // appropriate renderstates directly, because the shader sets some of the // renderstates on a per-mesh / per-pass basis depending on global fog states // (stored in the wrapper) as well as the shader settings. // This function should be called rarely - once per scene would be appropriate. // ---------------------------------------------------------------------------- WWINLINE void DX8Wrapper::Set_Fog(bool enable, const Vector3 &color, float start, float end) { // Set global states FogEnable = enable; FogColor = Convert_Color(color,0.0f); // Invalidate the current shader (since the renderstates set by the shader // depend on the global fog settings as well as the actual shader settings) ShaderClass::Invalidate(); // Set renderstates which are not affected by the shader Set_DX8_Render_State(D3DRS_FOGSTART, *(DWORD *)(&start)); Set_DX8_Render_State(D3DRS_FOGEND, *(DWORD *)(&end)); } // ---------------------------------------------------------------------------- // // Set vertex buffer to be used in the subsequent render calls. If there was // a vertex buffer being used earlier, release the reference to it. Passing // NULL just will release the vertex buffer. // // ---------------------------------------------------------------------------- WWINLINE void DX8Wrapper::Set_DX8_Material(const D3DMATERIAL8* mat) { DX8_RECORD_MATERIAL_CHANGE(); WWASSERT(mat); SNAPSHOT_SAY(("DX8 - SetMaterial\n")); DX8CALL(SetMaterial(mat)); } WWINLINE void DX8Wrapper::Set_DX8_Light(int index, D3DLIGHT8* light) { if (light) { DX8_RECORD_LIGHT_CHANGE(); DX8CALL(SetLight(index,light)); DX8CALL(LightEnable(index,TRUE)); CurrentDX8LightEnables[index]=true; SNAPSHOT_SAY(("DX8 - SetLight\n")); } else if (CurrentDX8LightEnables[index]) { DX8_RECORD_LIGHT_CHANGE(); CurrentDX8LightEnables[index]=false; DX8CALL(LightEnable(index,FALSE)); SNAPSHOT_SAY(("DX8 - DisableLight\n")); } } WWINLINE void DX8Wrapper::Set_DX8_Render_State(D3DRENDERSTATETYPE state, unsigned value) { // Can't monitor state changes because setShader call to GERD may change the states! if (RenderStates[state]==value) return; #ifdef MESH_RENDER_SNAPSHOT_ENABLED if (WW3D::Is_Snapshot_Activated()) { StringClass value_name(0,true); Get_DX8_Render_State_Value_Name(value_name,state,value); SNAPSHOT_SAY(("DX8 - SetRenderState(state: %s, value: %s)\n", Get_DX8_Render_State_Name(state), value_name)); } #endif RenderStates[state]=value; DX8CALL(SetRenderState( state, value )); DX8_RECORD_RENDER_STATE_CHANGE(); } WWINLINE void DX8Wrapper::Set_DX8_Texture_Stage_State(unsigned stage, D3DTEXTURESTAGESTATETYPE state, unsigned value) { // Can't monitor state changes because setShader call to GERD may change the states! if (TextureStageStates[stage][(unsigned int)state]==value) return; #ifdef MESH_RENDER_SNAPSHOT_ENABLED if (WW3D::Is_Snapshot_Activated()) { StringClass value_name(0,true); Get_DX8_Texture_Stage_State_Value_Name(value_name,state,value); SNAPSHOT_SAY(("DX8 - SetTextureStageState(stage: %d, state: %s, value: %s)\n", stage, Get_DX8_Texture_Stage_State_Name(state), value_name)); } #endif TextureStageStates[stage][(unsigned int)state]=value; DX8CALL(SetTextureStageState( stage, state, value )); DX8_RECORD_TEXTURE_STAGE_STATE_CHANGE(); } WWINLINE void DX8Wrapper::Set_DX8_Texture(unsigned int stage, IDirect3DBaseTexture8* texture) { if (Textures[stage]==texture) return; SNAPSHOT_SAY(("DX8 - SetTexture(%x) \n",texture)); if (Textures[stage]) Textures[stage]->Release(); Textures[stage] = texture; if (Textures[stage]) Textures[stage]->AddRef(); DX8CALL(SetTexture(stage, texture)); DX8_RECORD_TEXTURE_CHANGE(); } WWINLINE void DX8Wrapper::_Copy_DX8_Rects( IDirect3DSurface8* pSourceSurface, CONST RECT* pSourceRectsArray, UINT cRects, IDirect3DSurface8* pDestinationSurface, CONST POINT* pDestPointsArray ) { DX8CALL(CopyRects( pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray)); } WWINLINE Vector4 DX8Wrapper::Convert_Color(unsigned color) { Vector4 col; col[3]=((color&0xff000000)>>24)/255.0f; col[0]=((color&0xff0000)>>16)/255.0f; col[1]=((color&0xff00)>>8)/255.0f; col[2]=((color&0xff)>>0)/255.0f; // col=Vector4(1.0f,1.0f,1.0f,1.0f); return col; } #if 0 WWINLINE unsigned int DX8Wrapper::Convert_Color(const Vector3& color, const float alpha) { WWASSERT(color.X<=1.0f); WWASSERT(color.Y<=1.0f); WWASSERT(color.Z<=1.0f); WWASSERT(alpha<=1.0f); WWASSERT(color.X>=0.0f); WWASSERT(color.Y>=0.0f); WWASSERT(color.Z>=0.0f); WWASSERT(alpha>=0.0f); return D3DCOLOR_COLORVALUE(color.X,color.Y,color.Z,alpha); } WWINLINE unsigned int DX8Wrapper::Convert_Color(const Vector4& color) { WWASSERT(color.X<=1.0f); WWASSERT(color.Y<=1.0f); WWASSERT(color.Z<=1.0f); WWASSERT(color.W<=1.0f); WWASSERT(color.X>=0.0f); WWASSERT(color.Y>=0.0f); WWASSERT(color.Z>=0.0f); WWASSERT(color.W>=0.0f); return D3DCOLOR_COLORVALUE(color.X,color.Y,color.Z,color.W); } #else // ---------------------------------------------------------------------------- // // Convert RGBA color from float vector to 32 bit integer // Note: Color vector needs to be clamped to [0...1] range! // // ---------------------------------------------------------------------------- WWINLINE unsigned int DX8Wrapper::Convert_Color(const Vector3& color,float alpha) { const float scale = 255.0; unsigned int col; // Multiply r, g, b and a components (0.0,...,1.0) by 255 and convert to integer. Or the integer values togerher // such that 32 bit ingeger has AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBB. __asm { push ebp sub esp,20 // space for a, r, g and b float plus fpu rounding mode // Store the fpu rounding mode fwait fstcw [esp+16] // store control word to stack mov eax,[esp+16] // load it to eax mov edi,eax // take copy and eax,~(1024|2048) // mask out certain bits or eax,(1024|2048) // or with precision control value "truncate" sub edi,eax // did it change? jz skip // .. if not, skip mov [esp],eax // .. change control word fldcw [esp] skip: // Convert the color mov esi,dword ptr color fld dword ptr[scale] fld dword ptr[esi] // r fld dword ptr[esi+4] // g fld dword ptr[esi+8] // b fld dword ptr[alpha] // a fld st(4) fmul st(4),st fmul st(3),st fmul st(2),st fmulp st(1),st fistp dword ptr[esp+0] // a fistp dword ptr[esp+4] // b fistp dword ptr[esp+8] // g fistp dword ptr[esp+12] // r mov ebp,[esp] // a mov eax,[esp+4] // b mov edx,[esp+8] // g mov ebx,[esp+12] // r shl ebp,24 // a << 24 shl ebx,16 // r << 16 shl edx,8 // g << 8 or eax,ebp // (a << 24) | b or eax,ebx // (a << 24) | (r << 16) | b or eax,edx // (a << 24) | (r << 16) | (g << 8) | b fstp st(0) // Restore fpu rounding mode cmp edi,0 // did we change the value? je not_changed // nope... skip now... fwait fldcw [esp+16]; not_changed: add esp,20 pop ebp mov col,eax } return col; } // ---------------------------------------------------------------------------- // // Clamp color vertor to [0...1] range // // ---------------------------------------------------------------------------- WWINLINE void DX8Wrapper::Clamp_Color(Vector4& color) { if (!CPUDetectClass::Has_CMOV_Instruction()) { for (int i=0;i<4;++i) { float f=(color[i]<0.0f) ? 0.0f : color[i]; color[i]=(f>1.0f) ? 1.0f : f; } return; } __asm { mov esi,dword ptr color mov edx,0x3f800000 mov edi,dword ptr[esi] mov ebx,edi sar edi,31 not edi // mask is now zero if negative value and edi,ebx cmp edi,edx // if no less than 1.0 set to 1.0 cmovnb edi,edx mov dword ptr[esi],edi mov edi,dword ptr[esi+4] mov ebx,edi sar edi,31 not edi // mask is now zero if negative value and edi,ebx cmp edi,edx // if no less than 1.0 set to 1.0 cmovnb edi,edx mov dword ptr[esi+4],edi mov edi,dword ptr[esi+8] mov ebx,edi sar edi,31 not edi // mask is now zero if negative value and edi,ebx cmp edi,edx // if no less than 1.0 set to 1.0 cmovnb edi,edx mov dword ptr[esi+8],edi mov edi,dword ptr[esi+12] mov ebx,edi sar edi,31 not edi // mask is now zero if negative value and edi,ebx cmp edi,edx // if no less than 1.0 set to 1.0 cmovnb edi,edx mov dword ptr[esi+12],edi } } // ---------------------------------------------------------------------------- // // Convert RGBA color from float vector to 32 bit integer // // ---------------------------------------------------------------------------- WWINLINE unsigned int DX8Wrapper::Convert_Color(const Vector4& color) { return Convert_Color(reinterpret_cast(color),color[3]); } WWINLINE unsigned int DX8Wrapper::Convert_Color_Clamp(const Vector4& color) { Vector4 clamped_color=color; DX8Wrapper::Clamp_Color(clamped_color); return Convert_Color(reinterpret_cast(clamped_color),clamped_color[3]); } #endif WWINLINE void DX8Wrapper::Set_Alpha (const float alpha, unsigned int &color) { unsigned char *component = (unsigned char*) &color; component [3] = 255.0f * alpha; } WWINLINE void DX8Wrapper::Get_Render_State(RenderStateStruct& state) { state=render_state; } WWINLINE void DX8Wrapper::Get_Shader(ShaderClass& shader) { shader=render_state.shader; } WWINLINE void DX8Wrapper::Set_Texture(unsigned stage,TextureClass* texture) { WWASSERT(stage(material)); render_state_changed|=MATERIAL_CHANGED; } WWINLINE void DX8Wrapper::Set_Shader(const ShaderClass& shader) { if (!ShaderClass::ShaderDirty && ((unsigned&)shader==(unsigned&)render_state.shader)) return; render_state.shader=shader; render_state_changed|=SHADER_CHANGED; } WWINLINE void DX8Wrapper::Set_Projection_Transform_With_Z_Bias(const Matrix4& matrix, float znear, float zfar) { ZFar=zfar; ZNear=znear; ProjectionMatrix=matrix.Transpose(); if (!Get_Current_Caps()->Support_ZBias() && ZNear!=ZFar) { Matrix4 tmp=ProjectionMatrix; float tmp_zbias=ZBias; tmp_zbias*=(1.0f/16.0f); tmp_zbias*=1.0f / (ZFar - ZNear); tmp[2][2]-=tmp_zbias*tmp[3][2]; DX8CALL(SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&tmp)); } else { DX8CALL(SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&ProjectionMatrix)); } } WWINLINE void DX8Wrapper::Set_Pseudo_ZBias(int zbias) { if (zbias==ZBias) return; if (zbias>15) zbias=15; if (zbias<0) zbias=0; ZBias=zbias; Matrix4 tmp=ProjectionMatrix; float tmp_zbias=ZBias; tmp_zbias*=(1.0f/64.0f); tmp_zbias*=1.0f / (ZFar - ZNear); tmp[2][2]-=tmp_zbias*tmp[3][2]; DX8CALL(SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&tmp)); } WWINLINE void DX8Wrapper::Set_DX8_ZBias(int zbias) { if (zbias==ZBias) return; if (zbias>15) zbias=15; if (zbias<0) zbias=0; ZBias=zbias; if (!Get_Current_Caps()->Support_ZBias() && ZNear!=ZFar) { Matrix4 tmp=ProjectionMatrix; float tmp_zbias=ZBias; tmp_zbias*=(1.0f/16.0f); tmp_zbias*=1.0f / (ZFar - ZNear); tmp[2][2]-=tmp_zbias*tmp[3][2]; DX8CALL(SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&tmp)); } else { Set_DX8_Render_State (D3DRS_ZBIAS, ZBias); } } WWINLINE void DX8Wrapper::Set_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix4& m) { switch ((int)transform) { case D3DTS_WORLD: render_state.world=m.Transpose(); render_state_changed|=(unsigned)WORLD_CHANGED; render_state_changed&=~(unsigned)WORLD_IDENTITY; break; case D3DTS_VIEW: render_state.view=m.Transpose(); render_state_changed|=(unsigned)VIEW_CHANGED; render_state_changed&=~(unsigned)VIEW_IDENTITY; break; case D3DTS_PROJECTION: { Matrix4 ProjectionMatrix=m.Transpose(); ZFar=0.0f; ZNear=0.0f; DX8CALL(SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&ProjectionMatrix)); } break; default: DX8_RECORD_MATRIX_CHANGE(); Matrix4 m2=m.Transpose(); DX8CALL(SetTransform(transform,(D3DMATRIX*)&m2)); break; } } WWINLINE void DX8Wrapper::Set_Transform(D3DTRANSFORMSTATETYPE transform,const Matrix3D& m) { Matrix4 m2(m); switch ((int)transform) { case D3DTS_WORLD: render_state.world=m2.Transpose(); render_state_changed|=(unsigned)WORLD_CHANGED; render_state_changed&=~(unsigned)WORLD_IDENTITY; break; case D3DTS_VIEW: render_state.view=m2.Transpose(); render_state_changed|=(unsigned)VIEW_CHANGED; render_state_changed&=~(unsigned)VIEW_IDENTITY; break; default: DX8_RECORD_MATRIX_CHANGE(); m2=m2.Transpose(); DX8CALL(SetTransform(transform,(D3DMATRIX*)&m2)); break; } } WWINLINE void DX8Wrapper::Set_World_Identity() { if (render_state_changed&(unsigned)WORLD_IDENTITY) return; render_state.world.Make_Identity(); render_state_changed|=(unsigned)WORLD_CHANGED|(unsigned)WORLD_IDENTITY; } WWINLINE void DX8Wrapper::Set_View_Identity() { if (render_state_changed&(unsigned)VIEW_IDENTITY) return; render_state.view.Make_Identity(); render_state_changed|=(unsigned)VIEW_CHANGED|(unsigned)VIEW_IDENTITY; } WWINLINE bool DX8Wrapper::Is_World_Identity() { return !!(render_state_changed&(unsigned)WORLD_IDENTITY); } WWINLINE bool DX8Wrapper::Is_View_Identity() { return !!(render_state_changed&(unsigned)VIEW_IDENTITY); } WWINLINE void DX8Wrapper::Get_Transform(D3DTRANSFORMSTATETYPE transform, Matrix4& m) { D3DMATRIX mat; switch ((int)transform) { case D3DTS_WORLD: if (render_state_changed&WORLD_IDENTITY) m.Make_Identity(); else m=render_state.world.Transpose(); break; case D3DTS_VIEW: if (render_state_changed&VIEW_IDENTITY) m.Make_Identity(); else m=render_state.view.Transpose(); break; default: DX8CALL(GetTransform(transform,&mat)); m=*(Matrix4*)&mat; m=m.Transpose(); break; } } WWINLINE void DX8Wrapper::Set_Light(unsigned index, const D3DLIGHT8* light) { if (light) { render_state.Lights[index]=*light; render_state.LightEnable[index]=true; } else { render_state.LightEnable[index]=false; } render_state_changed|=(LIGHT0_CHANGED<Release_Engine_Ref(); } if (render_state.vertex_buffer) { render_state.vertex_buffer->Release_Engine_Ref(); } render_state=state; render_state_changed=0xffffffff; if (render_state.index_buffer) { render_state.index_buffer->Add_Engine_Ref(); } if (render_state.vertex_buffer) { render_state.vertex_buffer->Add_Engine_Ref(); } } WWINLINE void DX8Wrapper::Release_Render_State() { if (render_state.index_buffer) { render_state.index_buffer->Release_Engine_Ref(); } if (render_state.vertex_buffer) { render_state.vertex_buffer->Release_Engine_Ref(); } REF_PTR_RELEASE(render_state.vertex_buffer); REF_PTR_RELEASE(render_state.index_buffer); REF_PTR_RELEASE(render_state.material); for (unsigned i=0;i