ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

- integration with DrawPrimitive 

- remove non-esthetic c++ comments into c comments block ;)
- more more debug
- indent, cleanups
- trying to use DIFFUSE and SPECULAR for vertex shader
- many fixes
- integration with Jason's texture patch
This commit is contained in:
Raphael Junqueira 2003-01-02 17:59:01 +00:00 committed by Alexandre Julliard
parent 1d97f52fa1
commit 559b10699f
7 changed files with 711 additions and 378 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dlls/d3d8/d3d8.spec
View File

@ -1,5 +1,5 @@
@ stdcall D3D8GetSWInfo() D3D8GetSWInfo @ stdcall D3D8GetSWInfo() D3D8GetSWInfo
@ stdcall DebugSetMute() DebugSetMute @ stdcall DebugSetMute(long) DebugSetMute
@ stdcall Direct3DCreate8(long) Direct3DCreate8 @ stdcall Direct3DCreate8(long) Direct3DCreate8
@ stdcall ValidatePixelShader() ValidatePixelShader @ stdcall ValidatePixelShader(ptr ptr) ValidatePixelShader
@ stdcall ValidateVertexShader() ValidateVertexShader @ stdcall ValidateVertexShader(ptr ptr) ValidateVertexShader

52
dlls/d3d8/d3d8_private.h
View File

