system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-14 09:30:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

wined3d: Make the number of floating point shader constants dynamic.

Browse source
This commit is contained in:
Jason Green 2006-07-19 00:06:07 -04:00 committed by Alexandre Julliard
parent b5c98f4dd6
commit 718716b77a
10 changed files with 205 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
dlls/wined3d/arb_program_shader.c
View file

@ -108,13 +108,13 @@ void shader_arb_load_constants(
if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) {
/* Load DirectX 8 float constants for vertex shader */
shader_arb_load_constantsF(vshader, gl_info, GL_VERTEX_PROGRAM_ARB,
WINED3D_VSHADER_MAX_CONSTANTS,
GL_LIMITS(vshader_constantsF),
vertexDeclaration->constants, NULL);
}
/* Load DirectX 9 float constants for vertex shader */
shader_arb_load_constantsF(vshader, gl_info, GL_VERTEX_PROGRAM_ARB,
WINED3D_VSHADER_MAX_CONSTANTS,
GL_LIMITS(vshader_constantsF),
stateBlock->vertexShaderConstantF,
stateBlock->set.vertexShaderConstantsF);
}
@ -124,7 +124,8 @@ void shader_arb_load_constants(
IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
/* Load DirectX 9 float constants for pixel shader */
shader_arb_load_constantsF(pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB, WINED3D_PSHADER_MAX_CONSTANTS,
shader_arb_load_constantsF(pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB,
GL_LIMITS(pshader_constantsF),
stateBlock->pixelShaderConstantF,
stateBlock->set.pixelShaderConstantsF);
}
@ -134,10 +135,14 @@ void shader_arb_load_constants(
void shader_generate_arb_declarations(
IWineD3DBaseShader *iface,
shader_reg_maps* reg_maps,
SHADER_BUFFER* buffer) {
SHADER_BUFFER* buffer,
WineD3D_GL_Info* gl_info) {
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
DWORD i;
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
unsigned max_constantsF = min(This->baseShader.limits.constant_float,
(pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
for(i = 0; i < This->baseShader.limits.temporary; i++) {
if (reg_maps->temporary[i])
@ -162,8 +167,7 @@ void shader_generate_arb_declarations(
/* Need to PARAM the environment parameters (constants) so we can use relative addressing */
shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
This->baseShader.limits.constant_float,
This->baseShader.limits.constant_float - 1);
max_constantsF, max_constantsF - 1);
}
static const char* shift_tab[] = {

55
dlls/wined3d/device.c
View file

@ -775,6 +775,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface,
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
IWineD3DStateBlockImpl *object;
int i, j;
HRESULT temp_result;
D3DCREATEOBJECTINSTANCE(object, StateBlock)
object->blockType = Type;
@ -786,6 +787,10 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface,
be freed due to circular dependencies */
return WINED3D_OK;
}
temp_result = allocate_shader_constants(object);
if (WINED3D_OK != temp_result)
return temp_result;
/* Otherwise, might as well set the whole state block to the appropriate values */
if ( This->stateBlock != NULL) {
@ -813,11 +818,13 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface,
object->changed.pixelShader = TRUE;
/* Pixel Shader Constants */
for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i)
object->changed.pixelShaderConstantsF[i] = TRUE;
for (i = 0; i < MAX_CONST_B; ++i)
object->changed.pixelShaderConstantsB[i] = TRUE;
for (i = 0; i < MAX_CONST_I; ++i)
object->changed.pixelShaderConstantsI[i] = TRUE;
}
for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
object->changed.renderState[SavedPixelStates_R[i]] = TRUE;
}
@ -841,11 +848,13 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface,
object->changed.vertexShader = TRUE;
/* Vertex Shader Constants */
for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i)
object->changed.vertexShaderConstantsF[i] = TRUE;
for (i = 0; i < MAX_CONST_B; ++i)
object->changed.vertexShaderConstantsB[i] = TRUE;
for (i = 0; i < MAX_CONST_I; ++i)
object->changed.vertexShaderConstantsI[i] = TRUE;
}
for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
object->changed.renderState[SavedVertexStates_R[i]] = TRUE;
}
@ -4606,7 +4615,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int i, cnt = min(count, MAX_VSHADER_CONSTANTS - start);
int i, cnt = min(count, MAX_CONST_B - start);
TRACE("(iface %p, srcData %p, start %d, count %d)\n",
iface, srcData, start, count);
@ -4633,7 +4642,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int cnt = min(count, MAX_VSHADER_CONSTANTS - start);
int cnt = min(count, MAX_CONST_B - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
@ -4652,7 +4661,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int i, cnt = min(count, MAX_VSHADER_CONSTANTS - start);
int i, cnt = min(count, MAX_CONST_I - start);
TRACE("(iface %p, srcData %p, start %d, count %d)\n",
iface, srcData, start, count);
@ -4680,7 +4689,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int cnt = min(count, MAX_VSHADER_CONSTANTS - start);
int cnt = min(count, MAX_CONST_I - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
@ -4699,7 +4708,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int i, cnt = min(count, MAX_VSHADER_CONSTANTS - start);
int i, cnt = min(count, GL_LIMITS(vshader_constantsF) - start);
TRACE("(iface %p, srcData %p, start %d, count %d)\n",
iface, srcData, start, count);
@ -4727,7 +4736,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int cnt = min(count, MAX_VSHADER_CONSTANTS - start);
int cnt = min(count, GL_LIMITS(vshader_constantsF) - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
@ -4788,7 +4797,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int i, cnt = min(count, MAX_PSHADER_CONSTANTS - start);
int i, cnt = min(count, MAX_CONST_B - start);
TRACE("(iface %p, srcData %p, start %d, count %d)\n",
iface, srcData, start, count);
@ -4798,7 +4807,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(
memcpy(&This->updateStateBlock->pixelShaderConstantB[start], srcData, cnt * sizeof(BOOL));
for (i = 0; i < cnt; i++)
TRACE("Set BOOL constant %u to %s\n", i, srcData[i]? "true":"false");
TRACE("Set BOOL constant %u to %s\n", start + i, srcData[i]? "true":"false");
for (i = start; i < cnt + start; ++i) {
This->updateStateBlock->changed.pixelShaderConstantsB[i] = TRUE;
@ -4815,7 +4824,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int cnt = min(count, MAX_PSHADER_CONSTANTS - start);
int cnt = min(count, MAX_CONST_B - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
@ -4834,7 +4843,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int i, cnt = min(count, MAX_PSHADER_CONSTANTS - start);
int i, cnt = min(count, MAX_CONST_I - start);
TRACE("(iface %p, srcData %p, start %d, count %d)\n",
iface, srcData, start, count);
@ -4844,7 +4853,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(
memcpy(&This->updateStateBlock->pixelShaderConstantI[start * 4], srcData, cnt * sizeof(int) * 4);
for (i = 0; i < cnt; i++)
TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", i,
TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", start + i,
srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
for (i = start; i < cnt + start; ++i) {
@ -4862,7 +4871,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int cnt = min(count, MAX_PSHADER_CONSTANTS - start);
int cnt = min(count, MAX_CONST_I - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
@ -4881,7 +4890,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int i, cnt = min(count, MAX_PSHADER_CONSTANTS - start);
int i, cnt = min(count, GL_LIMITS(pshader_constantsF) - start);
TRACE("(iface %p, srcData %p, start %d, count %d)\n",
iface, srcData, start, count);
@ -4891,7 +4900,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(
memcpy(&This->updateStateBlock->pixelShaderConstantF[start * 4], srcData, cnt * sizeof(float) * 4);
for (i = 0; i < cnt; i++)
TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", i,
TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
for (i = start; i < cnt + start; ++i) {
@ -4909,7 +4918,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
int cnt = min(count, MAX_PSHADER_CONSTANTS - start);
int cnt = min(count, GL_LIMITS(pshader_constantsF) - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
@ -5746,6 +5755,8 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetHWND(IWineD3DDevice *iface, HWND *hW
static HRESULT WINAPI IWineD3DDeviceImpl_BeginStateBlock(IWineD3DDevice *iface) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
IWineD3DStateBlockImpl *object;
HRESULT temp_result;
TRACE("(%p)", This);
if (This->isRecordingState) {
@ -5757,13 +5768,17 @@ static HRESULT WINAPI IWineD3DDeviceImpl_BeginStateBlock(IWineD3DDevice *iface)
FIXME("(%p)Error allocating memory for stateblock\n", This);
return E_OUTOFMEMORY;
}
TRACE("(%p) creted object %p\n", This, object);
TRACE("(%p) created object %p\n", This, object);
object->wineD3DDevice= This;
/** FIXME: object->parent = parent; **/
object->parent = NULL;
object->blockType = WINED3DSBT_ALL;
object->ref = 1;
object->lpVtbl = &IWineD3DStateBlock_Vtbl;
temp_result = allocate_shader_constants(object);
if (WINED3D_OK != temp_result)
return temp_result;
IWineD3DStateBlock_Release((IWineD3DStateBlock*)This->updateStateBlock);
This->updateStateBlock = object;

56
dlls/wined3d/directx.c
View file

@ -208,32 +208,45 @@ static void select_shader_mode(
int* ps_selected,
int* vs_selected) {
/* Default # of constants to 0 */
gl_info->max_vshader_constantsF = 0;
gl_info->max_pshader_constantsF = 0;
/* Give priority to user disable/emulation request.
* Then respect REF device for software.
* Then check capabilities for hardware, and fallback to software */
if (wined3d_settings.vs_mode == VS_NONE)
if (wined3d_settings.vs_mode == VS_NONE) {
*vs_selected = SHADER_NONE;
else if (DeviceType == WINED3DDEVTYPE_REF || wined3d_settings.vs_mode == VS_SW)
} else if (DeviceType == WINED3DDEVTYPE_REF || wined3d_settings.vs_mode == VS_SW) {
*vs_selected = SHADER_SW;
else if (gl_info->supported[ARB_SHADING_LANGUAGE_100] && wined3d_settings.glslRequested)
} else if (gl_info->supported[ARB_SHADING_LANGUAGE_100] && wined3d_settings.glslRequested) {
*vs_selected = SHADER_GLSL;
else if (gl_info->supported[ARB_VERTEX_PROGRAM])
/* Subtract the other potential uniforms from the max available (bools & ints) */
gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF - MAX_CONST_B - MAX_CONST_I;
} else if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
*vs_selected = SHADER_ARB;
else
/* ARB shaders seem to have an implicit PARAM when fog is used, so we need to subtract 1 from the total available */
gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF - 1;
} else {
*vs_selected = SHADER_SW;
}
/* Fallback to SHADER_NONE where software pixel shaders should be used */
if (wined3d_settings.ps_mode == PS_NONE)
if (wined3d_settings.ps_mode == PS_NONE) {
*ps_selected = SHADER_NONE;
else if (DeviceType == WINED3DDEVTYPE_REF)
} else if (DeviceType == WINED3DDEVTYPE_REF) {
*ps_selected = SHADER_NONE;
else if (gl_info->supported[ARB_SHADING_LANGUAGE_100] && wined3d_settings.glslRequested)
} else if (gl_info->supported[ARB_SHADING_LANGUAGE_100] && wined3d_settings.glslRequested) {
*ps_selected = SHADER_GLSL;
else if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
/* Subtract the other potential uniforms from the max available (bools & ints) */
gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF - MAX_CONST_B - MAX_CONST_I;
} else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
*ps_selected = SHADER_ARB;
else
gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF;
} else {
*ps_selected = SHADER_NONE;
}
}
/**********************************************************
@ -528,12 +541,21 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info, Display* display) {
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &gl_max);
TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - GL_MAX_TEXTURE_IMAGE_UNITS_ARB=%u\n", gl_max);
gl_info->max_samplers = min(MAX_SAMPLERS, gl_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max);
TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - max float constants=%u\n", gl_max);
gl_info->ps_arb_constantsF = gl_max;
} else if (strcmp(ThisExtn, "GL_ARB_imaging") == 0) {
TRACE_(d3d_caps)(" FOUND: ARB imaging support\n");
gl_info->supported[ARB_IMAGING] = TRUE;
} else if (strcmp(ThisExtn, "GL_ARB_shading_language_100") == 0) {
TRACE_(d3d_caps)(" FOUND: GL Shading Language v100 support\n");
gl_info->supported[ARB_SHADING_LANGUAGE_100] = TRUE;
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
TRACE_(d3d_caps)(" FOUND: GL Shading Language support - max float vs constants=%u\n", gl_max);
gl_info->vs_glsl_constantsF = gl_max;
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
TRACE_(d3d_caps)(" FOUND: GL Shading Language support - max float ps constants=%u\n", gl_max);
gl_info->ps_glsl_constantsF = gl_max;
} else if (strcmp(ThisExtn, "GL_ARB_multisample") == 0) {
TRACE_(d3d_caps)(" FOUND: ARB Multisample support\n");
gl_info->supported[ARB_MULTISAMPLE] = TRUE;
@ -580,6 +602,9 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info, Display* display) {
gl_info->vs_arb_version = VS_VERSION_11;
TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - version=%02x\n", gl_info->vs_arb_version);
gl_info->supported[ARB_VERTEX_PROGRAM] = TRUE;
glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max);
TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - max float constants=%u\n", gl_max);
gl_info->vs_arb_constantsF = gl_max;
} else if (strcmp(ThisExtn, "GL_ARB_vertex_blend") == 0) {
glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
TRACE_(d3d_caps)(" FOUND: ARB Vertex Blend support GL_MAX_VERTEX_UNITS_ARB %d\n", gl_max);
@ -1765,11 +1790,7 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
TRACE_(d3d_caps)("Vertex shader functionality not available\n");
}
if (This->gl_info.gl_vendor == VENDOR_MESA || This->gl_info.gl_vendor == VENDOR_WINE) {
*pCaps->MaxVertexShaderConst = 95;
} else {
*pCaps->MaxVertexShaderConst = WINED3D_VSHADER_MAX_CONSTANTS;
}
*pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
/* FIXME: the shader ode should be per adapter */
if (wined3d_settings.ps_selected_mode == SHADER_GLSL) {
@ -1839,6 +1860,7 @@ static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter,
IWineD3DDeviceImpl *object = NULL;
IWineD3DImpl *This = (IWineD3DImpl *)iface;
HDC hDC;
HRESULT temp_result;
/* Validate the adapter number */
if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
@ -1898,6 +1920,10 @@ static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter,
select_shader_mode(&This->gl_info, DeviceType,
&wined3d_settings.ps_selected_mode, &wined3d_settings.vs_selected_mode);
temp_result = allocate_shader_constants(object->updateStateBlock);
if (WINED3D_OK != temp_result)
return temp_result;
/* set the state of the device to valid */
object->state = WINED3D_OK;

16
dlls/wined3d/glsl_shader.c
View file

@ -274,12 +274,12 @@ void shader_glsl_load_constants(
if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) {
/* Load DirectX 8 float constants/uniforms for vertex shader */
shader_glsl_load_constantsF(vshader, gl_info, programId, WINED3D_VSHADER_MAX_CONSTANTS,
shader_glsl_load_constantsF(vshader, gl_info, programId, GL_LIMITS(vshader_constantsF),
vertexDeclaration->constants, NULL);
}
/* Load DirectX 9 float constants/uniforms for vertex shader */
shader_glsl_load_constantsF(vshader, gl_info, programId, WINED3D_VSHADER_MAX_CONSTANTS,
shader_glsl_load_constantsF(vshader, gl_info, programId, GL_LIMITS(vshader_constantsF),
stateBlock->vertexShaderConstantF,
stateBlock->set.vertexShaderConstantsF);
@ -302,7 +302,7 @@ void shader_glsl_load_constants(
shader_glsl_load_psamplers(gl_info, iface);
/* Load DirectX 9 float constants/uniforms for pixel shader */
shader_glsl_load_constantsF(pshader, gl_info, programId, WINED3D_PSHADER_MAX_CONSTANTS,
shader_glsl_load_constantsF(pshader, gl_info, programId, GL_LIMITS(pshader_constantsF),
stateBlock->pixelShaderConstantF,
stateBlock->set.pixelShaderConstantsF);
@ -322,7 +322,8 @@ void shader_glsl_load_constants(
void shader_generate_glsl_declarations(
IWineD3DBaseShader *iface,
shader_reg_maps* reg_maps,
SHADER_BUFFER* buffer) {
SHADER_BUFFER* buffer,
WineD3D_GL_Info* gl_info) {
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
int i;
@ -338,8 +339,11 @@ void shader_generate_glsl_declarations(
}
/* Declare the constants (aka uniforms) */
if (This->baseShader.limits.constant_float > 0)
shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, This->baseShader.limits.constant_float);
if (This->baseShader.limits.constant_float > 0) {
unsigned max_constantsF = min(This->baseShader.limits.constant_float,
(pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
}
if (This->baseShader.limits.constant_int > 0)
shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, This->baseShader.limits.constant_int);

4
dlls/wined3d/pixelshader.c
View file

@ -843,7 +843,7 @@ inline static VOID IWineD3DPixelShaderImpl_GenerateShader(
GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
/* Base Declarations */
shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer);
shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer, &GLINFO_LOCATION);
/* Pack 3.0 inputs */
if (This->baseShader.hex_version >= D3DPS_VERSION(3,0))
@ -879,7 +879,7 @@ inline static VOID IWineD3DPixelShaderImpl_GenerateShader(
shader_addline(&buffer, "PARAM one = { 1.0, 1.0, 1.0, 1.0 };\n");
/* Base Declarations */
shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer);
shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer, &GLINFO_LOCATION);
/* Base Shader Body */
shader_generate_main( (IWineD3DBaseShader*) This, &buffer, reg_maps, pFunction);

90
dlls/wined3d/stateblock.c
View file

@ -26,6 +26,38 @@
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
#define GLINFO_LOCATION ((IWineD3DImpl *)(((IWineD3DDeviceImpl *)This->wineD3DDevice)->wineD3D))->gl_info
/***************************************
* Stateblock helper functions follow
**************************************/
/** Allocates the correct amount of space for pixel and vertex shader constants,
* along with their set/changed flags on the given stateblock object
*/
HRESULT allocate_shader_constants(IWineD3DStateBlockImpl* object) {
IWineD3DStateBlockImpl *This = object;
#define WINED3D_MEMCHECK(_object) if (NULL == _object) { FIXME("Out of memory!\n"); return E_OUTOFMEMORY; }
/* Allocate space for floating point constants */
object->pixelShaderConstantF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(float) * GL_LIMITS(pshader_constantsF) * 4);
WINED3D_MEMCHECK(object->pixelShaderConstantF);
object->set.pixelShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOL) * GL_LIMITS(pshader_constantsF) );
WINED3D_MEMCHECK(object->set.pixelShaderConstantsF);
object->changed.pixelShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOL) * GL_LIMITS(pshader_constantsF));
WINED3D_MEMCHECK(object->changed.pixelShaderConstantsF);
object->vertexShaderConstantF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(float) * GL_LIMITS(vshader_constantsF) * 4);
WINED3D_MEMCHECK(object->vertexShaderConstantF);
object->set.vertexShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOL) * GL_LIMITS(vshader_constantsF));
WINED3D_MEMCHECK(object->set.vertexShaderConstantsF);
object->changed.vertexShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOL) * GL_LIMITS(vshader_constantsF));
WINED3D_MEMCHECK(object->changed.vertexShaderConstantsF);
#undef WINED3D_MEMCHECK
return WINED3D_OK;
}
/**********************************************************
* IWineD3DStateBlockImpl IUnknown parts follows
**********************************************************/
@ -88,7 +120,14 @@ static ULONG WINAPI IWineD3DStateBlockImpl_Release(IWineD3DStateBlock *iface) {
if (NULL != This->vertexDecl) {
IWineD3DVertexDeclaration_Release(This->vertexDecl);
}
HeapFree(GetProcessHeap(), 0, This->vertexShaderConstantF);
HeapFree(GetProcessHeap(), 0, This->set.vertexShaderConstantsF);
HeapFree(GetProcessHeap(), 0, This->changed.vertexShaderConstantsF);
HeapFree(GetProcessHeap(), 0, This->pixelShaderConstantF);
HeapFree(GetProcessHeap(), 0, This->set.pixelShaderConstantsF);
HeapFree(GetProcessHeap(), 0, This->changed.pixelShaderConstantsF);
/* NOTE: according to MSDN: The application is responsible for making sure the texture references are cleared down */
for (counter = 0; counter < GL_LIMITS(sampler_stages); counter++) {
if (This->textures[counter]) {
@ -166,9 +205,8 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
This->vertexShader = targetStateBlock->vertexShader;
}
/* Vertex Shader Constants */
for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
/* Vertex Shader Float Constants */
for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
if (This->set.vertexShaderConstantsF[i]) {
TRACE("Setting %p from %p %d to { %f, %f, %f, %f }\n", This, targetStateBlock, i,
targetStateBlock->vertexShaderConstantF[i * 4],
@ -181,7 +219,10 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
This->vertexShaderConstantF[i * 4 + 2] = targetStateBlock->vertexShaderConstantF[i * 4 + 2];
This->vertexShaderConstantF[i * 4 + 3] = targetStateBlock->vertexShaderConstantF[i * 4 + 3];
}
}
/* Vertex Shader Integer Constants */
for (i = 0; i < MAX_CONST_I; ++i) {
if (This->set.vertexShaderConstantsI[i]) {
TRACE("Setting %p from %p %d to { %d, %d, %d, %d }\n", This, targetStateBlock, i,
targetStateBlock->vertexShaderConstantI[i * 4],
@ -194,7 +235,10 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
This->vertexShaderConstantI[i * 4 + 2] = targetStateBlock->vertexShaderConstantI[i * 4 + 2];
This->vertexShaderConstantI[i * 4 + 3] = targetStateBlock->vertexShaderConstantI[i * 4 + 3];
}
}
/* Vertex Shader Boolean Constants */
for (i = 0; i < MAX_CONST_B; ++i) {
if (This->set.vertexShaderConstantsB[i]) {
TRACE("Setting %p from %p %d to %s\n", This, targetStateBlock, i,
targetStateBlock->vertexShaderConstantB[i]? "TRUE":"FALSE");
@ -202,7 +246,7 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
This->vertexShaderConstantB[i] = targetStateBlock->vertexShaderConstantB[i];
}
}
/* Lights... For a recorded state block, we just had a chain of actions to perform,
so we need to walk that chain and update any actions which differ */
src = This->lights;
@ -249,8 +293,8 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
This->pixelShader = targetStateBlock->pixelShader;
}
for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
/* Pixel Shader Float Constants */
for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i) {
if (This->set.pixelShaderConstantsF[i]) {
TRACE("Setting %p from %p %d to { %f, %f, %f, %f }\n", This, targetStateBlock, i,
targetStateBlock->pixelShaderConstantF[i * 4],
@ -263,7 +307,10 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
This->pixelShaderConstantF[i * 4 + 2] = targetStateBlock->pixelShaderConstantF[i * 4 + 2];
This->pixelShaderConstantF[i * 4 + 3] = targetStateBlock->pixelShaderConstantF[i * 4 + 3];
}
}
/* Pixel Shader Integer Constants */
for (i = 0; i < MAX_CONST_I; ++i) {
if (This->set.pixelShaderConstantsI[i]) {
TRACE("Setting %p from %p %d to { %d, %d, %d, %d }\n", This, targetStateBlock, i,
targetStateBlock->pixelShaderConstantI[i * 4],
@ -276,7 +323,10 @@ static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
This->pixelShaderConstantI[i * 4 + 2] = targetStateBlock->pixelShaderConstantI[i * 4 + 2];
This->pixelShaderConstantI[i * 4 + 3] = targetStateBlock->pixelShaderConstantI[i * 4 + 3];
}
}
/* Pixel Shader Boolean Constants */
for (i = 0; i < MAX_CONST_B; ++i) {
if (This->set.pixelShaderConstantsB[i]) {
TRACE("Setting %p from %p %d to %s\n", This, targetStateBlock, i,
targetStateBlock->pixelShaderConstantB[i]? "TRUE":"FALSE");
@ -442,13 +492,17 @@ should really perform a delta so that only the changes get updated*/
}
/* Vertex Shader Constants */
for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
if (This->set.vertexShaderConstantsF[i] && This->changed.vertexShaderConstantsF[i])
IWineD3DDevice_SetVertexShaderConstantF(pDevice, i, This->vertexShaderConstantF + i * 4, 1);
}
for (i = 0; i < MAX_CONST_I; i++) {
if (This->set.vertexShaderConstantsI[i] && This->changed.vertexShaderConstantsI[i])
IWineD3DDevice_SetVertexShaderConstantI(pDevice, i, This->vertexShaderConstantI + i * 4, 1);
}
for (i = 0; i < MAX_CONST_B; i++) {
if (This->set.vertexShaderConstantsB[i] && This->changed.vertexShaderConstantsB[i])
IWineD3DDevice_SetVertexShaderConstantB(pDevice, i, This->vertexShaderConstantB + i, 1);
}
@ -462,13 +516,17 @@ should really perform a delta so that only the changes get updated*/
}
/* Pixel Shader Constants */
for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i) {
if (This->set.pixelShaderConstantsF[i] && This->changed.pixelShaderConstantsF[i])
IWineD3DDevice_SetPixelShaderConstantF(pDevice, i, This->pixelShaderConstantF + i * 4, 1);
}
for (i = 0; i < MAX_CONST_I; ++i) {
if (This->set.pixelShaderConstantsI[i] && This->changed.pixelShaderConstantsI[i])
IWineD3DDevice_SetPixelShaderConstantI(pDevice, i, This->pixelShaderConstantI + i * 4, 1);
}
for (i = 0; i < MAX_CONST_B; ++i) {
if (This->set.pixelShaderConstantsB[i] && This->changed.pixelShaderConstantsB[i])
IWineD3DDevice_SetPixelShaderConstantB(pDevice, i, This->pixelShaderConstantB + i, 1);
}

3
dlls/wined3d/vertexdeclaration.c
View file

@ -308,7 +308,8 @@ IWineD3DVertexDeclarationImpl *This = (IWineD3DVertexDeclarationImpl *)iface;
DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
DWORD constaddress = ((token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
if (This->constants == NULL ) {
This->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_VSHADER_CONSTANTS * 4 * sizeof(float));
This->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
((IWineD3DImpl*)This->wineD3DDevice->wineD3D)->gl_info.max_vshader_constantsF * 4 * sizeof(float));
}
TRACE(" 0x%08lx CONST(%lu, %lu)\n", token, constaddress, count);
for (i = 0; i < count; ++i) {

6
dlls/wined3d/vertexshader.c
View file

@ -567,7 +567,7 @@ static void vshader_set_limits(
This->baseShader.limits.packed_input = 0;
/* Must match D3DCAPS9.MaxVertexShaderConst: at least 256 for vs_2_0 */
This->baseShader.limits.constant_float = WINED3D_VSHADER_MAX_CONSTANTS;
This->baseShader.limits.constant_float = GL_LIMITS(vshader_constantsF);
switch (This->baseShader.hex_version) {
case D3DVS_VERSION(1,0):
@ -704,7 +704,7 @@ static VOID IWineD3DVertexShaderImpl_GenerateShader(
GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
/* Base Declarations */
shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer);
shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer, &GLINFO_LOCATION);
/* Base Shader Body */
shader_generate_main( (IWineD3DBaseShader*) This, &buffer, reg_maps, pFunction);
@ -740,7 +740,7 @@ static VOID IWineD3DVertexShaderImpl_GenerateShader(
min(95, This->baseShader.limits.constant_float);
/* Base Declarations */
shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer);
shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer, &GLINFO_LOCATION);
if (reg_maps->fog) {
This->usesFog = 1;

36
dlls/wined3d/wined3d_private.h
View file

@ -53,8 +53,8 @@
#define MAX_CLIPPLANES D3DMAXUSERCLIPPLANES
#define MAX_LEVELS 256
#define MAX_VSHADER_CONSTANTS 96
#define MAX_PSHADER_CONSTANTS 32
#define MAX_CONST_I 16
#define MAX_CONST_B 16
/* Used for CreateStateBlock */
#define NUM_SAVEDPIXELSTATES_R 35
@ -1021,13 +1021,13 @@ typedef struct SAVEDSTATES {
BOOL clipplane[MAX_CLIPPLANES];
BOOL vertexDecl;
BOOL pixelShader;
BOOL pixelShaderConstantsB[MAX_PSHADER_CONSTANTS];
BOOL pixelShaderConstantsI[MAX_PSHADER_CONSTANTS];
BOOL pixelShaderConstantsF[MAX_PSHADER_CONSTANTS];
BOOL pixelShaderConstantsB[MAX_CONST_B];
BOOL pixelShaderConstantsI[MAX_CONST_I];
BOOL *pixelShaderConstantsF;
BOOL vertexShader;
BOOL vertexShaderConstantsB[MAX_VSHADER_CONSTANTS];
BOOL vertexShaderConstantsI[MAX_VSHADER_CONSTANTS];
BOOL vertexShaderConstantsF[MAX_VSHADER_CONSTANTS];
BOOL vertexShaderConstantsB[MAX_CONST_B];
BOOL vertexShaderConstantsI[MAX_CONST_I];
BOOL *vertexShaderConstantsF;
} SAVEDSTATES;
struct IWineD3DStateBlockImpl
@ -1053,9 +1053,9 @@ struct IWineD3DStateBlockImpl
IWineD3DVertexShader *vertexShader;
/* Vertex Shader Constants */
BOOL vertexShaderConstantB[MAX_VSHADER_CONSTANTS];
INT vertexShaderConstantI[MAX_VSHADER_CONSTANTS * 4];
float vertexShaderConstantF[MAX_VSHADER_CONSTANTS * 4];
BOOL vertexShaderConstantB[MAX_CONST_B];
INT vertexShaderConstantI[MAX_CONST_I * 4];
float *vertexShaderConstantF;
/* Stream Source */
BOOL streamIsUP;
@ -1089,9 +1089,9 @@ struct IWineD3DStateBlockImpl
IWineD3DPixelShader *pixelShader;
/* Pixel Shader Constants */
BOOL pixelShaderConstantB[MAX_PSHADER_CONSTANTS];
INT pixelShaderConstantI[MAX_PSHADER_CONSTANTS * 4];
float pixelShaderConstantF[MAX_PSHADER_CONSTANTS * 4];
BOOL pixelShaderConstantB[MAX_CONST_B];
INT pixelShaderConstantI[MAX_CONST_I * 4];
float *pixelShaderConstantF;
/* Indexed Vertex Blending */
D3DVERTEXBLENDFLAGS vertex_blend;
@ -1417,6 +1417,8 @@ extern BOOL vshader_input_is_color(
IWineD3DVertexShader* iface,
unsigned int regnum);
extern HRESULT allocate_shader_constants(IWineD3DStateBlockImpl* object);
/* ARB_[vertex/fragment]_program helper functions */
extern void shader_arb_load_constants(
IWineD3DStateBlock* iface,
@ -1545,12 +1547,14 @@ extern HRESULT shader_get_registers_used(
extern void shader_generate_glsl_declarations(
IWineD3DBaseShader *iface,
shader_reg_maps* reg_maps,
SHADER_BUFFER* buffer);
SHADER_BUFFER* buffer,
WineD3D_GL_Info* gl_info);
extern void shader_generate_arb_declarations(
IWineD3DBaseShader *iface,
shader_reg_maps* reg_maps,
SHADER_BUFFER* buffer);
SHADER_BUFFER* buffer,
WineD3D_GL_Info* gl_info);
extern void shader_generate_main(
IWineD3DBaseShader *iface,

8
include/wine/wined3d_gl.h
View file

@ -1680,6 +1680,14 @@ typedef struct _WineD3D_GL_Info {
UINT max_blends;
UINT max_anisotropy;
unsigned max_vshader_constantsF;
unsigned max_pshader_constantsF;
unsigned vs_arb_constantsF;
unsigned ps_arb_constantsF;
unsigned vs_glsl_constantsF;
unsigned ps_glsl_constantsF;
GL_PSVersion ps_arb_version;
GL_PSVersion ps_nv_version;