From 1213c17489aa3bb8222c7b0b35a3af8989dc3741 Mon Sep 17 00:00:00 2001 From: Lionel Ulmer Date: Tue, 7 Jan 2003 23:08:31 +0000 Subject: [PATCH] - rewrote a little bit the state magagement to remove the RenderState stucture and use only the state_block code - factorize some code between interface revisions - fix some smalls bugs --- dlls/ddraw/d3d_private.h | 13 +- dlls/ddraw/d3ddevice/main.c | 45 +++---- dlls/ddraw/d3ddevice/mesa.c | 233 ++++++++++++++++++++---------------- dlls/ddraw/d3dexecutebuffer.c | 7 +- dlls/ddraw/d3dtexture.c | 2 +- dlls/ddraw/mesa.c | 272 +++++++++++++++++------------------------- dlls/ddraw/mesa_private.h | 46 ++----- 7 files changed, 272 insertions(+), 346 deletions(-) diff --git a/dlls/ddraw/d3d_private.h b/dlls/ddraw/d3d_private.h index 73f82cada76..3ff4fcdf422 100644 --- a/dlls/ddraw/d3d_private.h +++ b/dlls/ddraw/d3d_private.h @@ -26,9 +26,11 @@ #include "d3d.h" +#define MAX_TEXTURES 8 +#define MAX_LIGHTS 16 + #define HIGHEST_RENDER_STATE 152 #define HIGHEST_TEXTURE_STAGE_STATE 24 -#define HIGHEST_LIGHT_STATE 8 /***************************************************************************** * Predeclare the interface implementation structures @@ -45,15 +47,13 @@ typedef struct IDirect3DVertexBufferImpl IDirect3DVertexBufferImpl; typedef struct STATEBLOCKFLAGS { BOOL render_state[HIGHEST_RENDER_STATE]; - BOOL texture_stage_state[8][HIGHEST_TEXTURE_STAGE_STATE]; - BOOL light_state[HIGHEST_LIGHT_STATE]; + BOOL texture_stage_state[MAX_TEXTURES][HIGHEST_TEXTURE_STAGE_STATE]; } STATEBLOCKFLAGS; typedef struct STATEBLOCK { STATEBLOCKFLAGS set_flags; DWORD render_state[HIGHEST_RENDER_STATE]; - DWORD texture_stage_state[8][HIGHEST_TEXTURE_STAGE_STATE]; - DWORD light_state[HIGHEST_LIGHT_STATE]; + DWORD texture_stage_state[MAX_TEXTURES][HIGHEST_TEXTURE_STAGE_STATE]; } STATEBLOCK; /***************************************************************************** @@ -188,9 +188,6 @@ typedef struct d3d7clippingplane * IDirect3DDevice implementation structure */ -#define MAX_TEXTURES 8 -#define MAX_LIGHTS 16 - #define WORLDMAT_CHANGED (0x00000001 << 0) #define VIEWMAT_CHANGED (0x00000001 << 1) #define PROJMAT_CHANGED (0x00000001 << 2) diff --git a/dlls/ddraw/d3ddevice/main.c b/dlls/ddraw/d3ddevice/main.c index 05452bbbbe0..990dfb76046 100644 --- a/dlls/ddraw/d3ddevice/main.c +++ b/dlls/ddraw/d3ddevice/main.c @@ -104,7 +104,7 @@ DWORD InitRenderStateTab[] = { D3DRENDERSTATE_WRAP6, 0, D3DRENDERSTATE_WRAP7, 0, D3DRENDERSTATE_CLIPPING, FALSE, - D3DRENDERSTATE_LIGHTING, FALSE, /* FIXME: Should be TRUE */ + D3DRENDERSTATE_LIGHTING, TRUE, D3DRENDERSTATE_EXTENTS, FALSE, D3DRENDERSTATE_AMBIENT, D3DRGBA(0,0,0,0), D3DRENDERSTATE_FOGVERTEXMODE, D3DFOG_NONE, @@ -160,42 +160,35 @@ void InitDefaultStateBlock(STATEBLOCK* lpStateBlock, int version) { int i,j; TRACE("(%p,%d)\n", lpStateBlock, version); - memset(lpStateBlock,0,sizeof(STATEBLOCK)); + memset(lpStateBlock, 0, sizeof(STATEBLOCK)); /* Initialize render states */ - for(i=0;irender_state[InitRenderStateTab[i]-1] = InitRenderStateTab[i+1]; - lpStateBlock->set_flags.render_state[InitRenderStateTab[i]-1] = TRUE; - } - - /* Initialize render states */ - for(i=0;ilight_state[InitLightStateTab[i]-1] = InitLightStateTab[i+1]; - lpStateBlock->set_flags.light_state[InitLightStateTab[i]-1] = TRUE; + lpStateBlock->render_state[InitRenderStateTab[i] - 1] = InitRenderStateTab[i + 1]; + lpStateBlock->set_flags.render_state[InitRenderStateTab[i] - 1] = TRUE; } /* Initialize texture stages states */ - for(i=0;i<8;i++) + for(i = 0; i < MAX_TEXTURES; i++) { - for(j=0;jtexture_stage_state[i][InitTextureStageStateTab[j]-1] = InitTextureStageStateTab[j+1]; - lpStateBlock->set_flags.texture_stage_state[i][InitTextureStageStateTab[j]-1] = TRUE; + lpStateBlock->texture_stage_state[i][InitTextureStageStateTab[j] - 1] = InitTextureStageStateTab[j + 1]; + lpStateBlock->set_flags.texture_stage_state[i][InitTextureStageStateTab[j] - 1] = TRUE; } /* Map texture coords 0 to stage 0, 1 to stage 1, etc... */ - lpStateBlock->texture_stage_state[i][D3DTSS_TEXCOORDINDEX-1] = i; - lpStateBlock->set_flags.texture_stage_state[i][D3DTSS_TEXCOORDINDEX-1] = TRUE; + lpStateBlock->texture_stage_state[i][D3DTSS_TEXCOORDINDEX - 1] = i; + lpStateBlock->set_flags.texture_stage_state[i][D3DTSS_TEXCOORDINDEX - 1] = TRUE; } /* The first texture is particular, update it consequently */ - lpStateBlock->texture_stage_state[0][D3DTSS_COLOROP-1] = D3DTOP_MODULATE; - lpStateBlock->texture_stage_state[0][D3DTSS_ALPHAOP-1] = D3DTOP_SELECTARG1; + lpStateBlock->texture_stage_state[0][D3DTSS_COLOROP - 1] = D3DTOP_MODULATE; + lpStateBlock->texture_stage_state[0][D3DTSS_ALPHAOP - 1] = D3DTOP_SELECTARG1; /* Updates for particular versions */ - if ((version == 1)||(version==2)) - lpStateBlock->render_state[D3DRENDERSTATE_SPECULARENABLE-1] = TRUE; + if ((version == 1) || (version==2)) + lpStateBlock->render_state[D3DRENDERSTATE_SPECULARENABLE - 1] = TRUE; } HRESULT WINAPI @@ -1112,12 +1105,8 @@ Main_IDirect3DDeviceImpl_3_2T_GetLightState(LPDIRECT3DDEVICE3 iface, LPDWORD lpdwLightState) { ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface); - TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dwLightStateType, lpdwLightState); - if (lpdwLightState && dwLightStateType && (dwLightStateType <= HIGHEST_LIGHT_STATE) ) { - *lpdwLightState = This->state_block.light_state[dwLightStateType-1]; - return DD_OK; - } - return DDERR_INVALIDPARAMS; + FIXME("(%p/%p)->(%08x,%p): stub !\n", This, iface, dwLightStateType, lpdwLightState); + return DD_OK; } HRESULT WINAPI diff --git a/dlls/ddraw/d3ddevice/mesa.c b/dlls/ddraw/d3ddevice/mesa.c index c5966854884..0f359205764 100644 --- a/dlls/ddraw/d3ddevice/mesa.c +++ b/dlls/ddraw/d3ddevice/mesa.c @@ -541,12 +541,11 @@ GL_IDirect3DDeviceImpl_7_3T_2T_SetRenderState(LPDIRECT3DDEVICE7 iface, DWORD dwRenderState) { ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface); - IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This; TRACE("(%p/%p)->(%08x,%08lx)\n", This, iface, dwRenderStateType, dwRenderState); /* Call the render state functions */ - set_render_state(glThis, dwRenderStateType, dwRenderState); - store_render_state(dwRenderStateType, dwRenderState, &glThis->parent.state_block); + store_render_state(This, dwRenderStateType, dwRenderState, &This->state_block); + set_render_state(This, dwRenderStateType, &This->state_block); return DD_OK; } @@ -557,11 +556,12 @@ GL_IDirect3DDeviceImpl_7_3T_2T_GetRenderState(LPDIRECT3DDEVICE7 iface, LPDWORD lpdwRenderState) { ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface); - IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This; TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dwRenderStateType, lpdwRenderState); /* Call the render state functions */ - get_render_state(dwRenderStateType, lpdwRenderState, &glThis->parent.state_block); + get_render_state(This, dwRenderStateType, lpdwRenderState, &This->state_block); + + TRACE(" - asked for rendering state : %s, returning value %08lx.\n", _get_renderstate(dwRenderStateType), *lpdwRenderState); return DD_OK; } @@ -572,7 +572,6 @@ GL_IDirect3DDeviceImpl_3_2T_SetLightState(LPDIRECT3DDEVICE3 iface, DWORD dwLightState) { ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface); - IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This; TRACE("(%p/%p)->(%08x,%08lx)\n", This, iface, dwLightStateType, dwLightState); @@ -590,8 +589,9 @@ GL_IDirect3DDeviceImpl_3_2T_SetLightState(LPDIRECT3DDEVICE3 iface, } break; case D3DLIGHTSTATE_AMBIENT: /* 2 */ - /* Call the render_state function... */ - set_render_state(glThis, D3DRENDERSTATE_AMBIENT, dwLightState); + IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7), + D3DRENDERSTATE_AMBIENT, + dwLightState); break; #define UNSUP(x) case D3DLIGHTSTATE_##x: FIXME("unsupported D3DLIGHTSTATE_" #x "!\n");break; @@ -607,8 +607,6 @@ GL_IDirect3DDeviceImpl_3_2T_SetLightState(LPDIRECT3DDEVICE3 iface, TRACE("Unexpected Light State Type\n"); return DDERR_INVALIDPARAMS; } - - This->state_block.light_state[dwLightStateType] = dwLightState; return DD_OK; } @@ -667,7 +665,7 @@ static void draw_primitive_handle_GL_state(IDirect3DDeviceImpl *This, This->world_mat, This->view_mat, This->proj_mat); glThis->transform_state = GL_TRANSFORM_NORMAL; - if (glThis->render_state.fog_on == TRUE) + if (This->state_block.render_state[D3DRENDERSTATE_FOGENABLE - 1] == TRUE) glEnable(GL_FOG); } else if ((vertex_transformed == TRUE) && (glThis->transform_state != GL_TRANSFORM_ORTHO)) { @@ -680,18 +678,18 @@ static void draw_primitive_handle_GL_state(IDirect3DDeviceImpl *This, } /* Handle the 'no-normal' case */ - if (vertex_lit == FALSE) + if (vertex_lit == TRUE) glDisable(GL_LIGHTING); - else if (glThis->render_state.lighting_enable == TRUE) + else if (This->state_block.render_state[D3DRENDERSTATE_LIGHTING - 1] == TRUE) glEnable(GL_LIGHTING); /* Handle the code for pre-vertex material properties */ if (vertex_transformed == FALSE) { - if (glThis->render_state.lighting_enable == TRUE) { - if ((glThis->render_state.color_diffuse != D3DMCS_MATERIAL) || - (glThis->render_state.color_specular != D3DMCS_MATERIAL) || - (glThis->render_state.color_ambient != D3DMCS_MATERIAL) || - (glThis->render_state.color_emissive != D3DMCS_MATERIAL)) { + if (This->state_block.render_state[D3DRENDERSTATE_LIGHTING - 1] == TRUE) { + if ((This->state_block.render_state[D3DRENDERSTATE_DIFFUSEMATERIALSOURCE - 1] != D3DMCS_MATERIAL) || + (This->state_block.render_state[D3DRENDERSTATE_AMBIENTMATERIALSOURCE - 1] != D3DMCS_MATERIAL) || + (This->state_block.render_state[D3DRENDERSTATE_EMISSIVEMATERIALSOURCE - 1] != D3DMCS_MATERIAL) || + (This->state_block.render_state[D3DRENDERSTATE_SPECULARMATERIALSOURCE - 1] != D3DMCS_MATERIAL)) { glEnable(GL_COLOR_MATERIAL); } } @@ -826,8 +824,9 @@ inline static void handle_normal(D3DVALUE *coords) { glNormal3fv(coords); } -inline static void handle_diffuse_base(RenderState *rs, DWORD *color) { - if (rs->alpha_blend_enable == TRUE) { +inline static void handle_diffuse_base(STATEBLOCK *sb, DWORD *color) { + if ((sb->render_state[D3DRENDERSTATE_ALPHATESTENABLE - 1] == TRUE) || + (sb->render_state[D3DRENDERSTATE_ALPHABLENDENABLE - 1] == TRUE)) { glColor4ub((*color >> 16) & 0xFF, (*color >> 8) & 0xFF, (*color >> 0) & 0xFF, @@ -839,74 +838,78 @@ inline static void handle_diffuse_base(RenderState *rs, DWORD *color) { } } -inline static void handle_specular_base(RenderState *rs, DWORD *color) { +inline static void handle_specular_base(STATEBLOCK *sb, DWORD *color) { glColor4ub((*color >> 16) & 0xFF, (*color >> 8) & 0xFF, (*color >> 0) & 0xFF, (*color >> 24) & 0xFF); /* No idea if the alpha field is really used.. */ } -inline static void handle_diffuse(RenderState *rs, DWORD *color) { - if (rs->lighting_enable == TRUE) { - if (rs->color_diffuse == D3DMCS_COLOR1) { +inline static void handle_diffuse(STATEBLOCK *sb, DWORD *color, BOOLEAN lighted) { + if ((lighted == FALSE) && + (sb->render_state[D3DRENDERSTATE_LIGHTING - 1] == TRUE)) { + if (sb->render_state[D3DRENDERSTATE_DIFFUSEMATERIALSOURCE - 1] == D3DMCS_COLOR1) { glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); - handle_diffuse_base(rs, color); + handle_diffuse_base(sb, color); } - if (rs->color_ambient == D3DMCS_COLOR1) { + if (sb->render_state[D3DRENDERSTATE_AMBIENTMATERIALSOURCE - 1] == D3DMCS_COLOR1) { glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT); - handle_diffuse_base(rs, color); + handle_diffuse_base(sb, color); } - if ((rs->color_specular == D3DMCS_COLOR1) && (rs->specular_enable == TRUE)) { + if ((sb->render_state[D3DRENDERSTATE_SPECULARMATERIALSOURCE - 1] == D3DMCS_COLOR1) && + (sb->render_state[D3DRENDERSTATE_SPECULARENABLE - 1] == TRUE)) { glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR); - handle_diffuse_base(rs, color); + handle_diffuse_base(sb, color); } - if (rs->color_emissive == D3DMCS_COLOR1) { + if (sb->render_state[D3DRENDERSTATE_EMISSIVEMATERIALSOURCE - 1] == D3DMCS_COLOR1) { glColorMaterial(GL_FRONT_AND_BACK, GL_EMISSION); - handle_diffuse_base(rs, color); + handle_diffuse_base(sb, color); } } else { - handle_diffuse_base(rs, color); + handle_diffuse_base(sb, color); } } -inline static void handle_specular(RenderState *rs, DWORD *color) { - if (rs->lighting_enable == TRUE) { - if (rs->color_diffuse == D3DMCS_COLOR2) { +inline static void handle_specular(STATEBLOCK *sb, DWORD *color, BOOLEAN lighted) { + if ((lighted == FALSE) && + (sb->render_state[D3DRENDERSTATE_LIGHTING - 1] == TRUE)) { + if (sb->render_state[D3DRENDERSTATE_DIFFUSEMATERIALSOURCE - 1] == D3DMCS_COLOR2) { glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); - handle_specular(rs, color); + handle_specular_base(sb, color); } - if (rs->color_ambient == D3DMCS_COLOR2) { + if (sb->render_state[D3DRENDERSTATE_AMBIENTMATERIALSOURCE - 1] == D3DMCS_COLOR2) { glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT); - handle_specular(rs, color); + handle_specular_base(sb, color); } - if ((rs->color_specular == D3DMCS_COLOR2) && (rs->specular_enable == TRUE)) { + if ((sb->render_state[D3DRENDERSTATE_SPECULARMATERIALSOURCE - 1] == D3DMCS_COLOR2) && + (sb->render_state[D3DRENDERSTATE_SPECULARENABLE - 1] == TRUE)) { glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR); - handle_specular(rs, color); + handle_specular_base(sb, color); } - if (rs->color_emissive == D3DMCS_COLOR2) { + if (sb->render_state[D3DRENDERSTATE_EMISSIVEMATERIALSOURCE - 1] == D3DMCS_COLOR2) { glColorMaterial(GL_FRONT_AND_BACK, GL_EMISSION); - handle_specular(rs, color); + handle_specular_base(sb, color); } } /* No else here as we do not know how to handle 'specular' on its own in any case.. */ } -inline static void handle_diffuse_and_specular(RenderState *rs, DWORD *color_d, DWORD *color_s, BOOLEAN transformed) { - if (transformed == TRUE) { - if (rs->fog_on == TRUE) { +inline static void handle_diffuse_and_specular(STATEBLOCK *sb, DWORD *color_d, DWORD *color_s, BOOLEAN lighted) { + if (lighted == TRUE) { + if (sb->render_state[D3DRENDERSTATE_FOGENABLE - 1] == TRUE) { /* Special case where the specular value is used to do fogging. TODO */ } - if (rs->specular_enable == TRUE) { + if (sb->render_state[D3DRENDERSTATE_SPECULARENABLE - 1] == TRUE) { /* Standard specular value in transformed mode. TODO */ } - handle_diffuse_base(rs, color_d); + handle_diffuse_base(sb, color_d); } else { - if (rs->lighting_enable == TRUE) { - handle_diffuse(rs, color_d); - handle_specular(rs, color_s); + if (sb->render_state[D3DRENDERSTATE_LIGHTING - 1] == TRUE) { + handle_diffuse(sb, color_d, FALSE); + handle_specular(sb, color_s, FALSE); } else { /* In that case, only put the diffuse color... */ - handle_diffuse_base(rs, color_d); + handle_diffuse_base(sb, color_d); } } } @@ -929,7 +932,8 @@ static void draw_primitive_strided(IDirect3DDeviceImpl *This, DWORD dwIndexCount, DWORD dwFlags) { - IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This; + BOOLEAN vertex_lighted = (d3dvtVertexType & D3DFVF_NORMAL) == 0; + if (TRACE_ON(ddraw)) { TRACE(" Vertex format : "); dump_flexible_vertex(d3dvtVertexType); } @@ -937,7 +941,7 @@ static void draw_primitive_strided(IDirect3DDeviceImpl *This, ENTER_GL(); draw_primitive_handle_GL_state(This, (d3dvtVertexType & D3DFVF_POSITION_MASK) != D3DFVF_XYZ, - (d3dvtVertexType & D3DFVF_NORMAL) == 0); + vertex_lighted); draw_primitive_start_GL(d3dptPrimitiveType); /* Some fast paths first before the generic case.... */ @@ -976,7 +980,7 @@ static void draw_primitive_strided(IDirect3DDeviceImpl *This, D3DVALUE *position = (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride); - handle_diffuse_and_specular(&(glThis->render_state), color_d, color_s, TRUE); + handle_diffuse_and_specular(&(This->state_block), color_d, color_s, TRUE); handle_texture(tex_coord); handle_xyzrhw(position); @@ -1011,16 +1015,16 @@ static void draw_primitive_strided(IDirect3DDeviceImpl *This, (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride); DWORD *color_s = (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride); - handle_diffuse_and_specular(&(glThis->render_state), color_d, color_s, (d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW); + handle_diffuse_and_specular(&(This->state_block), color_d, color_s, vertex_lighted); } else { if (d3dvtVertexType & D3DFVF_SPECULAR) { DWORD *color_s = (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride); - handle_specular(&(glThis->render_state), color_s); + handle_specular(&(This->state_block), color_s, vertex_lighted); } else if (d3dvtVertexType & D3DFVF_DIFFUSE) { DWORD *color_d = (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride); - handle_diffuse(&(glThis->render_state), color_d); + handle_diffuse(&(This->state_block), color_d, vertex_lighted); } } @@ -1266,6 +1270,44 @@ GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveVB(LPDIRECT3DDEVICE7 iface, return DD_OK; } +static GLenum +convert_min_filter_to_GL(D3DTEXTUREMINFILTER dwState) +{ + GLenum gl_state; + + switch (dwState) { + case D3DTFN_POINT: + gl_state = GL_NEAREST; + break; + case D3DTFN_LINEAR: + gl_state = GL_LINEAR; + break; + default: + gl_state = GL_LINEAR; + break; + } + return gl_state; +} + +static GLenum +convert_mag_filter_to_GL(D3DTEXTUREMAGFILTER dwState) +{ + GLenum gl_state; + + switch (dwState) { + case D3DTFG_POINT: + gl_state = GL_NEAREST; + break; + case D3DTFG_LINEAR: + gl_state = GL_LINEAR; + break; + default: + gl_state = GL_LINEAR; + break; + } + return gl_state; +} + HRESULT WINAPI GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState(LPDIRECT3DDEVICE7 iface, DWORD dwStage, @@ -1273,11 +1315,11 @@ GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState(LPDIRECT3DDEVICE7 iface, DWORD dwState) { ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface); - IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This; - GLenum gl_state; TRACE("(%p/%p)->(%08lx,%08x,%08lx)\n", This, iface, dwStage, d3dTexStageStateType, dwState); + if (dwStage > 0) return DD_OK; /* We nothing in this case for now */ + if (TRACE_ON(ddraw)) { TRACE(" Stage type is : "); switch (d3dTexStageStateType) { @@ -1314,41 +1356,25 @@ GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState(LPDIRECT3DDEVICE7 iface, switch (d3dTexStageStateType) { case D3DTSS_MINFILTER: - switch ((D3DTEXTUREMINFILTER) dwState) { - case D3DTFN_POINT: - if (TRACE_ON(ddraw)) DPRINTF("D3DTFN_POINT\n"); - gl_state = GL_NEAREST; - break; - case D3DTFN_LINEAR: - if (TRACE_ON(ddraw)) DPRINTF("D3DTFN_LINEAR\n"); - gl_state = GL_LINEAR; - break; - default: - if (TRACE_ON(ddraw)) DPRINTF(" state unhandled (%ld).\n", dwState); - gl_state = GL_LINEAR; - break; + if (TRACE_ON(ddraw)) { + switch ((D3DTEXTUREMINFILTER) dwState) { + case D3DTFN_POINT: DPRINTF("D3DTFN_POINT\n"); break; + case D3DTFN_LINEAR: DPRINTF("D3DTFN_LINEAR\n"); break; + default: DPRINTF(" state unhandled (%ld).\n", dwState); break; + } } - glThis->render_state.min = gl_state; - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_state); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, convert_min_filter_to_GL(dwState)); break; case D3DTSS_MAGFILTER: - switch ((D3DTEXTUREMAGFILTER) dwState) { - case D3DTFG_POINT: - if (TRACE_ON(ddraw)) DPRINTF("D3DTFG_POINT\n"); - gl_state = GL_NEAREST; - break; - case D3DTFG_LINEAR: - if (TRACE_ON(ddraw)) DPRINTF("D3DTFG_LINEAR\n"); - gl_state = GL_LINEAR; - break; - default: - if (TRACE_ON(ddraw)) DPRINTF(" state unhandled (%ld).\n", dwState); - gl_state = GL_LINEAR; - break; + if (TRACE_ON(ddraw)) { + switch ((D3DTEXTUREMAGFILTER) dwState) { + case D3DTFG_POINT: DPRINTF("D3DTFN_POINT\n"); break; + case D3DTFG_LINEAR: DPRINTF("D3DTFN_LINEAR\n"); break; + default: DPRINTF(" state unhandled (%ld).\n", dwState); break; + } } - glThis->render_state.mag = gl_state; - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_state); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, convert_mag_filter_to_GL(dwState)); break; case D3DTSS_ADDRESS: @@ -1373,8 +1399,13 @@ GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState(LPDIRECT3DDEVICE7 iface, if (TRACE_ON(ddraw)) DPRINTF(" unhandled.\n"); } - This->state_block.texture_stage_state[dwStage][d3dTexStageStateType-1] = dwState; - + This->state_block.texture_stage_state[dwStage][d3dTexStageStateType - 1] = dwState; + /* Some special cases when one state modifies more than one... */ + if (d3dTexStageStateType == D3DTSS_ADDRESS) { + This->state_block.texture_stage_state[dwStage][D3DTSS_ADDRESSU - 1] = dwState; + This->state_block.texture_stage_state[dwStage][D3DTSS_ADDRESSV - 1] = dwState; + } + return DD_OK; } @@ -1384,10 +1415,11 @@ GL_IDirect3DDeviceImpl_7_3T_SetTexture(LPDIRECT3DDEVICE7 iface, LPDIRECTDRAWSURFACE7 lpTexture2) { ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface); - IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This; TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, dwStage, lpTexture2); + if (dwStage > 0) return DD_OK; + if (This->current_texture[dwStage] != NULL) { IDirectDrawSurface7_Release(ICOM_INTERFACE(This->current_texture[dwStage], IDirectDrawSurface7)); } @@ -1408,8 +1440,10 @@ GL_IDirect3DDeviceImpl_7_3T_SetTexture(LPDIRECT3DDEVICE7 iface, glEnable(GL_TEXTURE_2D); gltex_upload_texture(tex_impl); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, glThis->render_state.mag); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glThis->render_state.min); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, + convert_mag_filter_to_GL(This->state_block.texture_stage_state[dwStage][D3DTSS_MAGFILTER - 1])); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + convert_min_filter_to_GL(This->state_block.texture_stage_state[dwStage][D3DTSS_MINFILTER - 1])); } LEAVE_GL(); @@ -2141,13 +2175,6 @@ d3ddevice_create(IDirect3DDeviceImpl **obj, IDirect3DImpl *d3d, IDirectDrawSurfa surf->d3ddevice = object; } - /* FIXME: These 4 statements are kept for compatibility but should be removed as soon - as they are correctly handled */ - gl_object->render_state.fog_on = FALSE; - gl_object->render_state.stencil_enable = FALSE; - gl_object->render_state.lighting_enable = FALSE; - gl_object->render_state.specular_enable = FALSE; - /* Set the various light parameters */ for (light = 0; light < MAX_LIGHTS; light++) { /* Only set the fields that are not zero-created */ @@ -2205,9 +2232,9 @@ d3ddevice_create(IDirect3DDeviceImpl **obj, IDirect3DImpl *d3d, IDirectDrawSurfa object->d3d->added_device(object->d3d, object); /* FIXME: Should handle other versions than just 7 */ - InitDefaultStateBlock(&object->state_block,7); + InitDefaultStateBlock(&object->state_block, 7); /* Apply default render state values */ - apply_render_state(gl_object, &object->state_block); + apply_render_state(object, &object->state_block); /* FIXME: do something similar for ligh_state and texture_stage_state */ return DD_OK; diff --git a/dlls/ddraw/d3dexecutebuffer.c b/dlls/ddraw/d3dexecutebuffer.c index fb1b8cc02a4..656857a39f2 100644 --- a/dlls/ddraw/d3dexecutebuffer.c +++ b/dlls/ddraw/d3dexecutebuffer.c @@ -187,7 +187,6 @@ static void execute(IDirect3DExecuteBufferImpl *This, IDirect3DDeviceImpl *lpDevice, IDirect3DViewportImpl *lpViewport) { - IDirect3DDeviceGLImpl* lpDeviceGL = (IDirect3DDeviceGLImpl*) lpDevice; /* DWORD bs = This->desc.dwBufferSize; */ DWORD vs = This->data.dwVertexOffset; /* DWORD vc = This->data.dwVertexCount; */ @@ -441,8 +440,10 @@ static void execute(IDirect3DExecuteBufferImpl *This, for (i = 0; i < count; i++) { LPD3DSTATE ci = (LPD3DSTATE) instr; - /* Handle the state transform */ - set_render_state(lpDeviceGL, ci->u1.drstRenderStateType, ci->u2.dwArg[0]); + LEAVE_GL(); + IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(lpDevice, IDirect3DDevice7), + ci->u1.drstRenderStateType, ci->u2.dwArg[0]); + ENTER_GL(); instr += size; } diff --git a/dlls/ddraw/d3dtexture.c b/dlls/ddraw/d3dtexture.c index 1cbe3ee60d3..04b0859daeb 100644 --- a/dlls/ddraw/d3dtexture.c +++ b/dlls/ddraw/d3dtexture.c @@ -149,7 +149,7 @@ gltex_upload_texture(IDirectDrawSurfaceImpl *This) { } else { DWORD i; BYTE *src = (BYTE *) src_d->lpSurface, *dst; - + surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, src_d->dwWidth * src_d->dwHeight * sizeof(DWORD)); dst = (BYTE *) surface; diff --git a/dlls/ddraw/mesa.c b/dlls/ddraw/mesa.c index 9e370d752ac..ccf59d1a748 100644 --- a/dlls/ddraw/mesa.c +++ b/dlls/ddraw/mesa.c @@ -62,10 +62,30 @@ GLenum convert_D3D_stencilop_to_GL(D3DSTENCILOP dwRenderState) return GL_KEEP; } -void set_render_state(IDirect3DDeviceGLImpl* This, - D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState) +GLenum convert_D3D_blendop_to_GL(D3DBLEND dwRenderState) { - RenderState* rs = &This->render_state; + switch ((D3DBLEND) dwRenderState) { + case D3DBLEND_ZERO: return GL_ZERO; + case D3DBLEND_ONE: return GL_ONE; + case D3DBLEND_SRCALPHA: return GL_SRC_ALPHA; + case D3DBLEND_INVSRCALPHA: return GL_ONE_MINUS_SRC_ALPHA; + case D3DBLEND_DESTALPHA: return GL_DST_ALPHA; + case D3DBLEND_INVDESTALPHA: return GL_ONE_MINUS_DST_ALPHA; + case D3DBLEND_DESTCOLOR: return GL_DST_COLOR; + case D3DBLEND_INVDESTCOLOR: return GL_ONE_MINUS_DST_COLOR; + case D3DBLEND_SRCALPHASAT: return GL_SRC_ALPHA_SATURATE; + case D3DBLEND_SRCCOLOR: return GL_SRC_COLOR; + case D3DBLEND_INVSRCCOLOR: return GL_ONE_MINUS_SRC_COLOR; + default: ERR("Unhandled blend mode %d !\n", dwRenderState); return GL_ZERO; + } +} + +void set_render_state(IDirect3DDeviceImpl* This, + D3DRENDERSTATETYPE dwRenderStateType, STATEBLOCK *lpStateBlock) +{ + IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This; + DWORD dwRenderState = lpStateBlock->render_state[dwRenderStateType - 1]; + if (TRACE_ON(ddraw)) TRACE("%s = %08lx\n", _get_renderstate(dwRenderStateType), dwRenderState); @@ -82,7 +102,7 @@ void set_render_state(IDirect3DDeviceGLImpl* This, IDirectDrawSurfaceImpl *tex = (IDirectDrawSurfaceImpl*) dwRenderState; LEAVE_GL(); - IDirect3DDevice7_SetTexture(ICOM_INTERFACE(&(This->parent), IDirect3DDevice7), + IDirect3DDevice7_SetTexture(ICOM_INTERFACE(This, IDirect3DDevice7), 0, ICOM_INTERFACE(tex, IDirectDrawSurface7)); ENTER_GL(); @@ -91,19 +111,17 @@ void set_render_state(IDirect3DDeviceGLImpl* This, case D3DRENDERSTATE_TEXTUREADDRESSU: /* 44 */ case D3DRENDERSTATE_TEXTUREADDRESSV: /* 45 */ case D3DRENDERSTATE_TEXTUREADDRESS: { /* 3 */ - GLenum arg = GL_REPEAT; /* Default value */ - switch ((D3DTEXTUREADDRESS) dwRenderState) { - case D3DTADDRESS_WRAP: arg = GL_REPEAT; break; - case D3DTADDRESS_CLAMP: arg = GL_CLAMP; break; - case D3DTADDRESS_BORDER: arg = GL_CLAMP_TO_EDGE; break; - default: ERR("Unhandled TEXTUREADDRESS mode %ld !\n", dwRenderState); - } - if ((dwRenderStateType == D3DRENDERSTATE_TEXTUREADDRESSU) || - (dwRenderStateType == D3DRENDERSTATE_TEXTUREADDRESS)) - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, arg); - if ((dwRenderStateType == D3DRENDERSTATE_TEXTUREADDRESSV) || - (dwRenderStateType == D3DRENDERSTATE_TEXTUREADDRESS)) - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, arg); + D3DTEXTURESTAGESTATETYPE d3dTexStageStateType; + + if (dwRenderStateType == D3DRENDERSTATE_TEXTUREADDRESS) d3dTexStageStateType = D3DTSS_ADDRESS; + else if (dwRenderStateType == D3DRENDERSTATE_TEXTUREADDRESSU) d3dTexStageStateType = D3DTSS_ADDRESSU; + else d3dTexStageStateType = D3DTSS_ADDRESSV; + + LEAVE_GL(); + IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This, IDirect3DDevice7), + 0, d3dTexStageStateType, + dwRenderState); + ENTER_GL(); } break; case D3DRENDERSTATE_TEXTUREPERSPECTIVE: /* 4 */ @@ -181,113 +199,52 @@ void set_render_state(IDirect3DDeviceGLImpl* This, glDisable(GL_ALPHA_TEST); break; - case D3DRENDERSTATE_TEXTUREMAG: /* 17 */ + case D3DRENDERSTATE_TEXTUREMAG: { /* 17 */ + DWORD tex_mag = 0xFFFFFFFF; + switch ((D3DTEXTUREFILTER) dwRenderState) { case D3DFILTER_NEAREST: - rs->mag = GL_NEAREST; + tex_mag = D3DTFG_POINT; break; case D3DFILTER_LINEAR: - rs->mag = GL_LINEAR; + tex_mag = D3DTFG_LINEAR; break; default: ERR("Unhandled texture mag %ld !\n",dwRenderState); } - break; - case D3DRENDERSTATE_TEXTUREMIN: /* 18 */ + if (tex_mag != 0xFFFFFFFF) { + LEAVE_GL(); + IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This, IDirect3DDevice7), 0, D3DTSS_MAGFILTER, tex_mag); + ENTER_GL(); + } + } break; + + case D3DRENDERSTATE_TEXTUREMIN: { /* 18 */ + DWORD tex_min = 0xFFFFFFFF; + switch ((D3DTEXTUREFILTER) dwRenderState) { case D3DFILTER_NEAREST: - rs->min = GL_NEAREST; + tex_min = D3DTFN_POINT; break; case D3DFILTER_LINEAR: - rs->mag = GL_LINEAR; + tex_min = D3DTFN_LINEAR; break; default: ERR("Unhandled texture min %ld !\n",dwRenderState); - } - break; + } - case D3DRENDERSTATE_SRCBLEND: /* 19 */ - switch ((D3DBLEND) dwRenderState) { - case D3DBLEND_ZERO: - rs->src = GL_ZERO; - break; - case D3DBLEND_ONE: - rs->src = GL_ONE; - break; - case D3DBLEND_SRCALPHA: - rs->src = GL_SRC_ALPHA; - break; - case D3DBLEND_INVSRCALPHA: - rs->src = GL_ONE_MINUS_SRC_ALPHA; - break; - case D3DBLEND_DESTALPHA: - rs->src = GL_DST_ALPHA; - break; - case D3DBLEND_INVDESTALPHA: - rs->src = GL_ONE_MINUS_DST_ALPHA; - break; - case D3DBLEND_DESTCOLOR: - rs->src = GL_DST_COLOR; - break; - case D3DBLEND_INVDESTCOLOR: - rs->src = GL_ONE_MINUS_DST_COLOR; - break; - case D3DBLEND_BOTHSRCALPHA: - rs->src = GL_SRC_ALPHA; - rs->dst = GL_SRC_ALPHA; - break; - case D3DBLEND_BOTHINVSRCALPHA: - rs->src = GL_ONE_MINUS_SRC_ALPHA; - rs->dst = GL_ONE_MINUS_SRC_ALPHA; - break; - case D3DBLEND_SRCALPHASAT: - rs->src = GL_SRC_ALPHA_SATURATE; - break; - case D3DBLEND_SRCCOLOR: - case D3DBLEND_INVSRCCOLOR: - /* Cannot be supported with OpenGL */ - break; - default: - ERR("Unhandled src blend mode %ld !\n",dwRenderState); + if (tex_min != 0xFFFFFFFF) { + LEAVE_GL(); + IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This, IDirect3DDevice7), 0, D3DTSS_MINFILTER, tex_min); + ENTER_GL(); } - glBlendFunc(rs->src, rs->dst); - break; + } break; + case D3DRENDERSTATE_SRCBLEND: /* 19 */ case D3DRENDERSTATE_DESTBLEND: /* 20 */ - switch ((D3DBLEND) dwRenderState) { - case D3DBLEND_ZERO: - rs->dst = GL_ZERO; - break; - case D3DBLEND_ONE: - rs->dst = GL_ONE; - break; - case D3DBLEND_SRCCOLOR: - rs->dst = GL_SRC_COLOR; - break; - case D3DBLEND_INVSRCCOLOR: - rs->dst = GL_ONE_MINUS_SRC_COLOR; - break; - case D3DBLEND_SRCALPHA: - rs->dst = GL_SRC_ALPHA; - break; - case D3DBLEND_INVSRCALPHA: - rs->dst = GL_ONE_MINUS_SRC_ALPHA; - break; - case D3DBLEND_DESTALPHA: - rs->dst = GL_DST_ALPHA; - break; - case D3DBLEND_INVDESTALPHA: - rs->dst = GL_ONE_MINUS_DST_ALPHA; - break; - case D3DBLEND_DESTCOLOR: - case D3DBLEND_INVDESTCOLOR: - /* Cannot be supported with OpenGL */ - break; - default: - ERR("Unhandled dest blend mode %ld !\n",dwRenderState); - } - glBlendFunc(rs->src, rs->dst); + glBlendFunc(convert_D3D_blendop_to_GL(lpStateBlock->render_state[D3DRENDERSTATE_SRCBLEND - 1]), + convert_D3D_blendop_to_GL(lpStateBlock->render_state[D3DRENDERSTATE_DESTBLEND - 1])); break; case D3DRENDERSTATE_TEXTUREMAPBLEND: /* 21 */ @@ -297,7 +254,7 @@ void set_render_state(IDirect3DDeviceGLImpl* This, glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); break; default: - ERR("Unhandled texture environment %ld !\n",dwRenderState); + ERR("Unhandled texture environment %ld !\n",dwRenderState); } break; @@ -306,7 +263,6 @@ void set_render_state(IDirect3DDeviceGLImpl* This, case D3DCULL_NONE: glDisable(GL_CULL_FACE); break; - /* Not sure about these... The DirectX doc is, well, pretty unclear :-) */ case D3DCULL_CW: glEnable(GL_CULL_FACE); glFrontFace(GL_CCW); @@ -327,13 +283,9 @@ void set_render_state(IDirect3DDeviceGLImpl* This, break; case D3DRENDERSTATE_ALPHAREF: /* 24 */ - rs->alpha_ref = dwRenderState / 255.0; - glAlphaFunc(rs->alpha_func, rs->alpha_ref); - break; - - case D3DRENDERSTATE_ALPHAFUNC: /* 25 */ - rs->alpha_func = convert_D3D_compare_to_GL(dwRenderState); - glAlphaFunc(rs->alpha_func, rs->alpha_ref); + case D3DRENDERSTATE_ALPHAFUNC: /* 25 */ + glAlphaFunc(convert_D3D_compare_to_GL(lpStateBlock->render_state[D3DRENDERSTATE_ALPHAFUNC - 1]), + (lpStateBlock->render_state[D3DRENDERSTATE_ALPHAREF - 1] & 0x000000FF) / 255.0); break; case D3DRENDERSTATE_DITHERENABLE: /* 26 */ @@ -346,20 +298,17 @@ void set_render_state(IDirect3DDeviceGLImpl* This, case D3DRENDERSTATE_ALPHABLENDENABLE: /* 27 */ if (dwRenderState) { glEnable(GL_BLEND); - rs->alpha_blend_enable = TRUE; } else { glDisable(GL_BLEND); - rs->alpha_blend_enable = FALSE; } break; case D3DRENDERSTATE_FOGENABLE: /* 28 */ - if (dwRenderState) { + if ((dwRenderState == TRUE) && + (glThis->transform_state != GL_TRANSFORM_ORTHO)) { glEnable(GL_FOG); - rs->fog_on = TRUE; } else { glDisable(GL_FOG); - rs->fog_on = FALSE; } break; @@ -415,57 +364,43 @@ void set_render_state(IDirect3DDeviceGLImpl* This, case D3DRENDERSTATE_STENCILENABLE: /* 52 */ if (dwRenderState) - glDisable(GL_STENCIL_TEST); + glEnable(GL_STENCIL_TEST); else glDisable(GL_STENCIL_TEST); break; case D3DRENDERSTATE_STENCILFAIL: /* 53 */ - rs->stencil_fail = convert_D3D_stencilop_to_GL(dwRenderState); - glStencilOp(rs->stencil_fail, rs->stencil_zfail, rs->stencil_pass); - break; - case D3DRENDERSTATE_STENCILZFAIL: /* 54 */ - rs->stencil_zfail = convert_D3D_stencilop_to_GL(dwRenderState); - glStencilOp(rs->stencil_fail, rs->stencil_zfail, rs->stencil_pass); - break; - case D3DRENDERSTATE_STENCILPASS: /* 55 */ - rs->stencil_pass = convert_D3D_stencilop_to_GL(dwRenderState); - glStencilOp(rs->stencil_fail, rs->stencil_zfail, rs->stencil_pass); + glStencilOp(convert_D3D_stencilop_to_GL(lpStateBlock->render_state[D3DRENDERSTATE_STENCILFAIL - 1]), + convert_D3D_stencilop_to_GL(lpStateBlock->render_state[D3DRENDERSTATE_STENCILZFAIL - 1]), + convert_D3D_stencilop_to_GL(lpStateBlock->render_state[D3DRENDERSTATE_STENCILPASS - 1])); break; case D3DRENDERSTATE_STENCILFUNC: /* 56 */ - rs->stencil_func = convert_D3D_compare_to_GL(dwRenderState); - glStencilFunc(rs->stencil_func, rs->stencil_ref, rs->stencil_mask); - break; - case D3DRENDERSTATE_STENCILREF: /* 57 */ - rs->stencil_ref = dwRenderState; - glStencilFunc(rs->stencil_func, rs->stencil_ref, rs->stencil_mask); - break; - case D3DRENDERSTATE_STENCILMASK: /* 58 */ - rs->stencil_mask = dwRenderState; - glStencilFunc(rs->stencil_func, rs->stencil_ref, rs->stencil_mask); + glStencilFunc(convert_D3D_compare_to_GL(lpStateBlock->render_state[D3DRENDERSTATE_STENCILFUNC - 1]), + lpStateBlock->render_state[D3DRENDERSTATE_STENCILREF - 1], + lpStateBlock->render_state[D3DRENDERSTATE_STENCILMASK - 1]); break; case D3DRENDERSTATE_STENCILWRITEMASK: /* 59 */ glStencilMask(dwRenderState); break; - case D3DRENDERSTATE_CLIPPING: /* 136 */ - case D3DRENDERSTATE_CLIPPLANEENABLE: /*152*/ - { + case D3DRENDERSTATE_CLIPPING: /* 136 */ + case D3DRENDERSTATE_CLIPPLANEENABLE: { /* 152 */ GLint i; DWORD mask, runner; - if (dwRenderStateType==D3DRENDERSTATE_CLIPPING) { - mask = ((dwRenderState)?(This->parent.state_block.render_state[D3DRENDERSTATE_CLIPPLANEENABLE-1]):(0x0000)); + if (dwRenderStateType == D3DRENDERSTATE_CLIPPING) { + mask = ((dwRenderState) ? + (This->state_block.render_state[D3DRENDERSTATE_CLIPPLANEENABLE - 1]) : (0x0000)); } else { mask = dwRenderState; } - for (i = 0, runner = 1; i < This->parent.max_clipping_planes; i++, runner = (runner<<1)) { + for (i = 0, runner = 0x00000001; i < This->max_clipping_planes; i++, runner = (runner << 1)) { if (mask & runner) { glEnable(GL_CLIP_PLANE0 + i); } else { @@ -510,19 +445,10 @@ void set_render_state(IDirect3DDeviceGLImpl* This, break; case D3DRENDERSTATE_DIFFUSEMATERIALSOURCE: /* 145 */ - rs->color_diffuse = dwRenderState; - break; - case D3DRENDERSTATE_SPECULARMATERIALSOURCE: /* 146 */ - rs->color_specular = dwRenderState; - break; - case D3DRENDERSTATE_AMBIENTMATERIALSOURCE: /* 147 */ - rs->color_ambient = dwRenderState; - break; - case D3DRENDERSTATE_EMISSIVEMATERIALSOURCE: /* 148 */ - rs->color_emissive = dwRenderState; + /* Nothing to do here. Only the storage matters :-) */ break; default: @@ -532,26 +458,44 @@ void set_render_state(IDirect3DDeviceGLImpl* This, } } -void store_render_state(D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState, - STATEBLOCK* lpStateBlock) +void store_render_state(IDirect3DDeviceImpl *This, + D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState, STATEBLOCK *lpStateBlock) { TRACE("%s = %08lx\n", _get_renderstate(dwRenderStateType), dwRenderState); - lpStateBlock->render_state[dwRenderStateType-1] = dwRenderState; + + /* Some special cases first.. */ + if (dwRenderStateType == D3DRENDERSTATE_SRCBLEND) { + if (dwRenderState == D3DBLEND_BOTHSRCALPHA) { + lpStateBlock->render_state[D3DRENDERSTATE_SRCBLEND - 1] = D3DBLEND_SRCALPHA; + lpStateBlock->render_state[D3DRENDERSTATE_DESTBLEND - 1] = D3DBLEND_SRCALPHA; + return; + } else if (dwRenderState == D3DBLEND_BOTHINVSRCALPHA) { + lpStateBlock->render_state[D3DRENDERSTATE_SRCBLEND - 1] = D3DBLEND_INVSRCALPHA; + lpStateBlock->render_state[D3DRENDERSTATE_DESTBLEND - 1] = D3DBLEND_INVSRCALPHA; + return; + } + } else if (dwRenderStateType == D3DRENDERSTATE_TEXTUREADDRESS) { + lpStateBlock->render_state[D3DRENDERSTATE_TEXTUREADDRESSU - 1] = dwRenderState; + lpStateBlock->render_state[D3DRENDERSTATE_TEXTUREADDRESSV - 1] = dwRenderState; + } + + /* Default case */ + lpStateBlock->render_state[dwRenderStateType - 1] = dwRenderState; } -void get_render_state(D3DRENDERSTATETYPE dwRenderStateType, LPDWORD lpdwRenderState, - STATEBLOCK* lpStateBlock) +void get_render_state(IDirect3DDeviceImpl *This, + D3DRENDERSTATETYPE dwRenderStateType, LPDWORD lpdwRenderState, STATEBLOCK *lpStateBlock) { - *lpdwRenderState = lpStateBlock->render_state[dwRenderStateType-1]; + *lpdwRenderState = lpStateBlock->render_state[dwRenderStateType - 1]; if (TRACE_ON(ddraw)) TRACE("%s = %08lx\n", _get_renderstate(dwRenderStateType), *lpdwRenderState); } -void apply_render_state(IDirect3DDeviceGLImpl* This, STATEBLOCK* lpStateBlock) +void apply_render_state(IDirect3DDeviceImpl *This, STATEBLOCK *lpStateBlock) { DWORD i; TRACE("(%p,%p)\n", This, lpStateBlock); - for(i=0;iset_flags.render_state[i]) - set_render_state(This, i+1, lpStateBlock->render_state[i]); + set_render_state(This, i + 1, lpStateBlock); } diff --git a/dlls/ddraw/mesa_private.h b/dlls/ddraw/mesa_private.h index 7e88165c65a..403b27a056b 100644 --- a/dlls/ddraw/mesa_private.h +++ b/dlls/ddraw/mesa_private.h @@ -58,32 +58,6 @@ extern void (*wine_tsx11_unlock_ptr)(void); extern const GUID IID_D3DDEVICE_OpenGL; -typedef struct render_state { - /* This is used for the device mode */ - GLenum src, dst; - /* This is used for textures */ - GLenum mag, min; - - /* This is needed for the Alpha stuff */ - GLenum alpha_func; - GLclampf alpha_ref; - BOOLEAN alpha_blend_enable; - - /* This is needed for the stencil stuff */ - GLint stencil_ref; - GLuint stencil_mask; - GLenum stencil_func; - BOOLEAN stencil_enable; - GLenum stencil_fail, stencil_zfail, stencil_pass; - - /* This is needed for proper lighting */ - BOOLEAN lighting_enable, specular_enable; - D3DMATERIALCOLORSOURCE color_diffuse, color_specular, color_ambient, color_emissive; - - /* This is needed to re-enable fogging when XYZRHW and XYZ primitives are mixed */ - BOOLEAN fog_on; -} RenderState; - typedef struct IDirect3DGLImpl { struct IDirect3DImpl parent; @@ -127,9 +101,6 @@ typedef struct IDirect3DDeviceGLImpl GLXContext gl_context; - /* The current render state */ - RenderState render_state; - /* The last type of vertex drawn */ GL_TRANSFORM_STATE transform_state; @@ -167,20 +138,17 @@ extern HRESULT gltex_upload_texture(IDirectDrawSurfaceImpl *This) ; /* Used to set-up our orthographic projection */ extern void d3ddevice_set_ortho(IDirect3DDeviceImpl *This) ; -/* Common functions defined in d3dcommon.c */ -void set_render_state(IDirect3DDeviceGLImpl* This, - D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState); -void store_render_state(D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState, - STATEBLOCK* lpStateBlock); -void get_render_state(D3DRENDERSTATETYPE dwRenderStateType, LPDWORD lpdwRenderState, - STATEBLOCK* lpStateBlock); -void apply_render_state(IDirect3DDeviceGLImpl* This, STATEBLOCK* lpStateBlock); +/* Rendering state management functions */ +extern void set_render_state(IDirect3DDeviceImpl* This, D3DRENDERSTATETYPE dwRenderStateType, STATEBLOCK *lpStateBlock); +extern void store_render_state(IDirect3DDeviceImpl *This, D3DRENDERSTATETYPE dwRenderStateType, DWORD dwRenderState, STATEBLOCK* lpStateBlock); +extern void get_render_state(IDirect3DDeviceImpl *This, D3DRENDERSTATETYPE dwRenderStateType, LPDWORD lpdwRenderState, STATEBLOCK* lpStateBlock); +extern void apply_render_state(IDirect3DDeviceImpl* This, STATEBLOCK* lpStateBlock); /* This structure contains all the function pointers to OpenGL extensions that are used by Wine */ typedef struct { - void (*ptr_ColorTableEXT) (GLenum target, GLenum internalformat, - GLsizei width, GLenum format, GLenum type, const GLvoid *table); + void (*ptr_ColorTableEXT) (GLenum target, GLenum internalformat, + GLsizei width, GLenum format, GLenum type, const GLvoid *table); } Mesa_DeviceCapabilities; #endif /* HAVE_OPENGL */ -- 2.11.4.GIT