You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
793 lines
25 KiB
793 lines
25 KiB
/*==========================================================================;
|
|
*
|
|
* Copyright (C) 1995-1997 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: d3di.h
|
|
* Content: Direct3D internal include file
|
|
*@@BEGIN_MSINTERNAL
|
|
*
|
|
* $Id: d3di.h,v 1.26 1995/12/04 11:29:44 sjl Exp $
|
|
*
|
|
* History:
|
|
* Date By Reason
|
|
* ==== == ======
|
|
* 05/11/95 stevela Initial rev with this header.
|
|
* 11/11/95 stevela Light code changed.
|
|
* 21/11/95 colinmc Made Direct3D aggregatable
|
|
* (so it can be QI'd off DirectDraw).
|
|
* 23/11/95 colinmc Made Direct3D textures and devices aggregatable
|
|
* (QI'd off DirectDrawSurfaces).
|
|
* 07/12/95 stevela Merged in Colin's changes.
|
|
* 10/12/95 stevela Removed AGGREGATE_D3D.
|
|
* Removed Validate macros from here. Now in d3dpr.h
|
|
* 02/03/96 colinmc Minor build fix
|
|
* 17/04/96 stevela Use ddraw.h externally and ddrawp.h internally
|
|
*@@END_MSINTERNAL
|
|
*
|
|
***************************************************************************/
|
|
|
|
#ifndef _D3DI_H
|
|
#define _D3DI_H
|
|
|
|
//@@BEGIN_MSINTERNAL
|
|
#include "ddrawp.h"
|
|
#if 0
|
|
//@@END_MSINTERNAL
|
|
#include "ddraw.h"
|
|
//@@BEGIN_MSINTERNAL
|
|
#endif
|
|
//@@END_MSINTERNAL
|
|
#include "d3dp.h"
|
|
|
|
// @@BEGIN_MSINTERNAL
|
|
#if !defined(BUILD_RLAPI) && !defined(BUILD_DDDDK)
|
|
#include "ddrawi.h"
|
|
|
|
#include "rlreg.h"
|
|
#include "lists.h"
|
|
#include "object.h"
|
|
|
|
|
|
/*
|
|
INDEX_BATCH_SCALE is the constant which is used by DrawIndexedPrim
|
|
to deterimine if the number of primitives being drawn is small
|
|
relative to the number of vertices being passed. If it is then
|
|
the prims are dereferenced in batches and sent to DrawPrim.
|
|
*/
|
|
#define INDEX_BATCH_SCALE 2
|
|
|
|
/*
|
|
typedef D3DCOLORMODEL D3DCOLORMODEL;
|
|
|
|
#define D3DCOLOR_RAMP D3DCOLOR_RAMP
|
|
#define D3DCOLOR_RGB D3DCOLOR_RGB
|
|
#define D3D_COLORMODEL D3D_COLORMODEL
|
|
*/
|
|
#endif /* !BUILD_RLAPI */
|
|
// @@END_MSINTERNAL
|
|
|
|
typedef DWORD D3DI_BUFFERHANDLE, *LPD3DI_BUFFERHANDLE;
|
|
|
|
/*
|
|
* Internal version of executedata
|
|
*/
|
|
typedef struct _D3DI_ExecuteData {
|
|
DWORD dwSize;
|
|
D3DI_BUFFERHANDLE dwHandle; /* Handle allocated by driver */
|
|
DWORD dwVertexOffset;
|
|
DWORD dwVertexCount;
|
|
DWORD dwInstructionOffset;
|
|
DWORD dwInstructionLength;
|
|
DWORD dwHVertexOffset;
|
|
D3DSTATUS dsStatus; /* Status after execute */
|
|
} D3DI_EXECUTEDATA, *LPD3DI_EXECUTEDATA;
|
|
|
|
/*
|
|
* Internal version of lightdata and constants for flags
|
|
*/
|
|
|
|
#define D3DLIGHTI_ATT0_IS_NONZERO (0x00010000)
|
|
#define D3DLIGHTI_ATT1_IS_NONZERO (0x00020000)
|
|
#define D3DLIGHTI_ATT2_IS_NONZERO (0x00040000)
|
|
#define D3DLIGHTI_LINEAR_FALLOFF (0x00080000)
|
|
#define D3DLIGHTI_UNIT_SCALE (0x00100000)
|
|
#define D3DLIGHTI_LIGHT_AT_EYE (0x00200000)
|
|
|
|
typedef struct _D3DI_LIGHT {
|
|
D3DLIGHTTYPE type;
|
|
DWORD version; /* matches number on D3DLIGHT struct */
|
|
BOOL valid;
|
|
D3DVALUE red, green, blue, shade;
|
|
D3DVECTOR position;
|
|
D3DVECTOR model_position;
|
|
D3DVECTOR direction;
|
|
D3DVECTOR model_direction;
|
|
D3DVECTOR halfway;
|
|
D3DVECTOR model_eye; /* direction from eye in model space */
|
|
D3DVECTOR model_scale; /* model scale for proper range computations */
|
|
D3DVALUE range;
|
|
D3DVALUE range_squared;
|
|
D3DVALUE falloff;
|
|
D3DVALUE attenuation0;
|
|
D3DVALUE attenuation1;
|
|
D3DVALUE attenuation2;
|
|
D3DVALUE cos_theta_by_2;
|
|
D3DVALUE cos_phi_by_2;
|
|
DWORD flags;
|
|
} D3DI_LIGHT, *LPD3DI_LIGHT;
|
|
|
|
// @@BEGIN_MSINTERNAL
|
|
#if !defined(BUILD_RLAPI) && !defined(BUILD_DDDDK)
|
|
#ifndef BUILD_HEL
|
|
#ifdef BUILD_D3D_LAYER
|
|
#include "driver.h"
|
|
#endif
|
|
|
|
typedef struct IUnknownVtbl D3DUNKNOWNCALLBACKS, *LPD3DUNKNOWNCALLBACKS;
|
|
typedef struct ID3DObjectVtbl D3DOBJECTVTBL, *LPD3DOBJECTVTBL;
|
|
typedef struct IDirect3DVtbl DIRECT3DCALLBACKS, *LPDIRECT3DCALLBACKS;
|
|
typedef struct IDirect3D2Vtbl DIRECT3D2CALLBACKS, *LPDIRECT3D2CALLBACKS;
|
|
typedef struct IDirect3DDeviceVtbl DIRECT3DDEVICECALLBACKS, *LPDIRECT3DDEVICECALLBACKS;
|
|
typedef struct IDirect3DDevice2Vtbl DIRECT3DDEVICE2CALLBACKS, *LPDIRECT3DDEVICE2CALLBACKS;
|
|
typedef struct IDirect3DExecuteBufferVtbl DIRECT3DEXECUTEBUFFERCALLBACKS, *LPDIRECT3DEXECUTEBUFFERCALLBACKS;
|
|
typedef struct IDirect3DLightVtbl DIRECT3DLIGHTCALLBACKS, *LPDIRECT3DLIGHTCALLBACKS;
|
|
typedef struct IDirect3DMaterialVtbl DIRECT3DMATERIALCALLBACKS, *LPDIRECT3DMATERIALCALLBACKS;
|
|
typedef struct IDirect3DMaterial2Vtbl DIRECT3DMATERIAL2CALLBACKS, *LPDIRECT3DMATERIAL2CALLBACKS;
|
|
typedef struct IDirect3DTextureVtbl DIRECT3DTEXTURECALLBACKS, *LPDIRECT3DTEXTURECALLBACKS;
|
|
typedef struct IDirect3DTexture2Vtbl DIRECT3DTEXTURE2CALLBACKS, *LPDIRECT3DTEXTURE2CALLBACKS;
|
|
typedef struct IDirect3DViewport2Vtbl DIRECT3DVIEWPORT2CALLBACKS, *LPDIRECT3DVIEWPORT2CALLBACKS;
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef struct _DIRECT3DI *LPDIRECT3DI;
|
|
typedef struct _DIRECT3DDEVICEI *LPDIRECT3DDEVICEI;
|
|
typedef struct _DIRECT3DEXECUTEBUFFERI *LPDIRECT3DEXECUTEBUFFERI;
|
|
typedef struct _DIRECT3DLIGHTI *LPDIRECT3DLIGHTI;
|
|
typedef struct _DIRECT3DMATERIALI *LPDIRECT3DMATERIALI;
|
|
typedef struct _DIRECT3DTEXTUREI *LPDIRECT3DTEXTUREI;
|
|
typedef struct _DIRECT3DVIEWPORTI *LPDIRECT3DVIEWPORTI;
|
|
|
|
/*
|
|
* If we have an aggregate Direct3D we need a structure to
|
|
* represent an interface distinct from the underlying
|
|
* object. This is that structure. None of this would be necessary
|
|
* in C++
|
|
*/
|
|
typedef struct _DIRECT3DUNKNOWNI
|
|
{
|
|
LPD3DUNKNOWNCALLBACKS lpVtbl;
|
|
LPDIRECT3DI lpObj;
|
|
} DIRECT3DUNKNOWNI;
|
|
typedef struct _DIRECT3DUNKNOWNI *LPDIRECT3DUNKNOWNI;
|
|
|
|
typedef struct _DIRECT3DOLDI
|
|
{
|
|
LPDIRECT3DCALLBACKS lpVtbl;
|
|
LPDIRECT3DI lpObj;
|
|
} DIRECT3DOLDI;
|
|
typedef struct _DIRECT3DOLDI *LPDIRECT3DOLDI;
|
|
|
|
/*
|
|
* Internal version of Direct3D object; it has data after the vtable
|
|
*/
|
|
typedef struct _DIRECT3DI
|
|
{
|
|
/*** Object Interface ***/
|
|
LPDIRECT3D2CALLBACKS lpVtbl; /* Pointer to callbacks */
|
|
int refCnt; /* Reference count object */
|
|
|
|
/*** Object Relations ***/
|
|
/* Devices */
|
|
int numDevs;/* Number of devices */
|
|
LIST_ROOT(_devices, _DIRECT3DDEVICEI) devices;
|
|
/* Associated IDirect3DDevices */
|
|
|
|
/* Viewports */
|
|
int numViewports; /* Number of viewports */
|
|
LIST_ROOT(_viewports, _DIRECT3DVIEWPORTI) viewports;
|
|
/* Created IDirect3DViewports */
|
|
|
|
/* Lights */
|
|
int numLights; /* Number of lights */
|
|
LIST_ROOT(_lights, _DIRECT3DLIGHTI) lights;
|
|
/* Created IDirect3DLights */
|
|
|
|
/* Materials */
|
|
int numMaterials; /* Number of materials */
|
|
LIST_ROOT(_materials, _DIRECT3DMATERIALI) materials;
|
|
/* Created IDirect3DMaterials */
|
|
|
|
/*** Object Data ***/
|
|
unsigned long v_next; /* id of next viewport to be created */
|
|
RLDDIRegistry* lpReg; /* Registry */
|
|
|
|
/*
|
|
* DirectDraw Interface
|
|
*/
|
|
LPDDRAWI_DIRECTDRAW_INT lpDDInt;
|
|
|
|
/*
|
|
* The special IUnknown interface for the aggregate that does
|
|
* not punt to the parent object.
|
|
*/
|
|
LPUNKNOWN lpOwningIUnknown; /* The owning IUnknown */
|
|
DIRECT3DUNKNOWNI lpThisIUnknown; /* Our IUnknown interface */
|
|
DIRECT3DOLDI lpThisIDirect3D; /* Our IDirect3D interface */
|
|
|
|
DWORD dwVersion; /* 1 for legacy D3D, 2 for D3D2 */
|
|
} DIRECT3DI;
|
|
|
|
/*
|
|
* If we have an aggreate Direct3DDevice we need a structure to
|
|
* represent an interface distinct from the underlying
|
|
* object. This is that structure.
|
|
*/
|
|
typedef struct _DIRECT3DDEVICEUNKNOWNI
|
|
{
|
|
LPDIRECT3DDEVICE2CALLBACKS lpVtbl;
|
|
LPDIRECT3DDEVICEI lpObj;
|
|
} DIRECT3DDEVICEUNKNOWNI;
|
|
typedef struct _DIRECT3DDEVICEUNKNOWNI *LPDIRECT3DDEVICEUNKNOWNI;
|
|
|
|
typedef struct _DIRECT3DDEVICEOLDI
|
|
{
|
|
LPDIRECT3DDEVICECALLBACKS lpVtbl;
|
|
LPDIRECT3DDEVICEI lpObj;
|
|
} DIRECT3DDEVICEOLDI;
|
|
typedef struct _DIRECT3DDEVICEOLDI *LPDIRECT3DDEVICEOLDI;
|
|
|
|
/*
|
|
* Internal version of Direct3DDevice object; it has data after the vtable
|
|
*/
|
|
|
|
#include "d3dhal.h"
|
|
|
|
typedef RLDDIDriver* (*RLDDIDDrawCreateDriverFn)(
|
|
LPDDRAWI_DIRECTDRAW_INT lpDDInt,
|
|
LPDIRECTDRAWSURFACE lpDDS,
|
|
LPDIRECTDRAWSURFACE lpZ,
|
|
LPDIRECTDRAWPALETTE lpPal,
|
|
LPDIRECT3DDEVICEI);
|
|
|
|
typedef HRESULT (*RLDDIGetCapsFn)(LPD3DDEVICEDESC*, LPD3DDEVICEDESC*);
|
|
typedef void (*RLDDIInitFn)(RLDDIMallocFn, RLDDIReallocFn, RLDDIFreeFn, RLDDIRaiseFn, RLDDIValue**, int, int);
|
|
typedef void (*RLDDIPushDriverFn)(RLDDIDriverStack*, RLDDIDriver*);
|
|
typedef void (*RLDDIPopDriverFn)(RLDDIDriverStack*);
|
|
|
|
struct _RLDDIGenRasDriver;
|
|
typedef struct _RLDDIGenRasDriver* LPRLDDIGENRASDRIVER;
|
|
struct _RLDDIDDrawDriver;
|
|
typedef struct _RLDDIDDrawDriver* LPRLDDIDDRAWDRIVER;
|
|
|
|
struct _RLDDITransformDriver;
|
|
typedef struct _RLDDITransformDriver* LPRLDDITRANSFORMDRIVER;
|
|
|
|
typedef HRESULT (*PFNLOCKTEXTURE)(LPRLDDIGENRASDRIVER driver);
|
|
typedef void (*PFNUNLOCKTEXTURE)(LPRLDDIGENRASDRIVER driver);
|
|
typedef int (*PFNSETFILLPARAMS)(LPRLDDIGENRASDRIVER driver, D3DSTATE* in_params,
|
|
int count);
|
|
typedef HRESULT (*PFNREALLOCALIGNED)(void** p_inout, size_t size);
|
|
typedef HRESULT (*PFNMALLOCALIGNED)(void** p_inout, size_t size);
|
|
typedef HRESULT (*PFNFREEALIGNED)(void* p_inout);
|
|
typedef HRESULT (*PFNDRVSETRENDERTARGET)(LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE,
|
|
LPDIRECTDRAWPALETTE, LPDIRECT3DDEVICEI);
|
|
typedef HRESULT (*PFNDOFLUSHBEGINEND)(LPDIRECT3DDEVICE2, DWORD);
|
|
typedef HRESULT (*PFNDRAWPRIMITIVES)(LPDIRECT3DDEVICEI, LPD3DTLVERTEX, LPVOID, LPD3DINSTRUCTION, DWORD);
|
|
|
|
|
|
typedef struct _D3DI_TEXTUREBLOCK
|
|
{
|
|
LIST_MEMBER(_D3DI_TEXTUREBLOCK) list;
|
|
/* Next block in IDirect3DTexture */
|
|
LIST_MEMBER(_D3DI_TEXTUREBLOCK) devList;
|
|
/* Next block in IDirect3DDevice */
|
|
LPDIRECT3DDEVICEI lpD3DDeviceI;
|
|
LPDIRECT3DTEXTUREI lpD3DTextureI;
|
|
D3DTEXTUREHANDLE hTex;
|
|
/* texture handle */
|
|
} D3DI_TEXTUREBLOCK;
|
|
typedef struct _D3DI_TEXTUREBLOCK *LPD3DI_TEXTUREBLOCK;
|
|
|
|
typedef struct _D3DI_MATERIALBLOCK
|
|
{
|
|
LIST_MEMBER(_D3DI_MATERIALBLOCK) list;
|
|
/* Next block in IDirect3DMaterial */
|
|
LIST_MEMBER(_D3DI_MATERIALBLOCK) devList;
|
|
/* Next block in IDirect3DDevice */
|
|
LPDIRECT3DDEVICEI lpD3DDeviceI;
|
|
LPDIRECT3DMATERIALI lpD3DMaterialI;
|
|
D3DMATERIALHANDLE hMat;
|
|
/* material handle */
|
|
} D3DI_MATERIALBLOCK;
|
|
typedef struct _D3DI_MATERIALBLOCK *LPD3DI_MATERIALBLOCK;
|
|
|
|
#define D3D_RSTATEBUF_SIZE 128
|
|
#define D3D_MAX_RSTATES 96 /* Last render state ID + 1 */
|
|
#define D3D_MAX_MMX_VERTICES 1024
|
|
|
|
extern DWORD dwD3DTriBatchSize, dwTriBatchSize, dwLineBatchSize;
|
|
extern DWORD dwHWBufferSize, dwHWMaxTris;
|
|
extern DWORD dwHWFewVertices;
|
|
|
|
typedef struct _D3DHAL_DRAWPRIMCOUNTS *LPD3DHAL_DRAWPRIMCOUNTS;
|
|
|
|
// Legacy HAL batching is done with these structs.
|
|
typedef struct _D3DI_HWCOUNTS {
|
|
WORD wNumStateChanges; // Number of state changes batched
|
|
WORD wNumVertices; // Number of vertices in tri list
|
|
WORD wNumTriangles; // Number of triangles in tri list
|
|
} D3DI_HWCOUNTS, *LPD3DI_HWCOUNTS;
|
|
|
|
typedef struct _DIRECT3DDEVICEI
|
|
{
|
|
/*** Object Interface ***/
|
|
LPDIRECT3DDEVICE2CALLBACKS lpVtbl; /* Pointer to callbacks */
|
|
int refCnt; /* Reference count */
|
|
|
|
/*** Object Relations ***/
|
|
LPDIRECT3DI lpDirect3DI; /* parent */
|
|
LIST_MEMBER(_DIRECT3DDEVICEI)list; /* Next device IDirect3D */
|
|
|
|
/* Textures */
|
|
LIST_ROOT(_textures, _D3DI_TEXTUREBLOCK) texBlocks;
|
|
/* Ref to created IDirect3DTextures */
|
|
|
|
/* Execute buffers */
|
|
LIST_ROOT(_buffers, _DIRECT3DEXECUTEBUFFERI) buffers;
|
|
/* Created IDirect3DExecuteBuffers */
|
|
|
|
/* Viewports */
|
|
int numViewports;
|
|
CIRCLE_QUEUE_ROOT(_dviewports, _DIRECT3DVIEWPORTI) viewports;
|
|
/* Associated IDirect3DViewports */
|
|
LPDIRECT3DVIEWPORT2 lpCurrentViewport;
|
|
|
|
/* Materials */
|
|
LIST_ROOT(_dmmaterials, _D3DI_MATERIALBLOCK) matBlocks;
|
|
/* Ref to associated IDirect3DMaterials */
|
|
|
|
/*** Object Data ***/
|
|
/* Private interfaces */
|
|
LPD3DOBJECTVTBL lpClassVtbl; /* Private Vtbl */
|
|
LPD3DOBJECTVTBL lpObjVtbl; /* Private Vtbl */
|
|
|
|
LPD3DHAL_CALLBACKS lpD3DHALCallbacks; /* HW specific */
|
|
LPD3DHAL_GLOBALDRIVERDATA lpD3DHALGlobalDriverData; /* HW specific */
|
|
|
|
/* Viewports */
|
|
unsigned long v_id; /* ID of last viewport rendered */
|
|
|
|
/* Lights */
|
|
int numLights;
|
|
/* This indicates the maximum number
|
|
of lights that have been set in
|
|
the device. */
|
|
|
|
/* Device characteristics */
|
|
int age;
|
|
int width;
|
|
int height;
|
|
int depth;
|
|
unsigned long red_mask, green_mask, blue_mask;
|
|
|
|
int dither;
|
|
int ramp_size; /* SW specific */
|
|
D3DCOLORMODEL color_model;
|
|
int wireframe_options;
|
|
D3DTEXTUREFILTER texture_quality;
|
|
D3DVALUE gamma;
|
|
unsigned char gamma_table[256];
|
|
int aspectx, aspecty;
|
|
D3DVALUE perspective_tolerance;
|
|
|
|
/* Library information */
|
|
#ifdef WIN32
|
|
HINSTANCE hDrvDll;
|
|
char dllname[MAXPATH];
|
|
char base[256];
|
|
#endif
|
|
#ifdef SHLIB
|
|
void* so;
|
|
#endif
|
|
|
|
/* Are we in a scene? */
|
|
BOOL bInScene;
|
|
|
|
/* Our Device type */
|
|
GUID guid;
|
|
|
|
/* GetCaps function from the library */
|
|
RLDDIGetCapsFn GetCapsFn;
|
|
|
|
/* Functions required to build driver */
|
|
RLDDIInitFn RLDDIInit;
|
|
RLDDIPushDriverFn RLDDIPushDriver;
|
|
RLDDIPopDriverFn RLDDIPopDriver;
|
|
RLDDIDDrawCreateDriverFn RLDDIDDrawCreateDriver;
|
|
|
|
/* Device description */
|
|
D3DDEVICEDESC d3dHWDevDesc;
|
|
D3DDEVICEDESC d3dHELDevDesc;
|
|
|
|
/* Driver stack */
|
|
RLDDIDriverStack* stack;
|
|
|
|
/*
|
|
* The special IUnknown interface for the aggregate that does
|
|
* not punt to the parent object.
|
|
*/
|
|
LPUNKNOWN lpOwningIUnknown; /* The owning IUnknown */
|
|
DIRECT3DDEVICEUNKNOWNI lpThisIUnknown; /* Our IUnknown interface */
|
|
DIRECT3DDEVICEOLDI lpThisID3DDev; /* Our IDirect3DDevice interface */
|
|
|
|
LPD3DHAL_CALLBACKS2 lpD3DHALCallbacks2; /* HW specific */
|
|
|
|
/*
|
|
* Renderstate cache for DrawPrimitive
|
|
*/
|
|
WORD wRStateBufLevel;
|
|
D3DSTATE renStateBuf[D3D_RSTATEBUF_SIZE];
|
|
|
|
/* Pointers to drivers used by DrawPrimitive */
|
|
LPRLDDIGENRASDRIVER rasDriver; /* SW specific */
|
|
LPRLDDITRANSFORMDRIVER xfmDriver; /* Assumed to be NULL for HW */
|
|
LPRLDDIDDRAWDRIVER drawDriver; /* Assumed to be NULL for HW */
|
|
|
|
/*
|
|
* Pointers to functions used by DrawPrim&Begin/End
|
|
*/
|
|
|
|
PFNLOCKTEXTURE pfnLockTexture; /* SW specific */
|
|
PFNUNLOCKTEXTURE pfnUnlockTexture; /* SW specific */
|
|
PFNSETFILLPARAMS pfnSetFillParams; /* SW specific */
|
|
PFNREALLOCALIGNED pfnReallocAligned; /* SW specific */
|
|
PFNDRVSETRENDERTARGET pfnDrvSetRenderTarget; /* SW specific */
|
|
HRESULT (*pfnFlushStates)(struct _DIRECT3DDEVICEI*);
|
|
PFNDOFLUSHBEGINEND pfnDoFlushBeginEnd;
|
|
PFNDRAWPRIMITIVES pfnDrawPrimitives;
|
|
|
|
/* Are we between Begin/End? */
|
|
BOOL bInBegin;
|
|
D3DVERTEXTYPE vtVertexType;
|
|
D3DPRIMITIVETYPE ptPrimitiveType;
|
|
CRITICAL_SECTION BeginEndCSect;
|
|
|
|
// max number of vertices
|
|
#define BEGIN_DATA_BLOCK_SIZE 256
|
|
|
|
LPVOID lpvVertexBatch;
|
|
WORD *lpIndexBatch;
|
|
|
|
// lpvVertexData is non-NULL if we are InBegin and indexed.
|
|
LPVOID lpvVertexData;
|
|
DWORD dwNumVertices;
|
|
DWORD dwMaxVertexCount; // current number of vertices there is space for
|
|
WORD *lpVertexIndices;
|
|
DWORD dwNumIndices;
|
|
DWORD dwMaxIndexCount; // current number of indices there is space for
|
|
|
|
DWORD dwFlags;
|
|
WORD wFlushed;
|
|
|
|
/*
|
|
* DrawPrimitives batching
|
|
*/
|
|
|
|
|
|
// Buffer to put DrawPrimitives stuff into
|
|
// Used for both legacy and DrawPrimitive HALs
|
|
WORD *lpwDPBuffer;
|
|
WORD *lpwDPBufferAlloced;
|
|
|
|
/* Legacy HALs */
|
|
// pointer to current prim counts struct
|
|
LPD3DHAL_DRAWPRIMCOUNTS lpDPPrimCounts;
|
|
|
|
// Buffer of counts structures that keep track of the
|
|
// number of render states and vertices buffered
|
|
LPD3DI_HWCOUNTS lpHWCounts;
|
|
|
|
// Buffer of triangle structures.
|
|
LPD3DTRIANGLE lpHWTris;
|
|
|
|
// Buffer of interleaved render states and primitives.
|
|
LPD3DTLVERTEX lpHWVertices;
|
|
|
|
// Byte offset into lpHWVertices. This gets incremented
|
|
// by 8 when a render state is batched and by 32*dwNumVertices
|
|
// when a primitive is batched.
|
|
DWORD dwHWOffset;
|
|
|
|
// Max value of dwHWOffset. Used to decide whether to flush.
|
|
DWORD dwHWMaxOffset;
|
|
|
|
// Index into lpHWTris.
|
|
DWORD dwHWTriIndex;
|
|
|
|
// Number of counts structures used so far. This actually
|
|
// gives the number of primitives batched and the index of
|
|
// the counts structure to batch render states into.
|
|
DWORD dwHWNumCounts;
|
|
|
|
/* DrawPrimitive-aware HALs */
|
|
|
|
// Byte offset into buffer (we are currently
|
|
// using the device's wTriIndex)
|
|
DWORD dwDPOffset;
|
|
|
|
// Maximum offset. If dwDPOffset exceeds this, it is
|
|
// time to flush.
|
|
DWORD dwDPMaxOffset;
|
|
|
|
WORD *wTriIndex;
|
|
|
|
// buffers for TL and H vertices
|
|
LPD3DTLVERTEX lpTLVbuf;
|
|
LPD3DHVERTEX lpHVbuf;
|
|
DWORD dwVbufSize;
|
|
|
|
LPD3DHAL_D3DEXTENDEDCAPS lpD3DExtendedCaps; /* HW specific */
|
|
|
|
} DIRECT3DDEVICEI;
|
|
|
|
/*
|
|
* Internal version of Direct3DExecuteBuffer object;
|
|
* it has data after the vtable
|
|
*/
|
|
typedef struct _DIRECT3DEXECUTEBUFFERI
|
|
{
|
|
/*** Object Interface ***/
|
|
LPDIRECT3DEXECUTEBUFFERCALLBACKS lpVtbl; /* Pointer to callbacks */
|
|
int refCnt; /* Reference count */
|
|
|
|
/*** Object Relations ***/
|
|
LPDIRECT3DDEVICEI lpD3DDeviceI; /* Parent */
|
|
LIST_MEMBER(_DIRECT3DEXECUTEBUFFERI)list;
|
|
/* Next buffer in IDirect3D */
|
|
|
|
/*** Object Data ***/
|
|
DWORD pid; /* Process locking execute buffer */
|
|
D3DEXECUTEBUFFERDESC debDesc;
|
|
/* Description of the buffer */
|
|
D3DEXECUTEDATA exData; /* Execute Data */
|
|
BOOL locked; /* Is the buffer locked */
|
|
|
|
D3DI_BUFFERHANDLE hBuf;
|
|
/* Execute buffer handle */
|
|
} DIRECT3DEXECUTEBUFFERI;
|
|
|
|
/*
|
|
* Internal version of Direct3DLight object;
|
|
* it has data after the vtable
|
|
*/
|
|
typedef struct _DIRECT3DLIGHTI
|
|
{
|
|
/*** Object Interface ***/
|
|
LPDIRECT3DLIGHTCALLBACKS lpVtbl; /* Pointer to callbacks */
|
|
int refCnt; /* Reference count */
|
|
|
|
/*** Object Relations ***/
|
|
LPDIRECT3DI lpDirect3DI; /* Parent */
|
|
LIST_MEMBER(_DIRECT3DLIGHTI)list;
|
|
/* Next light in IDirect3D */
|
|
|
|
LPDIRECT3DVIEWPORTI lpD3DViewportI; /* Guardian */
|
|
CIRCLE_QUEUE_MEMBER(_DIRECT3DLIGHTI)light_list;
|
|
/* Next light in IDirect3DViewport */
|
|
|
|
/*** Object Data ***/
|
|
D3DLIGHT2 dlLight;/* Data describing light */
|
|
D3DI_LIGHT diLightData;
|
|
/* Internal representation of light */
|
|
} DIRECT3DLIGHTI;
|
|
|
|
typedef struct _DIRECT3DMATERIALOLDI
|
|
{
|
|
LPDIRECT3DMATERIALCALLBACKS lpVtbl;
|
|
LPDIRECT3DMATERIALI lpObj;
|
|
} DIRECT3DMATERIALOLDI, *LPDIRECT3DMATERIALOLDI;
|
|
|
|
/*
|
|
* Internal version of Direct3DMaterial object;
|
|
* it has data after the vtable
|
|
*/
|
|
typedef struct _DIRECT3DMATERIALI
|
|
{
|
|
/*** Object Interface ***/
|
|
LPDIRECT3DMATERIAL2CALLBACKS lpVtbl; /* Pointer to callbacks */
|
|
int refCnt; /* Reference count */
|
|
|
|
/*** Object Relations ***/
|
|
LPDIRECT3DI lpDirect3DI; /* Parent */
|
|
DIRECT3DMATERIALOLDI lpThisID3DMat; /* Our IDirect3DMaterial interface */
|
|
LIST_MEMBER(_DIRECT3DMATERIALI)list;
|
|
/* Next MATERIAL in IDirect3D */
|
|
|
|
LIST_ROOT(_mblocks, _D3DI_MATERIALBLOCK)blocks;
|
|
/* devices we're associated with */
|
|
|
|
/*** Object Data ***/
|
|
D3DMATERIAL dmMaterial; /* Data describing material */
|
|
BOOL bRes; /* Is this material reserved in the driver */
|
|
} DIRECT3DMATERIALI;
|
|
|
|
/*
|
|
* If we have an aggreate Direct3DTexture we need a structure
|
|
* to represent an unknown interface distinct from the underlying
|
|
* object. This is that structure.
|
|
*/
|
|
typedef struct _DIRECT3DTEXTUREUNKNOWNI
|
|
{
|
|
LPDIRECT3DTEXTURECALLBACKS lpVtbl;
|
|
LPDIRECT3DTEXTUREI lpObj;
|
|
} DIRECT3DTEXTUREUNKNOWNI;
|
|
typedef struct _DIRECT3DTEXTUREUNKNOWNI *LPDIRECT3DTEXTUREUNKNOWNI;
|
|
|
|
typedef struct _DIRECT3DTEXTUREOLDI
|
|
{
|
|
LPDIRECT3DTEXTURECALLBACKS lpVtbl;
|
|
LPDIRECT3DTEXTUREI lpObj;
|
|
} DIRECT3DTEXTUREOLDI, *LPDIRECT3DTEXTUREOLDI;
|
|
|
|
/*
|
|
* Internal version of Direct3DTexture object; it has data after the vtable
|
|
*/
|
|
typedef struct _DIRECT3DTEXTUREI
|
|
{
|
|
/*** Object Interface ***/
|
|
LPDIRECT3DTEXTURE2CALLBACKS lpVtbl; /* Pointer to callbacks */
|
|
int refCnt; /* Reference count */
|
|
|
|
|
|
/*** Object Relations ***/
|
|
LIST_ROOT(_blocks, _D3DI_TEXTUREBLOCK) blocks;
|
|
/* Devices we're associated with */
|
|
|
|
/*** Object Data ***/
|
|
LPDIRECTDRAWSURFACE lpDDS;
|
|
|
|
/*
|
|
* The special IUnknown interface for the aggregate that does
|
|
* not punt to the parent object.
|
|
*/
|
|
LPUNKNOWN lpOwningIUnknown; /* The owning IUnknown */
|
|
DIRECT3DTEXTUREUNKNOWNI lpThisIUnknown; /* Our IUnknown interface */
|
|
DIRECT3DTEXTUREOLDI lpThisID3DTex; /* Our IDirect3DTexture interface */
|
|
BOOL bIsPalettized;
|
|
|
|
} DIRECT3DTEXTUREI;
|
|
|
|
/*
|
|
* Internal version of Direct3DViewport object; it has data after the vtable
|
|
*/
|
|
typedef struct _DIRECT3DVIEWPORTI
|
|
{
|
|
/*** Object Interface ***/
|
|
LPDIRECT3DVIEWPORT2CALLBACKS lpVtbl; /* Pointer to callbacks */
|
|
int refCnt; /* Reference count */
|
|
|
|
/*** Object Relations */
|
|
LPDIRECT3DI lpDirect3DI; /* Parent */
|
|
LIST_MEMBER(_DIRECT3DVIEWPORTI)list;
|
|
/* Next viewport in IDirect3D */
|
|
|
|
LPDIRECT3DDEVICEI lpD3DDeviceI; /* Guardian */
|
|
CIRCLE_QUEUE_MEMBER(_DIRECT3DVIEWPORTI)vw_list;
|
|
/* Next viewport in IDirect3DDevice */
|
|
|
|
/* Lights */
|
|
int numLights;
|
|
CIRCLE_QUEUE_ROOT(_dlights, _DIRECT3DLIGHTI) lights;
|
|
/* Associated IDirect3DLights */
|
|
|
|
/*** Object Data ***/
|
|
unsigned long v_id; /* Id for this viewport */
|
|
D3DVIEWPORT2 v_data;
|
|
BOOL v_data_is_set;
|
|
|
|
BOOL have_background;
|
|
D3DMATERIALHANDLE background;
|
|
/* Background material */
|
|
BOOL have_depth;
|
|
LPDIRECTDRAWSURFACE depth; /* Background depth */
|
|
|
|
BOOL bLightsChanged;
|
|
/* Have the lights changed since they
|
|
were last collected? */
|
|
DWORD clrCount; /* Number of rects allocated */
|
|
LPD3DRECT clrRects; /* Rects used for clearing */
|
|
} DIRECT3DVIEWPORTI;
|
|
|
|
/*
|
|
* Picking stuff.
|
|
*/
|
|
typedef struct _D3DI_PICKDATA {
|
|
D3DI_EXECUTEDATA* exe;
|
|
D3DPICKRECORD* records;
|
|
int pick_count;
|
|
D3DRECT pick;
|
|
} D3DI_PICKDATA, *LPD3DI_PICKDATA;
|
|
|
|
/*
|
|
* Direct3D memory allocation
|
|
*/
|
|
|
|
/*
|
|
* Register a set of functions to be used in place of malloc, realloc
|
|
* and free for memory allocation. The functions D3DMalloc, D3DRealloc
|
|
* and D3DFree will use these functions. The default is to use the
|
|
* ANSI C library routines malloc, realloc and free.
|
|
*/
|
|
typedef LPVOID (*D3DMALLOCFUNCTION)(size_t);
|
|
typedef LPVOID (*D3DREALLOCFUNCTION)(LPVOID, size_t);
|
|
typedef VOID (*D3DFREEFUNCTION)(LPVOID);
|
|
|
|
/*
|
|
* Allocate size bytes of memory and return a pointer to it in *p_return.
|
|
* Returns D3DERR_BADALLOC with *p_return unchanged if the allocation fails.
|
|
*/
|
|
HRESULT D3DAPI D3DMalloc(LPVOID* p_return, size_t size);
|
|
|
|
/*
|
|
* Change the size of an allocated block of memory. A pointer to the
|
|
* block is passed in in *p_inout. If *p_inout is NULL then a new
|
|
* block is allocated. If the reallocation is successful, *p_inout is
|
|
* changed to point to the new block. If the allocation fails,
|
|
* *p_inout is unchanged and D3DERR_BADALLOC is returned.
|
|
*/
|
|
HRESULT D3DAPI D3DRealloc(LPVOID* p_inout, size_t size);
|
|
|
|
/*
|
|
* Free a block of memory previously allocated with D3DMalloc or
|
|
* D3DRealloc.
|
|
*/
|
|
VOID D3DAPI D3DFree(LPVOID p);
|
|
|
|
/*
|
|
* Used for raising errors from the driver.
|
|
*/
|
|
HRESULT D3DAPI D3DRaise(HRESULT);
|
|
|
|
/*
|
|
* Convert RLDDI error codes to D3D error codes
|
|
*/
|
|
#define RLDDITOD3DERR(_errcode) (RLDDIToD3DErrors[_errcode])
|
|
extern HRESULT RLDDIToD3DErrors[];
|
|
|
|
/*
|
|
* maths
|
|
*/
|
|
#if 1 /* defined(STACK_CALL) && defined(__WATCOMC__) */
|
|
D3DVALUE D3DIPow(D3DVALUE, D3DVALUE);
|
|
#else
|
|
#define D3DIPow(v,p) DTOVAL(pow(VALTOD(v), VALTOD(p)))
|
|
#endif
|
|
|
|
/*
|
|
* Light utils
|
|
*/
|
|
void D3DI_DeviceMarkLightEnd(LPDIRECT3DDEVICEI, int);
|
|
void D3DI_UpdateLightInternal(LPDIRECT3DLIGHTI);
|
|
void D3DI_VectorNormalise12(LPD3DVECTOR v);
|
|
D3DTEXTUREHANDLE D3DI_FindTextureHandle(LPDIRECT3DTEXTUREI, LPDIRECT3DDEVICEI);
|
|
void D3DI_SetTextureHandle(LPDIRECT3DTEXTUREI, LPDIRECT3DDEVICEI, D3DTEXTUREHANDLE);
|
|
void D3DI_RemoveTextureBlock(LPD3DI_TEXTUREBLOCK);
|
|
void D3DI_RemoveMaterialBlock(LPD3DI_MATERIALBLOCK);
|
|
|
|
extern BOOL D3DI_isHALValid(LPD3DHAL_CALLBACKS);
|
|
|
|
#ifdef BUILD_D3D_LAYER
|
|
extern RLDDIValue* RLDDIFInvSqrtTable;
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|
|
|
|
#endif /* BUILD_HEL */
|
|
#endif /* !BUILD_RLAPI */
|
|
// @@END_MSINTERNAL
|
|
|
|
#endif /* _D3DI_H */
|