2006-12-05 23:36:10 +01:00
|
|
|
|
/*
|
|
|
|
|
* Direct3D state management
|
|
|
|
|
*
|
2007-01-10 11:38:00 +01:00
|
|
|
|
* Copyright 2002 Lionel Ulmer
|
|
|
|
|
* Copyright 2002-2005 Jason Edmeades
|
|
|
|
|
* Copyright 2003-2004 Raphael Junqueira
|
|
|
|
|
* Copyright 2004 Christian Costa
|
|
|
|
|
* Copyright 2005 Oliver Stieber
|
|
|
|
|
* Copyright 2006 Henri Verbeet
|
|
|
|
|
* Copyright 2006-2007 Stefan D<EFBFBD>singer for CodeWeavers
|
2006-12-05 23:36:10 +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
|
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#ifdef HAVE_FLOAT_H
|
|
|
|
|
# include <float.h>
|
|
|
|
|
#endif
|
|
|
|
|
#include "wined3d_private.h"
|
|
|
|
|
|
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
|
2006-12-05 23:36:10 +01:00
|
|
|
|
|
2006-12-08 20:21:43 +01:00
|
|
|
|
#define GLINFO_LOCATION ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
|
|
|
|
|
|
2006-12-06 13:22:12 +01:00
|
|
|
|
static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* Used for states which are not mapped to a gl state as-is, but used somehow different,
|
|
|
|
|
* e.g as a parameter for drawing, or which are unimplemented in windows d3d
|
|
|
|
|
*/
|
|
|
|
|
if(STATE_IS_RENDER(state)) {
|
|
|
|
|
WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
|
|
|
|
|
TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
|
|
|
|
|
} else {
|
|
|
|
|
/* Shouldn't have an unknown type here */
|
|
|
|
|
FIXME("%d no direct mapping to gl of state with unknown type\n", state);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* Print a WARN, this allows the stateblock code to loop over all states to generate a display
|
|
|
|
|
* list without causing confusing terminal output. Deliberately no special debug name here
|
|
|
|
|
* because its undefined.
|
|
|
|
|
*/
|
|
|
|
|
WARN("undefined state %d\n", state);
|
2006-12-05 23:36:10 +01:00
|
|
|
|
}
|
|
|
|
|
|
2006-12-05 23:45:35 +01:00
|
|
|
|
static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
|
|
|
|
|
|
|
|
|
|
switch(Value) {
|
|
|
|
|
case D3DFILL_POINT:
|
|
|
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
|
|
|
|
|
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
|
|
|
|
|
break;
|
|
|
|
|
case D3DFILL_WIREFRAME:
|
|
|
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
|
|
|
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
|
|
|
|
|
break;
|
|
|
|
|
case D3DFILL_SOLID:
|
|
|
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
|
|
|
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:39:55 +01:00
|
|
|
|
static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2007-01-02 22:49:17 +01:00
|
|
|
|
BOOL normals;
|
2006-12-08 01:39:55 +01:00
|
|
|
|
|
2007-01-02 22:49:17 +01:00
|
|
|
|
/* Lighting is only enabled if Vertex normals are passed by the application,
|
|
|
|
|
* but lighting does not affect the stream sources, so it is not grouped for performance reasons.
|
|
|
|
|
* This state reads the decoded vertex decl, so if it is dirty don't do anything. The
|
|
|
|
|
* vertex declaration appplying function calls this function for updating
|
2006-12-08 01:39:55 +01:00
|
|
|
|
*/
|
|
|
|
|
|
2007-01-10 11:37:03 +01:00
|
|
|
|
if(isStateDirty(stateblock->wineD3DDevice, STATE_VDECL)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2007-01-02 22:49:17 +01:00
|
|
|
|
|
|
|
|
|
normals = stateblock->wineD3DDevice->strided_streams.u.s.normal.lpData != NULL ||
|
|
|
|
|
stateblock->wineD3DDevice->strided_streams.u.s.normal.VBO != 0;
|
|
|
|
|
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_LIGHTING] && normals) {
|
2006-12-08 01:39:55 +01:00
|
|
|
|
glEnable(GL_LIGHTING);
|
|
|
|
|
checkGLcall("glEnable GL_LIGHTING");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_LIGHTING);
|
|
|
|
|
checkGLcall("glDisable GL_LIGHTING");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:40:51 +01:00
|
|
|
|
static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
|
|
|
|
|
case WINED3DZB_FALSE:
|
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
|
checkGLcall("glDisable GL_DEPTH_TEST");
|
|
|
|
|
break;
|
|
|
|
|
case WINED3DZB_TRUE:
|
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
|
checkGLcall("glEnable GL_DEPTH_TEST");
|
|
|
|
|
break;
|
|
|
|
|
case WINED3DZB_USEW:
|
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
|
checkGLcall("glEnable GL_DEPTH_TEST");
|
|
|
|
|
FIXME("W buffer is not well handled\n");
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:41:43 +01:00
|
|
|
|
static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
|
|
|
|
|
|
|
|
|
|
/* If we are culling "back faces with clockwise vertices" then
|
|
|
|
|
set front faces to be counter clockwise and enable culling
|
|
|
|
|
of back faces */
|
|
|
|
|
switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
|
|
|
|
|
case WINED3DCULL_NONE:
|
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
|
checkGLcall("glDisable GL_CULL_FACE");
|
|
|
|
|
break;
|
|
|
|
|
case WINED3DCULL_CW:
|
|
|
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
|
checkGLcall("glEnable GL_CULL_FACE");
|
|
|
|
|
if (stateblock->wineD3DDevice->render_offscreen) {
|
|
|
|
|
glFrontFace(GL_CW);
|
|
|
|
|
checkGLcall("glFrontFace GL_CW");
|
|
|
|
|
} else {
|
|
|
|
|
glFrontFace(GL_CCW);
|
|
|
|
|
checkGLcall("glFrontFace GL_CCW");
|
|
|
|
|
}
|
|
|
|
|
glCullFace(GL_BACK);
|
|
|
|
|
break;
|
|
|
|
|
case WINED3DCULL_CCW:
|
|
|
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
|
checkGLcall("glEnable GL_CULL_FACE");
|
|
|
|
|
if (stateblock->wineD3DDevice->render_offscreen) {
|
|
|
|
|
glFrontFace(GL_CCW);
|
|
|
|
|
checkGLcall("glFrontFace GL_CCW");
|
|
|
|
|
} else {
|
|
|
|
|
glFrontFace(GL_CW);
|
|
|
|
|
checkGLcall("glFrontFace GL_CW");
|
|
|
|
|
}
|
|
|
|
|
glCullFace(GL_BACK);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:42:16 +01:00
|
|
|
|
static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
|
|
|
|
|
case WINED3DSHADE_FLAT:
|
|
|
|
|
glShadeModel(GL_FLAT);
|
|
|
|
|
checkGLcall("glShadeModel(GL_FLAT)");
|
|
|
|
|
break;
|
|
|
|
|
case WINED3DSHADE_GOURAUD:
|
|
|
|
|
glShadeModel(GL_SMOOTH);
|
|
|
|
|
checkGLcall("glShadeModel(GL_SMOOTH)");
|
|
|
|
|
break;
|
|
|
|
|
case WINED3DSHADE_PHONG:
|
|
|
|
|
FIXME("WINED3DSHADE_PHONG isn't supported\n");
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:42:43 +01:00
|
|
|
|
static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
|
|
|
|
|
glEnable(GL_DITHER);
|
|
|
|
|
checkGLcall("glEnable GL_DITHER");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_DITHER);
|
|
|
|
|
checkGLcall("glDisable GL_DITHER");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:43:25 +01:00
|
|
|
|
static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
|
|
|
|
|
* this has to be merged with ZENABLE and ZFUNC
|
|
|
|
|
*/
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
|
|
|
|
|
glDepthMask(1);
|
|
|
|
|
checkGLcall("glDepthMask(1)");
|
|
|
|
|
} else {
|
|
|
|
|
glDepthMask(0);
|
|
|
|
|
checkGLcall("glDepthMask(0)");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:44:55 +01:00
|
|
|
|
static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
|
|
|
|
|
|
|
|
|
|
if(glParm) {
|
|
|
|
|
glDepthFunc(glParm);
|
|
|
|
|
checkGLcall("glDepthFunc");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:45:26 +01:00
|
|
|
|
static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2006-12-29 11:35:57 +01:00
|
|
|
|
float col[4];
|
|
|
|
|
D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
|
2006-12-08 01:45:26 +01:00
|
|
|
|
|
2006-12-29 11:35:57 +01:00
|
|
|
|
TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
|
|
|
|
|
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
|
2006-12-08 01:45:26 +01:00
|
|
|
|
checkGLcall("glLightModel for MODEL_AMBIENT");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 01:51:11 +01:00
|
|
|
|
static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
int srcBlend = GL_ZERO;
|
|
|
|
|
int dstBlend = GL_ZERO;
|
|
|
|
|
|
|
|
|
|
/* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
|
2006-12-25 18:46:59 +01:00
|
|
|
|
stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
|
2006-12-08 01:51:11 +01:00
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
|
checkGLcall("glEnable GL_BLEND");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
|
checkGLcall("glDisable GL_BLEND");
|
|
|
|
|
/* Nothing more to do - get out */
|
|
|
|
|
return;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
|
|
|
|
|
case WINED3DBLEND_ZERO : srcBlend = GL_ZERO; break;
|
|
|
|
|
case WINED3DBLEND_ONE : srcBlend = GL_ONE; break;
|
|
|
|
|
case WINED3DBLEND_SRCCOLOR : srcBlend = GL_SRC_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_INVSRCCOLOR : srcBlend = GL_ONE_MINUS_SRC_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_SRCALPHA : srcBlend = GL_SRC_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_INVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_DESTALPHA : srcBlend = GL_DST_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_INVDESTALPHA : srcBlend = GL_ONE_MINUS_DST_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_DESTCOLOR : srcBlend = GL_DST_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_INVDESTCOLOR : srcBlend = GL_ONE_MINUS_DST_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_SRCALPHASAT : srcBlend = GL_SRC_ALPHA_SATURATE; break;
|
|
|
|
|
|
|
|
|
|
case WINED3DBLEND_BOTHSRCALPHA : srcBlend = GL_SRC_ALPHA;
|
|
|
|
|
dstBlend = GL_SRC_ALPHA;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WINED3DBLEND_BOTHINVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
|
|
|
|
|
dstBlend = GL_ONE_MINUS_SRC_ALPHA;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WINED3DBLEND_BLENDFACTOR : srcBlend = GL_CONSTANT_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_INVBLENDFACTOR : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
|
|
|
|
|
case WINED3DBLEND_ZERO : dstBlend = GL_ZERO; break;
|
|
|
|
|
case WINED3DBLEND_ONE : dstBlend = GL_ONE; break;
|
|
|
|
|
case WINED3DBLEND_SRCCOLOR : dstBlend = GL_SRC_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_INVSRCCOLOR : dstBlend = GL_ONE_MINUS_SRC_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_SRCALPHA : dstBlend = GL_SRC_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_INVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_DESTALPHA : dstBlend = GL_DST_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_INVDESTALPHA : dstBlend = GL_ONE_MINUS_DST_ALPHA; break;
|
|
|
|
|
case WINED3DBLEND_DESTCOLOR : dstBlend = GL_DST_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_INVDESTCOLOR : dstBlend = GL_ONE_MINUS_DST_COLOR; break;
|
|
|
|
|
case WINED3DBLEND_SRCALPHASAT : dstBlend = GL_SRC_ALPHA_SATURATE; break;
|
|
|
|
|
|
|
|
|
|
case WINED3DBLEND_BOTHSRCALPHA : dstBlend = GL_SRC_ALPHA;
|
|
|
|
|
srcBlend = GL_SRC_ALPHA;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WINED3DBLEND_BOTHINVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
|
|
|
|
|
srcBlend = GL_ONE_MINUS_SRC_ALPHA;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case D3DBLEND_BLENDFACTOR : dstBlend = GL_CONSTANT_COLOR; break;
|
|
|
|
|
case D3DBLEND_INVBLENDFACTOR : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
|
|
|
|
|
glEnable(GL_LINE_SMOOTH);
|
|
|
|
|
checkGLcall("glEnable(GL_LINE_SMOOTH)");
|
|
|
|
|
if(srcBlend != GL_SRC_ALPHA) {
|
|
|
|
|
FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
|
|
|
|
|
srcBlend = GL_SRC_ALPHA;
|
|
|
|
|
}
|
|
|
|
|
if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
|
|
|
|
|
FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
|
|
|
|
|
dstBlend = GL_ONE_MINUS_SRC_ALPHA;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_LINE_SMOOTH);
|
|
|
|
|
checkGLcall("glDisable(GL_LINE_SMOOTH)");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
|
|
|
|
|
glBlendFunc(srcBlend, dstBlend);
|
|
|
|
|
checkGLcall("glBlendFunc");
|
2006-12-25 18:46:59 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_blendfactor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
float col[4];
|
2006-12-08 01:51:11 +01:00
|
|
|
|
|
|
|
|
|
TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
|
|
|
|
|
D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
|
|
|
|
|
glBlendColor (col[0],col[1],col[2],col[3]);
|
|
|
|
|
checkGLcall("glBlendColor");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 20:21:32 +01:00
|
|
|
|
static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
int glParm = 0;
|
|
|
|
|
float ref;
|
|
|
|
|
BOOL enable_ckey = FALSE;
|
|
|
|
|
|
|
|
|
|
IWineD3DSurfaceImpl *surf;
|
|
|
|
|
|
|
|
|
|
/* Find out if the texture on the first stage has a ckey set
|
|
|
|
|
* The alpha state func reads the texture settings, even though alpha and texture are not grouped
|
|
|
|
|
* together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
|
|
|
|
|
* used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
|
|
|
|
|
* in case it finds some texture+colorkeyenable combination which needs extra care.
|
|
|
|
|
*/
|
|
|
|
|
if(stateblock->textures[0]) {
|
|
|
|
|
surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
|
|
|
|
|
if(surf->CKeyFlags & DDSD_CKSRCBLT) enable_ckey = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
|
|
|
|
|
(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
|
|
|
|
|
glEnable(GL_ALPHA_TEST);
|
|
|
|
|
checkGLcall("glEnable GL_ALPHA_TEST");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_ALPHA_TEST);
|
|
|
|
|
checkGLcall("glDisable GL_ALPHA_TEST");
|
|
|
|
|
/* Alpha test is disabled, don't bother setting the params - it will happen on the next
|
|
|
|
|
* enable call
|
|
|
|
|
*/
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
|
|
|
|
|
glParm = GL_NOTEQUAL;
|
|
|
|
|
ref = 0.0;
|
|
|
|
|
} else {
|
|
|
|
|
ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
|
|
|
|
|
glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
|
|
|
|
|
}
|
|
|
|
|
if(glParm) {
|
|
|
|
|
glAlphaFunc(glParm, ref);
|
|
|
|
|
checkGLcall("glAlphaFunc");
|
|
|
|
|
}
|
|
|
|
|
/* TODO: Some texture blending operations seem to affect the alpha test */
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 18:01:23 +01:00
|
|
|
|
static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD enable = 0xFFFFFFFF;
|
|
|
|
|
DWORD disable = 0x00000000;
|
|
|
|
|
|
|
|
|
|
/* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
|
|
|
|
|
* of already set values
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* If enabling / disabling all
|
|
|
|
|
* TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
|
|
|
|
|
*/
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_CLIPPING]) {
|
|
|
|
|
enable = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
|
|
|
|
|
disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
|
|
|
|
|
} else {
|
|
|
|
|
disable = 0xffffffff;
|
|
|
|
|
enable = 0x00;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (enable & WINED3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
|
|
|
|
|
if (enable & WINED3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
|
|
|
|
|
if (enable & WINED3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
|
|
|
|
|
if (enable & WINED3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
|
|
|
|
|
if (enable & WINED3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
|
|
|
|
|
if (enable & WINED3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
|
|
|
|
|
|
|
|
|
|
if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
|
|
|
|
|
if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
|
|
|
|
|
if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
|
|
|
|
|
if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
|
|
|
|
|
if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
|
|
|
|
|
if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
|
|
|
|
|
|
|
|
|
|
/** update clipping status */
|
|
|
|
|
if (enable) {
|
|
|
|
|
stateblock->clip_status.ClipUnion = 0;
|
|
|
|
|
stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
|
|
|
|
|
} else {
|
|
|
|
|
stateblock->clip_status.ClipUnion = 0;
|
|
|
|
|
stateblock->clip_status.ClipIntersection = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 20:21:43 +01:00
|
|
|
|
static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
int glParm = GL_FUNC_ADD;
|
|
|
|
|
|
|
|
|
|
if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
|
|
|
|
|
WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
|
|
|
|
|
case WINED3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break;
|
|
|
|
|
case WINED3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break;
|
|
|
|
|
case WINED3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
|
|
|
|
|
case WINED3DBLENDOP_MIN : glParm = GL_MIN; break;
|
|
|
|
|
case WINED3DBLENDOP_MAX : glParm = GL_MAX; break;
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TRACE("glBlendEquation(%x)\n", glParm);
|
|
|
|
|
GL_EXTCALL(glBlendEquation(glParm));
|
|
|
|
|
checkGLcall("glBlendEquation");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 18:38:30 +01:00
|
|
|
|
static void
|
|
|
|
|
state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
|
|
|
|
|
* and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
|
|
|
|
|
* specular color. This is wrong:
|
|
|
|
|
* Separate specular color means the specular colour is maintained separately, whereas
|
|
|
|
|
* single color means it is merged in. However in both cases they are being used to
|
|
|
|
|
* some extent.
|
|
|
|
|
* To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
|
|
|
|
|
* NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
|
|
|
|
|
* running 1.4 yet!
|
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
* If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
|
|
|
|
|
* Instead, we need to setup the FinalCombiner properly.
|
|
|
|
|
*
|
|
|
|
|
* The default setup for the FinalCombiner is:
|
|
|
|
|
*
|
|
|
|
|
* <variable> <input> <mapping> <usage>
|
|
|
|
|
* GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
|
|
|
|
|
* GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
|
|
|
|
|
* GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
|
|
|
|
|
* GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
|
|
|
|
|
* GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
|
|
|
|
|
* GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
|
|
|
|
|
* GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
|
|
|
|
|
*
|
|
|
|
|
* That's pretty much fine as it is, except for variable B, which needs to take
|
|
|
|
|
* either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
|
|
|
|
|
* whether WINED3DRS_SPECULARENABLE is enabled or not.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
TRACE("Setting specular enable state\n");
|
|
|
|
|
/* TODO: Add to the material setting functions */
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
|
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
|
|
|
|
|
checkGLcall("glMaterialfv");
|
|
|
|
|
if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
|
|
|
|
|
glEnable(GL_COLOR_SUM_EXT);
|
|
|
|
|
} else {
|
|
|
|
|
TRACE("Specular colors cannot be enabled in this version of opengl\n");
|
|
|
|
|
}
|
|
|
|
|
checkGLcall("glEnable(GL_COLOR_SUM)");
|
|
|
|
|
|
|
|
|
|
if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
|
|
|
|
|
checkGLcall("glFinalCombinerInputNV()");
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
|
|
|
|
|
|
|
|
|
|
/* for the case of enabled lighting: */
|
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
|
|
|
|
|
checkGLcall("glMaterialfv");
|
|
|
|
|
|
|
|
|
|
/* for the case of disabled lighting: */
|
|
|
|
|
if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
|
|
|
|
|
glDisable(GL_COLOR_SUM_EXT);
|
|
|
|
|
} else {
|
|
|
|
|
TRACE("Specular colors cannot be disabled in this version of opengl\n");
|
|
|
|
|
}
|
|
|
|
|
checkGLcall("glDisable(GL_COLOR_SUM)");
|
|
|
|
|
|
|
|
|
|
if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
|
|
|
|
|
checkGLcall("glFinalCombinerInputNV()");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 18:37:17 +01:00
|
|
|
|
static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
/* Note the texture color applies to all textures whereas
|
|
|
|
|
* GL_TEXTURE_ENV_COLOR applies to active only
|
|
|
|
|
*/
|
2006-12-29 11:35:57 +01:00
|
|
|
|
float col[4];
|
|
|
|
|
D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
|
2006-12-08 18:37:17 +01:00
|
|
|
|
|
|
|
|
|
if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
/* And now the default texture color as well */
|
|
|
|
|
for (i = 0; i < GL_LIMITS(texture_stages); i++) {
|
|
|
|
|
/* Note the WINED3DRS value applies to all textures, but GL has one
|
|
|
|
|
* per texture, so apply it now ready to be used!
|
|
|
|
|
*/
|
|
|
|
|
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
|
|
|
|
|
checkGLcall("glActiveTextureARB");
|
|
|
|
|
} else if (i>0) {
|
|
|
|
|
FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-29 11:35:57 +01:00
|
|
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
|
2006-12-08 18:37:17 +01:00
|
|
|
|
checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
|
|
|
|
|
}
|
2006-12-19 23:26:39 +01:00
|
|
|
|
} else {
|
2006-12-29 11:35:57 +01:00
|
|
|
|
GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
|
2006-12-08 18:37:17 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 18:39:45 +01:00
|
|
|
|
static void
|
|
|
|
|
renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
|
|
|
|
|
#if 0 /* Don't use OpenGL 2.0 calls for now */
|
|
|
|
|
if(GL_EXTCALL(glStencilFuncSeparate) && GL_EXTCALL(glStencilOpSeparate)) {
|
|
|
|
|
GL_EXTCALL(glStencilFuncSeparate(face, func, ref, mask));
|
|
|
|
|
checkGLcall("glStencilFuncSeparate(...)");
|
|
|
|
|
GL_EXTCALL(glStencilOpSeparate(face, stencilFail, depthFail, stencilPass));
|
|
|
|
|
checkGLcall("glStencilOpSeparate(...)");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
#endif
|
|
|
|
|
if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
|
|
|
|
|
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
|
|
|
|
|
checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
|
|
|
|
|
GL_EXTCALL(glActiveStencilFaceEXT(face));
|
|
|
|
|
checkGLcall("glActiveStencilFaceEXT(...)");
|
|
|
|
|
glStencilFunc(func, ref, mask);
|
|
|
|
|
checkGLcall("glStencilFunc(...)");
|
|
|
|
|
glStencilOp(stencilFail, depthFail, stencilPass);
|
|
|
|
|
checkGLcall("glStencilOp(...)");
|
|
|
|
|
} else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
|
|
|
|
|
GL_EXTCALL(glStencilFuncSeparateATI(face, func, ref, mask));
|
|
|
|
|
checkGLcall("glStencilFuncSeparateATI(...)");
|
|
|
|
|
GL_EXTCALL(glStencilOpSeparateATI(face, stencilFail, depthFail, stencilPass));
|
|
|
|
|
checkGLcall("glStencilOpSeparateATI(...)");
|
|
|
|
|
} else {
|
|
|
|
|
ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD onesided_enable = FALSE;
|
|
|
|
|
DWORD twosided_enable = FALSE;
|
|
|
|
|
GLint func = GL_ALWAYS;
|
|
|
|
|
GLint func_ccw = GL_ALWAYS;
|
|
|
|
|
GLint ref = 0;
|
|
|
|
|
GLuint mask = 0;
|
|
|
|
|
GLint stencilFail = GL_KEEP;
|
|
|
|
|
GLint depthFail = GL_KEEP;
|
|
|
|
|
GLint stencilPass = GL_KEEP;
|
|
|
|
|
GLint stencilFail_ccw = GL_KEEP;
|
|
|
|
|
GLint depthFail_ccw = GL_KEEP;
|
|
|
|
|
GLint stencilPass_ccw = GL_KEEP;
|
|
|
|
|
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_STENCILENABLE] )
|
|
|
|
|
onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_TWOSIDEDSTENCILMODE] )
|
|
|
|
|
twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_STENCILFUNC] )
|
|
|
|
|
if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
|
|
|
|
|
func = GL_ALWAYS;
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFUNC] )
|
|
|
|
|
if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
|
|
|
|
|
func = GL_ALWAYS;
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_STENCILREF] )
|
|
|
|
|
ref = stateblock->renderState[WINED3DRS_STENCILREF];
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_STENCILMASK] )
|
|
|
|
|
mask = stateblock->renderState[WINED3DRS_STENCILMASK];
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_STENCILFAIL] )
|
|
|
|
|
stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_STENCILZFAIL] )
|
|
|
|
|
depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_STENCILPASS] )
|
|
|
|
|
stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFAIL] )
|
|
|
|
|
stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_CCW_STENCILZFAIL] )
|
|
|
|
|
depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
|
|
|
|
|
if( stateblock->set.renderState[WINED3DRS_CCW_STENCILPASS] )
|
|
|
|
|
stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
|
|
|
|
|
|
2007-01-09 23:42:26 +01:00
|
|
|
|
TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
|
|
|
|
|
"GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
|
|
|
|
|
"GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
|
2006-12-08 18:39:45 +01:00
|
|
|
|
onesided_enable, twosided_enable, ref, mask,
|
|
|
|
|
func, stencilFail, depthFail, stencilPass,
|
|
|
|
|
func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
|
|
|
|
|
|
|
|
|
|
if (twosided_enable) {
|
|
|
|
|
renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask, stencilFail, depthFail, stencilPass);
|
|
|
|
|
renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
|
|
|
|
|
} else {
|
|
|
|
|
if (onesided_enable) {
|
|
|
|
|
glEnable(GL_STENCIL_TEST);
|
|
|
|
|
checkGLcall("glEnable GL_STENCIL_TEST");
|
|
|
|
|
glStencilFunc(func, ref, mask);
|
|
|
|
|
checkGLcall("glStencilFunc(...)");
|
|
|
|
|
glStencilOp(stencilFail, depthFail, stencilPass);
|
|
|
|
|
checkGLcall("glStencilOp(...)");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_STENCIL_TEST);
|
|
|
|
|
checkGLcall("glDisable GL_STENCIL_TEST");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 18:41:05 +01:00
|
|
|
|
static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
glStencilMask(stateblock->renderState[WINED3DRS_STENCILWRITEMASK]);
|
|
|
|
|
checkGLcall("glStencilMask");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 18:42:43 +01:00
|
|
|
|
static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* TODO: Put this into the vertex type block once that is in the state table */
|
|
|
|
|
BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
|
|
|
|
|
float fogstart, fogend;
|
|
|
|
|
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
|
|
|
|
if (!fogenable) {
|
|
|
|
|
/* No fog? Disable it, and we're done :-) */
|
|
|
|
|
glDisable(GL_FOG);
|
|
|
|
|
checkGLcall("glDisable GL_FOG");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
|
|
|
|
|
fogstart = tmpvalue.f;
|
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
|
|
|
|
|
fogend = tmpvalue.f;
|
|
|
|
|
|
|
|
|
|
/* Activate when vertex shaders are in the state table */
|
|
|
|
|
if(stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function &&
|
|
|
|
|
((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog) {
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_LINEAR);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
|
|
|
|
|
fogstart = 1.0;
|
|
|
|
|
fogend = 0.0;
|
|
|
|
|
stateblock->wineD3DDevice->last_was_foggy_shader = TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
|
|
|
|
|
* the system will apply only pixel(=table) fog effects."
|
|
|
|
|
*/
|
2007-01-10 11:37:03 +01:00
|
|
|
|
else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == D3DFOG_NONE) {
|
2006-12-08 18:42:43 +01:00
|
|
|
|
glHint(GL_FOG_HINT, GL_FASTEST);
|
|
|
|
|
checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
|
|
|
|
|
stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
|
2007-01-02 22:47:10 +01:00
|
|
|
|
|
2006-12-08 18:42:43 +01:00
|
|
|
|
switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
|
|
|
|
|
/* Processed vertices have their fog factor stored in the specular value. Fall too the none case.
|
|
|
|
|
* If we are drawing untransformed vertices atm, d3ddevice_set_ortho will update the fog
|
|
|
|
|
*/
|
|
|
|
|
case D3DFOG_EXP: {
|
|
|
|
|
if(!stateblock->wineD3DDevice->last_was_rhw) {
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_EXP);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
|
|
|
|
|
if(GL_SUPPORT(EXT_FOG_COORD)) {
|
|
|
|
|
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
case D3DFOG_EXP2: {
|
|
|
|
|
if(!stateblock->wineD3DDevice->last_was_rhw) {
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_EXP2);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
|
|
|
|
|
if(GL_SUPPORT(EXT_FOG_COORD)) {
|
|
|
|
|
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
case D3DFOG_LINEAR: {
|
|
|
|
|
if(!stateblock->wineD3DDevice->last_was_rhw) {
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_LINEAR);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
|
|
|
|
|
if(GL_SUPPORT(EXT_FOG_COORD)) {
|
|
|
|
|
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
case D3DFOG_NONE: {
|
|
|
|
|
/* Both are none? According to msdn the alpha channel of the specular
|
|
|
|
|
* color contains a fog factor. Set it in drawStridedSlow.
|
|
|
|
|
* Same happens with Vertexfog on transformed vertices
|
|
|
|
|
*/
|
|
|
|
|
if(GL_SUPPORT(EXT_FOG_COORD)) {
|
|
|
|
|
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_LINEAR);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
|
|
|
|
|
fogstart = 0xff;
|
|
|
|
|
fogend = 0x0;
|
|
|
|
|
} else {
|
|
|
|
|
/* Disable GL fog, handle this in software in drawStridedSlow */
|
|
|
|
|
fogenable = FALSE;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
glHint(GL_FOG_HINT, GL_NICEST);
|
|
|
|
|
checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
|
|
|
|
|
stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
|
2007-01-02 22:47:10 +01:00
|
|
|
|
|
2006-12-08 18:42:43 +01:00
|
|
|
|
switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
|
|
|
|
|
case D3DFOG_EXP:
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_EXP);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
|
|
|
|
|
if(GL_SUPPORT(EXT_FOG_COORD)) {
|
|
|
|
|
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case D3DFOG_EXP2:
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_EXP2);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
|
|
|
|
|
if(GL_SUPPORT(EXT_FOG_COORD)) {
|
|
|
|
|
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case D3DFOG_LINEAR:
|
|
|
|
|
glFogi(GL_FOG_MODE, GL_LINEAR);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
|
|
|
|
|
if(GL_SUPPORT(EXT_FOG_COORD)) {
|
|
|
|
|
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
|
|
|
|
|
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case D3DFOG_NONE: /* Won't happen */
|
|
|
|
|
default:
|
|
|
|
|
FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(fogenable) {
|
|
|
|
|
glEnable(GL_FOG);
|
|
|
|
|
checkGLcall("glEnable GL_FOG");
|
|
|
|
|
|
|
|
|
|
glFogfv(GL_FOG_START, &fogstart);
|
|
|
|
|
checkGLcall("glFogf(GL_FOG_START, fogstart");
|
|
|
|
|
TRACE("Fog Start == %f\n", fogstart);
|
|
|
|
|
|
|
|
|
|
glFogfv(GL_FOG_END, &fogend);
|
|
|
|
|
checkGLcall("glFogf(GL_FOG_END, fogend");
|
|
|
|
|
TRACE("Fog End == %f\n", fogend);
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_FOG);
|
|
|
|
|
checkGLcall("glDisable GL_FOG");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (GL_SUPPORT(NV_FOG_DISTANCE)) {
|
|
|
|
|
glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-08 18:52:30 +01:00
|
|
|
|
static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2006-12-29 11:35:57 +01:00
|
|
|
|
float col[4];
|
|
|
|
|
D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
|
2006-12-08 18:52:30 +01:00
|
|
|
|
/* Set the default alpha blend color */
|
2006-12-29 11:35:57 +01:00
|
|
|
|
glFogfv(GL_FOG_COLOR, &col[0]);
|
2006-12-08 18:52:30 +01:00
|
|
|
|
checkGLcall("glFog GL_FOG_COLOR");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 16:34:45 +01:00
|
|
|
|
static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
|
|
|
|
|
glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
|
|
|
|
|
checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 22:44:18 +01:00
|
|
|
|
/* TODO: Merge with primitive type + init_materials()!! */
|
|
|
|
|
static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2007-01-10 11:26:12 +01:00
|
|
|
|
GLenum Parm = -1;
|
|
|
|
|
WineDirect3DStridedData *diffuse = &stateblock->wineD3DDevice->strided_streams.u.s.diffuse;
|
|
|
|
|
BOOL isDiffuseSupplied;
|
|
|
|
|
|
|
|
|
|
/* Depends on the decoded vertex declaration to read the existance of diffuse data.
|
|
|
|
|
* The vertex declaration will call this function if the fixed function pipeline is used.
|
|
|
|
|
*/
|
|
|
|
|
if(isStateDirty(stateblock->wineD3DDevice, STATE_VDECL)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
isDiffuseSupplied = diffuse->lpData || diffuse->VBO;
|
2006-12-10 22:44:18 +01:00
|
|
|
|
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_COLORVERTEX]) {
|
|
|
|
|
TRACE("diff %d, amb %d, emis %d, spec %d\n",
|
|
|
|
|
stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
|
|
|
|
|
stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
|
|
|
|
|
stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
|
|
|
|
|
stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
|
|
|
|
|
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) {
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
|
|
|
|
|
Parm = GL_AMBIENT_AND_DIFFUSE;
|
|
|
|
|
} else {
|
|
|
|
|
Parm = GL_DIFFUSE;
|
|
|
|
|
}
|
|
|
|
|
} else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
|
|
|
|
|
Parm = GL_AMBIENT;
|
|
|
|
|
} else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) {
|
|
|
|
|
Parm = GL_EMISSION;
|
|
|
|
|
} else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) {
|
|
|
|
|
Parm = GL_SPECULAR;
|
|
|
|
|
}
|
2007-01-10 11:26:12 +01:00
|
|
|
|
}
|
2006-12-10 22:44:18 +01:00
|
|
|
|
|
2007-01-10 11:26:12 +01:00
|
|
|
|
if(Parm == -1 || !isDiffuseSupplied) {
|
|
|
|
|
glDisable(GL_COLOR_MATERIAL);
|
|
|
|
|
checkGLcall("glDisable GL_COLOR_MATERIAL");
|
2006-12-10 22:44:18 +01:00
|
|
|
|
} else {
|
2007-01-10 11:26:12 +01:00
|
|
|
|
glColorMaterial(GL_FRONT_AND_BACK, Parm);
|
|
|
|
|
checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
|
|
|
|
|
glEnable(GL_COLOR_MATERIAL);
|
|
|
|
|
checkGLcall("glEnable(GL_COLOR_MATERIAL)");
|
2006-12-10 22:44:18 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:01 +01:00
|
|
|
|
static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
WINED3DLINEPATTERN lp;
|
|
|
|
|
} tmppattern;
|
|
|
|
|
tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
|
|
|
|
|
|
|
|
|
|
TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
|
|
|
|
|
|
|
|
|
|
if (tmppattern.lp.wRepeatFactor) {
|
|
|
|
|
glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
|
|
|
|
|
checkGLcall("glLineStipple(repeat, linepattern)");
|
|
|
|
|
glEnable(GL_LINE_STIPPLE);
|
|
|
|
|
checkGLcall("glEnable(GL_LINE_STIPPLE);");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_LINE_STIPPLE);
|
|
|
|
|
checkGLcall("glDisable(GL_LINE_STIPPLE);");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:19:57 +01:00
|
|
|
|
static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_ZBIAS]) {
|
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
|
|
|
|
|
TRACE("ZBias value %f\n", tmpvalue.f);
|
|
|
|
|
glPolygonOffset(0, -tmpvalue.f);
|
|
|
|
|
checkGLcall("glPolygonOffset(0, -Value)");
|
|
|
|
|
glEnable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
|
checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
|
|
|
|
|
glEnable(GL_POLYGON_OFFSET_LINE);
|
|
|
|
|
checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
|
|
|
|
|
glEnable(GL_POLYGON_OFFSET_POINT);
|
|
|
|
|
checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
|
checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
|
|
|
|
|
glDisable(GL_POLYGON_OFFSET_LINE);
|
|
|
|
|
checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
|
|
|
|
|
glDisable(GL_POLYGON_OFFSET_POINT);
|
|
|
|
|
checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:05 +01:00
|
|
|
|
|
|
|
|
|
static void state_normalize(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS]) {
|
|
|
|
|
glEnable(GL_NORMALIZE);
|
|
|
|
|
checkGLcall("glEnable(GL_NORMALIZE);");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_NORMALIZE);
|
|
|
|
|
checkGLcall("glDisable(GL_NORMALIZE);");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:09 +01:00
|
|
|
|
static void state_psize(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
|
|
|
|
/* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
|
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE];
|
|
|
|
|
TRACE("Set point size to %f\n", tmpvalue.f);
|
|
|
|
|
glPointSize(tmpvalue.f);
|
|
|
|
|
checkGLcall("glPointSize(...);");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:12 +01:00
|
|
|
|
static void state_psizemin(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
2007-01-10 11:32:07 +01:00
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
|
2007-01-01 10:58:33 +01:00
|
|
|
|
if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
|
|
|
|
|
GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, tmpvalue.f);
|
|
|
|
|
checkGLcall("glPointParameterfARB(...");
|
|
|
|
|
}
|
|
|
|
|
else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
|
2006-12-10 23:20:12 +01:00
|
|
|
|
GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
|
|
|
|
|
checkGLcall("glPointParameterfEXT(...);");
|
2007-01-10 11:32:07 +01:00
|
|
|
|
} else if(tmpvalue.f != 1.0) {
|
|
|
|
|
FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
|
2006-12-10 23:20:12 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:15 +01:00
|
|
|
|
static void state_psizemax(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
2007-01-10 11:32:07 +01:00
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
|
2007-01-01 10:58:33 +01:00
|
|
|
|
if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
|
|
|
|
|
GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, tmpvalue.f);
|
|
|
|
|
checkGLcall("glPointParameterfARB(...");
|
|
|
|
|
}
|
|
|
|
|
else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
|
2006-12-10 23:20:15 +01:00
|
|
|
|
GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
|
|
|
|
|
checkGLcall("glPointParameterfEXT(...);");
|
2007-01-10 11:32:07 +01:00
|
|
|
|
} else if(tmpvalue.f != 64.0) {
|
|
|
|
|
FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
|
2006-12-10 23:20:15 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:19 +01:00
|
|
|
|
static void state_pscale(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* TODO: Group this with the viewport */
|
|
|
|
|
/*
|
|
|
|
|
* POINTSCALEENABLE controls how point size value is treated. If set to
|
|
|
|
|
* true, the point size is scaled with respect to height of viewport.
|
|
|
|
|
* When set to false point size is in pixels.
|
|
|
|
|
*
|
|
|
|
|
* http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Default values */
|
|
|
|
|
GLfloat att[3] = {1.0f, 0.0f, 0.0f};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
|
|
|
|
|
* This means that OpenGL will clamp really small point sizes to 1.0f.
|
|
|
|
|
* To correct for this we need to multiply by the scale factor when sizes
|
|
|
|
|
* are less than 1.0f. scale_factor = 1.0f / point_size.
|
|
|
|
|
*/
|
|
|
|
|
GLfloat pointSize = *((float*)&stateblock->renderState[WINED3DRS_POINTSIZE]);
|
|
|
|
|
if(pointSize > 0.0f) {
|
|
|
|
|
GLfloat scaleFactor;
|
|
|
|
|
|
|
|
|
|
if(pointSize < 1.0f) {
|
|
|
|
|
scaleFactor = pointSize * pointSize;
|
|
|
|
|
} else {
|
|
|
|
|
scaleFactor = 1.0f;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
|
|
|
|
|
att[0] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_A]) /
|
|
|
|
|
(stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
|
|
|
|
|
att[1] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_B]) /
|
|
|
|
|
(stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
|
|
|
|
|
att[2] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_C]) /
|
|
|
|
|
(stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
|
|
|
|
|
GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
|
|
|
|
|
checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
|
|
|
|
|
}
|
|
|
|
|
else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
|
|
|
|
|
GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
|
|
|
|
|
checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
|
|
|
|
|
} else {
|
|
|
|
|
TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:22 +01:00
|
|
|
|
static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
|
|
|
|
|
|
|
|
|
|
TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
|
|
|
|
|
Value & D3DCOLORWRITEENABLE_RED ? 1 : 0,
|
|
|
|
|
Value & D3DCOLORWRITEENABLE_GREEN ? 1 : 0,
|
|
|
|
|
Value & D3DCOLORWRITEENABLE_BLUE ? 1 : 0,
|
|
|
|
|
Value & D3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
|
|
|
|
|
glColorMask(Value & D3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
|
|
|
|
|
Value & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
|
|
|
|
|
Value & D3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
|
|
|
|
|
Value & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
|
|
|
|
|
checkGLcall("glColorMask(...)");
|
|
|
|
|
|
|
|
|
|
/* depends on WINED3DRS_COLORWRITEENABLE. */
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
|
|
|
|
|
ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
|
|
|
|
|
stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
|
|
|
|
|
stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
|
|
|
|
|
stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:26 +01:00
|
|
|
|
static void state_localviewer(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
|
|
|
|
|
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
|
|
|
|
|
checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
|
|
|
|
|
} else {
|
|
|
|
|
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
|
|
|
|
|
checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:29 +01:00
|
|
|
|
static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
|
|
|
|
|
TRACE("Last Pixel Drawing Enabled\n");
|
|
|
|
|
} else {
|
|
|
|
|
FIXME("Last Pixel Drawing Disabled, not handled yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:36 +01:00
|
|
|
|
static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2007-01-03 09:17:24 +01:00
|
|
|
|
unsigned int i;
|
|
|
|
|
int val;
|
|
|
|
|
|
2006-12-10 23:20:36 +01:00
|
|
|
|
/* TODO: NV_POINT_SPRITE */
|
|
|
|
|
if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
|
|
|
|
|
TRACE("Point sprites not supported\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
|
2007-01-03 09:17:24 +01:00
|
|
|
|
val = GL_TRUE;
|
2006-12-10 23:20:36 +01:00
|
|
|
|
} else {
|
2007-01-03 09:17:24 +01:00
|
|
|
|
val = GL_FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < GL_LIMITS(texture_stages); i++) {
|
|
|
|
|
/* Note the WINED3DRS value applies to all textures, but GL has one
|
|
|
|
|
* per texture, so apply it now ready to be used!
|
|
|
|
|
*/
|
|
|
|
|
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
|
|
|
|
|
checkGLcall("glActiveTextureARB");
|
|
|
|
|
} else if (i==1) {
|
|
|
|
|
FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, val);
|
|
|
|
|
checkGLcall((val?"glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)":
|
|
|
|
|
"glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE)"));
|
2006-12-10 23:20:36 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:45 +01:00
|
|
|
|
static void state_wrap(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/**
|
|
|
|
|
http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
|
|
|
|
|
http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
|
|
|
|
|
http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
|
|
|
|
|
Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
|
|
|
|
|
http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
|
|
|
|
|
|
|
|
|
|
so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
|
|
|
|
|
*/
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_WRAP0] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP1] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP2] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP3] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP4] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP5] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP6] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP7] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP8] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP9] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP10] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP11] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP12] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP13] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP14] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_WRAP15] ) {
|
|
|
|
|
ERR("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:40 +01:00
|
|
|
|
static void state_multisampleaa(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if( GL_SUPPORT(ARB_MULTISAMPLE) ) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
|
|
|
|
|
glEnable(GL_MULTISAMPLE_ARB);
|
|
|
|
|
checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_MULTISAMPLE_ARB);
|
|
|
|
|
checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
|
|
|
|
|
ERR("Multisample antialiasing not supported by gl\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:48 +01:00
|
|
|
|
static void state_scissor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
|
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
|
checkGLcall("glEnable(GL_SCISSOR_TEST)");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
|
checkGLcall("glDisable(GL_SCISSOR_TEST)");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:52 +01:00
|
|
|
|
static void state_depthbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] ||
|
|
|
|
|
stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
|
|
|
|
|
tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
|
|
|
|
|
glEnable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
|
checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
|
|
|
|
|
glPolygonOffset(tmpvalue.f, *((float*)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
|
|
|
|
|
checkGLcall("glPolygonOffset(...)");
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
|
checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:56 +01:00
|
|
|
|
static void state_perspective(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
|
|
|
|
|
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
|
|
|
|
|
checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
|
|
|
|
|
} else {
|
|
|
|
|
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
|
|
|
|
|
checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:20:59 +01:00
|
|
|
|
static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
|
|
|
|
|
ERR(" Stippled Alpha not supported yet.\n");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:21:03 +01:00
|
|
|
|
static void state_antialias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_ANTIALIAS])
|
|
|
|
|
ERR(" Antialias not supported yet.\n");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:21:07 +01:00
|
|
|
|
static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
|
|
|
|
|
ERR("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-15 20:03:17 +01:00
|
|
|
|
static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2006-12-10 23:21:10 +01:00
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != D3DPATCHEDGE_DISCRETE)
|
|
|
|
|
ERR("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:21:14 +01:00
|
|
|
|
static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
tmpvalue.f = 1.0f;
|
|
|
|
|
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
|
|
|
|
|
ERR("(WINED3DRS_PATCHSEGMENTS,%d) not yet implemented\n", tmpvalue.d);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:21:21 +01:00
|
|
|
|
static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != D3DDEGREE_CUBIC)
|
|
|
|
|
ERR("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:21:25 +01:00
|
|
|
|
static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != D3DDEGREE_LINEAR)
|
|
|
|
|
ERR("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:21:27 +01:00
|
|
|
|
static void state_tessellation(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
|
|
|
|
|
FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:13:38 +01:00
|
|
|
|
|
|
|
|
|
static void state_srgbwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE])
|
|
|
|
|
ERR("Render state WINED3DRS_SRGBWRITEENABLE not yet implemented\n");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-10 23:14:36 +01:00
|
|
|
|
static void state_seperateblend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
TRACE("Stub\n");
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE])
|
|
|
|
|
FIXME("(WINED3DRS_SEPARATEALPHABLENDENABLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-15 20:02:13 +01:00
|
|
|
|
static void state_wrapu(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_WRAPU]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_wrapv(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_WRAPV]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_monoenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_rop2(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_ROP2]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_planemask(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_subpixel(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_extents(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_EXTENTS]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
|
|
|
|
|
FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
/* Activates the texture dimension according to the bound D3D texture.
|
|
|
|
|
* Does not care for the colorop or correct gl texture unit(when using nvrc)
|
|
|
|
|
* Requires the caller to activate the correct unit before
|
|
|
|
|
*/
|
|
|
|
|
static void activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
if(stateblock->textures[stage]) {
|
|
|
|
|
glDisable(GL_TEXTURE_1D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_1D)");
|
|
|
|
|
switch(stateblock->textureDimensions[stage]) {
|
|
|
|
|
case GL_TEXTURE_2D:
|
|
|
|
|
glDisable(GL_TEXTURE_3D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_3D)");
|
|
|
|
|
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
|
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_2D)");
|
|
|
|
|
break;
|
|
|
|
|
case GL_TEXTURE_3D:
|
|
|
|
|
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
|
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_2D)");
|
|
|
|
|
glEnable(GL_TEXTURE_3D);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_3D)");
|
|
|
|
|
break;
|
|
|
|
|
case GL_TEXTURE_CUBE_MAP_ARB:
|
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_2D)");
|
|
|
|
|
glDisable(GL_TEXTURE_3D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_3D)");
|
|
|
|
|
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_2D)");
|
|
|
|
|
glDisable(GL_TEXTURE_3D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_3D)");
|
|
|
|
|
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
|
|
|
|
|
glEnable(GL_TEXTURE_1D);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_1D)");
|
|
|
|
|
/* Binding textures is done by samplers. A dummy texture will be bound */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
|
2007-01-03 19:18:38 +01:00
|
|
|
|
DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
|
2006-12-19 23:00:58 +01:00
|
|
|
|
|
|
|
|
|
TRACE("Setting color op for stage %d\n", stage);
|
|
|
|
|
|
|
|
|
|
if (stateblock->pixelShader && stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE &&
|
|
|
|
|
((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
|
|
|
|
|
/* Using a pixel shader? Don't care for anything here, the shader applying does it */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-03 19:18:38 +01:00
|
|
|
|
if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
|
|
|
|
|
|
|
|
|
|
if (mapped_stage != -1) {
|
|
|
|
|
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
if (mapped_stage >= GL_LIMITS(sampler_stages)) {
|
|
|
|
|
if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
|
|
|
|
|
FIXME("Attempt to enable unsupported stage!\n");
|
|
|
|
|
}
|
|
|
|
|
return;
|
2006-12-19 23:00:58 +01:00
|
|
|
|
}
|
2007-01-03 19:18:38 +01:00
|
|
|
|
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
|
|
|
|
|
checkGLcall("glActiveTextureARB");
|
|
|
|
|
} else if (stage > 0) {
|
|
|
|
|
WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
2006-12-19 23:00:58 +01:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
if(stateblock->lowest_disabled_stage > 0) {
|
|
|
|
|
glEnable(GL_REGISTER_COMBINERS_NV);
|
|
|
|
|
GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, stateblock->lowest_disabled_stage));
|
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_REGISTER_COMBINERS_NV);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(stage >= stateblock->lowest_disabled_stage) {
|
|
|
|
|
TRACE("Stage disabled\n");
|
2007-01-03 19:18:38 +01:00
|
|
|
|
if (mapped_stage != -1) {
|
|
|
|
|
/* Disable everything here */
|
|
|
|
|
glDisable(GL_TEXTURE_1D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_1D)");
|
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_2D)");
|
|
|
|
|
glDisable(GL_TEXTURE_3D);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_3D)");
|
|
|
|
|
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
|
|
|
|
|
}
|
2006-12-19 23:00:58 +01:00
|
|
|
|
/* All done */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-10 11:44:55 +01:00
|
|
|
|
/* The sampler will also activate the correct texture dimensions, so no need to do it here
|
|
|
|
|
* if the sampler for this stage is dirty
|
|
|
|
|
*/
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_SAMPLER(stage))) {
|
|
|
|
|
if (mapped_stage != -1) activate_dimensions(stage, stateblock);
|
|
|
|
|
}
|
2006-12-19 23:00:58 +01:00
|
|
|
|
|
|
|
|
|
/* Set the texture combiners */
|
|
|
|
|
if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLOROP],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLORARG1],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLORARG2],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLORARG0],
|
2007-01-03 19:18:38 +01:00
|
|
|
|
mapped_stage);
|
2006-12-19 23:00:58 +01:00
|
|
|
|
} else {
|
|
|
|
|
set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLOROP],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLORARG1],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLORARG2],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:03:37 +01:00
|
|
|
|
static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
|
2007-01-03 19:18:44 +01:00
|
|
|
|
DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
|
2006-12-19 23:03:37 +01:00
|
|
|
|
|
|
|
|
|
TRACE("Setting alpha op for stage %d\n", stage);
|
|
|
|
|
/* Do not care for enabled / disabled stages, just assign the settigns. colorop disables / enables required stuff */
|
2007-01-03 19:18:44 +01:00
|
|
|
|
if (mapped_stage != -1) {
|
|
|
|
|
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
if (stage >= GL_LIMITS(sampler_stages)) {
|
|
|
|
|
if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
|
|
|
|
|
FIXME("Attempt to enable unsupported stage!\n");
|
|
|
|
|
}
|
|
|
|
|
return;
|
2006-12-19 23:03:37 +01:00
|
|
|
|
}
|
2007-01-03 19:18:44 +01:00
|
|
|
|
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
|
|
|
|
|
checkGLcall("glActiveTextureARB");
|
|
|
|
|
} else if (stage > 0) {
|
|
|
|
|
/* We can't do anything here */
|
|
|
|
|
WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
2006-12-19 23:03:37 +01:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TRACE("Setting alpha op for stage %d\n", stage);
|
|
|
|
|
if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_ALPHAARG0],
|
2007-01-03 19:18:44 +01:00
|
|
|
|
mapped_stage);
|
2006-12-19 23:03:37 +01:00
|
|
|
|
} else {
|
|
|
|
|
set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage, stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
|
|
|
|
|
stateblock->textureState[stage][WINED3DTSS_ALPHAARG0]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-01 23:53:59 +01:00
|
|
|
|
static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
|
|
|
|
|
|
|
|
|
|
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
if(texUnit >= GL_LIMITS(sampler_stages)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[texUnit]));
|
|
|
|
|
checkGLcall("glActiveTextureARB");
|
|
|
|
|
} else if (texUnit > 0) {
|
|
|
|
|
/* We can't do anything here */
|
|
|
|
|
WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set_texture_matrix((float *)&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
|
|
|
|
|
stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
|
|
|
|
|
(stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-06 18:11:21 +01:00
|
|
|
|
static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd);
|
|
|
|
|
|
2006-12-19 23:04:16 +01:00
|
|
|
|
static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
|
2007-01-03 19:18:51 +01:00
|
|
|
|
DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
|
|
|
|
|
|
|
|
|
|
if (mapped_stage == -1) {
|
|
|
|
|
TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2006-12-19 23:04:16 +01:00
|
|
|
|
|
|
|
|
|
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
if(stage >= GL_LIMITS(sampler_stages)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2007-01-03 19:18:51 +01:00
|
|
|
|
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
|
2006-12-19 23:04:16 +01:00
|
|
|
|
checkGLcall("glActiveTextureARB");
|
|
|
|
|
} else if (stage > 0) {
|
|
|
|
|
/* We can't do anything here */
|
|
|
|
|
WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
|
|
|
|
|
*
|
|
|
|
|
* FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
|
|
|
|
|
* one flag, you can still specify an index value, which the system uses to
|
|
|
|
|
* determine the texture wrapping mode.
|
|
|
|
|
* eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
|
|
|
|
|
* means use the vertex position (camera-space) as the input texture coordinates
|
|
|
|
|
* for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
|
|
|
|
|
* state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
|
|
|
|
|
* to the TEXCOORDINDEX value
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Be careful the value of the mask 0xF0000 come from d3d8types.h infos
|
|
|
|
|
*/
|
|
|
|
|
switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) {
|
|
|
|
|
case WINED3DTSS_TCI_PASSTHRU:
|
|
|
|
|
/*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_T);
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_R);
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_Q);
|
|
|
|
|
checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WINED3DTSS_TCI_CAMERASPACEPOSITION:
|
|
|
|
|
/* CameraSpacePosition means use the vertex position, transformed to camera space,
|
|
|
|
|
* as the input texture coordinates for this stage's texture transformation. This
|
|
|
|
|
* equates roughly to EYE_LINEAR
|
|
|
|
|
*/
|
|
|
|
|
{
|
|
|
|
|
float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
|
|
|
|
|
float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
|
|
|
|
|
float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
|
|
|
|
|
float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
|
|
|
|
|
TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
|
|
|
|
|
|
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
|
glPushMatrix();
|
|
|
|
|
glLoadIdentity();
|
|
|
|
|
glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
|
|
|
|
|
glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
|
|
|
|
|
glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
|
|
|
|
|
glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
|
|
|
|
|
glPopMatrix();
|
|
|
|
|
|
|
|
|
|
TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
|
|
|
|
|
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
|
|
|
|
|
checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
|
|
|
|
|
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
|
|
|
|
|
checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_R);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
|
|
|
|
|
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
|
|
|
|
|
checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WINED3DTSS_TCI_CAMERASPACENORMAL:
|
|
|
|
|
{
|
|
|
|
|
if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
|
|
|
|
|
float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
|
|
|
|
|
float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
|
|
|
|
|
float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
|
|
|
|
|
float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
|
|
|
|
|
TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
|
|
|
|
|
|
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
|
glPushMatrix();
|
|
|
|
|
glLoadIdentity();
|
|
|
|
|
glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
|
|
|
|
|
glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
|
|
|
|
|
glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
|
|
|
|
|
glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
|
|
|
|
|
glPopMatrix();
|
|
|
|
|
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
|
|
|
|
|
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
|
|
|
|
|
checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
|
|
|
|
|
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
|
|
|
|
|
checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_R);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
|
|
|
|
|
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
|
|
|
|
|
checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
|
|
|
|
|
{
|
|
|
|
|
if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
|
|
|
|
|
float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
|
|
|
|
|
float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
|
|
|
|
|
float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
|
|
|
|
|
float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
|
|
|
|
|
TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
|
|
|
|
|
|
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
|
glPushMatrix();
|
|
|
|
|
glLoadIdentity();
|
|
|
|
|
glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
|
|
|
|
|
glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
|
|
|
|
|
glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
|
|
|
|
|
glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
|
|
|
|
|
glPopMatrix();
|
|
|
|
|
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
|
|
|
|
|
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
|
|
|
|
|
checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
|
|
|
|
|
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
|
|
|
|
|
checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
|
|
|
|
|
glEnable(GL_TEXTURE_GEN_R);
|
|
|
|
|
checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
|
|
|
|
|
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
|
|
|
|
|
checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Unhandled types: */
|
|
|
|
|
default:
|
|
|
|
|
/* Todo: */
|
|
|
|
|
/* ? disable GL_TEXTURE_GEN_n ? */
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_T);
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_R);
|
|
|
|
|
glDisable(GL_TEXTURE_GEN_Q);
|
|
|
|
|
FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2007-01-01 23:53:59 +01:00
|
|
|
|
|
|
|
|
|
/* Update the texture matrix */
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
|
|
|
|
|
transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage), stateblock);
|
|
|
|
|
}
|
2007-01-06 18:11:21 +01:00
|
|
|
|
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_VDECL) && stateblock->wineD3DDevice->namedArraysLoaded) {
|
|
|
|
|
/* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
|
|
|
|
|
* source. Call loadVertexData directly because there is no need to reparse the vertex declaration
|
|
|
|
|
* and do all the things linked to it
|
|
|
|
|
* TODO: Tidy that up to reload only the arrays of the changed unit
|
|
|
|
|
*/
|
|
|
|
|
loadVertexData(stateblock, &stateblock->wineD3DDevice->strided_streams);
|
|
|
|
|
}
|
2006-12-19 23:04:16 +01:00
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:05:08 +01:00
|
|
|
|
static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
|
|
|
|
tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
|
|
|
|
|
if(tmpvalue.f != 0.0) {
|
|
|
|
|
ERR("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:34:17 +01:00
|
|
|
|
static void tex_bumpenvloffset(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
|
|
|
|
|
union {
|
|
|
|
|
DWORD d;
|
|
|
|
|
float f;
|
|
|
|
|
} tmpvalue;
|
|
|
|
|
|
|
|
|
|
tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
|
|
|
|
|
if(tmpvalue.f != 0.0) {
|
|
|
|
|
ERR("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:11:21 +01:00
|
|
|
|
static void tex_resultarg(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
|
|
|
|
|
|
2007-01-10 11:31:18 +01:00
|
|
|
|
if(stage >= GL_LIMITS(texture_stages)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:11:21 +01:00
|
|
|
|
if(stateblock->textureState[stage][WINED3DTSS_RESULTARG] != D3DTA_CURRENT) {
|
|
|
|
|
ERR("WINED3DTSS_RESULTARG not supported yet\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:26:39 +01:00
|
|
|
|
static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
DWORD sampler = state - STATE_SAMPLER(0);
|
2007-01-03 19:18:59 +01:00
|
|
|
|
DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
|
2007-01-02 00:07:55 +01:00
|
|
|
|
union {
|
|
|
|
|
float f;
|
|
|
|
|
DWORD d;
|
|
|
|
|
} tmpvalue;
|
2006-12-19 23:26:39 +01:00
|
|
|
|
|
|
|
|
|
TRACE("Sampler: %d\n", sampler);
|
|
|
|
|
/* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
|
|
|
|
|
* only has to bind textures and set the per texture states
|
|
|
|
|
*/
|
2007-01-03 19:18:59 +01:00
|
|
|
|
|
|
|
|
|
if (mapped_stage == -1) {
|
|
|
|
|
TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:26:39 +01:00
|
|
|
|
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
if(sampler >= GL_LIMITS(sampler_stages)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2007-01-03 19:18:59 +01:00
|
|
|
|
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
|
2006-12-19 23:26:39 +01:00
|
|
|
|
checkGLcall("glActiveTextureARB");
|
|
|
|
|
} else if (sampler > 0) {
|
|
|
|
|
/* We can't do anything here */
|
|
|
|
|
WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(stateblock->textures[sampler]) {
|
2007-01-06 18:43:08 +01:00
|
|
|
|
BOOL texIsPow2 = FALSE;
|
2007-01-01 23:53:59 +01:00
|
|
|
|
|
2007-01-06 18:43:08 +01:00
|
|
|
|
/* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
|
|
|
|
|
* IWineD3DBaseTexture::ApplyStateChanges multiplies the set matrix with a fixup matrix. Before the
|
|
|
|
|
* scaling is reapplied or removed, the texture matrix has to be reapplied
|
|
|
|
|
*/
|
|
|
|
|
if(wined3d_settings.nonpower2_mode != NP2_NATIVE && sampler < MAX_TEXTURES) {
|
|
|
|
|
if(stateblock->textureDimensions[sampler] == GL_TEXTURE_2D) {
|
|
|
|
|
if(((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorX != 1.0 ||
|
|
|
|
|
((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorY != 1.0 ) {
|
|
|
|
|
texIsPow2 = TRUE;
|
|
|
|
|
}
|
|
|
|
|
} else if(stateblock->textureDimensions[sampler] == GL_TEXTURE_CUBE_MAP_ARB) {
|
|
|
|
|
if(((IWineD3DCubeTextureImpl *) stateblock->textures[sampler])->pow2scalingFactor != 1.0) {
|
|
|
|
|
texIsPow2 = TRUE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(texIsPow2 || stateblock->wineD3DDevice->lastWasPow2Texture[sampler]) {
|
|
|
|
|
transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock);
|
|
|
|
|
stateblock->wineD3DDevice->lastWasPow2Texture[sampler] = texIsPow2;
|
|
|
|
|
}
|
2007-01-01 23:53:59 +01:00
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:26:39 +01:00
|
|
|
|
IWineD3DBaseTexture_PreLoad((IWineD3DBaseTexture *) stateblock->textures[sampler]);
|
|
|
|
|
IWineD3DBaseTexture_ApplyStateChanges(stateblock->textures[sampler], stateblock->textureState[sampler], stateblock->samplerState[sampler]);
|
|
|
|
|
|
2007-01-02 00:07:55 +01:00
|
|
|
|
if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
|
|
|
|
|
tmpvalue.d = stateblock->samplerState[sampler][WINED3DSAMP_MIPMAPLODBIAS];
|
|
|
|
|
glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
|
|
|
|
|
GL_TEXTURE_LOD_BIAS_EXT,
|
|
|
|
|
tmpvalue.f);
|
|
|
|
|
checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:26:39 +01:00
|
|
|
|
if (stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader &&
|
|
|
|
|
((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
|
|
|
|
|
/* Using a pixel shader? Verify the sampler types */
|
|
|
|
|
|
|
|
|
|
/* Make sure that the texture dimensions are enabled. I don't have to disable the other
|
|
|
|
|
* dimensions because the shader knows from which texture type to sample from. For the sake of
|
|
|
|
|
* debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
|
|
|
|
|
* dimensions. This should make wrong sampling sources visible :-)
|
|
|
|
|
*/
|
|
|
|
|
glEnable(stateblock->textureDimensions[sampler]);
|
|
|
|
|
checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
|
|
|
|
|
} else if(sampler < stateblock->lowest_disabled_stage) {
|
2007-01-10 11:44:55 +01:00
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
|
|
|
|
|
activate_dimensions(sampler, stateblock);
|
|
|
|
|
}
|
2006-12-19 23:26:39 +01:00
|
|
|
|
|
|
|
|
|
if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
|
2007-01-04 10:47:11 +01:00
|
|
|
|
/* If color keying is enabled update the alpha test, it depends on the existence
|
2006-12-19 23:26:39 +01:00
|
|
|
|
* of a color key in stage 0
|
|
|
|
|
*/
|
|
|
|
|
state_alpha(WINED3DRS_COLORKEYENABLE, stateblock);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else if(sampler < GL_LIMITS(texture_stages)) {
|
|
|
|
|
if(sampler < stateblock->lowest_disabled_stage) {
|
2007-01-10 11:44:55 +01:00
|
|
|
|
/* TODO: What should I do with pixel shaders here ??? */
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
|
|
|
|
|
activate_dimensions(sampler, stateblock);
|
|
|
|
|
}
|
2006-12-19 23:26:39 +01:00
|
|
|
|
} /* Otherwise tex_colorop disables the stage */
|
|
|
|
|
glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
|
|
|
|
|
checkGLcall("glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-06 18:17:27 +01:00
|
|
|
|
static void shaderconstant(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
|
|
|
|
|
|
|
|
|
|
/* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
|
|
|
|
|
* has an update pending
|
|
|
|
|
*/
|
|
|
|
|
if(isStateDirty(device, STATE_VDECL) ||
|
|
|
|
|
isStateDirty(device, STATE_PIXELSHADER)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
device->shader_backend->shader_load_constants((IWineD3DDevice *) device,
|
|
|
|
|
stateblock->pixelShader && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function,
|
|
|
|
|
stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-19 23:22:19 +01:00
|
|
|
|
static void pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if(stateblock->pixelShader && ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.function != NULL) {
|
|
|
|
|
if(!stateblock->wineD3DDevice->last_was_pshader) {
|
|
|
|
|
/* Former draw without a pixel shader, some samplers
|
|
|
|
|
* may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
|
|
|
|
|
* make sure to enable them
|
|
|
|
|
*/
|
|
|
|
|
for(i=0; i < MAX_SAMPLERS; i++) {
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_SAMPLER(i))) {
|
|
|
|
|
sampler(STATE_SAMPLER(i), stateblock);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
|
|
|
|
|
* if a different texture was bound. I don't have to do anything.
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Compile and bind the shader */
|
|
|
|
|
IWineD3DPixelShader_CompileShader(stateblock->pixelShader);
|
|
|
|
|
|
2007-01-06 18:14:12 +01:00
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, StateTable[STATE_VSHADER].representative)) {
|
|
|
|
|
stateblock->wineD3DDevice->shader_backend->shader_select(
|
|
|
|
|
(IWineD3DDevice *) stateblock->wineD3DDevice,
|
|
|
|
|
TRUE,
|
|
|
|
|
!stateblock->vertexShader ? FALSE : ((IWineD3DVertexShaderImpl *) stateblock->vertexShader)->baseShader.function != NULL);
|
2007-01-06 18:17:27 +01:00
|
|
|
|
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_VERTEXSHADERCONSTANT)) {
|
|
|
|
|
shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock);
|
|
|
|
|
}
|
2007-01-06 18:14:12 +01:00
|
|
|
|
}
|
2006-12-19 23:22:19 +01:00
|
|
|
|
stateblock->wineD3DDevice->last_was_pshader = TRUE;
|
|
|
|
|
} else {
|
|
|
|
|
/* Disabled the pixel shader - color ops weren't applied
|
|
|
|
|
* while it was enabled, so re-apply them.
|
|
|
|
|
*/
|
|
|
|
|
for(i=0; i < MAX_TEXTURES; i++) {
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
|
|
|
|
|
tex_colorop(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
stateblock->wineD3DDevice->last_was_pshader = FALSE;
|
|
|
|
|
|
2007-01-06 18:14:12 +01:00
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, StateTable[STATE_VSHADER].representative)) {
|
|
|
|
|
stateblock->wineD3DDevice->shader_backend->shader_select(
|
|
|
|
|
(IWineD3DDevice *) stateblock->wineD3DDevice,
|
|
|
|
|
FALSE,
|
|
|
|
|
!stateblock->vertexShader ? FALSE : ((IWineD3DVertexShaderImpl *) stateblock->vertexShader)->baseShader.function != NULL);
|
2007-01-06 18:17:27 +01:00
|
|
|
|
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_VERTEXSHADERCONSTANT)) {
|
|
|
|
|
shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock);
|
|
|
|
|
}
|
2007-01-06 18:14:12 +01:00
|
|
|
|
}
|
2006-12-19 23:22:19 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-02 22:47:39 +01:00
|
|
|
|
static void transform_world(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2007-01-02 22:52:11 +01:00
|
|
|
|
/* This function is called by transform_view below if the view matrix was changed too
|
|
|
|
|
*
|
|
|
|
|
* Deliberately no check if the vertex declaration is dirty because the vdecl state
|
|
|
|
|
* does not always update the world matrix, only on a switch between transformed
|
|
|
|
|
* and untrannsformed draws. It *may* happen that the world matrix is set 2 times during one
|
|
|
|
|
* draw, but that should be rather rare and cheaper in total.
|
2007-01-02 22:47:39 +01:00
|
|
|
|
*/
|
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
|
checkGLcall("glMatrixMode");
|
|
|
|
|
|
2007-01-02 22:52:11 +01:00
|
|
|
|
if(stateblock->wineD3DDevice->last_was_rhw) {
|
|
|
|
|
glLoadIdentity();
|
|
|
|
|
checkGLcall("glLoadIdentity()");
|
2007-01-02 22:47:39 +01:00
|
|
|
|
} else {
|
2007-01-02 22:52:11 +01:00
|
|
|
|
/* In the general case, the view matrix is the identity matrix */
|
|
|
|
|
if (stateblock->wineD3DDevice->view_ident) {
|
|
|
|
|
glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
|
|
|
|
|
checkGLcall("glLoadMatrixf");
|
|
|
|
|
} else {
|
|
|
|
|
glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
|
|
|
|
|
checkGLcall("glLoadMatrixf");
|
|
|
|
|
glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
|
|
|
|
|
checkGLcall("glMultMatrixf");
|
|
|
|
|
}
|
2007-01-02 22:47:39 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-02 00:48:58 +01:00
|
|
|
|
static void transform_view(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
unsigned int k;
|
|
|
|
|
|
|
|
|
|
/* If we are changing the View matrix, reset the light and clipping planes to the new view
|
|
|
|
|
* NOTE: We have to reset the positions even if the light/plane is not currently
|
|
|
|
|
* enabled, since the call to enable it will not reset the position.
|
|
|
|
|
* NOTE2: Apparently texture transforms do NOT need reapplying
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
PLIGHTINFOEL *lightChain = NULL;
|
|
|
|
|
|
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
|
checkGLcall("glMatrixMode(GL_MODELVIEW)");
|
|
|
|
|
glLoadMatrixf((float *)(float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
|
|
|
|
|
checkGLcall("glLoadMatrixf(...)");
|
|
|
|
|
|
|
|
|
|
/* Reset lights. TODO: Call light apply func */
|
|
|
|
|
lightChain = stateblock->lights;
|
|
|
|
|
while (lightChain && lightChain->glIndex != -1) {
|
|
|
|
|
glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_POSITION, lightChain->lightPosn);
|
|
|
|
|
checkGLcall("glLightfv posn");
|
|
|
|
|
glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_SPOT_DIRECTION, lightChain->lightDirn);
|
|
|
|
|
checkGLcall("glLightfv dirn");
|
|
|
|
|
lightChain = lightChain->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Reset Clipping Planes if clipping is enabled. TODO: Call clipplane apply func */
|
|
|
|
|
for (k = 0; k < GL_LIMITS(clipplanes); k++) {
|
|
|
|
|
glClipPlane(GL_CLIP_PLANE0 + k, stateblock->clipplane[k]);
|
|
|
|
|
checkGLcall("glClipPlane");
|
|
|
|
|
}
|
2007-01-02 22:47:10 +01:00
|
|
|
|
|
2007-01-02 22:47:39 +01:00
|
|
|
|
if(stateblock->wineD3DDevice->last_was_rhw) {
|
|
|
|
|
glLoadIdentity();
|
|
|
|
|
checkGLcall("glLoadIdentity()");
|
|
|
|
|
/* No need to update the world matrix, the identity is fine */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
|
|
|
|
|
* No need to do it here if the state is scheduled for update.
|
|
|
|
|
*/
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
|
|
|
|
|
transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock);
|
|
|
|
|
}
|
2007-01-02 00:48:58 +01:00
|
|
|
|
}
|
|
|
|
|
|
2007-01-10 11:40:28 +01:00
|
|
|
|
static void transform_worldex(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
2007-01-10 11:37:03 +01:00
|
|
|
|
WARN("World matrix 1 - 255 not supported yet\n");
|
2007-01-02 00:25:51 +01:00
|
|
|
|
}
|
|
|
|
|
|
2007-01-02 22:47:10 +01:00
|
|
|
|
static const GLfloat invymat[16] = {
|
|
|
|
|
1.0f, 0.0f, 0.0f, 0.0f,
|
|
|
|
|
0.0f, -1.0f, 0.0f, 0.0f,
|
|
|
|
|
0.0f, 0.0f, 1.0f, 0.0f,
|
|
|
|
|
0.0f, 0.0f, 0.0f, 1.0f};
|
|
|
|
|
|
2007-01-02 22:50:38 +01:00
|
|
|
|
static void transform_projection(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
|
checkGLcall("glMatrixMode(GL_PROJECTION)");
|
|
|
|
|
glLoadIdentity();
|
|
|
|
|
checkGLcall("glLoadIdentity");
|
|
|
|
|
|
|
|
|
|
if(stateblock->wineD3DDevice->last_was_rhw) {
|
|
|
|
|
double X, Y, height, width, minZ, maxZ;
|
|
|
|
|
|
|
|
|
|
X = stateblock->viewport.X;
|
|
|
|
|
Y = stateblock->viewport.Y;
|
|
|
|
|
height = stateblock->viewport.Height;
|
|
|
|
|
width = stateblock->viewport.Width;
|
|
|
|
|
minZ = stateblock->viewport.MinZ;
|
|
|
|
|
maxZ = stateblock->viewport.MaxZ;
|
|
|
|
|
|
|
|
|
|
if(!stateblock->wineD3DDevice->untransformed) {
|
|
|
|
|
/* Transformed vertices are supposed to bypass the whole transform pipeline including
|
|
|
|
|
* frustum clipping. This can't be done in opengl, so this code adjusts the Z range to
|
|
|
|
|
* suppress depth clipping. This can be done because it is an orthogonal projection and
|
|
|
|
|
* the Z coordinate does not affect the size of the primitives
|
|
|
|
|
*/
|
|
|
|
|
TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
|
|
|
|
|
glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
|
|
|
|
|
} else {
|
|
|
|
|
/* If the app mixes transformed and untransformed primitives we can't use the coordinate system
|
|
|
|
|
* trick above because this would mess up transformed and untransformed Z order. Pass the z position
|
|
|
|
|
* unmodified to opengl.
|
|
|
|
|
*
|
|
|
|
|
* If the app depends on mixed types and disabled clipping we're out of luck without a pipeline
|
|
|
|
|
* replacement shader.
|
|
|
|
|
*/
|
|
|
|
|
TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, 1.0, -1.0);
|
|
|
|
|
glOrtho(X, X + width, Y + height, Y, 1.0, -1.0);
|
|
|
|
|
}
|
|
|
|
|
checkGLcall("glOrtho");
|
|
|
|
|
|
|
|
|
|
/* Window Coord 0 is the middle of the first pixel, so translate by 3/8 pixels */
|
|
|
|
|
glTranslatef(0.375, 0.375, 0);
|
|
|
|
|
checkGLcall("glTranslatef(0.375, 0.375, 0)");
|
|
|
|
|
/* D3D texture coordinates are flipped compared to OpenGL ones, so
|
|
|
|
|
* render everything upside down when rendering offscreen. */
|
|
|
|
|
if (stateblock->wineD3DDevice->render_offscreen) {
|
|
|
|
|
glMultMatrixf(invymat);
|
|
|
|
|
checkGLcall("glMultMatrixf(invymat)");
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* The rule is that the window coordinate 0 does not correspond to the
|
|
|
|
|
beginning of the first pixel, but the center of the first pixel.
|
|
|
|
|
As a consequence if you want to correctly draw one line exactly from
|
|
|
|
|
the left to the right end of the viewport (with all matrices set to
|
|
|
|
|
be identity), the x coords of both ends of the line would be not
|
|
|
|
|
-1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
|
|
|
|
|
instead. */
|
|
|
|
|
glTranslatef(0.9 / stateblock->viewport.Width, -0.9 / stateblock->viewport.Height, 0);
|
|
|
|
|
checkGLcall("glTranslatef (0.9 / width, -0.9 / height, 0)");
|
|
|
|
|
|
|
|
|
|
/* D3D texture coordinates are flipped compared to OpenGL ones, so
|
|
|
|
|
* render everything upside down when rendering offscreen. */
|
|
|
|
|
if (stateblock->wineD3DDevice->render_offscreen) {
|
|
|
|
|
glMultMatrixf(invymat);
|
|
|
|
|
checkGLcall("glMultMatrixf(invymat)");
|
|
|
|
|
}
|
|
|
|
|
glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_PROJECTION].u.m[0][0]);
|
|
|
|
|
checkGLcall("glLoadMatrixf");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-06 18:11:21 +01:00
|
|
|
|
/* This should match any arrays loaded in loadVertexData.
|
|
|
|
|
* stateblock impl is required for GL_SUPPORT
|
|
|
|
|
* TODO: Only load / unload arrays if we have to.
|
|
|
|
|
*/
|
|
|
|
|
static inline void unloadVertexData(IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
int texture_idx;
|
|
|
|
|
|
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
|
glDisableClientState(GL_NORMAL_ARRAY);
|
|
|
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
|
|
|
|
if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
|
|
|
|
|
glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
|
|
|
|
|
}
|
|
|
|
|
for (texture_idx = 0; texture_idx < GL_LIMITS(textures); ++texture_idx) {
|
|
|
|
|
GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
|
|
|
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This should match any arrays loaded in loadNumberedArrays
|
|
|
|
|
* TODO: Only load / unload arrays if we have to.
|
|
|
|
|
*/
|
|
|
|
|
static inline void unloadNumberedArrays(IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
/* disable any attribs (this is the same for both GLSL and ARB modes) */
|
|
|
|
|
GLint maxAttribs;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Leave all the attribs disabled */
|
|
|
|
|
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &maxAttribs);
|
|
|
|
|
/* MESA does not support it right not */
|
|
|
|
|
if (glGetError() != GL_NO_ERROR)
|
|
|
|
|
maxAttribs = 16;
|
|
|
|
|
for (i = 0; i < maxAttribs; ++i) {
|
|
|
|
|
GL_EXTCALL(glDisableVertexAttribArrayARB(i));
|
|
|
|
|
checkGLcall("glDisableVertexAttribArrayARB(reg);");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *strided) {
|
|
|
|
|
GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_ATTRIBS; i++) {
|
|
|
|
|
|
|
|
|
|
if (!strided->u.input[i].lpData && !strided->u.input[i].VBO)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, strided->u.input[i].VBO);
|
|
|
|
|
|
|
|
|
|
if(curVBO != strided->u.input[i].VBO) {
|
|
|
|
|
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, strided->u.input[i].VBO));
|
|
|
|
|
checkGLcall("glBindBufferARB");
|
|
|
|
|
curVBO = strided->u.input[i].VBO;
|
|
|
|
|
}
|
|
|
|
|
GL_EXTCALL(glVertexAttribPointerARB(i,
|
|
|
|
|
WINED3D_ATR_SIZE(strided->u.input[i].dwType),
|
|
|
|
|
WINED3D_ATR_GLTYPE(strided->u.input[i].dwType),
|
|
|
|
|
WINED3D_ATR_NORMALIZED(strided->u.input[i].dwType),
|
|
|
|
|
strided->u.input[i].dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
strided->u.input[i].lpData + stateblock->loadBaseVertexIndex * strided->u.input[i].dwStride));
|
2007-01-06 18:11:21 +01:00
|
|
|
|
GL_EXTCALL(glEnableVertexAttribArrayARB(i));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Used from 2 different functions, and too big to justify making it inlined */
|
|
|
|
|
static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd) {
|
|
|
|
|
unsigned int textureNo = 0;
|
|
|
|
|
unsigned int texture_idx = 0;
|
|
|
|
|
GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
|
|
|
|
|
|
|
|
|
|
TRACE("Using fast vertex array code\n");
|
|
|
|
|
/* Blend Data ---------------------------------------------- */
|
|
|
|
|
if( (sd->u.s.blendWeights.lpData) || (sd->u.s.blendWeights.VBO) ||
|
|
|
|
|
(sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO) ) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
|
|
|
|
|
|
|
|
|
|
#if 1
|
|
|
|
|
glEnableClientState(GL_WEIGHT_ARRAY_ARB);
|
|
|
|
|
checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
TRACE("Blend %d %p %d\n", WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride, sd->u.s.blendWeights.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
/* FIXME("TODO\n");*/
|
|
|
|
|
/* Note dwType == float3 or float4 == 2 or 3 */
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
/* with this on, the normals appear to be being modified,
|
|
|
|
|
but the vertices aren't being translated as they should be
|
|
|
|
|
Maybe the world matrix aren't being setup properly? */
|
|
|
|
|
glVertexBlendARB(WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) + 1);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
VTRACE(("glWeightPointerARB(%d, GL_FLOAT, %d, %p)\n",
|
|
|
|
|
WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) ,
|
|
|
|
|
sd->u.s.blendWeights.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride));
|
2007-01-06 18:11:21 +01:00
|
|
|
|
|
|
|
|
|
if(curVBO != sd->u.s.blendWeights.VBO) {
|
|
|
|
|
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.blendWeights.VBO));
|
|
|
|
|
checkGLcall("glBindBufferARB");
|
|
|
|
|
curVBO = sd->u.s.blendWeights.VBO;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GL_EXTCALL(glWeightPointerARB)(
|
|
|
|
|
WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
|
|
|
|
|
sd->u.s.blendWeights.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
|
|
|
|
|
checkGLcall("glWeightPointerARB");
|
|
|
|
|
|
|
|
|
|
if((sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO)){
|
|
|
|
|
static BOOL showfixme = TRUE;
|
|
|
|
|
if(showfixme){
|
|
|
|
|
FIXME("blendMatrixIndices support\n");
|
|
|
|
|
showfixme = FALSE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
|
|
|
|
|
/* FIXME("TODO\n");*/
|
|
|
|
|
#if 0
|
|
|
|
|
|
|
|
|
|
GL_EXTCALL(glVertexWeightPointerEXT)(
|
|
|
|
|
WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
|
|
|
|
|
sd->u.s.blendWeights.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
checkGLcall("glVertexWeightPointerEXT(numBlends, ...)");
|
|
|
|
|
glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
|
|
|
|
|
checkGLcall("glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
/* TODO: support blends in fixupVertices */
|
|
|
|
|
FIXME("unsupported blending in openGl\n");
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
|
|
|
|
|
#if 0 /* TODO: Vertex blending */
|
|
|
|
|
glDisable(GL_VERTEX_BLEND_ARB);
|
|
|
|
|
#endif
|
|
|
|
|
TRACE("ARB_VERTEX_BLEND\n");
|
|
|
|
|
} else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
|
|
|
|
|
TRACE(" EXT_VERTEX_WEIGHTING\n");
|
|
|
|
|
glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
|
|
|
|
|
checkGLcall("glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if 0 /* FOG ----------------------------------------------*/
|
|
|
|
|
if (sd->u.s.fog.lpData || sd->u.s.fog.VBO) {
|
|
|
|
|
/* TODO: fog*/
|
|
|
|
|
if (GL_SUPPORT(EXT_FOG_COORD) {
|
|
|
|
|
glEnableClientState(GL_FOG_COORDINATE_EXT);
|
|
|
|
|
(GL_EXTCALL)(FogCoordPointerEXT)(
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.fog.dwType),
|
|
|
|
|
sd->u.s.fog.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.fog.lpData + stateblock->loadBaseVertexIndex * sd->u.s.fog.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
} else {
|
|
|
|
|
/* don't bother falling back to 'slow' as we don't support software FOG yet. */
|
|
|
|
|
/* FIXME: fixme once */
|
|
|
|
|
TRACE("Hardware support for FOG is not avaiable, FOG disabled.\n");
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (GL_SUPPRT(EXT_FOR_COORD) {
|
|
|
|
|
/* make sure fog is disabled */
|
|
|
|
|
glDisableClientState(GL_FOG_COORDINATE_EXT);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if 0 /* tangents ----------------------------------------------*/
|
|
|
|
|
if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO ||
|
|
|
|
|
sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
|
|
|
|
|
/* TODO: tangents*/
|
|
|
|
|
if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
|
|
|
|
|
if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO) {
|
|
|
|
|
glEnable(GL_TANGENT_ARRAY_EXT);
|
|
|
|
|
(GL_EXTCALL)(TangentPointerEXT)(
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.tangent.dwType),
|
|
|
|
|
sd->u.s.tangent.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.tangent.lpData + stateblock->loadBaseVertexIndex * sd->u.s.tangent.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
} else {
|
|
|
|
|
glDisable(GL_TANGENT_ARRAY_EXT);
|
|
|
|
|
}
|
|
|
|
|
if (sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
|
|
|
|
|
glEnable(GL_BINORMAL_ARRAY_EXT);
|
|
|
|
|
(GL_EXTCALL)(BinormalPointerEXT)(
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.binormal.dwType),
|
|
|
|
|
sd->u.s.binormal.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.binormal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.binormal.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
} else{
|
|
|
|
|
glDisable(GL_BINORMAL_ARRAY_EXT);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
/* don't bother falling back to 'slow' as we don't support software tangents and binormals yet . */
|
|
|
|
|
/* FIXME: fixme once */
|
|
|
|
|
TRACE("Hardware support for tangents and binormals is not avaiable, tangents and binormals disabled.\n");
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
|
|
|
|
|
/* make sure fog is disabled */
|
|
|
|
|
glDisable(GL_TANGENT_ARRAY_EXT);
|
|
|
|
|
glDisable(GL_BINORMAL_ARRAY_EXT);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Point Size ----------------------------------------------*/
|
|
|
|
|
if (sd->u.s.pSize.lpData || sd->u.s.pSize.VBO) {
|
|
|
|
|
|
|
|
|
|
/* no such functionality in the fixed function GL pipeline */
|
|
|
|
|
TRACE("Cannot change ptSize here in openGl\n");
|
|
|
|
|
/* TODO: Implement this function in using shaders if they are available */
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Vertex Pointers -----------------------------------------*/
|
|
|
|
|
if (sd->u.s.position.lpData != NULL || sd->u.s.position.VBO != 0) {
|
|
|
|
|
/* Note dwType == float3 or float4 == 2 or 3 */
|
|
|
|
|
VTRACE(("glVertexPointer(%d, GL_FLOAT, %d, %p)\n",
|
|
|
|
|
sd->u.s.position.dwStride,
|
|
|
|
|
sd->u.s.position.dwType + 1,
|
|
|
|
|
sd->u.s.position.lpData));
|
|
|
|
|
|
|
|
|
|
if(curVBO != sd->u.s.position.VBO) {
|
|
|
|
|
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.position.VBO));
|
|
|
|
|
checkGLcall("glBindBufferARB");
|
|
|
|
|
curVBO = sd->u.s.position.VBO;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* min(WINED3D_ATR_SIZE(position),3) to Disable RHW mode as 'w' coord
|
|
|
|
|
handling for rhw mode should not impact screen position whereas in GL it does.
|
|
|
|
|
This may result in very slightly distored textures in rhw mode, but
|
|
|
|
|
a very minimal different. There's always the other option of
|
|
|
|
|
fixing the view matrix to prevent w from having any effect
|
|
|
|
|
|
|
|
|
|
This only applies to user pointer sources, in VBOs the vertices are fixed up
|
|
|
|
|
*/
|
|
|
|
|
if(sd->u.s.position.VBO == 0) {
|
|
|
|
|
glVertexPointer(3 /* min(WINED3D_ATR_SIZE(sd->u.s.position.dwType),3) */,
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
} else {
|
|
|
|
|
glVertexPointer(
|
|
|
|
|
WINED3D_ATR_SIZE(sd->u.s.position.dwType),
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
}
|
|
|
|
|
checkGLcall("glVertexPointer(...)");
|
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
|
checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
|
checkGLcall("glDisableClientState(GL_VERTEX_ARRAY)");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Normals -------------------------------------------------*/
|
|
|
|
|
if (sd->u.s.normal.lpData || sd->u.s.normal.VBO) {
|
|
|
|
|
/* Note dwType == float3 or float4 == 2 or 3 */
|
|
|
|
|
VTRACE(("glNormalPointer(GL_FLOAT, %d, %p)\n",
|
|
|
|
|
sd->u.s.normal.dwStride,
|
|
|
|
|
sd->u.s.normal.lpData));
|
|
|
|
|
if(curVBO != sd->u.s.normal.VBO) {
|
|
|
|
|
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.normal.VBO));
|
|
|
|
|
checkGLcall("glBindBufferARB");
|
|
|
|
|
curVBO = sd->u.s.normal.VBO;
|
|
|
|
|
}
|
|
|
|
|
glNormalPointer(
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.normal.dwType),
|
|
|
|
|
sd->u.s.normal.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.normal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.normal.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
checkGLcall("glNormalPointer(...)");
|
|
|
|
|
glEnableClientState(GL_NORMAL_ARRAY);
|
|
|
|
|
checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
glDisableClientState(GL_NORMAL_ARRAY);
|
|
|
|
|
checkGLcall("glDisableClientState(GL_NORMAL_ARRAY)");
|
|
|
|
|
glNormal3f(0, 0, 1);
|
|
|
|
|
checkGLcall("glNormal3f(0, 0, 1)");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Diffuse Colour --------------------------------------------*/
|
|
|
|
|
/* WARNING: Data here MUST be in RGBA format, so cannot */
|
|
|
|
|
/* go directly into fast mode from app pgm, because */
|
|
|
|
|
/* directx requires data in BGRA format. */
|
|
|
|
|
/* currently fixupVertices swizels the format, but this isn't */
|
|
|
|
|
/* very practical when using VBOS */
|
|
|
|
|
/* NOTE: Unless we write a vertex shader to swizel the colour */
|
|
|
|
|
/* , or the user doesn't care and wants the speed advantage */
|
|
|
|
|
|
|
|
|
|
if (sd->u.s.diffuse.lpData || sd->u.s.diffuse.VBO) {
|
|
|
|
|
/* Note dwType == float3 or float4 == 2 or 3 */
|
|
|
|
|
VTRACE(("glColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
|
|
|
|
|
sd->u.s.diffuse.dwStride,
|
|
|
|
|
sd->u.s.diffuse.lpData));
|
|
|
|
|
|
|
|
|
|
if(curVBO != sd->u.s.diffuse.VBO) {
|
|
|
|
|
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.diffuse.VBO));
|
|
|
|
|
checkGLcall("glBindBufferARB");
|
|
|
|
|
curVBO = sd->u.s.diffuse.VBO;
|
|
|
|
|
}
|
|
|
|
|
glColorPointer(4, GL_UNSIGNED_BYTE,
|
|
|
|
|
sd->u.s.diffuse.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.diffuse.lpData + stateblock->loadBaseVertexIndex * sd->u.s.diffuse.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
|
|
|
|
|
glEnableClientState(GL_COLOR_ARRAY);
|
|
|
|
|
checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
|
|
|
|
checkGLcall("glDisableClientState(GL_COLOR_ARRAY)");
|
|
|
|
|
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
|
checkGLcall("glColor4f(1, 1, 1, 1)");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Specular Colour ------------------------------------------*/
|
|
|
|
|
if (sd->u.s.specular.lpData || sd->u.s.specular.VBO) {
|
|
|
|
|
TRACE("setting specular colour\n");
|
|
|
|
|
/* Note dwType == float3 or float4 == 2 or 3 */
|
|
|
|
|
VTRACE(("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
|
|
|
|
|
sd->u.s.specular.dwStride,
|
|
|
|
|
sd->u.s.specular.lpData));
|
|
|
|
|
if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
|
|
|
|
|
if(curVBO != sd->u.s.specular.VBO) {
|
|
|
|
|
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.specular.VBO));
|
|
|
|
|
checkGLcall("glBindBufferARB");
|
|
|
|
|
curVBO = sd->u.s.specular.VBO;
|
|
|
|
|
}
|
|
|
|
|
GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE,
|
|
|
|
|
sd->u.s.specular.dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.specular.lpData + stateblock->loadBaseVertexIndex * sd->u.s.specular.dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
vcheckGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, ...)");
|
|
|
|
|
glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
|
|
|
|
|
vcheckGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
|
|
/* Missing specular color is not critical, no warnings */
|
|
|
|
|
VTRACE(("Specular colour is not supported in this GL implementation\n"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
|
|
|
|
|
|
|
|
|
|
glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
|
|
|
|
|
checkGLcall("glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
|
|
|
|
|
GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
|
|
|
|
|
checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
|
|
/* Missing specular color is not critical, no warnings */
|
|
|
|
|
VTRACE(("Specular colour is not supported in this GL implementation\n"));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Texture coords -------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
for (textureNo = 0, texture_idx = 0; textureNo < GL_LIMITS(texture_stages); ++textureNo) {
|
|
|
|
|
/* The code below uses glClientActiveTexture and glMultiTexCoord* which are all part of the GL_ARB_multitexture extension. */
|
|
|
|
|
/* Abort if we don't support the extension. */
|
|
|
|
|
if (!GL_SUPPORT(ARB_MULTITEXTURE)) {
|
|
|
|
|
FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (/*!GL_SUPPORT(NV_REGISTER_COMBINERS) || stateblock->textures[textureNo]*/ TRUE) {
|
|
|
|
|
/* Select the correct texture stage */
|
|
|
|
|
GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (stateblock->textures[textureNo] != NULL) {
|
|
|
|
|
int coordIdx = stateblock->textureState[textureNo][WINED3DTSS_TEXCOORDINDEX];
|
|
|
|
|
|
|
|
|
|
if (coordIdx >= MAX_TEXTURES) {
|
|
|
|
|
VTRACE(("tex: %d - Skip tex coords, as being system generated\n", textureNo));
|
|
|
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
|
GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
|
|
|
|
|
|
|
|
|
|
} else if (sd->u.s.texCoords[coordIdx].lpData == NULL && sd->u.s.texCoords[coordIdx].VBO == 0) {
|
|
|
|
|
VTRACE(("Bound texture but no texture coordinates supplied, so skipping\n"));
|
|
|
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
|
GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
|
|
|
|
|
textureNo, texture_idx, coordIdx, sd->u.s.texCoords[coordIdx].lpData);
|
|
|
|
|
if(curVBO != sd->u.s.texCoords[coordIdx].VBO) {
|
|
|
|
|
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.texCoords[coordIdx].VBO));
|
|
|
|
|
checkGLcall("glBindBufferARB");
|
|
|
|
|
curVBO = sd->u.s.texCoords[coordIdx].VBO;
|
|
|
|
|
}
|
|
|
|
|
/* The coords to supply depend completely on the fvf / vertex shader */
|
|
|
|
|
glTexCoordPointer(
|
|
|
|
|
WINED3D_ATR_SIZE(sd->u.s.texCoords[coordIdx].dwType),
|
|
|
|
|
WINED3D_ATR_GLTYPE(sd->u.s.texCoords[coordIdx].dwType),
|
|
|
|
|
sd->u.s.texCoords[coordIdx].dwStride,
|
2007-01-06 18:19:55 +01:00
|
|
|
|
sd->u.s.texCoords[coordIdx].lpData + stateblock->loadBaseVertexIndex * sd->u.s.texCoords[coordIdx].dwStride);
|
2007-01-06 18:11:21 +01:00
|
|
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
|
}
|
|
|
|
|
} else if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
|
GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
|
|
|
|
|
}
|
|
|
|
|
if (/*!GL_SUPPORT(NV_REGISTER_COMBINERS) || stateblock->textures[textureNo]*/ TRUE) ++texture_idx;
|
|
|
|
|
}
|
|
|
|
|
if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
|
|
|
|
|
for (textureNo = texture_idx; textureNo < GL_LIMITS(textures); ++textureNo) {
|
|
|
|
|
GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + textureNo));
|
|
|
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
|
|
|
GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-06 18:12:21 +01:00
|
|
|
|
inline void drawPrimitiveTraceDataLocations(
|
|
|
|
|
WineDirect3DVertexStridedData *dataLocations) {
|
|
|
|
|
|
|
|
|
|
/* Dump out what parts we have supplied */
|
|
|
|
|
TRACE("Strided Data:\n");
|
|
|
|
|
TRACE_STRIDED((dataLocations), position);
|
|
|
|
|
TRACE_STRIDED((dataLocations), blendWeights);
|
|
|
|
|
TRACE_STRIDED((dataLocations), blendMatrixIndices);
|
|
|
|
|
TRACE_STRIDED((dataLocations), normal);
|
|
|
|
|
TRACE_STRIDED((dataLocations), pSize);
|
|
|
|
|
TRACE_STRIDED((dataLocations), diffuse);
|
|
|
|
|
TRACE_STRIDED((dataLocations), specular);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[0]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[1]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[2]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[3]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[4]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[5]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[6]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), texCoords[7]);
|
|
|
|
|
TRACE_STRIDED((dataLocations), position2);
|
|
|
|
|
TRACE_STRIDED((dataLocations), normal2);
|
|
|
|
|
TRACE_STRIDED((dataLocations), tangent);
|
|
|
|
|
TRACE_STRIDED((dataLocations), binormal);
|
|
|
|
|
TRACE_STRIDED((dataLocations), tessFactor);
|
|
|
|
|
TRACE_STRIDED((dataLocations), fog);
|
|
|
|
|
TRACE_STRIDED((dataLocations), depth);
|
|
|
|
|
TRACE_STRIDED((dataLocations), sample);
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-04 00:13:15 +01:00
|
|
|
|
/* Helper for vertexdeclaration() */
|
|
|
|
|
static inline void handleStreams(IWineD3DStateBlockImpl *stateblock, BOOL useVertexShaderFunction) {
|
2007-01-02 22:47:10 +01:00
|
|
|
|
IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
|
2007-01-06 18:11:21 +01:00
|
|
|
|
BOOL fixup = FALSE;
|
|
|
|
|
WineDirect3DVertexStridedData *dataLocations = &device->strided_streams;
|
2007-01-02 22:47:10 +01:00
|
|
|
|
|
|
|
|
|
if(device->up_strided) {
|
2007-01-02 21:31:08 +01:00
|
|
|
|
/* Note: this is a ddraw fixed-function code path */
|
|
|
|
|
TRACE("================ Strided Input ===================\n");
|
2007-01-06 18:11:21 +01:00
|
|
|
|
memcpy(dataLocations, device->up_strided, sizeof(*dataLocations));
|
2007-01-06 18:12:21 +01:00
|
|
|
|
|
|
|
|
|
if(TRACE_ON(d3d)) {
|
|
|
|
|
drawPrimitiveTraceDataLocations(dataLocations);
|
|
|
|
|
}
|
2007-01-04 00:13:15 +01:00
|
|
|
|
} else if (stateblock->vertexDecl || stateblock->vertexShader) {
|
2007-01-02 21:31:08 +01:00
|
|
|
|
/* Note: This is a fixed function or shader codepath.
|
|
|
|
|
* This means it must handle both types of strided data.
|
|
|
|
|
* Shaders must go through here to zero the strided data, even if they
|
|
|
|
|
* don't set any declaration at all
|
|
|
|
|
*/
|
|
|
|
|
TRACE("================ Vertex Declaration ===================\n");
|
2007-01-06 18:11:21 +01:00
|
|
|
|
memset(dataLocations, 0, sizeof(*dataLocations));
|
2007-01-02 22:47:10 +01:00
|
|
|
|
|
2007-01-02 21:31:08 +01:00
|
|
|
|
if (stateblock->vertexDecl != NULL ||
|
|
|
|
|
((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->vertexDeclaration != NULL) {
|
2007-01-02 22:47:10 +01:00
|
|
|
|
|
|
|
|
|
primitiveDeclarationConvertToStridedData((IWineD3DDevice *) device, useVertexShaderFunction,
|
2007-01-06 18:11:21 +01:00
|
|
|
|
dataLocations, &fixup);
|
2007-01-02 21:31:08 +01:00
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* Note: This codepath is not reachable from d3d9 (see fvf->decl9 conversion)
|
|
|
|
|
* It is reachable through d3d8, but only for fixed-function.
|
|
|
|
|
* It will not work properly for shaders.
|
|
|
|
|
*/
|
|
|
|
|
TRACE("================ FVF ===================\n");
|
2007-01-06 18:11:21 +01:00
|
|
|
|
memset(dataLocations, 0, sizeof(*dataLocations));
|
2007-01-10 11:37:03 +01:00
|
|
|
|
primitiveConvertToStridedData((IWineD3DDevice *) device, dataLocations, &fixup);
|
2007-01-06 18:12:21 +01:00
|
|
|
|
if(TRACE_ON(d3d)) {
|
|
|
|
|
drawPrimitiveTraceDataLocations(dataLocations);
|
|
|
|
|
}
|
2007-01-02 21:31:08 +01:00
|
|
|
|
}
|
2007-01-06 18:11:21 +01:00
|
|
|
|
|
|
|
|
|
/* Unload the old arrays before loading the new ones to get old junk out */
|
|
|
|
|
if(device->numberedArraysLoaded) {
|
|
|
|
|
unloadNumberedArrays(stateblock);
|
|
|
|
|
device->numberedArraysLoaded = FALSE;
|
|
|
|
|
}
|
|
|
|
|
if(device->namedArraysLoaded) {
|
|
|
|
|
unloadVertexData(stateblock);
|
|
|
|
|
device->namedArraysLoaded = FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(useVertexShaderFunction) {
|
|
|
|
|
TRACE("Loading numbered arrays\n");
|
|
|
|
|
loadNumberedArrays(stateblock, dataLocations);
|
|
|
|
|
device->useDrawStridedSlow = FALSE;
|
|
|
|
|
device->numberedArraysLoaded = TRUE;
|
|
|
|
|
} else if (fixup ||
|
|
|
|
|
(dataLocations->u.s.pSize.lpData == NULL &&
|
|
|
|
|
dataLocations->u.s.diffuse.lpData == NULL &&
|
|
|
|
|
dataLocations->u.s.specular.lpData == NULL)) {
|
|
|
|
|
/* Load the vertex data using named arrays */
|
|
|
|
|
TRACE("Loading vertex data\n");
|
|
|
|
|
loadVertexData(stateblock, dataLocations);
|
|
|
|
|
device->useDrawStridedSlow = FALSE;
|
|
|
|
|
device->namedArraysLoaded = TRUE;
|
|
|
|
|
} else {
|
|
|
|
|
TRACE("Not loading vertex data\n");
|
|
|
|
|
device->useDrawStridedSlow = TRUE;
|
|
|
|
|
}
|
2007-01-06 18:13:21 +01:00
|
|
|
|
|
|
|
|
|
/* Generate some fixme's if unsupported functionality is being used */
|
|
|
|
|
#define BUFFER_OR_DATA(_attribute) dataLocations->u.s._attribute.lpData
|
|
|
|
|
/* TODO: Either support missing functionality in fixupVertices or by creating a shader to replace the pipeline. */
|
|
|
|
|
if (!useVertexShaderFunction && (BUFFER_OR_DATA(blendMatrixIndices) || BUFFER_OR_DATA(blendWeights))) {
|
|
|
|
|
FIXME("Blending data is only valid with vertex shaders %p %p\n",dataLocations->u.s.blendWeights.lpData,dataLocations->u.s.blendWeights.lpData);
|
|
|
|
|
}
|
|
|
|
|
if (!useVertexShaderFunction && (BUFFER_OR_DATA(position2) || BUFFER_OR_DATA(normal2))) {
|
|
|
|
|
FIXME("Tweening is only valid with vertex shaders\n");
|
|
|
|
|
}
|
|
|
|
|
if (!useVertexShaderFunction && (BUFFER_OR_DATA(tangent) || BUFFER_OR_DATA(binormal))) {
|
|
|
|
|
FIXME("Tangent and binormal bump mapping is only valid with vertex shaders\n");
|
|
|
|
|
}
|
|
|
|
|
if (!useVertexShaderFunction && (BUFFER_OR_DATA(tessFactor) || BUFFER_OR_DATA(fog) || BUFFER_OR_DATA(depth) || BUFFER_OR_DATA(sample))) {
|
|
|
|
|
FIXME("Extended attributes are only valid with vertex shaders\n");
|
|
|
|
|
}
|
|
|
|
|
#undef BUFFER_OR_DATA
|
2007-01-04 00:13:15 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
BOOL useVertexShaderFunction = FALSE, updateFog = FALSE;
|
|
|
|
|
BOOL transformed;
|
|
|
|
|
/* Some stuff is in the device until we have per context tracking */
|
|
|
|
|
IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
|
|
|
|
|
BOOL wasrhw = device->last_was_rhw;
|
|
|
|
|
|
|
|
|
|
/* Shaders can be implemented using ARB_PROGRAM, GLSL, or software -
|
|
|
|
|
* here simply check whether a shader was set, or the user disabled shaders
|
|
|
|
|
*/
|
|
|
|
|
if (device->vs_selected_mode != SHADER_NONE && stateblock->vertexShader &&
|
|
|
|
|
((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL) {
|
|
|
|
|
useVertexShaderFunction = TRUE;
|
|
|
|
|
|
|
|
|
|
if(((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog != device->last_was_foggy_shader) {
|
|
|
|
|
updateFog = TRUE;
|
|
|
|
|
}
|
|
|
|
|
} else if(device->last_was_foggy_shader) {
|
|
|
|
|
updateFog = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
handleStreams(stateblock, useVertexShaderFunction);
|
|
|
|
|
|
2007-01-02 22:47:10 +01:00
|
|
|
|
/* Do I have to use ? TRUE : FALSE ? Or can I rely on 15==15 beeing equal to TRUE(=1)? */
|
|
|
|
|
transformed = ((device->strided_streams.u.s.position.lpData != NULL ||
|
|
|
|
|
device->strided_streams.u.s.position.VBO != 0) &&
|
|
|
|
|
device->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
|
|
|
|
|
|
|
|
|
|
if(transformed != device->last_was_rhw && !useVertexShaderFunction) {
|
|
|
|
|
updateFog = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-02 22:49:17 +01:00
|
|
|
|
/* Reapply lighting if it is not sheduled for reapplication already */
|
|
|
|
|
if(!isStateDirty(device, STATE_RENDER(WINED3DRS_LIGHTING))) {
|
|
|
|
|
state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock);
|
2007-01-02 22:47:10 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!useVertexShaderFunction && transformed) {
|
2007-01-02 22:52:11 +01:00
|
|
|
|
stateblock->wineD3DDevice->last_was_rhw = TRUE;
|
2007-01-02 22:47:10 +01:00
|
|
|
|
} else {
|
|
|
|
|
|
|
|
|
|
/* Untransformed, so relies on the view and projection matrices */
|
2007-01-02 22:47:39 +01:00
|
|
|
|
device->last_was_rhw = FALSE;
|
|
|
|
|
/* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
|
2007-01-02 22:47:10 +01:00
|
|
|
|
device->untransformed = TRUE;
|
|
|
|
|
|
2007-01-02 22:52:11 +01:00
|
|
|
|
/* Todo for sw shaders: Vertex Shader output is already transformed, so set up identity matrices
|
|
|
|
|
* Not needed as long as only hw shaders are supported
|
2007-01-02 22:47:39 +01:00
|
|
|
|
*/
|
2007-01-02 22:47:10 +01:00
|
|
|
|
|
2007-01-02 22:52:11 +01:00
|
|
|
|
/* This sets the shader output position correction constants.
|
|
|
|
|
* TODO: Move to the viewport state
|
|
|
|
|
*/
|
2007-01-02 22:47:10 +01:00
|
|
|
|
if (useVertexShaderFunction) {
|
|
|
|
|
device->posFixup[1] = device->render_offscreen ? -1.0 : 1.0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-02 22:52:11 +01:00
|
|
|
|
/* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
|
|
|
|
|
* off this function will be called again anyway to make sure they're properly set
|
2007-01-02 22:50:38 +01:00
|
|
|
|
*/
|
2007-01-02 22:52:11 +01:00
|
|
|
|
if(!useVertexShaderFunction) {
|
|
|
|
|
/* TODO: Move this mainly to the viewport state and only apply when the vp has changed
|
|
|
|
|
* or transformed / untransformed was switched
|
|
|
|
|
*/
|
2007-01-04 00:05:05 +01:00
|
|
|
|
if(wasrhw != device->last_was_rhw &&
|
|
|
|
|
!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
|
|
|
|
|
!isStateDirty(stateblock->wineD3DDevice, STATE_VIEWPORT)) {
|
2007-01-02 22:52:11 +01:00
|
|
|
|
transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock);
|
|
|
|
|
}
|
|
|
|
|
/* World matrix needs reapplication here only if we're switching between rhw and non-rhw
|
|
|
|
|
* mode.
|
|
|
|
|
*
|
|
|
|
|
* If a vertex shader is used, the world matrix changed and then vertex shader unbound
|
|
|
|
|
* this check will fail and the matrix not applied again. This is OK because a simple
|
|
|
|
|
* world matrix change reapplies the matrix - These checks here are only to satisfy the
|
|
|
|
|
* needs of the vertex declaration.
|
|
|
|
|
*
|
|
|
|
|
* World and view matrix go into the same gl matrix, so only apply them when neither is
|
|
|
|
|
* dirty
|
|
|
|
|
*/
|
|
|
|
|
if(transformed != wasrhw &&
|
|
|
|
|
!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
|
|
|
|
|
!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_VIEW))) {
|
|
|
|
|
transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock);
|
|
|
|
|
}
|
2007-01-10 11:26:12 +01:00
|
|
|
|
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_RENDER(WINED3DRS_COLORVERTEX))) {
|
|
|
|
|
state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX), stateblock);
|
|
|
|
|
}
|
2007-01-06 18:11:21 +01:00
|
|
|
|
} else {
|
|
|
|
|
/* We compile the shader here because we need the vertex declaration
|
|
|
|
|
* in order to determine if we need to do any swizzling for D3DCOLOR
|
|
|
|
|
* registers. If the shader is already compiled this call will do nothing. */
|
|
|
|
|
IWineD3DVertexShader_CompileShader(stateblock->vertexShader);
|
2007-01-06 18:17:27 +01:00
|
|
|
|
}
|
2007-01-06 18:14:12 +01:00
|
|
|
|
|
2007-01-06 18:21:35 +01:00
|
|
|
|
if(useVertexShaderFunction || device->last_was_vshader) {
|
2007-01-06 18:17:27 +01:00
|
|
|
|
BOOL usePixelShaderFunction = device->ps_selected_mode != SHADER_NONE &&
|
2007-01-06 18:21:35 +01:00
|
|
|
|
stateblock->pixelShader &&
|
|
|
|
|
((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function;
|
2007-01-06 18:17:27 +01:00
|
|
|
|
|
2007-01-06 18:21:35 +01:00
|
|
|
|
/* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
|
|
|
|
|
* application
|
|
|
|
|
*/
|
|
|
|
|
if(!isStateDirty(device, STATE_PIXELSHADER)) {
|
|
|
|
|
device->shader_backend->shader_select((IWineD3DDevice *) device, usePixelShaderFunction, useVertexShaderFunction);
|
2007-01-06 18:14:12 +01:00
|
|
|
|
|
2007-01-06 18:21:35 +01:00
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_VERTEXSHADERCONSTANT) && (useVertexShaderFunction || usePixelShaderFunction)) {
|
|
|
|
|
shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock);
|
|
|
|
|
}
|
2007-01-06 18:14:12 +01:00
|
|
|
|
}
|
2007-01-06 18:21:35 +01:00
|
|
|
|
device->last_was_vshader = useVertexShaderFunction;
|
2007-01-06 18:11:21 +01:00
|
|
|
|
}
|
2007-01-02 22:50:38 +01:00
|
|
|
|
|
2007-01-02 22:47:10 +01:00
|
|
|
|
if(updateFog) {
|
2007-01-06 18:11:21 +01:00
|
|
|
|
state_fog(STATE_RENDER(WINED3DRS_FOGENABLE), stateblock);
|
2007-01-02 22:47:10 +01:00
|
|
|
|
}
|
2007-01-02 00:35:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
2007-01-04 00:05:05 +01:00
|
|
|
|
static void viewport(DWORD state, IWineD3DStateBlockImpl *stateblock) {
|
|
|
|
|
glDepthRange(stateblock->viewport.MinZ, stateblock->viewport.MaxZ);
|
|
|
|
|
checkGLcall("glDepthRange");
|
|
|
|
|
/* Note: GL requires lower left, DirectX supplies upper left */
|
|
|
|
|
/* TODO: replace usage of renderTarget with context management */
|
|
|
|
|
glViewport(stateblock->viewport.X,
|
|
|
|
|
(((IWineD3DSurfaceImpl *)stateblock->wineD3DDevice->render_targets[0])->currentDesc.Height - (stateblock->viewport.Y + stateblock->viewport.Height)),
|
|
|
|
|
stateblock->viewport.Width, stateblock->viewport.Height);
|
|
|
|
|
|
|
|
|
|
checkGLcall("glViewport");
|
|
|
|
|
|
|
|
|
|
stateblock->wineD3DDevice->posFixup[2] = 0.9 / stateblock->viewport.Width;
|
|
|
|
|
stateblock->wineD3DDevice->posFixup[3] = -0.9 / stateblock->viewport.Height;
|
|
|
|
|
if(!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(D3DTS_PROJECTION))) {
|
|
|
|
|
transform_projection(STATE_TRANSFORM(D3DTS_PROJECTION), stateblock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-05 23:36:10 +01:00
|
|
|
|
const struct StateEntry StateTable[] =
|
|
|
|
|
{
|
|
|
|
|
/* State name representative, apply function */
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 0, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 1, WINED3DRS_TEXTUREHANDLE */ 0 /* Handled in ddraw */, state_undefined },
|
2006-12-10 23:21:03 +01:00
|
|
|
|
{ /* 2, WINED3DRS_ANTIALIAS */ STATE_RENDER(WINED3DRS_ANTIALIAS), state_antialias },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 3, WINED3DRS_TEXTUREADDRESS */ 0 /* Handled in ddraw */, state_undefined },
|
2006-12-10 23:20:56 +01:00
|
|
|
|
{ /* 4, WINED3DRS_TEXTUREPERSPECTIVE */ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_perspective },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /* 5, WINED3DRS_WRAPU */ STATE_RENDER(WINED3DRS_WRAPU), state_wrapu },
|
|
|
|
|
{ /* 6, WINED3DRS_WRAPV */ STATE_RENDER(WINED3DRS_WRAPV), state_wrapv },
|
2006-12-08 01:40:51 +01:00
|
|
|
|
{ /* 7, WINED3DRS_ZENABLE */ STATE_RENDER(WINED3DRS_ZENABLE), state_zenable },
|
2006-12-05 23:45:35 +01:00
|
|
|
|
{ /* 8, WINED3DRS_FILLMODE */ STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode },
|
2006-12-08 01:42:16 +01:00
|
|
|
|
{ /* 9, WINED3DRS_SHADEMODE */ STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode },
|
2006-12-10 23:20:01 +01:00
|
|
|
|
{ /* 10, WINED3DRS_LINEPATTERN */ STATE_RENDER(WINED3DRS_LINEPATTERN), state_linepattern },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /* 11, WINED3DRS_MONOENABLE */ STATE_RENDER(WINED3DRS_MONOENABLE), state_monoenable },
|
|
|
|
|
{ /* 12, WINED3DRS_ROP2 */ STATE_RENDER(WINED3DRS_ROP2), state_rop2 },
|
|
|
|
|
{ /* 13, WINED3DRS_PLANEMASK */ STATE_RENDER(WINED3DRS_PLANEMASK), state_planemask },
|
2006-12-08 01:43:25 +01:00
|
|
|
|
{ /* 14, WINED3DRS_ZWRITEENABLE */ STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable },
|
2006-12-08 20:21:32 +01:00
|
|
|
|
{ /* 15, WINED3DRS_ALPHATESTENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
|
2006-12-10 23:20:29 +01:00
|
|
|
|
{ /* 16, WINED3DRS_LASTPIXEL */ STATE_RENDER(WINED3DRS_LASTPIXEL), state_lastpixel },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 17, WINED3DRS_TEXTUREMAG */ 0 /* Handled in ddraw */, state_undefined },
|
|
|
|
|
{ /* 18, WINED3DRS_TEXTUREMIN */ 0 /* Handled in ddraw */, state_undefined },
|
2006-12-08 01:51:11 +01:00
|
|
|
|
{ /* 19, WINED3DRS_SRCBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
|
|
|
|
|
{ /* 20, WINED3DRS_DESTBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 21, WINED3DRS_TEXTUREMAPBLEND */ 0 /* Handled in ddraw */, state_undefined },
|
2006-12-08 01:41:43 +01:00
|
|
|
|
{ /* 22, WINED3DRS_CULLMODE */ STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode },
|
2006-12-08 01:44:55 +01:00
|
|
|
|
{ /* 23, WINED3DRS_ZFUNC */ STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc },
|
2006-12-08 20:21:32 +01:00
|
|
|
|
{ /* 24, WINED3DRS_ALPHAREF */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
|
|
|
|
|
{ /* 25, WINED3DRS_ALPHAFUNC */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
|
2006-12-08 01:42:43 +01:00
|
|
|
|
{ /* 26, WINED3DRS_DITHERENABLE */ STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable },
|
2006-12-08 01:51:11 +01:00
|
|
|
|
{ /* 27, WINED3DRS_ALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
|
2006-12-08 18:42:43 +01:00
|
|
|
|
{ /* 28, WINED3DRS_FOGENABLE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
|
2006-12-08 18:38:30 +01:00
|
|
|
|
{ /* 29, WINED3DRS_SPECULARENABLE */ STATE_RENDER(WINED3DRS_SPECULARENABLE), state_specularenable},
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 30, WINED3DRS_ZVISIBLE */ 0 /* Not supported according to the msdn */, state_nogl },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /* 31, WINED3DRS_SUBPIXEL */ STATE_RENDER(WINED3DRS_SUBPIXEL), state_subpixel },
|
|
|
|
|
{ /* 32, WINED3DRS_SUBPIXELX */ STATE_RENDER(WINED3DRS_SUBPIXELX), state_subpixelx },
|
2006-12-10 23:20:59 +01:00
|
|
|
|
{ /* 33, WINED3DRS_STIPPLEDALPHA */ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_stippledalpha },
|
2006-12-08 18:52:30 +01:00
|
|
|
|
{ /* 34, WINED3DRS_FOGCOLOR */ STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor },
|
2006-12-08 18:42:43 +01:00
|
|
|
|
{ /* 35, WINED3DRS_FOGTABLEMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
|
|
|
|
|
{ /* 36, WINED3DRS_FOGSTART */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
|
|
|
|
|
{ /* 37, WINED3DRS_FOGEND */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
|
2006-12-10 16:34:45 +01:00
|
|
|
|
{ /* 38, WINED3DRS_FOGDENSITY */ STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /* 39, WINED3DRS_STIPPLEENABLE */ STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_stippleenable },
|
2006-12-08 01:51:11 +01:00
|
|
|
|
{ /* 40, WINED3DRS_EDGEANTIALIAS */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
|
2006-12-08 20:21:32 +01:00
|
|
|
|
{ /* 41, WINED3DRS_COLORKEYENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 42, undefined */ 0, state_undefined },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /* 43, WINED3DRS_BORDERCOLOR */ STATE_RENDER(WINED3DRS_BORDERCOLOR), state_bordercolor },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 44, WINED3DRS_TEXTUREADDRESSU */ 0, /* Handled in ddraw */ state_undefined },
|
|
|
|
|
{ /* 45, WINED3DRS_TEXTUREADDRESSV */ 0, /* Handled in ddraw */ state_undefined },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /* 46, WINED3DRS_MIPMAPLODBIAS */ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_mipmaplodbias },
|
2006-12-10 23:19:57 +01:00
|
|
|
|
{ /* 47, WINED3DRS_ZBIAS */ STATE_RENDER(WINED3DRS_ZBIAS), state_zbias },
|
2006-12-08 20:03:27 +01:00
|
|
|
|
{ /* 48, WINED3DRS_RANGEFOGENABLE */ 0, state_nogl },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /* 49, WINED3DRS_ANISOTROPY */ STATE_RENDER(WINED3DRS_ANISOTROPY), state_anisotropy },
|
|
|
|
|
{ /* 50, WINED3DRS_FLUSHBATCH */ STATE_RENDER(WINED3DRS_FLUSHBATCH), state_flushbatch },
|
|
|
|
|
{ /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT */ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi },
|
2006-12-08 18:39:45 +01:00
|
|
|
|
{ /* 52, WINED3DRS_STENCILENABLE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /* 53, WINED3DRS_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /* 54, WINED3DRS_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /* 55, WINED3DRS_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /* 56, WINED3DRS_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /* 57, WINED3DRS_STENCILREF */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /* 58, WINED3DRS_STENCILMASK */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
2006-12-08 18:41:05 +01:00
|
|
|
|
{ /* 59, WINED3DRS_STENCILWRITEMASK */ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite },
|
2006-12-08 18:37:17 +01:00
|
|
|
|
{ /* 60, WINED3DRS_TEXTUREFACTOR */ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 61, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 62, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 63, Undefined */ 0, state_undefined },
|
2006-12-17 17:21:30 +01:00
|
|
|
|
{ /* 64, WINED3DRS_STIPPLEPATTERN00 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 65, WINED3DRS_STIPPLEPATTERN01 */ 0 /* Obsolete, should he handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 66, WINED3DRS_STIPPLEPATTERN02 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 67, WINED3DRS_STIPPLEPATTERN03 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 68, WINED3DRS_STIPPLEPATTERN04 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 69, WINED3DRS_STIPPLEPATTERN05 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 70, WINED3DRS_STIPPLEPATTERN06 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 71, WINED3DRS_STIPPLEPATTERN07 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 72, WINED3DRS_STIPPLEPATTERN08 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 73, WINED3DRS_STIPPLEPATTERN09 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 74, WINED3DRS_STIPPLEPATTERN10 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 75, WINED3DRS_STIPPLEPATTERN11 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 76, WINED3DRS_STIPPLEPATTERN12 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 77, WINED3DRS_STIPPLEPATTERN13 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 78, WINED3DRS_STIPPLEPATTERN14 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 79, WINED3DRS_STIPPLEPATTERN15 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 80, WINED3DRS_STIPPLEPATTERN16 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 81, WINED3DRS_STIPPLEPATTERN17 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 82, WINED3DRS_STIPPLEPATTERN18 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 83, WINED3DRS_STIPPLEPATTERN19 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 84, WINED3DRS_STIPPLEPATTERN20 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 85, WINED3DRS_STIPPLEPATTERN21 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 86, WINED3DRS_STIPPLEPATTERN22 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 87, WINED3DRS_STIPPLEPATTERN23 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 88, WINED3DRS_STIPPLEPATTERN24 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 89, WINED3DRS_STIPPLEPATTERN25 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 90, WINED3DRS_STIPPLEPATTERN26 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 91, WINED3DRS_STIPPLEPATTERN27 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 92, WINED3DRS_STIPPLEPATTERN28 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 93, WINED3DRS_STIPPLEPATTERN29 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 94, WINED3DRS_STIPPLEPATTERN30 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
|
|
|
|
{ /* 95, WINED3DRS_STIPPLEPATTERN31 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /* 96, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 97, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 98, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 99, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*100, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*101, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*102, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*103, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*104, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*105, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*106, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*107, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*108, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*109, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*110, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*111, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*112, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*113, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*114, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*115, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*116, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*117, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*118, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*119, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*120, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*121, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*122, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*123, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*124, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*125, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*126, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*127, Undefined */ 0, state_undefined },
|
|
|
|
|
/* Big hole ends */
|
2006-12-10 23:20:45 +01:00
|
|
|
|
{ /*128, WINED3DRS_WRAP0 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*129, WINED3DRS_WRAP1 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*130, WINED3DRS_WRAP2 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*131, WINED3DRS_WRAP3 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*132, WINED3DRS_WRAP4 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*133, WINED3DRS_WRAP5 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*134, WINED3DRS_WRAP6 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*135, WINED3DRS_WRAP7 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
2006-12-08 18:01:23 +01:00
|
|
|
|
{ /*136, WINED3DRS_CLIPPING */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
|
2007-01-02 22:49:17 +01:00
|
|
|
|
{ /*137, WINED3DRS_LIGHTING */ STATE_RENDER(WINED3DRS_LIGHTING), state_lighting },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /*138, WINED3DRS_EXTENTS */ STATE_RENDER(WINED3DRS_EXTENTS), state_extents },
|
2006-12-08 01:45:26 +01:00
|
|
|
|
{ /*139, WINED3DRS_AMBIENT */ STATE_RENDER(WINED3DRS_AMBIENT), state_ambient },
|
2006-12-08 18:42:43 +01:00
|
|
|
|
{ /*140, WINED3DRS_FOGVERTEXMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
|
2006-12-10 22:44:18 +01:00
|
|
|
|
{ /*141, WINED3DRS_COLORVERTEX */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
|
2006-12-10 23:20:26 +01:00
|
|
|
|
{ /*142, WINED3DRS_LOCALVIEWER */ STATE_RENDER(WINED3DRS_LOCALVIEWER), state_localviewer },
|
2006-12-10 23:20:05 +01:00
|
|
|
|
{ /*143, WINED3DRS_NORMALIZENORMALS */ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_normalize },
|
2006-12-15 20:02:13 +01:00
|
|
|
|
{ /*144, WINED3DRS_COLORKEYBLENDENABLE */ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_ckeyblend },
|
2006-12-10 22:44:18 +01:00
|
|
|
|
{ /*145, WINED3DRS_DIFFUSEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
|
|
|
|
|
{ /*146, WINED3DRS_SPECULARMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
|
|
|
|
|
{ /*147, WINED3DRS_AMBIENTMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
|
|
|
|
|
{ /*148, WINED3DRS_EMISSIVEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /*149, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*150, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*151, WINED3DRS_VERTEXBLEND */ 0, state_nogl },
|
2006-12-08 18:01:23 +01:00
|
|
|
|
{ /*152, WINED3DRS_CLIPPLANEENABLE */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING */ 0, state_nogl },
|
2006-12-10 23:20:09 +01:00
|
|
|
|
{ /*154, WINED3DRS_POINTSIZE */ STATE_RENDER(WINED3DRS_POINTSIZE), state_psize },
|
2006-12-10 23:20:12 +01:00
|
|
|
|
{ /*155, WINED3DRS_POINTSIZE_MIN */ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin },
|
2006-12-10 23:20:36 +01:00
|
|
|
|
{ /*156, WINED3DRS_POINTSPRITEENABLE */ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite },
|
2006-12-10 23:20:19 +01:00
|
|
|
|
{ /*157, WINED3DRS_POINTSCALEENABLE */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
|
|
|
|
|
{ /*158, WINED3DRS_POINTSCALE_A */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
|
|
|
|
|
{ /*159, WINED3DRS_POINTSCALE_B */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
|
|
|
|
|
{ /*160, WINED3DRS_POINTSCALE_C */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
|
2006-12-10 23:20:40 +01:00
|
|
|
|
{ /*161, WINED3DRS_MULTISAMPLEANTIALIAS */ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_multisampleaa },
|
2006-12-10 23:21:07 +01:00
|
|
|
|
{ /*162, WINED3DRS_MULTISAMPLEMASK */ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_multisampmask },
|
2006-12-15 20:03:17 +01:00
|
|
|
|
{ /*163, WINED3DRS_PATCHEDGESTYLE */ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_patchedgestyle},
|
2006-12-10 23:21:14 +01:00
|
|
|
|
{ /*164, WINED3DRS_PATCHSEGMENTS */ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_patchsegments },
|
2006-12-10 23:21:17 +01:00
|
|
|
|
{ /*165, WINED3DRS_DEBUGMONITORTOKEN */ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), state_nogl },
|
2006-12-10 23:20:15 +01:00
|
|
|
|
{ /*166, WINED3DRS_POINTSIZE_MAX */ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), state_psizemax },
|
2006-12-08 19:53:41 +01:00
|
|
|
|
{ /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE */ 0, state_nogl },
|
2006-12-10 23:20:22 +01:00
|
|
|
|
{ /*168, WINED3DRS_COLORWRITEENABLE */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /*169, Undefined */ 0, state_undefined },
|
|
|
|
|
{ /*170, WINED3DRS_TWEENFACTOR */ 0, state_nogl },
|
2006-12-08 20:21:43 +01:00
|
|
|
|
{ /*171, WINED3DRS_BLENDOP */ STATE_RENDER(WINED3DRS_BLENDOP), state_blendop },
|
2006-12-10 23:21:21 +01:00
|
|
|
|
{ /*172, WINED3DRS_POSITIONDEGREE */ STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_positiondegree},
|
2006-12-10 23:21:25 +01:00
|
|
|
|
{ /*173, WINED3DRS_NORMALDEGREE */ STATE_RENDER(WINED3DRS_NORMALDEGREE), state_normaldegree },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
/*172, WINED3DRS_POSITIONORDER */ /* Value assigned to 2 state names */
|
|
|
|
|
/*173, WINED3DRS_NORMALORDER */ /* Value assigned to 2 state names */
|
2006-12-10 23:20:48 +01:00
|
|
|
|
{ /*174, WINED3DRS_SCISSORTESTENABLE */ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_scissor },
|
2006-12-10 23:20:52 +01:00
|
|
|
|
{ /*175, WINED3DRS_SLOPESCALEDEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias },
|
2006-12-08 01:51:11 +01:00
|
|
|
|
{ /*176, WINED3DRS_ANTIALIASEDLINEENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /*177, undefined */ 0, state_undefined },
|
2006-12-10 23:21:27 +01:00
|
|
|
|
{ /*178, WINED3DRS_MINTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
|
|
|
|
|
{ /*179, WINED3DRS_MAXTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
|
|
|
|
|
{ /*180, WINED3DRS_ADAPTIVETESS_X */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
|
|
|
|
|
{ /*181, WINED3DRS_ADAPTIVETESS_Y */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
|
|
|
|
|
{ /*182, WINED3DRS_ADAPTIVETESS_Z */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
|
|
|
|
|
{ /*183, WINED3DRS_ADAPTIVETESS_W */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
|
|
|
|
|
{ /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
|
2006-12-08 18:39:45 +01:00
|
|
|
|
{ /*185, WINED3DRS_TWOSIDEDSTENCILMODE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /*186, WINED3DRS_CCW_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /*187, WINED3DRS_CCW_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /*188, WINED3DRS_CCW_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
|
|
|
|
{ /*189, WINED3DRS_CCW_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
|
2006-12-10 23:20:22 +01:00
|
|
|
|
{ /*190, WINED3DRS_COLORWRITEENABLE1 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
|
|
|
|
|
{ /*191, WINED3DRS_COLORWRITEENABLE2 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
|
|
|
|
|
{ /*192, WINED3DRS_COLORWRITEENABLE3 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
|
2006-12-25 18:46:59 +01:00
|
|
|
|
{ /*193, WINED3DRS_BLENDFACTOR */ STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor },
|
2006-12-10 23:13:38 +01:00
|
|
|
|
{ /*194, WINED3DRS_SRGBWRITEENABLE */ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), state_srgbwrite },
|
2006-12-10 23:20:52 +01:00
|
|
|
|
{ /*195, WINED3DRS_DEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias },
|
2006-12-06 13:22:12 +01:00
|
|
|
|
{ /*196, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*197, undefined */ 0, state_undefined },
|
2006-12-10 23:20:45 +01:00
|
|
|
|
{ /*198, WINED3DRS_WRAP8 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*199, WINED3DRS_WRAP9 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*200, WINED3DRS_WRAP10 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*201, WINED3DRS_WRAP11 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*202, WINED3DRS_WRAP12 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*203, WINED3DRS_WRAP13 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*204, WINED3DRS_WRAP14 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
|
|
|
|
{ /*205, WINED3DRS_WRAP15 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
|
2006-12-10 23:14:36 +01:00
|
|
|
|
{ /*206, WINED3DRS_SEPARATEALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
|
|
|
|
|
{ /*207, WINED3DRS_SRCBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
|
|
|
|
|
{ /*208, WINED3DRS_DESTBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
|
|
|
|
|
{ /*209, WINED3DRS_BLENDOPALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
/* Texture stage states */
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*0, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*0, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*0, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*0, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*0, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*0, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*0, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*0, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*0, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*0, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*0, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*0, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*0, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*0, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE0), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*0, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*0, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*0, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*0, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*0, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*0, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*0, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*1, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*1, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*1, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*1, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*1, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*1, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*1, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*1, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*1, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*1, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*1, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*1, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*1, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*1, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE1), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*1, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*1, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*1, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*1, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*1, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*1, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*1, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*2, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*2, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*2, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*2, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*2, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*2, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*2, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*2, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*2, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*2, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*2, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*2, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*2, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*2, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE2), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*2, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*2, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*2, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*2, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*2, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*2, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*2, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*3, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*3, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*3, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*3, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*3, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*3, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*3, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*3, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*3, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*3, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*3, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*3, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*3, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*3, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE3), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*3, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*3, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*3, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*3, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*3, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*3, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*3, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*4, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*4, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*4, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*4, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*4, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*4, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*4, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), state_undefined },
|
|
|
|
|
{ /*4, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), state_undefined },
|
|
|
|
|
{ /*4, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), state_undefined },
|
|
|
|
|
{ /*4, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), state_undefined },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*4, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*4, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*4, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*4, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE4), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*4, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*4, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*4, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*4, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*4, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*4, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*4, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*5, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*5, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*5, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*5, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*5, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*5, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*5, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*5, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*5, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*5, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*5, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*5, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*5, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*5, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE5), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*5, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*5, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*5, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*5, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*5, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*5, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*5, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*6, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*6, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*6, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*6, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*6, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*6, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*6, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*6, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*6, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*6, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*6, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*6, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*6, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*6, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE6), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*6, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*6, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*6, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*6, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*6, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*6, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*6, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*7, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*7, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*7, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*7, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*7, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
|
|
|
|
|
{ /*7, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*7, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*7, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*7, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
|
|
|
|
{ /*7, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:04:16 +01:00
|
|
|
|
{ /*7, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*7, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:05:08 +01:00
|
|
|
|
{ /*7, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
|
2006-12-19 23:34:17 +01:00
|
|
|
|
{ /*7, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE7), transform_texture },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*7, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:00:58 +01:00
|
|
|
|
{ /*7, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
|
2006-12-19 23:03:37 +01:00
|
|
|
|
{ /*7, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
|
2006-12-19 23:11:21 +01:00
|
|
|
|
{ /*7, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), tex_resultarg },
|
2006-12-19 22:43:49 +01:00
|
|
|
|
{ /*7, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
|
|
|
|
{ /*7, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
|
2006-12-19 23:11:28 +01:00
|
|
|
|
{ /*7, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
|
2006-12-19 23:14:07 +01:00
|
|
|
|
/* Sampler states */
|
2006-12-19 23:26:39 +01:00
|
|
|
|
{ /* 0, Sampler 0 */ STATE_SAMPLER(0), sampler },
|
|
|
|
|
{ /* 1, Sampler 1 */ STATE_SAMPLER(1), sampler },
|
|
|
|
|
{ /* 2, Sampler 2 */ STATE_SAMPLER(2), sampler },
|
|
|
|
|
{ /* 3, Sampler 3 */ STATE_SAMPLER(3), sampler },
|
|
|
|
|
{ /* 4, Sampler 3 */ STATE_SAMPLER(4), sampler },
|
|
|
|
|
{ /* 5, Sampler 5 */ STATE_SAMPLER(5), sampler },
|
|
|
|
|
{ /* 6, Sampler 6 */ STATE_SAMPLER(6), sampler },
|
|
|
|
|
{ /* 7, Sampler 7 */ STATE_SAMPLER(7), sampler },
|
|
|
|
|
{ /* 8, Sampler 8 */ STATE_SAMPLER(8), sampler },
|
|
|
|
|
{ /* 9, Sampler 9 */ STATE_SAMPLER(9), sampler },
|
|
|
|
|
{ /*10, Sampler 10 */ STATE_SAMPLER(10), sampler },
|
|
|
|
|
{ /*11, Sampler 11 */ STATE_SAMPLER(11), sampler },
|
|
|
|
|
{ /*12, Sampler 12 */ STATE_SAMPLER(12), sampler },
|
|
|
|
|
{ /*13, Sampler 13 */ STATE_SAMPLER(13), sampler },
|
|
|
|
|
{ /*14, Sampler 14 */ STATE_SAMPLER(14), sampler },
|
|
|
|
|
{ /*15, Sampler 15 */ STATE_SAMPLER(15), sampler },
|
2006-12-19 23:22:19 +01:00
|
|
|
|
/* Pixel shader */
|
|
|
|
|
{ /* , Pixel Shader */ STATE_PIXELSHADER, pixelshader },
|
2006-12-28 18:57:16 +01:00
|
|
|
|
/* Transform states follow */
|
|
|
|
|
{ /* 1, undefined */ 0, state_undefined },
|
2007-01-02 00:48:58 +01:00
|
|
|
|
{ /* 2, WINED3DTS_VIEW */ STATE_TRANSFORM(WINED3DTS_VIEW), transform_view },
|
2007-01-02 22:50:38 +01:00
|
|
|
|
{ /* 3, WINED3DTS_PROJECTION */ STATE_TRANSFORM(WINED3DTS_PROJECTION), transform_projection},
|
2006-12-28 18:57:16 +01:00
|
|
|
|
{ /* 4, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 5, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 6, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 7, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 8, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 9, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 10, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 11, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 12, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 13, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 14, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 15, undefined */ 0, state_undefined },
|
2007-01-01 23:53:59 +01:00
|
|
|
|
{ /* 16, WINED3DTS_TEXTURE0 */ STATE_TRANSFORM(WINED3DTS_TEXTURE0), transform_texture },
|
|
|
|
|
{ /* 17, WINED3DTS_TEXTURE1 */ STATE_TRANSFORM(WINED3DTS_TEXTURE1), transform_texture },
|
|
|
|
|
{ /* 18, WINED3DTS_TEXTURE2 */ STATE_TRANSFORM(WINED3DTS_TEXTURE2), transform_texture },
|
|
|
|
|
{ /* 19, WINED3DTS_TEXTURE3 */ STATE_TRANSFORM(WINED3DTS_TEXTURE3), transform_texture },
|
|
|
|
|
{ /* 20, WINED3DTS_TEXTURE4 */ STATE_TRANSFORM(WINED3DTS_TEXTURE4), transform_texture },
|
|
|
|
|
{ /* 21, WINED3DTS_TEXTURE5 */ STATE_TRANSFORM(WINED3DTS_TEXTURE5), transform_texture },
|
|
|
|
|
{ /* 22, WINED3DTS_TEXTURE6 */ STATE_TRANSFORM(WINED3DTS_TEXTURE6), transform_texture },
|
|
|
|
|
{ /* 23, WINED3DTS_TEXTURE7 */ STATE_TRANSFORM(WINED3DTS_TEXTURE7), transform_texture },
|
2006-12-28 18:57:16 +01:00
|
|
|
|
/* A huge gap between TEXTURE7 and WORLDMATRIX(0) :-( But entries are needed to catch then if a broken app sets them */
|
|
|
|
|
{ /* 24, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 25, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 26, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 27, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 28, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 29, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 30, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 31, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 32, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 33, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 34, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 35, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 36, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 37, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 38, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 39, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 40, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 41, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 42, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 43, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 44, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 45, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 46, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 47, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 48, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 49, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 50, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 51, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 52, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 53, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 54, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 55, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 56, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 57, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 58, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 59, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 60, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 61, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 62, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 63, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 64, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 65, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 66, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 67, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 68, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 69, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 70, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 71, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 72, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 73, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 74, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 75, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 76, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 77, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 78, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 79, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 80, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 81, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 82, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 83, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 84, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 85, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 86, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 87, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 88, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 89, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 90, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 91, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 92, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 93, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 94, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 95, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 96, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 97, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 98, undefined */ 0, state_undefined },
|
|
|
|
|
{ /* 99, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*100, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*101, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*102, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*103, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*104, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*105, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*106, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*107, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*108, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*109, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*110, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*111, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*112, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*113, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*114, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*115, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*116, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*117, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*118, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*119, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*120, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*121, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*122, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*123, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*124, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*125, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*126, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*127, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*128, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*129, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*130, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*131, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*132, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*133, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*134, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*135, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*136, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*137, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*138, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*139, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*140, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*141, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*142, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*143, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*144, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*145, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*146, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*147, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*148, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*149, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*150, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*151, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*152, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*153, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*154, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*155, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*156, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*157, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*158, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*159, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*160, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*161, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*162, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*163, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*164, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*165, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*166, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*167, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*168, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*169, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*170, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*171, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*172, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*173, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*174, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*175, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*176, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*177, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*178, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*179, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*180, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*181, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*182, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*183, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*184, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*185, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*186, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*187, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*188, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*189, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*190, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*191, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*192, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*193, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*194, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*195, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*196, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*197, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*198, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*199, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*200, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*201, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*202, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*203, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*204, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*205, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*206, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*207, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*208, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*209, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*210, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*211, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*212, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*213, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*214, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*215, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*216, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*217, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*218, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*219, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*220, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*221, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*222, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*223, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*224, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*225, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*226, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*227, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*228, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*229, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*230, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*231, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*232, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*233, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*234, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*235, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*236, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*237, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*238, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*239, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*240, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*241, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*242, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*243, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*244, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*245, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*246, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*247, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*248, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*249, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*250, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*251, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*252, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*253, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*254, undefined */ 0, state_undefined },
|
|
|
|
|
{ /*255, undefined */ 0, state_undefined },
|
|
|
|
|
/* End huge gap */
|
2007-01-02 22:47:39 +01:00
|
|
|
|
{ /*256, WINED3DTS_WORLDMATRIX(0) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), transform_world },
|
2007-01-02 00:25:51 +01:00
|
|
|
|
{ /*257, WINED3DTS_WORLDMATRIX(1) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(1)), transform_worldex },
|
|
|
|
|
{ /*258, WINED3DTS_WORLDMATRIX(2) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(2)), transform_worldex },
|
|
|
|
|
{ /*259, WINED3DTS_WORLDMATRIX(3) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(3)), transform_worldex },
|
|
|
|
|
{ /*260, WINED3DTS_WORLDMATRIX(4) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(4)), transform_worldex },
|
|
|
|
|
{ /*261, WINED3DTS_WORLDMATRIX(5) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(5)), transform_worldex },
|
|
|
|
|
{ /*262, WINED3DTS_WORLDMATRIX(6) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(6)), transform_worldex },
|
|
|
|
|
{ /*263, WINED3DTS_WORLDMATRIX(7) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(7)), transform_worldex },
|
|
|
|
|
{ /*264, WINED3DTS_WORLDMATRIX(8) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(8)), transform_worldex },
|
|
|
|
|
{ /*265, WINED3DTS_WORLDMATRIX(9) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(9)), transform_worldex },
|
|
|
|
|
{ /*266, WINED3DTS_WORLDMATRIX(10) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(10)), transform_worldex },
|
|
|
|
|
{ /*267, WINED3DTS_WORLDMATRIX(11) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(11)), transform_worldex },
|
|
|
|
|
{ /*268, WINED3DTS_WORLDMATRIX(12) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(12)), transform_worldex },
|
|
|
|
|
{ /*269, WINED3DTS_WORLDMATRIX(13) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(13)), transform_worldex },
|
|
|
|
|
{ /*270, WINED3DTS_WORLDMATRIX(14) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(14)), transform_worldex },
|
|
|
|
|
{ /*271, WINED3DTS_WORLDMATRIX(15) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(15)), transform_worldex },
|
|
|
|
|
{ /*272, WINED3DTS_WORLDMATRIX(16) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(16)), transform_worldex },
|
|
|
|
|
{ /*273, WINED3DTS_WORLDMATRIX(17) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(17)), transform_worldex },
|
|
|
|
|
{ /*274, WINED3DTS_WORLDMATRIX(18) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(18)), transform_worldex },
|
|
|
|
|
{ /*275, WINED3DTS_WORLDMATRIX(19) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(19)), transform_worldex },
|
|
|
|
|
{ /*276, WINED3DTS_WORLDMATRIX(20) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(20)), transform_worldex },
|
|
|
|
|
{ /*277, WINED3DTS_WORLDMATRIX(21) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(21)), transform_worldex },
|
|
|
|
|
{ /*278, WINED3DTS_WORLDMATRIX(22) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(22)), transform_worldex },
|
|
|
|
|
{ /*279, WINED3DTS_WORLDMATRIX(23) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(23)), transform_worldex },
|
|
|
|
|
{ /*280, WINED3DTS_WORLDMATRIX(24) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(24)), transform_worldex },
|
|
|
|
|
{ /*281, WINED3DTS_WORLDMATRIX(25) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(25)), transform_worldex },
|
|
|
|
|
{ /*282, WINED3DTS_WORLDMATRIX(26) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(26)), transform_worldex },
|
|
|
|
|
{ /*283, WINED3DTS_WORLDMATRIX(27) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(27)), transform_worldex },
|
|
|
|
|
{ /*284, WINED3DTS_WORLDMATRIX(28) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(28)), transform_worldex },
|
|
|
|
|
{ /*285, WINED3DTS_WORLDMATRIX(29) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(29)), transform_worldex },
|
|
|
|
|
{ /*286, WINED3DTS_WORLDMATRIX(30) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(30)), transform_worldex },
|
|
|
|
|
{ /*287, WINED3DTS_WORLDMATRIX(31) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(31)), transform_worldex },
|
|
|
|
|
{ /*288, WINED3DTS_WORLDMATRIX(32) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(32)), transform_worldex },
|
|
|
|
|
{ /*289, WINED3DTS_WORLDMATRIX(33) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(33)), transform_worldex },
|
|
|
|
|
{ /*290, WINED3DTS_WORLDMATRIX(34) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(34)), transform_worldex },
|
|
|
|
|
{ /*291, WINED3DTS_WORLDMATRIX(35) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(35)), transform_worldex },
|
|
|
|
|
{ /*292, WINED3DTS_WORLDMATRIX(36) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(36)), transform_worldex },
|
|
|
|
|
{ /*293, WINED3DTS_WORLDMATRIX(37) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(37)), transform_worldex },
|
|
|
|
|
{ /*294, WINED3DTS_WORLDMATRIX(38) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(38)), transform_worldex },
|
|
|
|
|
{ /*295, WINED3DTS_WORLDMATRIX(39) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(39)), transform_worldex },
|
|
|
|
|
{ /*296, WINED3DTS_WORLDMATRIX(40) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(40)), transform_worldex },
|
|
|
|
|
{ /*297, WINED3DTS_WORLDMATRIX(41) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(41)), transform_worldex },
|
|
|
|
|
{ /*298, WINED3DTS_WORLDMATRIX(42) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(42)), transform_worldex },
|
|
|
|
|
{ /*299, WINED3DTS_WORLDMATRIX(43) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(43)), transform_worldex },
|
|
|
|
|
{ /*300, WINED3DTS_WORLDMATRIX(44) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(44)), transform_worldex },
|
|
|
|
|
{ /*301, WINED3DTS_WORLDMATRIX(45) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(45)), transform_worldex },
|
|
|
|
|
{ /*302, WINED3DTS_WORLDMATRIX(46) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(46)), transform_worldex },
|
|
|
|
|
{ /*303, WINED3DTS_WORLDMATRIX(47) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(47)), transform_worldex },
|
|
|
|
|
{ /*304, WINED3DTS_WORLDMATRIX(48) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(48)), transform_worldex },
|
|
|
|
|
{ /*305, WINED3DTS_WORLDMATRIX(49) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(49)), transform_worldex },
|
|
|
|
|
{ /*306, WINED3DTS_WORLDMATRIX(50) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(50)), transform_worldex },
|
|
|
|
|
{ /*307, WINED3DTS_WORLDMATRIX(51) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(51)), transform_worldex },
|
|
|
|
|
{ /*308, WINED3DTS_WORLDMATRIX(52) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(52)), transform_worldex },
|
|
|
|
|
{ /*309, WINED3DTS_WORLDMATRIX(53) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(53)), transform_worldex },
|
|
|
|
|
{ /*310, WINED3DTS_WORLDMATRIX(54) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(54)), transform_worldex },
|
|
|
|
|
{ /*311, WINED3DTS_WORLDMATRIX(55) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(55)), transform_worldex },
|
|
|
|
|
{ /*312, WINED3DTS_WORLDMATRIX(56) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(56)), transform_worldex },
|
|
|
|
|
{ /*313, WINED3DTS_WORLDMATRIX(57) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(57)), transform_worldex },
|
|
|
|
|
{ /*314, WINED3DTS_WORLDMATRIX(58) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(58)), transform_worldex },
|
|
|
|
|
{ /*315, WINED3DTS_WORLDMATRIX(59) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(59)), transform_worldex },
|
|
|
|
|
{ /*316, WINED3DTS_WORLDMATRIX(60) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(60)), transform_worldex },
|
|
|
|
|
{ /*317, WINED3DTS_WORLDMATRIX(61) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(61)), transform_worldex },
|
|
|
|
|
{ /*318, WINED3DTS_WORLDMATRIX(62) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(62)), transform_worldex },
|
|
|
|
|
{ /*319, WINED3DTS_WORLDMATRIX(63) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(63)), transform_worldex },
|
|
|
|
|
{ /*320, WINED3DTS_WORLDMATRIX(64) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(64)), transform_worldex },
|
|
|
|
|
{ /*321, WINED3DTS_WORLDMATRIX(65) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(65)), transform_worldex },
|
|
|
|
|
{ /*322, WINED3DTS_WORLDMATRIX(66) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(66)), transform_worldex },
|
|
|
|
|
{ /*323, WINED3DTS_WORLDMATRIX(67) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(67)), transform_worldex },
|
|
|
|
|
{ /*324, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(68)), transform_worldex },
|
|
|
|
|
{ /*325, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(69)), transform_worldex },
|
|
|
|
|
{ /*326, WINED3DTS_WORLDMATRIX(70) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(70)), transform_worldex },
|
|
|
|
|
{ /*327, WINED3DTS_WORLDMATRIX(71) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(71)), transform_worldex },
|
|
|
|
|
{ /*328, WINED3DTS_WORLDMATRIX(72) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(72)), transform_worldex },
|
|
|
|
|
{ /*329, WINED3DTS_WORLDMATRIX(73) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(73)), transform_worldex },
|
|
|
|
|
{ /*330, WINED3DTS_WORLDMATRIX(74) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(74)), transform_worldex },
|
|
|
|
|
{ /*331, WINED3DTS_WORLDMATRIX(75) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(75)), transform_worldex },
|
|
|
|
|
{ /*332, WINED3DTS_WORLDMATRIX(76) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(76)), transform_worldex },
|
|
|
|
|
{ /*333, WINED3DTS_WORLDMATRIX(77) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(77)), transform_worldex },
|
|
|
|
|
{ /*334, WINED3DTS_WORLDMATRIX(78) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(78)), transform_worldex },
|
|
|
|
|
{ /*335, WINED3DTS_WORLDMATRIX(79) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(79)), transform_worldex },
|
|
|
|
|
{ /*336, WINED3DTS_WORLDMATRIX(80) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(80)), transform_worldex },
|
|
|
|
|
{ /*337, WINED3DTS_WORLDMATRIX(81) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(81)), transform_worldex },
|
|
|
|
|
{ /*338, WINED3DTS_WORLDMATRIX(82) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(82)), transform_worldex },
|
|
|
|
|
{ /*339, WINED3DTS_WORLDMATRIX(83) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(83)), transform_worldex },
|
|
|
|
|
{ /*340, WINED3DTS_WORLDMATRIX(84) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(84)), transform_worldex },
|
|
|
|
|
{ /*341, WINED3DTS_WORLDMATRIX(85) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(85)), transform_worldex },
|
|
|
|
|
{ /*341, WINED3DTS_WORLDMATRIX(86) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(86)), transform_worldex },
|
|
|
|
|
{ /*343, WINED3DTS_WORLDMATRIX(87) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(87)), transform_worldex },
|
|
|
|
|
{ /*344, WINED3DTS_WORLDMATRIX(88) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(88)), transform_worldex },
|
|
|
|
|
{ /*345, WINED3DTS_WORLDMATRIX(89) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(89)), transform_worldex },
|
|
|
|
|
{ /*346, WINED3DTS_WORLDMATRIX(90) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(90)), transform_worldex },
|
|
|
|
|
{ /*347, WINED3DTS_WORLDMATRIX(91) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(91)), transform_worldex },
|
|
|
|
|
{ /*348, WINED3DTS_WORLDMATRIX(92) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(92)), transform_worldex },
|
|
|
|
|
{ /*349, WINED3DTS_WORLDMATRIX(93) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(93)), transform_worldex },
|
|
|
|
|
{ /*350, WINED3DTS_WORLDMATRIX(94) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(94)), transform_worldex },
|
|
|
|
|
{ /*351, WINED3DTS_WORLDMATRIX(95) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(95)), transform_worldex },
|
|
|
|
|
{ /*352, WINED3DTS_WORLDMATRIX(96) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(96)), transform_worldex },
|
|
|
|
|
{ /*353, WINED3DTS_WORLDMATRIX(97) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(97)), transform_worldex },
|
|
|
|
|
{ /*354, WINED3DTS_WORLDMATRIX(98) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(98)), transform_worldex },
|
|
|
|
|
{ /*355, WINED3DTS_WORLDMATRIX(99) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(99)), transform_worldex },
|
|
|
|
|
{ /*356, WINED3DTS_WORLDMATRIX(100) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex },
|
|
|
|
|
{ /*357, WINED3DTS_WORLDMATRIX(101) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex },
|
|
|
|
|
{ /*358, WINED3DTS_WORLDMATRIX(102) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex },
|
|
|
|
|
{ /*359, WINED3DTS_WORLDMATRIX(103) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex },
|
|
|
|
|
{ /*360, WINED3DTS_WORLDMATRIX(104) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex },
|
|
|
|
|
{ /*361, WINED3DTS_WORLDMATRIX(105) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex },
|
|
|
|
|
{ /*362, WINED3DTS_WORLDMATRIX(106) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex },
|
|
|
|
|
{ /*363, WINED3DTS_WORLDMATRIX(107) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex },
|
|
|
|
|
{ /*364, WINED3DTS_WORLDMATRIX(108) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex },
|
|
|
|
|
{ /*365, WINED3DTS_WORLDMATRIX(109) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex },
|
|
|
|
|
{ /*366, WINED3DTS_WORLDMATRIX(110) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex },
|
|
|
|
|
{ /*367, WINED3DTS_WORLDMATRIX(111) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex },
|
|
|
|
|
{ /*368, WINED3DTS_WORLDMATRIX(112) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex },
|
|
|
|
|
{ /*369, WINED3DTS_WORLDMATRIX(113) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex },
|
|
|
|
|
{ /*370, WINED3DTS_WORLDMATRIX(114) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex },
|
|
|
|
|
{ /*371, WINED3DTS_WORLDMATRIX(115) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex },
|
|
|
|
|
{ /*372, WINED3DTS_WORLDMATRIX(116) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex },
|
|
|
|
|
{ /*373, WINED3DTS_WORLDMATRIX(117) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex },
|
|
|
|
|
{ /*374, WINED3DTS_WORLDMATRIX(118) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex },
|
|
|
|
|
{ /*375, WINED3DTS_WORLDMATRIX(119) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex },
|
|
|
|
|
{ /*376, WINED3DTS_WORLDMATRIX(120) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex },
|
|
|
|
|
{ /*377, WINED3DTS_WORLDMATRIX(121) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex },
|
|
|
|
|
{ /*378, WINED3DTS_WORLDMATRIX(122) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex },
|
|
|
|
|
{ /*379, WINED3DTS_WORLDMATRIX(123) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex },
|
|
|
|
|
{ /*380, WINED3DTS_WORLDMATRIX(124) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex },
|
|
|
|
|
{ /*381, WINED3DTS_WORLDMATRIX(125) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex },
|
|
|
|
|
{ /*382, WINED3DTS_WORLDMATRIX(126) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex },
|
|
|
|
|
{ /*383, WINED3DTS_WORLDMATRIX(127) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex },
|
|
|
|
|
{ /*384, WINED3DTS_WORLDMATRIX(128) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex },
|
|
|
|
|
{ /*385, WINED3DTS_WORLDMATRIX(129) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex },
|
|
|
|
|
{ /*386, WINED3DTS_WORLDMATRIX(130) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex },
|
|
|
|
|
{ /*387, WINED3DTS_WORLDMATRIX(131) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex },
|
|
|
|
|
{ /*388, WINED3DTS_WORLDMATRIX(132) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex },
|
|
|
|
|
{ /*389, WINED3DTS_WORLDMATRIX(133) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex },
|
|
|
|
|
{ /*390, WINED3DTS_WORLDMATRIX(134) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex },
|
|
|
|
|
{ /*391, WINED3DTS_WORLDMATRIX(135) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex },
|
|
|
|
|
{ /*392, WINED3DTS_WORLDMATRIX(136) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex },
|
|
|
|
|
{ /*393, WINED3DTS_WORLDMATRIX(137) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex },
|
|
|
|
|
{ /*394, WINED3DTS_WORLDMATRIX(138) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex },
|
|
|
|
|
{ /*395, WINED3DTS_WORLDMATRIX(139) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex },
|
|
|
|
|
{ /*396, WINED3DTS_WORLDMATRIX(140) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex },
|
|
|
|
|
{ /*397, WINED3DTS_WORLDMATRIX(141) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex },
|
|
|
|
|
{ /*398, WINED3DTS_WORLDMATRIX(142) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex },
|
|
|
|
|
{ /*399, WINED3DTS_WORLDMATRIX(143) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex },
|
|
|
|
|
{ /*400, WINED3DTS_WORLDMATRIX(144) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex },
|
|
|
|
|
{ /*401, WINED3DTS_WORLDMATRIX(145) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex },
|
|
|
|
|
{ /*402, WINED3DTS_WORLDMATRIX(146) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex },
|
|
|
|
|
{ /*403, WINED3DTS_WORLDMATRIX(147) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex },
|
|
|
|
|
{ /*404, WINED3DTS_WORLDMATRIX(148) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex },
|
|
|
|
|
{ /*405, WINED3DTS_WORLDMATRIX(149) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex },
|
|
|
|
|
{ /*406, WINED3DTS_WORLDMATRIX(150) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex },
|
|
|
|
|
{ /*407, WINED3DTS_WORLDMATRIX(151) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex },
|
|
|
|
|
{ /*408, WINED3DTS_WORLDMATRIX(152) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex },
|
|
|
|
|
{ /*409, WINED3DTS_WORLDMATRIX(153) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex },
|
|
|
|
|
{ /*410, WINED3DTS_WORLDMATRIX(154) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex },
|
|
|
|
|
{ /*411, WINED3DTS_WORLDMATRIX(155) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex },
|
|
|
|
|
{ /*412, WINED3DTS_WORLDMATRIX(156) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex },
|
|
|
|
|
{ /*413, WINED3DTS_WORLDMATRIX(157) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex },
|
|
|
|
|
{ /*414, WINED3DTS_WORLDMATRIX(158) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex },
|
|
|
|
|
{ /*415, WINED3DTS_WORLDMATRIX(159) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex },
|
|
|
|
|
{ /*416, WINED3DTS_WORLDMATRIX(160) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex },
|
|
|
|
|
{ /*417, WINED3DTS_WORLDMATRIX(161) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex },
|
|
|
|
|
{ /*418, WINED3DTS_WORLDMATRIX(162) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex },
|
|
|
|
|
{ /*419, WINED3DTS_WORLDMATRIX(163) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex },
|
|
|
|
|
{ /*420, WINED3DTS_WORLDMATRIX(164) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex },
|
|
|
|
|
{ /*421, WINED3DTS_WORLDMATRIX(165) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex },
|
|
|
|
|
{ /*422, WINED3DTS_WORLDMATRIX(166) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex },
|
|
|
|
|
{ /*423, WINED3DTS_WORLDMATRIX(167) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex },
|
|
|
|
|
{ /*424, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex },
|
|
|
|
|
{ /*425, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex },
|
|
|
|
|
{ /*426, WINED3DTS_WORLDMATRIX(170) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex },
|
|
|
|
|
{ /*427, WINED3DTS_WORLDMATRIX(171) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex },
|
|
|
|
|
{ /*428, WINED3DTS_WORLDMATRIX(172) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex },
|
|
|
|
|
{ /*429, WINED3DTS_WORLDMATRIX(173) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex },
|
|
|
|
|
{ /*430, WINED3DTS_WORLDMATRIX(174) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex },
|
|
|
|
|
{ /*431, WINED3DTS_WORLDMATRIX(175) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex },
|
|
|
|
|
{ /*432, WINED3DTS_WORLDMATRIX(176) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex },
|
|
|
|
|
{ /*433, WINED3DTS_WORLDMATRIX(177) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex },
|
|
|
|
|
{ /*434, WINED3DTS_WORLDMATRIX(178) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex },
|
|
|
|
|
{ /*435, WINED3DTS_WORLDMATRIX(179) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex },
|
|
|
|
|
{ /*436, WINED3DTS_WORLDMATRIX(180) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex },
|
|
|
|
|
{ /*437, WINED3DTS_WORLDMATRIX(181) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex },
|
|
|
|
|
{ /*438, WINED3DTS_WORLDMATRIX(182) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex },
|
|
|
|
|
{ /*439, WINED3DTS_WORLDMATRIX(183) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex },
|
|
|
|
|
{ /*440, WINED3DTS_WORLDMATRIX(184) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex },
|
|
|
|
|
{ /*441, WINED3DTS_WORLDMATRIX(185) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex },
|
|
|
|
|
{ /*441, WINED3DTS_WORLDMATRIX(186) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex },
|
|
|
|
|
{ /*443, WINED3DTS_WORLDMATRIX(187) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex },
|
|
|
|
|
{ /*444, WINED3DTS_WORLDMATRIX(188) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex },
|
|
|
|
|
{ /*445, WINED3DTS_WORLDMATRIX(189) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex },
|
|
|
|
|
{ /*446, WINED3DTS_WORLDMATRIX(190) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex },
|
|
|
|
|
{ /*447, WINED3DTS_WORLDMATRIX(191) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex },
|
|
|
|
|
{ /*448, WINED3DTS_WORLDMATRIX(192) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex },
|
|
|
|
|
{ /*449, WINED3DTS_WORLDMATRIX(193) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex },
|
|
|
|
|
{ /*450, WINED3DTS_WORLDMATRIX(194) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex },
|
|
|
|
|
{ /*451, WINED3DTS_WORLDMATRIX(195) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex },
|
|
|
|
|
{ /*452, WINED3DTS_WORLDMATRIX(196) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex },
|
|
|
|
|
{ /*453, WINED3DTS_WORLDMATRIX(197) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex },
|
|
|
|
|
{ /*454, WINED3DTS_WORLDMATRIX(198) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex },
|
|
|
|
|
{ /*455, WINED3DTS_WORLDMATRIX(199) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex },
|
|
|
|
|
{ /*356, WINED3DTS_WORLDMATRIX(200) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex },
|
|
|
|
|
{ /*457, WINED3DTS_WORLDMATRIX(201) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex },
|
|
|
|
|
{ /*458, WINED3DTS_WORLDMATRIX(202) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex },
|
|
|
|
|
{ /*459, WINED3DTS_WORLDMATRIX(203) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex },
|
|
|
|
|
{ /*460, WINED3DTS_WORLDMATRIX(204) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex },
|
|
|
|
|
{ /*461, WINED3DTS_WORLDMATRIX(205) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex },
|
|
|
|
|
{ /*462, WINED3DTS_WORLDMATRIX(206) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex },
|
|
|
|
|
{ /*463, WINED3DTS_WORLDMATRIX(207) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex },
|
|
|
|
|
{ /*464, WINED3DTS_WORLDMATRIX(208) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex },
|
|
|
|
|
{ /*465, WINED3DTS_WORLDMATRIX(209) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex },
|
|
|
|
|
{ /*466, WINED3DTS_WORLDMATRIX(210) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex },
|
|
|
|
|
{ /*467, WINED3DTS_WORLDMATRIX(211) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex },
|
|
|
|
|
{ /*468, WINED3DTS_WORLDMATRIX(212) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex },
|
|
|
|
|
{ /*469, WINED3DTS_WORLDMATRIX(213) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex },
|
|
|
|
|
{ /*470, WINED3DTS_WORLDMATRIX(214) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex },
|
|
|
|
|
{ /*471, WINED3DTS_WORLDMATRIX(215) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex },
|
|
|
|
|
{ /*472, WINED3DTS_WORLDMATRIX(216) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex },
|
|
|
|
|
{ /*473, WINED3DTS_WORLDMATRIX(217) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex },
|
|
|
|
|
{ /*474, WINED3DTS_WORLDMATRIX(218) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex },
|
|
|
|
|
{ /*475, WINED3DTS_WORLDMATRIX(219) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex },
|
|
|
|
|
{ /*476, WINED3DTS_WORLDMATRIX(220) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex },
|
|
|
|
|
{ /*477, WINED3DTS_WORLDMATRIX(221) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex },
|
|
|
|
|
{ /*478, WINED3DTS_WORLDMATRIX(222) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex },
|
|
|
|
|
{ /*479, WINED3DTS_WORLDMATRIX(223) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex },
|
|
|
|
|
{ /*480, WINED3DTS_WORLDMATRIX(224) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex },
|
|
|
|
|
{ /*481, WINED3DTS_WORLDMATRIX(225) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex },
|
|
|
|
|
{ /*482, WINED3DTS_WORLDMATRIX(226) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex },
|
|
|
|
|
{ /*483, WINED3DTS_WORLDMATRIX(227) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex },
|
|
|
|
|
{ /*484, WINED3DTS_WORLDMATRIX(228) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex },
|
|
|
|
|
{ /*485, WINED3DTS_WORLDMATRIX(229) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex },
|
|
|
|
|
{ /*486, WINED3DTS_WORLDMATRIX(230) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex },
|
|
|
|
|
{ /*487, WINED3DTS_WORLDMATRIX(231) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex },
|
|
|
|
|
{ /*488, WINED3DTS_WORLDMATRIX(232) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex },
|
|
|
|
|
{ /*489, WINED3DTS_WORLDMATRIX(233) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex },
|
|
|
|
|
{ /*490, WINED3DTS_WORLDMATRIX(234) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex },
|
|
|
|
|
{ /*491, WINED3DTS_WORLDMATRIX(235) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex },
|
|
|
|
|
{ /*492, WINED3DTS_WORLDMATRIX(236) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex },
|
|
|
|
|
{ /*493, WINED3DTS_WORLDMATRIX(237) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex },
|
|
|
|
|
{ /*494, WINED3DTS_WORLDMATRIX(238) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex },
|
|
|
|
|
{ /*495, WINED3DTS_WORLDMATRIX(239) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex },
|
|
|
|
|
{ /*496, WINED3DTS_WORLDMATRIX(240) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex },
|
|
|
|
|
{ /*497, WINED3DTS_WORLDMATRIX(241) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex },
|
|
|
|
|
{ /*498, WINED3DTS_WORLDMATRIX(242) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex },
|
|
|
|
|
{ /*499, WINED3DTS_WORLDMATRIX(243) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex },
|
|
|
|
|
{ /*500, WINED3DTS_WORLDMATRIX(244) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex },
|
|
|
|
|
{ /*501, WINED3DTS_WORLDMATRIX(245) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex },
|
|
|
|
|
{ /*502, WINED3DTS_WORLDMATRIX(246) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex },
|
|
|
|
|
{ /*503, WINED3DTS_WORLDMATRIX(247) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex },
|
|
|
|
|
{ /*504, WINED3DTS_WORLDMATRIX(248) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex },
|
|
|
|
|
{ /*505, WINED3DTS_WORLDMATRIX(249) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex },
|
|
|
|
|
{ /*506, WINED3DTS_WORLDMATRIX(250) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex },
|
|
|
|
|
{ /*507, WINED3DTS_WORLDMATRIX(251) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex },
|
|
|
|
|
{ /*508, WINED3DTS_WORLDMATRIX(252) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex },
|
|
|
|
|
{ /*509, WINED3DTS_WORLDMATRIX(253) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex },
|
|
|
|
|
{ /*510, WINED3DTS_WORLDMATRIX(254) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex },
|
|
|
|
|
{ /*511, WINED3DTS_WORLDMATRIX(255) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex },
|
2007-01-02 00:35:07 +01:00
|
|
|
|
/* Various Vertex states follow */
|
|
|
|
|
{ /* , STATE_STREAMSRC */ STATE_VDECL, vertexdeclaration },
|
|
|
|
|
{ /* , STATE_VDECL */ STATE_VDECL, vertexdeclaration },
|
|
|
|
|
{ /* , STATE_VSHADER */ STATE_VDECL, vertexdeclaration },
|
2007-01-04 00:05:05 +01:00
|
|
|
|
{ /* , STATE_VIEWPORT */ STATE_VIEWPORT, viewport },
|
2007-01-06 18:17:27 +01:00
|
|
|
|
{ /* , STATE_VERTEXSHADERCONSTANT */ STATE_VERTEXSHADERCONSTANT, shaderconstant },
|
|
|
|
|
{ /* , STATE_PIXELSHADERCONSTANT */ STATE_VERTEXSHADERCONSTANT, shaderconstant },
|
2006-12-05 23:36:10 +01:00
|
|
|
|
};
|