?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- surface pool init fixes
[wine/wine-gecko.git] / dlls / d3d8 / device.c
blob90a5f7165624810df7b9d2493350d8d9de495c69
1 /*
2 * IDirect3DDevice8 implementation
3 *
4 * Copyright 2002 Jason Edmeades
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22
23 #include <math.h>
24
25 #define NONAMELESSUNION
26 #define NONAMELESSSTRUCT
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winuser.h"
30 #include "wingdi.h"
31 #include "wine/debug.h"
32
33 /** define GL_GLEXT_PROTOTYPES for having extensions prototypes defined */
34 /*#define GL_GLEXT_PROTOTYPES*/
35 #include "d3d8_private.h"
36
37 /** currently desactiving 1_4 support as mesa doesn't implement all 1_4 support while defining it */
38 #undef GL_VERSION_1_4
39
40 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
41
42 /* Some #defines for additional diagnostics */
43
44 /* Per-vertex trace: */
45 #if 0
46 # define VTRACE(A) TRACE A
47 #else
48 # define VTRACE(A)
49 #endif
50
51
52 static IDirect3DVertexShaderImpl* VertexShaders[64];
53 static IDirect3DVertexShaderDeclarationImpl* VertexShaderDeclarations[64];
54 static IDirect3DPixelShaderImpl* PixelShaders[64];
55
56 /* CreateVertexShader can return > 0xFFFF */
57 #define VS_HIGHESTFIXEDFXF 0xF0000000
58
59 /*
60 * Utility functions or macros
61 */
62 #define conv_mat(mat,gl_mat) \
63 do { \
64 TRACE("%f %f %f %f\n", (mat)->u.s._11, (mat)->u.s._12, (mat)->u.s._13, (mat)->u.s._14); \
65 TRACE("%f %f %f %f\n", (mat)->u.s._21, (mat)->u.s._22, (mat)->u.s._23, (mat)->u.s._24); \
66 TRACE("%f %f %f %f\n", (mat)->u.s._31, (mat)->u.s._32, (mat)->u.s._33, (mat)->u.s._34); \
67 TRACE("%f %f %f %f\n", (mat)->u.s._41, (mat)->u.s._42, (mat)->u.s._43, (mat)->u.s._44); \
68 memcpy(gl_mat, (mat), 16 * sizeof(float)); \
69 } while (0)
70
71 #define VERTEX_SHADER(Handle) \
72 ((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(VertexShaders) / sizeof(IDirect3DVertexShaderImpl*)) ? NULL : VertexShaders[Handle]) : VertexShaders[Handle - VS_HIGHESTFIXEDFXF])
73 #define VERTEX_SHADER_DECL(Handle) \
74 ((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(VertexShaderDeclarations) / sizeof(IDirect3DVertexShaderDeclarationImpl*)) ? NULL : VertexShaderDeclarations[Handle]) : VertexShaderDeclarations[Handle - VS_HIGHESTFIXEDFXF])
75 #define PIXEL_SHADER(Handle) \
76 ((Handle <= VS_HIGHESTFIXEDFXF) ? ((Handle >= sizeof(PixelShaders) / sizeof(IDirect3DPixelShaderImpl*)) ? NULL : PixelShaders[Handle]) : PixelShaders[Handle - VS_HIGHESTFIXEDFXF])
77
78 #define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w);
79
80
81
82 /* Routine common to the draw primitive and draw indexed primitive routines */
83 void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
84 int PrimitiveType,
85 long NumPrimitives,
86 BOOL isIndexed,
87
88 /* For Both:*/
89 D3DFORMAT fvf,
90 const void *vertexBufData,
91
92 /* for Indexed: */
93 long StartVertexIndex,
94 long StartIdx,
95 short idxBytes,
96 const void *idxData,
97 int minIndex) {
98
99 int NumVertexes = NumPrimitives;
100 IDirect3DVertexShaderImpl* vertex_shader = NULL;
101 BOOL useVertexShaderFunction = FALSE;
102
103 ICOM_THIS(IDirect3DDevice8Impl,iface);
104
105 /* Dont understand how to handle multiple streams, but if a fixed
106 FVF is passed in rather than a handle, it must use stream 0 */
107
108 if (This->UpdateStateBlock->VertexShader > VS_HIGHESTFIXEDFXF) {
109 vertex_shader = VERTEX_SHADER(This->UpdateStateBlock->VertexShader);
110 if (NULL == vertex_shader) {
111 ERR("trying to use unitialised vertex shader: %lu\n", This->UpdateStateBlock->VertexShader);
112 return ;
113 }
114 if (NULL == vertex_shader->function) {
115 TRACE("vertex shader declared without program, using FVF pure mode\n");
116 } else {
117 useVertexShaderFunction = TRUE;
118 }
119 fvf = (D3DFORMAT) This->UpdateStateBlock->vertexShaderDecl->fvf;
120 TRACE("vertex shader declared FVF: %lx\n", This->UpdateStateBlock->vertexShaderDecl->fvf);
121 memset(&vertex_shader->input, 0, sizeof(VSHADERINPUTDATA8));
122
123 /** init Constants */
124 if (TRUE == This->UpdateStateBlock->Changed.vertexShaderConstant) {
125 TRACE("vertex shader init Constant\n");
126 IDirect3DVertexShaderImpl_SetConstantF(vertex_shader, 0, (CONST FLOAT*) &This->UpdateStateBlock->vertexShaderConstant[0], 96);
127 }
128
129 }
130
131 {
132 int skip = This->StateBlock->stream_stride[0];
133 GLenum primType = GL_POINTS;
134 BOOL normal;
135 BOOL isRHW;
136 BOOL isPtSize;
137 BOOL isDiffuse;
138 BOOL isSpecular;
139 int numBlends;
140 BOOL isLastUByte4;
141 int numTextures;
142 int textureNo;
143 const char *curVtx = NULL;
144 const short *pIdxBufS = NULL;
145 const long *pIdxBufL = NULL;
146 const char *curPos;
147 BOOL isLightingOn = FALSE;
148 BOOL enableTexture = FALSE;
149 int vx_index;
150
151 float x = 0.0f,
152 y = 0.0f,
153 z = 0.0f; /* x,y,z coordinates */
154 float nx = 0.0f,
155 ny =0.0,
156 nz = 0.0f; /* normal x,y,z coordinates */
157 float rhw = 0.0f; /* rhw */
158 float ptSize = 0.0f; /* Point size */
159 DWORD diffuseColor = 0xFFFFFFFF; /* Diffuse Color */
160 DWORD specularColor = 0; /* Specular Color */
161
162 ENTER_GL();
163
164 if (isIndexed) {
165 if (idxBytes == 2) pIdxBufS = (short *) idxData;
166 else pIdxBufL = (long *) idxData;
167 }
168
169 /* Check vertex formats expected ? */
170 /**
171 * FVF parser as seen it
172 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dx8_c/directx_cpp/Graphics/Reference/CPP/D3D/FlexibleVertexFormatFlags.asp
173 */
174 normal = fvf & D3DFVF_NORMAL;
175 isRHW = fvf & D3DFVF_XYZRHW;
176 isLastUByte4 = fvf & D3DFVF_LASTBETA_UBYTE4;
177 numBlends = ((fvf & D3DFVF_POSITION_MASK) >> 1) - 2 + ((FALSE == isLastUByte4) ? 0 : -1); /* WARNING can be < 0 because -2 */
178 isPtSize = fvf & D3DFVF_PSIZE;
179 isDiffuse = fvf & D3DFVF_DIFFUSE;
180 isSpecular = fvf & D3DFVF_SPECULAR;
181 numTextures = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
182
183 TRACE("Drawing with FVF = %x, (n?%d, rhw?%d, ptSize(%d), diffuse?%d, specular?%d, numTextures=%d, numBlends=%d)\n",
184 fvf, normal, isRHW, isPtSize, isDiffuse, isSpecular, numTextures, numBlends);
185
186 /* If no normals, DISABLE lighting otherwise, dont touch lighing as it is
187 set by the appropriate render state */
188 if (!normal) {
189 isLightingOn = glIsEnabled(GL_LIGHTING);
190 glDisable(GL_LIGHTING);
191 TRACE("Enabled lighting as no normals supplied, old state = %d\n", isLightingOn);
192 }
193
194 if (isRHW) {
195 double height, width, minZ, maxZ;
196 /*
197 * Already transformed vertex do not need transform
198 * matrices. Reset all matrices to identity.
199 * Leave the default matrix in world mode.
200 */
201 glMatrixMode(GL_PROJECTION);
202 checkGLcall("glMatrixMode");
203 glLoadIdentity();
204 checkGLcall("glLoadIdentity");
205 glMatrixMode(GL_MODELVIEW);
206 checkGLcall("glMatrixMode");
207 glLoadIdentity();
208 checkGLcall("glLoadIdentity");
209 height = This->StateBlock->viewport.Height;
210 width = This->StateBlock->viewport.Width;
211 minZ = This->StateBlock->viewport.MinZ;
212 maxZ = This->StateBlock->viewport.MaxZ;
213 TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
214 glOrtho(0.0, width, height, 0.0, -minZ, -maxZ);
215 checkGLcall("glOrtho");
216 } else {
217 glMatrixMode(GL_PROJECTION);
218 checkGLcall("glMatrixMode");
219 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_PROJECTION].u.m[0][0]);
220 checkGLcall("glLoadMatrixf");
221 glMatrixMode(GL_MODELVIEW);
222 checkGLcall("glMatrixMode");
223 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
224 checkGLcall("glLoadMatrixf");
225 glMultMatrixf((float *) &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0]);
226 checkGLcall("glMultMatrixf");
227 }
228
229 /* Set OpenGL to the appropriate Primitive Type */
230 switch (PrimitiveType) {
231 case D3DPT_POINTLIST:
232 TRACE("POINTS\n");
233 primType = GL_POINTS;
234 NumVertexes = NumPrimitives;
235 break;
236
237 case D3DPT_LINELIST:
238 TRACE("LINES\n");
239 primType = GL_LINES;
240 NumVertexes = NumPrimitives * 2;
241 break;
242
243 case D3DPT_LINESTRIP:
244 TRACE("LINE_STRIP\n");
245 primType = GL_LINE_STRIP;
246 NumVertexes = NumPrimitives + 1;
247 break;
248
249 case D3DPT_TRIANGLELIST:
250 TRACE("TRIANGLES\n");
251 primType = GL_TRIANGLES;
252 NumVertexes = NumPrimitives * 3;
253 break;
254
255 case D3DPT_TRIANGLESTRIP:
256 TRACE("TRIANGLE_STRIP\n");
257 primType = GL_TRIANGLE_STRIP;
258 NumVertexes = NumPrimitives + 2;
259 break;
260
261 case D3DPT_TRIANGLEFAN:
262 TRACE("TRIANGLE_FAN\n");
263 primType = GL_TRIANGLE_FAN;
264 NumVertexes = NumPrimitives + 2;
265 break;
266
267 default:
268 FIXME("Unhandled primitive\n");
269 break;
270 }
271
272 /* Fixme, Ideally, only use this per-vertex code for software HAL
273 but until opengl supports all the functions returned to setup
274 vertex arrays, we need to drop down to the slow mechanism for
275 certain functions */
276
277 if (isPtSize || isDiffuse || useVertexShaderFunction==TRUE || (numBlends > 0)) {
278 TRACE("Using slow per-vertex code\n");
279
280 /* Enable this one to be able to debug what is going on, but it is slower
281 than the pointer/array version */
282 VTRACE(("glBegin(%x)\n", primType));
283 glBegin(primType);
284
285 /* Draw the primitives */
286 curVtx = (const char *)vertexBufData + (StartVertexIndex * skip);
287
288 for (vx_index = 0; vx_index < NumVertexes; vx_index++) {
289
290 if (!isIndexed) {
291 curPos = curVtx;
292 } else {
293 if (idxBytes == 2) {
294 VTRACE(("Idx for vertex %d = %d = %d\n", vx_index, pIdxBufS[StartIdx+vx_index], (pIdxBufS[StartIdx+vx_index])));
295 curPos = curVtx + ((pIdxBufS[StartIdx+vx_index]) * skip);
296 } else {
297 VTRACE(("Idx for vertex %d = %ld = %d\n", vx_index, pIdxBufL[StartIdx+vx_index], (pIdxBufS[StartIdx+vx_index])));
298 curPos = curVtx + ((pIdxBufL[StartIdx+vx_index]) * skip);
299 }
300 }
301
302 /* Work through the vertex buffer */
303 x = *(float *)curPos;
304 curPos = curPos + sizeof(float);
305 y = *(float *)curPos;
306 curPos = curPos + sizeof(float);
307 z = *(float *)curPos;
308 curPos = curPos + sizeof(float);
309 VTRACE(("x,y,z=%f,%f,%f\n", x,y,z));
310
311 /* RHW follows, only if transformed */
312 if (isRHW) {
313 rhw = *(float *)curPos;
314 curPos = curPos + sizeof(float);
315 VTRACE(("rhw=%f\n", rhw));
316 }
317
318 /* Blending data */
319 if (numBlends > 0) {
320 UINT i;
321 D3DSHADERVECTOR skippedBlend = { 0.0f, 0.0f, 0.0f, 0.0f};
322 DWORD skippedBlendLastUByte4 = 0;
323
324 for (i = 0; i < ((FALSE == isLastUByte4) ? numBlends : numBlends - 1); ++i) {
325 ((float*)&skippedBlend)[i] = *(float *)curPos;
326 curPos = curPos + sizeof(float);
327 }
328
329 if (isLastUByte4) {
330 skippedBlendLastUByte4 = *(DWORD*)curPos;
331 curPos = curPos + sizeof(DWORD);
332 }
333 }
334
335 /* Vertex Normal Data (untransformed only) */
336 if (normal) {
337 nx = *(float *)curPos;
338 curPos = curPos + sizeof(float);
339 ny = *(float *)curPos;
340 curPos = curPos + sizeof(float);
341 nz = *(float *)curPos;
342 curPos = curPos + sizeof(float);
343 VTRACE(("nx,ny,nz=%f,%f,%f\n", nx,ny,nz));
344 }
345
346 if (isPtSize) {
347 ptSize = *(float *)curPos;
348 VTRACE(("ptSize=%f\n", ptSize));
349 curPos = curPos + sizeof(float);
350 }
351
352 if (isDiffuse) {
353 diffuseColor = *(DWORD *)curPos;
354 VTRACE(("diffuseColor=%lx\n", diffuseColor));
355 curPos = curPos + sizeof(DWORD);
356 }
357
358 if (isSpecular) {
359 specularColor = *(DWORD *)curPos;
360 VTRACE(("specularColor=%lx\n", specularColor));
361 curPos = curPos + sizeof(DWORD);
362 }
363
364 /* ToDo: Texture coords */
365 for (textureNo = 0; textureNo < numTextures; ++textureNo) {
366 float s, t, r, q;
367
368 if (!(This->isMultiTexture) && textureNo > 0) {
369 FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
370 continue ;
371 }
372 if (textureNo > This->TextureUnits) {
373 FIXME("Program using more concurrent textures than this opengl implementation support\n");
374 break ;
375 }
376
377 /* Query tex coords */
378 if (This->StateBlock->textures[textureNo] != NULL) {
379 switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock->textures[textureNo])) {
380 case D3DRTYPE_TEXTURE:
381 s = *(float *)curPos;
382 curPos = curPos + sizeof(float);
383 t = *(float *)curPos;
384 curPos = curPos + sizeof(float);
385 VTRACE(("tex:%d, s,t=%f,%f\n", textureNo, s,t));
386
387 if (TRUE == useVertexShaderFunction) {
388 /* Nothing to do */
389 } else {
390 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX] > 7) {
391 VTRACE("Skip tex coords, as being system generated\n");
392 } else {
393
394 if (This->isMultiTexture) {
395 #if defined(GL_VERSION_1_3)
396 glMultiTexCoord2f(GL_TEXTURE0 + textureNo, s, t);
397 #else
398 glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t);
399 #endif
400 } else {
401 glTexCoord2f(s, t);
402 }
403
404 }
405 }
406 break;
407
408 case D3DRTYPE_VOLUMETEXTURE:
409 s = *(float *)curPos;
410 curPos = curPos + sizeof(float);
411 t = *(float *)curPos;
412 curPos = curPos + sizeof(float);
413 r = *(float *)curPos;
414 curPos = curPos + sizeof(float);
415 VTRACE(("tex:%d, s,t,r=%f,%f,%f\n", textureNo, s,t,r));
416
417 if (TRUE == useVertexShaderFunction) {
418 /* Nothing to do */
419 } else {
420 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX] > 7) {
421 VTRACE("Skip tex coords, as being system generated\n");
422 } else {
423 if (This->isMultiTexture) {
424 #if defined(GL_VERSION_1_3)
425 glMultiTexCoord3f(GL_TEXTURE0 + textureNo, s, t, r);
426 #else
427 glMultiTexCoord3fARB(GL_TEXTURE0_ARB + textureNo, s, t, r);
428 #endif
429 } else {
430 glTexCoord3f(s, t, r);
431 }
432 }
433 }
434 break;
435
436 case D3DRTYPE_CUBETEXTURE:
437 r = 0.0f; q = 0.0f; /* Avoid compiler warnings, need these vars later for other textures */
438 FIXME("Unhandled texture type: D3DRTYPE_CUBETEXTURE\n");
439 break;
440
441 default:
442 r = 0.0f; q = 0.0f; /* Avoid compiler warnings, need these vars later for other textures */
443 FIXME("Unhandled texture type: %u\n", IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock->textures[textureNo]));
444 }
445 } else {
446 /* Note I have seen a program actually do this, so just hide it and continue */
447 VTRACE(("Very odd - texture requested in FVF but not bound!\n"));
448 }
449
450 }
451
452 /** if vertex shader program specified ... using it */
453 if (TRUE == useVertexShaderFunction) {
454
455 /**
456 * this code must become the really
457 * vs input params init
458 *
459 * because its possible to use input registers for anything
460 * and some samples use registers for other things than they are
461 * declared
462 */
463
464 /**
465 * no really valid declaration, user defined input register use
466 * so fill input registers as described in vertex shader declaration
467 */
468 IDirect3DDeviceImpl_FillVertexShaderInput(This, vertex_shader, vertexBufData, StartVertexIndex,
469 (!isIndexed) ? (vx_index * skip) :
470 (idxBytes == 2) ? ((pIdxBufS[StartIdx + vx_index]) * skip) :
471 ((pIdxBufL[StartIdx + vx_index]) * skip));
472
473 memset(&vertex_shader->output, 0, sizeof(VSHADEROUTPUTDATA8));
474 IDirect3DVertexShaderImpl_ExecuteSW(vertex_shader, &vertex_shader->input, &vertex_shader->output);
475 /*
476 TRACE_VECTOR(vertex_shader->output.oPos);
477 TRACE_VECTOR(vertex_shader->output.oD[0]);
478 TRACE_VECTOR(vertex_shader->output.oD[1]);
479 TRACE_VECTOR(vertex_shader->output.oT[0]);
480 TRACE_VECTOR(vertex_shader->output.oT[1]);
481 TRACE_VECTOR(vertex_shader->input.V[0]);
482 TRACE_VECTOR(vertex_shader->data->C[0]);
483 TRACE_VECTOR(vertex_shader->data->C[1]);
484 TRACE_VECTOR(vertex_shader->data->C[2]);
485 TRACE_VECTOR(vertex_shader->data->C[3]);
486 TRACE_VECTOR(vertex_shader->data->C[4]);
487 TRACE_VECTOR(vertex_shader->data->C[5]);
488 TRACE_VECTOR(vertex_shader->data->C[6]);
489 TRACE_VECTOR(vertex_shader->data->C[7]);
490 */
491 x = vertex_shader->output.oPos.x;
492 y = vertex_shader->output.oPos.y;
493 z = vertex_shader->output.oPos.z;
494
495 if (1.0f != vertex_shader->output.oPos.w || isRHW) {
496 rhw = vertex_shader->output.oPos.w;
497 }
498 /*diffuseColor = D3DCOLOR_COLORVALUE(vertex_shader->output.oD[0]);*/
499 glColor4fv((float*) &vertex_shader->output.oD[0]);
500
501 /* Requires secondary color extensions to compile... */
502 #if defined(GL_VERSION_1_4)
503 glSecondaryColor3fv((float*) &vertex_shader->output.oD[1]);
504 checkGLcall("glSecondaryColor3fv");
505 #else
506 if (checkGLSupport(EXT_SECONDARY_COLOR)) {
507 /*specularColor = D3DCOLOR_COLORVALUE(vertex_shader->output.oD[1]);*/
508 /*GLExtCall(glSecondaryColor3fvEXT)((float*) &vertex_shader->output.oD[1]);*/
509 /*checkGLcall("glSecondaryColor3fvEXT");*/
510 }
511 #endif
512 /** reupdate textures coords binding using vertex_shader->output.oT[0->3] */
513 for (textureNo = 0; textureNo < 4; ++textureNo) {
514 float s, t, r, q;
515
516 if (!(This->isMultiTexture) && textureNo > 0) {
517 FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
518 continue ;
519 }
520 /* Query tex coords */
521 if (This->StateBlock->textures[textureNo] != NULL) {
522 switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock->textures[textureNo])) {
523 case D3DRTYPE_TEXTURE:
524 /*TRACE_VECTOR(vertex_shader->output.oT[textureNo]);*/
525 s = vertex_shader->output.oT[textureNo].x;
526 t = vertex_shader->output.oT[textureNo].y;
527 VTRACE(("tex:%d, s,t=%f,%f\n", textureNo, s, t));
528 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX] > 7) {
529 VTRACE("Skip tex coords, as being system generated\n");
530 } else {
531 if (This->isMultiTexture) {
532 #if defined(GL_VERSION_1_3)
533 glMultiTexCoord2f(GL_TEXTURE0 + textureNo, s, t);
534 #else
535 glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t);
536 #endif
537 /*checkGLcall("glMultiTexCoord2fARB");*/
538 } else {
539 glTexCoord2f(s, t);
540 /*checkGLcall("gTexCoord2f");*/
541 }
542 }
543 break;
544
545 case D3DRTYPE_VOLUMETEXTURE:
546 /*TRACE_VECTOR(vertex_shader->output.oT[textureNo]);*/
547 s = vertex_shader->output.oT[textureNo].x;
548 t = vertex_shader->output.oT[textureNo].y;
549 r = vertex_shader->output.oT[textureNo].z;
550 VTRACE(("tex:%d, s,t,r=%f,%f,%f\n", textureNo, s, t, r));
551 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX] > 7) {
552 VTRACE("Skip tex coords, as being system generated\n");
553 } else {
554 if (This->isMultiTexture) {
555 #if defined(GL_VERSION_1_3)
556 glMultiTexCoord3f(GL_TEXTURE0 + textureNo, s, t, r);
557 #else
558 glMultiTexCoord3fARB(GL_TEXTURE0_ARB + textureNo, s, t, r);
559 #endif
560 /*checkGLcall("glMultiTexCoord2fARB");*/
561 } else {
562 glTexCoord3f(s, t, r);
563 /*checkGLcall("gTexCoord3f");*/
564 }
565 }
566 break;
567
568 default:
569 /* Avoid compiler warnings, need these vars later for other textures */
570 r = 0.0f; q = 0.0f;
571 FIXME("Unhandled texture type\n");
572 }
573 }
574 }
575
576 if (1.0f == rhw || rhw < 0.01f) {
577 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z));
578 glVertex3f(x, y, z);
579 /*checkGLcall("glVertex3f");*/
580 } else {
581 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw));
582 glVertex4f(x / rhw, y / rhw, z / rhw, 1.0f / rhw);
583 /*checkGLcall("glVertex4f");*/
584 }
585 } else {
586 /**
587 * FALSE == useVertexShaderFunction
588 * using std FVF code
589 */
590
591 /* Handle these vertexes */
592 if (isDiffuse) {
593 glColor4ub((diffuseColor >> 16) & 0xFF,
594 (diffuseColor >> 8) & 0xFF,
595 (diffuseColor >> 0) & 0xFF,
596 (diffuseColor >> 24) & 0xFF);
597 VTRACE(("glColor4f: r,g,b,a=%f,%f,%f,%f\n",
598 ((diffuseColor >> 16) & 0xFF) / 255.0f,
599 ((diffuseColor >> 8) & 0xFF) / 255.0f,
600 ((diffuseColor >> 0) & 0xFF) / 255.0f,
601 ((diffuseColor >> 24) & 0xFF) / 255.0f));
602 }
603
604 if (normal) {
605 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f / glNormal:nx,ny,nz=%f,%f,%f\n", x,y,z,nx,ny,nz));
606 glNormal3f(nx, ny, nz);
607 glVertex3f(x, y, z);
608 } else {
609 if (1.0f == rhw || rhw < 0.01f) {
610 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z));
611 glVertex3f(x, y, z);
612 } else {
613 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw));
614 glVertex4f(x / rhw, y / rhw, z / rhw, 1.0f / rhw);
615 }
616 }
617 }
618
619 if (!isIndexed) {
620 curVtx = curVtx + skip;
621 }
622 }
623
624 glEnd();
625 checkGLcall("glEnd and previous calls");
626
627 } else {
628 TRACE("Using fast vertex array code\n");
629
630 /* Faster version, harder to debug */
631 /* Shuffle to the beginning of the vertexes to render and index from there */
632 curVtx = (const char *)vertexBufData + (StartVertexIndex * skip);
633 curPos = curVtx;
634
635 /* Set up the vertex pointers */
636 if (isRHW) {
637 glVertexPointer(4, GL_FLOAT, skip, curPos);
638 checkGLcall("glVertexPointer(4, ...)");
639 curPos += 4 * sizeof(float);
640 } else {
641 glVertexPointer(3, GL_FLOAT, skip, curPos);
642 checkGLcall("glVertexPointer(3, ...)");
643 curPos += 3 * sizeof(float);
644 }
645 glEnableClientState(GL_VERTEX_ARRAY);
646 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
647
648 if (numBlends > 0) {
649 /* no such functionality in the fixed function GL pipeline */
650 /* FIXME: Wont get here as will drop to slow method */
651 /* FIXME("Cannot handle blending data here in openGl\n");*/
652 if (checkGLSupport(ARB_VERTEX_BLEND)) {
653 FIXME("TODO\n");
654 } else if (checkGLSupport(EXT_VERTEX_WEIGHTING)) {
655 FIXME("TODO\n");
656 /*
657 GLExtCall(glVertexWeightPointerEXT)(numBlends, GL_FLOAT, skip, curPos);
658 checkGLcall("glVertexWeightPointerEXT(numBlends, ...)");
659 glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
660 checkGLcall("glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
661 */
662 curPos += numBlends * sizeof(float);
663 } else {
664 FIXME("unsupported blending in openGl\n");
665 }
666 } else {
667 if (checkGLSupport(ARB_VERTEX_BLEND)) {
668 FIXME("TODO\n");
669 } else if (checkGLSupport(EXT_VERTEX_WEIGHTING)) {
670 FIXME("TODO\n");
671 /*
672 glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
673 checkGLcall("glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
674 */
675 }
676 }
677
678
679 if (normal) {
680 glNormalPointer(GL_FLOAT, skip, curPos);
681 checkGLcall("glNormalPointer");
682 glEnableClientState(GL_NORMAL_ARRAY);
683 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
684 curPos += 3 * sizeof(float);
685 } else {
686 glDisableClientState(GL_NORMAL_ARRAY);
687 checkGLcall("glDisableClientState(GL_NORMAL_ARRAY)");
688 glNormal3f(0, 0, 1);
689 checkGLcall("glNormal3f(0, 0, 1)");
690 }
691
692 if (isPtSize) {
693 /* no such functionality in the fixed function GL pipeline */
694 /* FIXME: Wont get here as will drop to slow method */
695 FIXME("Cannot change ptSize here in openGl\n");
696 curPos = curPos + sizeof(float);
697 }
698
699 if (isDiffuse) {
700 glColorPointer(4, GL_UNSIGNED_BYTE, skip, curPos);
701 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
702 glEnableClientState(GL_COLOR_ARRAY);
703 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
704 curPos += sizeof(DWORD);
705 }
706 else {
707 glDisableClientState(GL_COLOR_ARRAY);
708 checkGLcall("glDisableClientState(GL_COLOR_ARRAY)");
709 glColor4f(1, 1, 1, 1);
710 checkGLcall("glColor4f(1, 1, 1, 1)");
711 }
712
713 /* Requires secondary color extensions to compile... */
714 if (isSpecular) {
715 #if defined(GL_VERSION_1_4)
716 glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, skip, curPos);
717 checkGLcall("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, skip, curPos)");
718 glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
719 checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY)");
720 #else
721 # if 0
722 /* FIXME: check for GL_EXT_secondary_color */
723 glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, skip, curPos);
724 checkGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, skip, curPos)");
725 glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
726 checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
727 # endif
728 #endif
729 curPos += sizeof(DWORD);
730 } else {
731 #if defined(GL_VERSION_1_4)
732 glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
733 checkGLcall("glDisableClientState(GL_SECONDARY_COLOR_ARRAY)");
734 glSecondaryColor3f(0, 0, 0);
735 checkGLcall("glSecondaryColor3f(0, 0, 0)");
736 #else
737 #if 0
738 glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
739 checkGLcall("glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
740 glSecondaryColor3fEXT(0, 0, 0);
741 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
742 #endif
743 #endif
744 }
745
746
747 /* ToDo: Texture coords */
748 for (textureNo = 0;textureNo<numTextures; textureNo++) {
749
750 /* Query tex coords */
751 #if defined(GL_VERSION_1_3)
752 glClientActiveTexture(GL_TEXTURE0 + textureNo);
753 #else
754 glClientActiveTextureARB(GL_TEXTURE0_ARB + textureNo);
755 #endif
756 if (This->StateBlock->textures[textureNo] != NULL) {
757 enableTexture = TRUE;
758 switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock->textures[textureNo])) {
759 case D3DRTYPE_TEXTURE:
760 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX] > 7) {
761 VTRACE("Skip tex coords, as being system generated\n");
762 } else {
763 glTexCoordPointer(2, GL_FLOAT, skip, curPos);
764 checkGLcall("glTexCoordPointer(2, ...)");
765 }
766 curPos += 2*sizeof(float);
767 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
768 checkGLcall("glEnableClientState(GL_TEXTURE_COORD_ARRAY);");
769 break;
770
771 case D3DRTYPE_VOLUMETEXTURE:
772 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX] > 7) {
773 VTRACE("Skip tex coords, as being system generated\n");
774 } else {
775 glTexCoordPointer(3, GL_FLOAT, skip, curPos);
776 checkGLcall("glTexCoordPointer(3, ...)");
777 }
778 curPos += 3*sizeof(float);
779 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
780 checkGLcall("glEnableClientState(GL_TEXTURE_COORD_ARRAY);");
781 break;
782
783 default:
784 FIXME("Unhandled texture type\n");
785 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
786 checkGLcall("glDisableClientState(GL_TEXTURE_COORD_ARRAY);");
787 }
788
789 } else {
790
791 /* Note I have seen a program actually do this, so just hide it and continue */
792 TRACE("Very odd - texture requested in FVF but not bound!\n");
793 #if defined(GL_VERSION_1_3)
794 glMultiTexCoord4f(GL_TEXTURE0 + textureNo, 0, 0, 0, 1);
795 checkGLcall("glMultiTexCoord4f(... , 0, 0, 0, 1)");
796 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
797 checkGLcall("glDisableClientState(GL_TEXTURE_COORD_ARRAY);");
798 #else
799 glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1);
800 checkGLcall("glMultiTexCoord4fARB(... , 0, 0, 0, 1)");
801 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
802 checkGLcall("glDisableClientState(GL_TEXTURE_COORD_ARRAY);");
803 #endif
804 }
805
806 }
807
808 /* Finally do the drawing */
809 if (isIndexed) {
810
811 TRACE("glElements(%x, %d, %d, ...)\n", primType, NumVertexes, minIndex);
812 if (idxBytes==2) {
813 #if 1 /* FIXME: Want to use DrawRangeElements, but wrong calculation! */
814 glDrawElements(primType, NumVertexes, GL_UNSIGNED_SHORT,
815 (char *)idxData+(2 * StartIdx));
816 #else
817 glDrawRangeElements(primType, minIndex, minIndex+NumVertexes-1, NumVertexes,
818 GL_UNSIGNED_SHORT, (char *)idxData+(2 * StartIdx));
819 #endif
820 } else {
821 #if 1 /* FIXME: Want to use DrawRangeElements, but wrong calculation! */
822 glDrawElements(primType, NumVertexes, GL_UNSIGNED_INT,
823 (char *)idxData+(4 * StartIdx));
824 #else
825 glDrawRangeElements(primType, minIndex, minIndex+NumVertexes-1, NumVertexes,
826 GL_UNSIGNED_INT, (char *)idxData+(2 * StartIdx));
827 #endif
828 }
829 checkGLcall("glDrawRangeElements");
830
831 } else {
832
833 /* Note first is now zero as we shuffled along earlier */
834 TRACE("glDrawArrays(%x, %ld, %d)\n", primType, StartIdx, NumVertexes);
835 glDrawArrays(primType, 0, NumVertexes);
836 checkGLcall("glDrawArrays");
837
838 }
839 }
840
841 /* If no normals, restore previous lighting state */
842 if (!normal) {
843 if (isLightingOn) glEnable(GL_LIGHTING);
844 else glDisable(GL_LIGHTING);
845 TRACE("Restored lighting to original state\n");
846 }
847
848 }
849 LEAVE_GL();
850
851 TRACE("glEnd\n");
852 }
853
854 /*
855 Simple utility routines used for dx -> gl mapping of byte formats
856 */
857 SHORT bytesPerPixel(D3DFORMAT fmt) {
858 SHORT retVal;
859
860 switch (fmt) {
861 /* color buffer */
862 case D3DFMT_A4R4G4B4: retVal = 2; break;
863 case D3DFMT_A8R8G8B8: retVal = 4; break;
864 case D3DFMT_X8R8G8B8: retVal = 4; break;
865 case D3DFMT_R8G8B8: retVal = 3; break;
866 case D3DFMT_R5G6B5: retVal = 2; break;
867 case D3DFMT_A1R5G5B5: retVal = 2; break;
868 /* depth/stencil buffer */
869 case D3DFMT_D16_LOCKABLE: retVal = 2; break;
870 case D3DFMT_D32: retVal = 4; break;
871 case D3DFMT_D15S1: retVal = 2; break;
872 case D3DFMT_D24S8: retVal = 4; break;
873 case D3DFMT_D16: retVal = 2; break;
874 case D3DFMT_D24X8: retVal = 4; break;
875 case D3DFMT_D24X4S4: retVal = 4; break;
876 /* unknown */
877 case D3DFMT_UNKNOWN:
878 /* Guess at the highest value of the above */
879 TRACE("D3DFMT_UNKNOWN - Guessing at 4 bytes/pixel %d\n", fmt);
880 retVal = 4;
881 break;
882 default:
883 FIXME("Unhandled fmt %d\n", fmt);
884 retVal = 4;
885 }
886 TRACE("bytes/Pxl for fmt %d = %d\n", fmt, retVal);
887 return retVal;
888 }
889
890 GLint fmt2glintFmt(D3DFORMAT fmt) {
891 GLint retVal;
892
893 switch (fmt) {
894 case D3DFMT_A4R4G4B4: retVal = GL_RGBA4; break;
895 case D3DFMT_A8R8G8B8: retVal = GL_RGBA8; break;
896 case D3DFMT_X8R8G8B8: retVal = GL_RGB8; break;
897 case D3DFMT_R8G8B8: retVal = GL_RGB8; break;
898 case D3DFMT_R5G6B5: retVal = GL_RGB5; break; /* fixme: internal format 6 for g? */
899 case D3DFMT_A1R5G5B5: retVal = GL_RGB5_A1; break;
900 default:
901 FIXME("Unhandled fmt %d\n", fmt);
902 retVal = 4;
903 }
904 TRACE("fmt2glintFmt for fmt %d = %x\n", fmt, retVal);
905 return retVal;
906 }
907 GLenum fmt2glFmt(D3DFORMAT fmt) {
908 GLenum retVal;
909
910 switch (fmt) {
911 case D3DFMT_A4R4G4B4: retVal = GL_BGRA; break;
912 case D3DFMT_A8R8G8B8: retVal = GL_BGRA; break;
913 case D3DFMT_X8R8G8B8: retVal = GL_BGRA; break;
914 case D3DFMT_R8G8B8: retVal = GL_BGR; break;
915 case D3DFMT_R5G6B5: retVal = GL_RGB; break;
916 case D3DFMT_A1R5G5B5: retVal = GL_BGRA; break;
917 default:
918 FIXME("Unhandled fmt %d\n", fmt);
919 retVal = 4;
920 }
921 TRACE("fmt2glFmt for fmt %d = %x\n", fmt, retVal);
922 return retVal;
923 }
924 DWORD fmt2glType(D3DFORMAT fmt) {
925 GLenum retVal;
926
927 switch (fmt) {
928 case D3DFMT_A4R4G4B4: retVal = GL_UNSIGNED_SHORT_4_4_4_4_REV; break;
929 case D3DFMT_A8R8G8B8: retVal = GL_UNSIGNED_BYTE; break;
930 case D3DFMT_X8R8G8B8: retVal = GL_UNSIGNED_BYTE; break;
931 case D3DFMT_R5G6B5: retVal = GL_UNSIGNED_SHORT_5_6_5_REV; break;
932 case D3DFMT_R8G8B8: retVal = GL_UNSIGNED_BYTE; break;
933 case D3DFMT_A1R5G5B5: retVal = GL_UNSIGNED_SHORT_1_5_5_5_REV; break;
934 default:
935 FIXME("Unhandled fmt %d\n", fmt);
936 retVal = 4;
937 }
938 TRACE("fmt2glType for fmt %d = %x\n", fmt, retVal);
939 return retVal;
940 }
941
942 int SOURCEx_RGB_EXT(DWORD arg) {
943 switch(arg) {
944 case D3DTSS_COLORARG0: return GL_SOURCE2_RGB_EXT;
945 case D3DTSS_COLORARG1: return GL_SOURCE0_RGB_EXT;
946 case D3DTSS_COLORARG2: return GL_SOURCE1_RGB_EXT;
947 case D3DTSS_ALPHAARG0:
948 case D3DTSS_ALPHAARG1:
949 case D3DTSS_ALPHAARG2:
950 default:
951 FIXME("Invalid arg %ld\n", arg);
952 return GL_SOURCE0_RGB_EXT;
953 }
954 }
955 int OPERANDx_RGB_EXT(DWORD arg) {
956 switch(arg) {
957 case D3DTSS_COLORARG0: return GL_OPERAND2_RGB_EXT;
958 case D3DTSS_COLORARG1: return GL_OPERAND0_RGB_EXT;
959 case D3DTSS_COLORARG2: return GL_OPERAND1_RGB_EXT;
960 case D3DTSS_ALPHAARG0:
961 case D3DTSS_ALPHAARG1:
962 case D3DTSS_ALPHAARG2:
963 default:
964 FIXME("Invalid arg %ld\n", arg);
965 return GL_OPERAND0_RGB_EXT;
966 }
967 }
968 int SOURCEx_ALPHA_EXT(DWORD arg) {
969 switch(arg) {
970 case D3DTSS_ALPHAARG0: return GL_SOURCE2_ALPHA_EXT;
971 case D3DTSS_ALPHAARG1: return GL_SOURCE0_ALPHA_EXT;
972 case D3DTSS_ALPHAARG2: return GL_SOURCE1_ALPHA_EXT;
973 case D3DTSS_COLORARG0:
974 case D3DTSS_COLORARG1:
975 case D3DTSS_COLORARG2:
976 default:
977 FIXME("Invalid arg %ld\n", arg);
978 return GL_SOURCE0_ALPHA_EXT;
979 }
980 }
981 int OPERANDx_ALPHA_EXT(DWORD arg) {
982 switch(arg) {
983 case D3DTSS_ALPHAARG0: return GL_OPERAND2_ALPHA_EXT;
984 case D3DTSS_ALPHAARG1: return GL_OPERAND0_ALPHA_EXT;
985 case D3DTSS_ALPHAARG2: return GL_OPERAND1_ALPHA_EXT;
986 case D3DTSS_COLORARG0:
987 case D3DTSS_COLORARG1:
988 case D3DTSS_COLORARG2:
989 default:
990 FIXME("Invalid arg %ld\n", arg);
991 return GL_OPERAND0_ALPHA_EXT;
992 }
993 }
994 GLenum StencilOp(DWORD op) {
995 switch(op) {
996 case D3DSTENCILOP_KEEP : return GL_KEEP;
997 case D3DSTENCILOP_ZERO : return GL_ZERO;
998 case D3DSTENCILOP_REPLACE : return GL_REPLACE;
999 case D3DSTENCILOP_INCRSAT : return GL_INCR;
1000 case D3DSTENCILOP_DECRSAT : return GL_DECR;
1001 case D3DSTENCILOP_INVERT : return GL_INVERT;
1002 case D3DSTENCILOP_INCR : FIXME("Unsupported stencil op D3DSTENCILOP_INCR\n");
1003 return GL_INCR; /* Fixme - needs to support wrap */
1004 case D3DSTENCILOP_DECR : FIXME("Unsupported stencil op D3DSTENCILOP_DECR\n");
1005 return GL_DECR; /* Fixme - needs to support wrap */
1006 default:
1007 FIXME("Invalid stencil op %ld\n", op);
1008 return GL_ALWAYS;
1009 }
1010 }
1011
1012 /**
1013 * @nodoc: todo
1014 */
1015 void GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum* operand)
1016 {
1017 BOOL isAlphaReplicate = FALSE;
1018 BOOL isComplement = FALSE;
1019
1020 *operand = GL_SRC_COLOR;
1021 *source = GL_TEXTURE;
1022
1023 /* Catch alpha replicate */
1024 if (iValue & D3DTA_ALPHAREPLICATE) {
1025 iValue = iValue & ~D3DTA_ALPHAREPLICATE;
1026 isAlphaReplicate = TRUE;
1027 }
1028
1029 /* Catch Complement */
1030 if (iValue & D3DTA_COMPLEMENT) {
1031 iValue = iValue & ~D3DTA_COMPLEMENT;
1032 isComplement = TRUE;
1033 }
1034
1035 /* Calculate the operand */
1036 if (isAlphaReplicate && !isComplement) {
1037 *operand = GL_SRC_ALPHA;
1038 } else if (isAlphaReplicate && isComplement) {
1039 *operand = GL_ONE_MINUS_SRC_ALPHA;
1040 } else if (isComplement) {
1041 if (isAlphaArg) {
1042 *operand = GL_ONE_MINUS_SRC_ALPHA;
1043 } else {
1044 *operand = GL_ONE_MINUS_SRC_COLOR;
1045 }
1046 } else {
1047 if (isAlphaArg) {
1048 *operand = GL_SRC_ALPHA;
1049 } else {
1050 *operand = GL_SRC_COLOR;
1051 }
1052 }
1053
1054 /* Calculate the source */
1055 switch (iValue & D3DTA_SELECTMASK) {
1056 case D3DTA_CURRENT: *source = GL_PREVIOUS_EXT;
1057 break;
1058 case D3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT;
1059 break;
1060 case D3DTA_TEXTURE: *source = GL_TEXTURE;
1061 break;
1062 case D3DTA_TFACTOR: *source = GL_CONSTANT_EXT;
1063 break;
1064 case D3DTA_SPECULAR:
1065 /**
1066 * According to the GL_ARB_texture_env_combine specs, SPECULAR is 'Secondary color' and
1067 * isnt supported until base GL supports it
1068 * There is no concept of temp registers as far as I can tell
1069 */
1070
1071 default:
1072 FIXME("Unrecognized or unhandled texture arg %ld\n", iValue);
1073 *source = GL_TEXTURE;
1074 }
1075 }
1076
1077
1078 /* Apply the current values to the specified texture stage */
1079 void setupTextureStates(LPDIRECT3DDEVICE8 iface, DWORD Stage) {
1080 ICOM_THIS(IDirect3DDevice8Impl,iface);
1081 int i=0;
1082 float col[4];
1083
1084 /* Make appropriate texture active */
1085 if (This->isMultiTexture) {
1086 #if defined(GL_VERSION_1_3)
1087 glActiveTexture(GL_TEXTURE0 + Stage);
1088 #else
1089 glActiveTextureARB(GL_TEXTURE0_ARB + Stage);
1090 #endif
1091 checkGLcall("glActiveTextureARB");
1092 } else if (Stage > 0) {
1093 FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
1094 }
1095
1096 TRACE("-----------------------> Updating the texture at stage %ld to have new texture state information\n", Stage);
1097 for (i=1; i<HIGHEST_TEXTURE_STATE; i++) {
1098 IDirect3DDevice8Impl_SetTextureStageState(iface, Stage, i, This->StateBlock->texture_state[Stage][i]);
1099 }
1100
1101 /* Note the D3DRS value applies to all textures, but GL has one
1102 per texture, so apply it now ready to be used! */
1103 col[0] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR]>> 16) & 0xFF) / 255.0;
1104 col[1] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR] >> 8 ) & 0xFF) / 255.0;
1105 col[2] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR] >> 0 ) & 0xFF) / 255.0;
1106 col[3] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR] >> 24 ) & 0xFF) / 255.0;
1107 glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
1108 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
1109
1110 TRACE("-----------------------> Updated the texture at stage %ld to have new texture state information\n", Stage);
1111 }
1112
1113 /* IDirect3D IUnknown parts follow: */
1114 HRESULT WINAPI IDirect3DDevice8Impl_QueryInterface(LPDIRECT3DDEVICE8 iface,REFIID riid,LPVOID *ppobj)
1115 {
1116 ICOM_THIS(IDirect3DDevice8Impl,iface);
1117
1118 if (IsEqualGUID(riid, &IID_IUnknown)
1119 || IsEqualGUID(riid, &IID_IDirect3DDevice8)) {
1120 IDirect3DDevice8Impl_AddRef(iface);
1121 *ppobj = This;
1122 return D3D_OK;
1123 }
1124
1125 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
1126 return E_NOINTERFACE;
1127 }
1128
1129 ULONG WINAPI IDirect3DDevice8Impl_AddRef(LPDIRECT3DDEVICE8 iface) {
1130 ICOM_THIS(IDirect3DDevice8Impl,iface);
1131 TRACE("(%p) : AddRef from %ld\n", This, This->ref);
1132 return ++(This->ref);
1133 }
1134
1135 ULONG WINAPI IDirect3DDevice8Impl_Release(LPDIRECT3DDEVICE8 iface) {
1136 ICOM_THIS(IDirect3DDevice8Impl,iface);
1137 ULONG ref = --This->ref;
1138 TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
1139 if (ref == 0) {
1140 HeapFree(GetProcessHeap(), 0, This);
1141 }
1142 return ref;
1143 }
1144
1145 /* IDirect3DDevice Interface follow: */
1146 HRESULT WINAPI IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 iface) {
1147 ICOM_THIS(IDirect3DDevice8Impl,iface);
1148 TRACE("(%p) : stub\n", This); /* No way of notifying yet! */
1149 return D3D_OK;
1150 }
1151
1152 UINT WINAPI IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface) {
1153 ICOM_THIS(IDirect3DDevice8Impl,iface);
1154 TRACE("(%p) : stub, emulating 32Mb for now\n", This);
1155 /*
1156 * pretend we have 32MB of any type of memory queried.
1157 */
1158 return (1024*1024*32);
1159 }
1160
1161 HRESULT WINAPI IDirect3DDevice8Impl_ResourceManagerDiscardBytes(LPDIRECT3DDEVICE8 iface, DWORD Bytes) {
1162 ICOM_THIS(IDirect3DDevice8Impl,iface);
1163 FIXME("(%p) : stub\n", This); return D3D_OK;
1164 }
1165 HRESULT WINAPI IDirect3DDevice8Impl_GetDirect3D(LPDIRECT3DDEVICE8 iface, IDirect3D8** ppD3D8) {
1166 ICOM_THIS(IDirect3DDevice8Impl,iface);
1167 TRACE("(%p) : returning %p\n", This, This->direct3d8);
1168
1169 /* Inc ref count */
1170 IDirect3D8_AddRef((LPDIRECT3D8) This->direct3d8);
1171
1172 *ppD3D8 = (IDirect3D8 *)This->direct3d8;
1173 return D3D_OK;
1174 }
1175 HRESULT WINAPI IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface, D3DCAPS8* pCaps) {
1176 ICOM_THIS(IDirect3DDevice8Impl,iface);
1177 FIXME("(%p) : stub, calling idirect3d for now\n", This);
1178 IDirect3D8Impl_GetDeviceCaps((LPDIRECT3D8) This->direct3d8, This->adapterNo, This->devType, pCaps);
1179 return D3D_OK;
1180 }
1181 HRESULT WINAPI IDirect3DDevice8Impl_GetDisplayMode(LPDIRECT3DDEVICE8 iface, D3DDISPLAYMODE* pMode) {
1182
1183 HDC hdc;
1184 int bpp = 0;
1185
1186 ICOM_THIS(IDirect3DDevice8Impl,iface);
1187 pMode->Width = GetSystemMetrics(SM_CXSCREEN);
1188 pMode->Height = GetSystemMetrics(SM_CYSCREEN);
1189 pMode->RefreshRate = 85; /*FIXME: How to identify? */
1190
1191 hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1192 bpp = GetDeviceCaps(hdc, BITSPIXEL);
1193 DeleteDC(hdc);
1194
1195 switch (bpp) {
1196 case 8: pMode->Format = D3DFMT_R8G8B8; break;
1197 case 16: pMode->Format = D3DFMT_R5G6B5; break;
1198 case 24: pMode->Format = D3DFMT_R8G8B8; break;
1199 case 32: pMode->Format = D3DFMT_A8R8G8B8; break;
1200 default:
1201 FIXME("Unrecognized display mode format\n");
1202 pMode->Format = D3DFMT_UNKNOWN;
1203 }
1204
1205 FIXME("(%p) : returning w(%d) h(%d) rr(%d) fmt(%d)\n", This, pMode->Width, pMode->Height, pMode->RefreshRate, pMode->Format);
1206 return D3D_OK;
1207 }
1208 HRESULT WINAPI IDirect3DDevice8Impl_GetCreationParameters(LPDIRECT3DDEVICE8 iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) {
1209 ICOM_THIS(IDirect3DDevice8Impl,iface);
1210 TRACE("(%p) copying to %p\n", This, pParameters);
1211 memcpy(pParameters, &This->CreateParms, sizeof(D3DDEVICE_CREATION_PARAMETERS));
1212 return D3D_OK;
1213 }
1214 HRESULT WINAPI IDirect3DDevice8Impl_SetCursorProperties(LPDIRECT3DDEVICE8 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap) {
1215 ICOM_THIS(IDirect3DDevice8Impl,iface);
1216 FIXME("(%p) : stub\n", This); return D3D_OK;
1217 }
1218 void WINAPI IDirect3DDevice8Impl_SetCursorPosition(LPDIRECT3DDEVICE8 iface, UINT XScreenSpace, UINT YScreenSpace,DWORD Flags) {
1219 ICOM_THIS(IDirect3DDevice8Impl,iface);
1220 FIXME("(%p) : stub\n", This); return;
1221 }
1222 BOOL WINAPI IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface, BOOL bShow) {
1223 ICOM_THIS(IDirect3DDevice8Impl,iface);
1224 FIXME("(%p) : stub\n", This); return D3D_OK;
1225 }
1226 HRESULT WINAPI IDirect3DDevice8Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain) {
1227 ICOM_THIS(IDirect3DDevice8Impl,iface);
1228 FIXME("(%p) : stub\n", This);
1229 *pSwapChain = NULL;
1230 return D3D_OK;
1231 }
1232 HRESULT WINAPI IDirect3DDevice8Impl_Reset(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) {
1233 ICOM_THIS(IDirect3DDevice8Impl,iface);
1234 FIXME("(%p) : stub\n", This); return D3D_OK;
1235 }
1236 HRESULT WINAPI IDirect3DDevice8Impl_Present(LPDIRECT3DDEVICE8 iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) {
1237 ICOM_THIS(IDirect3DDevice8Impl,iface);
1238 TRACE("(%p) : complete stub!\n", This);
1239
1240 ENTER_GL();
1241
1242 glXSwapBuffers(This->display, This->win);
1243 checkGLcall("glXSwapBuffers");
1244
1245 LEAVE_GL();
1246
1247 return D3D_OK;
1248 }
1249 HRESULT WINAPI IDirect3DDevice8Impl_GetBackBuffer(LPDIRECT3DDEVICE8 iface, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8** ppBackBuffer) {
1250 ICOM_THIS(IDirect3DDevice8Impl,iface);
1251 *ppBackBuffer = (LPDIRECT3DSURFACE8) This->backBuffer;
1252 TRACE("(%p) : BackBuf %d Type %d returning %p\n", This, BackBuffer, Type, *ppBackBuffer);
1253
1254 if (BackBuffer > This->PresentParms.BackBufferCount - 1) {
1255 FIXME("Only one backBuffer currently supported\n");
1256 return D3DERR_INVALIDCALL;
1257 }
1258
1259 /* Note inc ref on returned surface */
1260 IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) *ppBackBuffer);
1261
1262 return D3D_OK;
1263 }
1264 HRESULT WINAPI IDirect3DDevice8Impl_GetRasterStatus(LPDIRECT3DDEVICE8 iface, D3DRASTER_STATUS* pRasterStatus) {
1265 ICOM_THIS(IDirect3DDevice8Impl,iface);
1266 FIXME("(%p) : stub\n", This);
1267 return D3D_OK;
1268 }
1269 void WINAPI IDirect3DDevice8Impl_SetGammaRamp(LPDIRECT3DDEVICE8 iface, DWORD Flags,CONST D3DGAMMARAMP* pRamp) {
1270 ICOM_THIS(IDirect3DDevice8Impl,iface);
1271 FIXME("(%p) : stub\n", This); return;
1272 }
1273 void WINAPI IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface, D3DGAMMARAMP* pRamp) {
1274 ICOM_THIS(IDirect3DDevice8Impl,iface);
1275 FIXME("(%p) : stub\n", This); return;
1276 }
1277 HRESULT WINAPI IDirect3DDevice8Impl_CreateTexture(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, UINT Levels, DWORD Usage,
1278 D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture) {
1279 IDirect3DTexture8Impl *object;
1280 int i;
1281 UINT tmpW;
1282 UINT tmpH;
1283
1284 ICOM_THIS(IDirect3DDevice8Impl,iface);
1285
1286 /* Allocate the storage for the device */
1287 TRACE("(%p) : W(%d) H(%d), Lvl(%d) Usage(%ld), Fmt(%d), Pool(%d)\n", This, Width, Height, Levels, Usage, Format, Pool);
1288 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DTexture8Impl));
1289 object->lpVtbl = &Direct3DTexture8_Vtbl;
1290 object->Device = This;
1291 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->device);*/
1292 object->ResourceType = D3DRTYPE_TEXTURE;
1293 object->ref = 1;
1294 object->width = Width;
1295 object->height = Height;
1296 object->levels = Levels;
1297 object->usage = Usage;
1298 object->format = Format;
1299
1300
1301 /* Calculate levels for mip mapping */
1302 if (Levels == 0) {
1303 object->levels++;
1304 tmpW = Width;
1305 tmpH = Height;
1306 while (tmpW > 1 && tmpH > 1) {
1307 tmpW = max(1, tmpW / 2);
1308 tmpH = max(1, tmpH / 2);
1309 object->levels++;
1310 }
1311 TRACE("Calculated levels = %d\n", object->levels);
1312 }
1313
1314 /* Generate all the surfaces */
1315 tmpW = Width;
1316 tmpH = Height;
1317 for (i = 0; i < object->levels; i++)
1318 {
1319 IDirect3DDevice8Impl_CreateImageSurface(iface, tmpW, tmpH, Format, (LPDIRECT3DSURFACE8*) &object->surfaces[i]);
1320 object->surfaces[i]->Container = (IUnknown*) object;
1321 /*IUnknown_AddRef(object->surfaces[i]->Container);*/
1322 object->surfaces[i]->myDesc.Usage = Usage;
1323 object->surfaces[i]->myDesc.Pool = Pool ;
1324
1325 TRACE("Created surface level %d @ %p, memory at %p\n", i, object->surfaces[i], object->surfaces[i]->allocatedMemory);
1326 tmpW = max(1, tmpW / 2);
1327 tmpH = max(1, tmpH / 2);
1328 }
1329
1330 *ppTexture = (LPDIRECT3DTEXTURE8) object;
1331 return D3D_OK;
1332 }
1333 HRESULT WINAPI IDirect3DDevice8Impl_CreateVolumeTexture(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture) {
1334
1335 IDirect3DVolumeTexture8Impl *object;
1336 int i;
1337 UINT tmpW;
1338 UINT tmpH;
1339 UINT tmpD;
1340
1341 ICOM_THIS(IDirect3DDevice8Impl,iface);
1342
1343 /* Allocate the storage for it */
1344 TRACE("(%p) : W(%d) H(%d) D(%d), Lvl(%d) Usage(%ld), Fmt(%d), Pool(%d)\n", This, Width, Height, Depth, Levels, Usage, Format, Pool);
1345 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVolumeTexture8Impl));
1346 object->lpVtbl = &Direct3DVolumeTexture8_Vtbl;
1347 object->ResourceType = D3DRTYPE_VOLUMETEXTURE;
1348 object->Device = This;
1349 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->Device);*/
1350 object->ref = 1;
1351
1352 object->width = Width;
1353 object->height = Height;
1354 object->depth = Depth;
1355 object->levels = Levels;
1356 object->usage = Usage;
1357 object->format = Format;
1358
1359 /* Calculate levels for mip mapping */
1360 if (Levels == 0) {
1361 object->levels++;
1362 tmpW = Width;
1363 tmpH = Height;
1364 tmpD = Depth;
1365 while (tmpW > 1 && tmpH > 1 && tmpD > 1) {
1366 tmpW = max(1, tmpW / 2);
1367 tmpH = max(1, tmpH / 2);
1368 tmpD = max(1, tmpD / 2);
1369 object->levels++;
1370 }
1371 TRACE("Calculated levels = %d\n", object->levels);
1372 }
1373
1374 /* Generate all the surfaces */
1375 tmpW = Width;
1376 tmpH = Height;
1377 tmpD = Depth;
1378
1379 for (i = 0; i < object->levels; i++)
1380 {
1381 IDirect3DVolume8Impl *volume;
1382
1383 /* Create the volume - No entry point for this seperately?? */
1384 volume = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVolume8Impl));
1385 object->volumes[i] = (IDirect3DVolume8Impl *) volume;
1386
1387 volume->lpVtbl = &Direct3DVolume8_Vtbl;
1388 volume->Device = This;
1389 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) volume->Device);*/
1390 volume->ResourceType = D3DRTYPE_VOLUME;
1391 volume->Container = (IUnknown*) object;
1392 /*IUnknown_AddRef(volume->Container);*/
1393 volume->ref = 1;
1394
1395 volume->myDesc.Width = Width;
1396 volume->myDesc.Height = Height;
1397 volume->myDesc.Depth = Depth;
1398 volume->myDesc.Format = Format;
1399 volume->myDesc.Type = D3DRTYPE_VOLUME;
1400 volume->myDesc.Pool = Pool;
1401 volume->myDesc.Usage = Usage;
1402 volume->bytesPerPixel = bytesPerPixel(Format);
1403 volume->myDesc.Size = (Width * volume->bytesPerPixel) * Height * Depth;
1404 volume->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, volume->myDesc.Size);
1405
1406 TRACE("(%p) : Volume at w(%d) h(%d) d(%d) fmt(%d) surf@%p, surfmem@%p, %d bytes\n", This, Width, Height, Depth, Format,
1407 volume, volume->allocatedMemory, volume->myDesc.Size);
1408
1409 tmpW = max(1, tmpW / 2);
1410 tmpH = max(1, tmpH / 2);
1411 tmpD = max(1, tmpD / 2);
1412 }
1413
1414 *ppVolumeTexture = (LPDIRECT3DVOLUMETEXTURE8) object;
1415 return D3D_OK;
1416 }
1417 HRESULT WINAPI IDirect3DDevice8Impl_CreateCubeTexture(LPDIRECT3DDEVICE8 iface, UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture8** ppCubeTexture) {
1418
1419 IDirect3DCubeTexture8Impl *object;
1420 ICOM_THIS(IDirect3DDevice8Impl,iface);
1421 int i,j;
1422 UINT tmpW;
1423
1424 /* Allocate the storage for it */
1425 TRACE("(%p) : Len(%d), Lvl(%d) Usage(%ld), Fmt(%d), Pool(%d)\n", This, EdgeLength, Levels, Usage, Format, Pool);
1426 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DCubeTexture8Impl));
1427 object->lpVtbl = &Direct3DCubeTexture8_Vtbl;
1428 object->ref = 1;
1429 object->Device = This;
1430 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->Device);*/
1431 object->ResourceType = D3DRTYPE_CUBETEXTURE;
1432
1433 object->edgeLength = EdgeLength;
1434 object->levels = Levels;
1435 object->usage = Usage;
1436 object->format = Format;
1437
1438 /* Calculate levels for mip mapping */
1439 if (Levels == 0) {
1440 object->levels++;
1441 tmpW = EdgeLength;
1442 while (tmpW > 1) {
1443 tmpW = max(1, tmpW / 2);
1444 object->levels++;
1445 }
1446 TRACE("Calculated levels = %d\n", object->levels);
1447 }
1448
1449 /* Generate all the surfaces */
1450 tmpW = EdgeLength;
1451 for (i = 0; i < object->levels; i++)
1452 {
1453 /* Create the 6 faces */
1454 for (j = 0; j < 6; j++) {
1455 IDirect3DDevice8Impl_CreateImageSurface(iface, tmpW, tmpW, Format, (LPDIRECT3DSURFACE8*) &object->surfaces[j][i]);
1456 object->surfaces[j][i]->Container = (IUnknown*) object;
1457 /*IUnknown_AddRef(object->surfaces[j][i]->Container);*/
1458 object->surfaces[j][i]->myDesc.Usage = Usage;
1459 object->surfaces[j][i]->myDesc.Pool = Pool;
1460
1461 TRACE("Created surface level %d @ %p, memory at %p\n", i, object->surfaces[j][i], object->surfaces[j][i]->allocatedMemory);
1462 tmpW = max(1, tmpW / 2);
1463 }
1464 }
1465
1466 TRACE("(%p) : Iface@%p\n", This, object);
1467 *ppCubeTexture = (LPDIRECT3DCUBETEXTURE8)object;
1468 return D3D_OK;
1469 }
1470 HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexBuffer(LPDIRECT3DDEVICE8 iface, UINT Size, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer8** ppVertexBuffer) {
1471 IDirect3DVertexBuffer8Impl *object;
1472
1473 ICOM_THIS(IDirect3DDevice8Impl,iface);
1474
1475 /* Allocate the storage for the device */
1476 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexBuffer8Impl));
1477 object->lpVtbl = &Direct3DVertexBuffer8_Vtbl;
1478 object->Device = This;
1479 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->Device);*/
1480 object->ResourceType = D3DRTYPE_VERTEXBUFFER;
1481 object->ref = 1;
1482 object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Size);
1483 object->currentDesc.Usage = Usage;
1484 object->currentDesc.Pool = Pool;
1485 object->currentDesc.FVF = FVF;
1486 object->currentDesc.Size = Size;
1487
1488 TRACE("(%p) : Size=%d, Usage=%ld, FVF=%lx, Pool=%d - Memory@%p, Iface@%p\n", This, Size, Usage, FVF, Pool, object->allocatedMemory, object);
1489
1490 *ppVertexBuffer = (LPDIRECT3DVERTEXBUFFER8)object;
1491
1492 return D3D_OK;
1493 }
1494 HRESULT WINAPI IDirect3DDevice8Impl_CreateIndexBuffer(LPDIRECT3DDEVICE8 iface, UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer8** ppIndexBuffer) {
1495 IDirect3DIndexBuffer8Impl *object;
1496
1497 ICOM_THIS(IDirect3DDevice8Impl,iface);
1498 TRACE("(%p) : Len=%d, Use=%lx, Format=%x, Pool=%d\n", This, Length, Usage, Format, Pool);
1499
1500 /* Allocate the storage for the device */
1501 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DIndexBuffer8Impl));
1502 object->lpVtbl = &Direct3DIndexBuffer8_Vtbl;
1503 object->Device = This;
1504 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->Device);*/
1505 object->ref = 1;
1506 object->ResourceType = D3DRTYPE_INDEXBUFFER;
1507
1508 object->currentDesc.Type = D3DRTYPE_INDEXBUFFER;
1509 object->currentDesc.Usage = Usage;
1510 object->currentDesc.Pool = Pool;
1511 object->currentDesc.Format = Format;
1512 object->currentDesc.Size = Length;
1513
1514 object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Length);
1515
1516 TRACE("(%p) : Iface@%p allocatedMem @ %p\n", This, object, object->allocatedMemory);
1517
1518 *ppIndexBuffer = (LPDIRECT3DINDEXBUFFER8)object;
1519
1520 return D3D_OK;
1521 }
1522 HRESULT WINAPI IDirect3DDevice8Impl_CreateRenderTarget(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, BOOL Lockable, IDirect3DSurface8** ppSurface) {
1523 IDirect3DSurface8Impl *object;
1524
1525 ICOM_THIS(IDirect3DDevice8Impl,iface);
1526
1527 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface8Impl));
1528 if (NULL == object) {
1529 *ppSurface = NULL;
1530 return D3DERR_OUTOFVIDEOMEMORY;
1531 }
1532 *ppSurface = (LPDIRECT3DSURFACE8) object;
1533 object->lpVtbl = &Direct3DSurface8_Vtbl;
1534 object->Device = This;
1535 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->Device);*/
1536 object->ResourceType = D3DRTYPE_SURFACE;
1537 object->Container = (IUnknown*) This;
1538 /*IUnknown_AddRef(object->Container);*/
1539
1540 object->ref = 1;
1541 object->myDesc.Width = Width;
1542 object->myDesc.Height = Height;
1543 object->myDesc.Format = Format;
1544 object->myDesc.Type = D3DRTYPE_SURFACE;
1545 object->myDesc.Usage = D3DUSAGE_RENDERTARGET;
1546 object->myDesc.Pool = D3DPOOL_DEFAULT;
1547 object->myDesc.MultiSampleType = MultiSample;
1548 object->bytesPerPixel = bytesPerPixel(Format);
1549 object->myDesc.Size = (Width * object->bytesPerPixel) * Height;
1550 object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->myDesc.Size);
1551 object->lockable = Lockable;
1552 object->locked = FALSE;
1553
1554 TRACE("(%p) : w(%d) h(%d) fmt(%d) lockable(%d) surf@%p, surfmem@%p, %d bytes\n", This, Width, Height, Format, Lockable, *ppSurface, object->allocatedMemory, object->myDesc.Size);
1555 return D3D_OK;
1556 }
1557 HRESULT WINAPI IDirect3DDevice8Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, IDirect3DSurface8** ppSurface) {
1558 IDirect3DSurface8Impl *object;
1559
1560 ICOM_THIS(IDirect3DDevice8Impl,iface);
1561
1562 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface8Impl));
1563 if (NULL == object) {
1564 *ppSurface = NULL;
1565 return D3DERR_OUTOFVIDEOMEMORY;
1566 }
1567 *ppSurface = (LPDIRECT3DSURFACE8) object;
1568 object->lpVtbl = &Direct3DSurface8_Vtbl;
1569 object->Device = This;
1570 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->Device);*/
1571 object->ResourceType = D3DRTYPE_SURFACE;
1572 object->Container = (IUnknown*) This;
1573 /*IUnknown_AddRef(object->Container);*/
1574
1575 object->ref = 1;
1576 object->myDesc.Width = Width;
1577 object->myDesc.Height = Height;
1578 object->myDesc.Format = Format;
1579 object->myDesc.Type = D3DRTYPE_SURFACE;
1580 object->myDesc.Usage = D3DUSAGE_DEPTHSTENCIL;
1581 object->myDesc.Pool = D3DPOOL_DEFAULT;
1582 object->myDesc.MultiSampleType = MultiSample;
1583 object->bytesPerPixel = bytesPerPixel(Format);
1584 object->myDesc.Size = (Width * object->bytesPerPixel) * Height;
1585 object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->myDesc.Size);
1586 object->lockable = TRUE;
1587 object->locked = FALSE;
1588
1589 TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p, surfmem@%p, %d bytes\n", This, Width, Height, Format, *ppSurface, object->allocatedMemory, object->myDesc.Size);
1590 return D3D_OK;
1591 }
1592 HRESULT WINAPI IDirect3DDevice8Impl_CreateImageSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, IDirect3DSurface8** ppSurface) {
1593 IDirect3DSurface8Impl *object;
1594
1595 ICOM_THIS(IDirect3DDevice8Impl,iface);
1596
1597 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface8Impl));
1598 *ppSurface = (LPDIRECT3DSURFACE8) object;
1599 object->lpVtbl = &Direct3DSurface8_Vtbl;
1600 object->Device = This;
1601 /*IDirect3DDevice8Impl_AddRef((LPDIRECT3DDEVICE8) object->Device);*/
1602 object->ResourceType = D3DRTYPE_SURFACE;
1603 object->Container = (IUnknown*) This;
1604 /*IUnknown_AddRef(object->Container);*/
1605
1606 object->ref = 1;
1607 object->myDesc.Width = Width;
1608 object->myDesc.Height = Height;
1609 object->myDesc.Format = Format;
1610 object->myDesc.Type = D3DRTYPE_SURFACE;
1611 object->myDesc.Usage = 0;
1612 object->myDesc.Pool = D3DPOOL_SYSTEMMEM;
1613 object->bytesPerPixel = bytesPerPixel(Format);
1614 object->myDesc.Size = (Width * object->bytesPerPixel) * Height;
1615 object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->myDesc.Size);
1616 object->lockable = TRUE;
1617 object->locked = FALSE;
1618
1619 TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p, surfmem@%p, %d bytes\n", This, Width, Height, Format, *ppSurface, object->allocatedMemory, object->myDesc.Size);
1620 return D3D_OK;
1621 }
1622 HRESULT WINAPI IDirect3DDevice8Impl_CopyRects(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,
1623 IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray) {
1624
1625 HRESULT rc = D3D_OK;
1626 IDirect3DBaseTexture8* texture = NULL;
1627
1628
1629 IDirect3DSurface8Impl *src = (IDirect3DSurface8Impl*) pSourceSurface;
1630 IDirect3DSurface8Impl *dst = (IDirect3DSurface8Impl*) pDestinationSurface;
1631
1632 ICOM_THIS(IDirect3DDevice8Impl,iface);
1633 TRACE("(%p) srcsur=%p, pSourceRects=%p, cRects=%d, pDstSur=%p, pDestPtsArr=%p\n", This,
1634 pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray);
1635
1636 /* Note: Not sure about the d3dfmt_unknown bit, but seems to avoid a problem inside
1637 a sample and doesnt seem to break anything as far as I can tell */
1638 if (src->myDesc.Format != dst->myDesc.Format && (dst->myDesc.Format != D3DFMT_UNKNOWN)) {
1639 TRACE("Formats do not match %x / %x\n", src->myDesc.Format, dst->myDesc.Format);
1640 rc = D3DERR_INVALIDCALL;
1641
1642 } else if (dst->myDesc.Format == D3DFMT_UNKNOWN) {
1643 TRACE("Converting dest to same format as source, since dest was unknown\n");
1644 dst->myDesc.Format = src->myDesc.Format;
1645
1646 /* Convert container as well */
1647 IDirect3DSurface8Impl_GetContainer((LPDIRECT3DSURFACE8) dst, &IID_IDirect3DBaseTexture8, (void**) &texture); /* FIXME: Which refid? */
1648 if (texture != NULL) {
1649
1650 switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) texture)) {
1651 case D3DRTYPE_TEXTURE:
1652 ((IDirect3DTexture8Impl *)texture)->format = src->myDesc.Format;
1653 break;
1654 case D3DRTYPE_VOLUMETEXTURE:
1655 ((IDirect3DVolumeTexture8Impl *)texture)->format = src->myDesc.Format;
1656 break;
1657 case D3DRTYPE_CUBETEXTURE:
1658 ((IDirect3DCubeTexture8Impl *)texture)->format = src->myDesc.Format;
1659 break;
1660 default:
1661 FIXME("Unhandled texture type\n");
1662 }
1663
1664 /** Releasing texture after GetContainer */
1665 IDirect3DBaseTexture8_Release(texture);
1666 }
1667 }
1668
1669 /* Quick if complete copy ... */
1670 if (rc == D3D_OK && (cRects == 0 && pSourceRectsArray==NULL && pDestPointsArray==NULL &&
1671 src->myDesc.Width == dst->myDesc.Width &&
1672 src->myDesc.Height == dst->myDesc.Height)) {
1673 TRACE("Direct copy as surfaces are equal, w=%d, h=%d\n", dst->myDesc.Width, dst->myDesc.Height);
1674 memcpy(dst->allocatedMemory, src->allocatedMemory, src->myDesc.Size);
1675
1676 } else {
1677 int i;
1678 int bytesPerPixel = ((IDirect3DSurface8Impl *)pSourceSurface)->bytesPerPixel;
1679 int pitchFrom = ((IDirect3DSurface8Impl *)pSourceSurface)->myDesc.Width * bytesPerPixel;
1680 int pitchTo = ((IDirect3DSurface8Impl *)pDestinationSurface)->myDesc.Width * bytesPerPixel;
1681
1682 char *copyfrom = ((IDirect3DSurface8Impl *)pSourceSurface)->allocatedMemory;
1683 char *copyto = ((IDirect3DSurface8Impl *)pDestinationSurface)->allocatedMemory;
1684
1685 /* Copy rect by rect */
1686 for (i=0; i<cRects; i++) {
1687 CONST RECT *r = &pSourceRectsArray[i];
1688 CONST POINT *p = &pDestPointsArray[i];
1689 char *from;
1690 char *to;
1691 int copyperline = (r->right - r->left) * bytesPerPixel;
1692 int j;
1693
1694 TRACE("Copying rect %d (%ld,%ld),(%ld,%ld) -> (%ld,%ld)\n", i, r->left, r->top,
1695 r->right, r->bottom, p->x, p->y);
1696
1697 /* Find where to start */
1698 from = copyfrom + (r->top * pitchFrom) + (r->left * bytesPerPixel);
1699 to = copyto + (p->y * pitchTo) + (p->x * bytesPerPixel);
1700
1701 /* Copy line by line */
1702 for (j=0; j<(r->bottom - r->top); j++) {
1703 memcpy(to + (j*pitchTo), from + (j*pitchFrom), copyperline);
1704 }
1705 }
1706 }
1707
1708 /* Set dirty */
1709 if (rc == D3D_OK) {
1710 IDirect3DSurface8Impl_GetContainer((LPDIRECT3DSURFACE8) dst, &IID_IDirect3DBaseTexture8, (void**) &texture); /* FIXME: Which refid? */
1711 if (texture != NULL) {
1712
1713 switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) texture)) {
1714 case D3DRTYPE_TEXTURE:
1715 {
1716 IDirect3DTexture8Impl *pTexture = (IDirect3DTexture8Impl *)texture;
1717 pTexture->Dirty = TRUE;
1718 }
1719 break;
1720 case D3DRTYPE_VOLUMETEXTURE:
1721 {
1722 IDirect3DVolumeTexture8Impl *pTexture = (IDirect3DVolumeTexture8Impl *)texture;
1723 pTexture->Dirty = TRUE;
1724 }
1725 break;
1726 case D3DRTYPE_CUBETEXTURE:
1727 {
1728 IDirect3DCubeTexture8Impl *pTexture = (IDirect3DCubeTexture8Impl *)texture;
1729 pTexture->Dirty = TRUE;
1730 }
1731 break;
1732 default:
1733 FIXME("Unhandled texture type\n");
1734 }
1735
1736 /** Releasing texture after GetContainer */
1737 IDirect3DBaseTexture8_Release(texture);
1738 }
1739 }
1740
1741 return D3D_OK;
1742 }
1743 HRESULT WINAPI IDirect3DDevice8Impl_UpdateTexture(LPDIRECT3DDEVICE8 iface, IDirect3DBaseTexture8* pSourceTexture, IDirect3DBaseTexture8* pDestinationTexture) {
1744 ICOM_THIS(IDirect3DDevice8Impl,iface);
1745 FIXME("(%p) : stub\n", This);
1746 return D3D_OK;
1747 }
1748 HRESULT WINAPI IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pDestSurface) {
1749 HRESULT hr;
1750 D3DLOCKED_RECT lockedRect;
1751 GLint prev_store;
1752 GLenum prev_read;
1753
1754 ICOM_THIS(IDirect3DDevice8Impl,iface);
1755
1756 FIXME("(%p) : stub\n", This);
1757
1758 if (D3DFMT_A8R8G8B8 != ((IDirect3DSurface8Impl*) pDestSurface)->myDesc.Format) {
1759 return D3DERR_INVALIDCALL;
1760 }
1761
1762 hr = IDirect3DSurface8Impl_LockRect(pDestSurface, &lockedRect, NULL, 0);
1763 if (FAILED(hr)) {
1764 return D3DERR_INVALIDCALL;
1765 }
1766
1767 ENTER_GL();
1768
1769 glFlush();
1770 vcheckGLcall("glFlush");
1771 glGetIntegerv(GL_READ_BUFFER, &prev_read);
1772 vcheckGLcall("glIntegerv");
1773 glGetIntegerv(GL_PACK_SWAP_BYTES, &prev_store);
1774 vcheckGLcall("glIntegerv");
1775
1776 glReadBuffer(GL_FRONT);
1777 vcheckGLcall("glReadBuffer");
1778 glPixelStorei(GL_PACK_SWAP_BYTES, TRUE);
1779 vcheckGLcall("glPixelStorei");
1780 glReadPixels(0, 0, This->PresentParms.BackBufferWidth, This->PresentParms.BackBufferHeight,
1781 GL_BGRA, GL_UNSIGNED_BYTE, lockedRect.pBits);
1782 vcheckGLcall("glReadPixels");
1783 glPixelStorei(GL_PACK_SWAP_BYTES, prev_store);
1784 vcheckGLcall("glPixelStorei");
1785 glReadBuffer(prev_read);
1786 vcheckGLcall("glReadBuffer");
1787 LEAVE_GL();
1788
1789 hr = IDirect3DSurface8Impl_UnlockRect(pDestSurface);
1790 return hr;
1791 }
1792 HRESULT WINAPI IDirect3DDevice8Impl_SetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pRenderTarget, IDirect3DSurface8* pNewZStencil) {
1793 ICOM_THIS(IDirect3DDevice8Impl,iface);
1794
1795 if ((IDirect3DSurface8Impl*) pRenderTarget == This->frontBuffer && (IDirect3DSurface8Impl*) pNewZStencil == This->depthStencilBuffer) {
1796 TRACE("Trying to do a NOP SetRenderTarget operation\n");
1797 return D3D_OK;
1798 }
1799
1800 FIXME("(%p) : invalid stub expect crash newRender@%p newZStencil@%p\n", This, pRenderTarget, pNewZStencil);
1801
1802 return D3D_OK;
1803 }
1804 HRESULT WINAPI IDirect3DDevice8Impl_GetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppRenderTarget) {
1805 ICOM_THIS(IDirect3DDevice8Impl,iface);
1806
1807 TRACE("(%p)->(%p)\n", This, This->frontBuffer);
1808
1809 *ppRenderTarget = (LPDIRECT3DSURFACE8) This->frontBuffer;
1810 IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) *ppRenderTarget);
1811
1812 return D3D_OK;
1813 }
1814 HRESULT WINAPI IDirect3DDevice8Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppZStencilSurface) {
1815 ICOM_THIS(IDirect3DDevice8Impl,iface);
1816
1817 TRACE("(%p)->(%p)\n", This, ppZStencilSurface);
1818
1819 /* Note inc ref on returned surface */
1820 *ppZStencilSurface = (LPDIRECT3DSURFACE8) This->depthStencilBuffer;
1821 IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) *ppZStencilSurface);
1822
1823 return D3D_OK;
1824 }
1825
1826 HRESULT WINAPI IDirect3DDevice8Impl_BeginScene(LPDIRECT3DDEVICE8 iface) {
1827 ICOM_THIS(IDirect3DDevice8Impl,iface);
1828 TRACE("(%p) : stub\n", This);
1829 return D3D_OK;
1830 }
1831 HRESULT WINAPI IDirect3DDevice8Impl_EndScene(LPDIRECT3DDEVICE8 iface) {
1832 ICOM_THIS(IDirect3DDevice8Impl,iface);
1833 TRACE("(%p)\n", This);
1834
1835 ENTER_GL();
1836
1837 glFlush();
1838 checkGLcall("glFlush");
1839
1840 /* Useful for debugging sometimes!
1841 printf("Hit Enter ...\n");
1842 getchar(); */
1843
1844 LEAVE_GL();
1845 return D3D_OK;
1846 }
1847 HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil) {
1848 ICOM_THIS(IDirect3DDevice8Impl,iface);
1849
1850 /* TODO: From MSDN This method fails if you specify the D3DCLEAR_ZBUFFER or D3DCLEAR_STENCIL flags when the
1851 render target does not have an attached depth buffer. Similarly, if you specify the D3DCLEAR_STENCIL flag
1852 when the depth-buffer format does not contain stencil buffer information, this method fails. */
1853 GLbitfield glMask = 0;
1854 GLboolean old_ztest;
1855 GLfloat old_z_clear_value;
1856 GLint old_stencil_clear_value;
1857 GLfloat old_color_clear_value[4];
1858
1859 int i;
1860 CONST D3DRECT *curRect;
1861
1862 TRACE("(%p) Count (%ld), pRects (%p), Flags (%lx), Z (%f), Stencil (%ld)\n", This,
1863 Count, pRects, Flags, Z, Stencil);
1864
1865 ENTER_GL();
1866 if (Count > 0 && pRects) {
1867 glEnable(GL_SCISSOR_TEST);
1868 checkGLcall("glEnable GL_SCISSOR_TEST");
1869 curRect = pRects;
1870 } else {
1871 curRect = NULL;
1872 }
1873
1874 for (i = 0; i < Count || i == 0; i++) {
1875
1876 if (curRect) {
1877 /* Note gl uses lower left, width/height */
1878 TRACE("(%p) %p Rect=(%ld,%ld)->(%ld,%ld) glRect=(%ld,%ld), len=%ld, hei=%ld\n", This, curRect,
1879 curRect->x1, curRect->y1, curRect->x2, curRect->y2,
1880 curRect->x1, curRect->y2, curRect->x2 - curRect->x1, curRect->y2 - curRect->y1);
1881 glScissor(curRect->x1, curRect->y2, curRect->x2 - curRect->x1, curRect->y2 - curRect->y1);
1882 checkGLcall("glScissor");
1883 }
1884
1885 /* Clear the whole screen */
1886 if (Flags & D3DCLEAR_STENCIL) {
1887 glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &old_stencil_clear_value);
1888 glClearStencil(Stencil);
1889 checkGLcall("glClearStencil");
1890 glMask = glMask | GL_STENCIL_BUFFER_BIT;
1891 }
1892
1893 if (Flags & D3DCLEAR_ZBUFFER) {
1894 glGetBooleanv(GL_DEPTH_WRITEMASK, &old_ztest);
1895 glDepthMask(GL_TRUE);
1896 glGetFloatv(GL_DEPTH_CLEAR_VALUE, &old_z_clear_value);
1897 glClearDepth(Z);
1898 checkGLcall("glClearDepth");
1899 glMask = glMask | GL_DEPTH_BUFFER_BIT;
1900 }
1901
1902 if (Flags & D3DCLEAR_TARGET) {
1903 TRACE("Clearing screen with glClear to color %lx\n", Color);
1904 glGetFloatv(GL_COLOR_CLEAR_VALUE, old_color_clear_value);
1905 glClearColor(((Color >> 16) & 0xFF) / 255.0,
1906 ((Color >> 8) & 0xFF) / 255.0,
1907 ((Color >> 0) & 0xFF) / 255.0,
1908 ((Color >> 24) & 0xFF) / 255.0);
1909 checkGLcall("glClearColor");
1910 glMask = glMask | GL_COLOR_BUFFER_BIT;
1911 }
1912
1913 glClear(glMask);
1914 checkGLcall("glClear");
1915
1916 if (Flags & D3DCLEAR_STENCIL) {
1917 glClearStencil(old_stencil_clear_value);
1918 }
1919 if (Flags & D3DCLEAR_ZBUFFER) {
1920 glDepthMask(old_ztest);
1921 glClearDepth(old_z_clear_value);
1922 }
1923 if (Flags & D3DCLEAR_TARGET) {
1924 glClearColor(old_color_clear_value[0],
1925 old_color_clear_value[1],
1926 old_color_clear_value[2],
1927 old_color_clear_value[3]);
1928 }
1929
1930 if (curRect) curRect = curRect + sizeof(D3DRECT);
1931 }
1932
1933 if (Count > 0 && pRects) {
1934 glDisable(GL_SCISSOR_TEST);
1935 checkGLcall("glDisable");
1936 }
1937 LEAVE_GL();
1938
1939 return D3D_OK;
1940 }
1941 HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE d3dts,CONST D3DMATRIX* lpmatrix) {
1942 ICOM_THIS(IDirect3DDevice8Impl,iface);
1943 D3DMATRIX m;
1944 int k;
1945 float f;
1946 BOOL viewChanged = TRUE;
1947 int Stage;
1948
1949 /* Most of this routine, comments included copied from ddraw tree initially: */
1950 TRACE("(%p) : State=%d\n", This, d3dts);
1951
1952 This->UpdateStateBlock->Changed.transform[d3dts] = TRUE;
1953 This->UpdateStateBlock->Set.transform[d3dts] = TRUE;
1954 memcpy(&This->UpdateStateBlock->transforms[d3dts], lpmatrix, sizeof(D3DMATRIX));
1955
1956 /* Handle recording of state blocks */
1957 if (This->isRecordingState) {
1958 TRACE("Recording... not performing anything\n");
1959 return D3D_OK;
1960 }
1961
1962 /*
1963 ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
1964
1965 where ViewMat = Camera space, WorldMat = world space.
1966
1967 In OpenGL, camera and world space is combined into GL_MODELVIEW
1968 matrix. The Projection matrix stay projection matrix. */
1969
1970 /* After reading through both OpenGL and Direct3D documentations, I
1971 thought that D3D matrices were written in 'line major mode' transposed
1972 from OpenGL's 'column major mode'. But I found out that a simple memcpy
1973 works fine to transfer one matrix format to the other (it did not work
1974 when transposing)....
1975
1976 So :
1977 1) are the documentations wrong
1978 2) does the matrix work even if they are not read correctly
1979 3) is Mesa's implementation of OpenGL not compliant regarding Matrix
1980 loading using glLoadMatrix ?
1981
1982 Anyway, I always use 'conv_mat' to transfer the matrices from one format
1983 to the other so that if I ever find out that I need to transpose them, I
1984 will able to do it quickly, only by changing the macro conv_mat. */
1985
1986 if (d3dts <= 256) { /* WORLDMATRIX(0) == 256! */
1987 switch (d3dts) {
1988 case D3DTS_WORLDMATRIX(0):
1989 conv_mat(lpmatrix, &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)]);
1990 break;
1991
1992 case D3DTS_VIEW:
1993 conv_mat(lpmatrix, &This->StateBlock->transforms[D3DTS_VIEW]);
1994 break;
1995
1996 case D3DTS_PROJECTION:
1997 conv_mat(lpmatrix, &This->StateBlock->transforms[D3DTS_PROJECTION]);
1998 break;
1999
2000 case D3DTS_TEXTURE0:
2001 case D3DTS_TEXTURE1:
2002 case D3DTS_TEXTURE2:
2003 case D3DTS_TEXTURE3:
2004 case D3DTS_TEXTURE4:
2005 case D3DTS_TEXTURE5:
2006 case D3DTS_TEXTURE6:
2007 case D3DTS_TEXTURE7:
2008 conv_mat(lpmatrix, &This->StateBlock->transforms[d3dts]);
2009 break;
2010
2011 default:
2012 FIXME("Unhandled transform state!!\n");
2013 break;
2014 }
2015 } else {
2016 /**
2017 * Indexed Vertex Blending Matrices 256 -> 511
2018 */
2019 /** store it */
2020 conv_mat(lpmatrix, &This->StateBlock->transforms[d3dts]);
2021 if (checkGLSupport(ARB_VERTEX_BLEND)) {
2022 FIXME("TODO\n");
2023 } else if (checkGLSupport(EXT_VERTEX_WEIGHTING)) {
2024 FIXME("TODO\n");
2025 }
2026 }
2027
2028 /*
2029 * Move the GL operation to outside of switch to make it work
2030 * regardless of transform set order.
2031 */
2032 ENTER_GL();
2033 if (memcmp(&This->lastProj, &This->StateBlock->transforms[D3DTS_PROJECTION].u.m[0][0], sizeof(D3DMATRIX))) {
2034 glMatrixMode(GL_PROJECTION);
2035 checkGLcall("glMatrixMode");
2036 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_PROJECTION].u.m[0][0]);
2037 checkGLcall("glLoadMatrixf");
2038 memcpy(&This->lastProj, &This->StateBlock->transforms[D3DTS_PROJECTION].u.m[0][0], sizeof(D3DMATRIX));
2039 } else {
2040 TRACE("Skipping as projection already correct\n");
2041 }
2042
2043 glMatrixMode(GL_MODELVIEW);
2044 checkGLcall("glMatrixMode");
2045 viewChanged = FALSE;
2046 if (memcmp(&This->lastView, &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0], sizeof(D3DMATRIX))) {
2047 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
2048 checkGLcall("glLoadMatrixf");
2049 memcpy(&This->lastView, &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0], sizeof(D3DMATRIX));
2050 viewChanged = TRUE;
2051
2052 /* If we are changing the View matrix, reset the light and clipping planes to the new view */
2053 if (d3dts == D3DTS_VIEW) {
2054
2055 /* NOTE: We have to reset the positions even if the light/plane is not currently
2056 enabled, since the call to enable it will not reset the position. */
2057
2058 /* Reset lights */
2059 for (k = 0; k < This->maxLights; k++) {
2060 glLightfv(GL_LIGHT0 + k, GL_POSITION, &This->lightPosn[k][0]);
2061 checkGLcall("glLightfv posn");
2062 glLightfv(GL_LIGHT0 + k, GL_SPOT_DIRECTION, &This->lightDirn[k][0]);
2063 checkGLcall("glLightfv dirn");
2064 }
2065
2066 /* Reset Clipping Planes if clipping is enabled */
2067 for (k = 0; k < This->clipPlanes; k++) {
2068 glClipPlane(GL_CLIP_PLANE0 + k, This->StateBlock->clipplane[k]);
2069 checkGLcall("glClipPlane");
2070 }
2071
2072 /* Reapply texture transforms as based off modelview when applied */
2073 for (Stage = 0; Stage < This->TextureUnits; Stage++) {
2074
2075 /* Now apply texture transforms if not applying to the dummy textures */
2076 #if defined(GL_VERSION_1_3)
2077 glActiveTexture(GL_TEXTURE0 + Stage);
2078 #else
2079 glActiveTextureARB(GL_TEXTURE0_ARB + Stage);
2080 #endif
2081 checkGLcall("glActiveTexture(GL_TEXTURE0 + Stage);");
2082
2083 glMatrixMode(GL_TEXTURE);
2084 if (This->StateBlock->textureDimensions[Stage] == GL_TEXTURE_1D) {
2085 glLoadIdentity();
2086 } else {
2087 D3DMATRIX fred;
2088 conv_mat(&This->StateBlock->transforms[D3DTS_TEXTURE0+Stage], &fred);
2089 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_TEXTURE0+Stage].u.m[0][0]);
2090 }
2091 checkGLcall("Load matrix for texture");
2092 }
2093 glMatrixMode(GL_MODELVIEW); /* Always leave in model view */
2094 }
2095 } else if (d3dts >= D3DTS_TEXTURE0 && d3dts <= D3DTS_TEXTURE7) {
2096 /* Now apply texture transforms if not applying to the dummy textures */
2097 Stage = d3dts-D3DTS_TEXTURE0;
2098
2099 if (memcmp(&This->lastTexTrans[Stage], &This->StateBlock->transforms[D3DTS_TEXTURE0+Stage].u.m[0][0], sizeof(D3DMATRIX))) {
2100 memcpy(&This->lastTexTrans[Stage], &This->StateBlock->transforms[D3DTS_TEXTURE0+Stage].u.m[0][0], sizeof(D3DMATRIX));
2101
2102 #if defined(GL_VERSION_1_3)
2103 glActiveTexture(GL_TEXTURE0 + Stage);
2104 #else
2105 glActiveTextureARB(GL_TEXTURE0_ARB + Stage);
2106 #endif
2107 checkGLcall("glActiveTexture(GL_TEXTURE0 + Stage)");
2108
2109 glMatrixMode(GL_TEXTURE);
2110 if (This->StateBlock->textureDimensions[Stage] == GL_TEXTURE_1D) {
2111 glLoadIdentity();
2112 } else {
2113 D3DMATRIX fred;
2114 conv_mat(&This->StateBlock->transforms[D3DTS_TEXTURE0+Stage], &fred);
2115 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_TEXTURE0+Stage].u.m[0][0]);
2116 }
2117 checkGLcall("Load matrix for texture");
2118 glMatrixMode(GL_MODELVIEW); /* Always leave in model view */
2119 } else {
2120 TRACE("Skipping texture transform as already correct\n");
2121 }
2122
2123 } else {
2124 TRACE("Skipping view setup as view already correct\n");
2125 }
2126
2127 /**
2128 * Vertex Blending as described
2129 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/enums/d3dvertexblendflags.asp
2130 */
2131 switch (This->UpdateStateBlock->vertex_blend) {
2132 case D3DVBF_DISABLE:
2133 {
2134 if (viewChanged == TRUE ||
2135 (memcmp(&This->lastWorld0, &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0], sizeof(D3DMATRIX)))) {
2136 memcpy(&This->lastWorld0, &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0], sizeof(D3DMATRIX));
2137 if (viewChanged==FALSE) {
2138 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
2139 checkGLcall("glLoadMatrixf");
2140 }
2141 glMultMatrixf((float *) &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0]);
2142 checkGLcall("glMultMatrixf");
2143 } else {
2144 TRACE("Skipping as world already correct\n");
2145 }
2146 }
2147 break;
2148 case D3DVBF_1WEIGHTS:
2149 case D3DVBF_2WEIGHTS:
2150 case D3DVBF_3WEIGHTS:
2151 {
2152 FIXME("valid/correct D3DVBF_[1..3]WEIGHTS\n");
2153 /*
2154 * doc seems to say that the weight values must be in vertex data (specified in FVF by D3DFVF_XYZB*)
2155 * so waiting for the values before matrix work
2156 for (k = 0; k < This->UpdateStateBlock->vertex_blend; ++k) {
2157 glMultMatrixf((float *) &This->StateBlock->transforms[D3DTS_WORLDMATRIX(k)].u.m[0][0]);
2158 checkGLcall("glMultMatrixf");
2159 }
2160 */
2161 }
2162 break;
2163 case D3DVBF_TWEENING:
2164 {
2165 FIXME("valid/correct D3DVBF_TWEENING\n");
2166 f = This->UpdateStateBlock->tween_factor;
2167 m.u.s._11 = f; m.u.s._12 = f; m.u.s._13 = f; m.u.s._14 = f;
2168 m.u.s._21 = f; m.u.s._22 = f; m.u.s._23 = f; m.u.s._24 = f;
2169 m.u.s._31 = f; m.u.s._32 = f; m.u.s._33 = f; m.u.s._34 = f;
2170 m.u.s._41 = f; m.u.s._42 = f; m.u.s._43 = f; m.u.s._44 = f;
2171 if (viewChanged==FALSE) {
2172 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
2173 checkGLcall("glLoadMatrixf");
2174 }
2175 glMultMatrixf((float *) &m.u.m[0][0]);
2176 checkGLcall("glMultMatrixf");
2177 }
2178 break;
2179 case D3DVBF_0WEIGHTS:
2180 {
2181 FIXME("valid/correct D3DVBF_0WEIGHTS\n");
2182 /* single matrix of weight 1.0f */
2183 m.u.s._11 = 1.0f; m.u.s._12 = 1.0f; m.u.s._13 = 1.0f; m.u.s._14 = 1.0f;
2184 m.u.s._21 = 1.0f; m.u.s._22 = 1.0f; m.u.s._23 = 1.0f; m.u.s._24 = 1.0f;
2185 m.u.s._31 = 1.0f; m.u.s._32 = 1.0f; m.u.s._33 = 1.0f; m.u.s._34 = 1.0f;
2186 m.u.s._41 = 1.0f; m.u.s._42 = 1.0f; m.u.s._43 = 1.0f; m.u.s._44 = 1.0f;
2187 if (viewChanged == FALSE) {
2188 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
2189 checkGLcall("glLoadMatrixf");
2190 }
2191 glMultMatrixf((float *) &m.u.m[0][0]);
2192 checkGLcall("glMultMatrixf");
2193 }
2194 break;
2195 default:
2196 break; /* stupid compilator */
2197 }
2198
2199 LEAVE_GL();
2200
2201 return D3D_OK;
2202
2203 }
2204 HRESULT WINAPI IDirect3DDevice8Impl_GetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix) {
2205 ICOM_THIS(IDirect3DDevice8Impl,iface);
2206 TRACE("(%p) : for State %d\n", This, State);
2207 memcpy(pMatrix, &This->StateBlock->transforms[State], sizeof(D3DMATRIX));
2208 return D3D_OK;
2209 }
2210
2211 HRESULT WINAPI IDirect3DDevice8Impl_MultiplyTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) {
2212 D3DMATRIX *mat = NULL;
2213 D3DMATRIX temp;
2214
2215 /* Note: Using UpdateStateBlock means it would be recorded in a state block change,
2216 but works regardless of recording being on.
2217 If this is found to be wrong, change to StateBlock. */
2218 ICOM_THIS(IDirect3DDevice8Impl,iface);
2219 TRACE("(%p) : For state %u\n", This, State);
2220
2221 if (State < HIGHEST_TRANSFORMSTATE)
2222 {
2223 mat = &This->UpdateStateBlock->transforms[State];
2224 } else {
2225 FIXME("Unhandled transform state!!\n");
2226 }
2227
2228 /* Copied from ddraw code: */
2229 temp.u.s._11 = (mat->u.s._11 * pMatrix->u.s._11) + (mat->u.s._21 * pMatrix->u.s._12) + (mat->u.s._31 * pMatrix->u.s._13) + (mat->u.s._41 * pMatrix->u.s._14);
2230 temp.u.s._21 = (mat->u.s._11 * pMatrix->u.s._21) + (mat->u.s._21 * pMatrix->u.s._22) + (mat->u.s._31 * pMatrix->u.s._23) + (mat->u.s._41 * pMatrix->u.s._24);
2231 temp.u.s._31 = (mat->u.s._11 * pMatrix->u.s._31) + (mat->u.s._21 * pMatrix->u.s._32) + (mat->u.s._31 * pMatrix->u.s._33) + (mat->u.s._41 * pMatrix->u.s._34);
2232 temp.u.s._41 = (mat->u.s._11 * pMatrix->u.s._41) + (mat->u.s._21 * pMatrix->u.s._42) + (mat->u.s._31 * pMatrix->u.s._43) + (mat->u.s._41 * pMatrix->u.s._44);
2233
2234 temp.u.s._12 = (mat->u.s._12 * pMatrix->u.s._11) + (mat->u.s._22 * pMatrix->u.s._12) + (mat->u.s._32 * pMatrix->u.s._13) + (mat->u.s._42 * pMatrix->u.s._14);
2235 temp.u.s._22 = (mat->u.s._12 * pMatrix->u.s._21) + (mat->u.s._22 * pMatrix->u.s._22) + (mat->u.s._32 * pMatrix->u.s._23) + (mat->u.s._42 * pMatrix->u.s._24);
2236 temp.u.s._32 = (mat->u.s._12 * pMatrix->u.s._31) + (mat->u.s._22 * pMatrix->u.s._32) + (mat->u.s._32 * pMatrix->u.s._33) + (mat->u.s._42 * pMatrix->u.s._34);
2237 temp.u.s._42 = (mat->u.s._12 * pMatrix->u.s._41) + (mat->u.s._22 * pMatrix->u.s._42) + (mat->u.s._32 * pMatrix->u.s._43) + (mat->u.s._42 * pMatrix->u.s._44);
2238
2239 temp.u.s._13 = (mat->u.s._13 * pMatrix->u.s._11) + (mat->u.s._23 * pMatrix->u.s._12) + (mat->u.s._33 * pMatrix->u.s._13) + (mat->u.s._43 * pMatrix->u.s._14);
2240 temp.u.s._23 = (mat->u.s._13 * pMatrix->u.s._21) + (mat->u.s._23 * pMatrix->u.s._22) + (mat->u.s._33 * pMatrix->u.s._23) + (mat->u.s._43 * pMatrix->u.s._24);
2241 temp.u.s._33 = (mat->u.s._13 * pMatrix->u.s._31) + (mat->u.s._23 * pMatrix->u.s._32) + (mat->u.s._33 * pMatrix->u.s._33) + (mat->u.s._43 * pMatrix->u.s._34);
2242 temp.u.s._43 = (mat->u.s._13 * pMatrix->u.s._41) + (mat->u.s._23 * pMatrix->u.s._42) + (mat->u.s._33 * pMatrix->u.s._43) + (mat->u.s._43 * pMatrix->u.s._44);
2243
2244 temp.u.s._14 = (mat->u.s._14 * pMatrix->u.s._11) + (mat->u.s._24 * pMatrix->u.s._12) + (mat->u.s._34 * pMatrix->u.s._13) + (mat->u.s._44 * pMatrix->u.s._14);
2245 temp.u.s._24 = (mat->u.s._14 * pMatrix->u.s._21) + (mat->u.s._24 * pMatrix->u.s._22) + (mat->u.s._34 * pMatrix->u.s._23) + (mat->u.s._44 * pMatrix->u.s._24);
2246 temp.u.s._34 = (mat->u.s._14 * pMatrix->u.s._31) + (mat->u.s._24 * pMatrix->u.s._32) + (mat->u.s._34 * pMatrix->u.s._33) + (mat->u.s._44 * pMatrix->u.s._34);
2247 temp.u.s._44 = (mat->u.s._14 * pMatrix->u.s._41) + (mat->u.s._24 * pMatrix->u.s._42) + (mat->u.s._34 * pMatrix->u.s._43) + (mat->u.s._44 * pMatrix->u.s._44);
2248
2249 /* Apply change via set transform - will reapply to eg. lights this way */
2250 IDirect3DDevice8Impl_SetTransform(iface, State, &temp);
2251 return D3D_OK;
2252 }
2253 HRESULT WINAPI IDirect3DDevice8Impl_SetViewport(LPDIRECT3DDEVICE8 iface, CONST D3DVIEWPORT8* pViewport) {
2254 ICOM_THIS(IDirect3DDevice8Impl,iface);
2255
2256 TRACE("(%p)\n", This);
2257 This->UpdateStateBlock->Changed.viewport = TRUE;
2258 This->UpdateStateBlock->Set.viewport = TRUE;
2259 memcpy(&This->UpdateStateBlock->viewport, pViewport, sizeof(D3DVIEWPORT8));
2260
2261 /* Handle recording of state blocks */
2262 if (This->isRecordingState) {
2263 TRACE("Recording... not performing anything\n");
2264 return D3D_OK;
2265 }
2266
2267 TRACE("(%p) : x=%ld, y=%ld, wid=%ld, hei=%ld, minz=%f, maxz=%f\n", This,
2268 pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ);
2269
2270 glDepthRange(pViewport->MinZ, pViewport->MaxZ);
2271 checkGLcall("glDepthRange");
2272 /* Fixme? Note GL requires lower left, DirectX supplies upper left */
2273 glViewport(pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height);
2274 checkGLcall("glViewport");
2275
2276
2277 return D3D_OK;
2278
2279 }
2280 HRESULT WINAPI IDirect3DDevice8Impl_GetViewport(LPDIRECT3DDEVICE8 iface, D3DVIEWPORT8* pViewport) {
2281 ICOM_THIS(IDirect3DDevice8Impl,iface);
2282 TRACE("(%p)\n", This);
2283 memcpy(pViewport, &This->StateBlock->viewport, sizeof(D3DVIEWPORT8));
2284 return D3D_OK;
2285 }
2286
2287 HRESULT WINAPI IDirect3DDevice8Impl_SetMaterial(LPDIRECT3DDEVICE8 iface, CONST D3DMATERIAL8* pMaterial) {
2288 ICOM_THIS(IDirect3DDevice8Impl,iface);
2289
2290 This->UpdateStateBlock->Changed.material = TRUE;
2291 This->UpdateStateBlock->Set.material = TRUE;
2292 memcpy(&This->UpdateStateBlock->material, pMaterial, sizeof(D3DMATERIAL8));
2293
2294 /* Handle recording of state blocks */
2295 if (This->isRecordingState) {
2296 TRACE("Recording... not performing anything\n");
2297 return D3D_OK;
2298 }
2299
2300 ENTER_GL();
2301 TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g, pMaterial->Diffuse.b, pMaterial->Diffuse.a);
2302 TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g, pMaterial->Ambient.b, pMaterial->Ambient.a);
2303 TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g, pMaterial->Specular.b, pMaterial->Specular.a);
2304 TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g, pMaterial->Emissive.b, pMaterial->Emissive.a);
2305 TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
2306
2307 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&This->UpdateStateBlock->material.Ambient);
2308 checkGLcall("glMaterialfv");
2309 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&This->UpdateStateBlock->material.Diffuse);
2310 checkGLcall("glMaterialfv");
2311
2312 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&This->UpdateStateBlock->material.Specular);
2313 checkGLcall("glMaterialfv");
2314 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float *)&This->UpdateStateBlock->material.Emissive);
2315 checkGLcall("glMaterialfv");
2316 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, This->UpdateStateBlock->material.Power);
2317 checkGLcall("glMaterialf");
2318
2319 LEAVE_GL();
2320 return D3D_OK;
2321 }
2322 HRESULT WINAPI IDirect3DDevice8Impl_GetMaterial(LPDIRECT3DDEVICE8 iface, D3DMATERIAL8* pMaterial) {
2323 ICOM_THIS(IDirect3DDevice8Impl,iface);
2324 memcpy(pMaterial, &This->UpdateStateBlock->material, sizeof (D3DMATERIAL8));
2325 TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g, pMaterial->Diffuse.b, pMaterial->Diffuse.a);
2326 TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g, pMaterial->Ambient.b, pMaterial->Ambient.a);
2327 TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g, pMaterial->Specular.b, pMaterial->Specular.a);
2328 TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g, pMaterial->Emissive.b, pMaterial->Emissive.a);
2329 TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
2330 return D3D_OK;
2331 }
2332
2333 HRESULT WINAPI IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST D3DLIGHT8* pLight) {
2334 float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
2335 float rho;
2336 float quad_att;
2337
2338 ICOM_THIS(IDirect3DDevice8Impl,iface);
2339 TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight);
2340
2341 if (Index > This->maxLights) {
2342 FIXME("Cannot handle more lights than device supports\n");
2343 return D3DERR_INVALIDCALL;
2344 }
2345
2346 TRACE("Light %ld setting to type %d, Diffuse(%f,%f,%f,%f), Specular(%f,%f,%f,%f), Ambient(%f,%f,%f,%f)\n", Index, pLight->Type,
2347 pLight->Diffuse.r, pLight->Diffuse.g, pLight->Diffuse.b, pLight->Diffuse.a,
2348 pLight->Specular.r, pLight->Specular.g, pLight->Specular.b, pLight->Specular.a,
2349 pLight->Ambient.r, pLight->Ambient.g, pLight->Ambient.b, pLight->Ambient.a);
2350 TRACE("... Pos(%f,%f,%f), Dirn(%f,%f,%f)\n", pLight->Position.x, pLight->Position.y, pLight->Position.z,
2351 pLight->Direction.x, pLight->Direction.y, pLight->Direction.z);
2352 TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n", pLight->Range, pLight->Falloff, pLight->Theta, pLight->Phi);
2353
2354 This->UpdateStateBlock->Changed.lights[Index] = TRUE;
2355 This->UpdateStateBlock->Set.lights[Index] = TRUE;
2356 memcpy(&This->UpdateStateBlock->lights[Index], pLight, sizeof(D3DLIGHT8));
2357
2358 /* Handle recording of state blocks */
2359 if (This->isRecordingState) {
2360 TRACE("Recording... not performing anything\n");
2361 return D3D_OK;
2362 }
2363
2364 /* Diffuse: */
2365 colRGBA[0] = pLight->Diffuse.r;
2366 colRGBA[1] = pLight->Diffuse.g;
2367 colRGBA[2] = pLight->Diffuse.b;
2368 colRGBA[3] = pLight->Diffuse.a;
2369 glLightfv(GL_LIGHT0+Index, GL_DIFFUSE, colRGBA);
2370 checkGLcall("glLightfv");
2371
2372 /* Specular */
2373 colRGBA[0] = pLight->Specular.r;
2374 colRGBA[1] = pLight->Specular.g;
2375 colRGBA[2] = pLight->Specular.b;
2376 colRGBA[3] = pLight->Specular.a;
2377 glLightfv(GL_LIGHT0+Index, GL_SPECULAR, colRGBA);
2378 checkGLcall("glLightfv");
2379
2380 /* Ambient */
2381 colRGBA[0] = pLight->Ambient.r;
2382 colRGBA[1] = pLight->Ambient.g;
2383 colRGBA[2] = pLight->Ambient.b;
2384 colRGBA[3] = pLight->Ambient.a;
2385 glLightfv(GL_LIGHT0+Index, GL_AMBIENT, colRGBA);
2386 checkGLcall("glLightfv");
2387
2388 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
2389 glMatrixMode(GL_MODELVIEW);
2390 glPushMatrix();
2391 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
2392
2393 /* Attenuation - Are these right? guessing... */
2394 glLightf(GL_LIGHT0+Index, GL_CONSTANT_ATTENUATION, pLight->Attenuation0);
2395 checkGLcall("glLightf");
2396 glLightf(GL_LIGHT0+Index, GL_LINEAR_ATTENUATION, pLight->Attenuation1);
2397 checkGLcall("glLightf");
2398
2399 quad_att = 1.4/(pLight->Range*pLight->Range);
2400 if (quad_att < pLight->Attenuation2) quad_att = pLight->Attenuation2;
2401 glLightf(GL_LIGHT0+Index, GL_QUADRATIC_ATTENUATION, quad_att);
2402 checkGLcall("glLightf");
2403
2404 switch (pLight->Type) {
2405 case D3DLIGHT_POINT:
2406 /* Position */
2407 This->lightPosn[Index][0] = pLight->Position.x;
2408 This->lightPosn[Index][1] = pLight->Position.y;
2409 This->lightPosn[Index][2] = pLight->Position.z;
2410 This->lightPosn[Index][3] = 1.0;
2411 glLightfv(GL_LIGHT0+Index, GL_POSITION, &This->lightPosn[Index][0]);
2412 checkGLcall("glLightfv");
2413
2414 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, 180);
2415 checkGLcall("glLightf");
2416
2417 /* FIXME: Range */
2418 break;
2419
2420 case D3DLIGHT_SPOT:
2421 /* Position */
2422 This->lightPosn[Index][0] = pLight->Position.x;
2423 This->lightPosn[Index][1] = pLight->Position.y;
2424 This->lightPosn[Index][2] = pLight->Position.z;
2425 This->lightPosn[Index][3] = 1.0;
2426 glLightfv(GL_LIGHT0+Index, GL_POSITION, &This->lightPosn[Index][0]);
2427 checkGLcall("glLightfv");
2428
2429 /* Direction */
2430 This->lightDirn[Index][0] = pLight->Direction.x;
2431 This->lightDirn[Index][1] = pLight->Direction.y;
2432 This->lightDirn[Index][2] = pLight->Direction.z;
2433 This->lightDirn[Index][3] = 1.0;
2434 glLightfv(GL_LIGHT0+Index, GL_SPOT_DIRECTION, &This->lightDirn[Index][0]);
2435 checkGLcall("glLightfv");
2436
2437 /*
2438 * opengl-ish and d3d-ish spot lights use too different models for the
2439 * light "intensity" as a function of the angle towards the main light direction,
2440 * so we only can approximate very roughly.
2441 * however spot lights are rather rarely used in games (if ever used at all).
2442 * furthermore if still used, probably nobody pays attention to such details.
2443 */
2444 if (pLight->Falloff == 0) {
2445 rho = 6.28f;
2446 } else {
2447 rho = pLight->Theta + (pLight->Phi - pLight->Theta)/(2*pLight->Falloff);
2448 }
2449 if (rho < 0.0001) rho = 0.0001f;
2450 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, -0.3/log(cos(rho/2)));
2451 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, pLight->Phi*90/M_PI);
2452
2453 /* FIXME: Range */
2454 break;
2455 case D3DLIGHT_DIRECTIONAL:
2456 /* Direction */
2457 This->lightPosn[Index][0] = -pLight->Direction.x;
2458 This->lightPosn[Index][1] = -pLight->Direction.y;
2459 This->lightPosn[Index][2] = -pLight->Direction.z;
2460 This->lightPosn[Index][3] = 0.0;
2461 glLightfv(GL_LIGHT0+Index, GL_POSITION, &This->lightPosn[Index][0]); /* Note gl uses w position of 0 for direction! */
2462 checkGLcall("glLightfv");
2463
2464 glLightf(GL_LIGHT0+Index, GL_SPOT_CUTOFF, 180.0f);
2465 glLightf(GL_LIGHT0+Index, GL_SPOT_EXPONENT, 0.0f);
2466
2467
2468 break;
2469 default:
2470 FIXME("Unrecognized light type %d\n", pLight->Type);
2471 }
2472
2473 /* Restore the modelview matrix */
2474 glPopMatrix();
2475
2476 return D3D_OK;
2477 }
2478 HRESULT WINAPI IDirect3DDevice8Impl_GetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,D3DLIGHT8* pLight) {
2479 ICOM_THIS(IDirect3DDevice8Impl,iface);
2480 TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight);
2481
2482 if (Index > This->maxLights) {
2483 FIXME("Cannot handle more lights than device supports\n");
2484 return D3DERR_INVALIDCALL;
2485 }
2486
2487 memcpy(pLight, &This->StateBlock->lights[Index], sizeof(D3DLIGHT8));
2488 return D3D_OK;
2489 }
2490 HRESULT WINAPI IDirect3DDevice8Impl_LightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL Enable) {
2491 ICOM_THIS(IDirect3DDevice8Impl,iface);
2492 TRACE("(%p) : Idx(%ld), enable? %d\n", This, Index, Enable);
2493
2494 if (Index > This->maxLights) {
2495 FIXME("Cannot handle more lights than device supports\n");
2496 return D3DERR_INVALIDCALL;
2497 }
2498
2499 This->UpdateStateBlock->Changed.lightEnable[Index] = TRUE;
2500 This->UpdateStateBlock->Set.lightEnable[Index] = TRUE;
2501 This->UpdateStateBlock->lightEnable[Index] = Enable;
2502
2503 /* Handle recording of state blocks */
2504 if (This->isRecordingState) {
2505 TRACE("Recording... not performing anything\n");
2506 return D3D_OK;
2507 }
2508
2509 if (Enable) {
2510 glEnable(GL_LIGHT0+Index);
2511 checkGLcall("glEnable GL_LIGHT0+Index");
2512 } else {
2513 glDisable(GL_LIGHT0+Index);
2514 checkGLcall("glDisable GL_LIGHT0+Index");
2515 }
2516 return D3D_OK;
2517 }
2518 HRESULT WINAPI IDirect3DDevice8Impl_GetLightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL* pEnable) {
2519 ICOM_THIS(IDirect3DDevice8Impl,iface);
2520 TRACE("(%p) : for idx(%ld)\n", This, Index);
2521
2522 if (Index > This->maxLights) {
2523 FIXME("Cannot handle more lights than device supports\n");
2524 return D3DERR_INVALIDCALL;
2525 }
2526
2527 *pEnable = This->StateBlock->lightEnable[Index];
2528 return D3D_OK;
2529 }
2530 HRESULT WINAPI IDirect3DDevice8Impl_SetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST float* pPlane) {
2531 ICOM_THIS(IDirect3DDevice8Impl,iface);
2532 TRACE("(%p) : for idx %ld, %p\n", This, Index, pPlane);
2533
2534 /* Validate Index */
2535 if (Index >= This->clipPlanes ) {
2536 TRACE("Application has requested clipplane this device doesnt support\n");
2537 return D3DERR_INVALIDCALL;
2538 }
2539
2540 This->UpdateStateBlock->Changed.clipplane[Index] = TRUE;
2541 This->UpdateStateBlock->Set.clipplane[Index] = TRUE;
2542 This->UpdateStateBlock->clipplane[Index][0] = pPlane[0];
2543 This->UpdateStateBlock->clipplane[Index][1] = pPlane[1];
2544 This->UpdateStateBlock->clipplane[Index][2] = pPlane[2];
2545 This->UpdateStateBlock->clipplane[Index][3] = pPlane[3];
2546
2547 /* Handle recording of state blocks */
2548 if (This->isRecordingState) {
2549 TRACE("Recording... not performing anything\n");
2550 return D3D_OK;
2551 }
2552
2553 /* Apply it */
2554
2555 /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
2556 glMatrixMode(GL_MODELVIEW);
2557 glPushMatrix();
2558 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
2559
2560 TRACE("Clipplane [%f,%f,%f,%f]\n", This->UpdateStateBlock->clipplane[Index][0], This->UpdateStateBlock->clipplane[Index][1],
2561 This->UpdateStateBlock->clipplane[Index][2], This->UpdateStateBlock->clipplane[Index][3]);
2562 glClipPlane(GL_CLIP_PLANE0+Index, This->UpdateStateBlock->clipplane[Index]);
2563
2564 glPopMatrix();
2565 checkGLcall("glClipPlane");
2566
2567 return D3D_OK;
2568 }
2569 HRESULT WINAPI IDirect3DDevice8Impl_GetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,float* pPlane) {
2570 ICOM_THIS(IDirect3DDevice8Impl,iface);
2571 TRACE("(%p) : for idx %ld\n", This, Index);
2572
2573 /* Validate Index */
2574 if (Index >= This->clipPlanes ) {
2575 TRACE("Application has requested clipplane this device doesnt support\n");
2576 return D3DERR_INVALIDCALL;
2577 }
2578
2579 pPlane[0] = This->StateBlock->clipplane[Index][0];
2580 pPlane[1] = This->StateBlock->clipplane[Index][0];
2581 pPlane[2] = This->StateBlock->clipplane[Index][0];
2582 pPlane[3] = This->StateBlock->clipplane[Index][0];
2583 return D3D_OK;
2584 }
2585 HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD Value) {
2586 ICOM_THIS(IDirect3DDevice8Impl,iface);
2587 DWORD OldValue = This->StateBlock->renderstate[State];
2588
2589 TRACE("(%p)->state = %d, value = %ld\n", This, State, Value);
2590 This->UpdateStateBlock->Changed.renderstate[State] = TRUE;
2591 This->UpdateStateBlock->Set.renderstate[State] = TRUE;
2592 This->UpdateStateBlock->renderstate[State] = Value;
2593
2594 /* Handle recording of state blocks */
2595 if (This->isRecordingState) {
2596 TRACE("Recording... not performing anything\n");
2597 return D3D_OK;
2598 }
2599
2600 switch (State) {
2601 case D3DRS_FILLMODE :
2602 switch ((D3DFILLMODE) Value) {
2603 case D3DFILL_POINT : glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); break;
2604 case D3DFILL_WIREFRAME : glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break;
2605 case D3DFILL_SOLID : glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break;
2606 default:
2607 FIXME("Unrecognized D3DRS_FILLMODE value %ld\n", Value);
2608 }
2609 checkGLcall("glPolygonMode (fillmode)");
2610 break;
2611
2612 case D3DRS_LIGHTING :
2613 if (Value) {
2614 glEnable(GL_LIGHTING);
2615 checkGLcall("glEnable GL_LIGHTING");
2616 } else {
2617 glDisable(GL_LIGHTING);
2618 checkGLcall("glDisable GL_LIGHTING");
2619 }
2620 break;
2621
2622 case D3DRS_ZENABLE :
2623 switch ((D3DZBUFFERTYPE) Value) {
2624 case D3DZB_FALSE:
2625 glDisable(GL_DEPTH_TEST);
2626 checkGLcall("glDisable GL_DEPTH_TEST");
2627 break;
2628 case D3DZB_TRUE:
2629 glEnable(GL_DEPTH_TEST);
2630 checkGLcall("glEnable GL_DEPTH_TEST");
2631 break;
2632
2633 case D3DZB_USEW:
2634 default:
2635 FIXME("Unrecognized/Unhandled D3DZBUFFERTYPE value %ld\n", Value);
2636 }
2637 break;
2638
2639 case D3DRS_CULLMODE :
2640
2641 /* If we are culling "back faces with clockwise vertices" then
2642 set front faces to be counter clockwise and enable culling
2643 of back faces */
2644 switch ((D3DCULL) Value) {
2645 case D3DCULL_NONE:
2646 glDisable(GL_CULL_FACE);
2647 checkGLcall("glDisable GL_CULL_FACE");
2648 break;
2649 case D3DCULL_CW:
2650 glEnable(GL_CULL_FACE);
2651 checkGLcall("glEnable GL_CULL_FACE");
2652 glFrontFace(GL_CCW);
2653 checkGLcall("glFrontFace GL_CCW");
2654 glCullFace(GL_BACK);
2655 break;
2656 case D3DCULL_CCW:
2657 glEnable(GL_CULL_FACE);
2658 checkGLcall("glEnable GL_CULL_FACE");
2659 glFrontFace(GL_CW);
2660 checkGLcall("glFrontFace GL_CW");
2661 glCullFace(GL_BACK);
2662 break;
2663 default:
2664 FIXME("Unrecognized/Unhandled D3DCULL value %ld\n", Value);
2665 }
2666 break;
2667
2668 case D3DRS_SHADEMODE :
2669 switch ((D3DSHADEMODE) Value) {
2670 case D3DSHADE_FLAT:
2671 glShadeModel(GL_FLAT);
2672 checkGLcall("glShadeModel");
2673 break;
2674 case D3DSHADE_GOURAUD:
2675 glShadeModel(GL_SMOOTH);
2676 checkGLcall("glShadeModel");
2677 break;
2678 case D3DSHADE_PHONG:
2679 FIXME("D3DSHADE_PHONG isnt supported?\n");
2680 return D3DERR_INVALIDCALL;
2681 default:
2682 FIXME("Unrecognized/Unhandled D3DSHADEMODE value %ld\n", Value);
2683 }
2684 break;
2685
2686 case D3DRS_DITHERENABLE :
2687 if (Value) {
2688 glEnable(GL_DITHER);
2689 checkGLcall("glEnable GL_DITHER");
2690 } else {
2691 glDisable(GL_DITHER);
2692 checkGLcall("glDisable GL_DITHER");
2693 }
2694 break;
2695
2696 case D3DRS_ZWRITEENABLE :
2697 if (Value) {
2698 glDepthMask(1);
2699 checkGLcall("glDepthMask");
2700 } else {
2701 glDepthMask(0);
2702 checkGLcall("glDepthMask");
2703 }
2704 break;
2705
2706 case D3DRS_ZFUNC :
2707 {
2708 int glParm = GL_LESS;
2709
2710 switch ((D3DCMPFUNC) Value) {
2711 case D3DCMP_NEVER: glParm=GL_NEVER; break;
2712 case D3DCMP_LESS: glParm=GL_LESS; break;
2713 case D3DCMP_EQUAL: glParm=GL_EQUAL; break;
2714 case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break;
2715 case D3DCMP_GREATER: glParm=GL_GREATER; break;
2716 case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break;
2717 case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break;
2718 case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break;
2719 default:
2720 FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value);
2721 }
2722 glDepthFunc(glParm);
2723 checkGLcall("glDepthFunc");
2724 }
2725 break;
2726
2727 case D3DRS_AMBIENT :
2728 {
2729
2730 float col[4];
2731 col[0] = ((Value >> 16) & 0xFF) / 255.0;
2732 col[1] = ((Value >> 8 ) & 0xFF) / 255.0;
2733 col[2] = ((Value >> 0 ) & 0xFF) / 255.0;
2734 col[3] = ((Value >> 24 ) & 0xFF) / 255.0;
2735 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0],col[1],col[2],col[3]);
2736 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
2737 checkGLcall("glLightModel for MODEL_AMBIENT");
2738
2739 }
2740 break;
2741
2742 case D3DRS_ALPHABLENDENABLE :
2743 if (Value) {
2744 glEnable(GL_BLEND);
2745 checkGLcall("glEnable GL_BLEND");
2746 } else {
2747 glDisable(GL_BLEND);
2748 checkGLcall("glDisable GL_BLEND");
2749 };
2750 break;
2751
2752 case D3DRS_SRCBLEND :
2753 case D3DRS_DESTBLEND :
2754 {
2755 int newVal = GL_ZERO;
2756 switch (Value) {
2757 case D3DBLEND_ZERO : newVal = GL_ZERO; break;
2758 case D3DBLEND_ONE : newVal = GL_ONE; break;
2759 case D3DBLEND_SRCCOLOR : newVal = GL_SRC_COLOR; break;
2760 case D3DBLEND_INVSRCCOLOR : newVal = GL_ONE_MINUS_SRC_COLOR; break;
2761 case D3DBLEND_SRCALPHA : newVal = GL_SRC_ALPHA; break;
2762 case D3DBLEND_INVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA; break;
2763 case D3DBLEND_DESTALPHA : newVal = GL_DST_ALPHA; break;
2764 case D3DBLEND_INVDESTALPHA : newVal = GL_ONE_MINUS_DST_ALPHA; break;
2765 case D3DBLEND_DESTCOLOR : newVal = GL_DST_COLOR; break;
2766 case D3DBLEND_INVDESTCOLOR : newVal = GL_ONE_MINUS_DST_COLOR; break;
2767 case D3DBLEND_SRCALPHASAT : newVal = GL_SRC_ALPHA_SATURATE; break;
2768
2769 case D3DBLEND_BOTHSRCALPHA : newVal = GL_SRC_ALPHA;
2770 This->srcBlend = newVal;
2771 This->dstBlend = newVal;
2772 break;
2773
2774 case D3DBLEND_BOTHINVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA;
2775 This->srcBlend = newVal;
2776 This->dstBlend = newVal;
2777 break;
2778 default:
2779 FIXME("Unrecognized src/dest blend value %ld (%d)\n", Value, State);
2780 }
2781
2782 if (State == D3DRS_SRCBLEND) This->srcBlend = newVal;
2783 if (State == D3DRS_DESTBLEND) This->dstBlend = newVal;
2784 TRACE("glBlendFunc src=%x, dst=%x\n", This->srcBlend, This->dstBlend);
2785 glBlendFunc(This->srcBlend, This->dstBlend);
2786
2787 checkGLcall("glBlendFunc");
2788 }
2789 break;
2790
2791 case D3DRS_ALPHATESTENABLE :
2792 if (Value) {
2793 glEnable(GL_ALPHA_TEST);
2794 checkGLcall("glEnable GL_ALPHA_TEST");
2795 } else {
2796 glDisable(GL_ALPHA_TEST);
2797 checkGLcall("glDisable GL_ALPHA_TEST");
2798 }
2799 break;
2800
2801 case D3DRS_ALPHAFUNC :
2802 {
2803 int glParm = GL_LESS;
2804 float ref = 1.0;
2805
2806 glGetFloatv(GL_ALPHA_TEST_REF, &ref);
2807 checkGLcall("glGetFloatv(GL_ALPHA_TEST_REF, &ref);");
2808
2809 switch ((D3DCMPFUNC) Value) {
2810 case D3DCMP_NEVER: glParm=GL_NEVER; break;
2811 case D3DCMP_LESS: glParm=GL_LESS; break;
2812 case D3DCMP_EQUAL: glParm=GL_EQUAL; break;
2813 case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break;
2814 case D3DCMP_GREATER: glParm=GL_GREATER; break;
2815 case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break;
2816 case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break;
2817 case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break;
2818 default:
2819 FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value);
2820 }
2821 TRACE("glAlphaFunc with Parm=%x, ref=%f\n", glParm, ref);
2822 glAlphaFunc(glParm, ref);
2823 checkGLcall("glAlphaFunc");
2824 }
2825 break;
2826
2827 case D3DRS_ALPHAREF :
2828 {
2829 int glParm = GL_LESS;
2830 float ref = 1.0;
2831
2832 glGetIntegerv(GL_ALPHA_TEST_FUNC, &glParm);
2833 checkGLcall("glGetFloatv(GL_ALPHA_TEST_FUNC, &glParm);");
2834
2835 ref = ((float) Value) / 255.0;
2836 TRACE("glAlphaFunc with Parm=%x, ref=%f\n", glParm, ref);
2837 glAlphaFunc(glParm, ref);
2838 checkGLcall("glAlphaFunc");
2839 }
2840 break;
2841
2842 case D3DRS_CLIPPLANEENABLE :
2843 case D3DRS_CLIPPING :
2844 {
2845 /* Ensure we only do the changed clip planes */
2846 DWORD enable = 0xFFFFFFFF;
2847 DWORD disable = 0x00000000;
2848
2849 /* If enabling / disabling all */
2850 if (State == D3DRS_CLIPPING) {
2851 if (Value) {
2852 enable = This->StateBlock->renderstate[D3DRS_CLIPPLANEENABLE];
2853 disable = 0x00;
2854 } else {
2855 disable = This->StateBlock->renderstate[D3DRS_CLIPPLANEENABLE];
2856 enable = 0x00;
2857 }
2858 } else {
2859 enable = Value & ~OldValue;
2860 disable = ~Value & OldValue;
2861 }
2862
2863 if (enable & D3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
2864 if (enable & D3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
2865 if (enable & D3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
2866 if (enable & D3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
2867 if (enable & D3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
2868 if (enable & D3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
2869
2870 if (disable & D3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
2871 if (disable & D3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
2872 if (disable & D3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
2873 if (disable & D3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
2874 if (disable & D3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
2875 if (disable & D3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
2876 }
2877 break;
2878
2879 case D3DRS_BLENDOP :
2880 {
2881 int glParm = GL_FUNC_ADD;
2882
2883 switch ((D3DBLENDOP) Value) {
2884 case D3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break;
2885 case D3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break;
2886 case D3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
2887 case D3DBLENDOP_MIN : glParm = GL_MIN; break;
2888 case D3DBLENDOP_MAX : glParm = GL_MAX; break;
2889 default:
2890 FIXME("Unrecognized/Unhandled D3DBLENDOP value %ld\n", Value);
2891 }
2892 TRACE("glBlendEquation(%x)\n", glParm);
2893 glBlendEquation(glParm);
2894 checkGLcall("glBlendEquation");
2895 }
2896 break;
2897
2898 case D3DRS_TEXTUREFACTOR :
2899 {
2900 int i;
2901
2902 /* Note the texture color applies to all textures whereas
2903 GL_TEXTURE_ENV_COLOR applies to active only */
2904 float col[4];
2905 col[0] = ((Value >> 16) & 0xFF) / 255.0;
2906 col[1] = ((Value >> 8 ) & 0xFF) / 255.0;
2907 col[2] = ((Value >> 0 ) & 0xFF) / 255.0;
2908 col[3] = ((Value >> 24 ) & 0xFF) / 255.0;
2909
2910 /* Set the default alpha blend color */
2911 glBlendColor(col[0], col[1], col[2], col[3]);
2912 checkGLcall("glBlendColor");
2913
2914 /* And now the default texture color as well */
2915 for (i = 0; i < This->TextureUnits; i++) {
2916
2917 /* Note the D3DRS value applies to all textures, but GL has one
2918 per texture, so apply it now ready to be used! */
2919 if (This->isMultiTexture) {
2920 #if defined(GL_VERSION_1_3)
2921 glActiveTexture(GL_TEXTURE0 + i);
2922 #else
2923 glActiveTextureARB(GL_TEXTURE0_ARB + i);
2924 #endif
2925 checkGLcall("Activate texture.. to update const color");
2926 } else if (i>0) {
2927 FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
2928 }
2929
2930 glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
2931 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
2932 }
2933 }
2934 break;
2935
2936 case D3DRS_SPECULARENABLE :
2937 {
2938 if (Value) {
2939 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR);
2940 checkGLcall("glLightModel (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR);");
2941 } else {
2942 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR);
2943 checkGLcall("glLightModel (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR);");
2944 }
2945 }
2946 break;
2947
2948 case D3DRS_STENCILENABLE :
2949 if (Value) {
2950 glEnable(GL_STENCIL_TEST);
2951 checkGLcall("glEnable GL_STENCIL_TEST");
2952 } else {
2953 glDisable(GL_STENCIL_TEST);
2954 checkGLcall("glDisable GL_STENCIL_TEST");
2955 }
2956 break;
2957
2958 case D3DRS_STENCILFUNC :
2959 {
2960 int glParm = GL_ALWAYS;
2961 int ref = 0;
2962 GLuint mask = 0xFFFFFFFF;
2963
2964 glGetIntegerv(GL_STENCIL_REF, &ref);
2965 checkGLcall("glGetFloatv(GL_STENCIL_REF, &ref);");
2966 glGetIntegerv(GL_STENCIL_VALUE_MASK, &mask);
2967 checkGLcall("glGetFloatv(GL_STENCIL_VALUE_MASK, &glParm);");
2968
2969 switch ((D3DCMPFUNC) Value) {
2970 case D3DCMP_NEVER: glParm=GL_NEVER; break;
2971 case D3DCMP_LESS: glParm=GL_LESS; break;
2972 case D3DCMP_EQUAL: glParm=GL_EQUAL; break;
2973 case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break;
2974 case D3DCMP_GREATER: glParm=GL_GREATER; break;
2975 case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break;
2976 case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break;
2977 case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break;
2978 default:
2979 FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value);
2980 }
2981 TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask);
2982 glStencilFunc(glParm, ref, mask);
2983 checkGLcall("glStencilFunc");
2984 }
2985 break;
2986
2987 case D3DRS_STENCILREF :
2988 {
2989 int glParm = GL_ALWAYS;
2990 int ref = 0;
2991 GLuint mask = 0xFFFFFFFF;
2992
2993 glGetIntegerv(GL_STENCIL_FUNC, &glParm);
2994 checkGLcall("glGetFloatv(GL_STENCIL_FUNC, &glParm);");
2995 glGetIntegerv(GL_STENCIL_VALUE_MASK, &mask);
2996 checkGLcall("glGetFloatv(GL_STENCIL_VALUE_MASK, &glParm);");
2997
2998 ref = Value;
2999 TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask);
3000 glStencilFunc(glParm, ref, mask);
3001 checkGLcall("glStencilFunc");
3002 }
3003 break;
3004
3005 case D3DRS_STENCILMASK :
3006 {
3007 int glParm = GL_ALWAYS;
3008 int ref = 0.0;
3009 GLuint mask = Value;
3010
3011 glGetIntegerv(GL_STENCIL_REF, &ref);
3012 checkGLcall("glGetFloatv(GL_STENCIL_REF, &ref);");
3013 glGetIntegerv(GL_STENCIL_FUNC, &glParm);
3014 checkGLcall("glGetFloatv(GL_STENCIL_FUNC, &glParm);");
3015
3016 TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask);
3017 glStencilFunc(glParm, ref, mask);
3018 checkGLcall("glStencilFunc");
3019 }
3020 break;
3021
3022 case D3DRS_STENCILFAIL :
3023 {
3024 GLenum fail ;
3025 GLenum zpass ;
3026 GLenum zfail ;
3027
3028 fail = StencilOp(Value);
3029 glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass);
3030 checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass);");
3031 glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail);
3032 checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail);");
3033
3034 TRACE("StencilOp fail=%x, zfail=%x, zpass=%x\n", fail, zfail, zpass);
3035 glStencilOp(fail, zfail, zpass);
3036 checkGLcall("glStencilOp(fail, zfail, zpass);");
3037 }
3038 break;
3039 case D3DRS_STENCILZFAIL :
3040 {
3041 GLenum fail ;
3042 GLenum zpass ;
3043 GLenum zfail ;
3044
3045 glGetIntegerv(GL_STENCIL_FAIL, &fail);
3046 checkGLcall("glGetIntegerv(GL_STENCIL_FAIL, &fail);");
3047 glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass);
3048 checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass);");
3049 zfail = StencilOp(Value);
3050
3051 TRACE("StencilOp fail=%x, zfail=%x, zpass=%x\n", fail, zfail, zpass);
3052 glStencilOp(fail, zfail, zpass);
3053 checkGLcall("glStencilOp(fail, zfail, zpass);");
3054 }
3055 break;
3056 case D3DRS_STENCILPASS :
3057 {
3058 GLenum fail ;
3059 GLenum zpass ;
3060 GLenum zfail ;
3061
3062 glGetIntegerv(GL_STENCIL_FAIL, &fail);
3063 checkGLcall("glGetIntegerv(GL_STENCIL_FAIL, &fail);");
3064 zpass = StencilOp(Value);
3065 glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail);
3066 checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail);");
3067
3068 TRACE("StencilOp fail=%x, zfail=%x, zpass=%x\n", fail, zfail, zpass);
3069 glStencilOp(fail, zfail, zpass);
3070 checkGLcall("glStencilOp(fail, zfail, zpass);");
3071 }
3072 break;
3073
3074 case D3DRS_STENCILWRITEMASK :
3075 {
3076 glStencilMask(Value);
3077 TRACE("glStencilMask(%lu)\n", Value);
3078 checkGLcall("glStencilMask");
3079 }
3080 break;
3081
3082 case D3DRS_FOGENABLE :
3083 {
3084 if (Value && This->StateBlock->renderstate[D3DRS_FOGTABLEMODE] != D3DFOG_NONE) {
3085 glEnable(GL_FOG);
3086 checkGLcall("glEnable GL_FOG\n");
3087 } else {
3088 glDisable(GL_FOG);
3089 checkGLcall("glDisable GL_FOG\n");
3090 }
3091 }
3092 break;
3093
3094 case D3DRS_FOGCOLOR :
3095 {
3096 float col[4];
3097 col[0] = ((Value >> 16) & 0xFF) / 255.0;
3098 col[1] = ((Value >> 8 ) & 0xFF) / 255.0;
3099 col[2] = ((Value >> 0 ) & 0xFF) / 255.0;
3100 col[3] = ((Value >> 24 ) & 0xFF) / 255.0;
3101
3102 /* Set the default alpha blend color */
3103 glFogfv(GL_FOG_COLOR, &col[0]);
3104 checkGLcall("glFog GL_FOG_COLOR");
3105 }
3106 break;
3107
3108 case D3DRS_FOGSTART :
3109 {
3110 float *f = (float *)&Value;
3111 glFogfv(GL_FOG_START, f);
3112 checkGLcall("glFogf(GL_FOG_START, (float) Value)");
3113 TRACE("Fog Start == %f\n", *f);
3114 }
3115 break;
3116
3117 case D3DRS_FOGEND :
3118 {
3119 float *f = (float *)&Value;
3120 glFogfv(GL_FOG_END, f);
3121 checkGLcall("glFogf(GL_FOG_END, (float) Value)");
3122 TRACE("Fog End == %f\n", *f);
3123 }
3124 break;
3125
3126 case D3DRS_FOGDENSITY :
3127 {
3128 glFogf(GL_FOG_DENSITY, (float) Value);
3129 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
3130 }
3131 break;
3132
3133 case D3DRS_VERTEXBLEND :
3134 {
3135 This->UpdateStateBlock->vertex_blend = (D3DVERTEXBLENDFLAGS) Value;
3136 TRACE("Vertex Blending state to %ld\n", Value);
3137 }
3138 break;
3139
3140 case D3DRS_TWEENFACTOR :
3141 {
3142 This->UpdateStateBlock->tween_factor = *((float*) &Value);
3143 TRACE("Vertex Blending Tween Factor to %f\n", This->UpdateStateBlock->tween_factor);
3144 }
3145 break;
3146
3147 case D3DRS_INDEXEDVERTEXBLENDENABLE :
3148 {
3149 TRACE("Indexed Vertex Blend Enable to %ul\n", (BOOL) Value);
3150 }
3151 break;
3152
3153
3154 case D3DRS_COLORVERTEX :
3155 case D3DRS_DIFFUSEMATERIALSOURCE :
3156 case D3DRS_SPECULARMATERIALSOURCE :
3157 case D3DRS_AMBIENTMATERIALSOURCE :
3158 case D3DRS_EMISSIVEMATERIALSOURCE :
3159 {
3160 GLenum Parm = GL_AMBIENT_AND_DIFFUSE;
3161
3162 if (This->StateBlock->renderstate[D3DRS_COLORVERTEX]) {
3163 glEnable(GL_COLOR_MATERIAL);
3164 checkGLcall("glEnable GL_GL_COLOR_MATERIAL\n");
3165
3166 TRACE("diff %ld, amb %ld, emis %ld, spec %ld\n",
3167 This->StateBlock->renderstate[D3DRS_DIFFUSEMATERIALSOURCE],
3168 This->StateBlock->renderstate[D3DRS_AMBIENTMATERIALSOURCE],
3169 This->StateBlock->renderstate[D3DRS_EMISSIVEMATERIALSOURCE],
3170 This->StateBlock->renderstate[D3DRS_SPECULARMATERIALSOURCE]);
3171
3172 if (This->StateBlock->renderstate[D3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) {
3173 if (This->StateBlock->renderstate[D3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
3174 Parm = GL_AMBIENT_AND_DIFFUSE;
3175 } else {
3176 Parm = GL_DIFFUSE;
3177 }
3178 } else if (This->StateBlock->renderstate[D3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
3179 Parm = GL_AMBIENT;
3180 } else if (This->StateBlock->renderstate[D3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) {
3181 Parm = GL_EMISSION;
3182 } else if (This->StateBlock->renderstate[D3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) {
3183 Parm = GL_SPECULAR;
3184 } else {
3185 Parm = -1;
3186 }
3187
3188 if (Parm == -1) {
3189 glDisable(GL_COLOR_MATERIAL);
3190 checkGLcall("glDisable GL_GL_COLOR_MATERIAL\n");
3191 } else {
3192 TRACE("glColorMaterial Parm=%d\n", Parm);
3193 glColorMaterial(GL_FRONT_AND_BACK, Parm);
3194 checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)\n");
3195 }
3196
3197 } else {
3198 glDisable(GL_COLOR_MATERIAL);
3199 checkGLcall("glDisable GL_GL_COLOR_MATERIAL\n");
3200 }
3201 }
3202 break;
3203
3204 /* Unhandled yet...! */
3205 case D3DRS_LINEPATTERN :
3206 case D3DRS_LASTPIXEL :
3207 case D3DRS_ZVISIBLE :
3208 case D3DRS_FOGTABLEMODE :
3209 case D3DRS_EDGEANTIALIAS :
3210 case D3DRS_ZBIAS :
3211 case D3DRS_RANGEFOGENABLE :
3212 case D3DRS_WRAP0 :
3213 case D3DRS_WRAP1 :
3214 case D3DRS_WRAP2 :
3215 case D3DRS_WRAP3 :
3216 case D3DRS_WRAP4 :
3217 case D3DRS_WRAP5 :
3218 case D3DRS_WRAP6 :
3219 case D3DRS_WRAP7 :
3220 case D3DRS_FOGVERTEXMODE :
3221 case D3DRS_LOCALVIEWER :
3222 case D3DRS_NORMALIZENORMALS :
3223 case D3DRS_SOFTWAREVERTEXPROCESSING :
3224 case D3DRS_POINTSIZE :
3225 case D3DRS_POINTSIZE_MIN :
3226 case D3DRS_POINTSPRITEENABLE :
3227 case D3DRS_POINTSCALEENABLE :
3228 case D3DRS_POINTSCALE_A :
3229 case D3DRS_POINTSCALE_B :
3230 case D3DRS_POINTSCALE_C :
3231 case D3DRS_MULTISAMPLEANTIALIAS :
3232 case D3DRS_MULTISAMPLEMASK :
3233 case D3DRS_PATCHEDGESTYLE :
3234 case D3DRS_PATCHSEGMENTS :
3235 case D3DRS_DEBUGMONITORTOKEN :
3236 case D3DRS_POINTSIZE_MAX :
3237 case D3DRS_COLORWRITEENABLE :
3238 case D3DRS_POSITIONORDER :
3239 case D3DRS_NORMALORDER :
3240 /*Put back later: FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value); */
3241 TRACE("(%p)->(%d,%ld) not handled yet\n", This, State, Value);
3242 break;
3243 default:
3244 FIXME("(%p)->(%d,%ld) unrecognized\n", This, State, Value);
3245 }
3246
3247 return D3D_OK;
3248 }
3249 HRESULT WINAPI IDirect3DDevice8Impl_GetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD* pValue) {
3250 ICOM_THIS(IDirect3DDevice8Impl,iface);
3251 TRACE("(%p) for State %d = %ld\n", This, State, This->UpdateStateBlock->renderstate[State]);
3252 *pValue = This->StateBlock->renderstate[State];
3253 return D3D_OK;
3254 }
3255 HRESULT WINAPI IDirect3DDevice8Impl_BeginStateBlock(LPDIRECT3DDEVICE8 iface) {
3256 ICOM_THIS(IDirect3DDevice8Impl,iface);
3257
3258 TRACE("(%p)\n", This);
3259
3260 return IDirect3DDeviceImpl_BeginStateBlock(This);
3261 }
3262 HRESULT WINAPI IDirect3DDevice8Impl_EndStateBlock(LPDIRECT3DDEVICE8 iface, DWORD* pToken) {
3263 IDirect3DStateBlockImpl* pSB;
3264 ICOM_THIS(IDirect3DDevice8Impl,iface);
3265 HRESULT res;
3266
3267 TRACE("(%p)\n", This);
3268
3269 res = IDirect3DDeviceImpl_EndStateBlock(This, &pSB);
3270 *pToken = (DWORD) pSB;
3271 return res;
3272 }
3273
3274 HRESULT WINAPI IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
3275 IDirect3DStateBlockImpl* pSB = (IDirect3DStateBlockImpl*) Token;
3276 ICOM_THIS(IDirect3DDevice8Impl,iface);
3277
3278 TRACE("(%p)\n", This);
3279
3280 return IDirect3DDeviceImpl_ApplyStateBlock(This, pSB);
3281
3282 }
3283 HRESULT WINAPI IDirect3DDevice8Impl_CaptureStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
3284 IDirect3DStateBlockImpl* pSB = (IDirect3DStateBlockImpl*) Token;
3285 ICOM_THIS(IDirect3DDevice8Impl,iface);
3286
3287 TRACE("(%p)\n", This);
3288
3289 return IDirect3DDeviceImpl_CaptureStateBlock(This, pSB);
3290 }
3291 HRESULT WINAPI IDirect3DDevice8Impl_DeleteStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
3292 IDirect3DStateBlockImpl* pSB = (IDirect3DStateBlockImpl*) Token;
3293 ICOM_THIS(IDirect3DDevice8Impl,iface);
3294
3295 TRACE("(%p)\n", This);
3296
3297 return IDirect3DDeviceImpl_DeleteStateBlock(This, pSB);
3298 }
3299
3300 HRESULT WINAPI IDirect3DDevice8Impl_CreateStateBlock(LPDIRECT3DDEVICE8 iface, D3DSTATEBLOCKTYPE Type, DWORD* pToken) {
3301 IDirect3DStateBlockImpl* pSB;
3302 ICOM_THIS(IDirect3DDevice8Impl,iface);
3303 HRESULT res;
3304
3305 TRACE("(%p) : for type %d\n", This, Type);
3306
3307 res = IDirect3DDeviceImpl_CreateStateBlock(This, Type, &pSB);
3308 *pToken = (DWORD) pSB;
3309 return res;
3310 }
3311
3312 HRESULT WINAPI IDirect3DDevice8Impl_SetClipStatus(LPDIRECT3DDEVICE8 iface, CONST D3DCLIPSTATUS8* pClipStatus) {
3313 ICOM_THIS(IDirect3DDevice8Impl,iface);
3314 FIXME("(%p) : stub\n", This); return D3D_OK;
3315 }
3316 HRESULT WINAPI IDirect3DDevice8Impl_GetClipStatus(LPDIRECT3DDEVICE8 iface, D3DCLIPSTATUS8* pClipStatus) {
3317 ICOM_THIS(IDirect3DDevice8Impl,iface);
3318 FIXME("(%p) : stub\n", This); return D3D_OK;
3319 }
3320 HRESULT WINAPI IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8** ppTexture) {
3321 ICOM_THIS(IDirect3DDevice8Impl,iface);
3322 TRACE("(%p) : returning %p for stage %ld\n", This, This->UpdateStateBlock->textures[Stage], Stage);
3323 *ppTexture = (LPDIRECT3DBASETEXTURE8)This->UpdateStateBlock->textures[Stage];
3324 IDirect3DBaseTexture8Impl_AddRef(*ppTexture);
3325 return D3D_OK;
3326 }
3327 HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8* pTexture) {
3328
3329 IDirect3DBaseTexture8 *oldTxt;
3330 BOOL reapplyStates = TRUE;
3331
3332 ICOM_THIS(IDirect3DDevice8Impl,iface);
3333 D3DRESOURCETYPE textureType;
3334
3335 oldTxt = This->UpdateStateBlock->textures[Stage];
3336 TRACE("(%p) : Stage(%ld), Texture (%p)\n", This, Stage, pTexture);
3337
3338 /* Reject invalid texture units */
3339 if (Stage >= This->TextureUnits) {
3340 TRACE("Attempt to access invalid texture rejected\n");
3341 return D3DERR_INVALIDCALL;
3342 }
3343
3344 This->UpdateStateBlock->Set.textures[Stage] = TRUE;
3345 This->UpdateStateBlock->Changed.textures[Stage] = TRUE;
3346 This->UpdateStateBlock->textures[Stage] = pTexture;
3347
3348 /* Handle recording of state blocks */
3349 if (This->isRecordingState) {
3350 TRACE("Recording... not performing anything\n");
3351 return D3D_OK;
3352 }
3353
3354 /* Make appropriate texture active */
3355 if (This->isMultiTexture) {
3356 #if defined(GL_VERSION_1_3)
3357 glActiveTexture(GL_TEXTURE0 + Stage);
3358 #else
3359 glActiveTextureARB(GL_TEXTURE0_ARB + Stage);
3360 #endif
3361 checkGLcall("glActiveTextureARB");
3362 } else if (Stage>0) {
3363 FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
3364 }
3365
3366 /* Decrement the count of the previous texture */
3367 if (oldTxt != NULL) {
3368 IDirect3DBaseTexture8Impl_Release(oldTxt);
3369 }
3370
3371 if (pTexture) {
3372 IDirect3DBaseTexture8Impl_AddRef((LPDIRECT3DBASETEXTURE8)This->UpdateStateBlock->textures[Stage]);
3373
3374 /* Now setup the texture appropraitly */
3375 textureType = IDirect3DBaseTexture8Impl_GetType(pTexture);
3376
3377 if (textureType == D3DRTYPE_TEXTURE) {
3378 IDirect3DTexture8Impl *pTexture2 = (IDirect3DTexture8Impl *) pTexture;
3379
3380 if ((void *)oldTxt == (void *)pTexture2 && pTexture2->Dirty == FALSE) {
3381 TRACE("Skipping setting texture as old == new\n");
3382 reapplyStates = FALSE;
3383 } else {
3384
3385 /* Standard 2D texture */
3386 TRACE("Standard 2d texture\n");
3387 This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_2D;
3388
3389 /* Load up the texture now */
3390 IDirect3DTexture8Impl_PreLoad((LPDIRECT3DTEXTURE8)pTexture);
3391 }
3392 } else if (textureType == D3DRTYPE_VOLUMETEXTURE) {
3393 IDirect3DVolumeTexture8Impl *pTexture2 = (IDirect3DVolumeTexture8Impl *) pTexture;
3394 int i;
3395
3396 /* Standard 3D (volume) texture */
3397 TRACE("Standard 3d texture\n");
3398 This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_3D;
3399
3400 for (i=0; i<pTexture2->levels; i++)
3401 {
3402
3403 if (i==0 && pTexture2->volumes[i]->textureName != 0 && pTexture2->Dirty == FALSE) {
3404 glBindTexture(GL_TEXTURE_3D, pTexture2->volumes[i]->textureName);
3405 checkGLcall("glBindTexture");
3406 TRACE("Texture %p given name %d\n", pTexture2->volumes[i], pTexture2->volumes[i]->textureName);
3407
3408 /* No need to walk through all mip-map levels, since already all assigned */
3409 i = pTexture2->levels;
3410 } else {
3411 if (i==0) {
3412
3413 if (pTexture2->volumes[i]->textureName == 0) {
3414 glGenTextures(1, &pTexture2->volumes[i]->textureName);
3415 checkGLcall("glGenTextures");
3416 TRACE("Texture %p given name %d\n", pTexture2->volumes[i], pTexture2->volumes[i]->textureName);
3417 }
3418
3419 glBindTexture(GL_TEXTURE_3D, pTexture2->volumes[i]->textureName);
3420 checkGLcall("glBindTexture");
3421
3422 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, pTexture2->levels-1);
3423 checkGLcall("glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, pTexture2->levels-1)");
3424 }
3425
3426 TRACE("Calling glTexImage3D %x i=%d, intfmt=%x, w=%d, h=%d,d=%d, 0=%d, glFmt=%x, glType=%lx, Mem=%p\n",
3427 GL_TEXTURE_3D, i, fmt2glintFmt(pTexture2->format), pTexture2->volumes[i]->myDesc.Width,
3428 pTexture2->volumes[i]->myDesc.Height, pTexture2->volumes[i]->myDesc.Depth,
3429 0, fmt2glFmt(pTexture2->format),fmt2glType(pTexture2->format),
3430 pTexture2->volumes[i]->allocatedMemory);
3431 glTexImage3D(GL_TEXTURE_3D, i,
3432 fmt2glintFmt(pTexture2->format),
3433 pTexture2->volumes[i]->myDesc.Width,
3434 pTexture2->volumes[i]->myDesc.Height,
3435 pTexture2->volumes[i]->myDesc.Depth,
3436 0,
3437 fmt2glFmt(pTexture2->format),
3438 fmt2glType(pTexture2->format),
3439 pTexture2->volumes[i]->allocatedMemory
3440 );
3441 checkGLcall("glTexImage3D");
3442
3443 /* Removed glTexParameterf now TextureStageStates are initialized at startup */
3444 pTexture2->Dirty = FALSE;
3445 }
3446 }
3447
3448 } else {
3449 FIXME("(%p) : Incorrect type for a texture : %d\n", This, textureType);
3450 }
3451 } else {
3452 TRACE("Setting to no texture (ie default texture)\n");
3453 This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_1D;
3454 glBindTexture(GL_TEXTURE_1D, This->dummyTextureName[Stage]);
3455 checkGLcall("glBindTexture");
3456 TRACE("Bound dummy Texture to stage %ld (gl name %d)\n", Stage, This->dummyTextureName[Stage]);
3457 }
3458
3459 /* Even if the texture has been set to null, reapply the stages as a null texture to directx requires
3460 a dummy texture in opengl, and we always need to ensure the current view of the TextureStates apply */
3461 if (reapplyStates) {
3462 setupTextureStates (iface, Stage);
3463 }
3464
3465 return D3D_OK;
3466 }
3467
3468 HRESULT WINAPI IDirect3DDevice8Impl_GetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue) {
3469 ICOM_THIS(IDirect3DDevice8Impl,iface);
3470 TRACE("(%p) : requesting Stage %ld, Type %d getting %ld\n", This, Stage, Type, This->UpdateStateBlock->texture_state[Stage][Type]);
3471 *pValue = This->UpdateStateBlock->texture_state[Stage][Type];
3472 return D3D_OK;
3473 }
3474
3475 HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value) {
3476 ICOM_THIS(IDirect3DDevice8Impl,iface);
3477
3478 /* FIXME: Handle 3d textures? What if TSS value set before set texture? Need to reapply all values? */
3479
3480 TRACE("(%p) : stub, Stage=%ld, Type=%d, Value =%ld\n", This, Stage, Type, Value);
3481
3482 /* Reject invalid texture units */
3483 if (Stage >= This->TextureUnits) {
3484 TRACE("Attempt to access invalid texture rejected\n");
3485 return D3DERR_INVALIDCALL;
3486 }
3487
3488 This->UpdateStateBlock->Changed.texture_state[Stage][Type] = TRUE;
3489 This->UpdateStateBlock->Set.texture_state[Stage][Type] = TRUE;
3490 This->UpdateStateBlock->texture_state[Stage][Type] = Value;
3491
3492 /* Handle recording of state blocks */
3493 if (This->isRecordingState) {
3494 TRACE("Recording... not performing anything\n");
3495 return D3D_OK;
3496 }
3497
3498 /* Make appropriate texture active */
3499 VTRACE(("Activating appropriate texture state %ld\n", Stage));
3500 if (This->isMultiTexture) {
3501 #if defined(GL_VERSION_1_3)
3502 glActiveTexture(GL_TEXTURE0 + Stage);
3503 vcheckGLcall("glActiveTexture");
3504 #else
3505 glActiveTextureARB(GL_TEXTURE0_ARB + Stage);
3506 vcheckGLcall("glActiveTextureARB");
3507 #endif
3508 } else if (Stage > 0) {
3509 FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
3510 }
3511
3512 switch (Type) {
3513
3514 case D3DTSS_MINFILTER :
3515 case D3DTSS_MIPFILTER :
3516 {
3517 DWORD ValueMIN = This->StateBlock->texture_state[Stage][D3DTSS_MINFILTER];
3518 DWORD ValueMIP = This->StateBlock->texture_state[Stage][D3DTSS_MIPFILTER];
3519 GLint realVal = GL_LINEAR;
3520
3521 if (ValueMIN == D3DTEXF_POINT) {
3522 /* GL_NEAREST_* */
3523 if (ValueMIP == D3DTEXF_POINT) {
3524 realVal = GL_NEAREST_MIPMAP_NEAREST;
3525 } else if (ValueMIP == D3DTEXF_LINEAR) {
3526 realVal = GL_NEAREST_MIPMAP_LINEAR;
3527 } else if (ValueMIP == D3DTEXF_NONE) {
3528 realVal = GL_NEAREST;
3529 } else {
3530 FIXME("Unhandled D3DTSS_MIPFILTER value of %ld\n", ValueMIP);
3531 realVal = GL_NEAREST_MIPMAP_LINEAR;
3532 }
3533 } else if (ValueMIN == D3DTEXF_LINEAR) {
3534 /* GL_LINEAR_* */
3535 if (ValueMIP == D3DTEXF_POINT) {
3536 realVal = GL_LINEAR_MIPMAP_NEAREST;
3537 } else if (ValueMIP == D3DTEXF_LINEAR) {
3538 realVal = GL_LINEAR_MIPMAP_LINEAR;
3539 } else if (ValueMIP == D3DTEXF_NONE) {
3540 realVal = GL_LINEAR;
3541 } else {
3542 FIXME("Unhandled D3DTSS_MIPFILTER value of %ld\n", ValueMIP);
3543 realVal = GL_LINEAR_MIPMAP_LINEAR;
3544 }
3545 } else if (ValueMIN == D3DTEXF_NONE) {
3546 /* Doesnt really make sense - Windows just seems to disable
3547 mipmapping when this occurs */
3548 FIXME("Odd - minfilter of none, just disabling mipmaps\n");
3549 realVal = GL_LINEAR;
3550
3551 } else {
3552 FIXME("Unhandled D3DTSS_MINFILTER value of %ld\n", ValueMIN);
3553 realVal = GL_LINEAR_MIPMAP_LINEAR;
3554 }
3555
3556 TRACE("ValueMIN=%ld, ValueMIP=%ld, setting MINFILTER to %x\n", ValueMIN, ValueMIP, realVal);
3557 glTexParameteri(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_MIN_FILTER, realVal);
3558 checkGLcall("glTexParameter GL_TEXTURE_MINFILTER, ...");
3559 }
3560 break;
3561
3562
3563 case D3DTSS_MAGFILTER :
3564 if (Value == D3DTEXF_POINT) {
3565 glTexParameteri(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
3566 checkGLcall("glTexParameter GL_TEXTURE_MAGFILTER, GL_NEAREST");
3567 } else if (Value == D3DTEXF_LINEAR) {
3568 glTexParameteri(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
3569 checkGLcall("glTexParameter GL_TEXTURE_MAGFILTER, GL_LINEAR");
3570 } else {
3571 FIXME("Unhandled D3DTSS_MAGFILTER value of %ld\n", Value);
3572 }
3573 break;
3574
3575 case D3DTSS_COLORARG0 :
3576 case D3DTSS_ALPHAARG0 :
3577 /* FIXME: Mesa seems to struggle setting these at the moment */
3578 /*FIXME("COLORARG0/ALPHAARG0 support still a stub, Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value);*/
3579 /*break;*/
3580
3581 case D3DTSS_COLORARG1 :
3582 case D3DTSS_COLORARG2 :
3583 case D3DTSS_ALPHAARG1 :
3584 case D3DTSS_ALPHAARG2 :
3585 {
3586 BOOL isAlphaArg = (Type == D3DTSS_ALPHAARG1 || Type == D3DTSS_ALPHAARG2 || Type == D3DTSS_ALPHAARG0);
3587 int operand = GL_SRC_COLOR;
3588 int source = GL_TEXTURE;
3589
3590 GetSrcAndOpFromValue(Value, isAlphaArg, &source, &operand);
3591 if (isAlphaArg) {
3592 TRACE("Source %x = %x, Operand %x = %x\n", SOURCEx_ALPHA_EXT(Type), source, OPERANDx_ALPHA_EXT(Type), operand);
3593 glTexEnvi(GL_TEXTURE_ENV, SOURCEx_ALPHA_EXT(Type), source);
3594 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, SOURCEx_ALPHA_EXT, source);");
3595 glTexEnvi(GL_TEXTURE_ENV, OPERANDx_ALPHA_EXT(Type), operand);
3596 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, OPERANDx_ALPHA_EXT, operand);");
3597 } else {
3598 TRACE("Source %x = %x, Operand %x = %x\n", SOURCEx_RGB_EXT(Type), source, OPERANDx_RGB_EXT(Type), operand);
3599 glTexEnvi(GL_TEXTURE_ENV, SOURCEx_RGB_EXT(Type), source);
3600 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, SOURCEx_RGB_EXT, source);");
3601 glTexEnvi(GL_TEXTURE_ENV, OPERANDx_RGB_EXT(Type), operand);
3602 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, OPERANDx_RGB_EXT, operand);");
3603 }
3604 }
3605 break;
3606
3607 case D3DTSS_ALPHAOP :
3608 case D3DTSS_COLOROP :
3609 {
3610
3611 int Scale = 1;
3612 int Parm = (Type == D3DTSS_ALPHAOP) ? GL_COMBINE_ALPHA_EXT : GL_COMBINE_RGB_EXT;
3613
3614 if (Type == D3DTSS_COLOROP && Value == D3DTOP_DISABLE) {
3615 /* TODO: Disable by making this and all later levels disabled */
3616 glDisable(GL_TEXTURE_1D);
3617 checkGLcall("Disable GL_TEXTURE_1D");
3618 glDisable(GL_TEXTURE_2D);
3619 checkGLcall("Disable GL_TEXTURE_2D");
3620 glDisable(GL_TEXTURE_3D);
3621 checkGLcall("Disable GL_TEXTURE_3D");
3622 } else {
3623
3624 /* Enable only the appropriate texture dimension */
3625 if (Type == D3DTSS_COLOROP) {
3626 if (This->StateBlock->textureDimensions[Stage] == GL_TEXTURE_1D) {
3627 glEnable(GL_TEXTURE_1D);
3628 checkGLcall("Enable GL_TEXTURE_1D");
3629 } else {
3630 glDisable(GL_TEXTURE_1D);
3631 checkGLcall("Disable GL_TEXTURE_1D");
3632 }
3633 if (This->StateBlock->textureDimensions[Stage] == GL_TEXTURE_2D) {
3634 glEnable(GL_TEXTURE_2D);
3635 checkGLcall("Enable GL_TEXTURE_2D");
3636 } else {
3637 glDisable(GL_TEXTURE_2D);
3638 checkGLcall("Disable GL_TEXTURE_2D");
3639 }
3640 if (This->StateBlock->textureDimensions[Stage] == GL_TEXTURE_3D) {
3641 glEnable(GL_TEXTURE_3D);
3642 checkGLcall("Enable GL_TEXTURE_3D");
3643 } else {
3644 glDisable(GL_TEXTURE_3D);
3645 checkGLcall("Disable GL_TEXTURE_3D");
3646 }
3647 }
3648
3649 /* Re-Enable GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT */
3650 if (Value != D3DTOP_DISABLE) {
3651 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
3652 }
3653
3654 /* Now set up the operand correctly */
3655 switch (Value) {
3656 case D3DTOP_DISABLE :
3657 /* Contrary to the docs, alpha can be disabled when colorop is enabled
3658 and it works, so ignore this op */
3659 TRACE("Disable ALPHAOP but COLOROP enabled!\n");
3660 break;
3661
3662 case D3DTOP_SELECTARG1 :
3663 {
3664 FIXME("see if D3DTOP_SELECTARG1 behavior is correct now!\n");
3665 glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE);
3666 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE)");
3667 #if 0 /* don't seem to do anything */
3668 BOOL isAlphaOp = (Type == D3DTSS_ALPHAOP);
3669 DWORD dwValue = 0;
3670 GLenum source;
3671 GLenum operand;
3672 dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG1 : D3DTSS_COLORARG1];
3673 GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
3674 if (isAlphaOp) {
3675 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_ALPHA_EXT, source, GL_OPERAND0_ALPHA_EXT, operand);
3676 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, source);
3677 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, 'source')");
3678 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, operand);
3679 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, 'operand')");
3680 } else {
3681 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_RGB_EXT, source, GL_OPERAND0_RGB_EXT, operand);
3682 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, source);
3683 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, 'source')");
3684 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, operand);
3685 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, 'operand')");
3686 }
3687 dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG2 : D3DTSS_COLORARG2];
3688 GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
3689 if (isAlphaOp) {
3690 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_ALPHA_EXT, source, GL_OPERAND1_ALPHA_EXT, operand);
3691 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, source);
3692 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, 'source')");
3693 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, operand);
3694 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, 'operand')");
3695 } else {
3696 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_RGB_EXT, source, GL_OPERAND1_RGB_EXT, operand);
3697 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, source);
3698 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, 'source')");
3699 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, operand);
3700 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, 'operand')");
3701 }
3702 #endif
3703 }
3704 break;
3705
3706 case D3DTOP_SELECTARG2 :
3707 {
3708 BOOL isAlphaOp = (Type == D3DTSS_ALPHAOP);
3709 DWORD dwValue = 0;
3710 GLenum source;
3711 GLenum operand;
3712 FIXME("see if D3DTOP_SELECTARG2 behavior is correct now!\n");
3713 glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE);
3714 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE)");
3715 /* GL_REPLACE, swap args 0 and 1? */
3716 dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG2 : D3DTSS_COLORARG2];
3717 GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
3718 if (isAlphaOp) {
3719 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_ALPHA_EXT, source, GL_OPERAND0_ALPHA_EXT, operand);
3720 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, source);
3721 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, 'source')");
3722 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, operand);
3723 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, 'operand')");
3724 } else {
3725 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_RGB_EXT, source, GL_OPERAND0_RGB_EXT, operand);
3726 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, source);
3727 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, 'source')");
3728 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, operand);
3729 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, 'operand')");
3730 }
3731 dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG1 : D3DTSS_COLORARG1];
3732 GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
3733 if (isAlphaOp) {
3734 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_ALPHA_EXT, source, GL_OPERAND1_ALPHA_EXT, operand);
3735 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, source);
3736 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, 'source')");
3737 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, operand);
3738 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, 'operand')");
3739 } else {
3740 TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_RGB_EXT, source, GL_OPERAND1_RGB_EXT, operand);
3741 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, source);
3742 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, 'source')");
3743 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, operand);
3744 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, 'operand')");
3745 }
3746 }
3747 break;
3748
3749 case D3DTOP_MODULATE4X : Scale = Scale * 2; /* Drop through */
3750 case D3DTOP_MODULATE2X : Scale = Scale * 2; /* Drop through */
3751 case D3DTOP_MODULATE :
3752
3753 /* Correct scale */
3754 if (Type == D3DTSS_ALPHAOP) {
3755 glTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, Scale);
3756 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, Scale)");
3757 } else {
3758 glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, Scale);
3759 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, Scale)");
3760 }
3761 glTexEnvi(GL_TEXTURE_ENV, Parm, GL_MODULATE);
3762 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_MODULATE);");
3763 break;
3764
3765 case D3DTOP_ADD :
3766 glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD);
3767 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD)");
3768 break;
3769
3770 case D3DTOP_ADDSIGNED2X : Scale = Scale * 2; /* Drop through */
3771 case D3DTOP_ADDSIGNED :
3772 glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD_SIGNED_EXT);
3773 vcheckGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD_SIGNED_EXT)");
3774 break;
3775
3776 case D3DTOP_DOTPRODUCT3 :
3777 #if defined(GL_VERSION_1_3)
3778 if (This->isDot3) {
3779 glTexEnvi(GL_TEXTURE_ENV, Parm, GL_DOT3_RGBA);
3780 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA);");
3781 break;
3782 }
3783 #endif
3784 FIXME("DotProduct3 extension requested but not supported via this version of opengl\n");
3785 break;
3786
3787 case D3DTOP_SUBTRACT :
3788 #if defined(GL_VERSION_1_3)
3789 glTexEnvi(GL_TEXTURE_ENV, Parm, GL_SUBTRACT);
3790 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_SUBTRACT)");
3791 break;
3792 #else
3793 /**
3794 * @TODO: to check:
3795 * if ARB_texture_env_combine is supported
3796 * we can use GL_SUBTRACT_ARB here
3797 */
3798 #endif
3799 case D3DTOP_ADDSMOOTH :
3800 case D3DTOP_BLENDDIFFUSEALPHA :
3801 case D3DTOP_BLENDTEXTUREALPHA :
3802 case D3DTOP_BLENDFACTORALPHA :
3803 case D3DTOP_BLENDTEXTUREALPHAPM :
3804 case D3DTOP_BLENDCURRENTALPHA :
3805 case D3DTOP_PREMODULATE :
3806 case D3DTOP_MODULATEALPHA_ADDCOLOR :
3807 case D3DTOP_MODULATECOLOR_ADDALPHA :
3808 case D3DTOP_MODULATEINVALPHA_ADDCOLOR :
3809 case D3DTOP_MODULATEINVCOLOR_ADDALPHA :
3810 case D3DTOP_BUMPENVMAP :
3811 case D3DTOP_BUMPENVMAPLUMINANCE :
3812 case D3DTOP_MULTIPLYADD :
3813 case D3DTOP_LERP :
3814 default:
3815 FIXME("Unhandled texture operation %ld\n", Value);
3816 }
3817 }
3818 break;
3819 }
3820
3821 case D3DTSS_ADDRESSU :
3822 case D3DTSS_ADDRESSV :
3823 case D3DTSS_ADDRESSW :
3824 {
3825 GLint wrapParm = GL_REPEAT;
3826 switch (Value) {
3827 case D3DTADDRESS_WRAP: wrapParm = GL_REPEAT; break;
3828 case D3DTADDRESS_CLAMP: wrapParm = GL_CLAMP_TO_EDGE; break;
3829 case D3DTADDRESS_BORDER: wrapParm = GL_REPEAT; break; /* FIXME: Not right, but better */
3830 #if defined(GL_VERSION_1_4)
3831 case D3DTADDRESS_MIRROR: wrapParm = GL_MIRRORED_REPEAT; break;
3832 #elif defined(GL_ARB_texture_mirrored_repeat)
3833 case D3DTADDRESS_MIRROR: wrapParm = GL_MIRRORED_REPEAT_ARB; break;
3834 #else
3835 case D3DTADDRESS_MIRROR: /* Unsupported in OpenGL pre-1.4 */
3836 #endif
3837 case D3DTADDRESS_MIRRORONCE: /* Unsupported in OpenGL */
3838 default:
3839 FIXME("Unrecognized or unsupported D3DTADDRESS_* value %ld, state %d\n", Value, Type);
3840 wrapParm = GL_REPEAT;
3841 }
3842
3843 switch (Type) {
3844 case D3DTSS_ADDRESSU:
3845 TRACE("Setting WRAP_S to %d for %x\n", wrapParm, This->StateBlock->textureDimensions[Stage]);
3846 glTexParameteri(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_WRAP_S, wrapParm);
3847 checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_S, wrapParm)");
3848 break;
3849 case D3DTSS_ADDRESSV:
3850 TRACE("Setting WRAP_T to %d for %x\n", wrapParm, This->StateBlock->textureDimensions[Stage]);
3851 glTexParameteri(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_WRAP_T, wrapParm);
3852 checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_T, wrapParm)");
3853 break;
3854 case D3DTSS_ADDRESSW:
3855 TRACE("Setting WRAP_R to %d for %x\n", wrapParm, This->StateBlock->textureDimensions[Stage]);
3856 glTexParameteri(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_WRAP_R, wrapParm);
3857 checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_R, wrapParm)");
3858 break;
3859 default: /* nop */
3860 break; /** stupic compilator */
3861 }
3862 }
3863 break;
3864
3865 case D3DTSS_BORDERCOLOR :
3866 {
3867 float col[4];
3868 col[0] = ((Value >> 16) & 0xFF) / 255.0;
3869 col[1] = ((Value >> 8) & 0xFF) / 255.0;
3870 col[2] = ((Value >> 0) & 0xFF) / 255.0;
3871 col[3] = ((Value >> 24) & 0xFF) / 255.0;
3872
3873 TRACE("Setting border color for %x to %lx\n", This->StateBlock->textureDimensions[Stage], Value);
3874 glTexParameterfv(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_BORDER_COLOR, &col[0]);
3875 checkGLcall("glTexParameteri(..., GL_TEXTURE_BORDER_COLOR, ...)");
3876 }
3877 break;
3878
3879 case D3DTSS_TEXCOORDINDEX :
3880 {
3881 /* CameraSpacePosition means use the vertex position, transformed to camera space,
3882 as the input texture coordinates for this stage's texture transformation. This
3883 equates roughly to EYE_LINEAR */
3884
3885 /**
3886 * To Jason: i don't understand what to do with the (Value & 0x00FF) index
3887 * it seems a texture coordinate index (0 <= x <= 7) seeing msdn and logs
3888 * have you any idea ?
3889 */
3890
3891 /**
3892 * Be carefull the value of the mask 0xF0000 come from d3d8types.h infos
3893 */
3894 switch (Value & 0xFFFFFF00) {
3895 case D3DTSS_TCI_PASSTHRU:
3896 /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
3897 break;
3898
3899 case D3DTSS_TCI_CAMERASPACEPOSITION:
3900 {
3901 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
3902 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
3903 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
3904 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
3905 TRACE("D3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
3906
3907 glMatrixMode(GL_MODELVIEW);
3908 glPushMatrix();
3909 glLoadIdentity();
3910 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
3911 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
3912 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
3913 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
3914 glPopMatrix();
3915
3916 TRACE("D3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
3917 glEnable(GL_TEXTURE_GEN_S);
3918 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
3919 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
3920 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
3921 glEnable(GL_TEXTURE_GEN_T);
3922 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
3923 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
3924 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
3925 glEnable(GL_TEXTURE_GEN_R);
3926 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
3927 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
3928 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
3929 }
3930 break;
3931
3932 default:
3933 /* Todo: */
3934 /* ? disable GL_TEXTURE_GEN_n ? */
3935 FIXME("Unhandled D3DTSS_TEXCOORDINDEX %lx\n", Value);
3936 break;
3937 }
3938 }
3939 break;
3940
3941 /* Unhandled */
3942 case D3DTSS_BUMPENVMAT00 :
3943 case D3DTSS_BUMPENVMAT01 :
3944 TRACE("BUMPENVMAT0%u Still a stub, Stage=%ld, Type=%d, Value =%ld\n", Type - D3DTSS_BUMPENVMAT00, Stage, Type, Value);
3945 break;
3946 case D3DTSS_BUMPENVMAT10 :
3947 case D3DTSS_BUMPENVMAT11 :
3948 TRACE("BUMPENVMAT1%u Still a stub, Stage=%ld, Type=%d, Value =%ld\n", Type - D3DTSS_BUMPENVMAT10, Stage, Type, Value);
3949 break;
3950
3951 case D3DTSS_MIPMAPLODBIAS :
3952 case D3DTSS_MAXMIPLEVEL :
3953 case D3DTSS_MAXANISOTROPY :
3954 case D3DTSS_BUMPENVLSCALE :
3955 case D3DTSS_BUMPENVLOFFSET :
3956 case D3DTSS_TEXTURETRANSFORMFLAGS :
3957 case D3DTSS_RESULTARG :
3958 default:
3959 /* Put back later: FIXME("(%p) : stub, Stage=%ld, Type=%d, Value =%ld\n", This, Stage, Type, Value); */
3960 TRACE("Still a stub, Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value);
3961 }
3962 return D3D_OK;
3963 }
3964 HRESULT WINAPI IDirect3DDevice8Impl_ValidateDevice(LPDIRECT3DDEVICE8 iface, DWORD* pNumPasses) {
3965 ICOM_THIS(IDirect3DDevice8Impl,iface);
3966 TRACE("(%p) : stub\n", This); /* FIXME: Needs doing, but called often and is harmless */
3967 return D3D_OK;
3968 }
3969 HRESULT WINAPI IDirect3DDevice8Impl_GetInfo(LPDIRECT3DDEVICE8 iface, DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize) {
3970 ICOM_THIS(IDirect3DDevice8Impl,iface);
3971 FIXME("(%p) : stub\n", This); return D3D_OK;
3972 }
3973 HRESULT WINAPI IDirect3DDevice8Impl_SetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber,CONST PALETTEENTRY* pEntries) {
3974 ICOM_THIS(IDirect3DDevice8Impl,iface);
3975 FIXME("(%p) : stub\n", This); return D3D_OK;
3976 }
3977 HRESULT WINAPI IDirect3DDevice8Impl_GetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber,PALETTEENTRY* pEntries) {
3978 ICOM_THIS(IDirect3DDevice8Impl,iface);
3979 FIXME("(%p) : stub\n", This); return D3D_OK;
3980 }
3981 HRESULT WINAPI IDirect3DDevice8Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber) {
3982 ICOM_THIS(IDirect3DDevice8Impl,iface);
3983 FIXME("(%p) : stub\n", This); return D3D_OK;
3984 }
3985 HRESULT WINAPI IDirect3DDevice8Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT *PaletteNumber) {
3986 ICOM_THIS(IDirect3DDevice8Impl,iface);
3987 FIXME("(%p) : stub\n", This); return D3D_OK;
3988 }
3989 HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount) {
3990
3991 IDirect3DVertexBuffer8 *pVB;
3992
3993 ICOM_THIS(IDirect3DDevice8Impl,iface);
3994 pVB = This->StateBlock->stream_source[0];
3995
3996 TRACE("(%p) : Type=%d, Start=%d, Count=%d\n", This, PrimitiveType, StartVertex, PrimitiveCount);
3997
3998 DrawPrimitiveI(iface, PrimitiveType, PrimitiveCount, FALSE,
3999 This->StateBlock->VertexShader, ((IDirect3DVertexBuffer8Impl *)pVB)->allocatedMemory, StartVertex, -1, 0, NULL, 0);
4000
4001 return D3D_OK;
4002 }
4003 HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,
4004 UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount) {
4005 UINT idxStride = 2;
4006 IDirect3DIndexBuffer8 *pIB;
4007 IDirect3DVertexBuffer8 *pVB;
4008 D3DINDEXBUFFER_DESC IdxBufDsc;
4009
4010 ICOM_THIS(IDirect3DDevice8Impl,iface);
4011 pIB = This->StateBlock->pIndexData;
4012 pVB = This->StateBlock->stream_source[0];
4013
4014 TRACE("(%p) : Type=%d, min=%d, CountV=%d, startIdx=%d, countP=%d \n", This, PrimitiveType,
4015 minIndex, NumVertices, startIndex, primCount);
4016
4017 IDirect3DIndexBuffer8Impl_GetDesc(pIB, &IdxBufDsc);
4018 if (IdxBufDsc.Format == D3DFMT_INDEX16) {
4019 idxStride = 2;
4020 } else {
4021 idxStride = 4;
4022 }
4023
4024 DrawPrimitiveI(iface, PrimitiveType, primCount, TRUE, This->StateBlock->VertexShader, ((IDirect3DVertexBuffer8Impl *)pVB)->allocatedMemory,
4025 This->StateBlock->baseVertexIndex, startIndex, idxStride, ((IDirect3DIndexBuffer8Impl *) pIB)->allocatedMemory,
4026 minIndex);
4027
4028 return D3D_OK;
4029 }
4030 HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) {
4031 ICOM_THIS(IDirect3DDevice8Impl,iface);
4032
4033 TRACE("(%p) : Type=%d, pCount=%d, pVtxData=%p, Stride=%d\n", This, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
4034
4035 if (This->StateBlock->stream_source[0] != NULL) IDirect3DVertexBuffer8Impl_Release(This->StateBlock->stream_source[0]);
4036
4037 This->StateBlock->stream_source[0] = NULL;
4038 This->StateBlock->stream_stride[0] = VertexStreamZeroStride;
4039 DrawPrimitiveI(iface, PrimitiveType, PrimitiveCount, FALSE, This->StateBlock->VertexShader, pVertexStreamZeroData,
4040 0, 0, 0, NULL, 0);
4041 This->StateBlock->stream_stride[0] = 0;
4042
4043 /*stream zero settings set to null at end */
4044 return D3D_OK;
4045 }
4046 HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,
4047 UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,
4048 D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,
4049 UINT VertexStreamZeroStride) {
4050 int idxStride;
4051 ICOM_THIS(IDirect3DDevice8Impl,iface);
4052 TRACE("(%p) : Type=%d, MinVtxIdx=%d, NumVIdx=%d, PCount=%d, pidxdata=%p, IdxFmt=%d, pVtxdata=%p, stride=%d\n", This, PrimitiveType,
4053 MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
4054
4055 if (This->StateBlock->stream_source[0] != NULL) IDirect3DVertexBuffer8Impl_Release(This->StateBlock->stream_source[0]);
4056 if (IndexDataFormat == D3DFMT_INDEX16) {
4057 idxStride = 2;
4058 } else {
4059 idxStride = 4;
4060 }
4061
4062 This->StateBlock->stream_source[0] = NULL;
4063 This->StateBlock->stream_stride[0] = VertexStreamZeroStride;
4064 DrawPrimitiveI(iface, PrimitiveType, PrimitiveCount, TRUE, This->StateBlock->VertexShader, pVertexStreamZeroData,
4065 This->StateBlock->baseVertexIndex, 0, idxStride, pIndexData, MinVertexIndex);
4066
4067 /*stream zero settings set to null at end */
4068 This->StateBlock->stream_stride[0] = 0;
4069 IDirect3DDevice8Impl_SetIndices(iface, NULL, 0);
4070
4071 return D3D_OK;
4072 }
4073 HRESULT WINAPI IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface, UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags) {
4074 ICOM_THIS(IDirect3DDevice8Impl,iface);
4075 FIXME("(%p) : stub\n", This); return D3D_OK;
4076 }
4077 HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pDeclaration, CONST DWORD* pFunction, DWORD* pHandle, DWORD Usage) {
4078 ICOM_THIS(IDirect3DDevice8Impl,iface);
4079 IDirect3DVertexShaderImpl* object;
4080 IDirect3DVertexShaderDeclarationImpl* attached_decl;
4081 HRESULT res;
4082 UINT i;
4083
4084 TRACE("(%p) : VertexShader not fully supported yet : Decl=%p, Func=%p\n", This, pDeclaration, pFunction);
4085 if (NULL == pDeclaration || NULL == pHandle) { /* pFunction can be NULL see MSDN */
4086 return D3DERR_INVALIDCALL;
4087 }
4088 for (i = 1; NULL != VertexShaders[i] && i < sizeof(VertexShaders) / sizeof(IDirect3DVertexShaderImpl*); ++i) ;
4089 if (i >= sizeof(VertexShaders) / sizeof(IDirect3DVertexShaderImpl*)) {
4090 return D3DERR_OUTOFVIDEOMEMORY;
4091 }
4092
4093 /** Create the Vertex Shader */
4094 res = IDirect3DDeviceImpl_CreateVertexShader(This, pFunction, Usage, &object);
4095 /** TODO: check FAILED(res) */
4096
4097 /** Create and Bind the Vertex Shader Declaration */
4098 res = IDirect3DDeviceImpl_CreateVertexShaderDeclaration8(This, pDeclaration, &attached_decl);
4099 /** TODO: check FAILED(res) */
4100
4101 VertexShaders[i] = object;
4102 VertexShaderDeclarations[i] = attached_decl;
4103 *pHandle = VS_HIGHESTFIXEDFXF + i;
4104
4105 return D3D_OK;
4106 }
4107 HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) {
4108 ICOM_THIS(IDirect3DDevice8Impl,iface);
4109
4110 This->UpdateStateBlock->VertexShader = Handle;
4111 This->UpdateStateBlock->Changed.vertexShader = TRUE;
4112 This->UpdateStateBlock->Set.vertexShader = TRUE;
4113
4114 if (Handle > VS_HIGHESTFIXEDFXF) { /* only valid with non FVF shaders */
4115 FIXME("(%p) : Created shader, Handle=%lx\n", This, Handle);
4116 This->UpdateStateBlock->vertexShaderDecl = VERTEX_SHADER_DECL(Handle);
4117 This->UpdateStateBlock->Changed.vertexShaderDecl = TRUE;
4118 This->UpdateStateBlock->Set.vertexShaderDecl = TRUE;
4119 } else { /* use a fvf, so desactivate the vshader decl */
4120 TRACE("(%p) : FVF Shader, Handle=%lx\n", This, Handle);
4121 This->UpdateStateBlock->vertexShaderDecl = NULL;
4122 This->UpdateStateBlock->Changed.vertexShaderDecl = TRUE;
4123 This->UpdateStateBlock->Set.vertexShaderDecl = TRUE;
4124 }
4125 /* Handle recording of state blocks */
4126 if (This->isRecordingState) {
4127 TRACE("Recording... not performing anything\n");
4128 return D3D_OK;
4129 }
4130 /**
4131 * TODO: merge HAL shaders context switching from prototype
4132 */
4133 return D3D_OK;
4134 }
4135 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle) {
4136 ICOM_THIS(IDirect3DDevice8Impl,iface);
4137 TRACE("(%p) : GetVertexShader returning %ld\n", This, This->StateBlock->VertexShader);
4138 *pHandle = This->StateBlock->VertexShader;
4139 return D3D_OK;
4140 }
4141
4142 HRESULT WINAPI IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) {
4143 ICOM_THIS(IDirect3DDevice8Impl,iface);
4144 IDirect3DVertexShaderImpl* object;
4145 IDirect3DVertexShaderDeclarationImpl* attached_decl;
4146
4147 if (Handle <= VS_HIGHESTFIXEDFXF) { /* only delete user defined shaders */
4148 return D3DERR_INVALIDCALL;
4149 }
4150
4151 /**
4152 * Delete Vertex Shader
4153 */
4154 object = VertexShaders[Handle - VS_HIGHESTFIXEDFXF];
4155 if (NULL == object) {
4156 return D3DERR_INVALIDCALL;
4157 }
4158 FIXME("(%p) : freing VertexShader %p\n", This, object);
4159 /* TODO: check validity of object */
4160 if (NULL != object->function) HeapFree(GetProcessHeap(), 0, (void *)object->function);
4161 HeapFree(GetProcessHeap(), 0, (void *)object->data);
4162 HeapFree(GetProcessHeap(), 0, (void *)object);
4163 VertexShaders[Handle - VS_HIGHESTFIXEDFXF] = NULL;
4164
4165 /**
4166 * Delete Vertex Shader Declaration
4167 */
4168 attached_decl = VertexShaderDeclarations[Handle - VS_HIGHESTFIXEDFXF];
4169 if (NULL == attached_decl) {
4170 return D3DERR_INVALIDCALL;
4171 }
4172 FIXME("(%p) : freing VertexShaderDeclaration %p\n", This, attached_decl);
4173 /* TODO: check validity of object */
4174 HeapFree(GetProcessHeap(), 0, (void *)attached_decl->pDeclaration8);
4175 HeapFree(GetProcessHeap(), 0, (void *)attached_decl);
4176 VertexShaderDeclarations[Handle - VS_HIGHESTFIXEDFXF] = NULL;
4177
4178 return D3D_OK;
4179 }
4180
4181 HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
4182 ICOM_THIS(IDirect3DDevice8Impl,iface);
4183
4184 if (Register + ConstantCount > D3D8_VSHADER_MAX_CONSTANTS) {
4185 ERR("(%p) : SetVertexShaderConstant C[%lu] invalid\n", This, Register);
4186 return D3DERR_INVALIDCALL;
4187 }
4188 if (NULL == pConstantData) {
4189 return D3DERR_INVALIDCALL;
4190 }
4191 if (ConstantCount > 1) {
4192 FLOAT* f = (FLOAT*)pConstantData;
4193 UINT i;
4194 TRACE("(%p) : SetVertexShaderConstant C[%lu..%lu]=\n", This, Register, Register + ConstantCount - 1);
4195 for (i = 0; i < ConstantCount; ++i) {
4196 TRACE("{%f, %f, %f, %f}\n", f[0], f[1], f[2], f[3]);
4197 f += 4;
4198 }
4199 } else {
4200 FLOAT* f = (FLOAT*)pConstantData;
4201 TRACE("(%p) : SetVertexShaderConstant, C[%lu]={%f, %f, %f, %f}\n", This, Register, f[0], f[1], f[2], f[3]);
4202 }
4203 This->UpdateStateBlock->Changed.vertexShaderConstant = TRUE;
4204 memcpy(&This->UpdateStateBlock->vertexShaderConstant[Register], pConstantData, ConstantCount * 4 * sizeof(FLOAT));
4205 return D3D_OK;
4206 }
4207 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, void* pConstantData, DWORD ConstantCount) {
4208 ICOM_THIS(IDirect3DDevice8Impl,iface);
4209
4210 TRACE("(%p) : C[%lu] count=%ld\n", This, Register, ConstantCount);
4211 if (Register + ConstantCount > D3D8_VSHADER_MAX_CONSTANTS) {
4212 return D3DERR_INVALIDCALL;
4213 }
4214 if (NULL == pConstantData) {
4215 return D3DERR_INVALIDCALL;
4216 }
4217 memcpy(pConstantData, &This->UpdateStateBlock->vertexShaderConstant[Register], ConstantCount * 4 * sizeof(FLOAT));
4218 return D3D_OK;
4219 }
4220 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderDeclaration(LPDIRECT3DDEVICE8 iface, DWORD Handle, void* pData, DWORD* pSizeOfData) {
4221 /*ICOM_THIS(IDirect3DDevice8Impl,iface);*/
4222 IDirect3DVertexShaderDeclarationImpl* attached_decl;
4223
4224 attached_decl = VERTEX_SHADER_DECL(Handle);
4225 if (NULL == attached_decl) {
4226 return D3DERR_INVALIDCALL;
4227 }
4228 return IDirect3DVertexShaderDeclarationImpl_GetDeclaration8(attached_decl, pData, (UINT*) pSizeOfData);
4229 }
4230 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle, void* pData, DWORD* pSizeOfData) {
4231 /*ICOM_THIS(IDirect3DDevice8Impl,iface);*/
4232 IDirect3DVertexShaderImpl* object;
4233
4234 object = VERTEX_SHADER(Handle);
4235 if (NULL == object) {
4236 return D3DERR_INVALIDCALL;
4237 }
4238 return IDirect3DVertexShaderImpl_GetFunction(object, pData, (UINT*) pSizeOfData);
4239 }
4240
4241 HRESULT WINAPI IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8* pIndexData, UINT BaseVertexIndex) {
4242 ICOM_THIS(IDirect3DDevice8Impl,iface);
4243 IDirect3DIndexBuffer8 *oldIdxs;
4244
4245 TRACE("(%p) : Setting to %p, base %d\n", This, pIndexData, BaseVertexIndex);
4246 oldIdxs = This->StateBlock->pIndexData;
4247
4248 This->UpdateStateBlock->Changed.Indices = TRUE;
4249 This->UpdateStateBlock->Set.Indices = TRUE;
4250 This->UpdateStateBlock->pIndexData = pIndexData;
4251 This->UpdateStateBlock->baseVertexIndex = BaseVertexIndex;
4252
4253 /* Handle recording of state blocks */
4254 if (This->isRecordingState) {
4255 TRACE("Recording... not performing anything\n");
4256 return D3D_OK;
4257 }
4258
4259 if (oldIdxs) IDirect3DIndexBuffer8Impl_Release(oldIdxs);
4260 if (pIndexData) IDirect3DIndexBuffer8Impl_AddRef(This->StateBlock->pIndexData);
4261 return D3D_OK;
4262 }
4263 HRESULT WINAPI IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex) {
4264 ICOM_THIS(IDirect3DDevice8Impl,iface);
4265 FIXME("(%p) : stub\n", This);
4266
4267 *ppIndexData = This->StateBlock->pIndexData;
4268 /* up ref count on ppindexdata */
4269 if (*ppIndexData) IDirect3DIndexBuffer8Impl_AddRef(*ppIndexData);
4270 *pBaseVertexIndex = This->StateBlock->baseVertexIndex;
4271
4272 return D3D_OK;
4273 }
4274 HRESULT WINAPI IDirect3DDevice8Impl_CreatePixelShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pFunction, DWORD* pHandle) {
4275 ICOM_THIS(IDirect3DDevice8Impl,iface);
4276 IDirect3DPixelShaderImpl* object;
4277 UINT i;
4278
4279 FIXME("(%p) : PixelShader not fully supported yet\n", This);
4280 if (NULL == pFunction || NULL == pHandle) {
4281 return D3DERR_INVALIDCALL;
4282 }
4283 for (i = 1; NULL != PixelShaders[i] && i < sizeof(PixelShaders) / sizeof(IDirect3DPixelShaderImpl*); ++i) ;
4284 if (i >= sizeof(PixelShaders) / sizeof(IDirect3DPixelShaderImpl*)) {
4285 return D3DERR_OUTOFVIDEOMEMORY;
4286 }
4287 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DPixelShaderImpl));
4288 if (NULL == object) {
4289 return D3DERR_OUTOFVIDEOMEMORY;
4290 }
4291
4292 object->data = NULL; /* TODO */
4293
4294 PixelShaders[i] = object;
4295 *pHandle = VS_HIGHESTFIXEDFXF + i;
4296
4297 object->function = pFunction;
4298 for (i = 0; 0xFFFFFFFF != pFunction[i]; ++i) ;
4299 object->functionLength = i + 1;
4300
4301 return D3D_OK;
4302 }
4303 HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) {
4304 ICOM_THIS(IDirect3DDevice8Impl,iface);
4305
4306 This->UpdateStateBlock->PixelShader = Handle;
4307 This->UpdateStateBlock->Changed.pixelShader = TRUE;
4308 This->UpdateStateBlock->Set.pixelShader = TRUE;
4309
4310 /* Handle recording of state blocks */
4311 if (This->isRecordingState) {
4312 TRACE("Recording... not performing anything\n");
4313 return D3D_OK;
4314 }
4315
4316 /* FIXME: Quieten when not being used */
4317 if (Handle != 0) {
4318 FIXME("(%p) : stub %ld\n", This, Handle);
4319 } else {
4320 TRACE("(%p) : stub %ld\n", This, Handle);
4321 }
4322
4323 return D3D_OK;
4324 }
4325 HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle) {
4326 ICOM_THIS(IDirect3DDevice8Impl,iface);
4327 TRACE("(%p) : GetPixelShader returning %ld\n", This, This->StateBlock->PixelShader);
4328 *pHandle = This->StateBlock->PixelShader;
4329 return D3D_OK;
4330 }
4331
4332 HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) {
4333 ICOM_THIS(IDirect3DDevice8Impl,iface);
4334 IDirect3DPixelShaderImpl* object;
4335
4336 if (Handle <= VS_HIGHESTFIXEDFXF) { /* only delete user defined shaders */
4337 return D3DERR_INVALIDCALL;
4338 }
4339 object = PixelShaders[Handle - VS_HIGHESTFIXEDFXF];
4340 TRACE("(%p) : freeing PixelShader %p\n", This, object);
4341 /* TODO: check validity of object before free */
4342 HeapFree(GetProcessHeap(), 0, (void *)object);
4343 PixelShaders[Handle - VS_HIGHESTFIXEDFXF] = 0;
4344 return D3D_OK;
4345 }
4346
4347 HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData, DWORD ConstantCount) {
4348 ICOM_THIS(IDirect3DDevice8Impl,iface);
4349 FIXME("(%p) : stub\n", This);
4350 return D3D_OK;
4351 }
4352 HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData, DWORD ConstantCount) {
4353 ICOM_THIS(IDirect3DDevice8Impl,iface);
4354 FIXME("(%p) : stub\n", This);
4355 return D3D_OK;
4356 }
4357 HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle, void* pData, DWORD* pSizeOfData) {
4358 ICOM_THIS(IDirect3DDevice8Impl,iface);
4359 IDirect3DPixelShaderImpl* object;
4360
4361 object = PIXEL_SHADER(Handle);
4362 if (NULL == object) {
4363 return D3DERR_INVALIDCALL;
4364 }
4365 if (NULL == pData) {
4366 *pSizeOfData = object->functionLength;
4367 return D3D_OK;
4368 }
4369 if (*pSizeOfData < object->functionLength) {
4370 *pSizeOfData = object->functionLength;
4371 return D3DERR_MOREDATA;
4372 }
4373 TRACE("(%p) : GetPixelShaderFunction copying to %p\n", This, pData);
4374 memcpy(pData, object->function, object->functionLength);
4375 return D3D_OK;
4376 }
4377 HRESULT WINAPI IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) {
4378 ICOM_THIS(IDirect3DDevice8Impl,iface);
4379 FIXME("(%p) : stub\n", This); return D3D_OK;
4380 }
4381 HRESULT WINAPI IDirect3DDevice8Impl_DrawTriPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) {
4382 ICOM_THIS(IDirect3DDevice8Impl,iface);
4383 FIXME("(%p) : stub\n", This); return D3D_OK;
4384 }
4385 HRESULT WINAPI IDirect3DDevice8Impl_DeletePatch(LPDIRECT3DDEVICE8 iface, UINT Handle) {
4386 ICOM_THIS(IDirect3DDevice8Impl,iface);
4387 FIXME("(%p) : stub\n", This); return D3D_OK;
4388 }
4389
4390 HRESULT WINAPI IDirect3DDevice8Impl_SetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride) {
4391 IDirect3DVertexBuffer8 *oldSrc;
4392 ICOM_THIS(IDirect3DDevice8Impl,iface);
4393
4394 oldSrc = This->StateBlock->stream_source[StreamNumber];
4395 TRACE("(%p) : StreamNo: %d, OldStream (%p), NewStream (%p), NewStride %d\n", This, StreamNumber, oldSrc, pStreamData, Stride);
4396
4397 This->UpdateStateBlock->Changed.stream_source[StreamNumber] = TRUE;
4398 This->UpdateStateBlock->Set.stream_source[StreamNumber] = TRUE;
4399 This->UpdateStateBlock->stream_stride[StreamNumber] = Stride;
4400 This->UpdateStateBlock->stream_source[StreamNumber] = pStreamData;
4401
4402 /* Handle recording of state blocks */
4403 if (This->isRecordingState) {
4404 TRACE("Recording... not performing anything\n");
4405 return D3D_OK;
4406 }
4407
4408 if (oldSrc != NULL) IDirect3DVertexBuffer8Impl_Release(oldSrc);
4409 if (pStreamData != NULL) IDirect3DVertexBuffer8Impl_AddRef(pStreamData);
4410 return D3D_OK;
4411 }
4412 HRESULT WINAPI IDirect3DDevice8Impl_GetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8** pStream,UINT* pStride) {
4413 ICOM_THIS(IDirect3DDevice8Impl,iface);
4414 TRACE("(%p) : StreamNo: %d, Stream (%p), Stride %d\n", This, StreamNumber, This->StateBlock->stream_source[StreamNumber], This->StateBlock->stream_stride[StreamNumber]);
4415 *pStream = This->StateBlock->stream_source[StreamNumber];
4416 *pStride = This->StateBlock->stream_stride[StreamNumber];
4417 IDirect3DVertexBuffer8Impl_AddRef((LPDIRECT3DVERTEXBUFFER8) *pStream);
4418 return D3D_OK;
4419 }
4420
4421
4422 ICOM_VTABLE(IDirect3DDevice8) Direct3DDevice8_Vtbl =
4423 {
4424 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4425 IDirect3DDevice8Impl_QueryInterface,
4426 IDirect3DDevice8Impl_AddRef,
4427 IDirect3DDevice8Impl_Release,
4428 IDirect3DDevice8Impl_TestCooperativeLevel,
4429 IDirect3DDevice8Impl_GetAvailableTextureMem,
4430 IDirect3DDevice8Impl_ResourceManagerDiscardBytes,
4431 IDirect3DDevice8Impl_GetDirect3D,
4432 IDirect3DDevice8Impl_GetDeviceCaps,
4433 IDirect3DDevice8Impl_GetDisplayMode,
4434 IDirect3DDevice8Impl_GetCreationParameters,
4435 IDirect3DDevice8Impl_SetCursorProperties,
4436 IDirect3DDevice8Impl_SetCursorPosition,
4437 IDirect3DDevice8Impl_ShowCursor,
4438 IDirect3DDevice8Impl_CreateAdditionalSwapChain,
4439 IDirect3DDevice8Impl_Reset,
4440 IDirect3DDevice8Impl_Present,
4441 IDirect3DDevice8Impl_GetBackBuffer,
4442 IDirect3DDevice8Impl_GetRasterStatus,
4443 IDirect3DDevice8Impl_SetGammaRamp,
4444 IDirect3DDevice8Impl_GetGammaRamp,
4445 IDirect3DDevice8Impl_CreateTexture,
4446 IDirect3DDevice8Impl_CreateVolumeTexture,
4447 IDirect3DDevice8Impl_CreateCubeTexture,
4448 IDirect3DDevice8Impl_CreateVertexBuffer,
4449 IDirect3DDevice8Impl_CreateIndexBuffer,
4450 IDirect3DDevice8Impl_CreateRenderTarget,
4451 IDirect3DDevice8Impl_CreateDepthStencilSurface,
4452 IDirect3DDevice8Impl_CreateImageSurface,
4453 IDirect3DDevice8Impl_CopyRects,
4454 IDirect3DDevice8Impl_UpdateTexture,
4455 IDirect3DDevice8Impl_GetFrontBuffer,
4456 IDirect3DDevice8Impl_SetRenderTarget,
4457 IDirect3DDevice8Impl_GetRenderTarget,
4458 IDirect3DDevice8Impl_GetDepthStencilSurface,
4459 IDirect3DDevice8Impl_BeginScene,
4460 IDirect3DDevice8Impl_EndScene,
4461 IDirect3DDevice8Impl_Clear,
4462 IDirect3DDevice8Impl_SetTransform,
4463 IDirect3DDevice8Impl_GetTransform,
4464 IDirect3DDevice8Impl_MultiplyTransform,
4465 IDirect3DDevice8Impl_SetViewport,
4466 IDirect3DDevice8Impl_GetViewport,
4467 IDirect3DDevice8Impl_SetMaterial,
4468 IDirect3DDevice8Impl_GetMaterial,
4469 IDirect3DDevice8Impl_SetLight,
4470 IDirect3DDevice8Impl_GetLight,
4471 IDirect3DDevice8Impl_LightEnable,
4472 IDirect3DDevice8Impl_GetLightEnable,
4473 IDirect3DDevice8Impl_SetClipPlane,
4474 IDirect3DDevice8Impl_GetClipPlane,
4475 IDirect3DDevice8Impl_SetRenderState,
4476 IDirect3DDevice8Impl_GetRenderState,
4477 IDirect3DDevice8Impl_BeginStateBlock,
4478 IDirect3DDevice8Impl_EndStateBlock,
4479 IDirect3DDevice8Impl_ApplyStateBlock,
4480 IDirect3DDevice8Impl_CaptureStateBlock,
4481 IDirect3DDevice8Impl_DeleteStateBlock,
4482 IDirect3DDevice8Impl_CreateStateBlock,
4483 IDirect3DDevice8Impl_SetClipStatus,
4484 IDirect3DDevice8Impl_GetClipStatus,
4485 IDirect3DDevice8Impl_GetTexture,
4486 IDirect3DDevice8Impl_SetTexture,
4487 IDirect3DDevice8Impl_GetTextureStageState,
4488 IDirect3DDevice8Impl_SetTextureStageState,
4489 IDirect3DDevice8Impl_ValidateDevice,
4490 IDirect3DDevice8Impl_GetInfo,
4491 IDirect3DDevice8Impl_SetPaletteEntries,
4492 IDirect3DDevice8Impl_GetPaletteEntries,
4493 IDirect3DDevice8Impl_SetCurrentTexturePalette,
4494 IDirect3DDevice8Impl_GetCurrentTexturePalette,
4495 IDirect3DDevice8Impl_DrawPrimitive,
4496 IDirect3DDevice8Impl_DrawIndexedPrimitive,
4497 IDirect3DDevice8Impl_DrawPrimitiveUP,
4498 IDirect3DDevice8Impl_DrawIndexedPrimitiveUP,
4499 IDirect3DDevice8Impl_ProcessVertices,
4500 IDirect3DDevice8Impl_CreateVertexShader,
4501 IDirect3DDevice8Impl_SetVertexShader,
4502 IDirect3DDevice8Impl_GetVertexShader,
4503 IDirect3DDevice8Impl_DeleteVertexShader,
4504 IDirect3DDevice8Impl_SetVertexShaderConstant,
4505 IDirect3DDevice8Impl_GetVertexShaderConstant,
4506 IDirect3DDevice8Impl_GetVertexShaderDeclaration,
4507 IDirect3DDevice8Impl_GetVertexShaderFunction,
4508 IDirect3DDevice8Impl_SetStreamSource,
4509 IDirect3DDevice8Impl_GetStreamSource,
4510 IDirect3DDevice8Impl_SetIndices,
4511 IDirect3DDevice8Impl_GetIndices,
4512 IDirect3DDevice8Impl_CreatePixelShader,
4513 IDirect3DDevice8Impl_SetPixelShader,
4514 IDirect3DDevice8Impl_GetPixelShader,
4515 IDirect3DDevice8Impl_DeletePixelShader,
4516 IDirect3DDevice8Impl_SetPixelShaderConstant,
4517 IDirect3DDevice8Impl_GetPixelShaderConstant,
4518 IDirect3DDevice8Impl_GetPixelShaderFunction,
4519 IDirect3DDevice8Impl_DrawRectPatch,
4520 IDirect3DDevice8Impl_DrawTriPatch,
4521 IDirect3DDevice8Impl_DeletePatch
4522 };
Wine tree for Wine Gecko development