1220 lines
No EOL
39 KiB
C++
1220 lines
No EOL
39 KiB
C++
/*
|
|
** 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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/***********************************************************************************************
|
|
*** 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<const Vector3&>(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<const Vector3&>(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<MAX_TEXTURE_STAGES);
|
|
if (texture==render_state.Textures[stage]) return;
|
|
REF_PTR_SET(render_state.Textures[stage],texture);
|
|
render_state_changed|=(TEXTURE0_CHANGED<<stage);
|
|
}
|
|
|
|
WWINLINE void DX8Wrapper::Set_Material(const VertexMaterialClass* material)
|
|
{
|
|
if (material==render_state.material) return;
|
|
REF_PTR_SET(render_state.material,const_cast<VertexMaterialClass*>(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<<index);
|
|
}
|
|
|
|
WWINLINE const D3DLIGHT8& DX8Wrapper::Peek_Light(unsigned index)
|
|
{
|
|
return render_state.Lights[index];;
|
|
}
|
|
|
|
WWINLINE bool DX8Wrapper::Is_Light_Enabled(unsigned index)
|
|
{
|
|
return render_state.LightEnable[index];
|
|
}
|
|
|
|
|
|
WWINLINE void DX8Wrapper::Set_Render_State(const RenderStateStruct& 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();
|
|
}
|
|
|
|
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<MAX_TEXTURE_STAGES;++i) REF_PTR_RELEASE(render_state.Textures[i]);
|
|
}
|
|
|
|
|
|
WWINLINE RenderStateStruct::RenderStateStruct()
|
|
:
|
|
material(0),
|
|
vertex_buffer(0),
|
|
index_buffer(0)
|
|
{
|
|
for (unsigned i=0;i<MAX_TEXTURE_STAGES;++i) Textures[i]=0;
|
|
}
|
|
|
|
WWINLINE RenderStateStruct::~RenderStateStruct()
|
|
{
|
|
REF_PTR_RELEASE(material);
|
|
REF_PTR_RELEASE(vertex_buffer);
|
|
REF_PTR_RELEASE(index_buffer);
|
|
for (unsigned i=0;i<MAX_TEXTURE_STAGES;++i) REF_PTR_RELEASE(Textures[i]);
|
|
}
|
|
|
|
|
|
WWINLINE RenderStateStruct& RenderStateStruct::operator= (const RenderStateStruct& src)
|
|
{
|
|
REF_PTR_SET(material,src.material);
|
|
REF_PTR_SET(vertex_buffer,src.vertex_buffer);
|
|
REF_PTR_SET(index_buffer,src.index_buffer);
|
|
for (unsigned i=0;i<MAX_TEXTURE_STAGES;++i) REF_PTR_SET(Textures[i],src.Textures[i]);
|
|
|
|
LightEnable[0]=src.LightEnable[0];
|
|
LightEnable[1]=src.LightEnable[1];
|
|
LightEnable[2]=src.LightEnable[2];
|
|
LightEnable[3]=src.LightEnable[3];
|
|
if (LightEnable[0]) {
|
|
Lights[0]=src.Lights[0];
|
|
if (LightEnable[1]) {
|
|
Lights[1]=src.Lights[1];
|
|
if (LightEnable[2]) {
|
|
Lights[2]=src.Lights[2];
|
|
if (LightEnable[3]) {
|
|
Lights[3]=src.Lights[3];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
shader=src.shader;
|
|
world=src.world;
|
|
view=src.view;
|
|
vertex_buffer_type=src.vertex_buffer_type;
|
|
index_buffer_type=src.index_buffer_type;
|
|
vba_offset=src.vba_offset;
|
|
vba_count=src.vba_count;
|
|
iba_offset=src.iba_offset;
|
|
index_base_offset=src.index_base_offset;
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
#endif |