stateblock.c revision 4b9d6701570cb98fd36e209314239d104ec584d3
/*
* state block implementation
*
* Copyright 2002 Raphael Junqueira
* Copyright 2004 Jason Edmeades
* Copyright 2005 Oliver Stieber
* Copyright 2007 Stefan Dösinger for CodeWeavers
* Copyright 2009 Henri Verbeet for CodeWeavers
*
* 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
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
/*
* Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
* other than GPL or LGPL is available it will apply instead, Oracle elects to use only
* the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
* a choice of LGPL license versions is made available with the language indicating
* that LGPLv2 or any later version may be used, or where a choice of which version
* of the LGPL is applied is otherwise unspecified.
*/
#include "config.h"
#include "wined3d_private.h"
static const DWORD pixel_states_render[] =
{
};
static const DWORD pixel_states_texture[] =
{
};
static const DWORD pixel_states_sampler[] =
{
};
static const DWORD vertex_states_render[] =
{
};
static const DWORD vertex_states_texture[] =
{
};
static const DWORD vertex_states_sampler[] =
{
};
/* Allocates the correct amount of space for pixel and vertex shader constants,
*/
{
/* Allocate space for floating point constants */
return WINED3D_OK;
fail:
ERR("Failed to allocate memory\n");
return E_OUTOFMEMORY;
}
{
}
/* Set all members of a stateblock savedstate to the given value */
{
unsigned int i;
/* Single values */
/* Fixed size arrays */
/* Dynamically sized arrays */
}
{
DWORD texture_mask = 0;
WORD sampler_mask = 0;
unsigned int i;
for (i = 0; i < sizeof(pixel_states_render) / sizeof(*pixel_states_render); ++i)
{
}
for (i = 0; i < sizeof(pixel_states_texture) / sizeof(*pixel_states_texture); ++i)
for (i = 0; i < sizeof(pixel_states_sampler) / sizeof(*pixel_states_sampler); ++i)
}
{
DWORD texture_mask = 0;
WORD sampler_mask = 0;
unsigned int i;
for (i = 0; i < sizeof(vertex_states_render) / sizeof(*vertex_states_render); ++i)
{
}
for (i = 0; i < sizeof(vertex_states_texture) / sizeof(*vertex_states_texture); ++i)
for (i = 0; i < sizeof(vertex_states_sampler) / sizeof(*vertex_states_sampler); ++i)
}
{
unsigned int i, j;
for (i = 0; i <= WINEHIGHEST_RENDER_STATE >> 5; ++i)
{
{
if (!(map & 1)) continue;
}
}
for (i = 0; i <= HIGHEST_TRANSFORMSTATE >> 5; ++i)
{
{
if (!(map & 1)) continue;
}
}
for (i = 0; i < device->d3d_vshader_constantF; ++i)
{
{
}
}
for (i = 0; i < MAX_CONST_I; ++i)
{
{
}
}
for (i = 0; i < MAX_CONST_B; ++i)
{
{
}
}
for (i = 0; i < device->d3d_pshader_constantF; ++i)
{
{
}
}
for (i = 0; i < MAX_CONST_I; ++i)
{
{
}
}
for (i = 0; i < MAX_CONST_B; ++i)
{
{
}
}
for (i = 0; i < MAX_TEXTURES; ++i)
{
{
if (!(map & 1)) continue;
}
}
for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
{
{
if (!(map & 1)) continue;
}
}
}
{
unsigned int i;
for (i = 0; i < LIGHTMAP_SIZE; ++i)
{
const struct wined3d_light_info *src_light;
{
}
}
}
/**********************************************************
* IWineD3DStateBlockImpl IUnknown parts follows
**********************************************************/
static HRESULT WINAPI IWineD3DStateBlockImpl_QueryInterface(IWineD3DStateBlock *iface,REFIID riid,LPVOID *ppobj)
{
{
return S_OK;
}
return E_NOINTERFACE;
}
return refCount;
}
if (!refCount) {
int counter;
{
}
{
TRACE("Vertex buffer still referenced by stateblock, applications has leaked Stream %u, buffer %p\n", counter, This->streamSource[counter]);
}
}
}
{
}
}
}
return refCount;
}
/**********************************************************
* IWineD3DStateBlockImpl parts follows
**********************************************************/
static void record_lights(IWineD3DStateBlockImpl *This, const IWineD3DStateBlockImpl *targetStateBlock)
{
UINT 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
*/
for(i = 0; i < LIGHTMAP_SIZE; i++) {
struct list *e, *f;
/* Look up the light in the destination */
{
{
/* Light disabled */
}
{
/* Light enabled */
}
break;
}
}
if (!updated)
{
/* This can happen if the light was originally created as a
* default light for SetLightEnable() while recording. */
WARN("Light %u in stateblock %p does not exist in device stateblock %p.\n",
{
}
}
}
}
}
{
unsigned int i;
{
TRACE("Updating vertex shader from %p to %p\n", This->vertexShader, targetStateBlock->vertexShader);
}
/* Vertex Shader Float Constants */
for (i = 0; i < This->num_contained_vs_consts_f; ++i)
{
TRACE("Setting %p from %p %u to {%.8e, %.8e, %.8e, %.8e}.\n",
}
/* Vertex Shader Integer Constants */
for (i = 0; i < This->num_contained_vs_consts_i; ++i)
{
TRACE("Setting %p from %p %u to {%d, %d, %d, %d}.\n",
}
/* Vertex Shader Boolean Constants */
for (i = 0; i < This->num_contained_vs_consts_b; ++i)
{
TRACE("Setting %p from %p %u to %s.\n",
}
/* Pixel Shader Float Constants */
for (i = 0; i < This->num_contained_ps_consts_f; ++i)
{
TRACE("Setting %p from %p %u to {%.8e, %.8e, %.8e, %.8e}.\n",
}
/* Pixel Shader Integer Constants */
for (i = 0; i < This->num_contained_ps_consts_i; ++i)
{
TRACE("Setting %p from %p %u to {%d, %d, %d, %d}.\n",
}
/* Pixel Shader Boolean Constants */
for (i = 0; i < This->num_contained_ps_consts_b; ++i)
{
}
/* Others + Render & Texture */
for (i = 0; i < This->num_contained_transform_states; ++i)
{
}
{
TRACE("Updating pIndexData to %p, baseVertexIndex to %d.\n",
}
{
TRACE("Updating vertex declaration from %p to %p.\n", This->vertexDecl, targetStateBlock->vertexDecl);
}
{
TRACE("Updating material.\n");
}
{
TRACE("Updating viewport.\n");
}
{
TRACE("Updating scissor rect.\n");
}
{
if (!(map & 1)) continue;
{
TRACE("Updating stream source %u to %p, stride to %u.\n",
}
}
{
if (!(map & 1)) continue;
{
TRACE("Updating stream frequency %u to %u flags to %#x.\n",
}
}
{
if (!(map & 1)) continue;
{
TRACE("Updating clipplane %u.\n", i);
}
}
/* Render */
for (i = 0; i < This->num_contained_render_states; ++i)
{
}
/* Texture states */
for (i = 0; i < This->num_contained_tss_states; ++i)
{
}
/* Samplers */
{
if (!(map & 1)) continue;
TRACE("Updating texture %u to %p (was %p).\n", i, targetStateBlock->textures[i], This->textures[i]);
}
for (i = 0; i < This->num_contained_sampler_states; ++i)
{
}
{
}
return WINED3D_OK;
}
{
UINT i;
for(i = 0; i < LIGHTMAP_SIZE; i++) {
struct list *e;
{
}
}
}
{
unsigned int i;
/* Vertex Shader Constants */
for (i = 0; i < This->num_contained_vs_consts_f; ++i)
{
}
for (i = 0; i < This->num_contained_vs_consts_i; ++i)
{
}
for (i = 0; i < This->num_contained_vs_consts_b; ++i)
{
}
/* Pixel Shader Constants */
for (i = 0; i < This->num_contained_ps_consts_f; ++i)
{
}
for (i = 0; i < This->num_contained_ps_consts_i; ++i)
{
}
for (i = 0; i < This->num_contained_ps_consts_b; ++i)
{
}
/* Render */
for (i = 0; i < This->num_contained_render_states; ++i)
{
}
/* Texture states */
for (i = 0; i < This->num_contained_tss_states; ++i)
{
}
/* Sampler states */
for (i = 0; i < This->num_contained_sampler_states; ++i)
{
}
for (i = 0; i < This->num_contained_transform_states; ++i)
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
if (map & 1) IWineD3DDevice_SetStreamSource(pDevice, i, This->streamSource[i], 0, This->streamStride[i]);
}
{
if (map & 1) IWineD3DDevice_SetStreamSourceFreq(pDevice, i, This->streamFreq[i] | This->streamFlags[i]);
}
{
if (!(map & 1)) continue;
}
{
float clip[4];
if (!(map & 1)) continue;
}
for (i = 0; i < MAX_TEXTURES - 1; ++i)
{
{
break;
}
}
return WINED3D_OK;
}
union {
DWORD d;
} lp;
union {
float f;
DWORD d;
} tmpfloat;
unsigned int i;
/* Note this may have a large overhead but it should only be executed
once, in order to initialize the complete state of the device and
all opengl equivalents */
/* TODO: make a special stateblock type for the primary stateblock (it never gets applied so it doesn't need a real type) */
/* Set some of the defaults for lights, transforms etc */
for (i = 0; i < 256; ++i) {
}
TRACE("Render states\n");
/* Render states: */
} else {
}
tmpfloat.f = 0.0f;
tmpfloat.f = 1.0f;
tmpfloat.f = 1.0f;
tmpfloat.f = 1.0f;
tmpfloat.f = 1.0f;
tmpfloat.f = 1.0f;
tmpfloat.f = 0.0f;
tmpfloat.f = 0.0f;
tmpfloat.f = 1.0f;
tmpfloat.f = 0.0f;
/* states new in d3d9 */
tmpfloat.f = 1.0f;
tmpfloat.f = 0.0f;
tmpfloat.f = 1.0f;
tmpfloat.f = 0.0f;
/* clipping status */
/* Texture Stage States - Put directly into state block, we will call function below */
for (i = 0; i < MAX_TEXTURES; i++) {
TRACE("Setting up default texture states for texture Stage %d\n", i);
}
/* Sampler states*/
for (i = 0 ; i < MAX_COMBINED_SAMPLERS; i++) {
TRACE("Setting up default samplers states for sampler %d\n", i);
This->samplerState[i][WINED3DSAMP_ELEMENTINDEX ] = 0; /* TODO: Indicates which element of a multielement texture to use */
This->samplerState[i][WINED3DSAMP_DMAPOFFSET ] = 0; /* TODO: Vertex offset in the presampled displacement map */
}
{
/* Note: This avoids calling SetTexture, so pretend it has been called */
}
/* check the return values, because the GetBackBuffer call isn't valid for ddraw */
{
/* Set the default scissor rect values */
scissorrect.left = 0;
scissorrect.top = 0;
}
/* Set the default viewport */
vp.X = 0;
vp.Y = 0;
}
TRACE("-----------------------> Device defaults now set up...\n");
return WINED3D_OK;
}
/**********************************************************
* IWineD3DStateBlock VTbl follows
**********************************************************/
static const IWineD3DStateBlockVtbl IWineD3DStateBlock_Vtbl =
{
/* IUnknown */
/* IWineD3DStateBlock */
};
HRESULT stateblock_init(IWineD3DStateBlockImpl *stateblock, IWineD3DDeviceImpl *device, WINED3DSTATEBLOCKTYPE type)
{
unsigned int i;
for (i = 0; i < LIGHTMAP_SIZE; i++)
{
}
/* The WINED3DSBT_INIT stateblock type is used during initialization to
* produce a placeholder stateblock so other functions called can update a
* state block. */
switch (type)
{
case WINED3DSBT_ALL:
break;
case WINED3DSBT_PIXELSTATE:
break;
case WINED3DSBT_VERTEXSTATE:
break;
default:
break;
}
return WINED3D_OK;
}