mirror of
https://github.com/reactos/reactos.git
synced 2024-08-02 09:30:55 +00:00
part 2/2
Updating wined3d from winehq.org cvs/git date 27/11-2007 this update solv allot of bugs in wined3d ------------------------------------------ Include one ReactOS specify hack. do not use gdi32.dll use opengl32.dll instead. svn path=/trunk/; revision=30814
This commit is contained in:
parent
10d28df34a
commit
b7fb058e20
|
@ -468,7 +468,7 @@ static void vshader_program_add_param(SHADER_OPCODE_ARG *arg, const DWORD param,
|
||||||
break;
|
break;
|
||||||
case WINED3DSPR_CONST:
|
case WINED3DSPR_CONST:
|
||||||
if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
|
if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
|
||||||
if(reg - This->rel_offset >= 0) {
|
if(reg >= This->rel_offset) {
|
||||||
sprintf(tmpReg, "C[A0.x + %u]", reg - This->rel_offset);
|
sprintf(tmpReg, "C[A0.x + %u]", reg - This->rel_offset);
|
||||||
} else {
|
} else {
|
||||||
sprintf(tmpReg, "C[A0.x - %u]", -reg + This->rel_offset);
|
sprintf(tmpReg, "C[A0.x - %u]", -reg + This->rel_offset);
|
||||||
|
@ -1723,10 +1723,14 @@ static void shader_arb_cleanup(IWineD3DDevice *iface) {
|
||||||
if (GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) glDisable(GL_FRAGMENT_PROGRAM_ARB);
|
if (GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) glDisable(GL_FRAGMENT_PROGRAM_ARB);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void shader_arb_destroy(IWineD3DBaseShader *iface) {
|
||||||
|
}
|
||||||
|
|
||||||
const shader_backend_t arb_program_shader_backend = {
|
const shader_backend_t arb_program_shader_backend = {
|
||||||
&shader_arb_select,
|
&shader_arb_select,
|
||||||
&shader_arb_select_depth_blt,
|
&shader_arb_select_depth_blt,
|
||||||
&shader_arb_load_constants,
|
&shader_arb_load_constants,
|
||||||
&shader_arb_cleanup,
|
&shader_arb_cleanup,
|
||||||
&shader_arb_color_correction
|
&shader_arb_color_correction,
|
||||||
|
&shader_arb_destroy
|
||||||
};
|
};
|
||||||
|
|
|
@ -447,12 +447,16 @@ HRESULT shader_get_registers_used(
|
||||||
else if (WINED3DSPR_MISCTYPE == regtype && reg == 0 && pshader)
|
else if (WINED3DSPR_MISCTYPE == regtype && reg == 0 && pshader)
|
||||||
reg_maps->vpos = 1;
|
reg_maps->vpos = 1;
|
||||||
|
|
||||||
else if(WINED3DSPR_CONST == regtype && !pshader &&
|
else if(WINED3DSPR_CONST == regtype) {
|
||||||
param & WINED3DSHADER_ADDRMODE_RELATIVE) {
|
if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
|
||||||
if(reg <= ((IWineD3DVertexShaderImpl *) This)->min_rel_offset) {
|
if(!pshader) {
|
||||||
((IWineD3DVertexShaderImpl *) This)->min_rel_offset = reg;
|
if(reg <= ((IWineD3DVertexShaderImpl *) This)->min_rel_offset) {
|
||||||
} else if(reg >= ((IWineD3DVertexShaderImpl *) This)->max_rel_offset) {
|
((IWineD3DVertexShaderImpl *) This)->min_rel_offset = reg;
|
||||||
((IWineD3DVertexShaderImpl *) This)->max_rel_offset = reg;
|
} else if(reg >= ((IWineD3DVertexShaderImpl *) This)->max_rel_offset) {
|
||||||
|
((IWineD3DVertexShaderImpl *) This)->max_rel_offset = reg;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
reg_maps->usesrelconstF = TRUE;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1058,7 +1062,7 @@ void shader_trace_init(
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void shader_delete_constant_list(
|
static void shader_delete_constant_list(
|
||||||
struct list* clist) {
|
struct list* clist) {
|
||||||
|
|
||||||
struct list *ptr;
|
struct list *ptr;
|
||||||
|
@ -1076,10 +1080,56 @@ static void shader_none_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {}
|
||||||
static void shader_none_select_depth_blt(IWineD3DDevice *iface) {}
|
static void shader_none_select_depth_blt(IWineD3DDevice *iface) {}
|
||||||
static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
|
static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
|
||||||
static void shader_none_cleanup(IWineD3DDevice *iface) {}
|
static void shader_none_cleanup(IWineD3DDevice *iface) {}
|
||||||
|
static void shader_none_color_correction(SHADER_OPCODE_ARG* arg) {}
|
||||||
|
static void shader_none_destroy(IWineD3DBaseShader *iface) {}
|
||||||
|
|
||||||
const shader_backend_t none_shader_backend = {
|
const shader_backend_t none_shader_backend = {
|
||||||
&shader_none_select,
|
&shader_none_select,
|
||||||
&shader_none_select_depth_blt,
|
&shader_none_select_depth_blt,
|
||||||
&shader_none_load_constants,
|
&shader_none_load_constants,
|
||||||
&shader_none_cleanup
|
&shader_none_cleanup,
|
||||||
|
&shader_none_color_correction,
|
||||||
|
&shader_none_destroy
|
||||||
};
|
};
|
||||||
|
|
||||||
|
/* *******************************************
|
||||||
|
IWineD3DPixelShader IUnknown parts follow
|
||||||
|
******************************************* */
|
||||||
|
HRESULT WINAPI IWineD3DBaseShaderImpl_QueryInterface(IWineD3DBaseShader *iface, REFIID riid, LPVOID *ppobj)
|
||||||
|
{
|
||||||
|
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
|
||||||
|
TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
|
||||||
|
if (IsEqualGUID(riid, &IID_IUnknown)
|
||||||
|
|| IsEqualGUID(riid, &IID_IWineD3DBase)
|
||||||
|
|| IsEqualGUID(riid, &IID_IWineD3DBaseShader)
|
||||||
|
|| IsEqualGUID(riid, &IID_IWineD3DPixelShader)) {
|
||||||
|
IUnknown_AddRef(iface);
|
||||||
|
*ppobj = This;
|
||||||
|
return S_OK;
|
||||||
|
}
|
||||||
|
*ppobj = NULL;
|
||||||
|
return E_NOINTERFACE;
|
||||||
|
}
|
||||||
|
|
||||||
|
ULONG WINAPI IWineD3DBaseShaderImpl_AddRef(IWineD3DBaseShader *iface) {
|
||||||
|
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
|
||||||
|
TRACE("(%p) : AddRef increasing from %d\n", This, This->baseShader.ref);
|
||||||
|
return InterlockedIncrement(&This->baseShader.ref);
|
||||||
|
}
|
||||||
|
|
||||||
|
ULONG WINAPI IWineD3DBaseShaderImpl_Release(IWineD3DBaseShader *iface) {
|
||||||
|
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
|
||||||
|
IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
|
||||||
|
ULONG ref;
|
||||||
|
TRACE("(%p) : Releasing from %d\n", This, This->baseShader.ref);
|
||||||
|
ref = InterlockedDecrement(&This->baseShader.ref);
|
||||||
|
if (ref == 0) {
|
||||||
|
deviceImpl->shader_backend->shader_destroy(iface);
|
||||||
|
HeapFree(GetProcessHeap(), 0, This->baseShader.function);
|
||||||
|
shader_delete_constant_list(&This->baseShader.constantsF);
|
||||||
|
shader_delete_constant_list(&This->baseShader.constantsB);
|
||||||
|
shader_delete_constant_list(&This->baseShader.constantsI);
|
||||||
|
HeapFree(GetProcessHeap(), 0, This);
|
||||||
|
}
|
||||||
|
return ref;
|
||||||
|
}
|
||||||
|
|
|
@ -860,10 +860,17 @@ void ActivateContext(IWineD3DDeviceImpl *This, IWineD3DSurface *target, ContextU
|
||||||
/* Activate the opengl context */
|
/* Activate the opengl context */
|
||||||
if(context != This->activeContext) {
|
if(context != This->activeContext) {
|
||||||
BOOL ret;
|
BOOL ret;
|
||||||
TRACE("Switching gl ctx to %p, hdc=%p ctx=%p\n", context, context->hdc, context->glCtx);
|
|
||||||
ret = pwglMakeCurrent(context->hdc, context->glCtx);
|
/* Prevent an unneeded context switch as those are expensive */
|
||||||
if(ret == FALSE) {
|
if(context->glCtx && (context->glCtx == pwglGetCurrentContext())) {
|
||||||
ERR("Failed to activate the new context\n");
|
TRACE("Already using gl context %p\n", context->glCtx);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
TRACE("Switching gl ctx to %p, hdc=%p ctx=%p\n", context, context->hdc, context->glCtx);
|
||||||
|
ret = pwglMakeCurrent(context->hdc, context->glCtx);
|
||||||
|
if(ret == FALSE) {
|
||||||
|
ERR("Failed to activate the new context\n");
|
||||||
|
}
|
||||||
}
|
}
|
||||||
This->activeContext = context;
|
This->activeContext = context;
|
||||||
}
|
}
|
||||||
|
|
|
@ -230,40 +230,8 @@ static UINT WINAPI IWineD3DCubeTextureImpl_GetTextureDimensions(IWineD3DCubeText
|
||||||
static void WINAPI IWineD3DCubeTextureImpl_ApplyStateChanges(IWineD3DCubeTexture *iface,
|
static void WINAPI IWineD3DCubeTextureImpl_ApplyStateChanges(IWineD3DCubeTexture *iface,
|
||||||
const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1],
|
const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1],
|
||||||
const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]) {
|
const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]) {
|
||||||
IWineD3DCubeTextureImpl *This = (IWineD3DCubeTextureImpl *)iface;
|
TRACE("(%p) : relay to BaseTexture\n", iface);
|
||||||
float matrix[16];
|
|
||||||
IWineD3DBaseTextureImpl_ApplyStateChanges((IWineD3DBaseTexture *)iface, textureStates, samplerStates);
|
IWineD3DBaseTextureImpl_ApplyStateChanges((IWineD3DBaseTexture *)iface, textureStates, samplerStates);
|
||||||
|
|
||||||
|
|
||||||
/* Apply non-power2 mappings and texture offsets so long as the texture coords aren't projected or generated */
|
|
||||||
if(This->pow2scalingFactor != 1.0f) {
|
|
||||||
if((textureStates[WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) == WINED3DTSS_TCI_PASSTHRU &&
|
|
||||||
(~textureStates[WINED3DTSS_TEXTURETRANSFORMFLAGS] & WINED3DTTFF_PROJECTED)) {
|
|
||||||
|
|
||||||
glMatrixMode(GL_TEXTURE);
|
|
||||||
memset(matrix, 0 , sizeof(matrix));
|
|
||||||
|
|
||||||
matrix[0] = This->pow2scalingFactor;
|
|
||||||
matrix[5] = This->pow2scalingFactor;
|
|
||||||
matrix[10] = This->pow2scalingFactor;
|
|
||||||
#if 0 /* Translation fixup is no longer required (here for reminder) */
|
|
||||||
matrix[12] = -0.25f / (float)This->edgeLength;
|
|
||||||
matrix[13] = -0.75f / (float)This->edgeLength;
|
|
||||||
matrix[14] = -0.25f / (float)This->edgeLength;
|
|
||||||
#endif
|
|
||||||
TRACE("(%p) Setup Matrix:\n", This);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[0], matrix[1], matrix[2], matrix[3]);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[4], matrix[5], matrix[6], matrix[7]);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[8], matrix[9], matrix[10], matrix[11]);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[12], matrix[13], matrix[14], matrix[15]);
|
|
||||||
TRACE("\n");
|
|
||||||
glMultMatrixf(matrix);
|
|
||||||
} else {
|
|
||||||
/* I don't expect nonpower 2 textures to be used with generated texture coordinates, but if they are present a fixme. */
|
|
||||||
FIXME("Non-power2 texture being used with generated texture coords\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -71,8 +71,8 @@ static void WINAPI IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3
|
||||||
object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
|
object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
|
||||||
D3DMEMCHECK(object, pp##type); \
|
D3DMEMCHECK(object, pp##type); \
|
||||||
object->lpVtbl = &IWineD3D##type##_Vtbl; \
|
object->lpVtbl = &IWineD3D##type##_Vtbl; \
|
||||||
object->parent = parent; \
|
object->parent = parent; \
|
||||||
object->ref = 1; \
|
object->baseShader.ref = 1; \
|
||||||
object->baseShader.device = (IWineD3DDevice*) This; \
|
object->baseShader.device = (IWineD3DDevice*) This; \
|
||||||
list_init(&object->baseShader.linked_programs); \
|
list_init(&object->baseShader.linked_programs); \
|
||||||
*pp##type = (IWineD3D##type *) object; \
|
*pp##type = (IWineD3D##type *) object; \
|
||||||
|
@ -179,9 +179,9 @@ static ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
|
||||||
/* NOTE: You must release the parent if the object was created via a callback
|
/* NOTE: You must release the parent if the object was created via a callback
|
||||||
** ***************************/
|
** ***************************/
|
||||||
|
|
||||||
if (This->resources != NULL ) {
|
if (!list_empty(&This->resources)) {
|
||||||
FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This);
|
FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This);
|
||||||
dumpResources(This->resources);
|
dumpResources(&This->resources);
|
||||||
}
|
}
|
||||||
|
|
||||||
if(This->contexts) ERR("Context array not freed!\n");
|
if(This->contexts) ERR("Context array not freed!\n");
|
||||||
|
@ -880,9 +880,11 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateTexture(IWineD3DDevice *iface, U
|
||||||
|
|
||||||
/** FIXME: add support for real non-power-two if it's provided by the video card **/
|
/** FIXME: add support for real non-power-two if it's provided by the video card **/
|
||||||
/* Precalculated scaling for 'faked' non power of two texture coords */
|
/* Precalculated scaling for 'faked' non power of two texture coords */
|
||||||
object->pow2scalingFactorX = (((float)Width) / ((float)pow2Width));
|
object->baseTexture.pow2Matrix[0] = (((float)Width) / ((float)pow2Width));
|
||||||
object->pow2scalingFactorY = (((float)Height) / ((float)pow2Height));
|
object->baseTexture.pow2Matrix[5] = (((float)Height) / ((float)pow2Height));
|
||||||
TRACE(" xf(%f) yf(%f)\n", object->pow2scalingFactorX, object->pow2scalingFactorY);
|
object->baseTexture.pow2Matrix[10] = 1.0;
|
||||||
|
object->baseTexture.pow2Matrix[15] = 1.0;
|
||||||
|
TRACE(" xf(%f) yf(%f)\n", object->baseTexture.pow2Matrix[0], object->baseTexture.pow2Matrix[5]);
|
||||||
|
|
||||||
/* Calculate levels for mip mapping */
|
/* Calculate levels for mip mapping */
|
||||||
if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
|
if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
|
||||||
|
@ -976,6 +978,12 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolumeTexture(IWineD3DDevice *ifa
|
||||||
object->height = Height;
|
object->height = Height;
|
||||||
object->depth = Depth;
|
object->depth = Depth;
|
||||||
|
|
||||||
|
/* Is NP2 support for volumes needed? */
|
||||||
|
object->baseTexture.pow2Matrix[ 0] = 1.0;
|
||||||
|
object->baseTexture.pow2Matrix[ 5] = 1.0;
|
||||||
|
object->baseTexture.pow2Matrix[10] = 1.0;
|
||||||
|
object->baseTexture.pow2Matrix[15] = 1.0;
|
||||||
|
|
||||||
/* Calculate levels for mip mapping */
|
/* Calculate levels for mip mapping */
|
||||||
if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
|
if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
|
||||||
if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
|
if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
|
||||||
|
@ -1112,7 +1120,10 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateCubeTexture(IWineD3DDevice *iface
|
||||||
object->edgeLength = EdgeLength;
|
object->edgeLength = EdgeLength;
|
||||||
/* TODO: support for native non-power 2 */
|
/* TODO: support for native non-power 2 */
|
||||||
/* Precalculated scaling for 'faked' non power of two texture coords */
|
/* Precalculated scaling for 'faked' non power of two texture coords */
|
||||||
object->pow2scalingFactor = ((float)EdgeLength) / ((float)pow2EdgeLength);
|
object->baseTexture.pow2Matrix[ 0] = ((float)EdgeLength) / ((float)pow2EdgeLength);
|
||||||
|
object->baseTexture.pow2Matrix[ 5] = ((float)EdgeLength) / ((float)pow2EdgeLength);
|
||||||
|
object->baseTexture.pow2Matrix[10] = ((float)EdgeLength) / ((float)pow2EdgeLength);
|
||||||
|
object->baseTexture.pow2Matrix[15] = 1.0;
|
||||||
|
|
||||||
/* Calculate levels for mip mapping */
|
/* Calculate levels for mip mapping */
|
||||||
if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
|
if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
|
||||||
|
@ -1578,7 +1589,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevic
|
||||||
/* Under directX swapchains share the depth stencil, so only create one depth-stencil */
|
/* Under directX swapchains share the depth stencil, so only create one depth-stencil */
|
||||||
if (pPresentationParameters->EnableAutoDepthStencil && hr == WINED3D_OK) {
|
if (pPresentationParameters->EnableAutoDepthStencil && hr == WINED3D_OK) {
|
||||||
TRACE("Creating depth stencil buffer\n");
|
TRACE("Creating depth stencil buffer\n");
|
||||||
if (This->depthStencilBuffer == NULL ) {
|
if (This->auto_depth_stencil_buffer == NULL ) {
|
||||||
hr = D3DCB_CreateDepthStencil((IUnknown *) This->parent,
|
hr = D3DCB_CreateDepthStencil((IUnknown *) This->parent,
|
||||||
parent,
|
parent,
|
||||||
object->presentParms.BackBufferWidth,
|
object->presentParms.BackBufferWidth,
|
||||||
|
@ -1587,10 +1598,10 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevic
|
||||||
object->presentParms.MultiSampleType,
|
object->presentParms.MultiSampleType,
|
||||||
object->presentParms.MultiSampleQuality,
|
object->presentParms.MultiSampleQuality,
|
||||||
FALSE /* FIXME: Discard */,
|
FALSE /* FIXME: Discard */,
|
||||||
&This->depthStencilBuffer,
|
&This->auto_depth_stencil_buffer,
|
||||||
NULL /* pShared (always null)*/ );
|
NULL /* pShared (always null)*/ );
|
||||||
if (This->depthStencilBuffer != NULL)
|
if (This->auto_depth_stencil_buffer != NULL)
|
||||||
IWineD3DSurface_SetContainer(This->depthStencilBuffer, 0);
|
IWineD3DSurface_SetContainer(This->auto_depth_stencil_buffer, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
/** TODO: A check on width, height and multisample types
|
/** TODO: A check on width, height and multisample types
|
||||||
|
@ -2054,7 +2065,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_Init3D(IWineD3DDevice *iface, WINED3DPR
|
||||||
This->lastThread = GetCurrentThreadId();
|
This->lastThread = GetCurrentThreadId();
|
||||||
|
|
||||||
/* Depth Stencil support */
|
/* Depth Stencil support */
|
||||||
This->stencilBufferTarget = This->depthStencilBuffer;
|
This->stencilBufferTarget = This->auto_depth_stencil_buffer;
|
||||||
if (NULL != This->stencilBufferTarget) {
|
if (NULL != This->stencilBufferTarget) {
|
||||||
IWineD3DSurface_AddRef(This->stencilBufferTarget);
|
IWineD3DSurface_AddRef(This->stencilBufferTarget);
|
||||||
}
|
}
|
||||||
|
@ -2206,8 +2217,8 @@ static HRESULT WINAPI IWineD3DDeviceImpl_Uninit3D(IWineD3DDevice *iface, D3DCB_D
|
||||||
/* Release the buffers (with sanity checks)*/
|
/* Release the buffers (with sanity checks)*/
|
||||||
TRACE("Releasing the depth stencil buffer at %p\n", This->stencilBufferTarget);
|
TRACE("Releasing the depth stencil buffer at %p\n", This->stencilBufferTarget);
|
||||||
if(This->stencilBufferTarget != NULL && (IWineD3DSurface_Release(This->stencilBufferTarget) >0)){
|
if(This->stencilBufferTarget != NULL && (IWineD3DSurface_Release(This->stencilBufferTarget) >0)){
|
||||||
if(This->depthStencilBuffer != This->stencilBufferTarget)
|
if(This->auto_depth_stencil_buffer != This->stencilBufferTarget)
|
||||||
FIXME("(%p) Something's still holding the depthStencilBuffer\n",This);
|
FIXME("(%p) Something's still holding the stencilBufferTarget\n",This);
|
||||||
}
|
}
|
||||||
This->stencilBufferTarget = NULL;
|
This->stencilBufferTarget = NULL;
|
||||||
|
|
||||||
|
@ -2218,11 +2229,11 @@ static HRESULT WINAPI IWineD3DDeviceImpl_Uninit3D(IWineD3DDevice *iface, D3DCB_D
|
||||||
TRACE("Setting rendertarget to NULL\n");
|
TRACE("Setting rendertarget to NULL\n");
|
||||||
This->render_targets[0] = NULL;
|
This->render_targets[0] = NULL;
|
||||||
|
|
||||||
if (This->depthStencilBuffer) {
|
if (This->auto_depth_stencil_buffer) {
|
||||||
if(D3DCB_DestroyDepthStencilSurface(This->depthStencilBuffer) > 0) {
|
if(D3DCB_DestroyDepthStencilSurface(This->auto_depth_stencil_buffer) > 0) {
|
||||||
FIXME("(%p) Something's still holding the depthStencilBuffer\n", This);
|
FIXME("(%p) Something's still holding the auto depth stencil buffer\n", This);
|
||||||
}
|
}
|
||||||
This->depthStencilBuffer = NULL;
|
This->auto_depth_stencil_buffer = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
for(i=0; i < This->NumberOfSwapChains; i++) {
|
for(i=0; i < This->NumberOfSwapChains; i++) {
|
||||||
|
@ -6045,7 +6056,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetFrontBackBuffers(IWineD3DDevice *ifa
|
||||||
|
|
||||||
static HRESULT WINAPI IWineD3DDeviceImpl_GetDepthStencilSurface(IWineD3DDevice* iface, IWineD3DSurface **ppZStencilSurface) {
|
static HRESULT WINAPI IWineD3DDeviceImpl_GetDepthStencilSurface(IWineD3DDevice* iface, IWineD3DSurface **ppZStencilSurface) {
|
||||||
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
||||||
*ppZStencilSurface = This->depthStencilBuffer;
|
*ppZStencilSurface = This->stencilBufferTarget;
|
||||||
TRACE("(%p) : zStencilSurface returning %p\n", This, *ppZStencilSurface);
|
TRACE("(%p) : zStencilSurface returning %p\n", This, *ppZStencilSurface);
|
||||||
|
|
||||||
if(*ppZStencilSurface != NULL) {
|
if(*ppZStencilSurface != NULL) {
|
||||||
|
@ -6387,7 +6398,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetDepthStencilSurface(IWineD3DDevice *
|
||||||
HRESULT hr = WINED3D_OK;
|
HRESULT hr = WINED3D_OK;
|
||||||
IWineD3DSurface *tmp;
|
IWineD3DSurface *tmp;
|
||||||
|
|
||||||
TRACE("(%p) Swapping z-buffer\n",This);
|
TRACE("(%p) Swapping z-buffer. Old = %p, new = %p\n",This, This->stencilBufferTarget, pNewZStencil);
|
||||||
|
|
||||||
if (pNewZStencil == This->stencilBufferTarget) {
|
if (pNewZStencil == This->stencilBufferTarget) {
|
||||||
TRACE("Trying to do a NOP SetRenderTarget operation\n");
|
TRACE("Trying to do a NOP SetRenderTarget operation\n");
|
||||||
|
@ -6611,18 +6622,18 @@ static BOOL WINAPI IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOO
|
||||||
|
|
||||||
static HRESULT WINAPI IWineD3DDeviceImpl_TestCooperativeLevel(IWineD3DDevice* iface) {
|
static HRESULT WINAPI IWineD3DDeviceImpl_TestCooperativeLevel(IWineD3DDevice* iface) {
|
||||||
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
|
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
|
||||||
|
IWineD3DResourceImpl *resource;
|
||||||
TRACE("(%p) : state (%u)\n", This, This->state);
|
TRACE("(%p) : state (%u)\n", This, This->state);
|
||||||
|
|
||||||
/* TODO: Implement wrapping of the WndProc so that mimimize and maxamise can be monitored and the states adjusted. */
|
/* TODO: Implement wrapping of the WndProc so that mimimize and maxamise can be monitored and the states adjusted. */
|
||||||
switch (This->state) {
|
switch (This->state) {
|
||||||
case WINED3D_OK:
|
case WINED3D_OK:
|
||||||
return WINED3D_OK;
|
return WINED3D_OK;
|
||||||
case WINED3DERR_DEVICELOST:
|
case WINED3DERR_DEVICELOST:
|
||||||
{
|
{
|
||||||
ResourceList *resourceList = This->resources;
|
LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) {
|
||||||
while (NULL != resourceList) {
|
if (resource->resource.pool == WINED3DPOOL_DEFAULT)
|
||||||
if (((IWineD3DResourceImpl *)resourceList->resource)->resource.pool == WINED3DPOOL_DEFAULT /* TODO: IWineD3DResource_GetPool(resourceList->resource)*/)
|
return WINED3DERR_DEVICENOTRESET;
|
||||||
return WINED3DERR_DEVICENOTRESET;
|
|
||||||
resourceList = resourceList->next;
|
|
||||||
}
|
}
|
||||||
return WINED3DERR_DEVICELOST;
|
return WINED3DERR_DEVICELOST;
|
||||||
}
|
}
|
||||||
|
@ -6865,51 +6876,17 @@ static void WINAPI IWineD3DDeviceImpl_GetGammaRamp(IWineD3DDevice *iface, UINT i
|
||||||
*****************************************************/
|
*****************************************************/
|
||||||
static void WINAPI IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource){
|
static void WINAPI IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource){
|
||||||
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
||||||
ResourceList* resourceList;
|
|
||||||
|
|
||||||
TRACE("(%p) : resource %p\n", This, resource);
|
TRACE("(%p) : Adding Resource %p\n", This, resource);
|
||||||
/* add a new texture to the frot of the linked list */
|
list_add_head(&This->resources, &((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
|
||||||
resourceList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ResourceList));
|
|
||||||
resourceList->resource = resource;
|
|
||||||
|
|
||||||
/* Get the old head */
|
|
||||||
resourceList->next = This->resources;
|
|
||||||
|
|
||||||
This->resources = resourceList;
|
|
||||||
TRACE("Added resource %p with element %p pointing to %p\n", resource, resourceList, resourceList->next);
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static void WINAPI IWineD3DDeviceImpl_RemoveResource(IWineD3DDevice *iface, IWineD3DResource *resource){
|
static void WINAPI IWineD3DDeviceImpl_RemoveResource(IWineD3DDevice *iface, IWineD3DResource *resource){
|
||||||
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
||||||
ResourceList* resourceList = NULL;
|
|
||||||
ResourceList* previousResourceList = NULL;
|
|
||||||
|
|
||||||
TRACE("(%p) : resource %p\n", This, resource);
|
|
||||||
|
|
||||||
resourceList = This->resources;
|
TRACE("(%p) : Removing resource %p\n", This, resource);
|
||||||
|
|
||||||
while (resourceList != NULL) {
|
list_remove(&((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
|
||||||
if(resourceList->resource == resource) break;
|
|
||||||
previousResourceList = resourceList;
|
|
||||||
resourceList = resourceList->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (resourceList == NULL) {
|
|
||||||
FIXME("Attempted to remove resource %p that hasn't been stored\n", resource);
|
|
||||||
return;
|
|
||||||
} else {
|
|
||||||
TRACE("Found resource %p with element %p pointing to %p (previous %p)\n", resourceList->resource, resourceList, resourceList->next, previousResourceList);
|
|
||||||
}
|
|
||||||
/* make sure we don't leave a hole in the list */
|
|
||||||
if (previousResourceList != NULL) {
|
|
||||||
previousResourceList->next = resourceList->next;
|
|
||||||
} else {
|
|
||||||
This->resources = resourceList->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -40,89 +40,91 @@ WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
|
||||||
static const struct {
|
static const struct {
|
||||||
const char *extension_string;
|
const char *extension_string;
|
||||||
GL_SupportedExt extension;
|
GL_SupportedExt extension;
|
||||||
|
DWORD version;
|
||||||
} EXTENSION_MAP[] = {
|
} EXTENSION_MAP[] = {
|
||||||
/* APPLE */
|
/* APPLE */
|
||||||
{"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE},
|
{"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE, 0 },
|
||||||
{"GL_APPLE_fence", APPLE_FENCE},
|
{"GL_APPLE_fence", APPLE_FENCE, 0 },
|
||||||
{"GL_APPLE_flush_render", APPLE_FLUSH_RENDER},
|
{"GL_APPLE_flush_render", APPLE_FLUSH_RENDER, 0 },
|
||||||
{"GL_APPLE_ycbcr_422", APPLE_YCBCR_422},
|
{"GL_APPLE_ycbcr_422", APPLE_YCBCR_422, 0 },
|
||||||
|
|
||||||
/* ATI */
|
/* ATI */
|
||||||
{"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL},
|
{"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL, 0 },
|
||||||
{"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3},
|
{"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3, 0 },
|
||||||
{"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE},
|
{"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE, 0 },
|
||||||
{"GL_ATI_envmap_bumpmap", ATI_ENVMAP_BUMPMAP},
|
{"GL_ATI_envmap_bumpmap", ATI_ENVMAP_BUMPMAP, 0 },
|
||||||
|
|
||||||
/* ARB */
|
/* ARB */
|
||||||
{"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS},
|
{"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS, 0 },
|
||||||
{"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM},
|
{"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM, 0 },
|
||||||
{"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER},
|
{"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER, 0 },
|
||||||
{"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL},
|
{"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL, 0 },
|
||||||
{"GL_ARB_imaging", ARB_IMAGING},
|
{"GL_ARB_imaging", ARB_IMAGING, 0 },
|
||||||
{"GL_ARB_multisample", ARB_MULTISAMPLE}, /* needs GLX_ARB_MULTISAMPLE as well */
|
{"GL_ARB_multisample", ARB_MULTISAMPLE, 0 }, /* needs GLX_ARB_MULTISAMPLE as well */
|
||||||
{"GL_ARB_multitexture", ARB_MULTITEXTURE},
|
{"GL_ARB_multitexture", ARB_MULTITEXTURE, 0 },
|
||||||
{"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY},
|
{"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY, 0 },
|
||||||
{"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT},
|
{"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT, 0 },
|
||||||
{"GL_ARB_point_parameters", ARB_POINT_PARAMETERS},
|
{"GL_ARB_point_parameters", ARB_POINT_PARAMETERS, 0 },
|
||||||
{"GL_ARB_point_sprite", ARB_POINT_SPRITE},
|
{"GL_ARB_point_sprite", ARB_POINT_SPRITE, 0 },
|
||||||
{"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP},
|
{"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP, 0 },
|
||||||
{"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION},
|
{"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION, 0 },
|
||||||
{"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP},
|
{"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP, 0 },
|
||||||
{"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD},
|
{"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD, 0 },
|
||||||
{"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE},
|
{"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE, 0 },
|
||||||
{"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3},
|
{"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3, 0 },
|
||||||
{"GL_ARB_texture_float", ARB_TEXTURE_FLOAT},
|
{"GL_ARB_texture_float", ARB_TEXTURE_FLOAT, 0 },
|
||||||
{"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT},
|
{"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT, 0 },
|
||||||
{"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO},
|
{"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO, 0 },
|
||||||
{"GL_ARB_vertex_blend", ARB_VERTEX_BLEND},
|
{"GL_ARB_vertex_blend", ARB_VERTEX_BLEND, 0 },
|
||||||
{"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT},
|
{"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT, 0 },
|
||||||
{"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM},
|
{"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM, 0 },
|
||||||
{"GL_ARB_vertex_shader", ARB_VERTEX_SHADER},
|
{"GL_ARB_vertex_shader", ARB_VERTEX_SHADER, 0 },
|
||||||
|
{"GL_ARB_shader_objects", ARB_SHADER_OBJECTS, 0 },
|
||||||
|
|
||||||
/* EXT */
|
/* EXT */
|
||||||
{"GL_EXT_blend_minmax", EXT_BLEND_MINMAX},
|
{"GL_EXT_blend_minmax", EXT_BLEND_MINMAX, 0 },
|
||||||
{"GL_EXT_fog_coord", EXT_FOG_COORD},
|
{"GL_EXT_fog_coord", EXT_FOG_COORD, 0 },
|
||||||
{"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT},
|
{"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT, 0 },
|
||||||
{"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT},
|
{"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT, 0 },
|
||||||
{"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE},
|
{"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE, 0 },
|
||||||
{"GL_EXT_point_parameters", EXT_POINT_PARAMETERS},
|
{"GL_EXT_point_parameters", EXT_POINT_PARAMETERS, 0 },
|
||||||
{"GL_EXT_secondary_color", EXT_SECONDARY_COLOR},
|
{"GL_EXT_secondary_color", EXT_SECONDARY_COLOR, 0 },
|
||||||
{"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE},
|
{"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE, 0 },
|
||||||
{"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP},
|
{"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP, 0 },
|
||||||
{"GL_EXT_texture3D", EXT_TEXTURE3D},
|
{"GL_EXT_texture3D", EXT_TEXTURE3D, MAKEDWORD_VERSION(1, 2) },
|
||||||
{"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC},
|
{"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC, 0 },
|
||||||
{"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD},
|
{"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD, 0 },
|
||||||
{"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE},
|
{"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE, 0 },
|
||||||
{"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3},
|
{"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3, 0 },
|
||||||
{"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB},
|
{"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB, 0 },
|
||||||
{"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC},
|
{"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC, 0 },
|
||||||
{"GL_EXT_texture_lod", EXT_TEXTURE_LOD},
|
{"GL_EXT_texture_lod", EXT_TEXTURE_LOD, 0 },
|
||||||
{"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS},
|
{"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS, 0 },
|
||||||
{"GL_EXT_vertex_shader", EXT_VERTEX_SHADER},
|
{"GL_EXT_vertex_shader", EXT_VERTEX_SHADER, 0 },
|
||||||
{"GL_EXT_vertex_weighting", EXT_VERTEX_WEIGHTING},
|
{"GL_EXT_vertex_weighting", EXT_VERTEX_WEIGHTING, 0 },
|
||||||
|
|
||||||
/* NV */
|
/* NV */
|
||||||
{"GL_NV_half_float", NV_HALF_FLOAT},
|
{"GL_NV_half_float", NV_HALF_FLOAT, 0 },
|
||||||
{"GL_NV_fence", NV_FENCE},
|
{"GL_NV_fence", NV_FENCE, 0 },
|
||||||
{"GL_NV_fog_distance", NV_FOG_DISTANCE},
|
{"GL_NV_fog_distance", NV_FOG_DISTANCE, 0 },
|
||||||
{"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM},
|
{"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM, 0 },
|
||||||
{"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2},
|
{"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2, 0 },
|
||||||
{"GL_NV_register_combiners", NV_REGISTER_COMBINERS},
|
{"GL_NV_register_combiners", NV_REGISTER_COMBINERS, 0 },
|
||||||
{"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2},
|
{"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2, 0 },
|
||||||
{"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION},
|
{"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION, 0 },
|
||||||
{"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4},
|
{"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4, 0 },
|
||||||
{"GL_NV_texture_shader", NV_TEXTURE_SHADER},
|
{"GL_NV_texture_shader", NV_TEXTURE_SHADER, 0 },
|
||||||
{"GL_NV_texture_shader2", NV_TEXTURE_SHADER2},
|
{"GL_NV_texture_shader2", NV_TEXTURE_SHADER2, 0 },
|
||||||
{"GL_NV_texture_shader3", NV_TEXTURE_SHADER3},
|
{"GL_NV_texture_shader3", NV_TEXTURE_SHADER3, 0 },
|
||||||
{"GL_NV_occlusion_query", NV_OCCLUSION_QUERY},
|
{"GL_NV_occlusion_query", NV_OCCLUSION_QUERY, 0 },
|
||||||
{"GL_NV_vertex_program", NV_VERTEX_PROGRAM},
|
{"GL_NV_vertex_program", NV_VERTEX_PROGRAM, 0 },
|
||||||
{"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1},
|
{"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1, 0 },
|
||||||
{"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2},
|
{"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2, 0 },
|
||||||
{"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3},
|
{"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3, 0 },
|
||||||
{"GL_NV_depth_clamp", NV_DEPTH_CLAMP},
|
{"GL_NV_depth_clamp", NV_DEPTH_CLAMP, 0 },
|
||||||
|
|
||||||
/* SGI */
|
/* SGI */
|
||||||
{"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP},
|
{"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP, 0 },
|
||||||
};
|
};
|
||||||
|
|
||||||
/**********************************************************
|
/**********************************************************
|
||||||
|
@ -441,6 +443,17 @@ static inline BOOL test_arb_vs_offset_limit(WineD3D_GL_Info *gl_info) {
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static DWORD ver_for_ext(GL_SupportedExt ext)
|
||||||
|
{
|
||||||
|
unsigned int i;
|
||||||
|
for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
|
||||||
|
if(EXTENSION_MAP[i].extension == ext) {
|
||||||
|
return EXTENSION_MAP[i].version;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
|
BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
|
||||||
const char *GL_Extensions = NULL;
|
const char *GL_Extensions = NULL;
|
||||||
const char *WGL_Extensions = NULL;
|
const char *WGL_Extensions = NULL;
|
||||||
|
@ -623,12 +636,6 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
|
||||||
gl_info->vs_arb_constantsF = 0;
|
gl_info->vs_arb_constantsF = 0;
|
||||||
gl_info->ps_arb_constantsF = 0;
|
gl_info->ps_arb_constantsF = 0;
|
||||||
|
|
||||||
/* Now work out what GL support this card really has */
|
|
||||||
#define USE_GL_FUNC(type, pfn) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
|
|
||||||
GL_EXT_FUNCS_GEN;
|
|
||||||
WGL_EXT_FUNCS_GEN;
|
|
||||||
#undef USE_GL_FUNC
|
|
||||||
|
|
||||||
/* Retrieve opengl defaults */
|
/* Retrieve opengl defaults */
|
||||||
glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
|
glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
|
||||||
gl_info->max_clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
|
gl_info->max_clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
|
||||||
|
@ -685,6 +692,31 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
/* Now work out what GL support this card really has */
|
||||||
|
#define USE_GL_FUNC(type, pfn, ext, replace) { \
|
||||||
|
DWORD ver = ver_for_ext(ext); \
|
||||||
|
if(gl_info->supported[ext]) gl_info->pfn = (type) pwglGetProcAddress(#pfn); \
|
||||||
|
else if(ver && ver <= gl_info->gl_driver_version) gl_info->pfn = (type) pwglGetProcAddress(#replace); \
|
||||||
|
else gl_info->pfn = NULL; \
|
||||||
|
}
|
||||||
|
GL_EXT_FUNCS_GEN;
|
||||||
|
#undef USE_GL_FUNC
|
||||||
|
|
||||||
|
#define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
|
||||||
|
WGL_EXT_FUNCS_GEN;
|
||||||
|
#undef USE_GL_FUNC
|
||||||
|
|
||||||
|
/* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
|
||||||
|
* loading the functions, otherwise the code above will load the extension entry points instead of the
|
||||||
|
* core functions, which may not work
|
||||||
|
*/
|
||||||
|
for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
|
||||||
|
if (gl_info->supported[EXTENSION_MAP[i].extension] == FALSE &&
|
||||||
|
EXTENSION_MAP[i].version <= gl_info->gl_driver_version && EXTENSION_MAP[i].version) {
|
||||||
|
TRACE_(d3d_caps)(" GL CORE: %s support\n", EXTENSION_MAP[i].extension_string);
|
||||||
|
gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if (gl_info->supported[APPLE_FENCE]) {
|
if (gl_info->supported[APPLE_FENCE]) {
|
||||||
/* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
|
/* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
|
||||||
|
@ -726,7 +758,7 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
|
||||||
if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
|
if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
|
||||||
GLint tmp;
|
GLint tmp;
|
||||||
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
|
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
|
||||||
gl_info->max_fragment_samplers = min(8, tmp);
|
gl_info->max_fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
|
||||||
} else {
|
} else {
|
||||||
gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
|
gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
|
||||||
}
|
}
|
||||||
|
@ -1070,9 +1102,10 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
|
||||||
} else if(WINE_D3D7_CAPABLE(gl_info)) {
|
} else if(WINE_D3D7_CAPABLE(gl_info)) {
|
||||||
gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
|
gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
|
||||||
vidmem = 32; /* There are models with up to 64MB */
|
vidmem = 32; /* There are models with up to 64MB */
|
||||||
} else
|
} else {
|
||||||
gl_info->gl_card = CARD_ATI_RAGE_128PRO;
|
gl_info->gl_card = CARD_ATI_RAGE_128PRO;
|
||||||
vidmem = 16; /* There are 16-32MB models */
|
vidmem = 16; /* There are 16-32MB models */
|
||||||
|
}
|
||||||
break;
|
break;
|
||||||
case VENDOR_INTEL:
|
case VENDOR_INTEL:
|
||||||
if (strstr(gl_info->gl_renderer, "915GM")) {
|
if (strstr(gl_info->gl_renderer, "915GM")) {
|
||||||
|
@ -2662,6 +2695,7 @@ static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter,
|
||||||
object->adapter = numAdapters ? &Adapters[Adapter] : NULL;
|
object->adapter = numAdapters ? &Adapters[Adapter] : NULL;
|
||||||
IWineD3D_AddRef(object->wineD3D);
|
IWineD3D_AddRef(object->wineD3D);
|
||||||
object->parent = parent;
|
object->parent = parent;
|
||||||
|
list_init(&object->resources);
|
||||||
|
|
||||||
if(This->dxVersion == 7) {
|
if(This->dxVersion == 7) {
|
||||||
object->surface_alignment = 8;
|
object->surface_alignment = 8;
|
||||||
|
@ -2825,10 +2859,7 @@ BOOL InitAdapters(void) {
|
||||||
#else
|
#else
|
||||||
#define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
|
#define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
|
||||||
/* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
|
/* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
|
||||||
|
|
||||||
/* ReactOS hack, we do not have wglGetProcAddress implement in gdi32.dll yet, */
|
|
||||||
mod_gl = GetModuleHandleA("opengl32.dll");
|
mod_gl = GetModuleHandleA("opengl32.dll");
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -630,7 +630,7 @@ static void depth_blt(IWineD3DDevice *iface, GLuint texture) {
|
||||||
|
|
||||||
static void depth_copy(IWineD3DDevice *iface) {
|
static void depth_copy(IWineD3DDevice *iface) {
|
||||||
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
|
||||||
IWineD3DSurfaceImpl *depth_stencil = (IWineD3DSurfaceImpl *)This->depthStencilBuffer;
|
IWineD3DSurfaceImpl *depth_stencil = (IWineD3DSurfaceImpl *)This->auto_depth_stencil_buffer;
|
||||||
|
|
||||||
/* Only copy the depth buffer if there is one. */
|
/* Only copy the depth buffer if there is one. */
|
||||||
if (!depth_stencil) return;
|
if (!depth_stencil) return;
|
||||||
|
|
|
@ -199,6 +199,11 @@ static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL
|
||||||
}
|
}
|
||||||
checkGLcall("glUniform4fvARB()");
|
checkGLcall("glUniform4fvARB()");
|
||||||
|
|
||||||
|
if(!This->baseShader.load_local_constsF) {
|
||||||
|
TRACE("No need to load local float constants for this shader\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
/* Load immediate constants */
|
/* Load immediate constants */
|
||||||
if (TRACE_ON(d3d_shader)) {
|
if (TRACE_ON(d3d_shader)) {
|
||||||
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
|
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
|
||||||
|
@ -288,7 +293,7 @@ static void shader_glsl_load_constantsB(
|
||||||
for (i=0; i<max_constants; ++i) {
|
for (i=0; i<max_constants; ++i) {
|
||||||
if (NULL == constants_set || constants_set[i]) {
|
if (NULL == constants_set || constants_set[i]) {
|
||||||
|
|
||||||
TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i*4]);
|
TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i]);
|
||||||
|
|
||||||
/* TODO: Benchmark and see if it would be beneficial to store the
|
/* TODO: Benchmark and see if it would be beneficial to store the
|
||||||
* locations of the constants to avoid looking up each time */
|
* locations of the constants to avoid looking up each time */
|
||||||
|
@ -296,7 +301,7 @@ static void shader_glsl_load_constantsB(
|
||||||
tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
|
tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
|
||||||
if (tmp_loc != -1) {
|
if (tmp_loc != -1) {
|
||||||
/* We found this uniform name in the program - go ahead and send the data */
|
/* We found this uniform name in the program - go ahead and send the data */
|
||||||
GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i*4]));
|
GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i]));
|
||||||
checkGLcall("glUniform1ivARB");
|
checkGLcall("glUniform1ivARB");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -464,6 +469,7 @@ void shader_generate_glsl_declarations(
|
||||||
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
|
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
|
||||||
int i;
|
int i;
|
||||||
unsigned int extra_constants_needed = 0;
|
unsigned int extra_constants_needed = 0;
|
||||||
|
local_constant* lconst;
|
||||||
|
|
||||||
/* There are some minor differences between pixel and vertex shaders */
|
/* There are some minor differences between pixel and vertex shaders */
|
||||||
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
|
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
|
||||||
|
@ -527,9 +533,9 @@ void shader_generate_glsl_declarations(
|
||||||
extra_constants_needed++;
|
extra_constants_needed++;
|
||||||
} else {
|
} else {
|
||||||
ps_impl->srgb_mode_hardcoded = 1;
|
ps_impl->srgb_mode_hardcoded = 1;
|
||||||
shader_addline(buffer, "const vec4 srgb_mul_low = {%f, %f, %f, %f};\n",
|
shader_addline(buffer, "const vec4 srgb_mul_low = vec4(%f, %f, %f, %f);\n",
|
||||||
srgb_mul_low, srgb_mul_low, srgb_mul_low, srgb_mul_low);
|
srgb_mul_low, srgb_mul_low, srgb_mul_low, srgb_mul_low);
|
||||||
shader_addline(buffer, "const vec4 srgb_comparison = {%f, %f, %f, %f};\n",
|
shader_addline(buffer, "const vec4 srgb_comparison = vec4(%f, %f, %f, %f);\n",
|
||||||
srgb_cmp, srgb_cmp, srgb_cmp, srgb_cmp);
|
srgb_cmp, srgb_cmp, srgb_cmp, srgb_cmp);
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
|
@ -551,7 +557,7 @@ void shader_generate_glsl_declarations(
|
||||||
* actually used, only the max limit of the shader version
|
* actually used, only the max limit of the shader version
|
||||||
*/
|
*/
|
||||||
FIXME("Cannot find a free uniform for vpos correction params\n");
|
FIXME("Cannot find a free uniform for vpos correction params\n");
|
||||||
shader_addline(buffer, "const vec4 ycorrection = {%f, %f, 0.0, 0.0};\n",
|
shader_addline(buffer, "const vec4 ycorrection = vec4(%f, %f, 0.0, 0.0);\n",
|
||||||
device->render_offscreen ? 0.0 : ((IWineD3DSurfaceImpl *) device->render_targets[0])->currentDesc.Height,
|
device->render_offscreen ? 0.0 : ((IWineD3DSurfaceImpl *) device->render_targets[0])->currentDesc.Height,
|
||||||
device->render_offscreen ? 1.0 : -1.0);
|
device->render_offscreen ? 1.0 : -1.0);
|
||||||
}
|
}
|
||||||
|
@ -640,6 +646,15 @@ void shader_generate_glsl_declarations(
|
||||||
shader_addline(buffer, "vec4 tmp0;\n");
|
shader_addline(buffer, "vec4 tmp0;\n");
|
||||||
shader_addline(buffer, "vec4 tmp1;\n");
|
shader_addline(buffer, "vec4 tmp1;\n");
|
||||||
|
|
||||||
|
/* Hardcodeable local constants */
|
||||||
|
if(!This->baseShader.load_local_constsF) {
|
||||||
|
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
|
||||||
|
float *value = (float *) lconst->value;
|
||||||
|
shader_addline(buffer, "const vec4 LC%u = vec4(%f, %f, %f, %f);\n", lconst->idx,
|
||||||
|
value[0], value[1], value[2], value[3]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/* Start the main program */
|
/* Start the main program */
|
||||||
shader_addline(buffer, "void main() {\n");
|
shader_addline(buffer, "void main() {\n");
|
||||||
if(pshader && reg_maps->vpos) {
|
if(pshader && reg_maps->vpos) {
|
||||||
|
@ -734,6 +749,17 @@ static void shader_glsl_gen_modifier (
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static BOOL constant_is_local(IWineD3DBaseShaderImpl* This, DWORD reg) {
|
||||||
|
local_constant* lconst;
|
||||||
|
|
||||||
|
if(This->baseShader.load_local_constsF) return FALSE;
|
||||||
|
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
|
||||||
|
if(lconst->idx == reg) return TRUE;
|
||||||
|
}
|
||||||
|
return FALSE;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
/** Writes the GLSL variable name that corresponds to the register that the
|
/** Writes the GLSL variable name that corresponds to the register that the
|
||||||
* DX opcode parameter is trying to access */
|
* DX opcode parameter is trying to access */
|
||||||
static void shader_glsl_get_register_name(
|
static void shader_glsl_get_register_name(
|
||||||
|
@ -819,8 +845,13 @@ static void shader_glsl_get_register_name(
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
} else
|
} else {
|
||||||
sprintf(tmpStr, "%s[%u]", prefix, reg);
|
if(constant_is_local(This, reg)) {
|
||||||
|
sprintf(tmpStr, "LC%u", reg);
|
||||||
|
} else {
|
||||||
|
sprintf(tmpStr, "%s[%u]", prefix, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
@ -1532,9 +1563,17 @@ void shader_glsl_compare(SHADER_OPCODE_ARG* arg) {
|
||||||
} else {
|
} else {
|
||||||
switch(arg->opcode->opcode) {
|
switch(arg->opcode->opcode) {
|
||||||
case WINED3DSIO_SLT:
|
case WINED3DSIO_SLT:
|
||||||
shader_addline(arg->buffer, "step(%s, %s));\n", src0_param.param_str, src1_param.param_str);
|
/* Step(src0, src1) is not suitable here because if src0 == src1 SLT is supposed,
|
||||||
|
* to return 0.0 but step returns 1.0 because step is not < x
|
||||||
|
* An alternative is a bvec compare padded with an unused secound component.
|
||||||
|
* step(src1 * -1.0, src0 * -1.0) is not an option because it suffers from the same
|
||||||
|
* issue. Playing with not() is not possible either because not() does not accept
|
||||||
|
* a scalar.
|
||||||
|
*/
|
||||||
|
shader_addline(arg->buffer, "(%s < %s) ? 1.0 : 0.0);\n", src0_param.param_str, src1_param.param_str);
|
||||||
break;
|
break;
|
||||||
case WINED3DSIO_SGE:
|
case WINED3DSIO_SGE:
|
||||||
|
/* Here we can use the step() function and safe a conditional */
|
||||||
shader_addline(arg->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
|
shader_addline(arg->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
|
@ -3137,10 +3176,44 @@ static void shader_glsl_cleanup(IWineD3DDevice *iface) {
|
||||||
GL_EXTCALL(glUseProgramObjectARB(0));
|
GL_EXTCALL(glUseProgramObjectARB(0));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void shader_glsl_destroy(IWineD3DBaseShader *iface) {
|
||||||
|
struct list *linked_programs;
|
||||||
|
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) iface;
|
||||||
|
WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *) This->baseShader.device)->adapter->gl_info;
|
||||||
|
|
||||||
|
/* Note: Do not use QueryInterface here to find out which shader type this is because this code
|
||||||
|
* can be called from IWineD3DBaseShader::Release
|
||||||
|
*/
|
||||||
|
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
|
||||||
|
|
||||||
|
if(This->baseShader.prgId == 0) return;
|
||||||
|
linked_programs = &This->baseShader.linked_programs;
|
||||||
|
|
||||||
|
TRACE("Deleting linked programs\n");
|
||||||
|
if (linked_programs->next) {
|
||||||
|
struct glsl_shader_prog_link *entry, *entry2;
|
||||||
|
|
||||||
|
if(pshader) {
|
||||||
|
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, pshader_entry) {
|
||||||
|
delete_glsl_program_entry(This->baseShader.device, entry);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, vshader_entry) {
|
||||||
|
delete_glsl_program_entry(This->baseShader.device, entry);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TRACE("Deleting shader object %u\n", This->baseShader.prgId);
|
||||||
|
GL_EXTCALL(glDeleteObjectARB(This->baseShader.prgId));
|
||||||
|
checkGLcall("glDeleteObjectARB");
|
||||||
|
}
|
||||||
|
|
||||||
const shader_backend_t glsl_shader_backend = {
|
const shader_backend_t glsl_shader_backend = {
|
||||||
&shader_glsl_select,
|
&shader_glsl_select,
|
||||||
&shader_glsl_select_depth_blt,
|
&shader_glsl_select_depth_blt,
|
||||||
&shader_glsl_load_constants,
|
&shader_glsl_load_constants,
|
||||||
&shader_glsl_cleanup,
|
&shader_glsl_cleanup,
|
||||||
&shader_glsl_color_correction
|
&shader_glsl_color_correction,
|
||||||
|
&shader_glsl_destroy
|
||||||
};
|
};
|
||||||
|
|
|
@ -107,7 +107,7 @@ static HRESULT WINAPI IWineD3DPaletteImpl_GetEntries(IWineD3DPalette *iface, DW
|
||||||
static HRESULT WINAPI IWineD3DPaletteImpl_SetEntries(IWineD3DPalette *iface, DWORD Flags, DWORD Start, DWORD Count, PALETTEENTRY *PalEnt)
|
static HRESULT WINAPI IWineD3DPaletteImpl_SetEntries(IWineD3DPalette *iface, DWORD Flags, DWORD Start, DWORD Count, PALETTEENTRY *PalEnt)
|
||||||
{
|
{
|
||||||
IWineD3DPaletteImpl *This = (IWineD3DPaletteImpl *)iface;
|
IWineD3DPaletteImpl *This = (IWineD3DPaletteImpl *)iface;
|
||||||
ResourceList *res;
|
IWineD3DResourceImpl *res;
|
||||||
|
|
||||||
TRACE("(%p)->(%08x,%d,%d,%p)\n",This,Flags,Start,Count,PalEnt);
|
TRACE("(%p)->(%08x,%d,%d,%p)\n",This,Flags,Start,Count,PalEnt);
|
||||||
|
|
||||||
|
@ -134,11 +134,11 @@ static HRESULT WINAPI IWineD3DPaletteImpl_SetEntries(IWineD3DPalette *iface, DW
|
||||||
|
|
||||||
/* If the palette is attached to the render target, update all render targets */
|
/* If the palette is attached to the render target, update all render targets */
|
||||||
|
|
||||||
for(res = This->wineD3DDevice->resources; res != NULL; res=res->next) {
|
LIST_FOR_EACH_ENTRY(res, &This->wineD3DDevice->resources, IWineD3DResourceImpl, resource.resource_list_entry) {
|
||||||
if(IWineD3DResource_GetType(res->resource) == WINED3DRTYPE_SURFACE) {
|
if(IWineD3DResource_GetType((IWineD3DResource *) res) == WINED3DRTYPE_SURFACE) {
|
||||||
IWineD3DSurfaceImpl *impl = (IWineD3DSurfaceImpl *) res->resource;
|
IWineD3DSurfaceImpl *impl = (IWineD3DSurfaceImpl *) res;
|
||||||
if(impl->palette == This)
|
if(impl->palette == This)
|
||||||
IWineD3DSurface_RealizePalette( (IWineD3DSurface *) res->resource);
|
IWineD3DSurface_RealizePalette((IWineD3DSurface *) res);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -42,62 +42,17 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define GLNAME_REQUIRE_GLSL ((const char *)1)
|
#define GLNAME_REQUIRE_GLSL ((const char *)1)
|
||||||
/* *******************************************
|
|
||||||
IWineD3DPixelShader IUnknown parts follow
|
static HRESULT WINAPI IWineD3DPixelShaderImpl_QueryInterface(IWineD3DPixelShader *iface, REFIID riid, LPVOID *ppobj) {
|
||||||
******************************************* */
|
return IWineD3DBaseShaderImpl_QueryInterface((IWineD3DBaseShader *) iface, riid, ppobj);
|
||||||
static HRESULT WINAPI IWineD3DPixelShaderImpl_QueryInterface(IWineD3DPixelShader *iface, REFIID riid, LPVOID *ppobj)
|
|
||||||
{
|
|
||||||
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
|
|
||||||
TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
|
|
||||||
if (IsEqualGUID(riid, &IID_IUnknown)
|
|
||||||
|| IsEqualGUID(riid, &IID_IWineD3DBase)
|
|
||||||
|| IsEqualGUID(riid, &IID_IWineD3DBaseShader)
|
|
||||||
|| IsEqualGUID(riid, &IID_IWineD3DPixelShader)) {
|
|
||||||
IUnknown_AddRef(iface);
|
|
||||||
*ppobj = This;
|
|
||||||
return S_OK;
|
|
||||||
}
|
|
||||||
*ppobj = NULL;
|
|
||||||
return E_NOINTERFACE;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static ULONG WINAPI IWineD3DPixelShaderImpl_AddRef(IWineD3DPixelShader *iface) {
|
static ULONG WINAPI IWineD3DPixelShaderImpl_AddRef(IWineD3DPixelShader *iface) {
|
||||||
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
|
return IWineD3DBaseShaderImpl_AddRef((IWineD3DBaseShader *) iface);
|
||||||
TRACE("(%p) : AddRef increasing from %d\n", This, This->ref);
|
|
||||||
return InterlockedIncrement(&This->ref);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void destroy_glsl_pshader(IWineD3DPixelShaderImpl *This) {
|
|
||||||
struct list *linked_programs = &This->baseShader.linked_programs;
|
|
||||||
|
|
||||||
TRACE("Deleting linked programs\n");
|
|
||||||
if (linked_programs->next) {
|
|
||||||
struct glsl_shader_prog_link *entry, *entry2;
|
|
||||||
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, pshader_entry) {
|
|
||||||
delete_glsl_program_entry(This->baseShader.device, entry);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
TRACE("Deleting shader object %u\n", This->baseShader.prgId);
|
|
||||||
GL_EXTCALL(glDeleteObjectARB(This->baseShader.prgId));
|
|
||||||
checkGLcall("glDeleteObjectARB");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static ULONG WINAPI IWineD3DPixelShaderImpl_Release(IWineD3DPixelShader *iface) {
|
static ULONG WINAPI IWineD3DPixelShaderImpl_Release(IWineD3DPixelShader *iface) {
|
||||||
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
|
return IWineD3DBaseShaderImpl_Release((IWineD3DBaseShader *) iface);
|
||||||
ULONG ref;
|
|
||||||
TRACE("(%p) : Releasing from %d\n", This, This->ref);
|
|
||||||
ref = InterlockedDecrement(&This->ref);
|
|
||||||
if (ref == 0) {
|
|
||||||
if (This->baseShader.shader_mode == SHADER_GLSL && This->baseShader.prgId != 0) {
|
|
||||||
destroy_glsl_pshader(This);
|
|
||||||
}
|
|
||||||
shader_delete_constant_list(&This->baseShader.constantsF);
|
|
||||||
shader_delete_constant_list(&This->baseShader.constantsB);
|
|
||||||
shader_delete_constant_list(&This->baseShader.constantsI);
|
|
||||||
HeapFree(GetProcessHeap(), 0, This);
|
|
||||||
}
|
|
||||||
return ref;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* *******************************************
|
/* *******************************************
|
||||||
|
@ -586,6 +541,7 @@ static HRESULT WINAPI IWineD3DPixelShaderImpl_SetFunction(IWineD3DPixelShader *i
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
This->baseShader.load_local_constsF = FALSE;
|
||||||
|
|
||||||
This->baseShader.shader_mode = deviceImpl->ps_selected_mode;
|
This->baseShader.shader_mode = deviceImpl->ps_selected_mode;
|
||||||
|
|
||||||
|
@ -675,9 +631,7 @@ static HRESULT WINAPI IWineD3DPixelShaderImpl_CompileShader(IWineD3DPixelShader
|
||||||
This->baseShader.recompile_count++;
|
This->baseShader.recompile_count++;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (This->baseShader.shader_mode == SHADER_GLSL && This->baseShader.prgId != 0) {
|
deviceImpl->shader_backend->shader_destroy((IWineD3DBaseShader *) iface);
|
||||||
destroy_glsl_pshader(This);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* We don't need to compile */
|
/* We don't need to compile */
|
||||||
|
|
|
@ -248,12 +248,11 @@ HRESULT WINAPI IWineD3DResourceImpl_GetParent(IWineD3DResource *iface, IUnknown
|
||||||
return WINED3D_OK;
|
return WINED3D_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
void dumpResources(ResourceList *resources) {
|
void dumpResources(struct list *list) {
|
||||||
ResourceList *iterator = resources;
|
IWineD3DResourceImpl *resource;
|
||||||
|
|
||||||
while(iterator) {
|
LIST_FOR_EACH_ENTRY(resource, list, IWineD3DResourceImpl, resource.resource_list_entry) {
|
||||||
FIXME("Leftover resource %p with type %d,%s\n", iterator->resource, IWineD3DResource_GetType(iterator->resource), debug_d3dresourcetype(IWineD3DResource_GetType(iterator->resource)));
|
FIXME("Leftover resource %p with type %d,%s\n", resource, IWineD3DResource_GetType((IWineD3DResource *) resource), debug_d3dresourcetype(IWineD3DResource_GetType((IWineD3DResource *) resource)));
|
||||||
iterator = iterator->next;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -107,6 +107,7 @@ static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock, Wine
|
||||||
static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
|
static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
|
||||||
/* No z test without depth stencil buffers */
|
/* No z test without depth stencil buffers */
|
||||||
if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
|
if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
|
||||||
|
TRACE("No Z buffer - disabling depth test\n");
|
||||||
glDisable(GL_DEPTH_TEST); /* This also disables z writing in gl */
|
glDisable(GL_DEPTH_TEST); /* This also disables z writing in gl */
|
||||||
checkGLcall("glDisable GL_DEPTH_TEST");
|
checkGLcall("glDisable GL_DEPTH_TEST");
|
||||||
return;
|
return;
|
||||||
|
@ -1903,6 +1904,7 @@ static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3D
|
||||||
static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
|
static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
|
||||||
DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
|
DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
|
||||||
DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[texUnit];
|
DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[texUnit];
|
||||||
|
BOOL generated;
|
||||||
|
|
||||||
/* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
|
/* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
|
||||||
if(use_vs(stateblock->wineD3DDevice) ||
|
if(use_vs(stateblock->wineD3DDevice) ||
|
||||||
|
@ -1924,15 +1926,24 @@ static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, W
|
||||||
WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
generated = (stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU;
|
||||||
|
|
||||||
set_texture_matrix((float *)&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
|
set_texture_matrix((float *)&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
|
||||||
stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
|
stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
|
||||||
(stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU,
|
generated,
|
||||||
context->last_was_rhw,
|
context->last_was_rhw,
|
||||||
stateblock->wineD3DDevice->strided_streams.u.s.texCoords[texUnit].dwStride ?
|
stateblock->wineD3DDevice->strided_streams.u.s.texCoords[texUnit].dwStride ?
|
||||||
stateblock->wineD3DDevice->strided_streams.u.s.texCoords[texUnit].dwType:
|
stateblock->wineD3DDevice->strided_streams.u.s.texCoords[texUnit].dwType:
|
||||||
WINED3DDECLTYPE_UNUSED);
|
WINED3DDECLTYPE_UNUSED);
|
||||||
|
|
||||||
|
/* The sampler applying function calls us if this changes */
|
||||||
|
if(context->lastWasPow2Texture[texUnit] && stateblock->textures[texUnit]) {
|
||||||
|
if(generated) {
|
||||||
|
FIXME("Non-power2 texture being used with generated texture coords\n");
|
||||||
|
}
|
||||||
|
TRACE("Non power two matrix multiply fixup\n");
|
||||||
|
glMultMatrixf(((IWineD3DTextureImpl *) stateblock->textures[texUnit])->baseTexture.pow2Matrix);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void unloadTexCoords(IWineD3DStateBlockImpl *stateblock) {
|
static void unloadTexCoords(IWineD3DStateBlockImpl *stateblock) {
|
||||||
|
@ -2288,19 +2299,19 @@ static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DCont
|
||||||
*/
|
*/
|
||||||
if(!GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) && sampler < MAX_TEXTURES) {
|
if(!GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) && sampler < MAX_TEXTURES) {
|
||||||
if(stateblock->textureDimensions[sampler] == GL_TEXTURE_2D) {
|
if(stateblock->textureDimensions[sampler] == GL_TEXTURE_2D) {
|
||||||
if(((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorX != 1.0 ||
|
if(((IWineD3DTextureImpl *) stateblock->textures[sampler])->baseTexture.pow2Matrix[0] != 1.0 ||
|
||||||
((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorY != 1.0 ) {
|
((IWineD3DTextureImpl *) stateblock->textures[sampler])->baseTexture.pow2Matrix[5] != 1.0 ) {
|
||||||
texIsPow2 = TRUE;
|
texIsPow2 = TRUE;
|
||||||
}
|
}
|
||||||
} else if(stateblock->textureDimensions[sampler] == GL_TEXTURE_CUBE_MAP_ARB) {
|
} else if(stateblock->textureDimensions[sampler] == GL_TEXTURE_CUBE_MAP_ARB) {
|
||||||
if(((IWineD3DCubeTextureImpl *) stateblock->textures[sampler])->pow2scalingFactor != 1.0) {
|
if(((IWineD3DCubeTextureImpl *) stateblock->textures[sampler])->baseTexture.pow2Matrix[0] != 1.0) {
|
||||||
texIsPow2 = TRUE;
|
texIsPow2 = TRUE;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if(texIsPow2 || context->lastWasPow2Texture[sampler]) {
|
if(texIsPow2 || context->lastWasPow2Texture[sampler]) {
|
||||||
transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock, context);
|
|
||||||
context->lastWasPow2Texture[sampler] = texIsPow2;
|
context->lastWasPow2Texture[sampler] = texIsPow2;
|
||||||
|
transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock, context);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -3425,6 +3436,19 @@ static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock, W
|
||||||
FIXME("Clipping not supported with vertex shaders\n");
|
FIXME("Clipping not supported with vertex shaders\n");
|
||||||
warned = TRUE;
|
warned = TRUE;
|
||||||
}
|
}
|
||||||
|
if(wasrhw) {
|
||||||
|
/* Apply the transform matrices when switching from rhw drawing to vertex shaders. Vertex
|
||||||
|
* shaders themselves do not need it it, but the matrices are not reapplied automatically when
|
||||||
|
* switching back from vertex shaders to fixed function processing. So make sure we leave the
|
||||||
|
* fixed function vertex processing states back in a sane state before switching to shaders
|
||||||
|
*/
|
||||||
|
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
|
||||||
|
transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
|
||||||
|
}
|
||||||
|
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
|
||||||
|
transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -3597,12 +3621,15 @@ static void light(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContex
|
||||||
}
|
}
|
||||||
|
|
||||||
static void scissorrect(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
|
static void scissorrect(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
|
||||||
IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) stateblock->wineD3DDevice->swapchains[0];
|
|
||||||
RECT *pRect = &stateblock->scissorRect;
|
RECT *pRect = &stateblock->scissorRect;
|
||||||
RECT windowRect;
|
RECT windowRect;
|
||||||
UINT winHeight;
|
UINT winHeight;
|
||||||
|
|
||||||
GetClientRect(swapchain->win_handle, &windowRect);
|
windowRect.left = 0;
|
||||||
|
windowRect.top = 0;
|
||||||
|
windowRect.right = ((IWineD3DSurfaceImpl *) stateblock->wineD3DDevice->render_targets[0])->currentDesc.Width;
|
||||||
|
windowRect.bottom = ((IWineD3DSurfaceImpl *) stateblock->wineD3DDevice->render_targets[0])->currentDesc.Height;
|
||||||
|
|
||||||
/* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
|
/* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
|
||||||
* Warning2: Even in windowed mode the coords are relative to the window, not the screen
|
* Warning2: Even in windowed mode the coords are relative to the window, not the screen
|
||||||
*/
|
*/
|
||||||
|
|
|
@ -1055,7 +1055,7 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_InitStartupStateBlock(IWineD3DStat
|
||||||
|
|
||||||
TRACE("Render states\n");
|
TRACE("Render states\n");
|
||||||
/* Render states: */
|
/* Render states: */
|
||||||
if (ThisDevice->depthStencilBuffer != NULL) {
|
if (ThisDevice->auto_depth_stencil_buffer != NULL) {
|
||||||
IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE, WINED3DZB_TRUE);
|
IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE, WINED3DZB_TRUE);
|
||||||
} else {
|
} else {
|
||||||
IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE, WINED3DZB_FALSE);
|
IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE, WINED3DZB_FALSE);
|
||||||
|
|
|
@ -57,7 +57,7 @@ static void surface_download_data(IWineD3DSurfaceImpl *This) {
|
||||||
checkGLcall("glActiveTextureARB");
|
checkGLcall("glActiveTextureARB");
|
||||||
}
|
}
|
||||||
IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_SAMPLER(0));
|
IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_SAMPLER(0));
|
||||||
IWineD3DSurface_PreLoad((IWineD3DSurface *) This);
|
IWineD3DSurface_BindTexture((IWineD3DSurface *) This);
|
||||||
|
|
||||||
if (This->resource.format == WINED3DFMT_DXT1 ||
|
if (This->resource.format == WINED3DFMT_DXT1 ||
|
||||||
This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3 ||
|
This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3 ||
|
||||||
|
@ -2186,6 +2186,30 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface *iface, BO
|
||||||
return WINED3D_OK;
|
return WINED3D_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void WINAPI IWineD3DSurfaceImpl_BindTexture(IWineD3DSurface *iface) {
|
||||||
|
/* TODO: check for locks */
|
||||||
|
IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
|
||||||
|
IWineD3DBaseTexture *baseTexture = NULL;
|
||||||
|
IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
|
||||||
|
|
||||||
|
TRACE("(%p)Checking to see if the container is a base texture\n", This);
|
||||||
|
if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
|
||||||
|
TRACE("Passing to container\n");
|
||||||
|
IWineD3DBaseTexture_BindTexture(baseTexture);
|
||||||
|
IWineD3DBaseTexture_Release(baseTexture);
|
||||||
|
} else {
|
||||||
|
TRACE("(%p) : Binding surface\n", This);
|
||||||
|
|
||||||
|
if(!device->isInDraw) {
|
||||||
|
ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
|
||||||
|
}
|
||||||
|
ENTER_GL();
|
||||||
|
glBindTexture(This->glDescription.target, This->glDescription.textureName);
|
||||||
|
LEAVE_GL();
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
#include <errno.h>
|
#include <errno.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
HRESULT WINAPI IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, const char* filename) {
|
HRESULT WINAPI IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, const char* filename) {
|
||||||
|
@ -3131,6 +3155,10 @@ static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *This, RECT *
|
||||||
checkGLcall("glDisable(GL_ALPHA_TEST)");
|
checkGLcall("glDisable(GL_ALPHA_TEST)");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* Flush in case the drawable is used by multiple GL contexts */
|
||||||
|
if(dstSwapchain && (dstSwapchain->num_contexts >= 2))
|
||||||
|
glFlush();
|
||||||
|
|
||||||
/* Unbind the texture */
|
/* Unbind the texture */
|
||||||
glBindTexture(GL_TEXTURE_2D, 0);
|
glBindTexture(GL_TEXTURE_2D, 0);
|
||||||
checkGLcall("glEnable glBindTexture");
|
checkGLcall("glEnable glBindTexture");
|
||||||
|
@ -3481,6 +3509,8 @@ struct coords {
|
||||||
static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl *This, const RECT *rect_in) {
|
static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl *This, const RECT *rect_in) {
|
||||||
struct coords coords[4];
|
struct coords coords[4];
|
||||||
RECT rect;
|
RECT rect;
|
||||||
|
IWineD3DSwapChain *swapchain = NULL;
|
||||||
|
HRESULT hr;
|
||||||
IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
|
IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
|
||||||
|
|
||||||
if(rect_in) {
|
if(rect_in) {
|
||||||
|
@ -3602,6 +3632,15 @@ static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl *This, const RECT
|
||||||
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
|
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
|
||||||
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
|
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
hr = IWineD3DSurface_GetContainer((IWineD3DSurface*)This, &IID_IWineD3DSwapChain, (void **) &swapchain);
|
||||||
|
if(hr == WINED3D_OK && swapchain) {
|
||||||
|
/* Make sure to flush the buffers. This is needed in apps like Red Alert II and Tiberian SUN that use multiple WGL contexts. */
|
||||||
|
if(((IWineD3DSwapChainImpl*)swapchain)->num_contexts >= 2)
|
||||||
|
glFlush();
|
||||||
|
|
||||||
|
IWineD3DSwapChain_Release(swapchain);
|
||||||
|
}
|
||||||
LEAVE_GL();
|
LEAVE_GL();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -3830,6 +3869,7 @@ const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
|
||||||
/* Internal use: */
|
/* Internal use: */
|
||||||
IWineD3DSurfaceImpl_AddDirtyRect,
|
IWineD3DSurfaceImpl_AddDirtyRect,
|
||||||
IWineD3DSurfaceImpl_LoadTexture,
|
IWineD3DSurfaceImpl_LoadTexture,
|
||||||
|
IWineD3DSurfaceImpl_BindTexture,
|
||||||
IWineD3DSurfaceImpl_SaveSnapshot,
|
IWineD3DSurfaceImpl_SaveSnapshot,
|
||||||
IWineD3DBaseSurfaceImpl_SetContainer,
|
IWineD3DBaseSurfaceImpl_SetContainer,
|
||||||
IWineD3DSurfaceImpl_SetGlTextureDesc,
|
IWineD3DSurfaceImpl_SetGlTextureDesc,
|
||||||
|
|
|
@ -1628,3 +1628,8 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DL
|
||||||
|
|
||||||
return WINED3D_OK;
|
return WINED3D_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void WINAPI IWineD3DBaseSurfaceImpl_BindTexture(IWineD3DSurface *iface) {
|
||||||
|
ERR("Should not be called on base texture\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
|
@ -805,6 +805,7 @@ const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
|
||||||
/* Internal use: */
|
/* Internal use: */
|
||||||
IWineGDISurfaceImpl_AddDirtyRect,
|
IWineGDISurfaceImpl_AddDirtyRect,
|
||||||
IWineGDISurfaceImpl_LoadTexture,
|
IWineGDISurfaceImpl_LoadTexture,
|
||||||
|
IWineD3DBaseSurfaceImpl_BindTexture,
|
||||||
IWineGDISurfaceImpl_SaveSnapshot,
|
IWineGDISurfaceImpl_SaveSnapshot,
|
||||||
IWineD3DBaseSurfaceImpl_SetContainer,
|
IWineD3DBaseSurfaceImpl_SetContainer,
|
||||||
IWineGDISurfaceImpl_SetGlTextureDesc,
|
IWineGDISurfaceImpl_SetGlTextureDesc,
|
||||||
|
|
|
@ -106,6 +106,9 @@ static void WINAPI IWineD3DSwapChainImpl_Destroy(IWineD3DSwapChain *iface, D3DCB
|
||||||
HeapFree(GetProcessHeap(), 0, This->backBuffer);
|
HeapFree(GetProcessHeap(), 0, This->backBuffer);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
for(i = 0; i < This->num_contexts; i++) {
|
||||||
|
DestroyContext(This->wineD3DDevice, This->context[i]);
|
||||||
|
}
|
||||||
/* Restore the screen resolution if we rendered in fullscreen
|
/* Restore the screen resolution if we rendered in fullscreen
|
||||||
* This will restore the screen resolution to what it was before creating the swapchain. In case of d3d8 and d3d9
|
* This will restore the screen resolution to what it was before creating the swapchain. In case of d3d8 and d3d9
|
||||||
* this will be the original desktop resolution. In case of d3d7 this will be a NOP because ddraw sets the resolution
|
* this will be the original desktop resolution. In case of d3d7 this will be a NOP because ddraw sets the resolution
|
||||||
|
@ -118,9 +121,6 @@ static void WINAPI IWineD3DSwapChainImpl_Destroy(IWineD3DSwapChain *iface, D3DCB
|
||||||
mode.Format = This->orig_fmt;
|
mode.Format = This->orig_fmt;
|
||||||
IWineD3DDevice_SetDisplayMode((IWineD3DDevice *) This->wineD3DDevice, 0, &mode);
|
IWineD3DDevice_SetDisplayMode((IWineD3DDevice *) This->wineD3DDevice, 0, &mode);
|
||||||
}
|
}
|
||||||
for(i = 0; i < This->num_contexts; i++) {
|
|
||||||
DestroyContext(This->wineD3DDevice, This->context[i]);
|
|
||||||
}
|
|
||||||
HeapFree(GetProcessHeap(), 0, This->context);
|
HeapFree(GetProcessHeap(), 0, This->context);
|
||||||
|
|
||||||
HeapFree(GetProcessHeap(), 0, This);
|
HeapFree(GetProcessHeap(), 0, This);
|
||||||
|
|
|
@ -213,39 +213,8 @@ static UINT WINAPI IWineD3DTextureImpl_GetTextureDimensions(IWineD3DTexture *ifa
|
||||||
static void WINAPI IWineD3DTextureImpl_ApplyStateChanges(IWineD3DTexture *iface,
|
static void WINAPI IWineD3DTextureImpl_ApplyStateChanges(IWineD3DTexture *iface,
|
||||||
const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1],
|
const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1],
|
||||||
const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]) {
|
const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]) {
|
||||||
IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
|
TRACE("(%p) : relay to BaseTexture\n", iface);
|
||||||
float matrix[16];
|
|
||||||
IWineD3DBaseTextureImpl_ApplyStateChanges((IWineD3DBaseTexture *)iface, textureStates, samplerStates);
|
IWineD3DBaseTextureImpl_ApplyStateChanges((IWineD3DBaseTexture *)iface, textureStates, samplerStates);
|
||||||
|
|
||||||
/** non-power2 fixups using texture matrix **/
|
|
||||||
if(This->pow2scalingFactorX != 1.0f || This->pow2scalingFactorY != 1.0f) {
|
|
||||||
/* Apply non-power2 mappings and texture offsets so long as the texture coords aren't projected or generated */
|
|
||||||
if(((textureStates[WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) == WINED3DTSS_TCI_PASSTHRU) &&
|
|
||||||
(~textureStates[WINED3DTSS_TEXTURETRANSFORMFLAGS] & WINED3DTTFF_PROJECTED)) {
|
|
||||||
glMatrixMode(GL_TEXTURE);
|
|
||||||
memset(matrix, 0 , sizeof(matrix));
|
|
||||||
matrix[0] = This->pow2scalingFactorX;
|
|
||||||
matrix[5] = This->pow2scalingFactorY;
|
|
||||||
#if 0 /* this isn't needed any more, I changed the translation in drawprim.c to 0.9/width instead of 1/width and everything lines up ok. left here as a reminder */
|
|
||||||
matrix[12] = -0.25f / (float)This->width;
|
|
||||||
matrix[13] = -0.75f / (float)This->height;
|
|
||||||
#endif
|
|
||||||
matrix[10] = 1;
|
|
||||||
matrix[15] = 1;
|
|
||||||
TRACE("(%p) Setup Matrix:\n", This);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[0], matrix[1], matrix[2], matrix[3]);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[4], matrix[5], matrix[6], matrix[7]);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[8], matrix[9], matrix[10], matrix[11]);
|
|
||||||
TRACE(" %f %f %f %f\n", matrix[12], matrix[13], matrix[14], matrix[15]);
|
|
||||||
TRACE("\n");
|
|
||||||
|
|
||||||
glMultMatrixf(matrix);
|
|
||||||
} else {
|
|
||||||
/* I don't expect nonpower 2 textures to be used with generated texture coordinates, but if they are present a fixme. */
|
|
||||||
FIXME("Non-power2 texture being used with generated texture coords\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* *******************************************
|
/* *******************************************
|
||||||
|
|
|
@ -120,7 +120,7 @@ static HRESULT WINAPI IWineD3DVertexDeclarationImpl_SetDeclaration(IWineD3DVerte
|
||||||
const WINED3DVERTEXELEMENT *elements, size_t element_count) {
|
const WINED3DVERTEXELEMENT *elements, size_t element_count) {
|
||||||
IWineD3DVertexDeclarationImpl *This = (IWineD3DVertexDeclarationImpl *)iface;
|
IWineD3DVertexDeclarationImpl *This = (IWineD3DVertexDeclarationImpl *)iface;
|
||||||
HRESULT hr = WINED3D_OK;
|
HRESULT hr = WINED3D_OK;
|
||||||
int i;
|
int i, j;
|
||||||
char isPreLoaded[MAX_STREAMS];
|
char isPreLoaded[MAX_STREAMS];
|
||||||
|
|
||||||
TRACE("(%p) : d3d version %d\n", This, ((IWineD3DImpl *)This->wineD3DDevice->wineD3D)->dxVersion);
|
TRACE("(%p) : d3d version %d\n", This, ((IWineD3DImpl *)This->wineD3DDevice->wineD3D)->dxVersion);
|
||||||
|
@ -162,8 +162,35 @@ static HRESULT WINAPI IWineD3DVertexDeclarationImpl_SetDeclaration(IWineD3DVerte
|
||||||
This->num_streams++;
|
This->num_streams++;
|
||||||
isPreLoaded[This->pDeclarationWine[i].Stream] = 1;
|
isPreLoaded[This->pDeclarationWine[i].Stream] = 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* Create a sorted array containing the attribute declarations that are of type
|
||||||
|
* D3DCOLOR. D3DCOLOR requires swizzling of the r and b component, and if the
|
||||||
|
* declaration of one attribute changes the vertex shader needs recompilation.
|
||||||
|
* Having a sorted array of the attributes allows efficient comparison of the
|
||||||
|
* declaration against a shader
|
||||||
|
*/
|
||||||
|
if(This->pDeclarationWine[i].Type == WINED3DDECLTYPE_D3DCOLOR) {
|
||||||
|
for(j = 0; j < This->num_swizzled_attribs; j++) {
|
||||||
|
if(This->swizzled_attribs[j].usage > This->pDeclarationWine[i].Usage ||
|
||||||
|
(This->swizzled_attribs[j].usage == This->pDeclarationWine[i].Usage &&
|
||||||
|
This->swizzled_attribs[j].idx > This->pDeclarationWine[i].UsageIndex)) {
|
||||||
|
memmove(&This->swizzled_attribs[j + 1], &This->swizzled_attribs[j],
|
||||||
|
sizeof(This->swizzled_attribs) - (sizeof(This->swizzled_attribs[0]) * (j - 1)));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
This->swizzled_attribs[j].usage = This->pDeclarationWine[i].Usage;
|
||||||
|
This->swizzled_attribs[j].idx = This->pDeclarationWine[i].UsageIndex;
|
||||||
|
This->num_swizzled_attribs++;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
TRACE("Swizzled attributes found:\n");
|
||||||
|
for(i = 0; i < This->num_swizzled_attribs; i++) {
|
||||||
|
TRACE("%u: %s%d\n", i,
|
||||||
|
debug_d3ddeclusage(This->swizzled_attribs[i].usage), This->swizzled_attribs[i].idx);
|
||||||
|
}
|
||||||
TRACE("Returning\n");
|
TRACE("Returning\n");
|
||||||
return hr;
|
return hr;
|
||||||
}
|
}
|
||||||
|
|
|
@ -263,29 +263,95 @@ BOOL vshader_input_is_color(
|
||||||
unsigned int regnum) {
|
unsigned int regnum) {
|
||||||
|
|
||||||
IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) iface;
|
IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) iface;
|
||||||
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
|
|
||||||
IWineD3DVertexDeclarationImpl *vertexDeclaration = (IWineD3DVertexDeclarationImpl *)deviceImpl->stateBlock->vertexDecl;
|
|
||||||
|
|
||||||
DWORD usage_token = This->semantics_in[regnum].usage;
|
DWORD usage_token = This->semantics_in[regnum].usage;
|
||||||
DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
|
DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
|
||||||
DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
|
DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
|
||||||
|
|
||||||
if (vertexDeclaration) {
|
int i;
|
||||||
int i;
|
|
||||||
/* Find the declaration element that matches our register, then check
|
for(i = 0; i < This->num_swizzled_attribs; i++) {
|
||||||
* if it has D3DCOLOR as it's type. This works for both d3d8 and d3d9. */
|
if(This->swizzled_attribs[i].usage == usage &&
|
||||||
for (i = 0; i < vertexDeclaration->declarationWNumElements-1; ++i) {
|
This->swizzled_attribs[i].idx == usage_idx) {
|
||||||
WINED3DVERTEXELEMENT *element = vertexDeclaration->pDeclarationWine + i;
|
return TRUE;
|
||||||
if (match_usage(element->Usage, element->UsageIndex, usage, usage_idx)) {
|
}
|
||||||
return element->Type == WINED3DDECLTYPE_D3DCOLOR;
|
}
|
||||||
|
return FALSE;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void find_swizzled_attribs(IWineD3DVertexDeclaration *declaration, IWineD3DVertexShaderImpl *This) {
|
||||||
|
UINT num = 0, i, j;
|
||||||
|
UINT numoldswizzles = This->num_swizzled_attribs;
|
||||||
|
IWineD3DVertexDeclarationImpl *decl = (IWineD3DVertexDeclarationImpl *) declaration;
|
||||||
|
|
||||||
|
DWORD usage_token, usage, usage_idx;
|
||||||
|
BOOL found;
|
||||||
|
|
||||||
|
attrib_declaration oldswizzles[sizeof(This->swizzled_attribs) / sizeof(This->swizzled_attribs[0])];
|
||||||
|
|
||||||
|
/* Back up the old swizzles to keep attributes that are undefined in the current declaration */
|
||||||
|
memcpy(oldswizzles, This->swizzled_attribs, sizeof(oldswizzles));
|
||||||
|
|
||||||
|
memset(This->swizzled_attribs, 0, sizeof(This->swizzled_attribs[0]) * MAX_ATTRIBS);
|
||||||
|
|
||||||
|
for(i = 0; i < decl->num_swizzled_attribs; i++) {
|
||||||
|
for(j = 0; j < MAX_ATTRIBS; j++) {
|
||||||
|
usage_token = This->semantics_in[j].usage;
|
||||||
|
usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
|
||||||
|
usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
|
||||||
|
|
||||||
|
if(decl->swizzled_attribs[i].usage == usage &&
|
||||||
|
decl->swizzled_attribs[i].idx == usage_idx) {
|
||||||
|
This->swizzled_attribs[num].usage = usage;
|
||||||
|
This->swizzled_attribs[num].idx = usage_idx;
|
||||||
|
num++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ERR("Either no vertexdeclaration present, or register not matched. This should never happen.\n");
|
/* Add previously converted attributes back in if they are not defined in the current declaration */
|
||||||
return FALSE;
|
for(i = 0; i < numoldswizzles; i++) {
|
||||||
}
|
|
||||||
|
|
||||||
|
found = FALSE;
|
||||||
|
for(j = 0; j < decl->declarationWNumElements; j++) {
|
||||||
|
if(oldswizzles[i].usage == decl->pDeclarationWine[j].Usage &&
|
||||||
|
oldswizzles[i].idx == decl->pDeclarationWine[j].UsageIndex) {
|
||||||
|
found = TRUE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(found) {
|
||||||
|
/* This previously converted attribute is declared in the current declaration. Either it is
|
||||||
|
* already in the new array, or it should not be there. Skip it
|
||||||
|
*/
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
/* We have a previously swizzled attribute that is not defined by the current vertex declaration.
|
||||||
|
* Insert it into the new conversion array to keep it in the old defined state. Otherwise we end up
|
||||||
|
* recompiling if the old decl is used again because undefined attributes are reset to no swizzling.
|
||||||
|
* In the reverse way(attribute was not swizzled and is not declared in new declaration) the attrib
|
||||||
|
* stays unswizzled as well because it isn't found in the oldswizzles array
|
||||||
|
*/
|
||||||
|
for(j = 0; j < num; j++) {
|
||||||
|
if(oldswizzles[i].usage > This->swizzled_attribs[j].usage || (
|
||||||
|
oldswizzles[i].usage == This->swizzled_attribs[j].usage &&
|
||||||
|
oldswizzles[i].idx > This->swizzled_attribs[j].idx)) {
|
||||||
|
memmove(&This->swizzled_attribs[j + 1], &This->swizzled_attribs[j],
|
||||||
|
sizeof(This->swizzled_attribs) - (sizeof(This->swizzled_attribs[0]) * (j - 1)));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
This->swizzled_attribs[j].usage = oldswizzles[i].usage;
|
||||||
|
This->swizzled_attribs[j].idx = oldswizzles[i].idx;
|
||||||
|
num++;
|
||||||
|
}
|
||||||
|
|
||||||
|
TRACE("New swizzled attributes array\n");
|
||||||
|
for(i = 0; i < num; i++) {
|
||||||
|
TRACE("%d: %s(%d), %d\n", i, debug_d3ddeclusage(This->swizzled_attribs[i].usage),
|
||||||
|
This->swizzled_attribs[i].usage, This->swizzled_attribs[i].idx);
|
||||||
|
}
|
||||||
|
This->num_swizzled_attribs = num;
|
||||||
|
}
|
||||||
/** Generate a vertex shader string using either GL_VERTEX_PROGRAM_ARB
|
/** Generate a vertex shader string using either GL_VERTEX_PROGRAM_ARB
|
||||||
or GLSL and send it to the card */
|
or GLSL and send it to the card */
|
||||||
static VOID IWineD3DVertexShaderImpl_GenerateShader(
|
static VOID IWineD3DVertexShaderImpl_GenerateShader(
|
||||||
|
@ -294,8 +360,11 @@ static VOID IWineD3DVertexShaderImpl_GenerateShader(
|
||||||
CONST DWORD *pFunction) {
|
CONST DWORD *pFunction) {
|
||||||
|
|
||||||
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
||||||
|
IWineD3DVertexDeclaration *decl = ((IWineD3DDeviceImpl *) This->baseShader.device)->stateBlock->vertexDecl;
|
||||||
SHADER_BUFFER buffer;
|
SHADER_BUFFER buffer;
|
||||||
|
|
||||||
|
find_swizzled_attribs(decl, This);
|
||||||
|
|
||||||
#if 0 /* FIXME: Use the buffer that is held by the device, this is ok since fixups will be skipped for software shaders
|
#if 0 /* FIXME: Use the buffer that is held by the device, this is ok since fixups will be skipped for software shaders
|
||||||
it also requires entering a critical section but cuts down the runtime footprint of wined3d and any memory fragmentation that may occur... */
|
it also requires entering a critical section but cuts down the runtime footprint of wined3d and any memory fragmentation that may occur... */
|
||||||
if (This->device->fixupVertexBufferSize < SHADER_PGMSIZE) {
|
if (This->device->fixupVertexBufferSize < SHADER_PGMSIZE) {
|
||||||
|
@ -349,9 +418,7 @@ static VOID IWineD3DVertexShaderImpl_GenerateShader(
|
||||||
* before the homogenous divide, so we have to take the w into account: z = ((z / w) * 2 - 1) * w,
|
* before the homogenous divide, so we have to take the w into account: z = ((z / w) * 2 - 1) * w,
|
||||||
* which is the same as z = z / 2 - w.
|
* which is the same as z = z / 2 - w.
|
||||||
*/
|
*/
|
||||||
shader_addline(&buffer, "tmp0 = gl_Position;\n");
|
shader_addline(&buffer, "gl_Position.z = gl_Position.z * 2.0 - gl_Position.w;\n");
|
||||||
shader_addline(&buffer, "gl_Position.z = tmp0.z * 2.0;\n");
|
|
||||||
shader_addline(&buffer, "gl_Position.z = gl_Position.z - gl_Position.w;\n");
|
|
||||||
|
|
||||||
shader_addline(&buffer, "}\n");
|
shader_addline(&buffer, "}\n");
|
||||||
|
|
||||||
|
@ -399,8 +466,8 @@ static VOID IWineD3DVertexShaderImpl_GenerateShader(
|
||||||
* 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
|
* 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
|
||||||
* contains 1.0 to allow a mad, but arb vs swizzles are too restricted for that.
|
* contains 1.0 to allow a mad, but arb vs swizzles are too restricted for that.
|
||||||
*/
|
*/
|
||||||
shader_addline(&buffer, "ADD TMP_OUT.x, TMP_OUT.x, posFixup.z;");
|
shader_addline(&buffer, "ADD TMP_OUT.x, TMP_OUT.x, posFixup.z;\n");
|
||||||
shader_addline(&buffer, "MAD TMP_OUT.y, TMP_OUT.y, posFixup.y, posFixup.w;");
|
shader_addline(&buffer, "MAD TMP_OUT.y, TMP_OUT.y, posFixup.y, posFixup.w;\n");
|
||||||
|
|
||||||
/* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
|
/* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
|
||||||
* and the glsl equivalent
|
* and the glsl equivalent
|
||||||
|
@ -439,56 +506,16 @@ static VOID IWineD3DVertexShaderImpl_GenerateShader(
|
||||||
/* *******************************************
|
/* *******************************************
|
||||||
IWineD3DVertexShader IUnknown parts follow
|
IWineD3DVertexShader IUnknown parts follow
|
||||||
******************************************* */
|
******************************************* */
|
||||||
static HRESULT WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj)
|
static HRESULT WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj) {
|
||||||
{
|
return IWineD3DBaseShaderImpl_QueryInterface((IWineD3DBaseShader *) iface, riid, ppobj);
|
||||||
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
|
||||||
TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
|
|
||||||
if (IsEqualGUID(riid, &IID_IUnknown)
|
|
||||||
|| IsEqualGUID(riid, &IID_IWineD3DBase)
|
|
||||||
|| IsEqualGUID(riid, &IID_IWineD3DBaseShader)
|
|
||||||
|| IsEqualGUID(riid, &IID_IWineD3DVertexShader)) {
|
|
||||||
IUnknown_AddRef(iface);
|
|
||||||
*ppobj = This;
|
|
||||||
return S_OK;
|
|
||||||
}
|
|
||||||
*ppobj = NULL;
|
|
||||||
return E_NOINTERFACE;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static ULONG WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
|
static ULONG WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
|
||||||
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
return IWineD3DBaseShaderImpl_AddRef((IWineD3DBaseShader *) iface);
|
||||||
TRACE("(%p) : AddRef increasing from %d\n", This, This->ref);
|
|
||||||
return InterlockedIncrement(&This->ref);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
|
static ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
|
||||||
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
return IWineD3DBaseShaderImpl_Release((IWineD3DBaseShader *) iface);
|
||||||
ULONG ref;
|
|
||||||
TRACE("(%p) : Releasing from %d\n", This, This->ref);
|
|
||||||
ref = InterlockedDecrement(&This->ref);
|
|
||||||
if (ref == 0) {
|
|
||||||
if (This->baseShader.shader_mode == SHADER_GLSL && This->baseShader.prgId != 0) {
|
|
||||||
struct list *linked_programs = &This->baseShader.linked_programs;
|
|
||||||
|
|
||||||
TRACE("Deleting linked programs\n");
|
|
||||||
if (linked_programs->next) {
|
|
||||||
struct glsl_shader_prog_link *entry, *entry2;
|
|
||||||
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, vshader_entry) {
|
|
||||||
delete_glsl_program_entry(This->baseShader.device, entry);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
TRACE("Deleting shader object %u\n", This->baseShader.prgId);
|
|
||||||
GL_EXTCALL(glDeleteObjectARB(This->baseShader.prgId));
|
|
||||||
checkGLcall("glDeleteObjectARB");
|
|
||||||
}
|
|
||||||
shader_delete_constant_list(&This->baseShader.constantsF);
|
|
||||||
shader_delete_constant_list(&This->baseShader.constantsB);
|
|
||||||
shader_delete_constant_list(&This->baseShader.constantsI);
|
|
||||||
HeapFree(GetProcessHeap(), 0, This);
|
|
||||||
|
|
||||||
}
|
|
||||||
return ref;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* *******************************************
|
/* *******************************************
|
||||||
|
@ -587,6 +614,7 @@ static HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader
|
||||||
This->rel_offset = 0;
|
This->rel_offset = 0;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
This->baseShader.load_local_constsF = This->baseShader.reg_maps.usesrelconstF && !list_empty(&This->baseShader.constantsF);
|
||||||
|
|
||||||
/* copy the function ... because it will certainly be released by application */
|
/* copy the function ... because it will certainly be released by application */
|
||||||
if (NULL != pFunction) {
|
if (NULL != pFunction) {
|
||||||
|
@ -641,14 +669,86 @@ static HRESULT WINAPI IWIneD3DVertexShaderImpl_SetLocalConstantsF(IWineD3DVertex
|
||||||
return WINED3D_OK;
|
return WINED3D_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static inline BOOL swizzled_attribs_differ(IWineD3DVertexShaderImpl *This, IWineD3DVertexDeclarationImpl *vdecl) {
|
||||||
|
UINT i, j, k;
|
||||||
|
BOOL found;
|
||||||
|
|
||||||
|
DWORD usage_token;
|
||||||
|
DWORD usage;
|
||||||
|
DWORD usage_idx;
|
||||||
|
|
||||||
|
for(i = 0; i < vdecl->declarationWNumElements; i++) {
|
||||||
|
for(j = 0; j < MAX_ATTRIBS; j++) {
|
||||||
|
if(!This->baseShader.reg_maps.attributes) continue;
|
||||||
|
|
||||||
|
usage_token = This->semantics_in[j].usage;
|
||||||
|
usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
|
||||||
|
usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
|
||||||
|
|
||||||
|
if(vdecl->pDeclarationWine[i].Usage != usage ||
|
||||||
|
vdecl->pDeclarationWine[i].UsageIndex != usage_idx) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
found = FALSE;
|
||||||
|
for(k = 0; k < This->num_swizzled_attribs; k++) {
|
||||||
|
if(This->swizzled_attribs[k].usage == usage &&
|
||||||
|
This->swizzled_attribs[k].idx == usage_idx) {
|
||||||
|
found = TRUE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(!found && vdecl->pDeclarationWine[i].Type == WINED3DDECLTYPE_D3DCOLOR) {
|
||||||
|
TRACE("Attribute %s%d is D3DCOLOR now but wasn't before\n",
|
||||||
|
debug_d3ddeclusage(usage), usage_idx);
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
if( found && vdecl->pDeclarationWine[i].Type != WINED3DDECLTYPE_D3DCOLOR) {
|
||||||
|
TRACE("Attribute %s%d was D3DCOLOR before but is not any more\n",
|
||||||
|
debug_d3ddeclusage(usage), usage_idx);
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return FALSE;
|
||||||
|
}
|
||||||
|
|
||||||
static HRESULT WINAPI IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) {
|
static HRESULT WINAPI IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) {
|
||||||
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
||||||
|
IWineD3DVertexDeclarationImpl *vdecl;
|
||||||
CONST DWORD *function = This->baseShader.function;
|
CONST DWORD *function = This->baseShader.function;
|
||||||
|
IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
|
||||||
|
|
||||||
TRACE("(%p) : function %p\n", iface, function);
|
TRACE("(%p) : function %p\n", iface, function);
|
||||||
|
|
||||||
/* We're already compiled. */
|
/* We're already compiled. */
|
||||||
if (This->baseShader.is_compiled) return WINED3D_OK;
|
if (This->baseShader.is_compiled) {
|
||||||
|
vdecl = (IWineD3DVertexDeclarationImpl *) deviceImpl->stateBlock->vertexDecl;
|
||||||
|
|
||||||
|
if(This->num_swizzled_attribs != vdecl->num_swizzled_attribs ||
|
||||||
|
memcmp(This->swizzled_attribs, vdecl->swizzled_attribs, sizeof(vdecl->swizzled_attribs[0]) * This->num_swizzled_attribs) != 0) {
|
||||||
|
|
||||||
|
/* The swizzled attributes differ between shader and declaration. This doesn't necessarily mean
|
||||||
|
* we have to recompile, but we have to take a deeper look at see if the attribs that differ
|
||||||
|
* are declared in the decl and used in the shader
|
||||||
|
*/
|
||||||
|
if(swizzled_attribs_differ(This, vdecl)) {
|
||||||
|
WARN("Recompiling vertex shader %p due to D3DCOLOR input changes\n", This);
|
||||||
|
goto recompile;
|
||||||
|
}
|
||||||
|
WARN("Swizzled attribute validation required an expensive comparison\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
return WINED3D_OK;
|
||||||
|
|
||||||
|
recompile:
|
||||||
|
if(This->recompile_count < 50) {
|
||||||
|
This->recompile_count++;
|
||||||
|
} else {
|
||||||
|
FIXME("Vertexshader %p recompiled more than 50 times\n", This);
|
||||||
|
}
|
||||||
|
|
||||||
|
deviceImpl->shader_backend->shader_destroy((IWineD3DBaseShader *) iface);
|
||||||
|
}
|
||||||
|
|
||||||
/* We don't need to compile */
|
/* We don't need to compile */
|
||||||
if (!function) {
|
if (!function) {
|
||||||
|
|
|
@ -44,11 +44,6 @@
|
||||||
#include "wine/list.h"
|
#include "wine/list.h"
|
||||||
|
|
||||||
#define ceilf(x) (float)ceil((double)x)
|
#define ceilf(x) (float)ceil((double)x)
|
||||||
BOOL WINAPI
|
|
||||||
DllMain(IN HINSTANCE hinstDLL,
|
|
||||||
IN DWORD dwReason,
|
|
||||||
IN LPVOID lpvReserved);
|
|
||||||
|
|
||||||
/* Hash table functions */
|
/* Hash table functions */
|
||||||
typedef unsigned int (hash_function_t)(void *key);
|
typedef unsigned int (hash_function_t)(void *key);
|
||||||
typedef BOOL (compare_function_t)(void *keya, void *keyb);
|
typedef BOOL (compare_function_t)(void *keya, void *keyb);
|
||||||
|
@ -217,6 +212,7 @@ typedef struct {
|
||||||
void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
|
void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
|
||||||
void (*shader_cleanup)(IWineD3DDevice *iface);
|
void (*shader_cleanup)(IWineD3DDevice *iface);
|
||||||
void (*shader_color_correction)(struct SHADER_OPCODE_ARG *arg);
|
void (*shader_color_correction)(struct SHADER_OPCODE_ARG *arg);
|
||||||
|
void (*shader_destroy)(IWineD3DBaseShader *iface);
|
||||||
} shader_backend_t;
|
} shader_backend_t;
|
||||||
|
|
||||||
extern const shader_backend_t glsl_shader_backend;
|
extern const shader_backend_t glsl_shader_backend;
|
||||||
|
@ -631,13 +627,8 @@ extern BOOL pbuffer_support;
|
||||||
/* allocate one pbuffer per surface */
|
/* allocate one pbuffer per surface */
|
||||||
extern BOOL pbuffer_per_surface;
|
extern BOOL pbuffer_per_surface;
|
||||||
|
|
||||||
typedef struct ResourceList {
|
|
||||||
IWineD3DResource *resource;
|
|
||||||
struct ResourceList *next;
|
|
||||||
} ResourceList;
|
|
||||||
|
|
||||||
/* A helper function that dumps a resource list */
|
/* A helper function that dumps a resource list */
|
||||||
void dumpResources(ResourceList *resources);
|
void dumpResources(struct list *list);
|
||||||
|
|
||||||
/*****************************************************************************
|
/*****************************************************************************
|
||||||
* IWineD3DDevice implementation structure
|
* IWineD3DDevice implementation structure
|
||||||
|
@ -687,11 +678,11 @@ struct IWineD3DDeviceImpl
|
||||||
IWineD3DSwapChain **swapchains;
|
IWineD3DSwapChain **swapchains;
|
||||||
UINT NumberOfSwapChains;
|
UINT NumberOfSwapChains;
|
||||||
|
|
||||||
ResourceList *resources; /* a linked list to track resources created by the device */
|
struct list resources; /* a linked list to track resources created by the device */
|
||||||
|
|
||||||
/* Render Target Support */
|
/* Render Target Support */
|
||||||
IWineD3DSurface **render_targets;
|
IWineD3DSurface **render_targets;
|
||||||
IWineD3DSurface *depthStencilBuffer;
|
IWineD3DSurface *auto_depth_stencil_buffer;
|
||||||
IWineD3DSurface **fbo_color_attachments;
|
IWineD3DSurface **fbo_color_attachments;
|
||||||
IWineD3DSurface *fbo_depth_attachment;
|
IWineD3DSurface *fbo_depth_attachment;
|
||||||
|
|
||||||
|
@ -827,6 +818,7 @@ typedef struct IWineD3DResourceClass
|
||||||
BYTE *allocatedMemory; /* Pointer to the real data location */
|
BYTE *allocatedMemory; /* Pointer to the real data location */
|
||||||
BYTE *heapMemory; /* Pointer to the HeapAlloced block of memory */
|
BYTE *heapMemory; /* Pointer to the HeapAlloced block of memory */
|
||||||
struct list privateData;
|
struct list privateData;
|
||||||
|
struct list resource_list_entry;
|
||||||
|
|
||||||
} IWineD3DResourceClass;
|
} IWineD3DResourceClass;
|
||||||
|
|
||||||
|
@ -930,6 +922,7 @@ typedef struct IWineD3DBaseTextureClass
|
||||||
BOOL is_srgb;
|
BOOL is_srgb;
|
||||||
UINT srgb_mode_change_count;
|
UINT srgb_mode_change_count;
|
||||||
WINED3DFORMAT shader_conversion_group;
|
WINED3DFORMAT shader_conversion_group;
|
||||||
|
float pow2Matrix[16];
|
||||||
} IWineD3DBaseTextureClass;
|
} IWineD3DBaseTextureClass;
|
||||||
|
|
||||||
typedef struct IWineD3DBaseTextureImpl
|
typedef struct IWineD3DBaseTextureImpl
|
||||||
|
@ -956,8 +949,6 @@ typedef struct IWineD3DTextureImpl
|
||||||
|
|
||||||
UINT width;
|
UINT width;
|
||||||
UINT height;
|
UINT height;
|
||||||
float pow2scalingFactorX;
|
|
||||||
float pow2scalingFactorY;
|
|
||||||
|
|
||||||
} IWineD3DTextureImpl;
|
} IWineD3DTextureImpl;
|
||||||
|
|
||||||
|
@ -977,8 +968,6 @@ typedef struct IWineD3DCubeTextureImpl
|
||||||
IWineD3DSurface *surfaces[6][MAX_LEVELS];
|
IWineD3DSurface *surfaces[6][MAX_LEVELS];
|
||||||
|
|
||||||
UINT edgeLength;
|
UINT edgeLength;
|
||||||
float pow2scalingFactor;
|
|
||||||
|
|
||||||
} IWineD3DCubeTextureImpl;
|
} IWineD3DCubeTextureImpl;
|
||||||
|
|
||||||
extern const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl;
|
extern const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl;
|
||||||
|
@ -1103,12 +1092,6 @@ struct IWineD3DSurfaceImpl
|
||||||
/* PBO */
|
/* PBO */
|
||||||
GLuint pbo;
|
GLuint pbo;
|
||||||
|
|
||||||
#if 0
|
|
||||||
/* precalculated x and y scalings for texture coords */
|
|
||||||
float pow2scalingFactorX; /* = (Width / pow2Width ) */
|
|
||||||
float pow2scalingFactorY; /* = (Height / pow2Height) */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
RECT lockedRect;
|
RECT lockedRect;
|
||||||
RECT dirtyRect;
|
RECT dirtyRect;
|
||||||
int lockCount;
|
int lockCount;
|
||||||
|
@ -1174,6 +1157,7 @@ HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface);
|
||||||
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter);
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter);
|
||||||
HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, RECT *rsrc, DWORD trans);
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, RECT *rsrc, DWORD trans);
|
||||||
HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags);
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags);
|
||||||
|
void WINAPI IWineD3DBaseSurfaceImpl_BindTexture(IWineD3DSurface *iface);
|
||||||
|
|
||||||
const void *WINAPI IWineD3DSurfaceImpl_GetData(IWineD3DSurface *iface);
|
const void *WINAPI IWineD3DSurfaceImpl_GetData(IWineD3DSurface *iface);
|
||||||
|
|
||||||
|
@ -1252,6 +1236,13 @@ HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_
|
||||||
/*****************************************************************************
|
/*****************************************************************************
|
||||||
* IWineD3DVertexDeclaration implementation structure
|
* IWineD3DVertexDeclaration implementation structure
|
||||||
*/
|
*/
|
||||||
|
typedef struct attrib_declaration {
|
||||||
|
DWORD usage;
|
||||||
|
DWORD idx;
|
||||||
|
} attrib_declaration;
|
||||||
|
|
||||||
|
#define MAX_ATTRIBS 16
|
||||||
|
|
||||||
typedef struct IWineD3DVertexDeclarationImpl {
|
typedef struct IWineD3DVertexDeclarationImpl {
|
||||||
/* IUnknown Information */
|
/* IUnknown Information */
|
||||||
const IWineD3DVertexDeclarationVtbl *lpVtbl;
|
const IWineD3DVertexDeclarationVtbl *lpVtbl;
|
||||||
|
@ -1266,6 +1257,10 @@ typedef struct IWineD3DVertexDeclarationImpl {
|
||||||
DWORD streams[MAX_STREAMS];
|
DWORD streams[MAX_STREAMS];
|
||||||
UINT num_streams;
|
UINT num_streams;
|
||||||
BOOL position_transformed;
|
BOOL position_transformed;
|
||||||
|
|
||||||
|
/* Ordered array of declaration types that need swizzling in a vshader */
|
||||||
|
attrib_declaration swizzled_attribs[MAX_ATTRIBS];
|
||||||
|
UINT num_swizzled_attribs;
|
||||||
} IWineD3DVertexDeclarationImpl;
|
} IWineD3DVertexDeclarationImpl;
|
||||||
|
|
||||||
extern const IWineD3DVertexDeclarationVtbl IWineD3DVertexDeclaration_Vtbl;
|
extern const IWineD3DVertexDeclarationVtbl IWineD3DVertexDeclaration_Vtbl;
|
||||||
|
@ -1641,7 +1636,6 @@ typedef struct {
|
||||||
#define MAX_REG_TEXCRD 8
|
#define MAX_REG_TEXCRD 8
|
||||||
#define MAX_REG_INPUT 12
|
#define MAX_REG_INPUT 12
|
||||||
#define MAX_REG_OUTPUT 12
|
#define MAX_REG_OUTPUT 12
|
||||||
#define MAX_ATTRIBS 16
|
|
||||||
#define MAX_CONST_I 16
|
#define MAX_CONST_I 16
|
||||||
#define MAX_CONST_B 16
|
#define MAX_CONST_B 16
|
||||||
|
|
||||||
|
@ -1675,6 +1669,7 @@ typedef struct shader_reg_maps {
|
||||||
DWORD samplers[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)];
|
DWORD samplers[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)];
|
||||||
char bumpmat, luminanceparams;
|
char bumpmat, luminanceparams;
|
||||||
char usesnrm, vpos, usesdsy;
|
char usesnrm, vpos, usesdsy;
|
||||||
|
char usesrelconstF;
|
||||||
|
|
||||||
/* Whether or not loops are used in this shader, and nesting depth */
|
/* Whether or not loops are used in this shader, and nesting depth */
|
||||||
unsigned loop_depth;
|
unsigned loop_depth;
|
||||||
|
@ -1761,9 +1756,6 @@ extern const SHADER_OPCODE* shader_get_opcode(
|
||||||
IWineD3DBaseShader *iface,
|
IWineD3DBaseShader *iface,
|
||||||
const DWORD code);
|
const DWORD code);
|
||||||
|
|
||||||
extern void shader_delete_constant_list(
|
|
||||||
struct list* clist);
|
|
||||||
|
|
||||||
void delete_glsl_program_entry(IWineD3DDevice *iface, struct glsl_shader_prog_link *entry);
|
void delete_glsl_program_entry(IWineD3DDevice *iface, struct glsl_shader_prog_link *entry);
|
||||||
|
|
||||||
/* Vertex shader utility functions */
|
/* Vertex shader utility functions */
|
||||||
|
@ -1895,15 +1887,17 @@ extern void pshader_glsl_input_pack(
|
||||||
*/
|
*/
|
||||||
typedef struct IWineD3DBaseShaderClass
|
typedef struct IWineD3DBaseShaderClass
|
||||||
{
|
{
|
||||||
|
LONG ref;
|
||||||
DWORD hex_version;
|
DWORD hex_version;
|
||||||
SHADER_LIMITS limits;
|
SHADER_LIMITS limits;
|
||||||
SHADER_PARSE_STATE parse_state;
|
SHADER_PARSE_STATE parse_state;
|
||||||
CONST SHADER_OPCODE *shader_ins;
|
CONST SHADER_OPCODE *shader_ins;
|
||||||
CONST DWORD *function;
|
DWORD *function;
|
||||||
UINT functionLength;
|
UINT functionLength;
|
||||||
GLuint prgId;
|
GLuint prgId;
|
||||||
BOOL is_compiled;
|
BOOL is_compiled;
|
||||||
UINT cur_loop_depth, cur_loop_regno;
|
UINT cur_loop_depth, cur_loop_regno;
|
||||||
|
BOOL load_local_constsF;
|
||||||
|
|
||||||
/* Type of shader backend */
|
/* Type of shader backend */
|
||||||
int shader_mode;
|
int shader_mode;
|
||||||
|
@ -1936,12 +1930,15 @@ typedef struct IWineD3DBaseShaderClass
|
||||||
typedef struct IWineD3DBaseShaderImpl {
|
typedef struct IWineD3DBaseShaderImpl {
|
||||||
/* IUnknown */
|
/* IUnknown */
|
||||||
const IWineD3DBaseShaderVtbl *lpVtbl;
|
const IWineD3DBaseShaderVtbl *lpVtbl;
|
||||||
LONG ref;
|
|
||||||
|
|
||||||
/* IWineD3DBaseShader */
|
/* IWineD3DBaseShader */
|
||||||
IWineD3DBaseShaderClass baseShader;
|
IWineD3DBaseShaderClass baseShader;
|
||||||
} IWineD3DBaseShaderImpl;
|
} IWineD3DBaseShaderImpl;
|
||||||
|
|
||||||
|
HRESULT WINAPI IWineD3DBaseShaderImpl_QueryInterface(IWineD3DBaseShader *iface, REFIID riid, LPVOID *ppobj);
|
||||||
|
ULONG WINAPI IWineD3DBaseShaderImpl_AddRef(IWineD3DBaseShader *iface);
|
||||||
|
ULONG WINAPI IWineD3DBaseShaderImpl_Release(IWineD3DBaseShader *iface);
|
||||||
|
|
||||||
extern HRESULT shader_get_registers_used(
|
extern HRESULT shader_get_registers_used(
|
||||||
IWineD3DBaseShader *iface,
|
IWineD3DBaseShader *iface,
|
||||||
shader_reg_maps* reg_maps,
|
shader_reg_maps* reg_maps,
|
||||||
|
@ -2050,7 +2047,6 @@ static inline BOOL shader_is_scalar(DWORD param) {
|
||||||
typedef struct IWineD3DVertexShaderImpl {
|
typedef struct IWineD3DVertexShaderImpl {
|
||||||
/* IUnknown parts*/
|
/* IUnknown parts*/
|
||||||
const IWineD3DVertexShaderVtbl *lpVtbl;
|
const IWineD3DVertexShaderVtbl *lpVtbl;
|
||||||
LONG ref; /* Note: Ref counting not required */
|
|
||||||
|
|
||||||
/* IWineD3DBaseShader */
|
/* IWineD3DBaseShader */
|
||||||
IWineD3DBaseShaderClass baseShader;
|
IWineD3DBaseShaderClass baseShader;
|
||||||
|
@ -2064,11 +2060,16 @@ typedef struct IWineD3DVertexShaderImpl {
|
||||||
semantic semantics_in [MAX_ATTRIBS];
|
semantic semantics_in [MAX_ATTRIBS];
|
||||||
semantic semantics_out [MAX_REG_OUTPUT];
|
semantic semantics_out [MAX_REG_OUTPUT];
|
||||||
|
|
||||||
|
/* Ordered array of attributes that are swizzled */
|
||||||
|
attrib_declaration swizzled_attribs [MAX_ATTRIBS];
|
||||||
|
UINT num_swizzled_attribs;
|
||||||
|
|
||||||
/* run time datas... */
|
/* run time datas... */
|
||||||
VSHADERDATA *data;
|
VSHADERDATA *data;
|
||||||
UINT min_rel_offset, max_rel_offset;
|
UINT min_rel_offset, max_rel_offset;
|
||||||
UINT rel_offset;
|
UINT rel_offset;
|
||||||
|
|
||||||
|
UINT recompile_count;
|
||||||
#if 0 /* needs reworking */
|
#if 0 /* needs reworking */
|
||||||
/* run time datas */
|
/* run time datas */
|
||||||
VSHADERINPUTDATA input;
|
VSHADERINPUTDATA input;
|
||||||
|
@ -2091,7 +2092,6 @@ enum vertexprocessing_mode {
|
||||||
typedef struct IWineD3DPixelShaderImpl {
|
typedef struct IWineD3DPixelShaderImpl {
|
||||||
/* IUnknown parts */
|
/* IUnknown parts */
|
||||||
const IWineD3DPixelShaderVtbl *lpVtbl;
|
const IWineD3DPixelShaderVtbl *lpVtbl;
|
||||||
LONG ref; /* Note: Ref counting not required */
|
|
||||||
|
|
||||||
/* IWineD3DBaseShader */
|
/* IWineD3DBaseShader */
|
||||||
IWineD3DBaseShaderClass baseShader;
|
IWineD3DBaseShaderClass baseShader;
|
||||||
|
|
Loading…
Reference in a new issue