//================ Copyright (c) 1996-2009 Valve Corporation. All Rights Reserved. ================= // // // //================================================================================================== #ifdef _PS3 // Delegate to the correct dxabstract, // code in other files seem to include dxabstract // in a lot of places without platform specialization #include "../ps3gcm/dxabstract.h" #include "ps3/dxabstract_gcm_shared.h" #else #ifndef DXABSTRACT_H #define DXABSTRACT_H #ifdef _WIN32 #pragma once #endif #include "materialsystem/IShader.h" // Uncomment this on Windows if you want to compile the Windows GL version. // #undef USE_ACTUAL_DX #ifdef USE_ACTUAL_DX #ifndef WIN32 #error sorry man #endif #ifdef _X360 #include "d3d9.h" #include "d3dx9.h" #else #include #include "../../dx9sdk/include/d3d9.h" #include "../../dx9sdk/include/d3dx9.h" #endif typedef HWND VD3DHWND; #else #ifdef WIN32 #error Gl on win32? #endif #include "tier0/platform.h" #define DX_TO_GL_ABSTRACTION #include "bitmap/imageformat.h" #include "glmgr/glmgr.h" extern "C" void Debugger(void); // ------------------------------------------------------------------------------------------------------------------------------ // // DEFINES // ------------------------------------------------------------------------------------------------------------------------------ // typedef void* VD3DHWND; typedef void* VD3DHANDLE; // // // Stuff that would be in windows.h // // #ifdef _WINNT_ #error "No interoperability with windows.h!" #else typedef int INT; typedef unsigned long ULONG; typedef long LONG; typedef float FLOAT; typedef unsigned int DWORD; typedef unsigned short WORD; typedef long long LONGLONG; typedef unsigned int UINT; typedef long HRESULT; typedef unsigned char BYTE; #define CONST const typedef unsigned long ULONG_PTR; typedef ULONG_PTR SIZE_T; typedef const char* LPCSTR; typedef char* LPSTR; typedef DWORD* LPDWORD; #define ZeroMemory RtlZeroMemory #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length)) typedef union _LARGE_INTEGER { struct { DWORD LowPart; LONG HighPart; }; struct { DWORD LowPart; LONG HighPart; } u; LONGLONG QuadPart; } LARGE_INTEGER; typedef struct _GUID { bool operator==( const struct _GUID &other ) const; unsigned long Data1; unsigned short Data2; unsigned short Data3; unsigned char Data4[ 8 ]; } GUID; typedef struct _RECT { int left; int top; int right; int bottom; } RECT; // turn this on to get refcount logging from IUnknown #define IUNKNOWN_ALLOC_SPEW 0 #define IUNKNOWN_ALLOC_SPEW_MARK_ALL 0 struct IUnknown { public: int m_refcount[2]; bool m_mark; IUnknown( void ) { m_refcount[0] = 1; m_refcount[1] = 0; m_mark = (IUNKNOWN_ALLOC_SPEW_MARK_ALL != 0); // either all are marked, or only the ones that have SetMark(true) called on them #if IUNKNOWN_ALLOC_SPEW if (m_mark) { GLMPRINTF(("-A- IUnew (%08x) refc -> (%d,%d) ",this,m_refcount[0],m_refcount[1])); } #endif }; virtual ~IUnknown( void ) { #if IUNKNOWN_ALLOC_SPEW if (m_mark) { GLMPRINTF(("-A- IUdel (%08x) ",this )); } #endif }; void AddRef( int which=0, char *comment = NULL ) { Assert( which >= 0 ); Assert( which < 2 ); m_refcount[which]++; #if IUNKNOWN_ALLOC_SPEW if (m_mark) { GLMPRINTF(("-A- IUAddRef (%08x,%d) refc -> (%d,%d) [%s]",this,which,m_refcount[0],m_refcount[1],comment?comment:"...")) ; if (!comment) { GLMPRINTF(("")) ; // place to hang a breakpoint } } #endif }; ULONG __stdcall Release( int which=0, char *comment = NULL ) { Assert( which >= 0 ); Assert( which < 2 ); //int oldrefcs[2] = { m_refcount[0], m_refcount[1] }; bool deleting = false; m_refcount[which]--; if ( (!m_refcount[0]) && (!m_refcount[1]) ) { deleting = true; } #if IUNKNOWN_ALLOC_SPEW if (m_mark) { GLMPRINTF(("-A- IURelease (%08x,%d) refc -> (%d,%d) [%s] %s",this,which,m_refcount[0],m_refcount[1],comment?comment:"...",deleting?"->DELETING":"")); if (!comment) { GLMPRINTF(("")) ; // place to hang a breakpoint } } #endif if (deleting) { if (m_mark) { GLMPRINTF(("")) ; // place to hang a breakpoint } delete this; return 0; } else { return m_refcount[0]; } }; void SetMark( bool markValue, char *comment=NULL ) { #if IUNKNOWN_ALLOC_SPEW if (!m_mark && markValue) // leading edge detect { // print the same thing that the constructor would have printed if it had been marked from the beginning // i.e. it's anticipated that callers asking for marking will do so right at create time GLMPRINTF(("-A- IUSetMark (%08x) refc -> (%d,%d) (%s) ",this,m_refcount[0],m_refcount[1],comment?comment:"...")); } #endif m_mark = markValue; } }; typedef struct tagPOINT { LONG x; LONG y; } POINT, *PPOINT, *LPPOINT; typedef struct _MEMORYSTATUS { DWORD dwLength; SIZE_T dwTotalPhys; } MEMORYSTATUS, *LPMEMORYSTATUS; typedef DWORD COLORREF; #define RGB(r,g,b) ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16))) #define MAKE_HRESULT(sev,fac,code) \ ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) ) #define S_FALSE ((HRESULT)0x00000001L) #define S_OK 0 #define E_OUTOFMEMORY ((HRESULT)(0x8007000EL)) #define FAILED(hr) ((HRESULT)(hr) < 0) #define SUCCEEDED(hr) ((HRESULT)(hr) >= 0) #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) struct RGNDATA { public: }; void Sleep( unsigned int ms ); bool IsIconic( VD3DHWND hWnd ); void GetClientRect( VD3DHWND hWnd, RECT *destRect ); BOOL ClientToScreen( VD3DHWND hWnd, LPPOINT pPoint ); typedef const void* LPCVOID; void* GetCurrentThread(); void SetThreadAffinityMask( void *hThread, int nMask ); void GlobalMemoryStatus( MEMORYSTATUS *pOut ); #endif #define D3DSI_OPCODE_MASK 0x0000FFFF #define D3DSP_TEXTURETYPE_MASK 0x78000000 #define D3DUSAGE_AUTOGENMIPMAP (0x00000400L) #define D3DSP_DCL_USAGE_MASK 0x0000000f #define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000 #define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16 /* Flags to construct D3DRS_COLORWRITEENABLE */ #define D3DCOLORWRITEENABLE_RED (1L<<0) #define D3DCOLORWRITEENABLE_GREEN (1L<<1) #define D3DCOLORWRITEENABLE_BLUE (1L<<2) #define D3DCOLORWRITEENABLE_ALPHA (1L<<3) #define D3DSGR_NO_CALIBRATION 0x00000000L #define D3DXINLINE inline #define D3D_SDK_VERSION 32 #define _FACD3D 0x876 #define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code ) #define D3DERR_NOTFOUND MAKE_D3DHRESULT(2150) #define D3DERR_DEVICELOST MAKE_D3DHRESULT(2152) #define D3DERR_NOTAVAILABLE MAKE_D3DHRESULT(2154) #define D3DERR_DEVICENOTRESET MAKE_D3DHRESULT(2153) #define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156) #define D3DERR_DRIVERINTERNALERROR MAKE_D3DHRESULT(2087) #define D3DERR_OUTOFVIDEOMEMORY MAKE_D3DHRESULT(380) #define D3D_OK S_OK #define D3DPRESENT_RATE_DEFAULT 0x00000000 // // DevCaps // // we need to see who in Source land is interested in these values, as dxabstract is currently reporting zero for the whole Caps word #define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x00000010L /* Device can use execute buffers from system memory */ #define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */ #define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x00000080L /* Device can use TL buffers from video memory */ #define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x00000100L /* Device can texture from system memory */ #define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x00000200L /* Device can texture from device memory */ #define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x00000400L /* Device can draw TLVERTEX primitives */ #define D3DDEVCAPS_CANRENDERAFTERFLIP 0x00000800L /* Device can render without waiting for flip to complete */ #define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000L /* Device can texture from nonlocal video memory */ #define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000L /* Device is texturing from separate memory pools */ #define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */ #define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x00020000L /* Device supports a Tex Blt from system memory to non-local vidmem */ #define D3DDEVCAPS_HWRASTERIZATION 0x00080000L /* Device has HW acceleration for rasterization */ #define D3DDEVCAPS_PUREDEVICE 0x00100000L /* Device supports D3DCREATE_PUREDEVICE */ #define D3DDEVCAPS_QUINTICRTPATCHES 0x00200000L /* Device supports quintic Beziers and BSplines */ #define D3DDEVCAPS_RTPATCHHANDLEZERO 0x00800000L /* Indicates that RT Patches may be drawn efficiently using handle 0 */ #define D3DDEVCAPS_NPATCHES 0x01000000L /* Device supports N-Patches */ // // PrimitiveMiscCaps // #define D3DPMISCCAPS_MASKZ 0x00000002L #define D3DPMISCCAPS_CULLNONE 0x00000010L #define D3DPMISCCAPS_CULLCW 0x00000020L #define D3DPMISCCAPS_CULLCCW 0x00000040L #define D3DPMISCCAPS_COLORWRITEENABLE 0x00000080L #define D3DPMISCCAPS_CLIPPLANESCALEDPOINTS 0x00000100L /* Device correctly clips scaled points to clip planes */ #define D3DPMISCCAPS_CLIPTLVERTS 0x00000200L /* device will clip post-transformed vertex primitives */ #define D3DPMISCCAPS_TSSARGTEMP 0x00000400L /* device supports D3DTA_TEMP for temporary register */ #define D3DPMISCCAPS_BLENDOP 0x00000800L /* device supports D3DRS_BLENDOP */ #define D3DPMISCCAPS_NULLREFERENCE 0x00001000L /* Reference Device that doesnt render */ #define D3DPMISCCAPS_PERSTAGECONSTANT 0x00008000L /* Device supports per-stage constants */ #define D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS 0x00040000L /* Device supports different bit depths for MRT */ #define D3DPMISCCAPS_FOGVERTEXCLAMPED 0x00100000L /* Device clamps fog blend factor per vertex */ // Flags field for Issue #define D3DISSUE_END (1 << 0) // Tells the runtime to issue the end of a query, changing it's state to "non-signaled". #define D3DISSUE_BEGIN (1 << 1) // Tells the runtime to issue the beginng of a query. #define D3DPRESENT_INTERVAL_ONE 0x00000001L #define D3DPRESENT_INTERVAL_IMMEDIATE 0x80000000L /* * Options for clearing */ #define D3DCLEAR_TARGET 0x00000001l /* Clear target surface */ #define D3DCLEAR_ZBUFFER 0x00000002l /* Clear target z buffer */ #define D3DCLEAR_STENCIL 0x00000004l /* Clear stencil planes */ #define D3DENUM_WHQL_LEVEL 0x00000002L #define D3DPTEXTURECAPS_NOPROJECTEDBUMPENV 0x00200000L /* Device does not support projected bump env lookup operation in programmable and fixed function pixel shaders */ #define D3DDEVCAPS2_STREAMOFFSET 0x00000001L /* Device supports offsets in streams. Must be set by DX9 drivers */ #define D3DDEVCAPS_PUREDEVICE 0x00100000L /* Device supports D3DCREATE_PUREDEVICE */ #define D3DCREATE_PUREDEVICE 0x00000010L #define D3DCREATE_SOFTWARE_VERTEXPROCESSING 0x00000020L #define D3DCREATE_HARDWARE_VERTEXPROCESSING 0x00000040L #define D3DCREATE_FPU_PRESERVE 0x00000002L #define D3DPRASTERCAPS_FOGRANGE 0x00010000L #define D3DPRASTERCAPS_FOGTABLE 0x00000100L #define D3DPRASTERCAPS_FOGVERTEX 0x00000080L #define D3DPRASTERCAPS_WFOG 0x00100000L #define D3DPRASTERCAPS_ZFOG 0x00200000L #define D3DPRASTERCAPS_MIPMAPLODBIAS 0x00002000L #define D3DPRASTERCAPS_WBUFFER 0x00040000L #define D3DPRASTERCAPS_ZTEST 0x00000010L // // Caps2 // #define D3DCAPS2_CANCALIBRATEGAMMA 0x00100000L #define D3DPRASTERCAPS_SCISSORTEST 0x01000000L #define D3DPTEXTURECAPS_MIPCUBEMAP 0x00010000L /* Device can do mipmapped cube maps */ #define D3DPTEXTURECAPS_ALPHA 0x00000004L /* Alpha in texture pixels is supported */ #define D3DPTEXTURECAPS_SQUAREONLY 0x00000020L /* Only square textures are supported */ #define D3DCREATE_MULTITHREADED 0x00000004L #define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */ #define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400L #define D3DPTFILTERCAPS_MAGFANISOTROPIC 0x04000000L #define D3DPTEXTURECAPS_CUBEMAP 0x00000800L /* Device can do cubemap textures */ #define D3DPTEXTURECAPS_POW2 0x00000002L /* Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. */ #define D3DPTEXTURECAPS_NONPOW2CONDITIONAL 0x00000100L #define D3DPTEXTURECAPS_PROJECTED 0x00000400L /* Device can do D3DTTFF_PROJECTED */ #define D3DTEXOPCAPS_ADD 0x00000040L #define D3DTEXOPCAPS_MODULATE2X 0x00000010L #define D3DPRASTERCAPS_DEPTHBIAS 0x04000000L #define D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS 0x02000000L #define D3DVTXPCAPS_TEXGEN_SPHEREMAP 0x00000100L /* device supports D3DTSS_TCI_SPHEREMAP */ #define D3DCAPS2_DYNAMICTEXTURES 0x20000000L // The following usages are valid only for querying CheckDeviceFormat #define D3DUSAGE_QUERY_SRGBREAD (0x00010000L) #define D3DUSAGE_QUERY_FILTER (0x00020000L) #define D3DUSAGE_QUERY_SRGBWRITE (0x00040000L) #define D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING (0x00080000L) #define D3DUSAGE_QUERY_VERTEXTEXTURE (0x00100000L) /* Usages for Vertex/Index buffers */ #define D3DUSAGE_WRITEONLY (0x00000008L) #define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L) #define D3DUSAGE_DONOTCLIP (0x00000020L) #define D3DUSAGE_POINTS (0x00000040L) #define D3DUSAGE_RTPATCHES (0x00000080L) #define D3DUSAGE_NPATCHES (0x00000100L) // Flags field for GetData #define D3DGETDATA_FLUSH (1 << 0) // Tells the runtime to flush if the query is outstanding. #define D3DFVF_XYZ 0x002 #define D3DTA_SELECTMASK 0x0000000f // mask for arg selector #define D3DTA_DIFFUSE 0x00000000 // select diffuse color (read only) #define D3DTA_CURRENT 0x00000001 // select stage destination register (read/write) #define D3DTA_TEXTURE 0x00000002 // select texture color (read only) #define D3DTA_TFACTOR 0x00000003 // select D3DRS_TEXTUREFACTOR (read only) #define D3DTA_SPECULAR 0x00000004 // select specular color (read only) #define D3DTA_TEMP 0x00000005 // select temporary register color (read/write) #define D3DTA_CONSTANT 0x00000006 // select texture stage constant #define D3DTA_COMPLEMENT 0x00000010 // take 1.0 - x (read modifier) #define D3DTA_ALPHAREPLICATE 0x00000020 // replicate alpha to color components (read modifier) #define D3DUSAGE_RENDERTARGET (0x00000001L) #define D3DUSAGE_QUERY_VERTEXTEXTURE (0x00100000L) #define D3DUSAGE_QUERY_FILTER (0x00020000L) #define D3DUSAGE_DEPTHSTENCIL (0x00000002L) #define D3DUSAGE_WRITEONLY (0x00000008L) #define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L) #define D3DUSAGE_DYNAMIC (0x00000200L) #define D3DSI_INSTLENGTH_MASK 0x0F000000 #define D3DSI_INSTLENGTH_SHIFT 24 #define D3DSP_TEXTURETYPE_SHIFT 27 #define D3DSP_REGTYPE_SHIFT 28 #define D3DSP_REGTYPE_SHIFT2 8 #define D3DSP_REGTYPE_MASK 0x70000000 #define D3DSP_REGTYPE_MASK2 0x00001800 #define D3DSP_REGNUM_MASK 0x000007FF #define D3DSP_DSTMOD_SHIFT 20 #define D3DSP_DSTMOD_MASK 0x00F00000 #define D3DSPDM_MSAMPCENTROID (4<>8)&0xFF) #define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF) #define D3DSHADER_ADDRESSMODE_SHIFT 13 #define D3DSHADER_ADDRESSMODE_MASK (1 << D3DSHADER_ADDRESSMODE_SHIFT) #define D3DPS_END() 0x0000FFFF // ps_2_0 texld controls #define D3DSI_TEXLD_PROJECT (0x01 << D3DSP_OPCODESPECIFICCONTROL_SHIFT) #define D3DSI_TEXLD_BIAS (0x02 << D3DSP_OPCODESPECIFICCONTROL_SHIFT) // destination parameter write mask #define D3DSP_WRITEMASK_0 0x00010000 // Component 0 (X;Red) #define D3DSP_WRITEMASK_1 0x00020000 // Component 1 (Y;Green) #define D3DSP_WRITEMASK_2 0x00040000 // Component 2 (Z;Blue) #define D3DSP_WRITEMASK_3 0x00080000 // Component 3 (W;Alpha) #define D3DSP_WRITEMASK_ALL 0x000F0000 // All Components #define D3DVS_SWIZZLE_SHIFT 16 #define D3DVS_SWIZZLE_MASK 0x00FF0000 // The following bits define where to take component X from: #define D3DVS_X_X (0 << D3DVS_SWIZZLE_SHIFT) #define D3DVS_X_Y (1 << D3DVS_SWIZZLE_SHIFT) #define D3DVS_X_Z (2 << D3DVS_SWIZZLE_SHIFT) #define D3DVS_X_W (3 << D3DVS_SWIZZLE_SHIFT) // The following bits define where to take component Y from: #define D3DVS_Y_X (0 << (D3DVS_SWIZZLE_SHIFT + 2)) #define D3DVS_Y_Y (1 << (D3DVS_SWIZZLE_SHIFT + 2)) #define D3DVS_Y_Z (2 << (D3DVS_SWIZZLE_SHIFT + 2)) #define D3DVS_Y_W (3 << (D3DVS_SWIZZLE_SHIFT + 2)) // The following bits define where to take component Z from: #define D3DVS_Z_X (0 << (D3DVS_SWIZZLE_SHIFT + 4)) #define D3DVS_Z_Y (1 << (D3DVS_SWIZZLE_SHIFT + 4)) #define D3DVS_Z_Z (2 << (D3DVS_SWIZZLE_SHIFT + 4)) #define D3DVS_Z_W (3 << (D3DVS_SWIZZLE_SHIFT + 4)) // The following bits define where to take component W from: #define D3DVS_W_X (0 << (D3DVS_SWIZZLE_SHIFT + 6)) #define D3DVS_W_Y (1 << (D3DVS_SWIZZLE_SHIFT + 6)) #define D3DVS_W_Z (2 << (D3DVS_SWIZZLE_SHIFT + 6)) #define D3DVS_W_W (3 << (D3DVS_SWIZZLE_SHIFT + 6)) // source parameter modifiers #define D3DSP_SRCMOD_SHIFT 24 #define D3DSP_SRCMOD_MASK 0x0F000000 struct IDirect3DSurface9; struct IDirect3DDevice9; struct IDirect3DCubeTexture9; struct IDirect3DVertexDeclaration9; struct IDirect3DQuery9; // ------------------------------------------------------------------------------------------------------------------------------ // // ENUMS // ------------------------------------------------------------------------------------------------------------------------------ // typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE { D3DSPSM_NONE = 0<= 2.0 D3DDECLTYPE_UBYTE4N = 8, // Each of 4 bytes is normalized by dividing to 255.0 D3DDECLTYPE_SHORT2N = 9, // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1) D3DDECLTYPE_SHORT4N = 10, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0) D3DDECLTYPE_USHORT2N = 11, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1) D3DDECLTYPE_USHORT4N = 12, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0) D3DDECLTYPE_UDEC3 = 13, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1) D3DDECLTYPE_DEC3N = 14, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1) D3DDECLTYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded to (value, value, 0, 1) D3DDECLTYPE_FLOAT16_4 = 16, // Four 16-bit floating point values D3DDECLTYPE_UNUSED = 17, // When the type field in a decl is unused. } D3DDECLTYPE; typedef enum _D3DDECLMETHOD { D3DDECLMETHOD_DEFAULT = 0, D3DDECLMETHOD_PARTIALU, D3DDECLMETHOD_PARTIALV, D3DDECLMETHOD_CROSSUV, // Normal D3DDECLMETHOD_UV, D3DDECLMETHOD_LOOKUP, // Lookup a displacement map D3DDECLMETHOD_LOOKUPPRESAMPLED, // Lookup a pre-sampled displacement map } D3DDECLMETHOD; typedef enum _D3DDECLUSAGE { D3DDECLUSAGE_POSITION = 0, D3DDECLUSAGE_BLENDWEIGHT = 1, D3DDECLUSAGE_BLENDINDICES = 2, D3DDECLUSAGE_NORMAL = 3, D3DDECLUSAGE_PSIZE = 4, D3DDECLUSAGE_TEXCOORD = 5, D3DDECLUSAGE_TANGENT = 6, D3DDECLUSAGE_BINORMAL = 7, D3DDECLUSAGE_TESSFACTOR = 8, D3DDECLUSAGE_PLUGH = 9, // mystery value D3DDECLUSAGE_COLOR = 10, D3DDECLUSAGE_FOG = 11, D3DDECLUSAGE_DEPTH = 12, D3DDECLUSAGE_SAMPLE = 13, } D3DDECLUSAGE; typedef enum _D3DPRIMITIVETYPE { D3DPT_POINTLIST = 1, D3DPT_LINELIST = 2, D3DPT_TRIANGLELIST = 4, D3DPT_TRIANGLESTRIP = 5, D3DPT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ } D3DPRIMITIVETYPE; // ------------------------------------------------------------------------------------------------------------------------------ // // STRUCTURES // ------------------------------------------------------------------------------------------------------------------------------ // typedef struct D3DXPLANE { float& operator[]( int i ); bool operator==( const D3DXPLANE &o ); bool operator!=( const D3DXPLANE &o ); operator float*(); operator const float*() const; float a, b, c, d; } D3DXPLANE; typedef enum _D3DVERTEXBLENDFLAGS { D3DVBF_DISABLE = 0, // Disable vertex blending D3DVBF_1WEIGHTS = 1, // 2 matrix blending D3DVBF_2WEIGHTS = 2, // 3 matrix blending D3DVBF_3WEIGHTS = 3, // 4 matrix blending D3DVBF_TWEENING = 255, // blending using D3DRS_TWEENFACTOR D3DVBF_0WEIGHTS = 256, // one matrix is used with weight 1.0 D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum } D3DVERTEXBLENDFLAGS; typedef struct _D3DINDEXBUFFER_DESC { D3DFORMAT Format; D3DRESOURCETYPE Type; DWORD Usage; D3DPOOL Pool; UINT Size; } D3DINDEXBUFFER_DESC; typedef struct _D3DVERTEXELEMENT9 { WORD Stream; // Stream index WORD Offset; // Offset in the stream in bytes BYTE Type; // Data type BYTE Method; // Processing method BYTE Usage; // Semantics BYTE UsageIndex; // Semantic index } D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9; #define MAX_DEVICE_IDENTIFIER_STRING 512 typedef struct _D3DADAPTER_IDENTIFIER9 { char Driver[MAX_DEVICE_IDENTIFIER_STRING]; char Description[MAX_DEVICE_IDENTIFIER_STRING]; char DeviceName[32]; /* Device name for GDI (ex. \\.\DISPLAY1) */ LARGE_INTEGER DriverVersion; /* Defined for 32 bit components */ DWORD VendorId; DWORD DeviceId; DWORD SubSysId; DWORD Revision; DWORD VideoMemory; } D3DADAPTER_IDENTIFIER9; typedef struct _D3DCOLORVALUE { float r; float g; float b; float a; } D3DCOLORVALUE; typedef struct _D3DMATERIAL9 { D3DCOLORVALUE Diffuse; /* Diffuse color RGBA */ D3DCOLORVALUE Ambient; /* Ambient color RGB */ D3DCOLORVALUE Specular; /* Specular 'shininess' */ D3DCOLORVALUE Emissive; /* Emissive color RGB */ float Power; /* Sharpness if specular highlight */ } D3DMATERIAL9; typedef struct _D3DVOLUME_DESC { D3DFORMAT Format; D3DRESOURCETYPE Type; DWORD Usage; D3DPOOL Pool; UINT Width; UINT Height; UINT Depth; } D3DVOLUME_DESC; typedef struct _D3DVIEWPORT9 { DWORD X; DWORD Y; /* Viewport Top left */ DWORD Width; DWORD Height; /* Viewport Dimensions */ float MinZ; /* Min/max of clip Volume */ float MaxZ; } D3DVIEWPORT9; typedef struct _D3DPSHADERCAPS2_0 { DWORD Caps; INT DynamicFlowControlDepth; INT NumTemps; INT StaticFlowControlDepth; INT NumInstructionSlots; } D3DPSHADERCAPS2_0; typedef struct _D3DCAPS9 { /* Device Info */ D3DDEVTYPE DeviceType; /* Caps from DX7 Draw */ DWORD Caps; DWORD Caps2; /* Cursor Caps */ DWORD CursorCaps; /* 3D Device Caps */ DWORD DevCaps; DWORD PrimitiveMiscCaps; DWORD RasterCaps; DWORD TextureCaps; DWORD TextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DTexture9's DWORD MaxTextureWidth, MaxTextureHeight; DWORD MaxVolumeExtent; DWORD MaxTextureAspectRatio; DWORD MaxAnisotropy; DWORD TextureOpCaps; DWORD MaxTextureBlendStages; DWORD MaxSimultaneousTextures; DWORD VertexProcessingCaps; DWORD MaxActiveLights; DWORD MaxUserClipPlanes; DWORD MaxVertexBlendMatrices; DWORD MaxVertexBlendMatrixIndex; DWORD MaxPrimitiveCount; // max number of primitives per DrawPrimitive call DWORD MaxStreams; DWORD VertexShaderVersion; DWORD MaxVertexShaderConst; // number of vertex shader constant registers DWORD PixelShaderVersion; // Here are the DX9 specific ones DWORD DevCaps2; D3DPSHADERCAPS2_0 PS20Caps; DWORD NumSimultaneousRTs; // Will be at least 1 DWORD MaxVertexShader30InstructionSlots; DWORD MaxPixelShader30InstructionSlots; // only on Mac Posix/GL #if ( defined ( PLATFORM_OSX ) ) DWORD FakeSRGBWrite; // 1 for parts which can't support SRGB writes due to driver issues - 0 for others DWORD MixedSizeTargets; // 1 for parts which can mix attachment sizes (RT's color vs depth) DWORD CanDoSRGBReadFromRTs; // 0 when we're on Leopard, 1 when on Snow Leopard DWORD SRGBDecode; #endif } D3DCAPS9; typedef struct _D3DDISPLAYMODE { UINT Width; UINT Height; UINT RefreshRate; D3DFORMAT Format; } D3DDISPLAYMODE; typedef struct _D3DGAMMARAMP { WORD red [256]; WORD green[256]; WORD blue [256]; } D3DGAMMARAMP; /* Resize Optional Parameters */ typedef struct _D3DPRESENT_PARAMETERS_ { UINT BackBufferWidth; UINT BackBufferHeight; D3DFORMAT BackBufferFormat; UINT BackBufferCount; D3DMULTISAMPLE_TYPE MultiSampleType; DWORD MultiSampleQuality; D3DSWAPEFFECT SwapEffect; VD3DHWND hDeviceWindow; BOOL Windowed; BOOL EnableAutoDepthStencil; D3DFORMAT AutoDepthStencilFormat; DWORD Flags; /* FullScreen_RefreshRateInHz must be zero for Windowed mode */ UINT FullScreen_RefreshRateInHz; UINT PresentationInterval; } D3DPRESENT_PARAMETERS; typedef struct _D3DDEVICE_CREATION_PARAMETERS { UINT AdapterOrdinal; D3DDEVTYPE DeviceType; VD3DHWND hFocusWindow; DWORD BehaviorFlags; } D3DDEVICE_CREATION_PARAMETERS; /* Structures for LockBox */ typedef struct _D3DBOX { UINT Left; UINT Top; UINT Right; UINT Bottom; UINT Front; UINT Back; } D3DBOX; typedef struct _D3DLOCKED_BOX { INT RowPitch; INT SlicePitch; void* pBits; } D3DLOCKED_BOX; typedef struct _D3DSURFACE_DESC { D3DFORMAT Format; D3DRESOURCETYPE Type; DWORD Usage; D3DPOOL Pool; D3DMULTISAMPLE_TYPE MultiSampleType; DWORD MultiSampleQuality; UINT Width; UINT Height; } D3DSURFACE_DESC; typedef struct _D3DLOCKED_RECT { INT Pitch; void* pBits; } D3DLOCKED_RECT; typedef struct _D3DRASTER_STATUS { BOOL InVBlank; UINT ScanLine; } D3DRASTER_STATUS; typedef enum _D3DLIGHTTYPE { D3DLIGHT_POINT = 1, D3DLIGHT_SPOT = 2, D3DLIGHT_DIRECTIONAL = 3, D3DLIGHT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ } D3DLIGHTTYPE; typedef struct _D3DVECTOR { float x; float y; float z; } D3DVECTOR; class D3DXVECTOR2 { public: operator FLOAT* (); operator CONST FLOAT* () const; float x,y; }; class D3DXVECTOR3 : public D3DVECTOR { public: D3DXVECTOR3() {} D3DXVECTOR3( float a, float b, float c ); operator FLOAT* (); operator CONST FLOAT* () const; }; typedef enum _D3DXINCLUDE_TYPE { D3DXINC_LOCAL, // force 32-bit size enum D3DXINC_FORCE_DWORD = 0x7fffffff } D3DXINCLUDE_TYPE; typedef struct _D3DLIGHT9 { D3DLIGHTTYPE Type; /* Type of light source */ D3DCOLORVALUE Diffuse; /* Diffuse color of light */ D3DCOLORVALUE Specular; /* Specular color of light */ D3DCOLORVALUE Ambient; /* Ambient color of light */ D3DVECTOR Position; /* Position in world space */ D3DVECTOR Direction; /* Direction in world space */ float Range; /* Cutoff range */ float Falloff; /* Falloff */ float Attenuation0; /* Constant attenuation */ float Attenuation1; /* Linear attenuation */ float Attenuation2; /* Quadratic attenuation */ float Theta; /* Inner angle of spotlight cone */ float Phi; /* Outer angle of spotlight cone */ } D3DLIGHT9; class D3DXVECTOR4 { public: D3DXVECTOR4() {} D3DXVECTOR4( float a, float b, float c, float d ); float x,y,z,w; }; //---------------------------------------------------------------------------- // D3DXMACRO: // ---------- // Preprocessor macro definition. The application pass in a NULL-terminated // array of this structure to various D3DX APIs. This enables the application // to #define tokens at runtime, before the file is parsed. //---------------------------------------------------------------------------- typedef struct _D3DXMACRO { LPCSTR Name; LPCSTR Definition; } D3DXMACRO, *LPD3DXMACRO; // ------------------------------------------------------------------------------------------------------------------------------ // // ------------------------------------------------------------------------------------------------------------------------------ // // **** FIXED FUNCTION STUFF - None of this stuff needs support in GL. // // Also look for any functions marked with "**** FIXED FUNCTION STUFF" // // It's only laying around here so we don't have to chop up the shader system a lot to strip out the fixed function code paths. // ------------------------------------------------------------------------------------------------------------------------------ // // ------------------------------------------------------------------------------------------------------------------------------ // // **** FIXED FUNCTION STUFF - None of this stuff needs support in GL. typedef enum _D3DTRANSFORMSTATETYPE { D3DTS_VIEW = 2, D3DTS_PROJECTION = 3, D3DTS_TEXTURE0 = 16, D3DTS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ } D3DTRANSFORMSTATETYPE; // **** FIXED FUNCTION STUFF - None of this stuff needs support in GL. typedef enum _D3DTEXTUREOP { // Control D3DTOP_DISABLE = 1, // disables stage D3DTOP_SELECTARG1 = 2, // the default D3DTOP_SELECTARG2 = 3, // Modulate D3DTOP_MODULATE = 4, // multiply args together D3DTOP_MODULATE2X = 5, // multiply and 1 bit D3DTOP_MODULATE4X = 6, // multiply and 2 bits // Add D3DTOP_ADD = 7, // add arguments together D3DTOP_ADDSIGNED = 8, // add with -0.5 bias D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product // Arg1 + Arg2 - Arg1*Arg2 // = Arg1 + (1-Arg1)*Arg2 // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha) D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRS_TEXTUREFACTOR // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha) D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color // Specular mapping D3DTOP_PREMODULATE = 17, // modulate with next texture before use D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB // COLOROP only D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A // COLOROP only D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB // COLOROP only D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A // COLOROP only // Bump mapping D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel // This can do either diffuse or specular bump mapping with correct input. // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B) // where each component has been scaled and offset to make it signed. // The result is replicated into all four (including alpha) channels. // This is a valid COLOROP only. D3DTOP_DOTPRODUCT3 = 24, // Triadic ops D3DTOP_MULTIPLYADD = 25, // Arg0 + Arg1*Arg2 D3DTOP_LERP = 26, // (Arg0)*Arg1 + (1-Arg0)*Arg2 D3DTOP_FORCE_DWORD = 0x7fffffff, } D3DTEXTUREOP; // **** FIXED FUNCTION STUFF - None of this stuff needs support in GL. typedef enum _D3DTEXTURESTAGESTATETYPE { D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls for color channels */ D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */ D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */ D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */ D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */ D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */ D3DTSS_BUMPENVMAT00 = 7, /* float (bump mapping matrix) */ D3DTSS_BUMPENVMAT01 = 8, /* float (bump mapping matrix) */ D3DTSS_BUMPENVMAT10 = 9, /* float (bump mapping matrix) */ D3DTSS_BUMPENVMAT11 = 10, /* float (bump mapping matrix) */ D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates index this texture */ D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */ D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls texture transform */ D3DTSS_COLORARG0 = 26, /* D3DTA_* third arg for triadic ops */ D3DTSS_RESULTARG = 28, /* D3DTA_* arg for result (CURRENT or TEMP) */ D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ } D3DTEXTURESTAGESTATETYPE; // ------------------------------------------------------------------------------------------------------------------------------ // // INTERFACES // ------------------------------------------------------------------------------------------------------------------------------ // struct IDirect3DResource9 : public IUnknown { IDirect3DDevice9 *m_device; // parent device D3DRESOURCETYPE m_restype; DWORD SetPriority(DWORD PriorityNew); }; struct IDirect3DBaseTexture9 : public IDirect3DResource9 // "A Texture.." { D3DSURFACE_DESC m_descZero; // desc of top level. CGLMTex *m_tex; // a CGLMTex can represent all forms of tex int m_srgbFlipCount; virtual ~IDirect3DBaseTexture9(); D3DRESOURCETYPE GetType(); DWORD GetLevelCount(); HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc); }; struct IDirect3DTexture9 : public IDirect3DBaseTexture9 // "Texture 2D" { IDirect3DSurface9 *m_surfZero; // surf of top level. virtual ~IDirect3DTexture9(); HRESULT LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags); HRESULT UnlockRect(UINT Level); HRESULT GetSurfaceLevel(UINT Level,IDirect3DSurface9** ppSurfaceLevel); }; struct IDirect3DCubeTexture9 : public IDirect3DBaseTexture9 // "Texture Cube Map" { IDirect3DSurface9 *m_surfZero[6]; // surfs of top level. virtual ~IDirect3DCubeTexture9(); HRESULT GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface); HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc); }; struct IDirect3DVolumeTexture9 : public IDirect3DBaseTexture9 // "Texture 3D" { IDirect3DSurface9 *m_surfZero; // surf of top level. D3DVOLUME_DESC m_volDescZero; // volume desc top level virtual ~IDirect3DVolumeTexture9(); HRESULT LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags); HRESULT UnlockBox(UINT Level); HRESULT GetLevelDesc( UINT level, D3DVOLUME_DESC *pDesc ); }; // for the moment, a "D3D surface" is modeled as a GLM tex, a face, and a mip. // no Create method, these are filled in by the various create surface methods. struct IDirect3DSurface9 : public IDirect3DResource9 { virtual ~IDirect3DSurface9(); HRESULT LockRect(D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags); HRESULT UnlockRect(); HRESULT GetDesc(D3DSURFACE_DESC *pDesc); D3DSURFACE_DESC m_desc; CGLMTex *m_tex; int m_face; int m_mip; }; struct IDirect3D9 : public IUnknown { public: virtual ~IDirect3D9(); UINT GetAdapterCount(); //cheese: returns 1 HRESULT GetDeviceCaps (UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps); HRESULT GetAdapterIdentifier (UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier); HRESULT CheckDeviceFormat (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat); UINT GetAdapterModeCount (UINT Adapter,D3DFORMAT Format); HRESULT EnumAdapterModes (UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode); HRESULT CheckDeviceType (UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed); HRESULT GetAdapterDisplayMode (UINT Adapter,D3DDISPLAYMODE* pMode); HRESULT CheckDepthStencilMatch (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat); HRESULT CheckDeviceMultiSampleType (UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels); HRESULT CreateDevice (UINT Adapter,D3DDEVTYPE DeviceType,VD3DHWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface); }; struct IDirect3DSwapChain9 : public IUnknown { }; // typedef enum D3DDECLUSAGE // { // D3DDECLUSAGE_POSITION = 0, // D3DDECLUSAGE_BLENDWEIGHT = 1, // D3DDECLUSAGE_BLENDINDICES = 2, // D3DDECLUSAGE_NORMAL = 3, // D3DDECLUSAGE_PSIZE = 4, // D3DDECLUSAGE_TEXCOORD = 5, // D3DDECLUSAGE_TANGENT = 6, // D3DDECLUSAGE_BINORMAL = 7, // D3DDECLUSAGE_TESSFACTOR = 8, // D3DDECLUSAGE_POSITIONT = 9, // D3DDECLUSAGE_COLOR = 10, // D3DDECLUSAGE_FOG = 11, // D3DDECLUSAGE_DEPTH = 12, // D3DDECLUSAGE_SAMPLE = 13, // } D3DDECLUSAGE, *LPD3DDECLUSAGE; // Constants // // D3DDECLUSAGE_POSITION // Position data ranging from (-1,-1) to (1,1). Use D3DDECLUSAGE_POSITION with // a usage index of 0 to specify untransformed position for fixed function // vertex processing and the n-patch tessellator. Use D3DDECLUSAGE_POSITION // with a usage index of 1 to specify untransformed position in the fixed // function vertex shader for vertex tweening. // // D3DDECLUSAGE_BLENDWEIGHT // Blending weight data. Use D3DDECLUSAGE_BLENDWEIGHT with a usage index of 0 // to specify the blend weights used in indexed and nonindexed vertex // blending. // // D3DDECLUSAGE_BLENDINDICES // Blending indices data. Use D3DDECLUSAGE_BLENDINDICES with a usage index of // 0 to specify matrix indices for indexed paletted skinning. // // D3DDECLUSAGE_NORMAL // Vertex normal data. Use D3DDECLUSAGE_NORMAL with a usage index of 0 to // specify vertex normals for fixed function vertex processing and the n-patch // tessellator. Use D3DDECLUSAGE_NORMAL with a usage index of 1 to specify // vertex normals for fixed function vertex processing for vertex tweening. // // D3DDECLUSAGE_PSIZE // Point size data. Use D3DDECLUSAGE_PSIZE with a usage index of 0 to specify // the point-size attribute used by the setup engine of the rasterizer to // expand a point into a quad for the point-sprite functionality. // // D3DDECLUSAGE_TEXCOORD // Texture coordinate data. Use D3DDECLUSAGE_TEXCOORD, n to specify texture // coordinates in fixed function vertex processing and in pixel shaders prior // to ps_3_0. These can be used to pass user defined data. // // D3DDECLUSAGE_TANGENT // Vertex tangent data. // // D3DDECLUSAGE_BINORMAL // Vertex binormal data. // // D3DDECLUSAGE_TESSFACTOR // Single positive floating point value. Use D3DDECLUSAGE_TESSFACTOR with a // usage index of 0 to specify a tessellation factor used in the tessellation // unit to control the rate of tessellation. For more information about the // data type, see D3DDECLTYPE_FLOAT1. // // D3DDECLUSAGE_POSITIONT // Vertex data contains transformed position data ranging from (0,0) to // (viewport width, viewport height). Use D3DDECLUSAGE_POSITIONT with a usage // index of 0 to specify transformed position. When a declaration containing // this is set, the pipeline does not perform vertex processing. // // D3DDECLUSAGE_COLOR // Vertex data contains diffuse or specular color. Use D3DDECLUSAGE_COLOR with // a usage index of 0 to specify the diffuse color in the fixed function // vertex shader and pixel shaders prior to ps_3_0. Use D3DDECLUSAGE_COLOR // with a usage index of 1 to specify the specular color in the fixed function // vertex shader and pixel shaders prior to ps_3_0. // // D3DDECLUSAGE_FOG // Vertex data contains fog data. Use D3DDECLUSAGE_FOG with a usage index of 0 // to specify a fog blend value used after pixel shading finishes. This // applies to pixel shaders prior to version ps_3_0. // // D3DDECLUSAGE_DEPTH // Vertex data contains depth data. // // D3DDECLUSAGE_SAMPLE // Vertex data contains sampler data. Use D3DDECLUSAGE_SAMPLE with a usage // index of 0 to specify the displacement value to look up. It can be used // only with D3DDECLUSAGE_LOOKUPPRESAMPLED or D3DDECLUSAGE_LOOKUP. //note the form of the list terminator.. // #define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0} // typedef struct _D3DVERTEXELEMENT9 // { // WORD Stream; // Stream index // WORD Offset; // Offset in the stream in bytes // BYTE Type; // Data type // BYTE Method; // Processing method // BYTE Usage; // Semantics // BYTE UsageIndex; // Semantic index // } D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9; #define MAX_D3DVERTEXELEMENTS 16 struct D3DVERTEXELEMENT9_GL { // fields right out of the original decl element (copied) D3DVERTEXELEMENT9 m_dxdecl; // d3d info // WORD Stream; // Stream index // WORD Offset; // Offset in the stream in bytes // BYTE Type; // Data type // BYTE Method; // Processing method // BYTE Usage; // Semantics // BYTE UsageIndex; // Semantic index GLMVertexAttributeDesc m_gldecl; // CGLMBuffer *m_buffer; // late-dropped from selected stream desc (left NULL, will replace with stream source buffer at sync time) // GLuint m_datasize; // component count (1,2,3,4) of the attrib // GLenum m_datatype; // data type of the attribute (GL_FLOAT et al) // GLuint m_stride; // late-dropped from stream desc // GLuint m_offset; // net offset to attribute 'zero' within the stream data. Add the stream offset before passing to GL. // GLuint m_normalized; // net offset to attribute 'zero' within the stream data. Add the stream offset before passing to GL. }; struct IDirect3DVertexDeclaration9 : public IUnknown { //public: uint m_elemCount; D3DVERTEXELEMENT9_GL m_elements[ MAX_D3DVERTEXELEMENTS ]; virtual ~IDirect3DVertexDeclaration9(); }; struct IDirect3DQuery9 : public IDirect3DResource9 //was IUnknown { //public: D3DQUERYTYPE m_type; // D3DQUERYTYPE_OCCLUSION or D3DQUERYTYPE_EVENT GLMContext *m_ctx; CGLMQuery *m_query; virtual ~IDirect3DQuery9(); HRESULT Issue(DWORD dwIssueFlags); HRESULT GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags); }; struct IDirect3DVertexBuffer9 : public IDirect3DResource9 //was IUnknown { //public: GLMContext *m_ctx; CGLMBuffer *m_vtxBuffer; D3DVERTEXBUFFER_DESC m_vtxDesc; // to satisfy GetDesc virtual ~IDirect3DVertexBuffer9(); HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); HRESULT Unlock(); }; struct IDirect3DIndexBuffer9 : public IDirect3DResource9 //was IUnknown { //public: GLMContext *m_ctx; CGLMBuffer *m_idxBuffer; D3DINDEXBUFFER_DESC m_idxDesc; // to satisfy GetDesc virtual ~IDirect3DIndexBuffer9(); HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); HRESULT Unlock(); HRESULT GetDesc(D3DINDEXBUFFER_DESC *pDesc); }; struct IDirect3DPixelShader9 : public IDirect3DResource9 //was IUnknown { //public: CGLMProgram *m_pixProgram; uint m_pixHighWater; // count of active constant slots referenced by shader. uint m_pixSamplerMask; // (1< m_stack; int m_stackTop; // top of stack is at the highest index, this is that index. push increases, pop decreases. HRESULT Create( void ); D3DXMATRIX* GetTop(); void Push(); void Pop(); void LoadIdentity(); void LoadMatrix( const D3DXMATRIX *pMat ); void MultMatrix( const D3DXMATRIX *pMat ); void MultMatrixLocal( const D3DXMATRIX *pMat ); HRESULT ScaleLocal(FLOAT x, FLOAT y, FLOAT z); // Left multiply the current matrix with the computed rotation // matrix, counterclockwise about the given axis with the given angle. // (rotation is about the local origin of the object) HRESULT RotateAxisLocal(CONST D3DXVECTOR3* pV, FLOAT Angle); // Left multiply the current matrix with the computed translation // matrix. (transformation is about the local origin of the object) HRESULT TranslateLocal(FLOAT x, FLOAT y, FLOAT z); }; typedef ID3DXMatrixStack* LPD3DXMATRIXSTACK; struct IDirect3DDevice9Params { UINT m_adapter; D3DDEVTYPE m_deviceType; VD3DHWND m_focusWindow; DWORD m_behaviorFlags; D3DPRESENT_PARAMETERS m_presentationParameters; }; #define D3D_MAX_STREAMS 16 struct D3DStreamDesc { IDirect3DVertexBuffer9 *m_vtxBuffer; uint m_offset; uint m_stride; }; struct D3DIndexDesc { IDirect3DIndexBuffer9 *m_idxBuffer; }; // we latch sampler values until draw time and then convert them all to GL form // note these are similar in name to the fields of a GLMTexSamplingParams but contents are not // particularly in the texture filtering area struct D3DSamplerDesc { D3DTEXTUREADDRESS m_addressModes[3]; // D3DTEXTUREADDRESS modes for S,T,R DWORD m_borderColor; // DWORD bordercolor D3DTEXTUREFILTERTYPE m_magFilter; // mag filter D3DTEXTUREFILTERTYPE m_minFilter; // min filter D3DTEXTUREFILTERTYPE m_mipFilter; // mip filter float m_mipmapBias; // float: mipmap bias DWORD m_maxMipLevel; // DWORD 0..(n-1) LOD index of largest map to use (0 == largest) DWORD m_maxAniso; // D3DSAMP_MAXANISOTROPY max aniso DWORD m_srgb; // D3DSAMP_SRGBTEXTURE 0 = no SRGB sampling DWORD m_shadowFilter; // D3DSAMP_SHADOWFILTER }; struct IDirect3DDevice9 : public IUnknown { public: // members IDirect3DDevice9Params m_params; // mirror of the creation inputs // D3D flavor stuff IDirect3DSurface9 *m_rtSurfaces[16]; // current color RT surfaces. [0] is initially == m_defaultColorSurface IDirect3DSurface9 *m_dsSurface; // current DS RT surface. can be changed! IDirect3DSurface9 *m_defaultColorSurface; // default color surface. IDirect3DSurface9 *m_defaultDepthStencilSurface; // queried by GetDepthStencilSurface. IDirect3DVertexDeclaration9 *m_vertDecl; // Set by SetVertexDeclaration... D3DStreamDesc m_streams[ D3D_MAX_STREAMS ]; // Set by SetStreamSource.. D3DIndexDesc m_indices; // Set by SetIndices.. IDirect3DVertexShader9 *m_vertexShader; // Set by SetVertexShader... IDirect3DPixelShader9 *m_pixelShader; // Set by SetPixelShader... IDirect3DBaseTexture9 *m_textures[16]; // set by SetTexture... NULL if stage inactive D3DSamplerDesc m_samplers[16]; // set by SetSamplerState.. // GLM flavor stuff GLMContext *m_ctx; CGLMFBO *m_drawableFBO; // this FBO should have all the attachments set to match m_rtSurfaces and m_dsSurface. // GL state struct { // render state buckets GLAlphaTestEnable_t m_AlphaTestEnable; GLAlphaTestFunc_t m_AlphaTestFunc; GLDepthTestEnable_t m_DepthTestEnable; GLDepthMask_t m_DepthMask; GLDepthFunc_t m_DepthFunc; GLClipPlaneEnable_t m_ClipPlaneEnable[kGLMUserClipPlanes]; GLClipPlaneEquation_t m_ClipPlaneEquation[kGLMUserClipPlanes]; GLColorMaskSingle_t m_ColorMaskSingle; GLColorMaskMultiple_t m_ColorMaskMultiple; GLCullFaceEnable_t m_CullFaceEnable; GLCullFrontFace_t m_CullFrontFace; GLPolygonMode_t m_PolygonMode; GLDepthBias_t m_DepthBias; GLScissorEnable_t m_ScissorEnable; GLScissorBox_t m_ScissorBox; GLViewportBox_t m_ViewportBox; GLViewportDepthRange_t m_ViewportDepthRange; GLBlendEnable_t m_BlendEnable; GLBlendFactor_t m_BlendFactor; GLBlendEquation_t m_BlendEquation; GLBlendColor_t m_BlendColor; GLBlendEnableSRGB_t m_BlendEnableSRGB; GLStencilTestEnable_t m_StencilTestEnable; GLStencilFunc_t m_StencilFunc; GLStencilOp_t m_StencilOp; GLStencilWriteMask_t m_StencilWriteMask; GLClearColor_t m_ClearColor; GLClearDepth_t m_ClearDepth; GLClearStencil_t m_ClearStencil; bool m_FogEnable; // not really pushed to GL, just latched here // samplers GLMTexSamplingParams m_samplers[ 16 ]; // bindings...hmmm... // dirty-bits uint m_stateDirtyMask; // covers the state blocks, indexed by 1<x = pV1->x - pV2->x; pOut->y = pV1->y - pV2->y; pOut->z = pV1->z - pV2->z; return pOut; } D3DXINLINE D3DXVECTOR3* D3DXVec3Cross( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ) { D3DXVECTOR3 v; v.x = pV1->y * pV2->z - pV1->z * pV2->y; v.y = pV1->z * pV2->x - pV1->x * pV2->z; v.z = pV1->x * pV2->y - pV1->y * pV2->x; *pOut = v; return pOut; } D3DXINLINE FLOAT D3DXVec3Dot( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ) { return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z; } D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM ); D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM ); D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, CONST D3DXPLANE *pP); D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM ); D3DXVECTOR4* D3DXVec4Normalize( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV ); D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z ); // Build an ortho projection matrix. (right-handed) D3DXMATRIX* D3DXMatrixOrthoOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,FLOAT zf ); D3DXMATRIX* D3DXMatrixPerspectiveRH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf ); // Transform a plane by a matrix. The vector (a,b,c) must be normal. // M should be the inverse transpose of the transformation desired. D3DXPLANE* D3DXPlaneTransform( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM ); IDirect3D9 *Direct3DCreate9(UINT SDKVersion); void D3DPERF_SetOptions( DWORD dwOptions ); HRESULT D3DXCompileShader( LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable); #endif // USE_ACTUAL_DX // fake D3D usage constant for SRGB tex creation #define D3DUSAGE_TEXTURE_SRGB (0x80000000L) // fake D3D usage constant for deferred tex bits allocation #define D3DUSAGE_TEXTURE_NOD3DMEMORY (0x40000000L) #endif // DXABSTRACT_H #endif // PS3