*/
/** Vertex Shader Declaration 8 data types tokens */
-#if 0
#define MAX_VSHADER_DECL_TYPES 8
-static CONST char* VertexShader8_DeclDataTypes[] = {
+
+static CONST char* VertexDecl8_DataTypes[] = {
"D3DVSDT_FLOAT1",
"D3DVSDT_FLOAT2",
"D3DVSDT_FLOAT3",
"D3DVSDT_SHORT4",
NULL
};
+
+static CONST char* VertexDecl8_Registers[] = {
+ "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
+};
+
+typedef enum _D3DVSD_TOKENTYPE {
+ D3DVSD_TOKEN_NOP = 0,
+ D3DVSD_TOKEN_STREAM = 1,
+ D3DVSD_TOKEN_STREAMDATA = 2,
+ D3DVSD_TOKEN_TESSELLATOR = 3,
+ D3DVSD_TOKEN_CONSTMEM = 4,
+ D3DVSD_TOKEN_EXT = 5,
+ /* RESERVED = 6 */
+ D3DVSD_TOKEN_END = 7,
+ D3DVSD_FORCE_DWORD = 0x7FFFFFFF
+} D3DVSD_TOKENTYPE;
+
+typedef enum _D3DVSDE_REGISTER {
+ D3DVSDE_POSITION = 0,
+ D3DVSDE_BLENDWEIGHT = 1,
+ D3DVSDE_BLENDINDICES = 2,
+ D3DVSDE_NORMAL = 3,
+ D3DVSDE_PSIZE = 4,
+ D3DVSDE_DIFFUSE = 5,
+ D3DVSDE_SPECULAR = 6,
+ D3DVSDE_TEXCOORD0 = 7,
+ D3DVSDE_TEXCOORD1 = 8,
+ D3DVSDE_TEXCOORD2 = 9,
+ D3DVSDE_TEXCOORD3 = 10,
+ D3DVSDE_TEXCOORD4 = 11,
+ D3DVSDE_TEXCOORD5 = 12,
+ D3DVSDE_TEXCOORD6 = 13,
+ D3DVSDE_TEXCOORD7 = 14,
+ D3DVSDE_POSITION2 = 15,
+ D3DVSDE_NORMAL2 = 16
+} D3DVSDE_REGISTER;
+
+typedef enum _D3DVSDT_TYPE {
+ D3DVSDT_FLOAT1 = 0x00,
+ D3DVSDT_FLOAT2 = 0x01,
+ D3DVSDT_FLOAT3 = 0x02,
+ D3DVSDT_FLOAT4 = 0x03,
+ D3DVSDT_D3DCOLOR = 0x04,
+ D3DVSDT_UBYTE4 = 0x05,
+ D3DVSDT_SHORT2 = 0x06,
+ D3DVSDT_SHORT4 = 0x07
+} D3DVSDT_TYPE;
+
+
+#define D3DVSD_CONSTADDRESSSHIFT 0
+#define D3DVSD_EXTINFOSHIFT 0
+#define D3DVSD_STREAMNUMBERSHIFT 0
+#define D3DVSD_VERTEXREGSHIFT 0
+#define D3DVSD_CONSTRSSHIFT 16
+#define D3DVSD_DATATYPESHIFT 16
+#define D3DVSD_SKIPCOUNTSHIFT 16
+#define D3DVSD_VERTEXREGINSHIFT 20
+#define D3DVSD_EXTCOUNTSHIFT 24
+#define D3DVSD_CONSTCOUNTSHIFT 25
+#define D3DVSD_DATALOADTYPESHIFT 28
+#define D3DVSD_STREAMTESSSHIFT 28
+#define D3DVSD_TOKENTYPESHIFT 29
+
+#define D3DVSD_CONSTADDRESSMASK (0x7F << D3DVSD_CONSTADDRESSSHIFT)
+#define D3DVSD_EXTINFOMASK (0xFFFFFF << D3DVSD_EXTINFOSHIFT)
+#define D3DVSD_STREAMNUMBERMASK (0xF << D3DVSD_STREAMNUMBERSHIFT)
+#define D3DVSD_VERTEXREGMASK (0x1F << D3DVSD_VERTEXREGSHIFT)
+#define D3DVSD_CONSTRSMASK (0x1FFF << D3DVSD_CONSTRSSHIFT)
+#define D3DVSD_DATATYPEMASK (0xF << D3DVSD_DATATYPESHIFT)
+#define D3DVSD_SKIPCOUNTMASK (0xF << D3DVSD_SKIPCOUNTSHIFT)
+#define D3DVSD_EXTCOUNTMASK (0x1F << D3DVSD_EXTCOUNTSHIFT)
+#define D3DVSD_VERTEXREGINMASK (0xF << D3DVSD_VERTEXREGINSHIFT)
+#define D3DVSD_CONSTCOUNTMASK (0xF << D3DVSD_CONSTCOUNTSHIFT)
+#define D3DVSD_DATALOADTYPEMASK (0x1 << D3DVSD_DATALOADTYPESHIFT)
+#define D3DVSD_STREAMTESSMASK (0x1 << D3DVSD_STREAMTESSSHIFT)
+#define D3DVSD_TOKENTYPEMASK (0x7 << D3DVSD_TOKENTYPESHIFT)
+
+#define D3DVSD_END() 0xFFFFFFFF
+#define D3DVSD_NOP() 0x00000000
+
+DWORD IWineD3DVertexDeclarationImpl_ParseToken8(const DWORD* pToken) {
+ const DWORD token = *pToken;
+ DWORD tokenlen = 1;
+
+ switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
+ case D3DVSD_TOKEN_NOP:
+ TRACE(" 0x%08lx NOP()\n", token);
+ break;
+ case D3DVSD_TOKEN_STREAM:
+ if (token & D3DVSD_STREAMTESSMASK) {
+ TRACE(" 0x%08lx STREAM_TESS()\n", token);
+ } else {
+ TRACE(" 0x%08lx STREAM(%lu)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
+ }
+ break;
+ case D3DVSD_TOKEN_STREAMDATA:
+ if (token & 0x10000000) {
+ TRACE(" 0x%08lx SKIP(%lu)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
+ } else {
+ DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
+ DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
+ TRACE(" 0x%08lx REG(%s, %s)\n", token, VertexDecl8_Registers[reg], VertexDecl8_DataTypes[type]);
+ }
+ break;
+ case D3DVSD_TOKEN_TESSELLATOR:
+ if (token & 0x10000000) {
+ DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
+ DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
+ TRACE(" 0x%08lx TESSUV(%s) as %s\n", token, VertexDecl8_Registers[reg], VertexDecl8_DataTypes[type]);
+ } else {
+ DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
+ DWORD regout = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
+ DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
+ TRACE(" 0x%08lx TESSNORMAL(%s, %s) as %s\n", token, VertexDecl8_Registers[regin], VertexDecl8_Registers[regout], VertexDecl8_DataTypes[type]);
+ }
+ break;
+ case D3DVSD_TOKEN_CONSTMEM:
+ {
+ DWORD i;
+ DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
+ DWORD constaddress = ((token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
+ TRACE(" 0x%08lx CONST(%lu, %lu)\n", token, constaddress, count);
+ ++pToken;
+ for (i = 0; i < count; ++i) {
+#if 0
+ TRACE(" c[%lu] = (0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx)\n",
+ constaddress,
+ *pToken,
+ *(pToken + 1),
+ *(pToken + 2),
+ *(pToken + 3));
#endif
+ TRACE(" c[%lu] = (%8f, %8f, %8f, %8f)\n",
+ constaddress,
+ *(const float*) pToken,
+ *(const float*) (pToken + 1),
+ *(const float*) (pToken + 2),
+ *(const float*) (pToken + 3));
+ pToken += 4;
+ ++constaddress;
+ }
+ tokenlen = (4 * count) + 1;
+ }
+ break;
+ case D3DVSD_TOKEN_EXT:
+ {
+ DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
+ DWORD extinfo = ((token & D3DVSD_EXTINFOMASK) >> D3DVSD_EXTINFOSHIFT);
+ TRACE(" 0x%08lx EXT(%lu, %lu)\n", token, count, extinfo);
+ /* todo ... print extension */
+ tokenlen = count + 1;
+ }
+ break;
+ case D3DVSD_TOKEN_END:
+ TRACE(" 0x%08lx END()\n", token);
+ break;
+ default:
+ TRACE(" 0x%08lx UNKNOWN\n", token);
+ /* argg error */
+ }
+ return tokenlen;
+}
+
+HRESULT IWineD3DVertexDeclarationImpl_ParseDeclaration8(IWineD3DDeviceImpl* This, const DWORD* pDecl, IWineD3DVertexDeclarationImpl* object) {
+ const DWORD* pToken = pDecl;
+ DWORD fvf = 0;
+ BOOL invalid_fvf = FALSE;
+ DWORD tex = D3DFVF_TEX0;
+ DWORD len = 0;
+ DWORD stream = 0;
+ DWORD token;
+ DWORD tokenlen;
+ DWORD tokentype;
+
+ TRACE("(%p) : pDecl(%p)\n", This, pDecl);
+
+ while (D3DVSD_END() != *pToken) {
+ token = *pToken;
+ tokenlen = IWineD3DVertexDeclarationImpl_ParseToken8(pToken);
+ tokentype = ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
+
+ /** FVF generation block */
+ if (D3DVSD_TOKEN_STREAM == tokentype && 0 == (D3DVSD_STREAMTESSMASK & token)) {
+ /**
+ * how really works streams,
+ * in DolphinVS dx8 dsk sample they seems to decal reg numbers !!!
+ */
+ DWORD oldStream = stream;
+ stream = ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
+
+ /* copy fvf if valid */
+ if (FALSE == invalid_fvf) {
+ fvf |= tex << D3DFVF_TEXCOUNT_SHIFT;
+ tex = 0;
+ object->fvf[oldStream] = fvf;
+ object->allFVF |= fvf;
+ } else {
+ object->fvf[oldStream] = 0;
+ tex = 0;
+ }
+
+ /* reset valid/invalid fvf */
+ fvf = 0;
+ invalid_fvf = FALSE;
+
+ } else if (D3DVSD_TOKEN_STREAMDATA == tokentype && 0 == (0x10000000 & tokentype)) {
+ DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
+ DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
+
+ switch (reg) {
+ case D3DVSDE_POSITION:
+ switch (type) {
+ case D3DVSDT_FLOAT3: fvf |= D3DFVF_XYZ; break;
+ case D3DVSDT_FLOAT4: fvf |= D3DFVF_XYZRHW; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ if (type >= MAX_VSHADER_DECL_TYPES) {
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_POSITION register: unsupported and unrecognized type %08lx\n", type);
+ } else {
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_POSITION register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ }
+ break;
+
+ case D3DVSDE_BLENDWEIGHT:
+ switch (type) {
+ case D3DVSDT_FLOAT1: fvf |= D3DFVF_XYZB1; break;
+ case D3DVSDT_FLOAT2: fvf |= D3DFVF_XYZB2; break;
+ case D3DVSDT_FLOAT3: fvf |= D3DFVF_XYZB3; break;
+ case D3DVSDT_FLOAT4: fvf |= D3DFVF_XYZB4; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_BLENDWEIGHT register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ break;
+
+ case D3DVSDE_BLENDINDICES: /* seem to be B5 as said in MSDN Dx9SDK ?? */
+ switch (type) {
+ case D3DVSDT_UBYTE4: fvf |= D3DFVF_LASTBETA_UBYTE4; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_BLENDINDINCES register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ break;
+
+ case D3DVSDE_NORMAL: /* TODO: only FLOAT3 supported ... another choice possible ? */
+ switch (type) {
+ case D3DVSDT_FLOAT3: fvf |= D3DFVF_NORMAL; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_NORMAL register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ break;
+
+ case D3DVSDE_PSIZE: /* TODO: only FLOAT1 supported ... another choice possible ? */
+ switch (type) {
+ case D3DVSDT_FLOAT1: fvf |= D3DFVF_PSIZE; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_PSIZE register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ break;
+
+ case D3DVSDE_DIFFUSE: /* TODO: only D3DCOLOR supported */
+ switch (type) {
+ case D3DVSDT_D3DCOLOR: fvf |= D3DFVF_DIFFUSE; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_DIFFUSE register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ break;
+
+ case D3DVSDE_SPECULAR: /* TODO: only D3DCOLOR supported */
+ switch (type) {
+ case D3DVSDT_D3DCOLOR: fvf |= D3DFVF_SPECULAR; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_SPECULAR register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ break;
+
+ case D3DVSDE_TEXCOORD0:
+ case D3DVSDE_TEXCOORD1:
+ case D3DVSDE_TEXCOORD2:
+ case D3DVSDE_TEXCOORD3:
+ case D3DVSDE_TEXCOORD4:
+ case D3DVSDE_TEXCOORD5:
+ case D3DVSDE_TEXCOORD6:
+ case D3DVSDE_TEXCOORD7:
+ /* Fixme? - assume all tex coords in same stream */
+ {
+ int texNo = 1 + (reg - D3DVSDE_TEXCOORD0);
+ tex = max(tex, texNo);
+ switch (type) {
+ case D3DVSDT_FLOAT1: fvf |= D3DFVF_TEXCOORDSIZE1(texNo); break;
+ case D3DVSDT_FLOAT2: fvf |= D3DFVF_TEXCOORDSIZE2(texNo); break;
+ case D3DVSDT_FLOAT3: fvf |= D3DFVF_TEXCOORDSIZE3(texNo); break;
+ case D3DVSDT_FLOAT4: fvf |= D3DFVF_TEXCOORDSIZE4(texNo); break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexShader declaration of D3DVSDE_TEXCOORD? register: unsupported type %s\n", VertexDecl8_DataTypes[type]);
+ }
+ }
+ break;
+
+ 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 ;( */
+ FIXME("[%lu] registers in VertexShader declaration not supported yet (token:0x%08lx)\n", reg, token);
+ break;
+ }
+ TRACE("VertexShader declaration define %lx as current FVF\n", fvf);
+ }
+ len += tokenlen;
+ pToken += tokenlen;
+ }
+ /* here D3DVSD_END() */
+ len += IWineD3DVertexDeclarationImpl_ParseToken8(pToken);
+
+ /* copy fvf if valid */
+ if (FALSE == invalid_fvf) {
+ fvf |= tex << D3DFVF_TEXCOUNT_SHIFT;
+ object->fvf[stream] = fvf;
+ object->allFVF |= fvf;
+ } else {
+ object->fvf[stream] = 0;
+ }
+ TRACE("Completed, allFVF = %lx\n", object->allFVF);
+
+ /* compute size */
+ object->declaration8Length = len * sizeof(DWORD);
+ /* copy the declaration */
+ object->pDeclaration8 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->declaration8Length);
+ memcpy(object->pDeclaration8, pDecl, object->declaration8Length);
+ /* returns */
+ return D3D_OK;
+}
+
+static CONST char* VertexDecl9_DeclUsages[] = {
+ "D3DDECLUSAGE_POSITION",
+ "D3DDECLUSAGE_BLENDWEIGHT",
+ "D3DDECLUSAGE_BLENDINDICES",
+ "D3DDECLUSAGE_NORMAL",
+ "D3DDECLUSAGE_PSIZE",
+ "D3DDECLUSAGE_TEXCOORD",
+ "D3DDECLUSAGE_TANGENT",
+ "D3DDECLUSAGE_BINORMAL",
+ "D3DDECLUSAGE_TESSFACTOR",
+ "D3DDECLUSAGE_POSITIONT",
+ "D3DDECLUSAGE_COLOR",
+ "D3DDECLUSAGE_FOG",
+ "D3DDECLUSAGE_DEPTH",
+ "D3DDECLUSAGE_SAMPLE",
+ NULL
+};
+
+static CONST char* VertexDecl9_DeclMethods[] = {
+ "D3DDECLMETHOD_DEFAULT",
+ "D3DDECLMETHOD_PARTIALU",
+ "D3DDECLMETHOD_PARTIALV",
+ "D3DDECLMETHOD_CROSSUV",
+ "D3DDECLMETHOD_UV",
+ "D3DDECLMETHOD_LOOKUP",
+ "D3DDECLMETHOD_LOOKUPPRESAMPLED",
+ NULL
+};
+
+static CONST char* VertexDecl9_DeclTypes[] = {
+ "D3DDECLTYPE_FLOAT1",
+ "D3DDECLTYPE_FLOAT2",
+ "D3DDECLTYPE_FLOAT3",
+ "D3DDECLTYPE_FLOAT4",
+ "D3DDECLTYPE_D3DCOLOR",
+ "D3DDECLTYPE_UBYTE4",
+ "D3DDECLTYPE_SHORT2",
+ "D3DDECLTYPE_SHORT4",
+ /* VS 2.0 */
+ "D3DDECLTYPE_UBYTE4N",
+ "D3DDECLTYPE_SHORT2N",
+ "D3DDECLTYPE_SHORT4N",
+ "D3DDECLTYPE_USHORT2N",
+ "D3DDECLTYPE_USHORT4N",
+ "D3DDECLTYPE_UDEC3",
+ "D3DDECLTYPE_DEC3N",
+ "D3DDECLTYPE_FLOAT16_2",
+ "D3DDECLTYPE_FLOAT16_4",
+ "D3DDECLTYPE_UNUSED",
+ NULL
+};
+
+HRESULT IWineD3DVertexDeclarationImpl_ParseDeclaration9(IWineD3DDeviceImpl* This, const D3DVERTEXELEMENT9* pDecl, IWineD3DVertexDeclarationImpl* object) {
+ const D3DVERTEXELEMENT9* pToken = pDecl;
+ DWORD fvf = 0;
+ BOOL invalid_fvf = FALSE;
+ DWORD tex = D3DFVF_TEX0;
+ DWORD len = 0;
+ DWORD stream = 0;
+
+ TRACE("(%p) : pDecl(%p)\n", This, pDecl);
+
+ while (0xFF != pToken->Stream) {
+ DWORD type = pToken->Type;
+ DWORD oldStream = stream;
+ stream = pToken->Stream;
+
+ if (D3DDECLMETHOD_DEFAULT != pToken->Method) {
+ WARN(
+ "%s register: Unsupported Method of %s (only D3DDECLMETHOD_DEFAULT for now) for VertexDeclaration (type %s)\n",
+ VertexDecl9_DeclUsages[pToken->Usage],
+ VertexDecl9_DeclMethods[pToken->Method],
+ VertexDecl9_DeclTypes[pToken->Type]
+ );
+ }
+
+ if (oldStream != stream) {
+
+ if (FALSE == invalid_fvf) {
+ fvf |= tex << D3DFVF_TEXCOUNT_SHIFT;
+ tex = 0;
+ object->fvf[oldStream] = fvf;
+ object->allFVF |= fvf;
+ } else {
+ object->fvf[oldStream] = 0;
+ tex = 0;
+ }
+
+ /* reset valid/invalid fvf */
+ fvf = 0;
+ invalid_fvf = FALSE;
+ }
+
+ switch (pToken->Usage) {
+ case D3DDECLUSAGE_POSITION:
+ if (0 < pToken->UsageIndex) {
+ invalid_fvf = TRUE;
+ TRACE("Mismatched UsageIndex (%u) in VertexDeclaration for D3DDECLUSAGE_POSITION register: unsupported type %s\n", pToken->UsageIndex, VertexDecl9_DeclTypes[type]);
+ }
+ switch (type) {
+ case D3DDECLTYPE_FLOAT3: fvf |= D3DFVF_XYZ; break;
+ case D3DDECLTYPE_FLOAT4: fvf |= D3DFVF_XYZRHW; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_POSITION register: unsupported type %s\n", VertexDecl9_DeclTypes[type]);
+ }
+ break;
+
+ case D3DDECLUSAGE_BLENDWEIGHT:
+ switch (type) {
+ case D3DDECLTYPE_FLOAT1: fvf |= D3DFVF_XYZB1; break;
+ case D3DDECLTYPE_FLOAT2: fvf |= D3DFVF_XYZB2; break;
+ case D3DDECLTYPE_FLOAT3: fvf |= D3DFVF_XYZB3; break;
+ case D3DDECLTYPE_FLOAT4: fvf |= D3DFVF_XYZB4; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_BLENDWEIGHT register: unsupported type %s\n", VertexDecl9_DeclTypes[type]);
+ }
+ break;
+
+ case D3DDECLUSAGE_BLENDINDICES:
+ switch (type) {
+ case D3DDECLTYPE_UBYTE4: fvf |= D3DFVF_LASTBETA_UBYTE4; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_BLENDINDINCES register: unsupported type %s\n", VertexDecl9_DeclTypes[type]);
+ }
+ break;
+
+ case D3DDECLUSAGE_NORMAL:
+ if (0 < pToken->UsageIndex) {
+ invalid_fvf = TRUE;
+ TRACE("Mismatched UsageIndex (%u) in VertexDeclaration for D3DDECLUSAGE_NORMAL register: unsupported type %s\n", pToken->UsageIndex, VertexDecl9_DeclTypes[type]);
+ }
+ switch (type) {
+ case D3DDECLTYPE_FLOAT3: fvf |= D3DFVF_NORMAL; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_NORMAL register: unsupported type %s\n", VertexDecl9_DeclTypes[type]);
+ }
+ break;
+
+ case D3DDECLUSAGE_PSIZE:
+ switch (type) {
+ case D3DDECLTYPE_FLOAT1: fvf |= D3DFVF_PSIZE; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_PSIZE register: unsupported type %s\n", VertexDecl9_DeclTypes[type]);
+ }
+ break;
+
+ case D3DDECLUSAGE_TEXCOORD:
+ {
+ DWORD texNo = pToken->UsageIndex;
+ tex = max(tex, texNo);
+ switch (type) {
+ case D3DDECLTYPE_FLOAT1: fvf |= D3DFVF_TEXCOORDSIZE1(texNo); break;
+ case D3DDECLTYPE_FLOAT2: fvf |= D3DFVF_TEXCOORDSIZE2(texNo); break;
+ case D3DDECLTYPE_FLOAT3: fvf |= D3DFVF_TEXCOORDSIZE3(texNo); break;
+ case D3DDECLTYPE_FLOAT4: fvf |= D3DFVF_TEXCOORDSIZE4(texNo); break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_TEXCOORD[%lu] register: unsupported type %s\n", texNo, VertexDecl9_DeclTypes[type]);
+ }
+ }
+ break;
+
+ case D3DDECLUSAGE_COLOR:
+ {
+ DWORD colorNo = pToken->UsageIndex;
+ switch (type) {
+ case D3DDECLTYPE_D3DCOLOR:
+ switch (pToken->UsageIndex) {
+ case 0: fvf |= D3DFVF_DIFFUSE; break;
+ case 1: fvf |= D3DFVF_SPECULAR; break;
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_COLOR[%lu] unsupported COLOR register\n", colorNo);
+ }
+ default:
+ /** Mismatched use of a register, invalid for fixed function fvf computing (ok for VS) */
+ invalid_fvf = TRUE;
+ TRACE("Mismatched use in VertexDeclaration of D3DDECLUSAGE_COLOR[%lu] register: unsupported type %s\n", colorNo, VertexDecl9_DeclTypes[type]);
+ }
+ }
+ break;
+
+ case D3DDECLUSAGE_TANGENT:
+ case D3DDECLUSAGE_BINORMAL:
+ case D3DDECLUSAGE_TESSFACTOR:
+ case D3DDECLUSAGE_POSITIONT:
+ case D3DDECLUSAGE_FOG:
+ case D3DDECLUSAGE_DEPTH:
+ case D3DDECLUSAGE_SAMPLE:
+ FIXME("%s Usage not supported yet by VertexDeclaration (type is %s)\n", VertexDecl9_DeclUsages[pToken->Usage], VertexDecl9_DeclTypes[type]);
+ break;
+ }
+
+ ++len;
+ ++pToken;
+ }
+ ++len; /* D3DDECL_END() */
+
+ /* copy fvf if valid */
+ if (FALSE == invalid_fvf) {
+ fvf |= tex << D3DFVF_TEXCOUNT_SHIFT;
+ object->fvf[stream] = fvf;
+ object->allFVF |= fvf;
+ } else {
+ object->fvf[stream] = 0;
+ }
+
+
+ TRACE("Completed, allFVF = %lx\n", object->allFVF);
+
+ /* compute size */
+ object->declaration9NumElements = len;
+ /* copy the declaration */
+ object->pDeclaration8 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(D3DVERTEXELEMENT9));
+ memcpy(object->pDeclaration9, pDecl, len * sizeof(D3DVERTEXELEMENT9));
+ /* returns */
+ return D3D_OK;
+}
/* *******************************************
IWineD3DVertexDeclaration IUnknown parts follow
return D3D_OK;
}
-HRESULT WINAPI IWineD3DVertexDeclarationImpl_GetDeclaration8(IWineD3DVertexDeclaration* iface, DWORD* pData, DWORD* pSizeOfData) {
+static HRESULT WINAPI IWineD3DVertexDeclarationImpl_GetDeclaration8(IWineD3DVertexDeclaration* iface, DWORD* pData, DWORD* pSizeOfData) {
IWineD3DVertexDeclarationImpl *This = (IWineD3DVertexDeclarationImpl *)iface;
if (NULL == pData) {
*pSizeOfData = This->declaration8Length;
return D3D_OK;
}
-HRESULT WINAPI IWineD3DVertexDeclarationImpl_GetDeclaration9(IWineD3DVertexDeclaration* iface, D3DVERTEXELEMENT9* pData, UINT* pNumElements) {
+HRESULT WINAPI IWineD3DVertexDeclarationImpl_GetDeclaration9(IWineD3DVertexDeclaration* iface, D3DVERTEXELEMENT9* pData, DWORD* pNumElements) {
IWineD3DVertexDeclarationImpl *This = (IWineD3DVertexDeclarationImpl *)iface;
if (NULL == pData) {
*pNumElements = This->declaration9NumElements;
return D3D_OK;
}
+HRESULT WINAPI IWineD3DVertexDeclarationImpl_GetDeclaration(IWineD3DVertexDeclaration* iface, UINT iDeclVersion, VOID* pData, DWORD* pSize) {
+ if (8 == iDeclVersion) {
+ return IWineD3DVertexDeclarationImpl_GetDeclaration8(iface, (DWORD*) pData, pSize);
+ }
+ return IWineD3DVertexDeclarationImpl_GetDeclaration9(iface, (D3DVERTEXELEMENT9*) pData, pSize);
+}
+
IWineD3DVertexDeclarationVtbl IWineD3DVertexDeclaration_Vtbl =
{
IWineD3DVertexDeclarationImpl_QueryInterface,
IWineD3DVertexDeclarationImpl_AddRef,
IWineD3DVertexDeclarationImpl_Release,
IWineD3DVertexDeclarationImpl_GetDevice,
- IWineD3DVertexDeclarationImpl_GetDeclaration8,
- IWineD3DVertexDeclarationImpl_GetDeclaration9
+ IWineD3DVertexDeclarationImpl_GetDeclaration,
};
typedef struct IWineD3DStateBlock IWineD3DStateBlock;
typedef struct IWineD3DSurface IWineD3DSurface;
typedef struct IWineD3DVolume IWineD3DVolume;
-typedef struct IWineD3DVertexDeclaration IWineD3DVertexDeclaration;
+typedef struct IWineD3DVertexDeclaration IWineD3DVertexDeclaration;
+typedef struct IWineD3DVertexShader IWineD3DVertexShader;
+typedef struct IWineD3DPixelShader IWineD3DPixelShader;
/*****************************************************************************
* Callback functions required for predefining surfaces / stencils
STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE PrimitiveType,INT baseVIdx, UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount) PURE;
STDMETHOD(DrawPrimitiveUP)(THIS_ D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void * pVertexStreamZeroData,UINT VertexStreamZeroStride) PURE;
STDMETHOD(DrawIndexedPrimitiveUP)(THIS_ D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertexIndices,UINT PrimitiveCount,CONST void * pIndexData,D3DFORMAT IndexDataFormat,CONST void * pVertexStreamZeroData,UINT VertexStreamZeroStride) PURE;
+ STDMETHOD(CreateVertexDeclaration)(THIS_ UINT iDeclVersion, CONST VOID* pDeclaration, IWineD3DVertexDeclaration** ppDecl) PURE;
+ STDMETHOD(SetVertexDeclaration)(THIS_ IWineD3DVertexDeclaration* pDecl) PURE;
+ STDMETHOD(GetVertexDeclaration)(THIS_ IWineD3DVertexDeclaration** ppDecl) PURE;
/*** Internal use IWineD3D methods ***/
STDMETHOD_(void, SetupTextureStates)(THIS_ DWORD Stage, DWORD Flags);
-
-
};
#undef INTERFACE
STDMETHOD_(ULONG,Release)(THIS) PURE;
/*** IWineD3DVertexDeclaration methods ***/
STDMETHOD(GetDevice)(THIS_ IWineD3DDevice ** ppDevice) PURE;
- STDMETHOD(GetDeclaration8)(THIS_ DWORD*, DWORD* pSizeOfData) PURE;
-#ifdef __WINE_D3D9_H
- STDMETHOD(GetDeclaration9)(THIS_ D3DVERTEXELEMENT9*, UINT* pNumElements) PURE;
-#endif
+ STDMETHOD(GetDeclaration)(THIS_ UINT iDeclVersion, VOID*, DWORD* pSize) PURE;
};
#undef INTERFACE
#define IWineD3DVertexDeclaration_Release(p) (p)->lpVtbl->Release(p)
/*** IWineD3DVertexDeclaration methods ***/
#define IWineD3DVertexDeclaration_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a)
-#define IWineD3DVertexDeclaration_GetDeclaration8(p,a,b) (p)->lpVtbl->GetDeclaration8(p,a,b)
-#define IWineD3DVertexDeclaration_GetDeclaration9(p,a,b) (p)->lpVtbl->GetDeclaration9(p,a,b)
+#define IWineD3DVertexDeclaration_GetDeclaration(p,a,b,c) (p)->lpVtbl->GetDeclaration8(p,a,b,c)
#endif
/*****************************************************************************
- * WineD3DStateBlock interface
+ * IWineD3DStateBlock interface
*/
#define INTERFACE IWineD3DStateBlock
DECLARE_INTERFACE_(IWineD3DStateBlock,IUnknown)
#endif
-#if 0 /* FIXME: During porting in from d3d8 - the following will be used */
-/*****************************************************************
- * Some defines
- */
-
-/* Device caps */
-#define MAX_PALETTES 256
-#define MAX_STREAMS 16
-#define MAX_CLIPPLANES D3DMAXUSERCLIPPLANES
-#define MAX_LEVELS 256
-
-/* Other useful values */
-#define HIGHEST_RENDER_STATE 174
-#define HIGHEST_TEXTURE_STATE 29
-#define HIGHEST_TRANSFORMSTATE 512
-#define D3DSBT_RECORDED 0xfffffffe
-
-#define D3D_VSHADER_MAX_CONSTANTS 96
-#define D3D_PSHADER_MAX_CONSTANTS 32
-
-/*****************************************************************
- * Some includes
+/*****************************************************************************
+ * IWineD3DVertexShader interface
*/
+#define INTERFACE IWineD3DVertexShader
+DECLARE_INTERFACE_(IWineD3DVertexShader,IUnknown)
+{
+ /*** IUnknown methods ***/
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+ /*** IWineD3DVertexShader methods ***/
+ STDMETHOD(GetFunction)(THIS_ VOID* pData, UINT* pSizeOfData) PURE;
+ STDMETHOD(SetConstantB)(THIS_ UINT StartRegister, CONST BOOL* pConstantData, UINT BoolCount) PURE;
+ STDMETHOD(SetConstantI)(THIS_ UINT StartRegister, CONST INT* pConstantData, UINT Vector4iCount) PURE;
+ STDMETHOD(SetConstantF)(THIS_ UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount) PURE;
+ STDMETHOD(GetConstantB)(THIS_ UINT StartRegister, BOOL* pConstantData, UINT BoolCount) PURE;
+ STDMETHOD(GetConstantI)(THIS_ UINT StartRegister, INT* pConstantData, UINT Vector4iCount) PURE;
+ STDMETHOD(GetConstantF)(THIS_ UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount) PURE;
+ /* Internal Interfaces */
+ STDMETHOD_(DWORD, GetVersion)(THIS) PURE;
+};
+#undef INTERFACE
-#include "wine/wined3d_gl.h"
-#include "wine/wined3d_types.h"
-
-#include <stdarg.h>
-#include <windef.h>
-#include <winbase.h>
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IWineD3DVertexShader_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IWineD3DVertexShader_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IWineD3DVertexShader_Release(p) (p)->lpVtbl->Release(p)
+/*** IWineD3DVertexShader methods ***/
+#define IWineD3DVertexShader_GetFunction(p,a,b) (p)->lpVtbl->GetFunction(p,a,b)
+#define IWineD3DVertexShader_SetConstantB(p,a,b,c) (p)->lpVtbl->SetConstantB(p,a,b,c)
+#define IWineD3DVertexShader_SetConstantI(p,a,b,c) (p)->lpVtbl->SetConstantI(p,a,b,c)
+#define IWineD3DVertexShader_SetConstantF(p,a,b,c) (p)->lpVtbl->SetConstantF(p,a,b,c)
+#define IWineD3DVertexShader_GetConstantB(p,a,b,c) (p)->lpVtbl->GetConstantB(p,a,b,c)
+#define IWineD3DVertexShader_GetConstantI(p,a,b,c) (p)->lpVtbl->GetConstantI(p,a,b,c)
+#define IWineD3DVertexShader_GetConstantF(p,a,b,c) (p)->lpVtbl->GetConstantF(p,a,b,c)
+#define IWineD3DVertexShader_GetVersion(p) (p)->lpVtbl->GetVersion(p)
+#endif
-/*****************************************************************
- * Some defines
+/*****************************************************************************
+ * IWineD3DPixelShader interface
*/
+#define INTERFACE IWineD3DPixelShader
+DECLARE_INTERFACE_(IWineD3DPixelShader,IUnknown)
+{
+ /*** IUnknown methods ***/
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+ /*** IWineD3DPixelShader methods ***/
+ STDMETHOD(GetFunction)(THIS_ VOID* pData, UINT* pSizeOfData) PURE;
+ STDMETHOD(SetConstantF)(THIS_ UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount) PURE;
+ STDMETHOD(GetConstantF)(THIS_ UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount) PURE;
+ /* Internal Interfaces */
+ STDMETHOD_(DWORD, GetVersion)(THIS) PURE;
+};
+#undef INTERFACE
-typedef struct IDirect3DImpl IDirect3DImpl;
-typedef struct IDirect3DBaseTextureImpl IDirect3DBaseTextureImpl;
-typedef struct IDirect3DVolumeTextureImpl IDirect3DVolumeTextureImpl;
-typedef struct IDirect3DDeviceImpl IDirect3DDeviceImpl;
-typedef struct IDirect3DTextureImpl IDirect3DTextureImpl;
-typedef struct IDirect3DCubeTextureImpl IDirect3DCubeTextureImpl;
-typedef struct IDirect3DIndexBufferImpl IDirect3DIndexBufferImpl;
-typedef struct IDirect3DSurfaceImpl IDirect3DSurfaceImpl;
-typedef struct IDirect3DSwapChainImpl IDirect3DSwapChainImpl;
-typedef struct IDirect3DResourceImpl IDirect3DResourceImpl;
-typedef struct IDirect3DVolumeImpl IDirect3DVolumeImpl;
-typedef struct IDirect3DVertexBufferImpl IDirect3DVertexBufferImpl;
-typedef struct IDirect3DStateBlockImpl IDirect3DStateBlockImpl;
-typedef struct IDirect3DVertexDeclarationImpl IDirect3DVertexDeclarationImpl;
-typedef struct IDirect3DVertexShaderImpl IDirect3DVertexShaderImpl;
-typedef struct IDirect3DPixelShaderImpl IDirect3DPixelShaderImpl;
-
-
-/*************************************************************
- * d3dcore interfaces defs
- */
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IWineD3DPixelShader_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IWineD3DPixelShader_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IWineD3DPixelShader_Release(p) (p)->lpVtbl->Release(p)
+/*** IWineD3DPixelShader methods ***/
+#define IWineD3DPixelShader_GetFunction(p,a,b) (p)->lpVtbl->GetFunction(p,a,b)
+#define IWineD3DPixelShader_SetConstantF(p,a,b,c) (p)->lpVtbl->SetConstantF(p,a,b,c)
+#define IWineD3DPixelShader_GetConstantF(p,a,b,c) (p)->lpVtbl->GetConstantF(p,a,b,c)
+#define IWineD3DPixelShader_GetVersion(p) (p)->lpVtbl->GetVersion(p)
+#endif
-/** Vertex Shader API */
+#if 0 /* FIXME: During porting in from d3d8 - the following will be used */
extern HRESULT WINAPI IDirect3DVertexShaderImpl_ParseProgram(IDirect3DVertexShaderImpl* This, CONST DWORD* pFunction);
-extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetFunction(IDirect3DVertexShaderImpl* This, VOID* pData, UINT* pSizeOfData);
-extern HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantB(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST BOOL* pConstantData, UINT BoolCount);
-extern HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantI(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST INT* pConstantData, UINT Vector4iCount);
-extern HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount);
-extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantB(IDirect3DVertexShaderImpl* This, UINT StartRegister, BOOL* pConstantData, UINT BoolCount);
-extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantI(IDirect3DVertexShaderImpl* This, UINT StartRegister, INT* pConstantData, UINT Vector4iCount);
-extern HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount);
/* internal Interfaces */
-extern DWORD WINAPI IDirect3DVertexShaderImpl_GetVersion(IDirect3DVertexShaderImpl* This);
extern HRESULT WINAPI IDirect3DVertexShaderImpl_ExecuteSW(IDirect3DVertexShaderImpl* This, VSHADERINPUTDATA* input, VSHADEROUTPUTDATA* output);
-
#endif /* Temporary #if 0 */
http://git.etersoft.ru/projects / wine / eterwine.git / commitdiff