Again GTA3 problems -- it is fully broken. Warcraft 3 as well.
Raphaël Junqueira
fenix at club-internet.fr
Sat May 31 06:04:30 CDT 2003
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Hi,
have you any progress on GTA3 using lastest cvs + all pending patches (from
wine-patches) ?
Can you test with all patches + this last one (attached) please ?
Thanks,
Raphael
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.2 (GNU/Linux)
iD8DBQE+2Iw+p7NA3AmQTU4RAgZ1AJ4uNEjZpgRvDjpKvC1zNHcFemgaFQCeKi7A
WKMQkxhimXpSkRlS43BNZv4=
=kBFm
-----END PGP SIGNATURE-----
-------------- next part --------------
diff -u /cvs-src/wine-pending/d3d8_43/d3d8_main.c ./d3d8_main.c
--- /cvs-src/wine-pending/d3d8_43/d3d8_main.c 2003-05-30 00:09:35.000000000 +0200
+++ ./d3d8_main.c 2003-05-30 01:39:23.000000000 +0200
@@ -38,9 +38,9 @@
return 0;
}
-HRESULT WINAPI DebugSetMute(void)
+HRESULT CDECL DebugSetMute(DWORD dummy)
{
- FIXME("(void): stub\n");
+ FIXME("(void): stub %lu\n", dummy);
return 0;
}
diff -u /cvs-src/wine-pending/d3d8_43/d3d8_private.h ./d3d8_private.h
--- /cvs-src/wine-pending/d3d8_43/d3d8_private.h 2003-05-30 00:09:35.000000000 +0200
+++ ./d3d8_private.h 2003-05-30 16:13:33.000000000 +0200
@@ -99,17 +99,16 @@
} D3DSHADERSCALAR;
#define D3D8_VSHADER_MAX_CONSTANTS 96
-#define D3D8_PSHADER_MAX_CONSTANTS 96
typedef D3DSHADERVECTOR VSHADERCONSTANTS8[D3D8_VSHADER_MAX_CONSTANTS];
-typedef struct SHADERDATA8 {
+typedef struct VSHADERDATA8 {
/** Run Time Shader Function Constants */
/*D3DXBUFFER* constants;*/
VSHADERCONSTANTS8 C;
/** Shader Code as char ... */
CONST DWORD* code;
UINT codeLength;
-} SHADERDATA8;
+} VSHADERDATA8;
/** temporary here waiting for buffer code */
typedef struct VSHADERINPUTDATA8 {
@@ -125,6 +124,34 @@
D3DSHADERVECTOR oPts;
} VSHADEROUTPUTDATA8;
+
+#define D3D8_PSHADER_MAX_CONSTANTS 32
+typedef D3DSHADERVECTOR PSHADERCONSTANTS8[D3D8_PSHADER_MAX_CONSTANTS];
+
+typedef struct PSHADERDATA8 {
+ /** Run Time Shader Function Constants */
+ /*D3DXBUFFER* constants;*/
+ PSHADERCONSTANTS8 C;
+ /** Shader Code as char ... */
+ CONST DWORD* code;
+ UINT codeLength;
+} PSHADERDATA8;
+
+/** temporary here waiting for buffer code */
+typedef struct PSHADERINPUTDATA8 {
+ D3DSHADERVECTOR V[2];
+ D3DSHADERVECTOR T[8];
+ D3DSHADERVECTOR S[16];
+ /*D3DSHADERVECTOR R[12];*/
+} PSHADERINPUTDATA8;
+
+/** temporary here waiting for buffer code */
+typedef struct PSHADEROUTPUTDATA8 {
+ D3DSHADERVECTOR oC[4];
+ D3DSHADERVECTOR oDepth;
+} PSHADEROUTPUTDATA8;
+
+
/*
* External prototypes
*/
@@ -155,6 +182,7 @@
typedef enum _GL_SupportedExt {
/* ARB */
+ ARB_FRAGMENT_PROGRAM,
ARB_MULTISAMPLE,
ARB_MULTITEXTURE,
ARB_POINT_PARAMETERS,
@@ -173,6 +201,7 @@
EXT_TEXTURE_LOD_BIAS,
EXT_VERTEX_WEIGHTING,
/* NVIDIA */
+ NV_FRAGMENT_PROGRAM,
NV_VERTEX_PROGRAM,
/* ATI */
EXT_VERTEX_SHADER,
@@ -190,6 +219,19 @@
VS_VERSION_FORCE_DWORD = 0x7FFFFFFF
} GL_VSVersion;
+typedef enum _GL_PSVersion {
+ PS_VERSION_NOT_SUPPORTED = 0x0,
+ PS_VERSION_10 = 0x10,
+ PS_VERSION_11 = 0x11,
+ PS_VERSION_12 = 0x12,
+ PS_VERSION_13 = 0x13,
+ PS_VERSION_14 = 0x14,
+ PS_VERSION_20 = 0x20,
+ PS_VERSION_30 = 0x30,
+ /*Force 32-bits*/
+ PS_VERSION_FORCE_DWORD = 0x7FFFFFFF
+} GL_PSVersion;
+
typedef struct _GL_Info {
/**
* CAPS Constants
@@ -198,11 +240,14 @@
UINT max_textures;
UINT max_clipplanes;
+ GL_PSVersion ps_arb_version;
+ GL_PSVersion ps_nv_version;
+
GL_VSVersion vs_arb_version;
GL_VSVersion vs_nv_version;
GL_VSVersion vs_ati_version;
- BOOL supported[25];
+ BOOL supported[30];
} GL_Info;
#define GL_LIMITS(ExtName) (This->direct3d8->gl_info.max_##ExtName)
@@ -1017,6 +1062,7 @@
BOOL vertexShaderConstant;
BOOL vertexShaderDecl;
BOOL pixelShader;
+ BOOL pixelShaderConstant;
BOOL renderstate[HIGHEST_RENDER_STATE];
BOOL texture_state[8][HIGHEST_TEXTURE_STATE];
BOOL clipplane[MAX_CLIPPLANES];
@@ -1091,7 +1137,6 @@
/* Pixel Shader */
DWORD PixelShader;
- /* TODO: Pixel Shader Constant */
/* Indexed Vertex Blending */
D3DVERTEXBLENDFLAGS vertex_blend;
@@ -1099,6 +1144,8 @@
/* Vertex Shader Constant */
D3DSHADERVECTOR vertexShaderConstant[D3D8_VSHADER_MAX_CONSTANTS];
+ /* Pixel Shader Constant */
+ D3DSHADERVECTOR pixelShaderConstant[D3D8_PSHADER_MAX_CONSTANTS];
};
/* exported Interfaces */
@@ -1171,7 +1218,7 @@
DWORD usage; /* 0 || D3DUSAGE_SOFTWAREPROCESSING */
DWORD version;
/* run time datas */
- SHADERDATA8* data;
+ VSHADERDATA8* data;
VSHADERINPUTDATA8 input;
VSHADEROUTPUTDATA8 output;
};
@@ -1210,18 +1257,21 @@
/* The device, to be replaced by a IDirect3DDeviceImpl */
IDirect3DDevice8Impl* device;
- /* TODO: Pixel Shader */
- CONST DWORD* function;
+ DWORD* function;
UINT functionLength;
DWORD version;
/* run time datas */
- SHADERDATA8* data;
+ PSHADERDATA8* data;
+ PSHADERINPUTDATA8 input;
+ PSHADEROUTPUTDATA8 output;
};
/* exported Interfaces */
extern HRESULT WINAPI IDirect3DPixelShaderImpl_GetFunction(IDirect3DPixelShaderImpl* This, VOID* pData, UINT* pSizeOfData);
/* internal Interfaces */
extern DWORD WINAPI IDirect3DPixelShaderImpl_GetVersion(IDirect3DPixelShaderImpl* This);
+/* temporary internal Interfaces */
+extern HRESULT WINAPI IDirect3DDeviceImpl_CreatePixelShader(IDirect3DDevice8Impl* This, CONST DWORD* pFunction, IDirect3DPixelShaderImpl** ppPixelShader);
/**
@@ -1229,7 +1279,10 @@
*
* to see how not defined it here
*/
+void GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum* operand);
void setupTextureStates(LPDIRECT3DDEVICE8 iface, DWORD Stage);
+void set_tex_op(LPDIRECT3DDEVICE8 iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3);
+
SHORT D3DFmtGetBpp(IDirect3DDevice8Impl* This, D3DFORMAT fmt);
GLint D3DFmt2GLIntFmt(IDirect3DDevice8Impl* This, D3DFORMAT fmt);
diff -u /cvs-src/wine-pending/d3d8_43/d3d8.spec ./d3d8.spec
--- /cvs-src/wine-pending/d3d8_43/d3d8.spec 2003-05-30 00:09:35.000000000 +0200
+++ ./d3d8.spec 2003-05-30 13:59:17.000000000 +0200
@@ -1,5 +1,5 @@
@ stdcall D3D8GetSWInfo()
-@ stdcall DebugSetMute(long)
+@ cdecl DebugSetMute(long)
@ stdcall Direct3DCreate8(long)
-@ stdcall ValidatePixelShader(ptr ptr)
+@ cdecl ValidatePixelShader(ptr ptr)
@ stdcall ValidateVertexShader(ptr ptr)
diff -u /cvs-src/wine-pending/d3d8_43/device.c ./device.c
--- /cvs-src/wine-pending/d3d8_43/device.c 2003-05-30 00:09:35.000000000 +0200
+++ ./device.c 2003-05-30 16:28:00.000000000 +0200
@@ -996,71 +996,6 @@
TRACE("glEnd\n");
}
-/**
- * @nodoc: todo
- */
-void GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum* operand)
-{
- BOOL isAlphaReplicate = FALSE;
- BOOL isComplement = FALSE;
-
- *operand = GL_SRC_COLOR;
- *source = GL_TEXTURE;
-
- /* Catch alpha replicate */
- if (iValue & D3DTA_ALPHAREPLICATE) {
- iValue = iValue & ~D3DTA_ALPHAREPLICATE;
- isAlphaReplicate = TRUE;
- }
-
- /* Catch Complement */
- if (iValue & D3DTA_COMPLEMENT) {
- iValue = iValue & ~D3DTA_COMPLEMENT;
- isComplement = TRUE;
- }
-
- /* Calculate the operand */
- if (isAlphaReplicate && !isComplement) {
- *operand = GL_SRC_ALPHA;
- } else if (isAlphaReplicate && isComplement) {
- *operand = GL_ONE_MINUS_SRC_ALPHA;
- } else if (isComplement) {
- if (isAlphaArg) {
- *operand = GL_ONE_MINUS_SRC_ALPHA;
- } else {
- *operand = GL_ONE_MINUS_SRC_COLOR;
- }
- } else {
- if (isAlphaArg) {
- *operand = GL_SRC_ALPHA;
- } else {
- *operand = GL_SRC_COLOR;
- }
- }
-
- /* Calculate the source */
- switch (iValue & D3DTA_SELECTMASK) {
- case D3DTA_CURRENT: *source = GL_PREVIOUS_EXT;
- break;
- case D3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT;
- break;
- case D3DTA_TEXTURE: *source = GL_TEXTURE;
- break;
- case D3DTA_TFACTOR: *source = GL_CONSTANT_EXT;
- break;
- case D3DTA_SPECULAR:
- /**
- * According to the GL_ARB_texture_env_combine specs, SPECULAR is 'Secondary color' and
- * isnt supported until base GL supports it
- * There is no concept of temp registers as far as I can tell
- */
-
- default:
- FIXME("Unrecognized or unhandled texture arg %ld\n", iValue);
- *source = GL_TEXTURE;
- }
-}
-
/* Apply the current values to the specified texture stage */
void setupTextureStates(LPDIRECT3DDEVICE8 iface, DWORD Stage) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
@@ -3671,7 +3606,7 @@
IDirect3DBaseTexture8Impl_AddRef(*ppTexture);
return D3D_OK;
}
-HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8* pTexture) {
+HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage, IDirect3DBaseTexture8* pTexture) {
IDirect3DBaseTexture8 *oldTxt;
BOOL reapplyStates = TRUE;
@@ -3711,22 +3646,20 @@
}
/* Decrement the count of the previous texture */
- if (oldTxt != NULL) {
+ if (NULL != oldTxt) {
IDirect3DBaseTexture8Impl_Release(oldTxt);
}
- if (pTexture) {
- IDirect3DBaseTexture8Impl_AddRef((LPDIRECT3DBASETEXTURE8)This->UpdateStateBlock->textures[Stage]);
+ if (NULL != pTexture) {
+ IDirect3DBaseTexture8Impl_AddRef((LPDIRECT3DBASETEXTURE8) This->UpdateStateBlock->textures[Stage]);
/* Now setup the texture appropraitly */
textureType = IDirect3DBaseTexture8Impl_GetType(pTexture);
if (textureType == D3DRTYPE_TEXTURE) {
- IDirect3DTexture8Impl *pTexture2 = (IDirect3DTexture8Impl*) pTexture;
-
- if ((void*) oldTxt == (void*) pTexture2 && pTexture2->Dirty == FALSE) {
- TRACE("Skipping setting texture as old == new\n");
- reapplyStates = FALSE;
+ if (oldTxt == pTexture && TRUE == IDirect3DBaseTexture8Impl_IsDirty(pTexture)) {
+ TRACE("Skipping setting texture as old == new\n");
+ reapplyStates = FALSE;
} else {
/* Standard 2D texture */
TRACE("Standard 2d texture\n");
@@ -3736,19 +3669,29 @@
IDirect3DTexture8Impl_PreLoad((LPDIRECT3DTEXTURE8) pTexture);
}
} else if (textureType == D3DRTYPE_VOLUMETEXTURE) {
- /* Standard 3D (volume) texture */
+ if (oldTxt == pTexture && TRUE == IDirect3DBaseTexture8Impl_IsDirty(pTexture)) {
+ TRACE("Skipping setting texture as old == new\n");
+ reapplyStates = FALSE;
+ } else {
+ /* Standard 3D (volume) texture */
TRACE("Standard 3d texture\n");
This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_3D;
/* Load up the texture now */
IDirect3DVolumeTexture8Impl_PreLoad((LPDIRECT3DVOLUMETEXTURE8) pTexture);
+ }
} else if (textureType == D3DRTYPE_CUBETEXTURE) {
+ if (oldTxt == pTexture && TRUE == IDirect3DBaseTexture8Impl_IsDirty(pTexture)) {
+ TRACE("Skipping setting texture as old == new\n");
+ reapplyStates = FALSE;
+ } else {
/* Standard Cube texture */
TRACE("Standard Cube texture\n");
This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_CUBE_MAP_ARB;
/* Load up the texture now */
IDirect3DCubeTexture8Impl_PreLoad((LPDIRECT3DCUBETEXTURE8) pTexture);
+ }
} else {
FIXME("(%p) : Incorrect type for a texture : (%d,%s)\n", This, textureType, debug_d3dressourcetype(textureType));
}
@@ -3763,7 +3706,7 @@
/* Even if the texture has been set to null, reapply the stages as a null texture to directx requires
a dummy texture in opengl, and we always need to ensure the current view of the TextureStates apply */
if (reapplyStates) {
- setupTextureStates (iface, Stage);
+ setupTextureStates(iface, Stage);
}
return D3D_OK;
@@ -3884,63 +3827,22 @@
}
break;
- case D3DTSS_COLORARG0 :
- case D3DTSS_ALPHAARG0 :
- /* FIXME: Mesa seems to struggle setting these at the moment */
- /*FIXME("COLORARG0/ALPHAARG0 support still a stub, Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value);*/
- /*break;*/
-
- case D3DTSS_COLORARG1 :
- case D3DTSS_COLORARG2 :
- case D3DTSS_ALPHAARG1 :
- case D3DTSS_ALPHAARG2 :
- {
- BOOL isAlphaArg = (Type == D3DTSS_ALPHAARG1 || Type == D3DTSS_ALPHAARG2 || Type == D3DTSS_ALPHAARG0);
- int operand = GL_SRC_COLOR;
- int source = GL_TEXTURE;
-
- GetSrcAndOpFromValue(Value, isAlphaArg, &source, &operand);
- if (isAlphaArg) {
-
- /* From MSDN (D3DTSS_ALPHAARG1) :
- The default argument is D3DTA_TEXTURE. If no texture is set for this stage,
- then the default argument is D3DTA_DIFFUSE.
- FIXME? If texture added/removed, may need to reset back as well? */
- if (Type == D3DTSS_ALPHAARG1 && This->StateBlock->textures[Stage] == NULL && Value == D3DTA_TEXTURE) {
- GetSrcAndOpFromValue(D3DTA_DIFFUSE, isAlphaArg, &source, &operand);
- }
- TRACE("Source %x = %x, Operand %x = %x\n", SOURCEx_ALPHA_EXT(Type), source, OPERANDx_ALPHA_EXT(Type), operand);
- glTexEnvi(GL_TEXTURE_ENV, SOURCEx_ALPHA_EXT(Type), source);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, SOURCEx_ALPHA_EXT, source);");
- glTexEnvi(GL_TEXTURE_ENV, OPERANDx_ALPHA_EXT(Type), operand);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, OPERANDx_ALPHA_EXT, operand);");
- } else {
- TRACE("Source %x = %x, Operand %x = %x\n", SOURCEx_RGB_EXT(Type), source, OPERANDx_RGB_EXT(Type), operand);
- glTexEnvi(GL_TEXTURE_ENV, SOURCEx_RGB_EXT(Type), source);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, SOURCEx_RGB_EXT, source);");
- glTexEnvi(GL_TEXTURE_ENV, OPERANDx_RGB_EXT(Type), operand);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, OPERANDx_RGB_EXT, operand);");
- }
- }
- break;
-
case D3DTSS_ALPHAOP :
case D3DTSS_COLOROP :
{
- int Scale = 1;
- int Parm = (Type == D3DTSS_ALPHAOP) ? GL_COMBINE_ALPHA_EXT : GL_COMBINE_RGB_EXT;
-
- if (Type == D3DTSS_COLOROP && Value == D3DTOP_DISABLE) {
+ if (Value == D3DTOP_DISABLE) {
/* TODO: Disable by making this and all later levels disabled */
- glDisable(GL_TEXTURE_1D);
- checkGLcall("Disable GL_TEXTURE_1D");
- glDisable(GL_TEXTURE_2D);
- checkGLcall("Disable GL_TEXTURE_2D");
- glDisable(GL_TEXTURE_3D);
- checkGLcall("Disable GL_TEXTURE_3D");
+ if (Type == D3DTSS_COLOROP) {
+ glDisable(GL_TEXTURE_1D);
+ checkGLcall("Disable GL_TEXTURE_1D");
+ glDisable(GL_TEXTURE_2D);
+ checkGLcall("Disable GL_TEXTURE_2D");
+ glDisable(GL_TEXTURE_3D);
+ checkGLcall("Disable GL_TEXTURE_3D");
+ }
+ break; /* Dont bother setting the texture operations */
} else {
-
/* Enable only the appropriate texture dimension */
if (Type == D3DTSS_COLOROP) {
if (This->StateBlock->textureDimensions[Stage] == GL_TEXTURE_1D) {
@@ -3972,139 +3874,27 @@
checkGLcall("Disable GL_TEXTURE_CUBE_MAP");
}
}
-
- /* Re-Enable GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT */
- if (Value != D3DTOP_DISABLE) {
- glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
- }
-
- /* Now set up the operand correctly */
- switch (Value) {
- case D3DTOP_DISABLE :
- /* Contrary to the docs, alpha can be disabled when colorop is enabled
- and it works, so ignore this op */
- TRACE("Disable ALPHAOP but COLOROP enabled!\n");
- break;
-
- case D3DTOP_SELECTARG1 :
- {
- glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE)");
- }
- break;
-
- case D3DTOP_SELECTARG2 :
- {
- BOOL isAlphaOp = (Type == D3DTSS_ALPHAOP);
- DWORD dwValue = 0;
- GLenum source;
- GLenum operand;
- /*FIXME("see if D3DTOP_SELECTARG2 behavior is correct now!\n");*/
- glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE)");
- /* GL_REPLACE, swap args 0 and 1? */
- dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG2 : D3DTSS_COLORARG2];
- GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
- if (isAlphaOp) {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_ALPHA_EXT, source, GL_OPERAND0_ALPHA_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, 'operand')");
- } else {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_RGB_EXT, source, GL_OPERAND0_RGB_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, 'operand')");
- }
- dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG1 : D3DTSS_COLORARG1];
- GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
- if (isAlphaOp) {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_ALPHA_EXT, source, GL_OPERAND1_ALPHA_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, 'operand')");
- } else {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_RGB_EXT, source, GL_OPERAND1_RGB_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, 'operand')");
- }
- }
- break;
-
- case D3DTOP_MODULATE4X : Scale = Scale * 2; /* Drop through */
- case D3DTOP_MODULATE2X : Scale = Scale * 2; /* Drop through */
- case D3DTOP_MODULATE :
-
- /* Correct scale */
- if (Type == D3DTSS_ALPHAOP) {
- glTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, Scale);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, Scale)");
- } else {
- glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, Scale);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, Scale)");
- }
- glTexEnvi(GL_TEXTURE_ENV, Parm, GL_MODULATE);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_MODULATE);");
- break;
-
- case D3DTOP_ADD :
- glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD)");
- break;
-
- case D3DTOP_ADDSIGNED2X : Scale = Scale * 2; /* Drop through */
- case D3DTOP_ADDSIGNED :
- glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD_SIGNED_EXT);
- vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD_SIGNED_EXT)");
- break;
-
- case D3DTOP_DOTPRODUCT3 :
-#if defined(GL_VERSION_1_3)
- if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
- glTexEnvi(GL_TEXTURE_ENV, Parm, GL_DOT3_RGBA);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA);");
- break;
- }
-#endif
- FIXME("DotProduct3 extension requested but not supported via this version of opengl\n");
- break;
-
-
- case D3DTOP_SUBTRACT :
-#if defined(GL_VERSION_1_3)
- glTexEnvi(GL_TEXTURE_ENV, Parm, GL_SUBTRACT);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_SUBTRACT)");
- break;
-#else
- /**
- * @TODO: to check:
- * if ARB_texture_env_combine is supported
- * we can use GL_SUBTRACT_ARB here
- */
-#endif
-
- case D3DTOP_ADDSMOOTH :
- case D3DTOP_BLENDDIFFUSEALPHA :
- case D3DTOP_BLENDTEXTUREALPHA :
- case D3DTOP_BLENDFACTORALPHA :
- case D3DTOP_BLENDTEXTUREALPHAPM :
- case D3DTOP_BLENDCURRENTALPHA :
- case D3DTOP_PREMODULATE :
- case D3DTOP_MODULATEALPHA_ADDCOLOR :
- case D3DTOP_MODULATECOLOR_ADDALPHA :
- case D3DTOP_MODULATEINVALPHA_ADDCOLOR :
- case D3DTOP_MODULATEINVCOLOR_ADDALPHA :
- case D3DTOP_BUMPENVMAP :
- case D3DTOP_BUMPENVMAPLUMINANCE :
- case D3DTOP_MULTIPLYADD :
- case D3DTOP_LERP :
- default:
- FIXME("Unhandled texture operation %ld\n", Value);
+ }
+ /* Drop through... (Except disable case) */
+ case D3DTSS_COLORARG0 :
+ case D3DTSS_COLORARG1 :
+ case D3DTSS_COLORARG2 :
+ case D3DTSS_ALPHAARG0 :
+ case D3DTSS_ALPHAARG1 :
+ case D3DTSS_ALPHAARG2 :
+ {
+ BOOL isAlphaArg = (Type == D3DTSS_ALPHAOP || Type == D3DTSS_ALPHAARG1 ||
+ Type == D3DTSS_ALPHAARG2 || Type == D3DTSS_ALPHAARG0);
+ if (isAlphaArg) {
+ set_tex_op(iface, TRUE, Stage, This->StateBlock->texture_state[Stage][D3DTSS_ALPHAOP],
+ This->StateBlock->texture_state[Stage][D3DTSS_ALPHAARG1],
+ This->StateBlock->texture_state[Stage][D3DTSS_ALPHAARG2],
+ This->StateBlock->texture_state[Stage][D3DTSS_ALPHAARG0]);
+ } else {
+ set_tex_op(iface, FALSE, Stage, This->StateBlock->texture_state[Stage][D3DTSS_COLOROP],
+ This->StateBlock->texture_state[Stage][D3DTSS_COLORARG1],
+ This->StateBlock->texture_state[Stage][D3DTSS_COLORARG2],
+ This->StateBlock->texture_state[Stage][D3DTSS_COLORARG0]);
}
}
break;
@@ -4693,9 +4483,10 @@
HRESULT WINAPI IDirect3DDevice8Impl_CreatePixelShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pFunction, DWORD* pHandle) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
IDirect3DPixelShaderImpl* object;
+ HRESULT res;
UINT i;
- FIXME("(%p) : PixelShader not fully supported yet\n", This);
+ TRACE_(d3d_shader)("(%p) : PixelShader not fully supported yet : Func=%p\n", This, pFunction);
if (NULL == pFunction || NULL == pHandle) {
return D3DERR_INVALIDCALL;
}
@@ -4703,21 +4494,16 @@
if (i >= sizeof(PixelShaders) / sizeof(IDirect3DPixelShaderImpl*)) {
return D3DERR_OUTOFVIDEOMEMORY;
}
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DPixelShaderImpl));
- if (NULL == object) {
- return D3DERR_OUTOFVIDEOMEMORY;
- }
-
- object->data = NULL; /* TODO */
- PixelShaders[i] = object;
- *pHandle = VS_HIGHESTFIXEDFXF + i;
-
- object->function = pFunction;
- for (i = 0; D3DPS_END() != pFunction[i]; ++i) ;
- object->functionLength = i + 1;
-
- return D3D_OK;
+ /** Create the Pixel Shader */
+ res = IDirect3DDeviceImpl_CreatePixelShader(This, pFunction, &object);
+ if (SUCCEEDED(res)) {
+ PixelShaders[i] = object;
+ *pHandle = VS_HIGHESTFIXEDFXF + i;
+ return D3D_OK;
+ }
+ *pHandle = 0xFFFFFFFF;
+ return res;
}
HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
@@ -4728,22 +4514,22 @@
/* Handle recording of state blocks */
if (This->isRecordingState) {
- TRACE("Recording... not performing anything\n");
+ TRACE_(d3d_shader)("Recording... not performing anything\n");
return D3D_OK;
}
/* FIXME: Quieten when not being used */
if (Handle != 0) {
- FIXME("(%p) : stub %ld\n", This, Handle);
+ FIXME_(d3d_shader)("(%p) : stub %ld\n", This, Handle);
} else {
- TRACE("(%p) : stub %ld\n", This, Handle);
+ TRACE_(d3d_shader)("(%p) : stub %ld\n", This, Handle);
}
return D3D_OK;
}
HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
- TRACE("(%p) : GetPixelShader returning %ld\n", This, This->StateBlock->PixelShader);
+ TRACE_(d3d_shader)("(%p) : GetPixelShader returning %ld\n", This, This->StateBlock->PixelShader);
*pHandle = This->StateBlock->PixelShader;
return D3D_OK;
}
@@ -4756,42 +4542,63 @@
return D3DERR_INVALIDCALL;
}
object = PixelShaders[Handle - VS_HIGHESTFIXEDFXF];
- TRACE("(%p) : freeing PixelShader %p\n", This, object);
+ TRACE_(d3d_shader)("(%p) : freeing PixelShader %p\n", This, object);
/* TODO: check validity of object before free */
+ if (NULL != object->function) HeapFree(GetProcessHeap(), 0, (void *)object->function);
+ HeapFree(GetProcessHeap(), 0, (void *)object->data);
HeapFree(GetProcessHeap(), 0, (void *)object);
- PixelShaders[Handle - VS_HIGHESTFIXEDFXF] = 0;
+ PixelShaders[Handle - VS_HIGHESTFIXEDFXF] = NULL;
+
return D3D_OK;
}
-HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData, DWORD ConstantCount) {
- ICOM_THIS(IDirect3DDevice8Impl,iface);
- FIXME("(%p) : stub\n", This);
- return D3D_OK;
+HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
+ ICOM_THIS(IDirect3DDevice8Impl,iface);
+
+ if (Register + ConstantCount > D3D8_PSHADER_MAX_CONSTANTS) {
+ ERR_(d3d_shader)("(%p) : SetPixelShaderConstant C[%lu] invalid\n", This, Register);
+ return D3DERR_INVALIDCALL;
+ }
+ if (NULL == pConstantData) {
+ return D3DERR_INVALIDCALL;
+ }
+ if (ConstantCount > 1) {
+ FLOAT* f = (FLOAT*)pConstantData;
+ UINT i;
+ TRACE_(d3d_shader)("(%p) : SetPixelShaderConstant C[%lu..%lu]=\n", This, Register, Register + ConstantCount - 1);
+ for (i = 0; i < ConstantCount; ++i) {
+ TRACE_(d3d_shader)("{%f, %f, %f, %f}\n", f[0], f[1], f[2], f[3]);
+ f += 4;
+ }
+ } else {
+ FLOAT* f = (FLOAT*) pConstantData;
+ TRACE_(d3d_shader)("(%p) : SetPixelShaderConstant, C[%lu]={%f, %f, %f, %f}\n", This, Register, f[0], f[1], f[2], f[3]);
+ }
+ This->UpdateStateBlock->Changed.pixelShaderConstant = TRUE;
+ memcpy(&This->UpdateStateBlock->pixelShaderConstant[Register], pConstantData, ConstantCount * 4 * sizeof(FLOAT));
+ return D3D_OK;
}
-HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData, DWORD ConstantCount) {
- ICOM_THIS(IDirect3DDevice8Impl,iface);
- FIXME("(%p) : stub\n", This);
- return D3D_OK;
+HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, void* pConstantData, DWORD ConstantCount) {
+ ICOM_THIS(IDirect3DDevice8Impl,iface);
+
+ TRACE_(d3d_shader)("(%p) : C[%lu] count=%ld\n", This, Register, ConstantCount);
+ if (Register + ConstantCount > D3D8_PSHADER_MAX_CONSTANTS) {
+ return D3DERR_INVALIDCALL;
+ }
+ if (NULL == pConstantData) {
+ return D3DERR_INVALIDCALL;
+ }
+ memcpy(pConstantData, &This->UpdateStateBlock->pixelShaderConstant[Register], ConstantCount * 4 * sizeof(FLOAT));
+ return D3D_OK;
}
HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle, void* pData, DWORD* pSizeOfData) {
- ICOM_THIS(IDirect3DDevice8Impl,iface);
IDirect3DPixelShaderImpl* object;
object = PIXEL_SHADER(Handle);
if (NULL == object) {
return D3DERR_INVALIDCALL;
- }
- if (NULL == pData) {
- *pSizeOfData = object->functionLength;
- return D3D_OK;
- }
- if (*pSizeOfData < object->functionLength) {
- *pSizeOfData = object->functionLength;
- return D3DERR_MOREDATA;
- }
- TRACE("(%p) : GetPixelShaderFunction copying to %p\n", This, pData);
- memcpy(pData, object->function, object->functionLength);
- return D3D_OK;
+ }
+ return IDirect3DPixelShaderImpl_GetFunction(object, pData, (UINT*) pSizeOfData);
}
HRESULT WINAPI IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
diff -u /cvs-src/wine-pending/d3d8_43/directx.c ./directx.c
--- /cvs-src/wine-pending/d3d8_43/directx.c 2003-05-30 00:09:35.000000000 +0200
+++ ./directx.c 2003-05-30 17:57:52.000000000 +0200
@@ -681,12 +681,6 @@
int dblBuf[] = {GLX_RGBA,
GLX_STENCIL_SIZE, 8, /* 2 */
GLX_DEPTH_SIZE, 16, /* 4 */
-#if 0
- GLX_RED_SIZE, 8, /* 6 */
- GLX_GREEN_SIZE, 8, /* 8 */
- GLX_BLUE_SIZE, 8, /* 10 */
- GLX_ALPHA_SIZE, 8, /* 12 */
-#endif
GLX_DOUBLEBUFFER, None};
/* FIXME: Handle stencil appropriately via EnableAutoDepthStencil / AutoDepthStencilFormat */
@@ -889,8 +883,10 @@
*/
memset(&This->gl_info.supported, 0, sizeof(This->gl_info.supported));
This->gl_info.max_textures = 1;
+ This->gl_info.ps_arb_version = PS_VERSION_NOT_SUPPORTED;
This->gl_info.vs_arb_version = VS_VERSION_NOT_SUPPORTED;
This->gl_info.vs_nv_version = VS_VERSION_NOT_SUPPORTED;
+ This->gl_info.vs_ati_version = VS_VERSION_NOT_SUPPORTED;
/* Retrieve opengl defaults */
glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
@@ -922,7 +918,11 @@
/**
* ARB
*/
- if (strcmp(ThisExtn, "GL_ARB_multisample") == 0) {
+ if (strcmp(ThisExtn, "GL_ARB_fragment_program") == 0) {
+ This->gl_info.ps_arb_version = PS_VERSION_11;
+ FIXME(" FOUND: ARB Pixel Shader support - version=%02x\n", This->gl_info.ps_arb_version);
+ This->gl_info.supported[ARB_FRAGMENT_PROGRAM] = TRUE;
+ } else if (strcmp(ThisExtn, "GL_ARB_multisample") == 0) {
FIXME(" FOUND: ARB Multisample support\n");
This->gl_info.supported[ARB_MULTISAMPLE] = TRUE;
} else if (strcmp(ThisExtn, "GL_ARB_multitexture") == 0) {
@@ -976,6 +976,10 @@
/**
* NVIDIA
*/
+ } else if (strstr(ThisExtn, "GL_NV_fragment_program")) {
+ This->gl_info.ps_nv_version = PS_VERSION_11;
+ FIXME(" FOUND: NVIDIA (NV) Pixel Shader support - version=%02x\n", This->gl_info.ps_nv_version);
+ This->gl_info.supported[NV_FRAGMENT_PROGRAM] = TRUE;
} else if (strstr(ThisExtn, "GL_NV_vertex_program")) {
This->gl_info.vs_nv_version = max(This->gl_info.vs_nv_version, (0 == strcmp(ThisExtn, "GL_NV_vertex_program1_1")) ? VS_VERSION_11 : VS_VERSION_10);
This->gl_info.vs_nv_version = max(This->gl_info.vs_nv_version, (0 == strcmp(ThisExtn, "GL_NV_vertex_program2")) ? VS_VERSION_20 : VS_VERSION_10);
diff -u /cvs-src/wine-pending/d3d8_43/shader.c ./shader.c
--- /cvs-src/wine-pending/d3d8_43/shader.c 2003-05-30 00:09:35.000000000 +0200
+++ ./shader.c 2003-05-30 15:52:27.000000000 +0200
@@ -34,7 +34,7 @@
/* Shader debugging - Change the following line to enable debugging of software
vertex shaders */
-#if 1
+#if 0
# define VSTRACE(A) TRACE A
# define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w)
#else
@@ -82,6 +82,8 @@
const char* name;
CONST UINT num_params;
shader_fct_t soft_fct;
+ DWORD min_version;
+ DWORD max_version;
} SHADER_OPCODE;
/*******************************
@@ -345,36 +347,36 @@
* log, exp, frc, m*x* seems to be macros ins ... to see
*/
static CONST SHADER_OPCODE vshader_ins [] = {
- {D3DSIO_NOP, "nop", 0, vshader_nop},
- {D3DSIO_MOV, "mov", 2, vshader_mov},
- {D3DSIO_ADD, "add", 3, vshader_add},
- {D3DSIO_SUB, "sub", 3, vshader_sub},
- {D3DSIO_MAD, "mad", 4, vshader_mad},
- {D3DSIO_MUL, "mul", 3, vshader_mul},
- {D3DSIO_RCP, "rcp", 2, vshader_rcp},
- {D3DSIO_RSQ, "rsq", 2, vshader_rsq},
- {D3DSIO_DP3, "dp3", 3, vshader_dp3},
- {D3DSIO_DP4, "dp4", 3, vshader_dp4},
- {D3DSIO_MIN, "min", 3, vshader_min},
- {D3DSIO_MAX, "max", 3, vshader_max},
- {D3DSIO_SLT, "slt", 3, vshader_slt},
- {D3DSIO_SGE, "sge", 3, vshader_sge},
- {D3DSIO_EXP, "exp", 2, vshader_exp},
- {D3DSIO_LOG, "log", 2, vshader_log},
- {D3DSIO_LIT, "lit", 2, vshader_lit},
- {D3DSIO_DST, "dst", 3, vshader_dst},
- {D3DSIO_LRP, "lrp", 5, vshader_lrp},
- {D3DSIO_FRC, "frc", 2, vshader_frc},
- {D3DSIO_M4x4, "m4x4", 3, vshader_m4x4},
- {D3DSIO_M4x3, "m4x3", 3, vshader_m4x3},
- {D3DSIO_M3x4, "m3x4", 3, vshader_m3x4},
- {D3DSIO_M3x3, "m3x3", 3, vshader_m3x3},
- {D3DSIO_M3x2, "m3x2", 3, vshader_m3x2},
+ {D3DSIO_NOP, "nop", 0, vshader_nop, 0, 0},
+ {D3DSIO_MOV, "mov", 2, vshader_mov, 0, 0},
+ {D3DSIO_ADD, "add", 3, vshader_add, 0, 0},
+ {D3DSIO_SUB, "sub", 3, vshader_sub, 0, 0},
+ {D3DSIO_MAD, "mad", 4, vshader_mad, 0, 0},
+ {D3DSIO_MUL, "mul", 3, vshader_mul, 0, 0},
+ {D3DSIO_RCP, "rcp", 2, vshader_rcp, 0, 0},
+ {D3DSIO_RSQ, "rsq", 2, vshader_rsq, 0, 0},
+ {D3DSIO_DP3, "dp3", 3, vshader_dp3, 0, 0},
+ {D3DSIO_DP4, "dp4", 3, vshader_dp4, 0, 0},
+ {D3DSIO_MIN, "min", 3, vshader_min, 0, 0},
+ {D3DSIO_MAX, "max", 3, vshader_max, 0, 0},
+ {D3DSIO_SLT, "slt", 3, vshader_slt, 0, 0},
+ {D3DSIO_SGE, "sge", 3, vshader_sge, 0, 0},
+ {D3DSIO_EXP, "exp", 2, vshader_exp, 0, 0},
+ {D3DSIO_LOG, "log", 2, vshader_log, 0, 0},
+ {D3DSIO_LIT, "lit", 2, vshader_lit, 0, 0},
+ {D3DSIO_DST, "dst", 3, vshader_dst, 0, 0},
+ {D3DSIO_LRP, "lrp", 5, vshader_lrp, 0, 0},
+ {D3DSIO_FRC, "frc", 2, vshader_frc, 0, 0},
+ {D3DSIO_M4x4, "m4x4", 3, vshader_m4x4, 0, 0},
+ {D3DSIO_M4x3, "m4x3", 3, vshader_m4x3, 0, 0},
+ {D3DSIO_M3x4, "m3x4", 3, vshader_m3x4, 0, 0},
+ {D3DSIO_M3x3, "m3x3", 3, vshader_m3x3, 0, 0},
+ {D3DSIO_M3x2, "m3x2", 3, vshader_m3x2, 0, 0},
/** FIXME: use direct access so add the others opcodes as stubs */
- {D3DSIO_EXPP, "expp", 2, vshader_expp},
- {D3DSIO_LOGP, "logp", 2, vshader_logp},
+ {D3DSIO_EXPP, "expp", 2, vshader_expp, 0, 0},
+ {D3DSIO_LOGP, "logp", 2, vshader_logp, 0, 0},
- {0, NULL, 0, NULL}
+ {0, NULL, 0, NULL, 0, 0}
};
@@ -546,7 +548,7 @@
object->ref = 1;
object->usage = Usage;
- object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHADERDATA8));
+ object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VSHADERDATA8));
IDirect3DVertexShaderImpl_ParseProgram(object, pFunction);
@@ -839,6 +841,458 @@
}
+/**********************************************************************************************************************************************
+ **********************************************************************************************************************************************
+ **********************************************************************************************************************************************
+ **********************************************************************************************************************************************
+ **********************************************************************************************************************************************/
+
+void pshader_texcoord(D3DSHADERVECTOR* d) {
+}
+
+void pshader_texkill(D3DSHADERVECTOR* d) {
+}
+
+void pshader_tex(D3DSHADERVECTOR* d) {
+}
+
+void pshader_texbem(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texbeml(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texreg2ar(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texreg2gb(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x2pad(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x2tex(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x3pad(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x3tex(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x3diff(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x3spec(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
+}
+
+void pshader_texm3x3vspec(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_cnd(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2) {
+}
+
+void pshader_def(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2, D3DSHADERVECTOR* s3) {
+}
+
+void pshader_texreg2rgb(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texdp3tex(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x2depth(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texdp3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texm3x3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
+}
+
+void pshader_texdepth(D3DSHADERVECTOR* d) {
+}
+
+void pshader_cmp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2) {
+}
+
+void pshader_bem(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
+}
+
+static CONST SHADER_OPCODE pshader_ins [] = {
+ {D3DSIO_NOP, "nop", 0, vshader_nop, 0, 0},
+ {D3DSIO_MOV, "mov", 2, vshader_mov, 0, 0},
+ {D3DSIO_ADD, "add", 3, vshader_add, 0, 0},
+ {D3DSIO_SUB, "sub", 3, vshader_sub, 0, 0},
+ {D3DSIO_MAD, "mad", 4, vshader_mad, 0, 0},
+ {D3DSIO_MUL, "mul", 3, vshader_mul, 0, 0},
+ {D3DSIO_RCP, "rcp", 2, vshader_rcp, 0, 0},
+ {D3DSIO_RSQ, "rsq", 2, vshader_rsq, 0, 0},
+ {D3DSIO_DP3, "dp3", 3, vshader_dp3, 0, 0},
+ {D3DSIO_DP4, "dp4", 3, vshader_dp4, 0, 0},
+ {D3DSIO_MIN, "min", 3, vshader_min, 0, 0},
+ {D3DSIO_MAX, "max", 3, vshader_max, 0, 0},
+ {D3DSIO_SLT, "slt", 3, vshader_slt, 0, 0},
+ {D3DSIO_SGE, "sge", 3, vshader_sge, 0, 0},
+ {D3DSIO_EXP, "exp", 2, vshader_exp, 0, 0},
+ {D3DSIO_LOG, "log", 2, vshader_log, 0, 0},
+ {D3DSIO_LIT, "lit", 2, vshader_lit, 0, 0},
+ {D3DSIO_DST, "dst", 3, vshader_dst, 0, 0},
+ {D3DSIO_LRP, "lrp", 5, vshader_lrp, 0, 0},
+ {D3DSIO_FRC, "frc", 2, vshader_frc, 0, 0},
+ {D3DSIO_M4x4, "m4x4", 3, vshader_m4x4, 0, 0},
+ {D3DSIO_M4x3, "m4x3", 3, vshader_m4x3, 0, 0},
+ {D3DSIO_M3x4, "m3x4", 3, vshader_m3x4, 0, 0},
+ {D3DSIO_M3x3, "m3x3", 3, vshader_m3x3, 0, 0},
+ {D3DSIO_M3x2, "m3x2", 3, vshader_m3x2, 0, 0},
+
+ {D3DSIO_TEXCOORD, "texcoord", 1, pshader_texcoord, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXKILL, "texkill", 1, pshader_texkill, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEX, "tex", 1, pshader_tex, D3DPS_VERSION(1,1), D3DPS_VERSION(1,4)},
+ {D3DSIO_TEXBEM, "texbem", 2, pshader_texbem, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXBEML, "texbeml", 2, pshader_texbeml, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXREG2AR, "texreg2ar", 2, pshader_texreg2ar, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXREG2GB, "texreg2gb", 2, pshader_texreg2gb, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x2PAD, "texm3x2pad", 2, pshader_texm3x2pad, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x2TEX, "texm3x2tex", 2, pshader_texm3x2tex, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x3PAD, "texm3x3pad", 2, pshader_texm3x3pad, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x3TEX, "texm3x3tex", 2, pshader_texm3x3tex, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x3DIFF, "texm3x3diff", 2, pshader_texm3x3diff, D3DPS_VERSION(0,0), D3DPS_VERSION(0,0)},
+ {D3DSIO_TEXM3x3SPEC, "texm3x3spec", 3, pshader_texm3x3spec, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x3VSPEC, "texm3x3vspec", 2, pshader_texm3x3vspec, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
+
+ {D3DSIO_EXPP, "expp", 2, vshader_expp, 0, 0},
+ {D3DSIO_LOGP, "logp", 2, vshader_logp, 0, 0},
+
+ {D3DSIO_CND, "cnd", 4, pshader_cnd, D3DPS_VERSION(1,1), D3DPS_VERSION(1,4)},
+ {D3DSIO_DEF, "def", 5, pshader_def, D3DPS_VERSION(1,1), D3DPS_VERSION(3,0)},
+ {D3DSIO_TEXREG2RGB, "texbreg2rgb", 2, pshader_texreg2rgb, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
+
+ {D3DSIO_TEXDP3TEX, "texdp3tex", 2, pshader_texdp3tex, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x2DEPTH, "texm3x2depth", 2, pshader_texm3x2depth, D3DPS_VERSION(1,3), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXDP3, "texdp3", 2, pshader_texdp3, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXM3x3, "texm3x3", 2, pshader_texm3x3, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
+ {D3DSIO_TEXDEPTH, "texdepth", 1, pshader_texdepth, D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
+ {D3DSIO_CMP, "cmp", 4, pshader_cmp, D3DPS_VERSION(1,1), D3DPS_VERSION(3,0)},
+ {D3DSIO_BEM, "bem", 3, pshader_bem, D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
+
+ {0, NULL, 0, NULL}
+};
+
+inline static const SHADER_OPCODE* pshader_program_get_opcode(const DWORD code) {
+ DWORD i = 0;
+ /** TODO: use dichotomic search */
+ while (NULL != pshader_ins[i].name) {
+ if ((code & D3DSI_OPCODE_MASK) == pshader_ins[i].opcode) {
+ return &pshader_ins[i];
+ }
+ ++i;
+ }
+ return NULL;
+}
+
+inline static void pshader_program_dump_opcode(const SHADER_OPCODE* curOpcode, const DWORD code, const DWORD output) {
+ if (0 != (code & ~D3DSI_OPCODE_MASK)) {
+ DWORD mask = (code & ~D3DSI_OPCODE_MASK);
+ switch (mask) {
+ case 0x40000000: TRACE("+"); break;
+ default:
+ TRACE(" unhandled modifier(0x%08lx) ", mask);
+ }
+ }
+ TRACE("%s", curOpcode->name);
+ /**
+ * normally this is a destination reg modifier
+ * but in pixel shaders asm code its specified as:
+ * dp3_x4 t1.rgba, r1, c1
+ * or
+ * dp3_x2_sat r0, t0_bx2, v0_bx2
+ * so for better debbuging i use the same norm
+ */
+ if (0 != (output & D3DSP_DSTSHIFT_MASK)) {
+ DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
+ if (shift > 0) {
+ TRACE("_x%u", 1 << shift);
+ }
+ }
+ /**
+ * TODO: fix the divide shifts: d2, d4, d8
+ * so i have to find a sample
+ */
+ if (0 != (output & D3DSP_DSTMOD_MASK)) {
+ DWORD mask = output & D3DSP_DSTMOD_MASK;
+ switch (mask) {
+ case D3DSPDM_SATURATE: TRACE("_sat"); break;
+ default:
+ TRACE("_unhandled_modifier(0x%08lx)", mask);
+ }
+ }
+ TRACE(" ");
+}
+
+inline static void pshader_program_dump_param(const DWORD param, int input) {
+ static const char* rastout_reg_names[] = { "oC0", "oC1", "oC2", "oC3", "oDepth" };
+ static const char swizzle_reg_chars[] = "rgba";
+
+ DWORD reg = param & 0x00001FFF;
+ DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
+
+ if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) {
+ TRACE("-");
+ }
+
+ switch (regtype << D3DSP_REGTYPE_SHIFT) {
+ case D3DSPR_TEMP:
+ TRACE("R[%lu]", reg);
+ break;
+ case D3DSPR_INPUT:
+ TRACE("V[%lu]", reg);
+ break;
+ case D3DSPR_CONST:
+ TRACE("C[%s%lu]", (reg & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
+ break;
+ case D3DSPR_TEXTURE: /* case D3DSPR_ADDR: */
+ TRACE("t[%lu]", reg);
+ break;
+ case D3DSPR_RASTOUT:
+ TRACE("%s", rastout_reg_names[reg]);
+ break;
+ case D3DSPR_ATTROUT:
+ TRACE("oD[%lu]", reg);
+ break;
+ case D3DSPR_TEXCRDOUT:
+ TRACE("oT[%lu]", reg);
+ break;
+ default:
+ break;
+ }
+
+ if (!input) {
+ /** operand output */
+ /**
+ * for better debugging traces it's done into opcode dump code
+ * @see pshader_program_dump_opcode
+ if (0 != (param & D3DSP_DSTMOD_MASK)) {
+ DWORD mask = param & D3DSP_DSTMOD_MASK;
+ switch (mask) {
+ case D3DSPDM_SATURATE: TRACE("_sat"); break;
+ default:
+ TRACE("_unhandled_modifier(0x%08lx)", mask);
+ }
+ }
+ if (0 != (param & D3DSP_DSTSHIFT_MASK)) {
+ DWORD shift = (param & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
+ if (shift > 0) {
+ TRACE("_x%u", 1 << shift);
+ }
+ }
+ */
+ if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
+ if (param & D3DSP_WRITEMASK_0) TRACE(".r");
+ if (param & D3DSP_WRITEMASK_1) TRACE(".g");
+ if (param & D3DSP_WRITEMASK_2) TRACE(".b");
+ if (param & D3DSP_WRITEMASK_3) TRACE(".a");
+ }
+ } else {
+ /** operand input */
+ DWORD swizzle = (param & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT;
+ DWORD swizzle_x = swizzle & 0x03;
+ DWORD swizzle_y = (swizzle >> 2) & 0x03;
+ DWORD swizzle_z = (swizzle >> 4) & 0x03;
+ DWORD swizzle_w = (swizzle >> 6) & 0x03;
+ /**
+ * swizzle bits fields:
+ * WWZZYYXX
+ */
+ if ((D3DSP_NOSWIZZLE >> D3DSP_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
+ if (swizzle_x == swizzle_y &&
+ swizzle_x == swizzle_z &&
+ swizzle_x == swizzle_w) {
+ TRACE(".%c", swizzle_reg_chars[swizzle_x]);
+ } else {
+ TRACE(".%c%c%c%c",
+ swizzle_reg_chars[swizzle_x],
+ swizzle_reg_chars[swizzle_y],
+ swizzle_reg_chars[swizzle_z],
+ swizzle_reg_chars[swizzle_w]);
+ }
+ }
+ if (0 != (param & D3DSP_SRCMOD_MASK)) {
+ DWORD mask = param & D3DSP_SRCMOD_MASK;
+ /*TRACE("_modifier(0x%08lx) ", mask);*/
+ switch (mask) {
+ case D3DSPSM_NONE: break;
+ case D3DSPSM_NEG: break;
+ case D3DSPSM_BIAS: TRACE("_bias"); break;
+ case D3DSPSM_BIASNEG: TRACE("_bias"); break;
+ case D3DSPSM_SIGN: TRACE("_sign"); break;
+ case D3DSPSM_SIGNNEG: TRACE("_sign"); break;
+ case D3DSPSM_COMP: TRACE("_comp"); break;
+ case D3DSPSM_X2: TRACE("_x2"); break;
+ case D3DSPSM_X2NEG: TRACE("_bx2"); break;
+ case D3DSPSM_DZ: TRACE("_dz"); break;
+ case D3DSPSM_DW: TRACE("_dw"); break;
+ default:
+ TRACE("_unknown(0x%08lx)", mask);
+ }
+ }
+ }
+}
+
+inline static BOOL pshader_is_version_token(DWORD token) {
+ return 0xFFFF0000 == (token & 0xFFFF0000);
+}
+
+inline static BOOL pshader_is_comment_token(DWORD token) {
+ return D3DSIO_COMMENT == (token & D3DSI_OPCODE_MASK);
+}
+
+
+
+/**
+ * Pixel Shaders
+ *
+ * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/PixelShader1_X/modifiers/sourceregistermodifiers.asp
+ * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/PixelShader2_0/Registers/Registers.asp
+ * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/IDirect3DPixelShader9/_IDirect3DPixelShader9.asp
+ *
+ */
+inline static VOID IDirect3DPixelShaderImpl_ParseProgram(IDirect3DPixelShaderImpl* pshader, CONST DWORD* pFunction) {
+ const DWORD* pToken = pFunction;
+ const SHADER_OPCODE* curOpcode = NULL;
+ DWORD code;
+ DWORD len = 0;
+ DWORD i;
+
+ if (NULL != pToken) {
+ while (D3DPS_END() != *pToken) {
+ if (pshader_is_version_token(*pToken)) { /** version */
+ TRACE("ps.%lu.%lu\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
+ ++pToken;
+ ++len;
+ continue;
+ }
+ if (pshader_is_comment_token(*pToken)) { /** comment */
+ DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
+ ++pToken;
+ /*TRACE("comment[%ld] ;%s\n", comment_len, (char*)pToken);*/
+ pToken += comment_len;
+ len += comment_len + 1;
+ continue;
+ }
+ code = *pToken;
+ curOpcode = pshader_program_get_opcode(code);
+ ++pToken;
+ ++len;
+ if (NULL == curOpcode) {
+ /* unkown current opcode ... */
+ while (*pToken & 0x80000000) {
+ TRACE("unrecognized opcode: %08lx\n", *pToken);
+ ++pToken;
+ ++len;
+ }
+ } else {
+ TRACE(" ");
+ pshader_program_dump_opcode(curOpcode, code, *pToken);
+ if (curOpcode->num_params > 0) {
+ pshader_program_dump_param(*pToken, 0);
+ ++pToken;
+ ++len;
+ for (i = 1; i < curOpcode->num_params; ++i) {
+ TRACE(", ");
+ if (D3DSIO_DEF != code) {
+ pshader_program_dump_param(*pToken, 1);
+ } else {
+ TRACE("%f", *((float*) pToken));
+ }
+ ++pToken;
+ ++len;
+ }
+ }
+ TRACE("\n");
+ }
+ pshader->functionLength = (len + 1) * sizeof(DWORD);
+ }
+ } else {
+ pshader->functionLength = 1; /* no Function defined use fixed function vertex processing */
+ }
+ if (NULL != pFunction) {
+ pshader->function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pshader->functionLength);
+ memcpy(pshader->function, pFunction, pshader->functionLength);
+ } else {
+ pshader->function = NULL;
+ }
+}
+
+HRESULT WINAPI IDirect3DDeviceImpl_CreatePixelShader(IDirect3DDevice8Impl* This, CONST DWORD* pFunction, IDirect3DPixelShaderImpl** ppPixelShader) {
+ IDirect3DPixelShaderImpl* object;
+
+ object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DPixelShaderImpl));
+ if (NULL == object) {
+ *ppPixelShader = NULL;
+ return D3DERR_OUTOFVIDEOMEMORY;
+ }
+ /*object->lpVtbl = &Direct3DPixelShader9_Vtbl;*/
+ object->device = This;
+ object->ref = 1;
+
+ object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PSHADERDATA8));
+
+ IDirect3DPixelShaderImpl_ParseProgram(object, pFunction);
+
+ *ppPixelShader = object;
+ return D3D_OK;
+}
+
+HRESULT WINAPI IDirect3DPixelShaderImpl_GetFunction(IDirect3DPixelShaderImpl* This, VOID* pData, UINT* pSizeOfData) {
+ if (NULL == pData) {
+ *pSizeOfData = This->functionLength;
+ return D3D_OK;
+ }
+ if (*pSizeOfData < This->functionLength) {
+ *pSizeOfData = This->functionLength;
+ return D3DERR_MOREDATA;
+ }
+ if (NULL == This->function) { /* no function defined */
+ TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
+ (*(DWORD **) pData) = NULL;
+ } else {
+ TRACE("(%p) : GetFunction copying to %p\n", This, pData);
+ memcpy(pData, This->function, This->functionLength);
+ }
+ return D3D_OK;
+}
+
+HRESULT WINAPI IDirect3DPixelShaderImpl_SetConstantF(IDirect3DPixelShaderImpl* This, UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount) {
+ if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
+ return D3DERR_INVALIDCALL;
+ }
+ if (NULL == This->data) { /* temporary while datas not supported */
+ FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This);
+ return D3DERR_INVALIDCALL;
+ }
+ memcpy(&This->data->C[StartRegister], pConstantData, Vector4fCount * 4 * sizeof(FLOAT));
+ return D3D_OK;
+}
+
+HRESULT WINAPI IDirect3DPixelShaderImpl_GetConstantF(IDirect3DPixelShaderImpl* This, UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount) {
+ if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
+ return D3DERR_INVALIDCALL;
+ }
+ if (NULL == This->data) { /* temporary while datas not supported */
+ return D3DERR_INVALIDCALL;
+ }
+ memcpy(pConstantData, &This->data->C[StartRegister], Vector4fCount * 4 * sizeof(FLOAT));
+ return D3D_OK;
+}
+
+
+/**********************************************************************************************************************************************
+ **********************************************************************************************************************************************
+ **********************************************************************************************************************************************
+ **********************************************************************************************************************************************
+ **********************************************************************************************************************************************/
+
/***********************************************************************
* ValidateVertexShader (D3D8.@)
*/
@@ -850,7 +1304,7 @@
/***********************************************************************
* ValidatePixelShader (D3D8.@)
*/
-BOOL WINAPI ValidatePixelShader(LPVOID what) {
- FIXME("(void): stub: %p\n", what);
+BOOL WINAPI ValidatePixelShader(LPVOID what, LPVOID toto) {
+ FIXME("(void): stub: %p %p\n", what, toto);
return TRUE;
}
Seulement dans .: shader.o
Seulement dans .: stateblock.o
Seulement dans .: surface.o
Seulement dans .: swapchain.o
Seulement dans .: texture.o
diff -u /cvs-src/wine-pending/d3d8_43/utils.c ./utils.c
--- /cvs-src/wine-pending/d3d8_43/utils.c 2003-05-30 00:09:35.000000000 +0200
+++ ./utils.c 2003-05-30 00:10:21.000000000 +0200
@@ -469,3 +469,617 @@
}
}
+/* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
+#if defined (GL_VERSION_1_3)
+ #define useext(A) A
+ #define combine_ext 1
+#elif defined (GL_EXT_texture_env_combine)
+ #define useext(A) A##_EXT
+ #define combine_ext 1
+#elif defined (GL_ARB_texture_env_combine)
+ #define useext(A) A##_ARB
+ #define combine_ext 1
+#else
+ #undef combine_ext
+#endif
+
+#if !defined(combine_ext)
+void set_tex_op(LPDIRECT3DDEVICE8 iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
+{
+ FIXME("Requires opengl combine extensions to work\n");
+ return;
+}
+#else
+/* Setup the texture operations texture stage states */
+void set_tex_op(LPDIRECT3DDEVICE8 iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
+{
+ GLenum src1, src2, src3;
+ GLenum opr1, opr2, opr3;
+ GLenum comb_target;
+ GLenum src0_target, src1_target, src2_target;
+ GLenum opr0_target, opr1_target, opr2_target;
+ GLenum scal_target;
+ GLenum opr=0, invopr, src3_target, opr3_target;
+ BOOL Handled = FALSE;
+ ICOM_THIS(IDirect3DDevice8Impl,iface);
+
+ TRACE("Alpha?(%d), Stage:%d Op(%d), a1(%ld), a2(%ld), a3(%ld)\n", isAlpha, Stage, op, arg1, arg2, arg3);
+ if (op == D3DTOP_DISABLE) return;
+
+ if (isAlpha) {
+ comb_target = useext(GL_COMBINE_ALPHA);
+ src0_target = useext(GL_SOURCE0_ALPHA);
+ src1_target = useext(GL_SOURCE1_ALPHA);
+ src2_target = useext(GL_SOURCE2_ALPHA);
+ opr0_target = useext(GL_OPERAND0_ALPHA);
+ opr1_target = useext(GL_OPERAND1_ALPHA);
+ opr2_target = useext(GL_OPERAND2_ALPHA);
+ scal_target = useext(GL_ALPHA_SCALE);
+ }
+ else {
+ comb_target = useext(GL_COMBINE_RGB);
+ src0_target = useext(GL_SOURCE0_RGB);
+ src1_target = useext(GL_SOURCE1_RGB);
+ src2_target = useext(GL_SOURCE2_RGB);
+ opr0_target = useext(GL_OPERAND0_RGB);
+ opr1_target = useext(GL_OPERAND1_RGB);
+ opr2_target = useext(GL_OPERAND2_RGB);
+ scal_target = useext(GL_RGB_SCALE);
+ }
+
+ /* From MSDN (D3DTSS_ALPHAARG1) :
+ The default argument is D3DTA_TEXTURE. If no texture is set for this stage,
+ then the default argument is D3DTA_DIFFUSE.
+ FIXME? If texture added/removed, may need to reset back as well? */
+ if (isAlpha && Stage==0 && This->StateBlock->textures[Stage] == NULL && arg1 == D3DTA_TEXTURE) {
+ GetSrcAndOpFromValue(D3DTA_DIFFUSE, isAlpha, &src1, &opr1);
+ } else {
+ GetSrcAndOpFromValue(arg1, isAlpha, &src1, &opr1);
+ }
+ GetSrcAndOpFromValue(arg2, isAlpha, &src2, &opr2);
+ GetSrcAndOpFromValue(arg3, isAlpha, &src3, &opr3);
+
+ TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
+
+ Handled = TRUE; /* Assume will be handled */
+ switch (op) {
+ case D3DTOP_SELECTARG1:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_SELECTARG2:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_MODULATE:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_MODULATE2X:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
+ break;
+ case D3DTOP_MODULATE4X:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
+ break;
+ case D3DTOP_ADD:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_ADDSIGNED:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_ADDSIGNED2X:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
+ break;
+ case D3DTOP_SUBTRACT:
+#if defined(GL_VERSION_1_3) || defined (GL_ARB_texture_env_combine)
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+#else
+ FIXME("This version of opengl does not support GL_SUBTRACT\n");
+#endif
+ break;
+ case D3DTOP_BLENDDIFFUSEALPHA:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_BLENDTEXTUREALPHA:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_BLENDFACTORALPHA:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_CONSTANT);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_BLENDCURRENTALPHA:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_PREVIOUS);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_DOTPRODUCT3:
+#if defined(GL_EXT_texture_env_dot3)
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
+#elif defined(GL_ARB_texture_env_dot3)
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
+#elif defined (GL_VERSION_1_3)
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA");
+#else
+ FIXME("This version of opengl does not support GL_DOT3\n");
+#endif
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_LERP:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
+ checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src3);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src3");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr3);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr3");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ default:
+ Handled = FALSE;
+ }
+ if (Handled) {
+#if defined(GL_NV_texture_env_combine4)
+ /* Note: If COMBINE4 in effect cant go back to combine! */
+ if (isAlpha) {
+ switch (This->UpdateStateBlock->texture_state[Stage][D3DTSS_COLOROP])
+ {
+ case D3DTOP_ADDSMOOTH:
+ case D3DTOP_BLENDTEXTUREALPHAPM:
+ case D3DTOP_MODULATEALPHA_ADDCOLOR:
+ case D3DTOP_MODULATECOLOR_ADDALPHA:
+ case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
+ case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
+ case D3DTOP_MULTIPLYADD:
+ FIXME("Cant have COMBINE4 and COMBINE in efferct together, alphaop=%d\n", op);
+ return;
+ }
+ }
+#endif
+ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
+ checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
+ return;
+ }
+
+ /* Other texture operations require special extensions: */
+#if defined(GL_NV_texture_env_combine4)
+ if (isAlpha) {
+ invopr = GL_ONE_MINUS_SRC_ALPHA;
+ src3_target = GL_SOURCE3_ALPHA_NV;
+ opr3_target = GL_OPERAND3_ALPHA_NV;
+ }
+ else {
+ invopr = GL_ONE_MINUS_SRC_COLOR;
+ src3_target = GL_SOURCE3_RGB_NV;
+ opr3_target = GL_OPERAND3_RGB_NV;
+ }
+ Handled = TRUE; /* Again, assume handled */
+ switch (op) {
+ case D3DTOP_ADDSMOOTH:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
+ switch (opr1) {
+ case GL_SRC_COLOR: opr1 = GL_ONE_MINUS_SRC_COLOR; break;
+ case GL_ONE_MINUS_SRC_COLOR: opr1 = GL_SRC_COLOR; break;
+ case GL_SRC_ALPHA: opr1 = GL_ONE_MINUS_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_ALPHA: opr1 = GL_SRC_ALPHA; break;
+ }
+ glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_BLENDTEXTUREALPHAPM:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
+ checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
+ glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
+ checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_MODULATEALPHA_ADDCOLOR:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1); /* a0 = src1/opr1 */
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src2); /* a2 = arg2 */
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
+ glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
+ switch (opr1) {
+ case GL_SRC_COLOR: opr1 = GL_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_COLOR: opr1 = GL_ONE_MINUS_SRC_ALPHA; break;
+ }
+ glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_MODULATECOLOR_ADDALPHA:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
+ switch (opr1) {
+ case GL_SRC_COLOR: opr1 = GL_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_COLOR: opr1 = GL_ONE_MINUS_SRC_ALPHA; break;
+ }
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
+ checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
+ glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
+ checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
+ switch (opr1) {
+ case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
+ case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
+ }
+ glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
+ checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ switch (opr1) {
+ case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
+ case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
+ case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
+ }
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
+ switch (opr1) {
+ case GL_SRC_COLOR: opr1 = GL_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_COLOR: opr1 = GL_ONE_MINUS_SRC_ALPHA; break;
+ }
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
+ checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
+ glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
+ checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+ case D3DTOP_MULTIPLYADD:
+ glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
+ checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
+ glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
+ checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
+ glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
+ checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
+ glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
+ checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
+ glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
+ checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
+ glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
+ checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
+ glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
+ checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
+ glTexEnvi(GL_TEXTURE_ENV, src3_target, src3);
+ checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
+ glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr3);
+ checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
+ glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
+ checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
+ break;
+
+ default:
+ Handled = FALSE;
+ }
+ if (Handled) {
+ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
+ checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
+ return;
+ }
+#endif /* GL_NV_texture_env_combine4 */
+
+ /* After all the extensions, if still unhandled, report fixme */
+ FIXME("Unhandled texture operation %d\n", op);
+}
+#endif
+
+/**
+ * @nodoc: todo
+ */
+void GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum* operand)
+{
+ BOOL isAlphaReplicate = FALSE;
+ BOOL isComplement = FALSE;
+
+ *operand = GL_SRC_COLOR;
+ *source = GL_TEXTURE;
+
+ /* Catch alpha replicate */
+ if (iValue & D3DTA_ALPHAREPLICATE) {
+ iValue = iValue & ~D3DTA_ALPHAREPLICATE;
+ isAlphaReplicate = TRUE;
+ }
+
+ /* Catch Complement */
+ if (iValue & D3DTA_COMPLEMENT) {
+ iValue = iValue & ~D3DTA_COMPLEMENT;
+ isComplement = TRUE;
+ }
+
+ /* Calculate the operand */
+ if (isAlphaReplicate && !isComplement) {
+ *operand = GL_SRC_ALPHA;
+ } else if (isAlphaReplicate && isComplement) {
+ *operand = GL_ONE_MINUS_SRC_ALPHA;
+ } else if (isComplement) {
+ if (isAlphaArg) {
+ *operand = GL_ONE_MINUS_SRC_ALPHA;
+ } else {
+ *operand = GL_ONE_MINUS_SRC_COLOR;
+ }
+ } else {
+ if (isAlphaArg) {
+ *operand = GL_SRC_ALPHA;
+ } else {
+ *operand = GL_SRC_COLOR;
+ }
+ }
+
+ /* Calculate the source */
+ switch (iValue & D3DTA_SELECTMASK) {
+ case D3DTA_CURRENT: *source = GL_PREVIOUS_EXT;
+ break;
+ case D3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT;
+ break;
+ case D3DTA_TEXTURE: *source = GL_TEXTURE;
+ break;
+ case D3DTA_TFACTOR: *source = GL_CONSTANT_EXT;
+ break;
+ case D3DTA_SPECULAR:
+ /**
+ * According to the GL_ARB_texture_env_combine specs, SPECULAR is 'Secondary color' and
+ * isnt supported until base GL supports it
+ * There is no concept of temp registers as far as I can tell
+ */
+
+ default:
+ FIXME("Unrecognized or unhandled texture arg %ld\n", iValue);
+ *source = GL_TEXTURE;
+ }
+}
More information about the wine-devel
mailing list