@ -63,7 +63,7 @@ extern void (*wine_tsx11_unlock_ptr)(void);
#define HIGHEST_TRANSFORMSTATE 512 #define HIGHEST_TRANSFORMSTATE 512
#define D3DSBT_RECORDED 0xfffffffe #define D3DSBT_RECORDED 0xfffffffe
/* Direct38 Interfaces: */ /* Direct3D8 Interfaces: */
typedef struct IDirect3DBaseTexture8Impl IDirect3DBaseTexture8Impl; typedef struct IDirect3DBaseTexture8Impl IDirect3DBaseTexture8Impl;
typedef struct IDirect3DVolumeTexture8Impl IDirect3DVolumeTexture8Impl; typedef struct IDirect3DVolumeTexture8Impl IDirect3DVolumeTexture8Impl;
typedef struct IDirect3D8Impl IDirect3D8Impl; typedef struct IDirect3D8Impl IDirect3D8Impl;
@ -152,52 +152,64 @@ typedef struct STATEBLOCK {
} STATEBLOCK; } STATEBLOCK;
typedef struct SHADER8Vector { typedef struct D3DSHADERVECTOR {
float x; float x;
float y; float y;
float z; float z;
float w; float w;
} SHADER8Vector; } D3DSHADERVECTOR;
typedef struct SHADER8Scalar { typedef struct D3DSHADERSCALAR {
float x; float x;
} SHADER8Scalar; } D3DSHADERSCALAR;
#define SHADER_MAX_CONSTANTS 96 #define D3D8_VSHADER_MAX_CONSTANTS 96
#define VSHADER_MAX_CONSTANTS 96 #define D3D8_PSHADER_MAX_CONSTANTS 96
#define PSHADER_MAX_CONSTANTS 96 typedef D3DSHADERVECTOR VSHADERCONSTANTS8[D3D8_VSHADER_MAX_CONSTANTS];
typedef SHADER8Vector SHADER8Constants[SHADER_MAX_CONSTANTS];
typedef struct SHADER8Data { typedef struct SHADERDATA8 {
/** Run Time Shader Function Constants */ /** Run Time Shader Function Constants */
/*D3DXBUFFER* constants;*/ /*D3DXBUFFER* constants;*/
SHADER8Constants C; VSHADERCONSTANTS8 C;
/** Shader Code as char ... */ /** Shader Code as char ... */
CONST DWORD* code; CONST DWORD* code;
UINT codeLength; UINT codeLength;
} SHADER8Data; } SHADERDATA8;
typedef struct VERTEXSHADER8 { /* TODO: Vertex Shader */ typedef struct VERTEXSHADER8 { /* TODO: Vertex Shader */
CONST DWORD* decl; DWORD* decl;
CONST DWORD* function; DWORD* function;
DWORD usage; /* 0 || D3DUSAGE_SOFTWAREPROCESSING */ DWORD usage; /* 0 || D3DUSAGE_SOFTWAREPROCESSING */
UINT declLength; UINT declLength;
UINT functionLength; UINT functionLength;
DWORD fvf; DWORD fvf;
DWORD version;
/* run time datas */ /* run time datas */
SHADER8Data* data; SHADERDATA8* data;
} VERTEXSHADER8; } VERTEXSHADER8;
typedef struct PIXELSHADER8 { /* TODO: Pixel Shader */ typedef struct PIXELSHADER8 { /* TODO: Pixel Shader */
CONST DWORD* function; CONST DWORD* function;
UINT functionLength; UINT functionLength;
DWORD version;
/* run time datas */ /* run time datas */
SHADER8Data* data; SHADERDATA8* data;
} PIXELSHADER8; } PIXELSHADER8;
/** temporary here waiting for buffer code */
typedef struct VSHADERINPUTDATA8 {
D3DSHADERVECTOR V[16];
} VSHADERINPUTDATA8;
/** temporary here waiting for buffer code */
typedef struct VSHADEROUTPUTDATA8 {
D3DSHADERVECTOR oPos;
D3DSHADERVECTOR oD[2];
D3DSHADERVECTOR oT[4];
D3DSHADERVECTOR oFog;
D3DSHADERVECTOR oPts;
} VSHADEROUTPUTDATA8;
/* /*
* External prototypes * External prototypes
*/ */
@ -916,6 +928,6 @@ extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_AddDirtyBox(LPDIRECT3D
*/ */
DWORD vshader_decl_parse(VERTEXSHADER8* vshader); DWORD vshader_decl_parse(VERTEXSHADER8* vshader);
DWORD vshader_program_parse(VERTEXSHADER8* vshader); DWORD vshader_program_parse(VERTEXSHADER8* vshader);
BOOL vshader_program_execute_SW(VERTEXSHADER8* vshader, VSHADERINPUTDATA8* input, VSHADEROUTPUTDATA8* output);
#endif /* __WINE_D3DX8_PRIVATE_H */ #endif /* __WINE_D3DX8_PRIVATE_H */

336
dlls/d3d8/device.c
View File

@ -53,6 +53,11 @@ static PIXELSHADER8* PixelShaders[64];
memcpy(gl_mat, (mat), 16 * sizeof(float)); \ memcpy(gl_mat, (mat), 16 * sizeof(float)); \
}; };
#define VERTEX_SHADER(Handle) \
((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(VertexShaders) / sizeof(VERTEXSHADER8*)) ? NULL : VertexShaders[Handle]) : VertexShaders[Handle - VS_HIGHESTFIXEDFXF])
#define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w);
/* /*
* Globals * Globals
*/ */
@ -68,6 +73,7 @@ static const float idmatrix[16] = {
0.0, 0.0, 0.0, 1.0 0.0, 0.0, 0.0, 1.0
}; };
/* Routine common to the draw primitive and draw indexed primitive routines /* Routine common to the draw primitive and draw indexed primitive routines
Doesnt use gl pointer arrays as I dont believe we can support the blending Doesnt use gl pointer arrays as I dont believe we can support the blending
coordinates that way. */ coordinates that way. */
@ -89,6 +95,9 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
int vx_index; int vx_index;
int NumVertexes = NumPrimitives; int NumVertexes = NumPrimitives;
VERTEXSHADER8* vertex_shader = NULL;
VSHADERINPUTDATA8 vertex_shader_input;
BOOL useVertexShaderFunction = FALSE;
ICOM_THIS(IDirect3DDevice8Impl,iface); ICOM_THIS(IDirect3DDevice8Impl,iface);
@ -96,10 +105,22 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
FVF is passed in rather than a handle, it must use stream 0 */ FVF is passed in rather than a handle, it must use stream 0 */
if (This->StateBlock.VertexShader > VS_HIGHESTFIXEDFXF) { if (This->StateBlock.VertexShader > VS_HIGHESTFIXEDFXF) {
FIXME("Cant handle created shaders yet\n"); vertex_shader = VERTEX_SHADER(This->StateBlock.VertexShader);
return; if (NULL == vertex_shader) {
ERR("trying to use unitialised vertex shader: %lu\n", This->StateBlock.VertexShader);
return ;
}
if (NULL == vertex_shader->function) {
TRACE("vertex shader declared without program, using FVF pure mode\n");
} else { } else {
useVertexShaderFunction = TRUE;
}
fvf = (D3DFORMAT) vertex_shader->fvf;
TRACE("vertex shader declared FVF: %lx\n", vertex_shader->fvf);
memset(&vertex_shader_input, 0, sizeof(VSHADERINPUTDATA8));
}
{
int skip = This->StateBlock.stream_stride[0]; int skip = This->StateBlock.stream_stride[0];
BOOL normal; BOOL normal;
@ -107,6 +128,8 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
BOOL isPtSize; BOOL isPtSize;
BOOL isDiffuse; BOOL isDiffuse;
BOOL isSpecular; BOOL isSpecular;
int numBlends;
BOOL isLastUByte4;
int numTextures; int numTextures;
int textureNo; int textureNo;
const void *curVtx = NULL; const void *curVtx = NULL;
@ -133,13 +156,16 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
normal = fvf & D3DFVF_NORMAL; normal = fvf & D3DFVF_NORMAL;
isRHW = fvf & D3DFVF_XYZRHW; isRHW = fvf & D3DFVF_XYZRHW;
/*numBlends = 5 - ((~fvf) & 0xe);*/ /* There must be a simpler way? */ /*numBlends = 5 - ((~fvf) & 0xe);*/ /* There must be a simpler way? */
numBlends = ((fvf & D3DFVF_POSITION_MASK) >> 1) - 2; /* WARNING can be < 0 because -2 */
isLastUByte4 = fvf & D3DFVF_LASTBETA_UBYTE4;
isPtSize = fvf & D3DFVF_PSIZE; isPtSize = fvf & D3DFVF_PSIZE;
isDiffuse = fvf & D3DFVF_DIFFUSE; isDiffuse = fvf & D3DFVF_DIFFUSE;
isSpecular = fvf & D3DFVF_SPECULAR; isSpecular = fvf & D3DFVF_SPECULAR;
numTextures = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT; numTextures = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
TRACE("Drawing with FVF = %x, (n?%d, rhw?%d, ptSize(%d), diffuse?%d, specular?%d, numTextures=%d)\n",
fvf, normal, isRHW, isPtSize, isDiffuse, isSpecular, numTextures); TRACE("Drawing with FVF = %x, (n?%d, rhw?%d, ptSize(%d), diffuse?%d, specular?%d, numTextures=%d, numBlends=%d)\n",
fvf, normal, isRHW, isPtSize, isDiffuse, isSpecular, numTextures, numBlends);
/* If no normals, DISABLE lighting otherwise, dont touch lighing as it is /* If no normals, DISABLE lighting otherwise, dont touch lighing as it is
set by the appropriate render state */ set by the appropriate render state */
@ -151,9 +177,7 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
if (isRHW) { if (isRHW) {
double height, width, minZ, maxZ; double height, width, minZ, maxZ;
/* /*
* Already transformed vertex do not need transform * Already transformed vertex do not need transform
* matrices. Reset all matrices to identity. * matrices. Reset all matrices to identity.
@ -174,13 +198,11 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ); TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
glOrtho(0.0, width, height, 0.0, -minZ, -maxZ); glOrtho(0.0, width, height, 0.0, -minZ, -maxZ);
checkGLcall("glOrtho"); checkGLcall("glOrtho");
} else { } else {
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
checkGLcall("glMatrixMode"); checkGLcall("glMatrixMode");
glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_PROJECTION].u.m[0][0]); glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_PROJECTION].u.m[0][0]);
checkGLcall("glLoadMatrixf"); checkGLcall("glLoadMatrixf");
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
checkGLcall("glMatrixMode"); checkGLcall("glMatrixMode");
glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_VIEW].u.m[0][0]); glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_VIEW].u.m[0][0]);
@ -257,18 +279,51 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
z = *(float *)curPos; z = *(float *)curPos;
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
TRACE("x,y,z=%f,%f,%f\n", x,y,z); /*TRACE("x,y,z=%f,%f,%f\n", x,y,z);*/
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_POSITION].x = x;
vertex_shader_input.V[D3DVSDE_POSITION].y = y;
vertex_shader_input.V[D3DVSDE_POSITION].z = z;
vertex_shader_input.V[D3DVSDE_POSITION].w = 1.0f;
}
/* RHW follows, only if transformed */ /* RHW follows, only if transformed */
if (isRHW) { if (isRHW) {
rhw = *(float *)curPos; rhw = *(float *)curPos;
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
TRACE("rhw=%f\n", rhw); /*TRACE("rhw=%f\n", rhw);*/
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_POSITION].w = rhw;
}
}
/* FIXME: Skip Blending data */
if (numBlends > 0) {
UINT i;
D3DSHADERVECTOR skippedBlend = { 0.0f, 0.0f, 0.0f, 0.0f };
DWORD skippedBlendLastUByte4 = 0;
for (i = 0; i < ((FALSE == isLastUByte4) ? numBlends : numBlends - 1); ++i) {
((float*)&skippedBlend)[i] = *(float *)curPos;
curPos = curPos + sizeof(float);
}
if (isLastUByte4) {
skippedBlendLastUByte4 = *(DWORD*)curPos;
curPos = curPos + sizeof(DWORD);
} }
if (TRUE == useVertexShaderFunction) {
/* FIXME: Skip Blending data */ vertex_shader_input.V[D3DVSDE_BLENDWEIGHT].x = skippedBlend.x;
vertex_shader_input.V[D3DVSDE_BLENDWEIGHT].y = skippedBlend.y;
vertex_shader_input.V[D3DVSDE_BLENDWEIGHT].z = skippedBlend.z;
vertex_shader_input.V[D3DVSDE_BLENDWEIGHT].w = skippedBlend.w;
if (isLastUByte4) {
vertex_shader_input.V[D3DVSDE_BLENDINDICES].x = (float) skippedBlendLastUByte4;
vertex_shader_input.V[D3DVSDE_BLENDINDICES].y = (float) skippedBlendLastUByte4;
vertex_shader_input.V[D3DVSDE_BLENDINDICES].z = (float) skippedBlendLastUByte4;
vertex_shader_input.V[D3DVSDE_BLENDINDICES].w = (float) skippedBlendLastUByte4;
}
}
}
/* Vertex Normal Data (untransformed only) */ /* Vertex Normal Data (untransformed only) */
if (normal) { if (normal) {
nx = *(float *)curPos; nx = *(float *)curPos;
@ -277,35 +332,64 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
nz = *(float *)curPos; nz = *(float *)curPos;
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
TRACE("nx,ny,nz=%f,%f,%f\n", nx,ny,nz); /*TRACE("nx,ny,nz=%f,%f,%f\n", nx,ny,nz);*/
}
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_NORMAL].x = nx;
vertex_shader_input.V[D3DVSDE_NORMAL].y = ny;
vertex_shader_input.V[D3DVSDE_NORMAL].z = nz;
vertex_shader_input.V[D3DVSDE_NORMAL].w = 1.0f;
}
}
if (isPtSize) { if (isPtSize) {
ptSize = *(float *)curPos; ptSize = *(float *)curPos;
/*TRACE("ptSize=%f\n", ptSize);*/
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
TRACE("ptSize=%f\n", ptSize);
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_PSIZE].x = ptSize;
vertex_shader_input.V[D3DVSDE_PSIZE].y = 0.0f;
vertex_shader_input.V[D3DVSDE_PSIZE].z = 0.0f;
vertex_shader_input.V[D3DVSDE_PSIZE].w = 1.0f;
}
} }
if (isDiffuse) { if (isDiffuse) {
diffuseColor = *(DWORD *)curPos; diffuseColor = *(DWORD *)curPos;
TRACE("diffuseColor=%lx\n", diffuseColor); /*TRACE("diffuseColor=%lx\n", diffuseColor);*/
curPos = curPos + sizeof(DWORD); curPos = curPos + sizeof(DWORD);
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_DIFFUSE].x = (float) (((diffuseColor >> 16) & 0xFF) / 255.0f);
vertex_shader_input.V[D3DVSDE_DIFFUSE].y = (float) (((diffuseColor >> 8) & 0xFF) / 255.0f);
vertex_shader_input.V[D3DVSDE_DIFFUSE].z = (float) (((diffuseColor >> 0) & 0xFF) / 255.0f);
vertex_shader_input.V[D3DVSDE_DIFFUSE].w = (float) (((diffuseColor >> 24) & 0xFF) / 255.0f);
}
} }
if (isSpecular) { if (isSpecular) {
specularColor = *(DWORD *)curPos; specularColor = *(DWORD *)curPos;
TRACE("specularColor=%lx\n", specularColor); /*TRACE("specularColor=%lx\n", specularColor);*/
curPos = curPos + sizeof(DWORD); curPos = curPos + sizeof(DWORD);
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_SPECULAR].x = (float) (((specularColor >> 16) & 0xFF) / 255.0f);
vertex_shader_input.V[D3DVSDE_SPECULAR].y = (float) (((specularColor >> 8) & 0xFF) / 255.0f);
vertex_shader_input.V[D3DVSDE_SPECULAR].z = (float) (((specularColor >> 0) & 0xFF) / 255.0f);
vertex_shader_input.V[D3DVSDE_SPECULAR].w = (float) (((specularColor >> 24) & 0xFF) / 255.0f);
}
} }
/* ToDo: Texture coords */ /* ToDo: Texture coords */
for (textureNo = 0;textureNo<numTextures; textureNo++) { for (textureNo = 0; textureNo < numTextures; ++textureNo) {
float s, t, r, q;
float s,t,r,q; if (!(This->isMultiTexture) && textureNo > 0) {
if (!(This->isMultiTexture) && textureNo>0) {
FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n"); FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
continue; continue ;
}
if (textureNo > This->TextureUnits) {
FIXME("Program using more concurrent textures than this opengl implementation support\n");
break ;
} }
/* Query tex coords */ /* Query tex coords */
if (This->StateBlock.textures[textureNo] != NULL) { if (This->StateBlock.textures[textureNo] != NULL) {
switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock.textures[textureNo])) { switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock.textures[textureNo])) {
@ -315,11 +399,19 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
t = *(float *)curPos; t = *(float *)curPos;
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
TRACE("tex:%d, s,t=%f,%f\n", textureNo, s,t); TRACE("tex:%d, s,t=%f,%f\n", textureNo, s,t);
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].x = s;
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].y = t;
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].z = 0.0f;
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].w = 1.0f;
} else {
if (This->isMultiTexture) { if (This->isMultiTexture) {
glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t); glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t);
} else { } else {
glTexCoord2f(s, t); glTexCoord2f(s, t);
} }
}
break; break;
case D3DRTYPE_VOLUMETEXTURE: case D3DRTYPE_VOLUMETEXTURE:
@ -330,15 +422,23 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
r = *(float *)curPos; r = *(float *)curPos;
curPos = curPos + sizeof(float); curPos = curPos + sizeof(float);
TRACE("tex:%d, s,t,r=%f,%f,%f\n", textureNo, s,t,r); TRACE("tex:%d, s,t,r=%f,%f,%f\n", textureNo, s,t,r);
if (TRUE == useVertexShaderFunction) {
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].x = s;
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].y = t;
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].z = r;
vertex_shader_input.V[D3DVSDE_TEXCOORD0 + textureNo].w = 1.0f;
} else {
if (This->isMultiTexture) { if (This->isMultiTexture) {
glMultiTexCoord3fARB(GL_TEXTURE0_ARB + textureNo, s, t, r); glMultiTexCoord3fARB(GL_TEXTURE0_ARB + textureNo, s, t, r);
} else { } else {
glTexCoord3f(s, t, r); glTexCoord3f(s, t, r);
} }
}
break; break;
default: default:
r=0;q=0; /* Avoid compiler warnings, need these vars later for other textures */ r = 0.0f; q = 0.0f; /* Avoid compiler warnings, need these vars later for other textures */
FIXME("Unhandled texture type\n"); FIXME("Unhandled texture type\n");
} }
} else { } else {
@ -348,28 +448,134 @@ void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
} }
/** if vertex shader program specified ... using it */
if (TRUE == useVertexShaderFunction) {
VSHADEROUTPUTDATA8 vs_o;
memset(&vs_o, 0, sizeof(VSHADEROUTPUTDATA8));
vshader_program_execute_SW(vertex_shader, &vertex_shader_input, &vs_o);
/*
TRACE_VECTOR(vs_o.oPos);
TRACE_VECTOR(vs_o.oD[0]);
TRACE_VECTOR(vs_o.oT[0]);
TRACE_VECTOR(vs_o.oT[1]);
*/
x = vs_o.oPos.x;
y = vs_o.oPos.y;
z = vs_o.oPos.z;
if (1.0f != vs_o.oPos.w || isRHW) {
rhw = vs_o.oPos.w;
}
/*TRACE_VECTOR(vs_o.oPos);*/
if (isDiffuse) {
/*diffuseColor = D3DCOLOR_COLORVALUE(vs_o.oD[0].x, vs_o.oD[0].y, vs_o.oD[0].z, vs_o.oD[0].w);*/
/*TRACE_VECTOR(vs_o.oD[0]);*/
/*glColor4f(vs_o.oD[0].x, vs_o.oD[0].y, vs_o.oD[0].z, vs_o.oD[0].w); */
glMaterialfv(GL_FRONT, GL_DIFFUSE, (float*) &vs_o.oD[0]);
checkGLcall("glMaterialfv");
}
if (isSpecular) {
/*specularColor = D3DCOLOR_COLORVALUE(vs_o.oD[1].x, vs_o.oD[1].y, vs_o.oD[1].z, vs_o.oD[1].w);*/
/*TRACE_VECTOR(vs_o.oD[1]);*/
glMaterialfv(GL_FRONT, GL_SPECULAR, (float*) &vs_o.oD[1]);
checkGLcall("glMaterialfv");
}
/** reupdate textures coords binding using vs_o.oT[0->3] */
for (textureNo = 0; textureNo < 4/*min(numTextures, 4)*/; ++textureNo) {
float s, t, r, q;
if (!(This->isMultiTexture) && textureNo > 0) {
FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
continue ;
}
/* Query tex coords */
if (This->StateBlock.textures[textureNo] != NULL) {
switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock.textures[textureNo])) {
case D3DRTYPE_TEXTURE:
/*TRACE_VECTOR(vs_o.oT[textureNo]);*/
s = vs_o.oT[textureNo].x;
t = vs_o.oT[textureNo].y;
TRACE("tex:%d, s,t=%f,%f\n", textureNo, s,t);
if (This->isMultiTexture) {
glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t);
checkGLcall("glMultiTexCoord2fARB");
} else {
glTexCoord2f(s, t);
checkGLcall("gTexCoord2f");
}
break;
case D3DRTYPE_VOLUMETEXTURE:
/*TRACE_VECTOR(vs_o.oT[textureNo]);*/
s = vs_o.oT[textureNo].x;
t = vs_o.oT[textureNo].y;
r = vs_o.oT[textureNo].z;
TRACE("tex:%d, s,t,r=%f,%f,%f\n", textureNo, s,t,r);
if (This->isMultiTexture) {
glMultiTexCoord3fARB(GL_TEXTURE0_ARB + textureNo, s, t, r);
checkGLcall("glMultiTexCoord2fARB");
} else {
glTexCoord3f(s, t, r);
checkGLcall("gTexCoord3f");
}
break;
default:
/* Avoid compiler warnings, need these vars later for other textures */
r = 0.0f; q = 0.0f;
FIXME("Unhandled texture type\n");
}
}
}
if (1.0f == rhw || rhw < 0.01f) {
/*TRACE("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z);*/
glVertex3f(x, y, z);
checkGLcall("glVertex3f");
} else {
/*TRACE("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw);*/
glVertex4f(x / rhw, y / rhw, z / rhw, 1.0f / rhw);
checkGLcall("glVertex4f");
}
} else {
/**
* FALSE == useVertexShaderFunction
* using std FVF code
*/
/* Handle these vertexes */ /* Handle these vertexes */
if (isDiffuse) { if (isDiffuse) {
glColor4f(((diffuseColor >> 16) & 0xFF) / 255.0, /*
((diffuseColor >> 8) & 0xFF) / 255.0, glColor4f(((diffuseColor >> 16) & 0xFF) / 255.0f,
((diffuseColor >> 0) & 0xFF) / 255.0, ((diffuseColor >> 8) & 0xFF) / 255.0f,
((diffuseColor >> 24) & 0xFF) / 255.0); ((diffuseColor >> 0) & 0xFF) / 255.0f,
TRACE("glColor4f: r,g,b,a=%f,%f,%f,%f\n", ((diffuseColor >> 16) & 0xFF) / 255.0, ((diffuseColor >> 8) & 0xFF) / 255.0, ((diffuseColor >> 24) & 0xFF) / 255.0f);
((diffuseColor >> 0) & 0xFF) / 255.0, ((diffuseColor >> 24) & 0xFF) / 255.0); */
glColor4ub((diffuseColor >> 16) & 0xFF,
(diffuseColor >> 8) & 0xFF,
(diffuseColor >> 0) & 0xFF,
(diffuseColor >> 24) & 0xFF);
/*
TRACE("glColor4f: r,g,b,a=%f,%f,%f,%f\n",
((diffuseColor >> 16) & 0xFF) / 255.0f,
((diffuseColor >> 8) & 0xFF) / 255.0f,
((diffuseColor >> 0) & 0xFF) / 255.0f,
((diffuseColor >> 24) & 0xFF) / 255.0f);
*/
} }
if (normal) { if (normal) {
TRACE("Vertex: glVertex:x,y,z=%f,%f,%f / glNormal:nx,ny,nz=%f,%f,%f\n", x,y,z,nx,ny,nz); /*TRACE("Vertex: glVertex:x,y,z=%f,%f,%f / glNormal:nx,ny,nz=%f,%f,%f\n", x,y,z,nx,ny,nz);*/
glNormal3f(nx, ny, nz); glNormal3f(nx, ny, nz);
glVertex3f(x, y, z); glVertex3f(x, y, z);
} else { } else {
if (rhw < 0.01) { if (1.0f == rhw || rhw < 0.01f) {
TRACE("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z); /*TRACE("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z);*/
glVertex3f(x, y, z); glVertex3f(x, y, z);
} else { } else {
TRACE("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw); /*TRACE("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw);*/
glVertex4f(x / rhw, y / rhw, z / rhw, 1.0 / rhw); glVertex4f(x / rhw, y / rhw, z / rhw, 1.0f / rhw);
}
} }
} }
@ -411,8 +617,6 @@ SHORT bytesPerPixel(D3DFORMAT fmt) {
FIXME("Unhandled fmt %d\n", fmt); FIXME("Unhandled fmt %d\n", fmt);
retVal = 4; retVal = 4;
} }
TRACE("bytes/Pxl for fmt %d = %d\n", fmt, retVal); TRACE("bytes/Pxl for fmt %d = %d\n", fmt, retVal);
return retVal; return retVal;
} }
@ -465,8 +669,6 @@ DWORD fmt2glType(D3DFORMAT fmt) {
FIXME("Unhandled fmt %d\n", fmt); FIXME("Unhandled fmt %d\n", fmt);
retVal = 4; retVal = 4;
} }
TRACE("fmt2glType for fmt %d = %x\n", fmt, retVal); TRACE("fmt2glType for fmt %d = %x\n", fmt, retVal);
return retVal; return retVal;
} }
@ -551,7 +753,7 @@ void setupTextureStates(LPDIRECT3DDEVICE8 iface, DWORD Stage) {
if (This->isMultiTexture) { if (This->isMultiTexture) {
glActiveTextureARB(GL_TEXTURE0_ARB + Stage); glActiveTextureARB(GL_TEXTURE0_ARB + Stage);
checkGLcall("glActiveTextureARB"); checkGLcall("glActiveTextureARB");
} else if (Stage>0) { } else if (Stage > 0) {
FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n"); FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
} }
@ -611,7 +813,6 @@ HRESULT WINAPI IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 ifa
return D3D_OK; return D3D_OK;
} }
UINT WINAPI IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface) { UINT WINAPI IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface) {
ICOM_THIS(IDirect3DDevice8Impl,iface); ICOM_THIS(IDirect3DDevice8Impl,iface);
TRACE("(%p) : stub, emulating 32Mb for now\n", This); TRACE("(%p) : stub, emulating 32Mb for now\n", This);
@ -1918,7 +2119,7 @@ HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface, D3
checkGLcall("glBlendColor"); checkGLcall("glBlendColor");
/* And now the default texture color as well */ /* And now the default texture color as well */
for (i=0; i<This->TextureUnits; i++) { for (i = 0; i < This->TextureUnits; i++) {
/* Note the D3DRS value applies to all textures, but GL has one /* Note the D3DRS value applies to all textures, but GL has one
per texture, so apply it now ready to be used! */ per texture, so apply it now ready to be used! */
@ -2304,13 +2505,12 @@ HRESULT WINAPI IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface, D
} }
/* Texture */ /* Texture */
for (j=0; j<This->TextureUnits; j++) { for (j = 0; j < This->TextureUnits; j++) {
for (i=0; i<HIGHEST_TEXTURE_STATE; i++) { for (i = 0; i < HIGHEST_TEXTURE_STATE; i++) {
if (pSB->Set.texture_state[j][i] && pSB->Changed.texture_state[j][i]) {
if (pSB->Set.texture_state[j][i] && pSB->Changed.texture_state[j][i])
IDirect3DDevice8Impl_SetTextureStageState(iface, j, i, pSB->texture_state[j][i]); IDirect3DDevice8Impl_SetTextureStageState(iface, j, i, pSB->texture_state[j][i]);
} }
}
if (pSB->Set.textures[j] && pSB->Changed.textures[j]) { if (pSB->Set.textures[j] && pSB->Changed.textures[j]) {
IDirect3DDevice8Impl_SetTexture(iface, j, pSB->textures[j]); IDirect3DDevice8Impl_SetTexture(iface, j, pSB->textures[j]);
} }
@ -3173,27 +3373,25 @@ HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 iface
} }
object->usage = Usage; object->usage = Usage;
object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHADER8Data)); object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHADERDATA8));
VertexShaders[i] = object; VertexShaders[i] = object;
*pHandle = VS_HIGHESTFIXEDFXF + i; *pHandle = VS_HIGHESTFIXEDFXF + i;
object->decl = pDeclaration; object->decl = (DWORD*) pDeclaration;
object->function = pFunction; object->function = (DWORD*) pFunction;
/*
for (i = 0; 0xFFFFFFFF != pDeclaration[i]; ++i) ;
object->declLength = i + 1;
if (NULL != pFunction) {
for (i = 0; 0xFFFFFFFF != pFunction[i]; ++i) ;
object->functionLength = i + 1;
} else {
object->functionLength = 1; // no Function defined use fixed function vertex processing
}
*/
vshader_decl_parse(object); vshader_decl_parse(object);
vshader_program_parse(object); vshader_program_parse(object);
/* copy the function ... because it will certainly be released by application */
if (NULL != pFunction) {
object->function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->functionLength);
memcpy(object->function, pFunction, object->functionLength);
}
/* copy the declaration too */
object->decl = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->declLength);
memcpy(object->decl, pDeclaration, object->declLength);
return D3D_OK; return D3D_OK;
} }
HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) { HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) {
@ -3236,21 +3434,21 @@ HRESULT WINAPI IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface
} }
TRACE("(%p) : freing VertexShader %p\n", This, object); TRACE("(%p) : freing VertexShader %p\n", This, object);
/* TODO: check validity of object */ /* TODO: check validity of object */
if (NULL != object->data) HeapFree(GetProcessHeap(), 0, (void *)object->data); if (NULL != object->function) HeapFree(GetProcessHeap(), 0, (void *)object->function);
HeapFree(GetProcessHeap(), 0, (void *)object->decl);
HeapFree(GetProcessHeap(), 0, (void *)object->data);
HeapFree(GetProcessHeap(), 0, (void *)object); HeapFree(GetProcessHeap(), 0, (void *)object);
VertexShaders[Handle - VS_HIGHESTFIXEDFXF] = NULL; VertexShaders[Handle - VS_HIGHESTFIXEDFXF] = NULL;
return D3D_OK; return D3D_OK;
} }
#define VERTEX_SHADER(Handle) ((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(VertexShaders) / sizeof(VERTEXSHADER8*)) ? NULL : VertexShaders[Handle]) : VertexShaders[Handle - VS_HIGHESTFIXEDFXF])
HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) { HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
ICOM_THIS(IDirect3DDevice8Impl,iface); ICOM_THIS(IDirect3DDevice8Impl,iface);
VERTEXSHADER8* object; VERTEXSHADER8* object;
DWORD Handle = This->UpdateStateBlock->VertexShader; DWORD Handle = This->UpdateStateBlock->VertexShader;
/* FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This); */ /* FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This); */
if (Register + ConstantCount > VSHADER_MAX_CONSTANTS) { if (Register + ConstantCount > D3D8_VSHADER_MAX_CONSTANTS) {
return D3DERR_INVALIDCALL; return D3DERR_INVALIDCALL;
} }
object = VERTEX_SHADER(Handle); object = VERTEX_SHADER(Handle);
@ -3261,7 +3459,7 @@ HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8
FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This); FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This);
return D3DERR_INVALIDCALL; return D3DERR_INVALIDCALL;
} }
memcpy(object->data->C + Register, pConstantData, ConstantCount * sizeof(SHADER8Vector)); memcpy(object->data->C + Register, pConstantData, ConstantCount * sizeof(D3DSHADERVECTOR));
return D3D_OK; return D3D_OK;
} }
@ -3272,7 +3470,7 @@ HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8
FIXME("(%p) : VertexShader_GetConstant not fully supported yet\n", This); FIXME("(%p) : VertexShader_GetConstant not fully supported yet\n", This);
if (Register + ConstantCount > VSHADER_MAX_CONSTANTS) { if (Register + ConstantCount > D3D8_VSHADER_MAX_CONSTANTS) {
return D3DERR_INVALIDCALL; return D3DERR_INVALIDCALL;
} }
object = VERTEX_SHADER(Handle); object = VERTEX_SHADER(Handle);
@ -3282,7 +3480,7 @@ HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8
if (NULL == object->data) { /* temporary while datas not supported */ if (NULL == object->data) { /* temporary while datas not supported */
return D3DERR_INVALIDCALL; return D3DERR_INVALIDCALL;
} }
memcpy(pConstantData, object->data->C + Register, ConstantCount * sizeof(SHADER8Vector)); memcpy(pConstantData, object->data->C + Register, ConstantCount * sizeof(D3DSHADERVECTOR));
return D3D_OK; return D3D_OK;
} }

