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

158
graphics/d3dlight.c
View File

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

159
graphics/d3dmaterial.c
View File

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

182
graphics/d3dtexture.c
View File

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

207
graphics/d3dviewport.c
View File

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

2397
graphics/ddraw.c
View File

File diff suppressed because it is too large Load Diff