2003-11-14 04:50:35 +01:00
|
|
|
/*
|
|
|
|
* shaders implementation
|
|
|
|
*
|
|
|
|
* Copyright 2002-2003 Jason Edmeades
|
2005-08-17 11:54:54 +02:00
|
|
|
* Copyright 2002-2003 Raphael Junqueira
|
2006-07-17 20:35:14 +02:00
|
|
|
* Copyright 2004 Christian Costa
|
2005-08-17 11:54:54 +02:00
|
|
|
* Copyright 2005 Oliver Stieber
|
2006-05-17 08:04:30 +02:00
|
|
|
* Copyright 2006 Ivan Gyurdiev
|
2008-10-18 19:21:20 +02:00
|
|
|
* Copyright 2007-2008 Stefan Dösinger for CodeWeavers
|
2009-09-25 13:31:43 +02:00
|
|
|
* Copyright 2009 Henri Verbeet for CodeWeavers
|
2003-11-14 04:50:35 +01:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
2006-05-18 14:49:52 +02:00
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
2003-11-14 04:50:35 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <math.h>
|
2005-08-17 13:34:03 +02:00
|
|
|
#include <stdio.h>
|
2003-11-14 04:50:35 +01:00
|
|
|
|
|
|
|
#include "wined3d_private.h"
|
|
|
|
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
|
|
|
|
|
2009-05-06 10:05:45 +02:00
|
|
|
static void vshader_set_limits(IWineD3DVertexShaderImpl *This)
|
|
|
|
{
|
2009-05-06 17:59:21 +02:00
|
|
|
DWORD shader_version = WINED3D_SHADER_VERSION(This->baseShader.reg_maps.shader_version.major,
|
|
|
|
This->baseShader.reg_maps.shader_version.minor);
|
2009-10-25 01:23:34 +02:00
|
|
|
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
|
2009-05-06 17:59:21 +02:00
|
|
|
|
2009-05-06 10:05:45 +02:00
|
|
|
This->baseShader.limits.texcoord = 0;
|
|
|
|
This->baseShader.limits.attributes = 16;
|
|
|
|
This->baseShader.limits.packed_input = 0;
|
2006-05-08 23:09:21 +02:00
|
|
|
|
2009-05-06 17:59:21 +02:00
|
|
|
switch (shader_version)
|
2009-05-06 10:05:45 +02:00
|
|
|
{
|
2009-05-06 17:59:21 +02:00
|
|
|
case WINED3D_SHADER_VERSION(1,0):
|
|
|
|
case WINED3D_SHADER_VERSION(1,1):
|
2009-05-06 10:05:45 +02:00
|
|
|
This->baseShader.limits.temporary = 12;
|
|
|
|
This->baseShader.limits.constant_bool = 0;
|
|
|
|
This->baseShader.limits.constant_int = 0;
|
|
|
|
This->baseShader.limits.address = 1;
|
|
|
|
This->baseShader.limits.packed_output = 0;
|
|
|
|
This->baseShader.limits.sampler = 0;
|
|
|
|
This->baseShader.limits.label = 0;
|
|
|
|
/* TODO: vs_1_1 has a minimum of 96 constants. What happens if a vs_1_1 shader is used
|
|
|
|
* on a vs_3_0 capable card that has 256 constants? */
|
2009-10-25 01:23:34 +02:00
|
|
|
This->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
|
2009-05-06 10:05:45 +02:00
|
|
|
break;
|
2006-05-08 23:09:21 +02:00
|
|
|
|
2009-05-06 17:59:21 +02:00
|
|
|
case WINED3D_SHADER_VERSION(2,0):
|
|
|
|
case WINED3D_SHADER_VERSION(2,1):
|
2009-05-06 10:05:45 +02:00
|
|
|
This->baseShader.limits.temporary = 12;
|
|
|
|
This->baseShader.limits.constant_bool = 16;
|
|
|
|
This->baseShader.limits.constant_int = 16;
|
|
|
|
This->baseShader.limits.address = 1;
|
|
|
|
This->baseShader.limits.packed_output = 0;
|
|
|
|
This->baseShader.limits.sampler = 0;
|
|
|
|
This->baseShader.limits.label = 16;
|
2009-10-25 01:23:34 +02:00
|
|
|
This->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
|
2009-05-06 10:05:45 +02:00
|
|
|
break;
|
2009-04-25 15:02:42 +02:00
|
|
|
|
2009-05-26 09:15:12 +02:00
|
|
|
case WINED3D_SHADER_VERSION(4,0):
|
|
|
|
FIXME("Using 3.0 limits for 4.0 shader\n");
|
|
|
|
/* Fall through */
|
|
|
|
|
2009-05-06 17:59:21 +02:00
|
|
|
case WINED3D_SHADER_VERSION(3,0):
|
2009-05-06 10:05:45 +02:00
|
|
|
This->baseShader.limits.temporary = 32;
|
|
|
|
This->baseShader.limits.constant_bool = 32;
|
|
|
|
This->baseShader.limits.constant_int = 32;
|
|
|
|
This->baseShader.limits.address = 1;
|
|
|
|
This->baseShader.limits.packed_output = 12;
|
|
|
|
This->baseShader.limits.sampler = 4;
|
|
|
|
This->baseShader.limits.label = 16; /* FIXME: 2048 */
|
|
|
|
/* DX10 cards on Windows advertise a d3d9 constant limit of 256 even though they are capable
|
|
|
|
* of supporting much more(GL drivers advertise 1024). d3d9.dll and d3d8.dll clamp the
|
|
|
|
* wined3d-advertised maximum. Clamp the constant limit for <= 3.0 shaders to 256.s
|
|
|
|
* use constant buffers */
|
2009-10-25 01:23:34 +02:00
|
|
|
This->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
|
2009-05-06 10:05:45 +02:00
|
|
|
break;
|
2006-05-08 23:09:21 +02:00
|
|
|
|
2009-05-06 10:05:45 +02:00
|
|
|
default:
|
|
|
|
This->baseShader.limits.temporary = 12;
|
|
|
|
This->baseShader.limits.constant_bool = 16;
|
|
|
|
This->baseShader.limits.constant_int = 16;
|
|
|
|
This->baseShader.limits.address = 1;
|
|
|
|
This->baseShader.limits.packed_output = 0;
|
|
|
|
This->baseShader.limits.sampler = 0;
|
|
|
|
This->baseShader.limits.label = 16;
|
2009-10-25 01:23:34 +02:00
|
|
|
This->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
|
2009-05-06 17:59:21 +02:00
|
|
|
FIXME("Unrecognized vertex shader version %u.%u\n",
|
|
|
|
This->baseShader.reg_maps.shader_version.major,
|
|
|
|
This->baseShader.reg_maps.shader_version.minor);
|
2009-05-06 10:05:45 +02:00
|
|
|
}
|
2006-05-08 23:09:21 +02:00
|
|
|
}
|
|
|
|
|
2007-02-27 20:51:18 +01:00
|
|
|
static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2) {
|
|
|
|
if (usage_idx1 != usage_idx2) return FALSE;
|
|
|
|
if (usage1 == usage2) return TRUE;
|
|
|
|
if (usage1 == WINED3DDECLUSAGE_POSITION && usage2 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
|
|
|
|
if (usage2 == WINED3DDECLUSAGE_POSITION && usage1 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2009-05-27 10:24:49 +02:00
|
|
|
BOOL vshader_get_input(IWineD3DVertexShader* iface, BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum)
|
|
|
|
{
|
|
|
|
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
|
|
|
WORD map = This->baseShader.reg_maps.input_registers;
|
|
|
|
unsigned int i;
|
2006-07-07 08:27:38 +02:00
|
|
|
|
2009-05-27 10:24:49 +02:00
|
|
|
for (i = 0; map; map >>= 1, ++i)
|
|
|
|
{
|
|
|
|
if (!(map & 1)) continue;
|
2009-04-08 08:35:07 +02:00
|
|
|
|
2009-05-27 10:24:50 +02:00
|
|
|
if (match_usage(This->attributes[i].usage,
|
|
|
|
This->attributes[i].usage_idx, usage_req, usage_idx_req))
|
2009-04-08 08:35:07 +02:00
|
|
|
{
|
2006-07-07 08:27:38 +02:00
|
|
|
*regnum = i;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2005-03-02 13:16:10 +01:00
|
|
|
/* *******************************************
|
|
|
|
IWineD3DVertexShader IUnknown parts follow
|
|
|
|
******************************************* */
|
2007-11-16 21:01:33 +01:00
|
|
|
static HRESULT WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj) {
|
2008-12-09 09:52:39 +01:00
|
|
|
TRACE("iface %p, riid %s, ppobj %p\n", iface, debugstr_guid(riid), ppobj);
|
|
|
|
|
|
|
|
if (IsEqualGUID(riid, &IID_IWineD3DVertexShader)
|
|
|
|
|| IsEqualGUID(riid, &IID_IWineD3DBaseShader)
|
|
|
|
|| IsEqualGUID(riid, &IID_IWineD3DBase)
|
|
|
|
|| IsEqualGUID(riid, &IID_IUnknown))
|
|
|
|
{
|
|
|
|
IUnknown_AddRef(iface);
|
|
|
|
*ppobj = iface;
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
|
|
|
|
|
|
|
|
*ppobj = NULL;
|
|
|
|
return E_NOINTERFACE;
|
2005-03-02 13:16:10 +01:00
|
|
|
}
|
|
|
|
|
2007-11-16 21:01:33 +01:00
|
|
|
static ULONG WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
|
2008-12-09 09:52:39 +01:00
|
|
|
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
|
|
|
ULONG refcount = InterlockedIncrement(&This->baseShader.ref);
|
|
|
|
|
|
|
|
TRACE("%p increasing refcount to %u\n", This, refcount);
|
|
|
|
|
|
|
|
return refcount;
|
2005-03-02 13:16:10 +01:00
|
|
|
}
|
|
|
|
|
2006-06-10 13:15:32 +02:00
|
|
|
static ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
|
2008-12-09 09:52:39 +01:00
|
|
|
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
|
|
|
ULONG refcount = InterlockedDecrement(&This->baseShader.ref);
|
|
|
|
|
|
|
|
TRACE("%p decreasing refcount to %u\n", This, refcount);
|
|
|
|
|
|
|
|
if (!refcount)
|
|
|
|
{
|
|
|
|
shader_cleanup((IWineD3DBaseShader *)iface);
|
2009-09-25 13:31:44 +02:00
|
|
|
This->baseShader.parent_ops->wined3d_object_destroyed(This->baseShader.parent);
|
2008-12-09 09:52:39 +01:00
|
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
|
|
}
|
|
|
|
|
|
|
|
return refcount;
|
2005-03-02 13:16:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* *******************************************
|
|
|
|
IWineD3DVertexShader IWineD3DVertexShader parts follow
|
|
|
|
******************************************* */
|
|
|
|
|
2006-06-10 13:15:32 +02:00
|
|
|
static HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){
|
2005-03-02 13:16:10 +01:00
|
|
|
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
|
2009-08-27 10:04:56 +02:00
|
|
|
|
2009-09-25 13:31:44 +02:00
|
|
|
*parent = This->baseShader.parent;
|
2005-03-02 13:16:10 +01:00
|
|
|
IUnknown_AddRef(*parent);
|
|
|
|
TRACE("(%p) : returning %p\n", This, *parent);
|
2006-04-07 12:51:12 +02:00
|
|
|
return WINED3D_OK;
|
2005-03-02 13:16:10 +01:00
|
|
|
}
|
2005-07-13 16:15:54 +02:00
|
|
|
|
2006-06-10 13:15:32 +02:00
|
|
|
static HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* impl, VOID* pData, UINT* pSizeOfData) {
|
2005-08-17 11:54:54 +02:00
|
|
|
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)impl;
|
2006-06-09 23:46:38 +02:00
|
|
|
TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This, pData, pSizeOfData);
|
2005-03-02 13:16:10 +01:00
|
|
|
|
2005-08-17 11:54:54 +02:00
|
|
|
if (NULL == pData) {
|
2006-03-30 19:14:31 +02:00
|
|
|
*pSizeOfData = This->baseShader.functionLength;
|
2006-04-07 12:51:12 +02:00
|
|
|
return WINED3D_OK;
|
2005-08-17 11:54:54 +02:00
|
|
|
}
|
2006-03-30 19:14:31 +02:00
|
|
|
if (*pSizeOfData < This->baseShader.functionLength) {
|
2007-03-08 01:16:09 +01:00
|
|
|
/* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
|
|
|
|
* than the required size we should write the required size and
|
|
|
|
* return D3DERR_MOREDATA. That's not actually true. */
|
|
|
|
return WINED3DERR_INVALIDCALL;
|
2005-08-17 11:54:54 +02:00
|
|
|
}
|
2008-12-15 16:35:14 +01:00
|
|
|
|
|
|
|
TRACE("(%p) : GetFunction copying to %p\n", This, pData);
|
|
|
|
memcpy(pData, This->baseShader.function, This->baseShader.functionLength);
|
|
|
|
|
2006-04-07 12:51:12 +02:00
|
|
|
return WINED3D_OK;
|
2005-03-02 13:16:10 +01:00
|
|
|
}
|
|
|
|
|
2009-09-25 13:31:43 +02:00
|
|
|
static HRESULT vertexshader_set_function(IWineD3DVertexShaderImpl *shader,
|
|
|
|
const DWORD *byte_code, const struct wined3d_shader_signature *output_signature)
|
2009-05-08 17:44:25 +02:00
|
|
|
{
|
2009-09-25 13:31:43 +02:00
|
|
|
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)shader->baseShader.device;
|
|
|
|
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
|
2009-05-04 09:49:27 +02:00
|
|
|
const struct wined3d_shader_frontend *fe;
|
2009-05-28 08:44:21 +02:00
|
|
|
unsigned int i;
|
2006-07-10 06:51:03 +02:00
|
|
|
HRESULT hr;
|
2009-09-25 13:31:43 +02:00
|
|
|
shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
|
2006-05-17 08:04:30 +02:00
|
|
|
|
2009-09-25 13:31:43 +02:00
|
|
|
TRACE("shader %p, byte_code %p, output_signature %p.\n", shader, byte_code, output_signature);
|
2006-07-25 00:51:03 +02:00
|
|
|
|
2009-09-25 13:31:43 +02:00
|
|
|
fe = shader_select_frontend(*byte_code);
|
2009-05-04 09:49:27 +02:00
|
|
|
if (!fe)
|
|
|
|
{
|
|
|
|
FIXME("Unable to find frontend for shader.\n");
|
|
|
|
return WINED3DERR_INVALIDCALL;
|
|
|
|
}
|
2009-09-25 13:31:43 +02:00
|
|
|
shader->baseShader.frontend = fe;
|
|
|
|
shader->baseShader.frontend_data = fe->shader_init(byte_code, output_signature);
|
|
|
|
if (!shader->baseShader.frontend_data)
|
2009-05-05 09:38:03 +02:00
|
|
|
{
|
|
|
|
FIXME("Failed to initialize frontend.\n");
|
|
|
|
return WINED3DERR_INVALIDCALL;
|
|
|
|
}
|
2009-05-04 09:49:27 +02:00
|
|
|
|
2006-07-04 10:01:46 +02:00
|
|
|
/* First pass: trace shader */
|
2009-09-25 13:31:43 +02:00
|
|
|
if (TRACE_ON(d3d_shader)) shader_trace_init(fe, shader->baseShader.frontend_data, byte_code);
|
2005-03-02 13:16:10 +01:00
|
|
|
|
2006-07-10 06:51:03 +02:00
|
|
|
/* Initialize immediate constant lists */
|
2009-09-25 13:31:43 +02:00
|
|
|
list_init(&shader->baseShader.constantsF);
|
|
|
|
list_init(&shader->baseShader.constantsB);
|
|
|
|
list_init(&shader->baseShader.constantsI);
|
2006-07-10 06:51:03 +02:00
|
|
|
|
2006-07-04 10:01:46 +02:00
|
|
|
/* Second pass: figure out registers used, semantics, etc.. */
|
2009-10-25 01:23:34 +02:00
|
|
|
shader->min_rel_offset = device->d3d_vshader_constantF;
|
2009-09-25 13:31:43 +02:00
|
|
|
shader->max_rel_offset = 0;
|
|
|
|
hr = shader_get_registers_used((IWineD3DBaseShader *)shader, fe,
|
|
|
|
reg_maps, shader->attributes, NULL, shader->output_signature,
|
2009-10-25 01:23:34 +02:00
|
|
|
byte_code, device->d3d_vshader_constantF);
|
2006-07-10 06:51:03 +02:00
|
|
|
if (hr != WINED3D_OK) return hr;
|
2006-07-04 10:01:46 +02:00
|
|
|
|
2009-05-28 08:44:21 +02:00
|
|
|
if (output_signature)
|
|
|
|
{
|
|
|
|
for (i = 0; i < output_signature->element_count; ++i)
|
|
|
|
{
|
|
|
|
struct wined3d_shader_signature_element *e = &output_signature->elements[i];
|
|
|
|
reg_maps->output_registers |= 1 << e->register_idx;
|
2009-09-25 13:31:43 +02:00
|
|
|
shader->output_signature[e->register_idx] = *e;
|
2009-05-28 08:44:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-25 13:31:43 +02:00
|
|
|
vshader_set_limits(shader);
|
2008-12-11 11:52:37 +01:00
|
|
|
|
2009-09-25 13:31:43 +02:00
|
|
|
if (device->vs_selected_mode == SHADER_ARB
|
|
|
|
&& (gl_info->quirks & WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT)
|
|
|
|
&& shader->min_rel_offset <= shader->max_rel_offset)
|
2009-07-01 09:46:19 +02:00
|
|
|
{
|
2009-09-25 13:31:43 +02:00
|
|
|
if (shader->max_rel_offset - shader->min_rel_offset > 127)
|
|
|
|
{
|
2007-11-07 19:57:49 +01:00
|
|
|
FIXME("The difference between the minimum and maximum relative offset is > 127\n");
|
|
|
|
FIXME("Which this OpenGL implementation does not support. Try using GLSL\n");
|
2009-09-25 13:31:43 +02:00
|
|
|
FIXME("Min: %d, Max: %d\n", shader->min_rel_offset, shader->max_rel_offset);
|
|
|
|
}
|
|
|
|
else if (shader->max_rel_offset - shader->min_rel_offset > 63)
|
|
|
|
{
|
|
|
|
shader->rel_offset = shader->min_rel_offset + 63;
|
|
|
|
}
|
|
|
|
else if (shader->max_rel_offset > 63)
|
|
|
|
{
|
|
|
|
shader->rel_offset = shader->min_rel_offset;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
shader->rel_offset = 0;
|
2007-11-07 19:57:49 +01:00
|
|
|
}
|
|
|
|
}
|
2009-09-25 13:31:43 +02:00
|
|
|
shader->baseShader.load_local_constsF = shader->baseShader.reg_maps.usesrelconstF
|
|
|
|
&& !list_empty(&shader->baseShader.constantsF);
|
2007-11-07 19:57:49 +01:00
|
|
|
|
2005-08-17 13:34:03 +02:00
|
|
|
/* copy the function ... because it will certainly be released by application */
|
2009-09-25 13:31:43 +02:00
|
|
|
shader->baseShader.function = HeapAlloc(GetProcessHeap(), 0, shader->baseShader.functionLength);
|
|
|
|
if (!shader->baseShader.function) return E_OUTOFMEMORY;
|
|
|
|
memcpy(shader->baseShader.function, byte_code, shader->baseShader.functionLength);
|
wined3d: Rework shader mode selection.
- currently half the shader selection code (GLSL vs ARB) is in
fillGLcaps. The parts that check for software shaders are in
GetDeviceCaps. That placement, will work, but is definitely not optimal.
FillGLcaps should detect support - it should not make decision as to
what's used, because that's not what the purpose of the function is.
GetDeviceCaps should report support as it has already been selected.
Instead, select shader mode in its own function, called in the
appropriate places.
- unifying pixel and vertex shaders into a single selection is a
mistake. A software vertex shader can be coupled with a hardware arb or
glsl pixel shader, or no shader at all. Split them back into two and add
a SHADER_NONE variant.
- drawprim is doing support checks for ARB_PROGRAM, and making shader
decisions based on that - that's wrong, support has already been
checked, and decided upon, and shaders can be implemented via software,
ARB_PROGRAm or GLSL, so that support check isn't valid.
- Store the shader selected mode into the shader itself. Different types
of shaders can be combined, so this is an improvement. In fact, storing
the mode into the settings globally is a mistake as well - it should be
done per device, since different cards have different capabilities.
2006-07-04 09:21:53 +02:00
|
|
|
|
2006-04-07 12:51:12 +02:00
|
|
|
return WINED3D_OK;
|
2005-08-17 13:34:03 +02:00
|
|
|
}
|
2005-03-02 13:16:10 +01:00
|
|
|
|
2007-02-13 23:12:40 +01:00
|
|
|
/* Set local constants for d3d8 shaders */
|
|
|
|
static HRESULT WINAPI IWIneD3DVertexShaderImpl_SetLocalConstantsF(IWineD3DVertexShader *iface,
|
|
|
|
UINT start_idx, const float *src_data, UINT count) {
|
|
|
|
IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
|
2009-10-25 01:23:34 +02:00
|
|
|
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
|
2007-02-13 23:12:40 +01:00
|
|
|
UINT i, end_idx;
|
|
|
|
|
|
|
|
TRACE("(%p) : start_idx %u, src_data %p, count %u\n", This, start_idx, src_data, count);
|
|
|
|
|
|
|
|
end_idx = start_idx + count;
|
2009-10-25 01:23:34 +02:00
|
|
|
if (end_idx > device->d3d_vshader_constantF)
|
2009-10-22 10:09:54 +02:00
|
|
|
{
|
2009-10-25 01:23:34 +02:00
|
|
|
WARN("end_idx %u > float constants limit %u\n", end_idx, device->d3d_vshader_constantF);
|
|
|
|
end_idx = device->d3d_vshader_constantF;
|
2007-02-13 23:12:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = start_idx; i < end_idx; ++i) {
|
|
|
|
local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
|
|
|
|
if (!lconst) return E_OUTOFMEMORY;
|
|
|
|
|
|
|
|
lconst->idx = i;
|
2007-06-16 11:44:08 +02:00
|
|
|
memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
|
2007-02-13 23:12:40 +01:00
|
|
|
list_add_head(&This->baseShader.constantsF, &lconst->entry);
|
|
|
|
}
|
|
|
|
|
2007-02-14 23:30:40 +01:00
|
|
|
return WINED3D_OK;
|
2007-02-13 23:12:40 +01:00
|
|
|
}
|
|
|
|
|
2009-09-23 18:42:04 +02:00
|
|
|
static const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
|
2005-03-02 13:16:10 +01:00
|
|
|
{
|
|
|
|
/*** IUnknown methods ***/
|
|
|
|
IWineD3DVertexShaderImpl_QueryInterface,
|
|
|
|
IWineD3DVertexShaderImpl_AddRef,
|
|
|
|
IWineD3DVertexShaderImpl_Release,
|
2006-03-28 21:10:51 +02:00
|
|
|
/*** IWineD3DBase methods ***/
|
2005-03-02 13:16:10 +01:00
|
|
|
IWineD3DVertexShaderImpl_GetParent,
|
2006-03-28 21:10:51 +02:00
|
|
|
/*** IWineD3DBaseShader methods ***/
|
2007-02-13 23:12:29 +01:00
|
|
|
IWineD3DVertexShaderImpl_GetFunction,
|
2009-09-25 13:31:42 +02:00
|
|
|
/*** IWineD3DVertexShader methods ***/
|
2007-02-13 23:12:40 +01:00
|
|
|
IWIneD3DVertexShaderImpl_SetLocalConstantsF
|
2005-03-02 13:16:10 +01:00
|
|
|
};
|
2009-02-05 19:44:32 +01:00
|
|
|
|
|
|
|
void find_vs_compile_args(IWineD3DVertexShaderImpl *shader, IWineD3DStateBlockImpl *stateblock, struct vs_compile_args *args) {
|
|
|
|
args->fog_src = stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE ? VS_FOG_COORD : VS_FOG_Z;
|
2009-11-01 17:03:39 +01:00
|
|
|
args->clip_enabled = stateblock->renderState[WINED3DRS_CLIPPING] && stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
|
2009-02-05 19:44:32 +01:00
|
|
|
args->swizzle_map = ((IWineD3DDeviceImpl *)shader->baseShader.device)->strided_streams.swizzle_map;
|
|
|
|
}
|
2009-09-23 18:42:04 +02:00
|
|
|
|
|
|
|
HRESULT vertexshader_init(IWineD3DVertexShaderImpl *shader, IWineD3DDeviceImpl *device,
|
|
|
|
const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
|
2009-09-23 18:42:08 +02:00
|
|
|
IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
|
2009-09-23 18:42:04 +02:00
|
|
|
{
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
|
|
if (!byte_code) return WINED3DERR_INVALIDCALL;
|
|
|
|
|
|
|
|
shader->lpVtbl = &IWineD3DVertexShader_Vtbl;
|
2009-09-25 13:31:44 +02:00
|
|
|
shader_init(&shader->baseShader, device, parent, parent_ops);
|
2009-09-23 18:42:04 +02:00
|
|
|
|
2009-09-25 13:31:43 +02:00
|
|
|
hr = vertexshader_set_function(shader, byte_code, output_signature);
|
2009-09-23 18:42:04 +02:00
|
|
|
if (FAILED(hr))
|
|
|
|
{
|
|
|
|
WARN("Failed to set function, hr %#x.\n", hr);
|
|
|
|
shader_cleanup((IWineD3DBaseShader *)shader);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return WINED3D_OK;
|
|
|
|
}
|