37
dlls/d3d8/directx.c
View File

@ -159,7 +159,7 @@ UINT WINAPI IDirect3D8Impl_GetAdapterModeCount (LPDIRECT3D8 iface,
FIXME("Adapter not primary display\n"); FIXME("Adapter not primary display\n");
} }
return D3D_OK; return 0;
} }
HRESULT WINAPI IDirect3D8Impl_EnumAdapterModes (LPDIRECT3D8 iface, HRESULT WINAPI IDirect3D8Impl_EnumAdapterModes (LPDIRECT3D8 iface,
@ -195,7 +195,8 @@ HRESULT WINAPI IDirect3D8Impl_EnumAdapterModes (LPDIRECT3D8 iface,
switch (bpp) { switch (bpp) {
case 8: pMode->Format = D3DFMT_R3G3B2; break; case 8: pMode->Format = D3DFMT_R3G3B2; break;
case 16: pMode->Format = D3DFMT_A4R4G4B4; break; /*case 16: pMode->Format = D3DFMT_A4R4G4B4; break;*/
case 16: pMode->Format = D3DFMT_R5G6B5; break;
case 24: pMode->Format = D3DFMT_R8G8B8; break; case 24: pMode->Format = D3DFMT_R8G8B8; break;
case 32: pMode->Format = D3DFMT_A8R8G8B8; break; case 32: pMode->Format = D3DFMT_A8R8G8B8; break;
default: pMode->Format = D3DFMT_UNKNOWN; default: pMode->Format = D3DFMT_UNKNOWN;
@ -232,7 +233,8 @@ HRESULT WINAPI IDirect3D8Impl_GetAdapterDisplayMode (LPDIRECT3D8 iface,
switch (bpp) { switch (bpp) {
case 8: pMode->Format = D3DFMT_R3G3B2; break; case 8: pMode->Format = D3DFMT_R3G3B2; break;
case 16: pMode->Format = D3DFMT_A4R4G4B4; break; case 16: pMode->Format = D3DFMT_R5G6B5; break;
/*case 16: pMode->Format = D3DFMT_A4R4G4B4; break;*/
case 24: pMode->Format = D3DFMT_R8G8B8; break; case 24: pMode->Format = D3DFMT_R8G8B8; break;
case 32: pMode->Format = D3DFMT_A8R8G8B8; break; case 32: pMode->Format = D3DFMT_A8R8G8B8; break;
default: pMode->Format = D3DFMT_UNKNOWN; default: pMode->Format = D3DFMT_UNKNOWN;
@ -242,7 +244,7 @@ HRESULT WINAPI IDirect3D8Impl_GetAdapterDisplayMode (LPDIRECT3D8 iface,
FIXME("Adapter not primary display\n"); FIXME("Adapter not primary display\n");
} }
TRACE("returning w:%d, h:%d, ref:%d, fmt:%d\n", pMode->Width, TRACE("returning w:%d, h:%d, ref:%d, fmt:%x\n", pMode->Width,
pMode->Height, pMode->RefreshRate, pMode->Format); pMode->Height, pMode->RefreshRate, pMode->Format);
return D3D_OK; return D3D_OK;
} }
@ -290,7 +292,7 @@ HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps (LPDIRECT3D8 iface,
/* NOTE: Most of the values here are complete garbage for now */ /* NOTE: Most of the values here are complete garbage for now */
pCaps->DeviceType = D3DDEVTYPE_HAL; /* Not quite true, but use h/w supported by opengl I suppose */ pCaps->DeviceType = (DeviceType == D3DDEVTYPE_HAL) ? D3DDEVTYPE_HAL : D3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
pCaps->AdapterOrdinal = Adapter; pCaps->AdapterOrdinal = Adapter;
pCaps->Caps = 0; pCaps->Caps = 0;
@ -367,7 +369,7 @@ HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps (LPDIRECT3D8 iface,
pCaps->MaxStreamStride = 1024; pCaps->MaxStreamStride = 1024;
pCaps->VertexShaderVersion = 01; pCaps->VertexShaderVersion = 01;
pCaps->MaxVertexShaderConst = 1; pCaps->MaxVertexShaderConst = D3D8_VSHADER_MAX_CONSTANTS;
pCaps->PixelShaderVersion = 01; pCaps->PixelShaderVersion = 01;
pCaps->MaxPixelShaderValue = 1.0; pCaps->MaxPixelShaderValue = 1.0;
@ -466,9 +468,8 @@ HRESULT WINAPI IDirect3D8Impl_CreateDevice (LPDIRECT3D8 iface,
return D3DERR_NOTAVAILABLE; return D3DERR_NOTAVAILABLE;
} }
} }
object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE); object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE);
if (NULL == object->visInfo) { if (NULL == object->glCtx) {
ERR("cannot create glxContext\n"); ERR("cannot create glxContext\n");
LEAVE_GL(); LEAVE_GL();
return D3DERR_NOTAVAILABLE; return D3DERR_NOTAVAILABLE;
@ -524,6 +525,8 @@ HRESULT WINAPI IDirect3D8Impl_CreateDevice (LPDIRECT3D8 iface,
*/ */
ENTER_GL(); ENTER_GL();
/*TRACE("hereeee. %x %x %x\n", object->display, object->win, object->glCtx);*/
if (glXMakeCurrent(object->display, object->win, object->glCtx) == False) { if (glXMakeCurrent(object->display, object->win, object->glCtx) == False) {
ERR("Error in setting current context (context %p drawable %ld)!\n", object->glCtx, object->win); ERR("Error in setting current context (context %p drawable %ld)!\n", object->glCtx, object->win);
} }
@ -555,18 +558,18 @@ HRESULT WINAPI IDirect3D8Impl_CreateDevice (LPDIRECT3D8 iface,
if (NULL == GL_Extensions) { if (NULL == GL_Extensions) {
ERR(" GL_Extensions returns NULL\n"); ERR(" GL_Extensions returns NULL\n");
} else { } else {
while (*GL_Extensions!=0x00) { while (*GL_Extensions != 0x00) {
const char *Start = GL_Extensions; const char *Start = GL_Extensions;
char ThisExtn[256]; char ThisExtn[256];
memset(ThisExtn, 0x00, sizeof(ThisExtn)); memset(ThisExtn, 0x00, sizeof(ThisExtn));
while (*GL_Extensions!=' ' && *GL_Extensions!=0x00) { while (*GL_Extensions != ' ' && *GL_Extensions != 0x00) {
GL_Extensions++; GL_Extensions++;
} }
memcpy(ThisExtn, Start, (GL_Extensions-Start)); memcpy(ThisExtn, Start, (GL_Extensions - Start));
TRACE (" %s\n", ThisExtn); TRACE (" %s\n", ThisExtn);
if (strcmp(ThisExtn, "GL_ARB_multitexture")==0) { if (strcmp(ThisExtn, "GL_ARB_multitexture") == 0) {
GLint gl_max_texture_units_arb; GLint gl_max_texture_units_arb;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max_texture_units_arb); glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max_texture_units_arb);
object->isMultiTexture = TRUE; object->isMultiTexture = TRUE;
@ -574,7 +577,7 @@ HRESULT WINAPI IDirect3D8Impl_CreateDevice (LPDIRECT3D8 iface,
TRACE("FOUND: Multitexture support - GL_MAX_TEXTURE_UNITS_ARB=%d\n", gl_max_texture_units_arb); TRACE("FOUND: Multitexture support - GL_MAX_TEXTURE_UNITS_ARB=%d\n", gl_max_texture_units_arb);
} }
if (*GL_Extensions==' ') GL_Extensions++; if (*GL_Extensions == ' ') GL_Extensions++;
} }
} }
@ -584,17 +587,17 @@ HRESULT WINAPI IDirect3D8Impl_CreateDevice (LPDIRECT3D8 iface,
if (NULL == GLX_Extensions) { if (NULL == GLX_Extensions) {
ERR(" GLX_Extensions returns NULL\n"); ERR(" GLX_Extensions returns NULL\n");
} else { } else {
while (*GLX_Extensions!=0x00) { while (*GLX_Extensions != 0x00) {
const char *Start = GLX_Extensions; const char *Start = GLX_Extensions;
char ThisExtn[256]; char ThisExtn[256];
memset(ThisExtn, 0x00, sizeof(ThisExtn)); memset(ThisExtn, 0x00, sizeof(ThisExtn));
while (*GLX_Extensions!=' ' && *GLX_Extensions!=0x00) { while (*GLX_Extensions != ' ' && *GLX_Extensions != 0x00) {
GLX_Extensions++; GLX_Extensions++;
} }
memcpy(ThisExtn, Start, (GLX_Extensions-Start)); memcpy(ThisExtn, Start, (GLX_Extensions - Start));
TRACE (" %s\n", ThisExtn); TRACE (" %s\n", ThisExtn);
if (*GLX_Extensions==' ') GLX_Extensions++; if (*GLX_Extensions == ' ') GLX_Extensions++;
} }
} }

448
dlls/d3d8/shader.c
View File

@ -30,163 +30,214 @@
WINE_DEFAULT_DEBUG_CHANNEL(d3d); WINE_DEFAULT_DEBUG_CHANNEL(d3d);
typedef void (*shader_fct0_t)(void); /**
typedef void (*shader_fct1_t)(SHADER8Vector*); * DirectX9 SDK download
typedef void (*shader_fct2_t)(SHADER8Vector*,SHADER8Vector*); * http://msdn.microsoft.com/library/default.asp?url=/downloads/list/directx.asp
typedef void (*shader_fct3_t)(SHADER8Vector*,SHADER8Vector*,SHADER8Vector*); *
typedef void (*shader_fct4_t)(SHADER8Vector*,SHADER8Vector*,SHADER8Vector*,SHADER8Vector*); * Exploring D3DX
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx07162002.asp
*
* Using Vertex Shaders
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx02192001.asp
*
* Dx9 New
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/whatsnew.asp
*
* Dx9 Shaders
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/VertexShader2_0.asp
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/Instructions/Instructions.asp
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexDeclaration/VertexDeclaration.asp
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader3_0/VertexShader3_0.asp
*
* Dx9 D3DX
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/advancedtopics/VertexPipe/matrixstack/matrixstack.asp
*
* FVF
* http://msdn.microsoft.com/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexFormats/vformats.asp
*/
/* typedef void (*shader_fct_t)();
typedef union shader_fct {
shader_fct0_t fct0;
shader_fct1_t fct1;
shader_fct2_t fct2;
shader_fct3_t fct3;
shader_fct4_t fct4;
} shader_fct;
*/
typedef void (*shader_fct)();
typedef struct shader_opcode { typedef struct SHADER_OPCODE {
CONST BYTE opcode; CONST BYTE opcode;
const char* name; const char* name;
CONST UINT num_params; CONST UINT num_params;
shader_fct soft_fct; shader_fct_t soft_fct;
/* } SHADER_OPCODE;
union {
shader_fct0_t fct0;
shader_fct1_t fct1;
shader_fct2_t fct2;
shader_fct3_t fct3;
shader_fct4_t fct4;
} shader_fct;
*/
} shader_opcode;
typedef struct vshader_input_data { /** Vertex Shader Declaration data types tokens */
/*SHADER8Vector V[16];//0-15*/ static CONST char* VertexShaderDeclDataTypes [] = {
SHADER8Vector V[16]; "D3DVSDT_FLOAT1",
} vshader_input_data; "D3DVSDT_FLOAT2",
"D3DVSDT_FLOAT3",
"D3DVSDT_FLOAT4",
"D3DVSDT_D3DCOLOR",
"D3DVSDT_UBYTE4",
"D3DVSDT_SHORT2",
"D3DVSDT_SHORT4",
NULL
};
typedef struct vshader_output_data { static CONST char* VertexShaderDeclRegister [] = {
SHADER8Vector oPos; "D3DVSDE_POSITION",
/*SHADER8Vector oD[2];//0-1*/ "D3DVSDE_BLENDWEIGHT",
SHADER8Vector oD[2]; "D3DVSDE_BLENDINDICES",
/*SHADER8Vector oT[4];//0-3*/ "D3DVSDE_NORMAL",
SHADER8Vector oT[4]; "D3DVSDE_PSIZE",
/*SHADER8Scalar oFog;*/ "D3DVSDE_DIFFUSE",
/*SHADER8Scalar oPts;*/ "D3DVSDE_SPECULAR",
SHADER8Vector oFog; "D3DVSDE_TEXCOORD0",
SHADER8Vector oPts; "D3DVSDE_TEXCOORD1",
} vshader_output_data; "D3DVSDE_TEXCOORD2",
"D3DVSDE_TEXCOORD3",
"D3DVSDE_TEXCOORD4",
"D3DVSDE_TEXCOORD5",
"D3DVSDE_TEXCOORD6",
"D3DVSDE_TEXCOORD7",
"D3DVSDE_POSITION2",
"D3DVSDE_NORMAL2",
NULL
};
/******************************* /*******************************
* vshader functions software VM * vshader functions software VM
*/ */
void vshader_add(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_add(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = s0->x + s1->x; d->x = s0->x + s1->x;
d->y = s0->y + s1->y; d->y = s0->y + s1->y;
d->z = s0->z + s1->z; d->z = s0->z + s1->z;
d->w = s0->w + s1->w; d->w = s0->w + s1->w;
} }
void vshader_dp3(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_dp3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z; d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z;
} }
void vshader_dp4(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_dp4(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z + s0->w * s1->w; d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z + s0->w * s1->w;
/*
DPRINTF("executing dp4: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w);
*/
} }
void vshader_dst(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_dst(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = 1; d->x = 1.0f;
d->y = s0->y * s1->y; d->y = s0->y * s1->y;
d->z = s0->z; d->z = s0->z;
d->w = s1->w; d->w = s1->w;
/*
DPRINTF("executing dst: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w);
*/
} }
void vshader_expp(SHADER8Vector* d, SHADER8Vector* s0) { void vshader_expp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
float tmp_f = floorf(s0->w); float tmp_f = floorf(s0->w);
d->x = pow(2, tmp_f); d->x = powf(2.0f, tmp_f);
d->y = s0->w - tmp_f; d->y = s0->w - tmp_f;
d->z = pow(2, s0->w); d->z = powf(2.0f, s0->w);
d->w = 1; d->w = 1.0f;
/*
DPRINTF("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w);
*/
} }
void vshader_lit(SHADER8Vector* d, SHADER8Vector* s0) { void vshader_lit(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
d->x = 1; d->x = 1.0f;
d->y = (0 < s0->x) ? s0->x : 0; d->y = (0.0f < s0->x) ? s0->x : 0.0f;
d->z = (0 < s0->x && 0 < s0->y) ? pow(s0->y, s0->w) : 0; d->z = (0.0f < s0->x && 0.0f < s0->y) ? powf(s0->y, s0->w) : 0.0f;
d->w = 1; d->w = 1.0f;
/*
DPRINTF("executing lit: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w);
*/
} }
void vshader_logp(SHADER8Vector* d, SHADER8Vector* s0) { void vshader_logp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
d->x = d->y = d->z = d->w = (0 != s0->w) ? log(fabsf(s0->w))/log(2) : HUGE; float tmp_f = fabsf(s0->w);
d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE;
} }
void vshader_mad(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1, SHADER8Vector* s2) { void vshader_mad(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2) {
d->x = s0->x * s1->x + s2->x; d->x = s0->x * s1->x + s2->x;
d->y = s0->y * s1->y + s2->y; d->y = s0->y * s1->y + s2->y;
d->z = s0->z * s1->z + s2->z; d->z = s0->z * s1->z + s2->z;
d->w = s0->w * s1->w + s2->w; d->w = s0->w * s1->w + s2->w;
} }
void vshader_max(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_max(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = (s0->x >= s1->x) ? s0->x : s1->x; d->x = (s0->x >= s1->x) ? s0->x : s1->x;
d->y = (s0->y >= s1->y) ? s0->y : s1->y; d->y = (s0->y >= s1->y) ? s0->y : s1->y;
d->z = (s0->z >= s1->z) ? s0->z : s1->z; d->z = (s0->z >= s1->z) ? s0->z : s1->z;
d->w = (s0->w >= s1->w) ? s0->w : s1->w; d->w = (s0->w >= s1->w) ? s0->w : s1->w;
} }
void vshader_min(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_min(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = (s0->x < s1->x) ? s0->x : s1->x; d->x = (s0->x < s1->x) ? s0->x : s1->x;
d->y = (s0->y < s1->y) ? s0->y : s1->y; d->y = (s0->y < s1->y) ? s0->y : s1->y;
d->z = (s0->z < s1->z) ? s0->z : s1->z; d->z = (s0->z < s1->z) ? s0->z : s1->z;
d->w = (s0->w < s1->w) ? s0->w : s1->w; d->w = (s0->w < s1->w) ? s0->w : s1->w;
} }
void vshader_mov(SHADER8Vector* d, SHADER8Vector* s0) { void vshader_mov(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
d->x = s0->x; d->x = s0->x;
d->y = s0->y; d->y = s0->y;
d->z = s0->z; d->z = s0->z;
d->w = s0->w; d->w = s0->w;
/*
DPRINTF("executing mov: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w);
*/
} }
void vshader_mul(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_mul(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = s0->x * s1->x; d->x = s0->x * s1->x;
d->y = s0->y * s1->y; d->y = s0->y * s1->y;
d->z = s0->z * s1->z; d->z = s0->z * s1->z;
d->w = s0->w * s1->w; d->w = s0->w * s1->w;
/*
DPRINTF("executing mul: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w);
*/
} }
void vshader_nop(void) { void vshader_nop(void) {
/* NOPPPP ahhh too easy ;) */ /* NOPPPP ahhh too easy ;) */
} }
void vshader_rcp(SHADER8Vector* d, SHADER8Vector* s0) { void vshader_rcp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
d->x = d->y = d->z = d->w = (0 == s0->w) ? HUGE : 1 / s0->w; d->x = d->y = d->z = d->w = (0.0f == s0->w) ? HUGE : 1.0f / s0->w;
} }
void vshader_rsq(SHADER8Vector* d, SHADER8Vector* s0) { void vshader_rsq(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
d->x = d->y = d->z = d->w = (0 == s0->w) ? HUGE : 1 / sqrt(fabsf(s0->w)); float tmp_f = fabsf(s0->w);
d->x = d->y = d->z = d->w = (0.0f == tmp_f) ? HUGE : ((1.0f != tmp_f) ? 1.0f / sqrtf(tmp_f) : 1.0f);
} }
void vshader_sge(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_sge(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = (s0->x >= s1->x) ? 1 : 0; d->x = (s0->x >= s1->x) ? 1.0f : 0.0f;
d->y = (s0->y >= s1->y) ? 1 : 0; d->y = (s0->y >= s1->y) ? 1.0f : 0.0f;
d->z = (s0->z >= s1->z) ? 1 : 0; d->z = (s0->z >= s1->z) ? 1.0f : 0.0f;
d->w = (s0->w >= s1->w) ? 1 : 0; d->w = (s0->w >= s1->w) ? 1.0f : 0.0f;
} }
void vshader_slt(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_slt(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = (s0->x < s1->x) ? 1 : 0; d->x = (s0->x < s1->x) ? 1.0f : 0.0f;
d->y = (s0->y < s1->y) ? 1 : 0; d->y = (s0->y < s1->y) ? 1.0f : 0.0f;
d->z = (s0->z < s1->z) ? 1 : 0; d->z = (s0->z < s1->z) ? 1.0f : 0.0f;
d->w = (s0->w < s1->w) ? 1 : 0; d->w = (s0->w < s1->w) ? 1.0f : 0.0f;
} }
void vshader_sub(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) { void vshader_sub(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
d->x = s0->x - s1->x; d->x = s0->x - s1->x;
d->y = s0->y - s1->y; d->y = s0->y - s1->y;
d->z = s0->z - s1->z; d->z = s0->z - s1->z;
@ -195,10 +246,8 @@ void vshader_sub(SHADER8Vector* d, SHADER8Vector* s0, SHADER8Vector* s1) {
/** /**
* log, exp, frc, m*x* seems to be macros ins ... to see * log, exp, frc, m*x* seems to be macros ins ... to see
*
* @TODO: find this fucking really opcodes values
*/ */
static CONST shader_opcode vshader_ins [] = { static CONST SHADER_OPCODE vshader_ins [] = {
{D3DSIO_MOV, "mov", 2, vshader_mov}, {D3DSIO_MOV, "mov", 2, vshader_mov},
{D3DSIO_MAX, "max", 3, vshader_max}, {D3DSIO_MAX, "max", 3, vshader_max},
{D3DSIO_MIN, "min", 3, vshader_min}, {D3DSIO_MIN, "min", 3, vshader_min},
@ -221,8 +270,9 @@ static CONST shader_opcode vshader_ins [] = {
}; };
const shader_opcode* vshader_program_get_opcode(const DWORD code) { const SHADER_OPCODE* vshader_program_get_opcode(const DWORD code) {
DWORD i = 0; DWORD i = 0;
/** TODO: use dichotomic search */
while (NULL != vshader_ins[i].name) { while (NULL != vshader_ins[i].name) {
if ((code & D3DSI_OPCODE_MASK) == vshader_ins[i].opcode) { if ((code & D3DSI_OPCODE_MASK) == vshader_ins[i].opcode) {
return &vshader_ins[i]; return &vshader_ins[i];
@ -307,7 +357,7 @@ void vshader_program_dump_param(const DWORD param, int input) {
*/ */
DWORD vshader_program_parse(VERTEXSHADER8* vshader) { DWORD vshader_program_parse(VERTEXSHADER8* vshader) {
const DWORD* pToken = vshader->function; const DWORD* pToken = vshader->function;
const shader_opcode* curOpcode = NULL; const SHADER_OPCODE* curOpcode = NULL;
DWORD len = 0; DWORD len = 0;
DWORD i; DWORD i;
@ -339,7 +389,7 @@ DWORD vshader_program_parse(VERTEXSHADER8* vshader) {
DPRINTF("\n"); DPRINTF("\n");
} }
} }
vshader->functionLength = len * sizeof(DWORD); vshader->functionLength = (len + 1) * sizeof(DWORD);
} else { } else {
vshader->functionLength = 1; /* no Function defined use fixed function vertex processing */ vshader->functionLength = 1; /* no Function defined use fixed function vertex processing */
} }
@ -347,8 +397,8 @@ DWORD vshader_program_parse(VERTEXSHADER8* vshader) {
} }
BOOL vshader_program_execute_HAL(VERTEXSHADER8* vshader, BOOL vshader_program_execute_HAL(VERTEXSHADER8* vshader,
const vshader_input_data* input, VSHADERINPUTDATA8* input,
vshader_output_data* output) { VSHADEROUTPUTDATA8* output) {
/** /**
* TODO: use the NV_vertex_program (or 1_1) extension * TODO: use the NV_vertex_program (or 1_1) extension
* and specifics vendors (ARB_vertex_program??) variants for it * and specifics vendors (ARB_vertex_program??) variants for it
@ -356,51 +406,73 @@ BOOL vshader_program_execute_HAL(VERTEXSHADER8* vshader,
return TRUE; return TRUE;
} }
#define TRACE_VECTOR(name) DPRINTF( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w)
BOOL vshader_program_execute_SW(VERTEXSHADER8* vshader, BOOL vshader_program_execute_SW(VERTEXSHADER8* vshader,
vshader_input_data* input, VSHADERINPUTDATA8* input,
vshader_output_data* output) { VSHADEROUTPUTDATA8* output) {
/** Vertex Shader Temporary Registers */ /** Vertex Shader Temporary Registers */
SHADER8Vector R[12]; D3DSHADERVECTOR R[12];
/*SHADER8Scalar A0;*/ /*D3DSHADERSCALAR A0;*/
SHADER8Vector A[1]; D3DSHADERVECTOR A[1];
/** temporary Vector for modifier management */ /** temporary Vector for modifier management */
SHADER8Vector d; D3DSHADERVECTOR d;
SHADER8Vector s[3]; D3DSHADERVECTOR s[3];
/** parser datas */ /** parser datas */
const DWORD* pToken = vshader->function; const DWORD* pToken = vshader->function;
const shader_opcode* curOpcode = NULL; const SHADER_OPCODE* curOpcode = NULL;
/** functions parameters */ /** functions parameters */
SHADER8Vector* p[4]; D3DSHADERVECTOR* p[4];
SHADER8Vector* p_send[4]; D3DSHADERVECTOR* p_send[4];
DWORD i; DWORD i;
memset(R, 0, 12 * sizeof(D3DSHADERVECTOR));
/* vshader_program_parse(vshader); */
/*
TRACE_VECTOR(vshader->data->C[0]);
TRACE_VECTOR(vshader->data->C[1]);
TRACE_VECTOR(vshader->data->C[2]);
TRACE_VECTOR(vshader->data->C[3]);
TRACE_VECTOR(vshader->data->C[4]);
TRACE_VECTOR(vshader->data->C[5]);
TRACE_VECTOR(input->V[D3DVSDE_POSITION]);
TRACE_VECTOR(input->V[D3DVSDE_BLENDWEIGHT]);
TRACE_VECTOR(input->V[D3DVSDE_BLENDINDICES]);
TRACE_VECTOR(input->V[D3DVSDE_NORMAL]);
TRACE_VECTOR(input->V[D3DVSDE_PSIZE]);
TRACE_VECTOR(input->V[D3DVSDE_DIFFUSE]);
TRACE_VECTOR(input->V[D3DVSDE_SPECULAR]);
TRACE_VECTOR(input->V[D3DVSDE_TEXCOORD0]);
TRACE_VECTOR(input->V[D3DVSDE_TEXCOORD1]);
*/
/* the first dword is the version tag */ /* the first dword is the version tag */
/* TODO: parse it */ /* TODO: parse it */
++pToken;
while (D3DVS_END() != *pToken) { while (D3DVS_END() != *pToken) {
curOpcode = vshader_program_get_opcode(*pToken); curOpcode = vshader_program_get_opcode(*pToken);
++pToken; ++pToken;
if (NULL == curOpcode) { if (NULL == curOpcode) {
/* unkown current opcode ... */ /* unkown current opcode ... */
while (*pToken & 0x80000000) { while (*pToken & 0x80000000) {
DPRINTF("unrecognized opcode: %08lX\n", *pToken); DPRINTF("unrecognized opcode: pos=%d token=%08lX\n", pToken - vshader->function, *pToken);
++pToken; ++pToken;
} }
/*return FALSE;*/ /*return FALSE;*/
} else { } else {
if (curOpcode->num_params > 0) { if (curOpcode->num_params > 0) {
/*DPRINTF(">> execting opcode: pos=%d opcode_name=%s token=%08lX\n", pToken - vshader->function, curOpcode->name, *pToken);*/
for (i = 0; i < curOpcode->num_params; ++i) { for (i = 0; i < curOpcode->num_params; ++i) {
DWORD reg = pToken[i] & 0x00001FFF; DWORD reg = pToken[i] & 0x00001FFF;
DWORD regtype = ((pToken[i] & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT); DWORD regtype = ((pToken[i] & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
switch (regtype << D3DSP_REGTYPE_SHIFT) { switch (regtype << D3DSP_REGTYPE_SHIFT) {
case D3DSPR_TEMP: case D3DSPR_TEMP:
/*DPRINTF("p[%d]=R[%d]\n", i, reg);*/
p[i] = &R[reg]; p[i] = &R[reg];
break; break;
case D3DSPR_INPUT: case D3DSPR_INPUT:
/*DPRINTF("p[%d]=V[%s]\n", i, VertexShaderDeclRegister[reg]);*/
p[i] = &input->V[reg]; p[i] = &input->V[reg];
break; break;
case D3DSPR_CONST: case D3DSPR_CONST:
@ -411,8 +483,11 @@ BOOL vshader_program_execute_SW(VERTEXSHADER8* vshader,
} }
break; break;
case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/ case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
if (0 != reg) if (0 != reg) {
ERR("cannot handle address registers != a0"); ERR("cannot handle address registers != a0, forcing use of a0\n");
reg = 0;
}
/*DPRINTF("p[%d]=A[%d]\n", i, reg);*/
p[i] = &A[reg]; p[i] = &A[reg];
break; break;
case D3DSPR_RASTOUT: case D3DSPR_RASTOUT:
@ -429,29 +504,35 @@ BOOL vshader_program_execute_SW(VERTEXSHADER8* vshader,
} }
break; break;
case D3DSPR_ATTROUT: case D3DSPR_ATTROUT:
/*DPRINTF("p[%d]=oD[%d]\n", i, reg);*/
p[i] = &output->oD[reg]; p[i] = &output->oD[reg];
break; break;
case D3DSPR_TEXCRDOUT: case D3DSPR_TEXCRDOUT:
/*DPRINTF("p[%d]=oT[%d]\n", i, reg);*/
p[i] = &output->oT[reg]; p[i] = &output->oT[reg];
break; break;
default: default:
break; break;
} }
if (i > 1) { /* input reg */ if (i > 0) { /* input reg */
DWORD swizzle = (pToken[i] & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT; DWORD swizzle = (pToken[i] & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
UINT isNegative = ((*pToken & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG);
if (!isNegative && (D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) {
/*DPRINTF("p[%d] not swizzled\n", i);*/
p_send[i] = p[i];
} else {
DWORD swizzle_x = swizzle & 0x03; DWORD swizzle_x = swizzle & 0x03;
DWORD swizzle_y = (swizzle >> 2) & 0x03; DWORD swizzle_y = (swizzle >> 2) & 0x03;
DWORD swizzle_z = (swizzle >> 4) & 0x03; DWORD swizzle_z = (swizzle >> 4) & 0x03;
DWORD swizzle_w = (swizzle >> 6) & 0x03; DWORD swizzle_w = (swizzle >> 6) & 0x03;
if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) { /*DPRINTF("p[%d] swizzled\n", i);*/
p_send[i] = p[i];
} else {
float* tt = (float*) p[i]; float* tt = (float*) p[i];
s[i].x = tt[swizzle_x]; s[i].x = (isNegative) ? -tt[swizzle_x] : tt[swizzle_x];
s[i].y = tt[swizzle_y]; s[i].y = (isNegative) ? -tt[swizzle_y] : tt[swizzle_y];
s[i].z = tt[swizzle_z]; s[i].z = (isNegative) ? -tt[swizzle_z] : tt[swizzle_z];
s[i].w = tt[swizzle_w]; s[i].w = (isNegative) ? -tt[swizzle_w] : tt[swizzle_w];
p_send[i] = &s[i]; p_send[i] = &s[i];
} }
} else { /* output reg */ } else { /* output reg */
@ -492,6 +573,19 @@ BOOL vshader_program_execute_SW(VERTEXSHADER8* vshader,
if (pToken[0] & D3DSP_WRITEMASK_3) p[0]->w = d.w; if (pToken[0] & D3DSP_WRITEMASK_3) p[0]->w = d.w;
} }
/*
TRACE_VECTOR(output->oPos);
TRACE_VECTOR(output->oD[0]);
TRACE_VECTOR(output->oD[1]);
TRACE_VECTOR(output->oT[0]);
TRACE_VECTOR(output->oT[1]);
TRACE_VECTOR(R[0]);
TRACE_VECTOR(R[1]);
TRACE_VECTOR(R[2]);
TRACE_VECTOR(R[3]);
TRACE_VECTOR(R[4]);
*/
/* to next opcode token */ /* to next opcode token */
pToken += curOpcode->num_params; pToken += curOpcode->num_params;
} }
@ -503,41 +597,6 @@ BOOL vshader_program_execute_SW(VERTEXSHADER8* vshader,
* Vertex Shader Declaration Parser First draft ... * Vertex Shader Declaration Parser First draft ...
*/ */
/** Vertex Shader Declaration data types tokens */
static CONST char* VertexShaderDeclDataTypes [] = {
"D3DVSDT_FLOAT1",
"D3DVSDT_FLOAT2",
"D3DVSDT_FLOAT3",
"D3DVSDT_FLOAT4",
"D3DVSDT_D3DCOLOR",
"D3DVSDT_UBYTE4",
"D3DVSDT_SHORT2",
"D3DVSDT_SHORT4",
NULL
};
static CONST char* VertexShaderDeclRegister [] = {
"D3DVSDE_POSITION",
"D3DVSDE_BLENDWEIGHT",
"D3DVSDE_BLENDINDICES",
"D3DVSDE_NORMAL",
"D3DVSDE_PSIZE",
"D3DVSDE_DIFFUSE",
"D3DVSDE_SPECULAR",
"D3DVSDE_TEXCOORD0",
"D3DVSDE_TEXCOORD1",
"D3DVSDE_TEXCOORD2",
"D3DVSDE_TEXCOORD3",
"D3DVSDE_TEXCOORD4",
"D3DVSDE_TEXCOORD5",
"D3DVSDE_TEXCOORD6",
"D3DVSDE_TEXCOORD7",
"D3DVSDE_POSITION2",
"D3DVSDE_NORMAL2",
NULL
};
/** todo check decl validity */ /** todo check decl validity */
DWORD vshader_decl_parse_token(const DWORD* pToken) { DWORD vshader_decl_parse_token(const DWORD* pToken) {
const DWORD token = *pToken; const DWORD token = *pToken;
@ -622,6 +681,7 @@ DWORD vshader_decl_parse(VERTEXSHADER8* vshader) {
DWORD token; DWORD token;
DWORD tokenlen; DWORD tokenlen;
DWORD tokentype; DWORD tokentype;
DWORD tex = D3DFVF_TEX0;
while (D3DVSD_END() != *pToken) { while (D3DVSD_END() != *pToken) {
token = *pToken; token = *pToken;
@ -632,55 +692,107 @@ DWORD vshader_decl_parse(VERTEXSHADER8* vshader) {
if (D3DVSD_TOKEN_STREAMDATA == tokentype && 0 == (0x10000000 & tokentype)) { if (D3DVSD_TOKEN_STREAMDATA == tokentype && 0 == (0x10000000 & tokentype)) {
DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
switch (reg) { switch (reg) {
case D3DVSDE_POSITION: fvf |= D3DFVF_XYZ; break; case D3DVSDE_POSITION:
switch (type) {
case D3DVSDT_FLOAT3: fvf |= D3DFVF_XYZ; break;
case D3DVSDT_FLOAT4: fvf |= D3DFVF_XYZRHW; break;
default: /** errooooorr what to do ? */
ERR("Error in VertexShader declaration of D3DVSDE_POSITION register: unsupported type %lu\n", type);
}
break;
case D3DVSDE_BLENDWEIGHT: case D3DVSDE_BLENDWEIGHT:
switch (type) { switch (type) {
case D3DVSDT_FLOAT1: fvf |= D3DFVF_XYZB1; break; case D3DVSDT_FLOAT1: fvf |= D3DFVF_XYZB1; break;
case D3DVSDT_FLOAT2: fvf |= D3DFVF_XYZB2; break; case D3DVSDT_FLOAT2: fvf |= D3DFVF_XYZB2; break;
case D3DVSDT_FLOAT3: fvf |= D3DFVF_XYZB3; break; case D3DVSDT_FLOAT3: fvf |= D3DFVF_XYZB3; break;
case D3DVSDT_FLOAT4: fvf |= D3DFVF_XYZB4; break; case D3DVSDT_FLOAT4: fvf |= D3DFVF_XYZB4; break;
default: default: /** errooooorr what to do ? */
/** errooooorr what to do ? */
ERR("Error in VertexShader declaration of D3DVSDE_BLENDWEIGHT register: unsupported type %lu\n", type); ERR("Error in VertexShader declaration of D3DVSDE_BLENDWEIGHT register: unsupported type %lu\n", type);
} }
break; break;
case D3DVSDE_BLENDINDICES: fvf |= D3DFVF_LASTBETA_UBYTE4; break; case D3DVSDE_BLENDINDICES: /* seem to be B5 as said in MSDN Dx9SDK ?? */
case D3DVSDE_NORMAL: fvf |= D3DFVF_NORMAL; break; switch (type) {
case D3DVSDE_PSIZE: fvf |= D3DFVF_PSIZE; break; case D3DVSDT_UBYTE4: fvf |= D3DFVF_LASTBETA_UBYTE4; break;
case D3DVSDE_DIFFUSE: fvf |= D3DFVF_DIFFUSE; break; default: /** errooooorr what to do ? */
case D3DVSDE_SPECULAR: fvf |= D3DFVF_SPECULAR; break; ERR("Error in VertexShader declaration of D3DVSDE_BLENDINDINCES register: unsupported type %lu\n", type);
case D3DVSDE_TEXCOORD0: fvf |= D3DFVF_TEX1; break; }
case D3DVSDE_TEXCOORD1: fvf |= D3DFVF_TEX2; break; break;
case D3DVSDE_TEXCOORD2: fvf |= D3DFVF_TEX3; break;
case D3DVSDE_TEXCOORD3: fvf |= D3DFVF_TEX4; break; case D3DVSDE_NORMAL: /* TODO: only FLOAT3 supported ... another choice possible ? */
case D3DVSDE_TEXCOORD4: fvf |= D3DFVF_TEX5; break; switch (type) {
case D3DVSDE_TEXCOORD5: fvf |= D3DFVF_TEX6; break; case D3DVSDT_FLOAT3: fvf |= D3DFVF_NORMAL; break;
case D3DVSDE_TEXCOORD6: fvf |= D3DFVF_TEX7; break; default: /** errooooorr what to do ? */
case D3DVSDE_TEXCOORD7: fvf |= D3DFVF_TEX8; break; ERR("Error in VertexShader declaration of D3DVSDE_NORMAL register: unsupported type %lu\n", type);
}
break;
case D3DVSDE_PSIZE: /* TODO: only FLOAT1 supported ... another choice possible ? */
switch (type) {
case D3DVSDT_FLOAT1: fvf |= D3DFVF_PSIZE; break;
default: /** errooooorr what to do ? */
ERR("Error in VertexShader declaration of D3DVSDE_PSIZE register: unsupported type %lu\n", type);
}
break;
case D3DVSDE_DIFFUSE: /* TODO: only D3DCOLOR supported */
switch (type) {
case D3DVSDT_D3DCOLOR: fvf |= D3DFVF_DIFFUSE; break;
default: /** errooooorr what to do ? */
ERR("Error in VertexShader declaration of D3DVSDE_DIFFUSE register: unsupported type %lu\n", type);
}
break;
case D3DVSDE_SPECULAR: /* TODO: only D3DCOLOR supported */
switch (type) {
case D3DVSDT_D3DCOLOR: fvf |= D3DFVF_SPECULAR; break;
default: /** errooooorr what to do ? */
ERR("Error in VertexShader declaration of D3DVSDE_SPECULAR register: unsupported type %lu\n", type);
}
break;
/**
* TODO: for TEX* only FLOAT2 supported
* by default using texture type info
*/
case D3DVSDE_TEXCOORD0: tex = max(tex, D3DFVF_TEX1); break;
case D3DVSDE_TEXCOORD1: tex = max(tex, D3DFVF_TEX2); break;
case D3DVSDE_TEXCOORD2: tex = max(tex, D3DFVF_TEX3); break;
case D3DVSDE_TEXCOORD3: tex = max(tex, D3DFVF_TEX4); break;
case D3DVSDE_TEXCOORD4: tex = max(tex, D3DFVF_TEX5); break;
case D3DVSDE_TEXCOORD5: tex = max(tex, D3DFVF_TEX6); break;
case D3DVSDE_TEXCOORD6: tex = max(tex, D3DFVF_TEX7); break;
case D3DVSDE_TEXCOORD7: tex = max(tex, D3DFVF_TEX8); break;
case D3DVSDE_POSITION2: /* maybe D3DFVF_XYZRHW instead D3DFVF_XYZ (of D3DVDE_POSITION) ... to see */ case D3DVSDE_POSITION2: /* maybe D3DFVF_XYZRHW instead D3DFVF_XYZ (of D3DVDE_POSITION) ... to see */
case D3DVSDE_NORMAL2: /* FIXME i don't know what to do here ;( */ case D3DVSDE_NORMAL2: /* FIXME i don't know what to do here ;( */
FIXME("[%lu] registers in VertexShader declaration not supported yet (token:0x%08lx)\n", reg, token); FIXME("[%lu] registers in VertexShader declaration not supported yet (token:0x%08lx)\n", reg, token);
break; break;
} }
/*TRACE("VertexShader declaration define %x as current FVF\n", fvf);*/
} }
len += tokenlen; len += tokenlen;
pToken += tokenlen; pToken += tokenlen;
} }
if (tex > 0) {
/*TRACE("VertexShader declaration define %x as texture level\n", tex);*/
fvf |= tex;
}
/* here D3DVSD_END() */ /* here D3DVSD_END() */
len += vshader_decl_parse_token(pToken); len += vshader_decl_parse_token(pToken);
if (NULL == vshader->function) vshader->fvf = fvf; vshader->fvf = fvf;
vshader->declLength = len * sizeof(DWORD); vshader->declLength = len * sizeof(DWORD);
return len * sizeof(DWORD); return len * sizeof(DWORD);
} }
HRESULT WINAPI ValidateVertexShader(void) { BOOL WINAPI ValidateVertexShader(LPVOID what, LPVOID toto) {
FIXME("(void): stub\n"); FIXME("(void): stub: %p\n", what);
return 0; return TRUE;
} }
HRESULT WINAPI ValidatePixelShader(void) { BOOL WINAPI ValidatePixelShader(LPVOID what, LPVOID toto) {
FIXME("(void): stub\n"); FIXME("(void): stub: %p\n", what);
return 0; return TRUE;
} }

30
include/d3d8.h
View File

@ -66,37 +66,37 @@
DEFINE_GUID(IID_IDirect3D8, 0x1DD9E8DA,0x1C77,0x4D40,0xB0,0xCF,0x98,0xFE,0xFD,0xFF,0x95,0x12); DEFINE_GUID(IID_IDirect3D8, 0x1DD9E8DA,0x1C77,0x4D40,0xB0,0xCF,0x98,0xFE,0xFD,0xFF,0x95,0x12);
typedef struct IDirect3D8 IDirect3D8, *LPDIRECT3D8; typedef struct IDirect3D8 IDirect3D8, *LPDIRECT3D8;
DEFINE_GUID(IID_IDirect3DDevice8, 0X7385E5DF,0X8FE8,0X41D5,0X86,0XB6,0XD7,0XB4,0X85,0X47,0XB6,0XCF); DEFINE_GUID(IID_IDirect3DDevice8, 0x7385E5DF,0x8FE8,0x41D5,0x86,0xB6,0xD7,0xB4,0x85,0x47,0xB6,0xCF);
typedef struct IDirect3DDevice8 IDirect3DDevice8, *LPDIRECT3DDEVICE8; typedef struct IDirect3DDevice8 IDirect3DDevice8, *LPDIRECT3DDEVICE8;
DEFINE_GUID(IID_IDirect3DResource8, 0X1B36BB7B,0X09B7,0X410A,0XB4,0X45,0X7D,0X14,0X30,0XD7,0XB3,0X3F); DEFINE_GUID(IID_IDirect3DResource8, 0x1B36BB7B,0x09B7,0x410A,0xB4,0x45,0x7D,0x14,0x30,0xD7,0xB3,0x3F);
typedef struct IDirect3DResource8 IDirect3DResource8, *LPDIRECT3DRESOURCE8, *PDIRECT3DRESOURCE8; typedef struct IDirect3DResource8 IDirect3DResource8, *LPDIRECT3DRESOURCE8, *PDIRECT3DRESOURCE8;
DEFINE_GUID(IID_IDirect3DVertexBuffer8, 0X8AEEEAC7,0X05F9,0X44D4,0XB5,0X91,0X00,0X0B,0X0D,0XF1,0XCB,0X95); DEFINE_GUID(IID_IDirect3DVertexBuffer8, 0x8AEEEAC7,0x05F9,0x44D4,0xB5,0x91,0x00,0x0B,0x0D,0xF1,0xCB,0x95);
typedef struct IDirect3DVertexBuffer8 IDirect3DVertexBuffer8, *LPDIRECT3DVERTEXBUFFER8, *PDIRECT3DVERTEXBUFFER8; typedef struct IDirect3DVertexBuffer8 IDirect3DVertexBuffer8, *LPDIRECT3DVERTEXBUFFER8, *PDIRECT3DVERTEXBUFFER8;
DEFINE_GUID(IID_IDirect3DVolume8, 0XBD7349F5,0X14F1,0X42E4,0X9C,0X79,0X97,0X23,0X80,0XDB,0X40,0XC0); DEFINE_GUID(IID_IDirect3DVolume8, 0xBD7349F5,0x14F1,0x42E4,0x9C,0x79,0x97,0x23,0x80,0xDB,0x40,0xC0);
typedef struct IDirect3DVolume8 IDirect3DVolume8, *LPDIRECT3DVOLUME8, *PDIRECT3DVOLUME8; typedef struct IDirect3DVolume8 IDirect3DVolume8, *LPDIRECT3DVOLUME8, *PDIRECT3DVOLUME8;
DEFINE_GUID(IID_IDirect3DSwapChain8, 0X928C088B,0X76B9,0X4C6B,0XA5,0X36,0XA5,0X90,0X85,0X38,0X76,0XCD); DEFINE_GUID(IID_IDirect3DSwapChain8, 0x928C088B,0x76B9,0x4C6B,0xA5,0x36,0xA5,0x90,0x85,0x38,0x76,0xCD);
typedef struct IDirect3DSwapChain8 IDirect3DSwapChain8, *LPDIRECT3DSWAPCHAIN8, *PDIRECT3DSWAPCHAIN8; typedef struct IDirect3DSwapChain8 IDirect3DSwapChain8, *LPDIRECT3DSWAPCHAIN8, *PDIRECT3DSWAPCHAIN8;
DEFINE_GUID(IID_IDirect3DSurface8, 0XB96EEBCA,0XB326,0X4EA5,0X88,0X2F,0X2F,0XF5,0XBA,0XE0,0X21,0XDD); DEFINE_GUID(IID_IDirect3DSurface8, 0xB96EEBCA,0xB326,0x4EA5,0x88,0x2F,0x2F,0xF5,0xBA,0xE0,0x21,0xDD);
typedef struct IDirect3DSurface8 IDirect3DSurface8, *LPDIRECT3DSURFACE8, *PDIRECT3DSURFACE8; typedef struct IDirect3DSurface8 IDirect3DSurface8, *LPDIRECT3DSURFACE8, *PDIRECT3DSURFACE8;
DEFINE_GUID(IID_IDirect3DIndexBuffer8, 0X0E689C9A,0X053D,0X44A0,0X9D,0X92,0XDB,0X0E,0X3D,0X75,0X0F,0X86); DEFINE_GUID(IID_IDirect3DIndexBuffer8, 0x0E689C9A,0x053D,0x44A0,0x9D,0x92,0xDB,0x0E,0x3D,0x75,0x0F,0x86);
typedef struct IDirect3DIndexBuffer8 IDirect3DIndexBuffer8, *LPDIRECT3DINDEXBUFFER8, *PDIRECT3DINDEXBUFFER8; typedef struct IDirect3DIndexBuffer8 IDirect3DIndexBuffer8, *LPDIRECT3DINDEXBUFFER8, *PDIRECT3DINDEXBUFFER8;
DEFINE_GUID(IID_IDirect3DBaseTexture8, 0XB4211CFA,0X51B9,0X4A9F,0XAB,0X78,0XDB,0X99,0XB2,0XBB,0X67,0X8E); DEFINE_GUID(IID_IDirect3DBaseTexture8, 0xB4211CFA,0x51B9,0x4A9F,0xAB,0x78,0xDB,0x99,0xB2,0xBB,0x67,0x8E);
typedef struct IDirect3DBaseTexture8 IDirect3DBaseTexture8, *LPDIRECT3DBASETEXTURE8, *PDIRECT3DBASETEXTURE8; typedef struct IDirect3DBaseTexture8 IDirect3DBaseTexture8, *LPDIRECT3DBASETEXTURE8, *PDIRECT3DBASETEXTURE8;
DEFINE_GUID(IID_IDirect3DTexture8, 0XE4CDD575,0X2866,0X4F01,0XB1,0X2E,0X7E,0XEC,0XE1,0XEC,0X93,0X58); DEFINE_GUID(IID_IDirect3DTexture8, 0xE4CDD575,0x2866,0x4F01,0xB1,0x2E,0x7E,0xEC,0xE1,0xEC,0x93,0x58);
typedef struct IDirect3DTexture8 IDirect3DTexture8, *LPDIRECT3DTEXTURE8, *PDIRECT3DTEXTURE8; typedef struct IDirect3DTexture8 IDirect3DTexture8, *LPDIRECT3DTEXTURE8, *PDIRECT3DTEXTURE8;
DEFINE_GUID(IID_IDirect3DCubeTexture8, 0X3EE5B968,0X2ACA,0X4C34,0X8B,0XB5,0X7E,0X0C,0X3D,0X19,0XB7,0X50); DEFINE_GUID(IID_IDirect3DCubeTexture8, 0x3EE5B968,0x2ACA,0x4C34,0x8B,0xB5,0x7E,0x0C,0x3D,0x19,0xB7,0x50);
typedef struct IDirect3DCubeTexture8 IDirect3DCubeTexture8, *LPDIRECT3DCUBETEXTURE8, *PDIRECT3DCUBETEXTURE8; typedef struct IDirect3DCubeTexture8 IDirect3DCubeTexture8, *LPDIRECT3DCUBETEXTURE8, *PDIRECT3DCUBETEXTURE8;
DEFINE_GUID(IID_IDirect3DVolumeTexture8,0X4B8AAAFA,0X140F,0X42BA,0X91,0X31,0X59,0X7E,0XAF,0XAA,0X2E,0XAD); DEFINE_GUID(IID_IDirect3DVolumeTexture8, 0x4B8AAAFA,0x140F,0x42BA,0x91,0x31,0x59,0x7E,0xAF,0xAA,0x2E,0xAD);
typedef struct IDirect3DVolumeTexture8 IDirect3DVolumeTexture8, *LPDIRECT3DVOLUMETEXTURE8, *PDIRECT3DVOLUMETEXTURE8; typedef struct IDirect3DVolumeTexture8 IDirect3DVolumeTexture8, *LPDIRECT3DVOLUMETEXTURE8, *PDIRECT3DVOLUMETEXTURE8;
/***************************************************************************** /*****************************************************************************
@ -728,7 +728,15 @@ ICOM_DEFINE(IDirect3DVolumeTexture8,IDirect3DBaseTexture8)
#define IDirect3DVolumeTexture8_UnlockBox(p,a) ICOM_CALL1(UnlockBox,p,a) #define IDirect3DVolumeTexture8_UnlockBox(p,a) ICOM_CALL1(UnlockBox,p,a)
#define IDirect3DVolumeTexture8_AddDirtyBox(p,a) ICOM_CALL1(AddDirtyBox,p,a) #define IDirect3DVolumeTexture8_AddDirtyBox(p,a) ICOM_CALL1(AddDirtyBox,p,a)
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */
/* Define the main entrypoint as well */ /* Define the main entrypoint as well */
IDirect3D8* WINAPI Direct3DCreate8(UINT SDKVersion); IDirect3D8* WINAPI Direct3DCreate8(UINT SDKVersion);
#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */
#endif /* __WINE_D3D8_H */ #endif /* __WINE_D3D8_H */

2
include/d3d8types.h
View File

@ -250,7 +250,7 @@ typedef enum _D3DVSDT_TYPE {
#define D3DVSD_EXTINFOMASK (0xFFFFFF << D3DVSD_EXTINFOSHIFT) #define D3DVSD_EXTINFOMASK (0xFFFFFF << D3DVSD_EXTINFOSHIFT)
#define D3DVSD_STREAMNUMBERMASK (0xF << D3DVSD_STREAMNUMBERSHIFT) #define D3DVSD_STREAMNUMBERMASK (0xF << D3DVSD_STREAMNUMBERSHIFT)
#define D3DVSD_VERTEXREGMASK (0x1F << D3DVSD_VERTEXREGSHIFT) #define D3DVSD_VERTEXREGMASK (0x1F << D3DVSD_VERTEXREGSHIFT)
#define D3DVSD_CONSTRSMASK (0x1FFF << D3DVSD_CONSTREGSHIFT) #define D3DVSD_CONSTRSMASK (0x1FFF << D3DVSD_CONSTRSSHIFT)
#define D3DVSD_DATATYPEMASK (0xF << D3DVSD_DATATYPESHIFT) #define D3DVSD_DATATYPEMASK (0xF << D3DVSD_DATATYPESHIFT)
#define D3DVSD_SKIPCOUNTMASK (0xF << D3DVSD_SKIPCOUNTSHIFT) #define D3DVSD_SKIPCOUNTMASK (0xF << D3DVSD_SKIPCOUNTSHIFT)
#define D3DVSD_EXTCOUNTMASK (0x1F << D3DVSD_EXTCOUNTSHIFT) #define D3DVSD_EXTCOUNTMASK (0x1F << D3DVSD_EXTCOUNTSHIFT)