ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Adapted to the interface/implementation separation. 

Now uses ICOM_THIS to access the implementation structures.
Replaced 'this' with 'This' for ICOM_THIS.
Direct access to the virtual table has been eliminated too.
This commit is contained in:
Francois Gouget 1999-03-27 16:56:13 +00:00 committed by Alexandre Julliard
parent 9e2f4af9b0
commit 022d372709
8 changed files with 2049 additions and 1788 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
graphics/d3dcommon.c
View File

@ -124,7 +124,7 @@ void set_render_state(D3DRENDERSTATETYPE dwRenderStateType,
switch (dwRenderStateType) { switch (dwRenderStateType) {
case D3DRENDERSTATE_TEXTUREHANDLE: { /* 1 */ case D3DRENDERSTATE_TEXTUREHANDLE: { /* 1 */
LPDIRECT3DTEXTURE2 tex = (LPDIRECT3DTEXTURE2) dwRenderState; IDirect3DTexture2Impl* tex = (IDirect3DTexture2Impl*) dwRenderState;
if (tex == NULL) { if (tex == NULL) {
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);

558
graphics/d3ddevices.c
View File

File diff suppressed because it is too large Load Diff

174
graphics/d3dexecutebuffer.c
View File

@ -46,7 +46,7 @@ typedef struct {
D3DVALUE v; D3DVALUE v;
} OGL_LVertex; } OGL_LVertex;
static IDirect3DExecuteBuffer_VTable executebuffer_vtable; static ICOM_VTABLE(IDirect3DExecuteBuffer) executebuffer_vtable;
/******************************************************************************* /*******************************************************************************
* ExecuteBuffer static functions * ExecuteBuffer static functions
@ -169,18 +169,20 @@ void _dump_executedata(LPD3DEXECUTEDATA lpData) {
static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff, static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
LPDIRECT3DDEVICE dev, LPDIRECT3DDEVICE dev,
LPDIRECT3DVIEWPORT vp) { LPDIRECT3DVIEWPORT vp) {
/* DWORD bs = lpBuff->desc.dwBufferSize; */ IDirect3DExecuteBufferImpl* ilpBuff=(IDirect3DExecuteBufferImpl*)lpBuff;
DWORD vs = lpBuff->data.dwVertexOffset; IDirect3DViewport2Impl* ivp=(IDirect3DViewport2Impl*)vp;
/* DWORD vc = lpBuff->data.dwVertexCount; */ /* DWORD bs = ilpBuff->desc.dwBufferSize; */
DWORD is = lpBuff->data.dwInstructionOffset; DWORD vs = ilpBuff->data.dwVertexOffset;
/* DWORD il = lpBuff->data.dwInstructionLength; */ /* DWORD vc = ilpBuff->data.dwVertexCount; */
DWORD is = ilpBuff->data.dwInstructionOffset;
/* DWORD il = ilpBuff->data.dwInstructionLength; */
void *instr = lpBuff->desc.lpData + is; void *instr = ilpBuff->desc.lpData + is;
OpenGL_IDirect3DDevice *odev = (OpenGL_IDirect3DDevice *) dev; OpenGL_IDirect3DDevice *odev = (OpenGL_IDirect3DDevice *) dev;
TRACE(ddraw, "ExecuteData : \n"); TRACE(ddraw, "ExecuteData : \n");
if (TRACE_ON(ddraw)) if (TRACE_ON(ddraw))
_dump_executedata(&(lpBuff->data)); _dump_executedata(&(ilpBuff->data));
while (1) { while (1) {
LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr; LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr;
@ -213,13 +215,13 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
0.0, 0.0, 1.0, 1.0 0.0, 0.0, 1.0, 1.0
}; };
OGL_Vertex *vx = (OGL_Vertex *) lpBuff->vertex_data; OGL_Vertex *vx = (OGL_Vertex *) ilpBuff->vertex_data;
OGL_LVertex *l_vx = (OGL_LVertex *) lpBuff->vertex_data; OGL_LVertex *l_vx = (OGL_LVertex *) ilpBuff->vertex_data;
D3DTLVERTEX *tl_vx = (D3DTLVERTEX *) lpBuff->vertex_data; D3DTLVERTEX *tl_vx = (D3DTLVERTEX *) ilpBuff->vertex_data;
TRACE(ddraw, "TRIANGLE (%d)\n", count); TRACE(ddraw, "TRIANGLE (%d)\n", count);
switch (lpBuff->vertex_type) { switch (ilpBuff->vertex_type) {
case D3DVT_VERTEX: case D3DVT_VERTEX:
/* This time, there is lighting */ /* This time, there is lighting */
glEnable(GL_LIGHTING); glEnable(GL_LIGHTING);
@ -271,7 +273,7 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
if (vp == NULL) { if (ivp == NULL) {
ERR(ddraw, "No current viewport !\n"); ERR(ddraw, "No current viewport !\n");
/* Using standard values */ /* Using standard values */
height = 640.0; height = 640.0;
@ -279,10 +281,10 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
minZ = -10.0; minZ = -10.0;
maxZ = 10.0; maxZ = 10.0;
} else { } else {
height = (GLdouble) vp->viewport.vp1.dwHeight; height = (GLdouble) ivp->viewport.vp1.dwHeight;
width = (GLdouble) vp->viewport.vp1.dwWidth; width = (GLdouble) ivp->viewport.vp1.dwWidth;
minZ = (GLdouble) vp->viewport.vp1.dvMinZ; minZ = (GLdouble) ivp->viewport.vp1.dvMinZ;
maxZ = (GLdouble) vp->viewport.vp1.dvMaxZ; maxZ = (GLdouble) ivp->viewport.vp1.dvMaxZ;
if (minZ == maxZ) { if (minZ == maxZ) {
/* I do not know why, but many Dx 3.0 games have minZ = maxZ = 0.0 */ /* I do not know why, but many Dx 3.0 games have minZ = maxZ = 0.0 */
@ -299,7 +301,7 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
break; break;
} }
switch (lpBuff->vertex_type) { switch (ilpBuff->vertex_type) {
case D3DVT_VERTEX: case D3DVT_VERTEX:
TRIANGLE_LOOP(DO_VERTEX); TRIANGLE_LOOP(DO_VERTEX);
break; break;
@ -397,7 +399,7 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
/* Handle the state transform */ /* Handle the state transform */
switch (ci->t.dlstLightStateType) { switch (ci->t.dlstLightStateType) {
case D3DLIGHTSTATE_MATERIAL: { case D3DLIGHTSTATE_MATERIAL: {
LPDIRECT3DMATERIAL mat = (LPDIRECT3DMATERIAL) ci->v.dwArg[0]; IDirect3DMaterial2Impl* mat = (IDirect3DMaterial2Impl*) ci->v.dwArg[0];
TRACE(ddraw, " MATERIAL\n"); TRACE(ddraw, " MATERIAL\n");
if (mat != NULL) { if (mat != NULL) {
@ -522,14 +524,14 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
/* Enough for the moment */ /* Enough for the moment */
if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) { if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) {
int nb; int nb;
D3DVERTEX *src = ((LPD3DVERTEX) (lpBuff->desc.lpData + vs)) + ci->wStart; D3DVERTEX *src = ((LPD3DVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
OGL_Vertex *dst = ((OGL_Vertex *) (lpBuff->vertex_data)) + ci->wDest; OGL_Vertex *dst = ((OGL_Vertex *) (ilpBuff->vertex_data)) + ci->wDest;
D3DMATRIX *mat = odev->world_mat; D3DMATRIX *mat = odev->world_mat;
TRACE(ddraw, " World Matrix : (%p)\n", mat); TRACE(ddraw, " World Matrix : (%p)\n", mat);
dump_mat(mat); dump_mat(mat);
lpBuff->vertex_type = D3DVT_VERTEX; ilpBuff->vertex_type = D3DVT_VERTEX;
for (nb = 0; nb < ci->dwCount; nb++) { for (nb = 0; nb < ci->dwCount; nb++) {
/* For the moment, no normal transformation... */ /* For the moment, no normal transformation... */
@ -551,14 +553,14 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
} }
} else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) { } else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) {
int nb; int nb;
D3DLVERTEX *src = ((LPD3DLVERTEX) (lpBuff->desc.lpData + vs)) + ci->wStart; D3DLVERTEX *src = ((LPD3DLVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
OGL_LVertex *dst = ((OGL_LVertex *) (lpBuff->vertex_data)) + ci->wDest; OGL_LVertex *dst = ((OGL_LVertex *) (ilpBuff->vertex_data)) + ci->wDest;
D3DMATRIX *mat = odev->world_mat; D3DMATRIX *mat = odev->world_mat;
TRACE(ddraw, " World Matrix : (%p)\n", mat); TRACE(ddraw, " World Matrix : (%p)\n", mat);
dump_mat(mat); dump_mat(mat);
lpBuff->vertex_type = D3DVT_LVERTEX; ilpBuff->vertex_type = D3DVT_LVERTEX;
for (nb = 0; nb < ci->dwCount; nb++) { for (nb = 0; nb < ci->dwCount; nb++) {
dst->c = src->c.color; dst->c = src->c.color;
@ -576,10 +578,10 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
dst++; dst++;
} }
} else if (ci->dwFlags == D3DPROCESSVERTICES_COPY) { } else if (ci->dwFlags == D3DPROCESSVERTICES_COPY) {
D3DTLVERTEX *src = ((LPD3DTLVERTEX) (lpBuff->desc.lpData + vs)) + ci->wStart; D3DTLVERTEX *src = ((LPD3DTLVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (lpBuff->vertex_data)) + ci->wDest; D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (ilpBuff->vertex_data)) + ci->wDest;
lpBuff->vertex_type = D3DVT_TLVERTEX; ilpBuff->vertex_type = D3DVT_TLVERTEX;
memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX)); memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX));
} else { } else {
@ -611,7 +613,7 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
LPD3DBRANCH ci = (LPD3DBRANCH) instr; LPD3DBRANCH ci = (LPD3DBRANCH) instr;
if ((lpBuff->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue) { if ((ilpBuff->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue) {
if (!ci->bNegate) { if (!ci->bNegate) {
TRACE(ddraw," Should branch to %ld\n", ci->dwOffset); TRACE(ddraw," Should branch to %ld\n", ci->dwOffset);
} }
@ -638,7 +640,7 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
LPD3DSTATUS ci = (LPD3DSTATUS) instr; LPD3DSTATUS ci = (LPD3DSTATUS) instr;
lpBuff->data.dsStatus = *ci; ilpBuff->data.dsStatus = *ci;
instr += size; instr += size;
} }
@ -658,11 +660,11 @@ static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
/******************************************************************************* /*******************************************************************************
* ExecuteBuffer Creation functions * ExecuteBuffer Creation functions
*/ */
LPDIRECT3DEXECUTEBUFFER d3dexecutebuffer_create(LPDIRECT3DDEVICE d3ddev, LPD3DEXECUTEBUFFERDESC lpDesc) LPDIRECT3DEXECUTEBUFFER d3dexecutebuffer_create(IDirect3DDeviceImpl* d3ddev, LPD3DEXECUTEBUFFERDESC lpDesc)
{ {
LPDIRECT3DEXECUTEBUFFER eb; IDirect3DExecuteBufferImpl* eb;
eb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DExecuteBuffer)); eb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DExecuteBufferImpl));
eb->ref = 1; eb->ref = 1;
eb->lpvtbl = &executebuffer_vtable; eb->lpvtbl = &executebuffer_vtable;
eb->d3ddev = d3ddev; eb->d3ddev = d3ddev;
@ -693,97 +695,104 @@ LPDIRECT3DEXECUTEBUFFER d3dexecutebuffer_create(LPDIRECT3DDEVICE d3ddev, LPD3DEX
eb->execute = execute; eb->execute = execute;
return eb; return (LPDIRECT3DEXECUTEBUFFER)eb;
} }
/******************************************************************************* /*******************************************************************************
* IDirect3DLight methods * IDirect3ExecuteBuffer methods
*/ */
static HRESULT WINAPI IDirect3DExecuteBuffer_QueryInterface(LPDIRECT3DEXECUTEBUFFER this, static HRESULT WINAPI IDirect3DExecuteBufferImpl_QueryInterface(LPDIRECT3DEXECUTEBUFFER iface,
REFIID riid, REFIID riid,
LPVOID* ppvObj) LPVOID* ppvObj)
{ {
ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
char xrefiid[50]; char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)riid,xrefiid); WINE_StringFromCLSID((LPCLSID)riid,xrefiid);
FIXME(ddraw, "(%p)->(%s,%p): stub\n", this, xrefiid,ppvObj); FIXME(ddraw, "(%p)->(%s,%p): stub\n", This, xrefiid,ppvObj);
return S_OK; return S_OK;
} }
static ULONG WINAPI IDirect3DExecuteBuffer_AddRef(LPDIRECT3DEXECUTEBUFFER this) static ULONG WINAPI IDirect3DExecuteBufferImpl_AddRef(LPDIRECT3DEXECUTEBUFFER iface)
{ {
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", This, This->ref );
return ++(this->ref); return ++(This->ref);
} }
static ULONG WINAPI IDirect3DExecuteBuffer_Release(LPDIRECT3DEXECUTEBUFFER this) static ULONG WINAPI IDirect3DExecuteBufferImpl_Release(LPDIRECT3DEXECUTEBUFFER iface)
{ {
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
if (!--(this->ref)) { if (!--(This->ref)) {
if ((this->desc.lpData != NULL) && this->need_free) if ((This->desc.lpData != NULL) && This->need_free)
HeapFree(GetProcessHeap(),0,this->desc.lpData); HeapFree(GetProcessHeap(),0,This->desc.lpData);
if (this->vertex_data != NULL) if (This->vertex_data != NULL)
HeapFree(GetProcessHeap(),0,this->vertex_data); HeapFree(GetProcessHeap(),0,This->vertex_data);
HeapFree(GetProcessHeap(),0,this); HeapFree(GetProcessHeap(),0,This);
return 0; return 0;
} }
return this->ref; return This->ref;
} }
static HRESULT WINAPI IDirect3DExecuteBuffer_Initialize(LPDIRECT3DEXECUTEBUFFER this, static HRESULT WINAPI IDirect3DExecuteBufferImpl_Initialize(LPDIRECT3DEXECUTEBUFFER iface,
LPDIRECT3DDEVICE lpDirect3DDevice, LPDIRECT3DDEVICE lpDirect3DDevice,
LPD3DEXECUTEBUFFERDESC lpDesc) LPD3DEXECUTEBUFFERDESC lpDesc)
{ {
FIXME(ddraw, "(%p)->(%p,%p): stub\n", this, lpDirect3DDevice, lpDesc); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
FIXME(ddraw, "(%p)->(%p,%p): stub\n", This, lpDirect3DDevice, lpDesc);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DExecuteBuffer_Lock(LPDIRECT3DEXECUTEBUFFER this, static HRESULT WINAPI IDirect3DExecuteBufferImpl_Lock(LPDIRECT3DEXECUTEBUFFER iface,
LPD3DEXECUTEBUFFERDESC lpDesc) LPD3DEXECUTEBUFFERDESC lpDesc)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpDesc); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpDesc);
/* Copies the buffer description */ /* Copies the buffer description */
*lpDesc = this->desc; *lpDesc = This->desc;
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DExecuteBuffer_Unlock(LPDIRECT3DEXECUTEBUFFER this) static HRESULT WINAPI IDirect3DExecuteBufferImpl_Unlock(LPDIRECT3DEXECUTEBUFFER iface)
{ {
TRACE(ddraw, "(%p)->()\n", this); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
TRACE(ddraw, "(%p)->()\n", This);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DExecuteBuffer_SetExecuteData(LPDIRECT3DEXECUTEBUFFER this, static HRESULT WINAPI IDirect3DExecuteBufferImpl_SetExecuteData(LPDIRECT3DEXECUTEBUFFER iface,
LPD3DEXECUTEDATA lpData) LPD3DEXECUTEDATA lpData)
{ {
ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
DWORD nbvert; DWORD nbvert;
TRACE(ddraw, "(%p)->(%p)\n", this, lpData); TRACE(ddraw, "(%p)->(%p)\n", This, lpData);
this->data = *lpData; This->data = *lpData;
/* Get the number of vertices in the execute buffer */ /* Get the number of vertices in the execute buffer */
nbvert = this->data.dwVertexCount; nbvert = This->data.dwVertexCount;
/* Prepares the transformed vertex buffer */ /* Prepares the transformed vertex buffer */
if (this->vertex_data != NULL) if (This->vertex_data != NULL)
HeapFree(GetProcessHeap(), 0, this->vertex_data); HeapFree(GetProcessHeap(), 0, This->vertex_data);
this->vertex_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,nbvert * sizeof(OGL_Vertex)); This->vertex_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,nbvert * sizeof(OGL_Vertex));
if (TRACE_ON(ddraw)) { if (TRACE_ON(ddraw)) {
@ -793,31 +802,34 @@ static HRESULT WINAPI IDirect3DExecuteBuffer_SetExecuteData(LPDIRECT3DEXECUTEBUF
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DExecuteBuffer_GetExecuteData(LPDIRECT3DEXECUTEBUFFER this, static HRESULT WINAPI IDirect3DExecuteBufferImpl_GetExecuteData(LPDIRECT3DEXECUTEBUFFER iface,
LPD3DEXECUTEDATA lpData) LPD3DEXECUTEDATA lpData)
{ {
TRACE(ddraw, "(%p)->(%p): stub\n", this, lpData); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
TRACE(ddraw, "(%p)->(%p): stub\n", This, lpData);
*lpData = this->data; *lpData = This->data;
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DExecuteBuffer_Validate(LPDIRECT3DEXECUTEBUFFER this, static HRESULT WINAPI IDirect3DExecuteBufferImpl_Validate(LPDIRECT3DEXECUTEBUFFER iface,
LPDWORD lpdwOffset, LPDWORD lpdwOffset,
LPD3DVALIDATECALLBACK lpFunc, LPD3DVALIDATECALLBACK lpFunc,
LPVOID lpUserArg, LPVOID lpUserArg,
DWORD dwReserved) DWORD dwReserved)
{ {
TRACE(ddraw, "(%p)->(%p,%p,%p,%lu)\n", this, lpdwOffset, lpFunc, lpUserArg, dwReserved); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
TRACE(ddraw, "(%p)->(%p,%p,%p,%lu)\n", This, lpdwOffset, lpFunc, lpUserArg, dwReserved);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DExecuteBuffer_Optimize(LPDIRECT3DEXECUTEBUFFER this, static HRESULT WINAPI IDirect3DExecuteBufferImpl_Optimize(LPDIRECT3DEXECUTEBUFFER iface,
DWORD dwReserved) DWORD dwReserved)
{ {
TRACE(ddraw, "(%p)->(%lu)\n", this, dwReserved); ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
TRACE(ddraw, "(%p)->(%lu)\n", This, dwReserved);
return DD_OK; return DD_OK;
} }
@ -826,19 +838,19 @@ static HRESULT WINAPI IDirect3DExecuteBuffer_Optimize(LPDIRECT3DEXECUTEBUFFER th
/******************************************************************************* /*******************************************************************************
* IDirect3DLight VTable * IDirect3DLight VTable
*/ */
static IDirect3DExecuteBuffer_VTable executebuffer_vtable = { static ICOM_VTABLE(IDirect3DExecuteBuffer) executebuffer_vtable = {
/*** IUnknown methods ***/ /*** IUnknown methods ***/
IDirect3DExecuteBuffer_QueryInterface, IDirect3DExecuteBufferImpl_QueryInterface,
IDirect3DExecuteBuffer_AddRef, IDirect3DExecuteBufferImpl_AddRef,
IDirect3DExecuteBuffer_Release, IDirect3DExecuteBufferImpl_Release,
/*** IDirect3DExecuteBuffer methods ***/ /*** IDirect3DExecuteBuffer methods ***/
IDirect3DExecuteBuffer_Initialize, IDirect3DExecuteBufferImpl_Initialize,
IDirect3DExecuteBuffer_Lock, IDirect3DExecuteBufferImpl_Lock,
IDirect3DExecuteBuffer_Unlock, IDirect3DExecuteBufferImpl_Unlock,
IDirect3DExecuteBuffer_SetExecuteData, IDirect3DExecuteBufferImpl_SetExecuteData,
IDirect3DExecuteBuffer_GetExecuteData, IDirect3DExecuteBufferImpl_GetExecuteData,
IDirect3DExecuteBuffer_Validate, IDirect3DExecuteBufferImpl_Validate,
IDirect3DExecuteBuffer_Optimize IDirect3DExecuteBufferImpl_Optimize
}; };
#endif /* HAVE_MESAGL */ #endif /* HAVE_MESAGL */

158
graphics/d3dlight.c
View File

@ -17,7 +17,7 @@
#ifdef HAVE_MESAGL #ifdef HAVE_MESAGL
static IDirect3DLight_VTable light_vtable; static ICOM_VTABLE(IDirect3DLight) light_vtable;
enum { enum {
D3D_1, D3D_1,
@ -31,8 +31,8 @@ static const float zero_value[] = {
0.0, 0.0, 0.0, 0.0 0.0, 0.0, 0.0, 0.0
}; };
static void update(LPDIRECT3DLIGHT this) { static void update(IDirect3DLightImpl* This) {
switch (this->light.dltType) { switch (This->light.dltType) {
case D3DLIGHT_POINT: /* 1 */ case D3DLIGHT_POINT: /* 1 */
TRACE(ddraw, "Activating POINT\n"); TRACE(ddraw, "Activating POINT\n");
break; break;
@ -46,24 +46,24 @@ static void update(LPDIRECT3DLIGHT this) {
TRACE(ddraw, "Activating DIRECTIONAL\n"); TRACE(ddraw, "Activating DIRECTIONAL\n");
TRACE(ddraw, " direction : %f %f %f\n", TRACE(ddraw, " direction : %f %f %f\n",
this->light.dvDirection.x.x, This->light.dvDirection.x.x,
this->light.dvDirection.y.y, This->light.dvDirection.y.y,
this->light.dvDirection.z.z); This->light.dvDirection.z.z);
_dump_colorvalue(" color ", this->light.dcvColor); _dump_colorvalue(" color ", This->light.dcvColor);
glLightfv(this->light_num, glLightfv(This->light_num,
GL_AMBIENT, GL_AMBIENT,
(float *) zero_value); (float *) zero_value);
glLightfv(this->light_num, glLightfv(This->light_num,
GL_DIFFUSE, GL_DIFFUSE,
(float *) &(this->light.dcvColor)); (float *) &(This->light.dcvColor));
direction[0] = -this->light.dvDirection.x.x; direction[0] = -This->light.dvDirection.x.x;
direction[1] = -this->light.dvDirection.y.y; direction[1] = -This->light.dvDirection.y.y;
direction[2] = -this->light.dvDirection.z.z; direction[2] = -This->light.dvDirection.z.z;
direction[3] = 0.0; /* This is a directional light */ direction[3] = 0.0; /* This is a directional light */
glLightfv(this->light_num, glLightfv(This->light_num,
GL_POSITION, GL_POSITION,
(float *) direction); (float *) direction);
} break; } break;
@ -78,14 +78,14 @@ static void update(LPDIRECT3DLIGHT this) {
} }
} }
static void activate(LPDIRECT3DLIGHT this) { static void activate(IDirect3DLightImpl* This) {
update(this); update(This);
/* If was not active, activate it */ /* If was not active, activate it */
if (this->is_active == 0) { if (This->is_active == 0) {
glEnable(this->light_num); glEnable(This->light_num);
this->is_active = 1; This->is_active = 1;
} }
return ; return ;
@ -94,80 +94,83 @@ static void activate(LPDIRECT3DLIGHT this) {
/******************************************************************************* /*******************************************************************************
* Light Creation functions * Light Creation functions
*/ */
LPDIRECT3DLIGHT d3dlight_create(LPDIRECT3D2 d3d) LPDIRECT3DLIGHT d3dlight_create(IDirect3D2Impl* d3d2)
{ {
LPDIRECT3DLIGHT mat; IDirect3DLightImpl* light;
mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DLight)); light = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DLightImpl));
mat->ref = 1; light->ref = 1;
mat->lpvtbl = &light_vtable; light->lpvtbl = &light_vtable;
mat->d3d.d3d2 = d3d; light->d3d.d3d2 = d3d2;
mat->type = D3D_2; light->type = D3D_2;
mat->next = NULL; light->next = NULL;
mat->prev = NULL; light->prev = NULL;
mat->activate = activate; light->activate = activate;
mat->is_active = 0; light->is_active = 0;
return mat; return (LPDIRECT3DLIGHT)light;
} }
LPDIRECT3DLIGHT d3dlight_create_dx3(LPDIRECT3D d3d) LPDIRECT3DLIGHT d3dlight_create_dx3(IDirect3DImpl* d3d1)
{ {
LPDIRECT3DLIGHT mat; IDirect3DLightImpl* light;
mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DLight)); light = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DLightImpl));
mat->ref = 1; light->ref = 1;
mat->lpvtbl = &light_vtable; light->lpvtbl = &light_vtable;
mat->d3d.d3d = d3d; light->d3d.d3d1 = d3d1;
mat->type = D3D_1; light->type = D3D_1;
mat->next = NULL; light->next = NULL;
mat->prev = NULL; light->prev = NULL;
mat->activate = activate; light->activate = activate;
mat->is_active = 0; light->is_active = 0;
return mat; return (LPDIRECT3DLIGHT)light;
} }
/******************************************************************************* /*******************************************************************************
* IDirect3DLight methods * IDirect3DLight methods
*/ */
static HRESULT WINAPI IDirect3DLight_QueryInterface(LPDIRECT3DLIGHT this, static HRESULT WINAPI IDirect3DLightImpl_QueryInterface(LPDIRECT3DLIGHT iface,
REFIID riid, REFIID riid,
LPVOID* ppvObj) LPVOID* ppvObj)
{ {
ICOM_THIS(IDirect3DLightImpl,iface);
char xrefiid[50]; char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)riid,xrefiid); WINE_StringFromCLSID((LPCLSID)riid,xrefiid);
FIXME(ddraw, "(%p)->(%s,%p): stub\n", this, xrefiid,ppvObj); FIXME(ddraw, "(%p)->(%s,%p): stub\n", This, xrefiid,ppvObj);
return S_OK; return S_OK;
} }
static ULONG WINAPI IDirect3DLight_AddRef(LPDIRECT3DLIGHT this) static ULONG WINAPI IDirect3DLightImpl_AddRef(LPDIRECT3DLIGHT iface)
{ {
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DLightImpl,iface);
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", This, This->ref );
return ++(this->ref); return ++(This->ref);
} }
static ULONG WINAPI IDirect3DLight_Release(LPDIRECT3DLIGHT this) static ULONG WINAPI IDirect3DLightImpl_Release(LPDIRECT3DLIGHT iface)
{ {
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DLightImpl,iface);
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
if (!--(this->ref)) { if (!--(This->ref)) {
HeapFree(GetProcessHeap(),0,this); HeapFree(GetProcessHeap(),0,This);
return 0; return 0;
} }
return this->ref; return This->ref;
} }
/*** IDirect3DLight methods ***/ /*** IDirect3DLight methods ***/
@ -176,54 +179,57 @@ static void dump_light(LPD3DLIGHT light)
fprintf(stderr, " dwSize : %ld\n", light->dwSize); fprintf(stderr, " dwSize : %ld\n", light->dwSize);
} }
static HRESULT WINAPI IDirect3DLight_GetLight(LPDIRECT3DLIGHT this, static HRESULT WINAPI IDirect3DLightImpl_GetLight(LPDIRECT3DLIGHT iface,
LPD3DLIGHT lpLight) LPD3DLIGHT lpLight)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpLight); ICOM_THIS(IDirect3DLightImpl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpLight);
if (TRACE_ON(ddraw)) if (TRACE_ON(ddraw))
dump_light(lpLight); dump_light(lpLight);
/* Copies the light structure */ /* Copies the light structure */
switch (this->type) { switch (This->type) {
case D3D_1: case D3D_1:
*((LPD3DLIGHT)lpLight) = *((LPD3DLIGHT) &(this->light)); *((LPD3DLIGHT)lpLight) = *((LPD3DLIGHT) &(This->light));
break; break;
case D3D_2: case D3D_2:
*((LPD3DLIGHT2)lpLight) = *((LPD3DLIGHT2) &(this->light)); *((LPD3DLIGHT2)lpLight) = *((LPD3DLIGHT2) &(This->light));
break; break;
} }
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DLight_SetLight(LPDIRECT3DLIGHT this, static HRESULT WINAPI IDirect3DLightImpl_SetLight(LPDIRECT3DLIGHT iface,
LPD3DLIGHT lpLight) LPD3DLIGHT lpLight)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpLight); ICOM_THIS(IDirect3DLightImpl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpLight);
if (TRACE_ON(ddraw)) if (TRACE_ON(ddraw))
dump_light(lpLight); dump_light(lpLight);
/* Stores the light */ /* Stores the light */
switch (this->type) { switch (This->type) {
case D3D_1: case D3D_1:
*((LPD3DLIGHT) &(this->light)) = *((LPD3DLIGHT)lpLight); *((LPD3DLIGHT) &(This->light)) = *((LPD3DLIGHT)lpLight);
break; break;
case D3D_2: case D3D_2:
*((LPD3DLIGHT2) &(this->light)) = *((LPD3DLIGHT2)lpLight); *((LPD3DLIGHT2) &(This->light)) = *((LPD3DLIGHT2)lpLight);
break; break;
} }
if (this->is_active) if (This->is_active)
update(this); update(This);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DLight_Initialize(LPDIRECT3DLIGHT this, static HRESULT WINAPI IDirect3DLightImpl_Initialize(LPDIRECT3DLIGHT iface,
LPDIRECT3D lpDirect3D) LPDIRECT3D lpDirect3D)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpDirect3D); ICOM_THIS(IDirect3DLightImpl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpDirect3D);
return DDERR_ALREADYINITIALIZED; return DDERR_ALREADYINITIALIZED;
} }
@ -232,26 +238,26 @@ static HRESULT WINAPI IDirect3DLight_Initialize(LPDIRECT3DLIGHT this,
/******************************************************************************* /*******************************************************************************
* IDirect3DLight VTable * IDirect3DLight VTable
*/ */
static IDirect3DLight_VTable light_vtable = { static ICOM_VTABLE(IDirect3DLight) light_vtable = {
/*** IUnknown methods ***/ /*** IUnknown methods ***/
IDirect3DLight_QueryInterface, IDirect3DLightImpl_QueryInterface,
IDirect3DLight_AddRef, IDirect3DLightImpl_AddRef,
IDirect3DLight_Release, IDirect3DLightImpl_Release,
/*** IDirect3DLight methods ***/ /*** IDirect3DLight methods ***/
IDirect3DLight_Initialize, IDirect3DLightImpl_Initialize,
IDirect3DLight_SetLight, IDirect3DLightImpl_SetLight,
IDirect3DLight_GetLight IDirect3DLightImpl_GetLight
}; };
#else /* HAVE_MESAGL */ #else /* HAVE_MESAGL */
/* These function should never be called if MesaGL is not present */ /* These function should never be called if MesaGL is not present */
LPDIRECT3DLIGHT d3dlight_create_dx3(LPDIRECT3D d3d) { LPDIRECT3DLIGHT d3dlight_create_dx3(IDirect3DImpl* d3d1) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }
LPDIRECT3DLIGHT d3dlight_create(LPDIRECT3D2 d3d) { LPDIRECT3DLIGHT d3dlight_create(IDirect3D2Impl* d3d2) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }

159
graphics/d3dmaterial.c
View File

@ -16,43 +16,43 @@
#ifdef HAVE_MESAGL #ifdef HAVE_MESAGL
static IDirect3DMaterial2_VTable material2_vtable; static ICOM_VTABLE(IDirect3DMaterial2) material2_vtable;
static IDirect3DMaterial_VTable material_vtable; static ICOM_VTABLE(IDirect3DMaterial) material_vtable;
/******************************************************************************* /*******************************************************************************
* Matrial2 static functions * Matrial2 static functions
*/ */
static void activate(LPDIRECT3DMATERIAL2 this) { static void activate(IDirect3DMaterial2Impl* This) {
TRACE(ddraw, "Activating material %p\n", this); TRACE(ddraw, "Activating material %p\n", This);
/* First, set the rendering context */ /* First, set the rendering context */
if (this->use_d3d2) if (This->use_d3d2)
this->device.active_device2->set_context(this->device.active_device2); This->device.active_device2->set_context(This->device.active_device2);
else else
this->device.active_device1->set_context(this->device.active_device1); This->device.active_device1->set_context(This->device.active_device1);
/* Set the current Material */ /* Set the current Material */
_dump_colorvalue("Diffuse", this->mat.a.diffuse); _dump_colorvalue("Diffuse", This->mat.a.diffuse);
glMaterialfv(GL_FRONT, glMaterialfv(GL_FRONT,
GL_DIFFUSE, GL_DIFFUSE,
(float *) &(this->mat.a.diffuse)); (float *) &(This->mat.a.diffuse));
_dump_colorvalue("Ambient", this->mat.b.ambient); _dump_colorvalue("Ambient", This->mat.b.ambient);
glMaterialfv(GL_FRONT, glMaterialfv(GL_FRONT,
GL_AMBIENT, GL_AMBIENT,
(float *) &(this->mat.b.ambient)); (float *) &(This->mat.b.ambient));
_dump_colorvalue("Specular", this->mat.c.specular); _dump_colorvalue("Specular", This->mat.c.specular);
glMaterialfv(GL_FRONT, glMaterialfv(GL_FRONT,
GL_SPECULAR, GL_SPECULAR,
(float *) &(this->mat.c.specular)); (float *) &(This->mat.c.specular));
_dump_colorvalue("Emissive", this->mat.d.emissive); _dump_colorvalue("Emissive", This->mat.d.emissive);
glMaterialfv(GL_FRONT, glMaterialfv(GL_FRONT,
GL_EMISSION, GL_EMISSION,
(float *) &(this->mat.d.emissive)); (float *) &(This->mat.d.emissive));
TRACE(ddraw, "Size : %ld\n", this->mat.dwSize); TRACE(ddraw, "Size : %ld\n", This->mat.dwSize);
TRACE(ddraw, "Power : %f\n", this->mat.e.power); TRACE(ddraw, "Power : %f\n", This->mat.e.power);
TRACE(ddraw, "Texture handle : %08lx\n", (DWORD)this->mat.hTexture); TRACE(ddraw, "Texture handle : %08lx\n", (DWORD)This->mat.hTexture);
return ; return ;
} }
@ -60,32 +60,32 @@ static void activate(LPDIRECT3DMATERIAL2 this) {
/******************************************************************************* /*******************************************************************************
* Matrial2 Creation functions * Matrial2 Creation functions
*/ */
LPDIRECT3DMATERIAL2 d3dmaterial2_create(LPDIRECT3D2 d3d) LPDIRECT3DMATERIAL2 d3dmaterial2_create(IDirect3D2Impl* d3d2)
{ {
LPDIRECT3DMATERIAL2 mat; IDirect3DMaterial2Impl* mat;
mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DMaterial2)); mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DMaterial2Impl));
mat->ref = 1; mat->ref = 1;
mat->lpvtbl = &material2_vtable; mat->lpvtbl = &material2_vtable;
mat->use_d3d2 = 1; mat->use_d3d2 = 1;
mat->d3d.d3d2 = d3d; mat->d3d.d3d2 = d3d2;
mat->activate = activate; mat->activate = activate;
return mat; return (LPDIRECT3DMATERIAL2)mat;
} }
LPDIRECT3DMATERIAL d3dmaterial_create(LPDIRECT3D d3d) LPDIRECT3DMATERIAL d3dmaterial_create(IDirect3DImpl* d3d1)
{ {
LPDIRECT3DMATERIAL2 mat; IDirect3DMaterial2Impl* mat;
mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DMaterial2)); mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DMaterial2Impl));
mat->ref = 1; mat->ref = 1;
mat->lpvtbl = (LPDIRECT3DMATERIAL2_VTABLE) &material_vtable; mat->lpvtbl = (ICOM_VTABLE(IDirect3DMaterial2)*)&material_vtable;
mat->use_d3d2 = 0; mat->use_d3d2 = 0;
mat->d3d.d3d1 = d3d; mat->d3d.d3d1 = d3d1;
mat->activate = activate; mat->activate = activate;
@ -96,39 +96,42 @@ LPDIRECT3DMATERIAL d3dmaterial_create(LPDIRECT3D d3d)
* IDirect3DMaterial2 methods * IDirect3DMaterial2 methods
*/ */
static HRESULT WINAPI IDirect3DMaterial2_QueryInterface(LPDIRECT3DMATERIAL2 this, static HRESULT WINAPI IDirect3DMaterial2Impl_QueryInterface(LPDIRECT3DMATERIAL2 iface,
REFIID riid, REFIID riid,
LPVOID* ppvObj) LPVOID* ppvObj)
{ {
ICOM_THIS(IDirect3DMaterial2Impl,iface);
char xrefiid[50]; char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)riid,xrefiid); WINE_StringFromCLSID((LPCLSID)riid,xrefiid);
FIXME(ddraw, "(%p)->(%s,%p): stub\n", this, xrefiid,ppvObj); FIXME(ddraw, "(%p)->(%s,%p): stub\n", This, xrefiid,ppvObj);
return S_OK; return S_OK;
} }
static ULONG WINAPI IDirect3DMaterial2_AddRef(LPDIRECT3DMATERIAL2 this) static ULONG WINAPI IDirect3DMaterial2Impl_AddRef(LPDIRECT3DMATERIAL2 iface)
{ {
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DMaterial2Impl,iface);
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", This, This->ref );
return ++(this->ref); return ++(This->ref);
} }
static ULONG WINAPI IDirect3DMaterial2_Release(LPDIRECT3DMATERIAL2 this) static ULONG WINAPI IDirect3DMaterial2Impl_Release(LPDIRECT3DMATERIAL2 iface)
{ {
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DMaterial2Impl,iface);
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
if (!--(this->ref)) { if (!--(This->ref)) {
HeapFree(GetProcessHeap(),0,this); HeapFree(GetProcessHeap(),0,This);
return 0; return 0;
} }
return this->ref; return This->ref;
} }
/*** IDirect3DMaterial2 methods ***/ /*** IDirect3DMaterial2 methods ***/
@ -137,68 +140,74 @@ static void dump_material(LPD3DMATERIAL mat)
fprintf(stderr, " dwSize : %ld\n", mat->dwSize); fprintf(stderr, " dwSize : %ld\n", mat->dwSize);
} }
static HRESULT WINAPI IDirect3DMaterial2_GetMaterial(LPDIRECT3DMATERIAL2 this, static HRESULT WINAPI IDirect3DMaterial2Impl_GetMaterial(LPDIRECT3DMATERIAL2 iface,
LPD3DMATERIAL lpMat) LPD3DMATERIAL lpMat)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpMat); ICOM_THIS(IDirect3DMaterial2Impl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpMat);
if (TRACE_ON(ddraw)) if (TRACE_ON(ddraw))
dump_material(lpMat); dump_material(lpMat);
/* Copies the material structure */ /* Copies the material structure */
*lpMat = this->mat; *lpMat = This->mat;
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DMaterial2_SetMaterial(LPDIRECT3DMATERIAL2 this, static HRESULT WINAPI IDirect3DMaterial2Impl_SetMaterial(LPDIRECT3DMATERIAL2 iface,
LPD3DMATERIAL lpMat) LPD3DMATERIAL lpMat)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpMat); ICOM_THIS(IDirect3DMaterial2Impl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpMat);
if (TRACE_ON(ddraw)) if (TRACE_ON(ddraw))
dump_material(lpMat); dump_material(lpMat);
/* Stores the material */ /* Stores the material */
this->mat = *lpMat; This->mat = *lpMat;
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DMaterial2_GetHandle(LPDIRECT3DMATERIAL2 this, static HRESULT WINAPI IDirect3DMaterial2Impl_GetHandle(LPDIRECT3DMATERIAL2 iface,
LPDIRECT3DDEVICE2 lpD3DDevice2, LPDIRECT3DDEVICE2 lpD3DDevice2,
LPD3DMATERIALHANDLE lpMatHandle) LPD3DMATERIALHANDLE lpMatHandle)
{ {
FIXME(ddraw, "(%p)->(%p,%p): stub\n", this, lpD3DDevice2, lpMatHandle); ICOM_THIS(IDirect3DMaterial2Impl,iface);
FIXME(ddraw, "(%p)->(%p,%p): stub\n", This, lpD3DDevice2, lpMatHandle);
if (this->use_d3d2) if (This->use_d3d2)
this->device.active_device2 = lpD3DDevice2; This->device.active_device2 = (IDirect3DDevice2Impl*)lpD3DDevice2;
else else
this->device.active_device1 = (LPDIRECT3DDEVICE) lpD3DDevice2; This->device.active_device1 = (IDirect3DDeviceImpl*)lpD3DDevice2;
*lpMatHandle = (DWORD) this; /* lpD3DDevice2->store_material(this); */ *lpMatHandle = (DWORD) This; /* lpD3DDevice2->store_material(This); */
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DMaterial_Reserve(LPDIRECT3DMATERIAL this) static HRESULT WINAPI IDirect3DMaterialImpl_Reserve(LPDIRECT3DMATERIAL iface)
{ {
FIXME(ddraw, "(%p)->(): stub\n", this); ICOM_THIS(IDirect3DMaterial2Impl,iface);
FIXME(ddraw, "(%p)->(): stub\n", This);
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
static HRESULT WINAPI IDirect3DMaterial_Unreserve(LPDIRECT3DMATERIAL this) static HRESULT WINAPI IDirect3DMaterialImpl_Unreserve(LPDIRECT3DMATERIAL iface)
{ {
FIXME(ddraw, "(%p)->(): stub\n", this); ICOM_THIS(IDirect3DMaterial2Impl,iface);
FIXME(ddraw, "(%p)->(): stub\n", This);
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
static HRESULT WINAPI IDirect3DMaterial_Initialize(LPDIRECT3DMATERIAL this, static HRESULT WINAPI IDirect3DMaterialImpl_Initialize(LPDIRECT3DMATERIAL iface,
LPDIRECT3D lpDirect3D) LPDIRECT3D lpDirect3D)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpDirect3D); ICOM_THIS(IDirect3DMaterial2Impl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpDirect3D);
return DDERR_ALREADYINITIALIZED; return DDERR_ALREADYINITIALIZED;
} }
@ -207,43 +216,43 @@ static HRESULT WINAPI IDirect3DMaterial_Initialize(LPDIRECT3DMATERIAL this,
/******************************************************************************* /*******************************************************************************
* IDirect3DMaterial VTable * IDirect3DMaterial VTable
*/ */
static IDirect3DMaterial_VTable material_vtable = { static ICOM_VTABLE(IDirect3DMaterial) material_vtable = {
/*** IUnknown methods ***/ /*** IUnknown methods ***/
IDirect3DMaterial2_QueryInterface, IDirect3DMaterial2Impl_QueryInterface,
IDirect3DMaterial2_AddRef, IDirect3DMaterial2Impl_AddRef,
IDirect3DMaterial2_Release, IDirect3DMaterial2Impl_Release,
/*** IDirect3DMaterial methods ***/ /*** IDirect3DMaterial methods ***/
IDirect3DMaterial_Initialize, IDirect3DMaterialImpl_Initialize,
IDirect3DMaterial2_SetMaterial, IDirect3DMaterial2Impl_SetMaterial,
IDirect3DMaterial2_GetMaterial, IDirect3DMaterial2Impl_GetMaterial,
IDirect3DMaterial2_GetHandle, IDirect3DMaterial2Impl_GetHandle,
IDirect3DMaterial_Reserve, IDirect3DMaterialImpl_Reserve,
IDirect3DMaterial_Unreserve IDirect3DMaterialImpl_Unreserve
}; };
/******************************************************************************* /*******************************************************************************
* IDirect3DMaterial2 VTable * IDirect3DMaterial2 VTable
*/ */
static IDirect3DMaterial2_VTable material2_vtable = { static ICOM_VTABLE(IDirect3DMaterial2) material2_vtable = {
/*** IUnknown methods ***/ /*** IUnknown methods ***/
IDirect3DMaterial2_QueryInterface, IDirect3DMaterial2Impl_QueryInterface,
IDirect3DMaterial2_AddRef, IDirect3DMaterial2Impl_AddRef,
IDirect3DMaterial2_Release, IDirect3DMaterial2Impl_Release,
/*** IDirect3DMaterial methods ***/ /*** IDirect3DMaterial methods ***/
IDirect3DMaterial2_SetMaterial, IDirect3DMaterial2Impl_SetMaterial,
IDirect3DMaterial2_GetMaterial, IDirect3DMaterial2Impl_GetMaterial,
IDirect3DMaterial2_GetHandle IDirect3DMaterial2Impl_GetHandle
}; };
#else /* HAVE_MESAGL */ #else /* HAVE_MESAGL */
LPDIRECT3DMATERIAL d3dmaterial_create(LPDIRECT3D d3d) { LPDIRECT3DMATERIAL d3dmaterial_create(IDirect3DImpl* d3d1) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }
LPDIRECT3DMATERIAL2 d3dmaterial2_create(LPDIRECT3D2 d3d) { LPDIRECT3DMATERIAL2 d3dmaterial2_create(IDirect3D2Impl* d3d2) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }

182
graphics/d3dtexture.c
View File

@ -23,37 +23,37 @@
texture memory) */ texture memory) */
#undef TEXTURE_SNOOP #undef TEXTURE_SNOOP
static IDirect3DTexture2_VTable texture2_vtable; static ICOM_VTABLE(IDirect3DTexture2) texture2_vtable;
static IDirect3DTexture_VTable texture_vtable; static ICOM_VTABLE(IDirect3DTexture) texture_vtable;
/******************************************************************************* /*******************************************************************************
* Texture2 Creation functions * Texture2 Creation functions
*/ */
LPDIRECT3DTEXTURE2 d3dtexture2_create(LPDIRECTDRAWSURFACE4 surf) LPDIRECT3DTEXTURE2 d3dtexture2_create(IDirectDrawSurface4Impl* surf)
{ {
LPDIRECT3DTEXTURE2 mat; IDirect3DTexture2Impl* tex;
mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DTexture2)); tex = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DTexture2Impl));
mat->ref = 1; tex->ref = 1;
mat->lpvtbl = &texture2_vtable; tex->lpvtbl = &texture2_vtable;
mat->surface = surf; tex->surface = surf;
return mat; return (LPDIRECT3DTEXTURE2)tex;
} }
/******************************************************************************* /*******************************************************************************
* Texture Creation functions * Texture Creation functions
*/ */
LPDIRECT3DTEXTURE d3dtexture_create(LPDIRECTDRAWSURFACE4 surf) LPDIRECT3DTEXTURE d3dtexture_create(IDirectDrawSurface4Impl* surf)
{ {
LPDIRECT3DTEXTURE mat; IDirect3DTexture2Impl* tex;
mat = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DTexture)); tex = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DTexture2Impl));
mat->ref = 1; tex->ref = 1;
mat->lpvtbl = (IDirect3DTexture2_VTable*) &texture_vtable; tex->lpvtbl = (ICOM_VTABLE(IDirect3DTexture2)*)&texture_vtable;
mat->surface = surf; tex->surface = surf;
return mat; return (LPDIRECT3DTEXTURE)tex;
} }
@ -61,137 +61,149 @@ LPDIRECT3DTEXTURE d3dtexture_create(LPDIRECTDRAWSURFACE4 surf)
* IDirect3DTexture2 methods * IDirect3DTexture2 methods
*/ */
static HRESULT WINAPI IDirect3DTexture2_QueryInterface(LPDIRECT3DTEXTURE2 this, static HRESULT WINAPI IDirect3DTexture2Impl_QueryInterface(LPDIRECT3DTEXTURE2 iface,
REFIID riid, REFIID riid,
LPVOID* ppvObj) LPVOID* ppvObj)
{ {
ICOM_THIS(IDirect3DTexture2Impl,iface);
char xrefiid[50]; char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)riid,xrefiid); WINE_StringFromCLSID((LPCLSID)riid,xrefiid);
FIXME(ddraw, "(%p)->(%s,%p): stub\n", this, xrefiid,ppvObj); FIXME(ddraw, "(%p)->(%s,%p): stub\n", This, xrefiid,ppvObj);
return S_OK; return S_OK;
} }
static ULONG WINAPI IDirect3DTexture2_AddRef(LPDIRECT3DTEXTURE2 this) static ULONG WINAPI IDirect3DTexture2Impl_AddRef(LPDIRECT3DTEXTURE2 iface)
{ {
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DTexture2Impl,iface);
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", This, This->ref );
return ++(this->ref); return ++(This->ref);
} }
static ULONG WINAPI IDirect3DTexture2_Release(LPDIRECT3DTEXTURE2 this) static ULONG WINAPI IDirect3DTexture2Impl_Release(LPDIRECT3DTEXTURE2 iface)
{ {
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DTexture2Impl,iface);
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
if (!--(this->ref)) { if (!--(This->ref)) {
/* Delete texture from OpenGL */ /* Delete texture from OpenGL */
glDeleteTextures(1, &(this->tex_name)); glDeleteTextures(1, &(This->tex_name));
/* Release surface */ /* Release surface */
this->surface->lpvtbl->fnRelease(this->surface); IDirectDrawSurface4_Release((IDirectDrawSurface4*)This->surface);
HeapFree(GetProcessHeap(),0,this); HeapFree(GetProcessHeap(),0,This);
return 0; return 0;
} }
return this->ref; return This->ref;
} }
/*** IDirect3DTexture methods ***/ /*** IDirect3DTexture methods ***/
static HRESULT WINAPI IDirect3DTexture_GetHandle(LPDIRECT3DTEXTURE this, static HRESULT WINAPI IDirect3DTextureImpl_GetHandle(LPDIRECT3DTEXTURE iface,
LPDIRECT3DDEVICE lpD3DDevice, LPDIRECT3DDEVICE lpD3DDevice,
LPD3DTEXTUREHANDLE lpHandle) LPD3DTEXTUREHANDLE lpHandle)
{ {
FIXME(ddraw, "(%p)->(%p,%p): stub\n", this, lpD3DDevice, lpHandle); ICOM_THIS(IDirect3DTexture2Impl,iface);
IDirect3DDeviceImpl* ilpD3DDevice=(IDirect3DDeviceImpl*)lpD3DDevice;
FIXME(ddraw, "(%p)->(%p,%p): stub\n", This, ilpD3DDevice, lpHandle);
*lpHandle = (DWORD) this; *lpHandle = (D3DTEXTUREHANDLE) This;
/* Now, bind a new texture */ /* Now, bind a new texture */
lpD3DDevice->set_context(lpD3DDevice); ilpD3DDevice->set_context(ilpD3DDevice);
this->D3Ddevice = (void *) lpD3DDevice; This->D3Ddevice = (void *) ilpD3DDevice;
if (this->tex_name == 0) if (This->tex_name == 0)
glGenTextures(1, &(this->tex_name)); glGenTextures(1, &(This->tex_name));
TRACE(ddraw, "OpenGL texture handle is : %d\n", this->tex_name); TRACE(ddraw, "OpenGL texture handle is : %d\n", This->tex_name);
return D3D_OK; return D3D_OK;
} }
static HRESULT WINAPI IDirect3DTexture_Initialize(LPDIRECT3DTEXTURE this, static HRESULT WINAPI IDirect3DTextureImpl_Initialize(LPDIRECT3DTEXTURE iface,
LPDIRECT3DDEVICE lpD3DDevice, LPDIRECT3DDEVICE lpD3DDevice,
LPDIRECTDRAWSURFACE lpSurface) LPDIRECTDRAWSURFACE lpSurface)
{ {
TRACE(ddraw, "(%p)->(%p,%p)\n", this, lpD3DDevice, lpSurface); ICOM_THIS(IDirect3DTexture2Impl,iface);
TRACE(ddraw, "(%p)->(%p,%p)\n", This, lpD3DDevice, lpSurface);
return DDERR_ALREADYINITIALIZED; return DDERR_ALREADYINITIALIZED;
} }
static HRESULT WINAPI IDirect3DTexture_Unload(LPDIRECT3DTEXTURE this) static HRESULT WINAPI IDirect3DTextureImpl_Unload(LPDIRECT3DTEXTURE iface)
{ {
FIXME(ddraw, "(%p)->(): stub\n", this); ICOM_THIS(IDirect3DTexture2Impl,iface);
FIXME(ddraw, "(%p)->(): stub\n", This);
return D3D_OK; return D3D_OK;
} }
/*** IDirect3DTexture2 methods ***/ /*** IDirect3DTexture2 methods ***/
static HRESULT WINAPI IDirect3DTexture2_GetHandle(LPDIRECT3DTEXTURE2 this, static HRESULT WINAPI IDirect3DTexture2Impl_GetHandle(LPDIRECT3DTEXTURE2 iface,
LPDIRECT3DDEVICE2 lpD3DDevice2, LPDIRECT3DDEVICE2 lpD3DDevice2,
LPD3DTEXTUREHANDLE lpHandle) LPD3DTEXTUREHANDLE lpHandle)
{ {
TRACE(ddraw, "(%p)->(%p,%p)\n", this, lpD3DDevice2, lpHandle); ICOM_THIS(IDirect3DTexture2Impl,iface);
IDirect3DDevice2Impl* ilpD3DDevice2=(IDirect3DDevice2Impl*)lpD3DDevice2;
TRACE(ddraw, "(%p)->(%p,%p)\n", This, ilpD3DDevice2, lpHandle);
/* For 32 bits OSes, handles = pointers */ /* For 32 bits OSes, handles = pointers */
*lpHandle = (DWORD) this; *lpHandle = (D3DTEXTUREHANDLE) This;
/* Now, bind a new texture */ /* Now, bind a new texture */
lpD3DDevice2->set_context(lpD3DDevice2); ilpD3DDevice2->set_context(ilpD3DDevice2);
this->D3Ddevice = (void *) lpD3DDevice2; This->D3Ddevice = (void *) ilpD3DDevice2;
if (this->tex_name == 0) if (This->tex_name == 0)
glGenTextures(1, &(this->tex_name)); glGenTextures(1, &(This->tex_name));
TRACE(ddraw, "OpenGL texture handle is : %d\n", this->tex_name); TRACE(ddraw, "OpenGL texture handle is : %d\n", This->tex_name);
return D3D_OK; return D3D_OK;
} }
/* Common methods */ /* Common methods */
static HRESULT WINAPI IDirect3DTexture2_PaletteChanged(LPDIRECT3DTEXTURE2 this, static HRESULT WINAPI IDirect3DTexture2Impl_PaletteChanged(LPDIRECT3DTEXTURE2 iface,
DWORD dwStart, DWORD dwStart,
DWORD dwCount) DWORD dwCount)
{ {
FIXME(ddraw, "(%p)->(%8ld,%8ld): stub\n", this, dwStart, dwCount); ICOM_THIS(IDirect3DTexture2Impl,iface);
FIXME(ddraw, "(%p)->(%8ld,%8ld): stub\n", This, dwStart, dwCount);
return D3D_OK; return D3D_OK;
} }
/* NOTE : if you experience crashes in this function, you must have a buggy /* NOTE : if you experience crashes in this function, you must have a buggy
version of Mesa. See the file d3dtexture.c for a cure */ version of Mesa. See the file d3dtexture.c for a cure */
static HRESULT WINAPI IDirect3DTexture2_Load(LPDIRECT3DTEXTURE2 this, static HRESULT WINAPI IDirect3DTexture2Impl_Load(LPDIRECT3DTEXTURE2 iface,
LPDIRECT3DTEXTURE2 lpD3DTexture2) LPDIRECT3DTEXTURE2 lpD3DTexture2)
{ {
ICOM_THIS(IDirect3DTexture2Impl,iface);
IDirect3DTexture2Impl* ilpD3DTexture2=(IDirect3DTexture2Impl*)lpD3DTexture2;
DDSURFACEDESC *src_d, *dst_d; DDSURFACEDESC *src_d, *dst_d;
TRACE(ddraw, "(%p)->(%p)\n", this, lpD3DTexture2); TRACE(ddraw, "(%p)->(%p)\n", This, ilpD3DTexture2);
TRACE(ddraw, "Copied to surface %p, surface %p\n", this->surface, lpD3DTexture2->surface); TRACE(ddraw, "Copied to surface %p, surface %p\n", This->surface, ilpD3DTexture2->surface);
/* Suppress the ALLOCONLOAD flag */ /* Suppress the ALLOCONLOAD flag */
this->surface->s.surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD; This->surface->s.surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
/* Copy one surface on the other */ /* Copy one surface on the other */
dst_d = &(this->surface->s.surface_desc); dst_d = &(This->surface->s.surface_desc);
src_d = &(lpD3DTexture2->surface->s.surface_desc); src_d = &(ilpD3DTexture2->surface->s.surface_desc);
if ((src_d->dwWidth != dst_d->dwWidth) || (src_d->dwHeight != dst_d->dwHeight)) { if ((src_d->dwWidth != dst_d->dwWidth) || (src_d->dwHeight != dst_d->dwHeight)) {
/* Should also check for same pixel format, lPitch, ... */ /* Should also check for same pixel format, lPitch, ... */
ERR(ddraw, "Error in surface sizes\n"); ERR(ddraw, "Error in surface sizes\n");
return D3DERR_TEXTURE_LOAD_FAILED; return D3DERR_TEXTURE_LOAD_FAILED;
} else { } else {
/* LPDIRECT3DDEVICE2 d3dd = (LPDIRECT3DDEVICE2) this->D3Ddevice; */ /* LPDIRECT3DDEVICE2 d3dd = (LPDIRECT3DDEVICE2) This->D3Ddevice; */
/* I should put a macro for the calculus of bpp */ /* I should put a macro for the calculus of bpp */
int bpp = (src_d->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8 ? int bpp = (src_d->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8 ?
1 /* 8 bit of palette index */: 1 /* 8 bit of palette index */:
@ -206,15 +218,15 @@ static HRESULT WINAPI IDirect3DTexture2_Load(LPDIRECT3DTEXTURE2 this,
glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture); glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
/* If the GetHandle was not done, get the texture name here */ /* If the GetHandle was not done, get the texture name here */
if (this->tex_name == 0) if (This->tex_name == 0)
glGenTextures(1, &(this->tex_name)); glGenTextures(1, &(This->tex_name));
glBindTexture(GL_TEXTURE_2D, this->tex_name); glBindTexture(GL_TEXTURE_2D, This->tex_name);
if (src_d->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) { if (src_d->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
/* **************** /* ****************
Paletted Texture Paletted Texture
**************** */ **************** */
LPDIRECTDRAWPALETTE pal = this->surface->s.palette; IDirectDrawPaletteImpl* pal = This->surface->s.palette;
BYTE table[256][4]; BYTE table[256][4];
int i; int i;
@ -228,9 +240,9 @@ static HRESULT WINAPI IDirect3DTexture2_Load(LPDIRECT3DTEXTURE2 this,
table[i][0] = pal->palents[i].peRed; table[i][0] = pal->palents[i].peRed;
table[i][1] = pal->palents[i].peGreen; table[i][1] = pal->palents[i].peGreen;
table[i][2] = pal->palents[i].peBlue; table[i][2] = pal->palents[i].peBlue;
if ((this->surface->s.surface_desc.dwFlags & DDSD_CKSRCBLT) && if ((This->surface->s.surface_desc.dwFlags & DDSD_CKSRCBLT) &&
(i >= this->surface->s.surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue) && (i >= This->surface->s.surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue) &&
(i <= this->surface->s.surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue)) (i <= This->surface->s.surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue))
table[i][3] = 0x00; table[i][3] = 0x00;
else else
table[i][3] = 0xFF; table[i][3] = 0xFF;
@ -242,7 +254,7 @@ static HRESULT WINAPI IDirect3DTexture2_Load(LPDIRECT3DTEXTURE2 this,
char buf[32]; char buf[32];
int x, y; int x, y;
sprintf(buf, "%d.pnm", this->tex_name); sprintf(buf, "%d.pnm", This->tex_name);
f = fopen(buf, "wb"); f = fopen(buf, "wb");
fprintf(f, "P6\n%d %d\n255\n", src_d->dwWidth, src_d->dwHeight); fprintf(f, "P6\n%d %d\n255\n", src_d->dwWidth, src_d->dwHeight);
for (y = 0; y < src_d->dwHeight; y++) { for (y = 0; y < src_d->dwHeight; y++) {
@ -296,7 +308,7 @@ static HRESULT WINAPI IDirect3DTexture2_Load(LPDIRECT3DTEXTURE2 this,
char buf[32]; char buf[32];
int x, y; int x, y;
sprintf(buf, "%d.pnm", this->tex_name); sprintf(buf, "%d.pnm", This->tex_name);
f = fopen(buf, "wb"); f = fopen(buf, "wb");
fprintf(f, "P6\n%d %d\n255\n", src_d->dwWidth, src_d->dwHeight); fprintf(f, "P6\n%d %d\n255\n", src_d->dwWidth, src_d->dwHeight);
for (y = 0; y < src_d->dwHeight; y++) { for (y = 0; y < src_d->dwHeight; y++) {
@ -325,7 +337,7 @@ static HRESULT WINAPI IDirect3DTexture2_Load(LPDIRECT3DTEXTURE2 this,
char buf[32]; char buf[32];
int x, y; int x, y;
sprintf(buf, "%d.pnm", this->tex_name); sprintf(buf, "%d.pnm", This->tex_name);
f = fopen(buf, "wb"); f = fopen(buf, "wb");
fprintf(f, "P6\n%d %d\n255\n", src_d->dwWidth, src_d->dwHeight); fprintf(f, "P6\n%d %d\n255\n", src_d->dwWidth, src_d->dwHeight);
for (y = 0; y < src_d->dwHeight; y++) { for (y = 0; y < src_d->dwHeight; y++) {
@ -395,42 +407,42 @@ static HRESULT WINAPI IDirect3DTexture2_Load(LPDIRECT3DTEXTURE2 this,
/******************************************************************************* /*******************************************************************************
* IDirect3DTexture2 VTable * IDirect3DTexture2 VTable
*/ */
static IDirect3DTexture2_VTable texture2_vtable = { static ICOM_VTABLE(IDirect3DTexture2) texture2_vtable = {
/*** IUnknown methods ***/ /*** IUnknown methods ***/
IDirect3DTexture2_QueryInterface, IDirect3DTexture2Impl_QueryInterface,
IDirect3DTexture2_AddRef, IDirect3DTexture2Impl_AddRef,
IDirect3DTexture2_Release, IDirect3DTexture2Impl_Release,
/*** IDirect3DTexture methods ***/ /*** IDirect3DTexture methods ***/
IDirect3DTexture2_GetHandle, IDirect3DTexture2Impl_GetHandle,
IDirect3DTexture2_PaletteChanged, IDirect3DTexture2Impl_PaletteChanged,
IDirect3DTexture2_Load IDirect3DTexture2Impl_Load
}; };
/******************************************************************************* /*******************************************************************************
* IDirect3DTexture VTable * IDirect3DTexture VTable
*/ */
static IDirect3DTexture_VTable texture_vtable = { static ICOM_VTABLE(IDirect3DTexture) texture_vtable = {
/*** IUnknown methods ***/ /*** IUnknown methods ***/
IDirect3DTexture2_QueryInterface, IDirect3DTexture2Impl_QueryInterface,
IDirect3DTexture2_AddRef, IDirect3DTexture2Impl_AddRef,
IDirect3DTexture2_Release, IDirect3DTexture2Impl_Release,
/*** IDirect3DTexture methods ***/ /*** IDirect3DTexture methods ***/
IDirect3DTexture_Initialize, IDirect3DTextureImpl_Initialize,
IDirect3DTexture_GetHandle, IDirect3DTextureImpl_GetHandle,
IDirect3DTexture2_PaletteChanged, IDirect3DTexture2Impl_PaletteChanged,
IDirect3DTexture2_Load, IDirect3DTexture2Impl_Load,
IDirect3DTexture_Unload IDirect3DTextureImpl_Unload
}; };
#else /* HAVE_MESAGL */ #else /* HAVE_MESAGL */
/* These function should never be called if MesaGL is not present */ /* These function should never be called if MesaGL is not present */
LPDIRECT3DTEXTURE2 d3dtexture2_create(LPDIRECTDRAWSURFACE4 surf) { LPDIRECT3DTEXTURE2 d3dtexture2_create(IDirectDrawSurface4Impl* surf) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }
LPDIRECT3DTEXTURE d3dtexture_create(LPDIRECTDRAWSURFACE4 surf) { LPDIRECT3DTEXTURE d3dtexture_create(IDirectDrawSurface4Impl* surf) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }

207
graphics/d3dviewport.c
View File

@ -17,16 +17,16 @@
#ifdef HAVE_MESAGL #ifdef HAVE_MESAGL
static IDirect3DViewport2_VTable viewport2_vtable; static ICOM_VTABLE(IDirect3DViewport2) viewport2_vtable;
/******************************************************************************* /*******************************************************************************
* Viewport1/2 static functions * Viewport1/2 static functions
*/ */
static void activate(LPDIRECT3DVIEWPORT2 this) { static void activate(IDirect3DViewport2Impl* This) {
LPDIRECT3DLIGHT l; IDirect3DLightImpl* l;
/* Activate all the lights associated with this context */ /* Activate all the lights associated with this context */
l = this->lights; l = This->lights;
while (l != NULL) { while (l != NULL) {
l->activate(l); l->activate(l);
@ -37,14 +37,14 @@ static void activate(LPDIRECT3DVIEWPORT2 this) {
/******************************************************************************* /*******************************************************************************
* Viewport1/2 Creation functions * Viewport1/2 Creation functions
*/ */
LPDIRECT3DVIEWPORT2 d3dviewport2_create(LPDIRECT3D2 d3d) LPDIRECT3DVIEWPORT2 d3dviewport2_create(IDirect3D2Impl* d3d2)
{ {
LPDIRECT3DVIEWPORT2 vp; IDirect3DViewport2Impl* vp;
vp = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DViewport2)); vp = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DViewport2Impl));
vp->ref = 1; vp->ref = 1;
vp->lpvtbl = &viewport2_vtable; vp->lpvtbl = &viewport2_vtable;
vp->d3d.d3d2 = d3d; vp->d3d.d3d2 = d3d2;
vp->use_d3d2 = 1; vp->use_d3d2 = 1;
vp->device.active_device2 = NULL; vp->device.active_device2 = NULL;
@ -54,17 +54,17 @@ LPDIRECT3DVIEWPORT2 d3dviewport2_create(LPDIRECT3D2 d3d)
vp->nextlight = GL_LIGHT0; vp->nextlight = GL_LIGHT0;
return vp; return (LPDIRECT3DVIEWPORT2)vp;
} }
LPDIRECT3DVIEWPORT d3dviewport_create(LPDIRECT3D d3d) LPDIRECT3DVIEWPORT d3dviewport_create(IDirect3DImpl* d3d1)
{ {
LPDIRECT3DVIEWPORT2 vp; IDirect3DViewport2Impl* vp;
vp = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DViewport2)); vp = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DViewport2Impl));
vp->ref = 1; vp->ref = 1;
vp->lpvtbl = &viewport2_vtable; vp->lpvtbl = &viewport2_vtable;
vp->d3d.d3d1 = d3d; vp->d3d.d3d1 = d3d1;
vp->use_d3d2 = 0; vp->use_d3d2 = 0;
vp->device.active_device1 = NULL; vp->device.active_device1 = NULL;
@ -81,70 +81,76 @@ LPDIRECT3DVIEWPORT d3dviewport_create(LPDIRECT3D d3d)
* IDirect3DViewport2 methods * IDirect3DViewport2 methods
*/ */
static HRESULT WINAPI IDirect3DViewport2_QueryInterface(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_QueryInterface(LPDIRECT3DVIEWPORT2 iface,
REFIID riid, REFIID riid,
LPVOID* ppvObj) LPVOID* ppvObj)
{ {
ICOM_THIS(IDirect3DViewport2Impl,iface);
char xrefiid[50]; char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)riid,xrefiid); WINE_StringFromCLSID((LPCLSID)riid,xrefiid);
FIXME(ddraw, "(%p)->(%s,%p): stub\n", this, xrefiid,ppvObj); FIXME(ddraw, "(%p)->(%s,%p): stub\n", This, xrefiid,ppvObj);
return S_OK; return S_OK;
} }
static ULONG WINAPI IDirect3DViewport2_AddRef(LPDIRECT3DVIEWPORT2 this) static ULONG WINAPI IDirect3DViewport2Impl_AddRef(LPDIRECT3DVIEWPORT2 iface)
{ {
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DViewport2Impl,iface);
TRACE(ddraw, "(%p)->()incrementing from %lu.\n", This, This->ref );
return ++(this->ref); return ++(This->ref);
} }
static ULONG WINAPI IDirect3DViewport2_Release(LPDIRECT3DVIEWPORT2 this) static ULONG WINAPI IDirect3DViewport2Impl_Release(LPDIRECT3DVIEWPORT2 iface)
{ {
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref ); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
if (!--(this->ref)) { if (!--(This->ref)) {
HeapFree(GetProcessHeap(),0,this); HeapFree(GetProcessHeap(),0,This);
return 0; return 0;
} }
return this->ref; return This->ref;
} }
/*** IDirect3DViewport methods ***/ /*** IDirect3DViewport methods ***/
static HRESULT WINAPI IDirect3DViewport2_Initialize(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_Initialize(LPDIRECT3DVIEWPORT2 iface,
LPDIRECT3D d3d) LPDIRECT3D d3d)
{ {
FIXME(ddraw, "(%p)->(%p): stub\n", this, d3d); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p): stub\n", This, d3d);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_GetViewport(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_GetViewport(LPDIRECT3DVIEWPORT2 iface,
LPD3DVIEWPORT lpvp) LPD3DVIEWPORT lpvp)
{ {
FIXME(ddraw, "(%p)->(%p): stub\n", this, lpvp); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p): stub\n", This, lpvp);
if (this->use_vp2 != 0) if (This->use_vp2 != 0)
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
*lpvp = this->viewport.vp1; *lpvp = This->viewport.vp1;
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_SetViewport(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_SetViewport(LPDIRECT3DVIEWPORT2 iface,
LPD3DVIEWPORT lpvp) LPD3DVIEWPORT lpvp)
{ {
FIXME(ddraw, "(%p)->(%p): stub\n", this, lpvp); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p): stub\n", This, lpvp);
this->use_vp2 = 0; This->use_vp2 = 0;
this->viewport.vp1 = *lpvp; This->viewport.vp1 = *lpvp;
TRACE(ddraw, "dwSize = %ld dwX = %ld dwY = %ld\n", TRACE(ddraw, "dwSize = %ld dwX = %ld dwY = %ld\n",
lpvp->dwSize, lpvp->dwX, lpvp->dwY); lpvp->dwSize, lpvp->dwX, lpvp->dwY);
@ -161,76 +167,83 @@ static HRESULT WINAPI IDirect3DViewport2_SetViewport(LPDIRECT3DVIEWPORT2 this,
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_TransformVertices(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_TransformVertices(LPDIRECT3DVIEWPORT2 iface,
DWORD dwVertexCount, DWORD dwVertexCount,
LPD3DTRANSFORMDATA lpData, LPD3DTRANSFORMDATA lpData,
DWORD dwFlags, DWORD dwFlags,
LPDWORD lpOffScreen) LPDWORD lpOffScreen)
{ {
ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%8ld,%p,%08lx,%p): stub\n", FIXME(ddraw, "(%p)->(%8ld,%p,%08lx,%p): stub\n",
this, dwVertexCount, lpData, dwFlags, lpOffScreen); This, dwVertexCount, lpData, dwFlags, lpOffScreen);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_LightElements(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_LightElements(LPDIRECT3DVIEWPORT2 iface,
DWORD dwElementCount, DWORD dwElementCount,
LPD3DLIGHTDATA lpData) LPD3DLIGHTDATA lpData)
{ {
FIXME(ddraw, "(%p)->(%8ld,%p): stub\n", this, dwElementCount, lpData); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%8ld,%p): stub\n", This, dwElementCount, lpData);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_SetBackground(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_SetBackground(LPDIRECT3DVIEWPORT2 iface,
D3DMATERIALHANDLE hMat) D3DMATERIALHANDLE hMat)
{ {
FIXME(ddraw, "(%p)->(%08lx): stub\n", this, (DWORD) hMat); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%08lx): stub\n", This, (DWORD) hMat);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_GetBackground(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_GetBackground(LPDIRECT3DVIEWPORT2 iface,
LPD3DMATERIALHANDLE lphMat, LPD3DMATERIALHANDLE lphMat,
LPBOOL lpValid) LPBOOL lpValid)
{ {
FIXME(ddraw, "(%p)->(%p,%p): stub\n", this, lphMat, lpValid); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p,%p): stub\n", This, lphMat, lpValid);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_SetBackgroundDepth(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_SetBackgroundDepth(LPDIRECT3DVIEWPORT2 iface,
LPDIRECTDRAWSURFACE lpDDSurface) LPDIRECTDRAWSURFACE lpDDSurface)
{ {
FIXME(ddraw, "(%p)->(%p): stub\n", this, lpDDSurface); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p): stub\n", This, lpDDSurface);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_GetBackgroundDepth(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_GetBackgroundDepth(LPDIRECT3DVIEWPORT2 iface,
LPDIRECTDRAWSURFACE* lplpDDSurface, LPDIRECTDRAWSURFACE* lplpDDSurface,
LPBOOL lpValid) LPBOOL lpValid)
{ {
FIXME(ddraw, "(%p)->(%p,%p): stub\n", this, lplpDDSurface, lpValid); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p,%p): stub\n", This, lplpDDSurface, lpValid);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_Clear(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_Clear(LPDIRECT3DVIEWPORT2 iface,
DWORD dwCount, DWORD dwCount,
LPD3DRECT lpRects, LPD3DRECT lpRects,
DWORD dwFlags) DWORD dwFlags)
{ {
ICOM_THIS(IDirect3DViewport2Impl,iface);
GLboolean ztest; GLboolean ztest;
FIXME(ddraw, "(%p)->(%8ld,%p,%08lx): stub\n", this, dwCount, lpRects, dwFlags); FIXME(ddraw, "(%p)->(%8ld,%p,%08lx): stub\n", This, dwCount, lpRects, dwFlags);
/* For the moment, ignore the rectangles */ /* For the moment, ignore the rectangles */
if (this->device.active_device1 != NULL) { if (This->device.active_device1 != NULL) {
/* Get the rendering context */ /* Get the rendering context */
if (this->use_d3d2) if (This->use_d3d2)
this->device.active_device2->set_context(this->device.active_device2); This->device.active_device2->set_context(This->device.active_device2);
else else
this->device.active_device1->set_context(this->device.active_device1); This->device.active_device1->set_context(This->device.active_device1);
} }
/* Clears the screen */ /* Clears the screen */
@ -242,67 +255,73 @@ static HRESULT WINAPI IDirect3DViewport2_Clear(LPDIRECT3DVIEWPORT2 this,
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_AddLight(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_AddLight(LPDIRECT3DVIEWPORT2 iface,
LPDIRECT3DLIGHT lpLight) LPDIRECT3DLIGHT lpLight)
{ {
FIXME(ddraw, "(%p)->(%p): stub\n", this, lpLight); ICOM_THIS(IDirect3DViewport2Impl,iface);
IDirect3DLightImpl* ilpLight=(IDirect3DLightImpl*)lpLight;
FIXME(ddraw, "(%p)->(%p): stub\n", This, ilpLight);
/* Add the light in the 'linked' chain */ /* Add the light in the 'linked' chain */
lpLight->next = this->lights; ilpLight->next = This->lights;
this->lights = lpLight; This->lights = ilpLight;
/* If active, activate the light */ /* If active, activate the light */
if (this->device.active_device1 != NULL) { if (This->device.active_device1 != NULL) {
/* Get the rendering context */ /* Get the rendering context */
if (this->use_d3d2) if (This->use_d3d2)
this->device.active_device2->set_context(this->device.active_device2); This->device.active_device2->set_context(This->device.active_device2);
else else
this->device.active_device1->set_context(this->device.active_device1); This->device.active_device1->set_context(This->device.active_device1);
/* Activate the light */ /* Activate the light */
lpLight->light_num = this->nextlight++; ilpLight->light_num = This->nextlight++;
lpLight->activate(lpLight); ilpLight->activate(ilpLight);
} }
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_DeleteLight(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_DeleteLight(LPDIRECT3DVIEWPORT2 iface,
LPDIRECT3DLIGHT lpLight) LPDIRECT3DLIGHT lpLight)
{ {
FIXME(ddraw, "(%p)->(%p): stub\n", this, lpLight); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p): stub\n", This, lpLight);
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_NextLight(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_NextLight(LPDIRECT3DVIEWPORT2 iface,
LPDIRECT3DLIGHT lpLight, LPDIRECT3DLIGHT lpLight,
LPDIRECT3DLIGHT* lplpLight, LPDIRECT3DLIGHT* lplpLight,
DWORD dwFlags) DWORD dwFlags)
{ {
FIXME(ddraw, "(%p)->(%p,%p,%08lx): stub\n", this, lpLight, lplpLight, dwFlags); ICOM_THIS(IDirect3DViewport2Impl,iface);
FIXME(ddraw, "(%p)->(%p,%p,%08lx): stub\n", This, lpLight, lplpLight, dwFlags);
return DD_OK; return DD_OK;
} }
/*** IDirect3DViewport2 methods ***/ /*** IDirect3DViewport2 methods ***/
static HRESULT WINAPI IDirect3DViewport2_GetViewport2(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_GetViewport2(LPDIRECT3DVIEWPORT2 iface,
LPD3DVIEWPORT2 lpViewport2) LPD3DVIEWPORT2 lpViewport2)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpViewport2); ICOM_THIS(IDirect3DViewport2Impl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpViewport2);
if (this->use_vp2 != 1) if (This->use_vp2 != 1)
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
*lpViewport2 = this->viewport.vp2; *lpViewport2 = This->viewport.vp2;
return DD_OK; return DD_OK;
} }
static HRESULT WINAPI IDirect3DViewport2_SetViewport2(LPDIRECT3DVIEWPORT2 this, static HRESULT WINAPI IDirect3DViewport2Impl_SetViewport2(LPDIRECT3DVIEWPORT2 iface,
LPD3DVIEWPORT2 lpViewport2) LPD3DVIEWPORT2 lpViewport2)
{ {
TRACE(ddraw, "(%p)->(%p)\n", this, lpViewport2); ICOM_THIS(IDirect3DViewport2Impl,iface);
TRACE(ddraw, "(%p)->(%p)\n", This, lpViewport2);
TRACE(ddraw, "dwSize = %ld dwX = %ld dwY = %ld\n", TRACE(ddraw, "dwSize = %ld dwX = %ld dwY = %ld\n",
lpViewport2->dwSize, lpViewport2->dwX, lpViewport2->dwY); lpViewport2->dwSize, lpViewport2->dwX, lpViewport2->dwY);
@ -315,8 +334,8 @@ static HRESULT WINAPI IDirect3DViewport2_SetViewport2(LPDIRECT3DVIEWPORT2 this,
TRACE(ddraw, "dvMinZ = %f dvMaxZ = %f\n", TRACE(ddraw, "dvMinZ = %f dvMaxZ = %f\n",
lpViewport2->dvMinZ, lpViewport2->dvMaxZ); lpViewport2->dvMinZ, lpViewport2->dvMaxZ);
this->viewport.vp2 = *lpViewport2; This->viewport.vp2 = *lpViewport2;
this->use_vp2 = 1; This->use_vp2 = 1;
return DD_OK; return DD_OK;
} }
@ -325,38 +344,38 @@ static HRESULT WINAPI IDirect3DViewport2_SetViewport2(LPDIRECT3DVIEWPORT2 this,
/******************************************************************************* /*******************************************************************************
* IDirect3DViewport1/2 VTable * IDirect3DViewport1/2 VTable
*/ */
static IDirect3DViewport2_VTable viewport2_vtable = { static ICOM_VTABLE(IDirect3DViewport2) viewport2_vtable = {
/*** IUnknown methods ***/ /*** IUnknown methods ***/
IDirect3DViewport2_QueryInterface, IDirect3DViewport2Impl_QueryInterface,
IDirect3DViewport2_AddRef, IDirect3DViewport2Impl_AddRef,
IDirect3DViewport2_Release, IDirect3DViewport2Impl_Release,
/*** IDirect3DViewport methods ***/ /*** IDirect3DViewport methods ***/
IDirect3DViewport2_Initialize, IDirect3DViewport2Impl_Initialize,
IDirect3DViewport2_GetViewport, IDirect3DViewport2Impl_GetViewport,
IDirect3DViewport2_SetViewport, IDirect3DViewport2Impl_SetViewport,
IDirect3DViewport2_TransformVertices, IDirect3DViewport2Impl_TransformVertices,
IDirect3DViewport2_LightElements, IDirect3DViewport2Impl_LightElements,
IDirect3DViewport2_SetBackground, IDirect3DViewport2Impl_SetBackground,
IDirect3DViewport2_GetBackground, IDirect3DViewport2Impl_GetBackground,
IDirect3DViewport2_SetBackgroundDepth, IDirect3DViewport2Impl_SetBackgroundDepth,
IDirect3DViewport2_GetBackgroundDepth, IDirect3DViewport2Impl_GetBackgroundDepth,
IDirect3DViewport2_Clear, IDirect3DViewport2Impl_Clear,
IDirect3DViewport2_AddLight, IDirect3DViewport2Impl_AddLight,
IDirect3DViewport2_DeleteLight, IDirect3DViewport2Impl_DeleteLight,
IDirect3DViewport2_NextLight, IDirect3DViewport2Impl_NextLight,
/*** IDirect3DViewport2 methods ***/ /*** IDirect3DViewport2 methods ***/
IDirect3DViewport2_GetViewport2, IDirect3DViewport2Impl_GetViewport2,
IDirect3DViewport2_SetViewport2 IDirect3DViewport2Impl_SetViewport2
}; };
#else /* HAVE_MESAGL */ #else /* HAVE_MESAGL */
LPDIRECT3DVIEWPORT d3dviewport_create(LPDIRECT3D d3d) { LPDIRECT3DVIEWPORT d3dviewport_create(IDirect3DImpl* d3d1) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }
LPDIRECT3DVIEWPORT2 d3dviewport2_create(LPDIRECT3D2 d3d) { LPDIRECT3DVIEWPORT2 d3dviewport2_create(IDirect3D2Impl* d3d2) {
ERR(ddraw, "Should not be called...\n"); ERR(ddraw, "Should not be called...\n");
return NULL; return NULL;
} }

2397
graphics/ddraw.c
View File

File diff suppressed because it is too large Load Diff