?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
#ifdef guard the declaration of type IID to be compatible with
[wine.git] / dlls / d3d8 / drawprim.c
blob1afff076fd7a03426b4a3c5672a315a7165262ec
1 /*
2 * D3D8 utils
3 *
4 * Copyright 2002-2003 Jason Edmeades
5 * Raphael Junqueira
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23
24 #include <math.h>
25 #include <stdarg.h>
26
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winuser.h"
32 #include "wingdi.h"
33 #include "wine/debug.h"
34
35 #include "d3d8_private.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
38 WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
39
40 extern IDirect3DVertexShaderImpl* VertexShaders[64];
41 extern IDirect3DVertexShaderDeclarationImpl* VertexShaderDeclarations[64];
42 extern IDirect3DPixelShaderImpl* PixelShaders[64];
43
44 /* Useful holding place for 4 floats */
45 typedef struct _D3DVECTOR_4 {
46 float x;
47 float y;
48 float z;
49 float w;
50 } D3DVECTOR_4;
51
52 #undef GL_VERSION_1_4 /* To be fixed, caused by mesa headers */
53
54 /* Returns bits for what is expected from the fixed function pipeline, and whether
55 a vertex shader will be in use. Note the fvf bits returned may be split over
56 multiple streams only if the vertex shader was created, otherwise it all relates
57 to stream 0 */
58 BOOL initializeFVF(LPDIRECT3DDEVICE8 iface,
59 DWORD *FVFbits, /* What to expect in the FVF across all streams */
60 BOOL *useVertexShaderFunction) /* Should we use the vertex shader */
61 {
62
63 ICOM_THIS(IDirect3DDevice8Impl,iface);
64
65 /* The first thing to work out is if we are using the fixed function pipeline
66 which is either SetVertexShader with < VS_HIGHESTFIXEDFXF - in which case this
67 is the FVF, or with a shader which was created with no function - in which
68 case there is an FVF per declared stream. If this occurs, we also maintain
69 an 'OR' of all the FVF's together so we know what to expect across all the
70 streams */
71
72 if (This->UpdateStateBlock->VertexShader <= VS_HIGHESTFIXEDFXF) {
73
74 /* Use this as the FVF */
75 *FVFbits = This->UpdateStateBlock->VertexShader;
76 *useVertexShaderFunction = FALSE;
77 TRACE("FVF explicitally defined, using fixed function pipeline with FVF=%lx\n", *FVFbits);
78
79 } else {
80
81 /* Use created shader */
82 IDirect3DVertexShaderImpl* vertex_shader = NULL;
83 vertex_shader = VERTEX_SHADER(This->UpdateStateBlock->VertexShader);
84
85 if (vertex_shader == NULL) {
86
87 /* Hmm - User pulled figure out of the air? Unlikely, probably a bug */
88 ERR("trying to use unitialised vertex shader: %lu\n", This->UpdateStateBlock->VertexShader);
89 return TRUE;
90
91 } else {
92
93 *FVFbits = This->UpdateStateBlock->vertexShaderDecl->allFVF;
94
95 if (vertex_shader->function == NULL) {
96 /* No function, so many streams supplied plus FVF definition pre stream */
97 *useVertexShaderFunction = FALSE;
98 TRACE("vertex shader (%lx) declared without program, using fixed function pipeline with FVF=%lx\n",
99 This->StateBlock->VertexShader, *FVFbits);
100 } else {
101 /* Vertex shader needs calling */
102 *useVertexShaderFunction = TRUE;
103 TRACE("vertex shader will be used (unusued FVF=%lx)\n", *FVFbits);
104 }
105 }
106 }
107 return FALSE;
108 }
109
110 /* Issues the glBegin call for gl given the primitive type and count */
111 DWORD primitiveToGl(D3DPRIMITIVETYPE PrimitiveType,
112 DWORD NumPrimitives,
113 GLenum *primType)
114 {
115 DWORD NumVertexes = NumPrimitives;
116
117 switch (PrimitiveType) {
118 case D3DPT_POINTLIST:
119 TRACE("POINTS\n");
120 *primType = GL_POINTS;
121 NumVertexes = NumPrimitives;
122 break;
123
124 case D3DPT_LINELIST:
125 TRACE("LINES\n");
126 *primType = GL_LINES;
127 NumVertexes = NumPrimitives * 2;
128 break;
129
130 case D3DPT_LINESTRIP:
131 TRACE("LINE_STRIP\n");
132 *primType = GL_LINE_STRIP;
133 NumVertexes = NumPrimitives + 1;
134 break;
135
136 case D3DPT_TRIANGLELIST:
137 TRACE("TRIANGLES\n");
138 *primType = GL_TRIANGLES;
139 NumVertexes = NumPrimitives * 3;
140 break;
141
142 case D3DPT_TRIANGLESTRIP:
143 TRACE("TRIANGLE_STRIP\n");
144 *primType = GL_TRIANGLE_STRIP;
145 NumVertexes = NumPrimitives + 2;
146 break;
147
148 case D3DPT_TRIANGLEFAN:
149 TRACE("TRIANGLE_FAN\n");
150 *primType = GL_TRIANGLE_FAN;
151 NumVertexes = NumPrimitives + 2;
152 break;
153
154 default:
155 FIXME("Unhandled primitive\n");
156 *primType = GL_POINTS;
157 break;
158 }
159 return NumVertexes;
160 }
161
162 /* Ensure the appropriate material states are set up - only change
163 state if really required */
164 void init_materials(LPDIRECT3DDEVICE8 iface, BOOL isDiffuseSupplied) {
165
166 BOOL requires_material_reset = FALSE;
167 ICOM_THIS(IDirect3DDevice8Impl,iface);
168
169 if (This->tracking_color == NEEDS_TRACKING && isDiffuseSupplied == TRUE) {
170 /* If we have not set up the material color tracking, do it now as required */
171 glDisable(GL_COLOR_MATERIAL); /* Note: Man pages state must enable AFTER calling glColorMaterial! Required?*/
172 checkGLcall("glDisable GL_COLOR_MATERIAL");
173 TRACE("glColorMaterial Parm=%x\n", This->tracking_parm);
174 glColorMaterial(GL_FRONT_AND_BACK, This->tracking_parm);
175 checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
176 glEnable(GL_COLOR_MATERIAL);
177 checkGLcall("glEnable GL_COLOR_MATERIAL");
178 This->tracking_color = IS_TRACKING;
179 requires_material_reset = TRUE; /* Restore material settings as will be used */
180
181 } else if ((This->tracking_color == IS_TRACKING && isDiffuseSupplied == FALSE) ||
182 (This->tracking_color == NEEDS_TRACKING && isDiffuseSupplied == FALSE)) {
183 /* If we are tracking the current color but one isn't supplied, don't! */
184 glDisable(GL_COLOR_MATERIAL);
185 checkGLcall("glDisable GL_COLOR_MATERIAL");
186 This->tracking_color = NEEDS_TRACKING;
187 requires_material_reset = TRUE; /* Restore material settings as will be used */
188
189 } else if (This->tracking_color == IS_TRACKING && isDiffuseSupplied == TRUE) {
190 /* No need to reset material colors since no change to gl_color_material */
191 requires_material_reset = FALSE;
192
193 } else if (This->tracking_color == NEEDS_DISABLE) {
194 glDisable(GL_COLOR_MATERIAL);
195 checkGLcall("glDisable GL_COLOR_MATERIAL");
196 This->tracking_color = DISABLED_TRACKING;
197 requires_material_reset = TRUE; /* Restore material settings as will be used */
198 }
199
200 /* Reset the material colors which may have been tracking the color*/
201 if (requires_material_reset == TRUE) {
202 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*) &This->StateBlock->material.Ambient);
203 checkGLcall("glMaterialfv");
204 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*) &This->StateBlock->material.Diffuse);
205 checkGLcall("glMaterialfv");
206 if (This->StateBlock->renderstate[D3DRS_SPECULARENABLE]) {
207 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &This->StateBlock->material.Specular);
208 checkGLcall("glMaterialfv");
209 } else {
210 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
211 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
212 checkGLcall("glMaterialfv");
213 }
214 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*) &This->StateBlock->material.Emissive);
215 checkGLcall("glMaterialfv");
216 }
217
218 }
219
220 /* Setup views - Transformed & lit if RHW, else untransformed.
221 Only unlit if Normals are supplied
222 Returns: Whether to restore lighting afterwards */
223 BOOL primitiveInitState(LPDIRECT3DDEVICE8 iface, BOOL vtx_transformed, BOOL vtx_lit, BOOL useVS) {
224
225 BOOL isLightingOn = FALSE;
226 ICOM_THIS(IDirect3DDevice8Impl,iface);
227
228 /* If no normals, DISABLE lighting otherwise, don't touch lighing as it is
229 set by the appropriate render state. Note Vertex Shader output is already lit */
230 if (vtx_lit || useVS) {
231 isLightingOn = glIsEnabled(GL_LIGHTING);
232 glDisable(GL_LIGHTING);
233 checkGLcall("glDisable(GL_LIGHTING);");
234 TRACE("Disabled lighting as no normals supplied, old state = %d\n", isLightingOn);
235 }
236
237 if (!useVS && vtx_transformed) {
238
239 /* If the last draw was transformed as well, no need to reapply all the matrixes */
240 if (!This->last_was_rhw) {
241
242 double X, Y, height, width, minZ, maxZ;
243 This->last_was_rhw = TRUE;
244
245 /* Transformed already into viewport coordinates, so we do not need transform
246 matrices. Reset all matrices to identity and leave the default matrix in world
247 mode. */
248 glMatrixMode(GL_MODELVIEW);
249 checkGLcall("glMatrixMode");
250 glLoadIdentity();
251 checkGLcall("glLoadIdentity");
252
253 glMatrixMode(GL_PROJECTION);
254 checkGLcall("glMatrixMode");
255 glLoadIdentity();
256 checkGLcall("glLoadIdentity");
257
258 /* Set up the viewport to be full viewport */
259 X = This->StateBlock->viewport.X;
260 Y = This->StateBlock->viewport.Y;
261 height = This->StateBlock->viewport.Height;
262 width = This->StateBlock->viewport.Width;
263 minZ = This->StateBlock->viewport.MinZ;
264 maxZ = This->StateBlock->viewport.MaxZ;
265 TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
266 glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
267 checkGLcall("glOrtho");
268
269 /* Window Coord 0 is the middle of the first pixel, so translate by half
270 a pixel (See comment above glTranslate below) */
271 glTranslatef(0.5, 0.5, 0);
272 checkGLcall("glTranslatef(0.5, 0.5, 0)");
273 }
274
275 } else {
276
277 /* Untransformed, so relies on the view and projection matrices */
278
279 if (!useVS && (This->last_was_rhw || !This->modelview_valid)) {
280 /* Only reapply when have to */
281 This->modelview_valid = TRUE;
282 glMatrixMode(GL_MODELVIEW);
283 checkGLcall("glMatrixMode");
284
285 /* In the general case, the view matrix is the identity matrix */
286 if (This->view_ident) {
287 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0]);
288 checkGLcall("glLoadMatrixf");
289 } else {
290 glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
291 checkGLcall("glLoadMatrixf");
292 glMultMatrixf((float *) &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0]);
293 checkGLcall("glMultMatrixf");
294 }
295 }
296
297 if (!useVS && (This->last_was_rhw || !This->proj_valid)) {
298 /* Only reapply when have to */
299 This->proj_valid = TRUE;
300 glMatrixMode(GL_PROJECTION);
301 checkGLcall("glMatrixMode");
302
303 /* The rule is that the window coordinate 0 does not correspond to the
304 beginning of the first pixel, but the center of the first pixel.
305 As a consequence if you want to correctly draw one line exactly from
306 the left to the right end of the viewport (with all matrices set to
307 be identity), the x coords of both ends of the line would be not
308 -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
309 instead. */
310 glLoadIdentity();
311 glTranslatef(1.0/This->StateBlock->viewport.Width, -1.0/This->StateBlock->viewport.Height, 0);
312 checkGLcall("glTranslatef (1.0/width, -1.0/height, 0)");
313 glMultMatrixf((float *) &This->StateBlock->transforms[D3DTS_PROJECTION].u.m[0][0]);
314 checkGLcall("glLoadMatrixf");
315 }
316
317 /* Vertex Shader output is already transformed, so set up identity matrices */
318 /* FIXME: Actually, only true for software emulated ones, so when h/w ones
319 come along this needs to take into account whether s/w ones were
320 requested or not */
321 if (useVS) {
322 glMatrixMode(GL_MODELVIEW);
323 checkGLcall("glMatrixMode");
324 glLoadIdentity();
325 glMatrixMode(GL_PROJECTION);
326 checkGLcall("glMatrixMode");
327 glLoadIdentity();
328 /* Window Coord 0 is the middle of the first pixel, so translate by half
329 a pixel (See comment above glTranslate above) */
330 glTranslatef(1.0/This->StateBlock->viewport.Width, -1.0/This->StateBlock->viewport.Height, 0);
331 checkGLcall("glTranslatef (1.0/width, -1.0/height, 0)");
332 This->modelview_valid = FALSE;
333 This->proj_valid = FALSE;
334 }
335 This->last_was_rhw = FALSE;
336 }
337 return isLightingOn;
338 }
339
340 void primitiveConvertToStridedData(LPDIRECT3DDEVICE8 iface, Direct3DVertexStridedData *strided, LONG BaseVertexIndex) {
341
342 short LoopThroughTo = 0;
343 short nStream;
344 BOOL canDoViaGLPointers = TRUE;
345 int numBlends;
346 int numTextures;
347 int textureNo;
348 int coordIdxInfo = 0x00; /* Information on number of coords supplied */
349 int numCoords[8]; /* Holding place for D3DFVF_TEXTUREFORMATx */
350
351 ICOM_THIS(IDirect3DDevice8Impl,iface);
352
353 /* OK, Now to setup the data locations
354 For the non-created vertex shaders, the VertexShader var holds the real
355 FVF and only stream 0 matters
356 For the created vertex shaders, there is an FVF per stream */
357 if (!This->StateBlock->streamIsUP && (This->UpdateStateBlock->VertexShader > VS_HIGHESTFIXEDFXF)) {
358 LoopThroughTo = MAX_STREAMS;
359 } else {
360 LoopThroughTo = 1;
361 }
362
363 /* Work through stream by stream */
364 for (nStream=0; nStream<LoopThroughTo; nStream++) {
365 DWORD stride = This->StateBlock->stream_stride[nStream];
366 BYTE *data = NULL;
367 DWORD thisFVF = 0;
368
369 /* Skip empty streams */
370 if (This->StateBlock->stream_source[nStream] == NULL) continue;
371
372 /* Retrieve appropriate FVF */
373 if (LoopThroughTo == 1) { /* VertexShader is FVF */
374 thisFVF = This->UpdateStateBlock->VertexShader;
375 /* Handle memory passed directly as well as vertex buffers */
376 if (This->StateBlock->streamIsUP == TRUE) {
377 data = (BYTE *)This->StateBlock->stream_source[nStream];
378 } else {
379 data = ((IDirect3DVertexBuffer8Impl *)This->StateBlock->stream_source[nStream])->allocatedMemory;
380 }
381 } else {
382 thisFVF = This->StateBlock->vertexShaderDecl->fvf[nStream];
383 data = ((IDirect3DVertexBuffer8Impl *)This->StateBlock->stream_source[nStream])->allocatedMemory;
384 }
385 VTRACE(("FVF for stream %d is %lx\n", nStream, thisFVF));
386 if (thisFVF == 0) continue;
387
388 /* Now convert the stream into pointers */
389
390 /* Shuffle to the beginning of the vertexes to render and index from there */
391 data = data + (BaseVertexIndex * stride);
392
393 /* Either 3 or 4 floats depending on the FVF */
394 /* FIXME: Can blending data be in a different stream to the position data?
395 and if so using the fixed pipeline how do we handle it */
396 if (thisFVF & D3DFVF_POSITION_MASK) {
397 strided->u.s.position.lpData = data;
398 strided->u.s.position.dwType = D3DVSDT_FLOAT3;
399 strided->u.s.position.dwStride = stride;
400 data += 3 * sizeof(float);
401 if (thisFVF & D3DFVF_XYZRHW) {
402 strided->u.s.position.dwType = D3DVSDT_FLOAT4;
403 data += sizeof(float);
404 }
405 }
406
407 /* Blending is numBlends * FLOATs followed by a DWORD for UBYTE4 */
408 /** do we have to Check This->UpdateStateBlock->renderstate[D3DRS_INDEXEDVERTEXBLENDENABLE] ? */
409 numBlends = ((thisFVF & D3DFVF_POSITION_MASK) >> 1) - 2 +
410 ((FALSE == (thisFVF & D3DFVF_LASTBETA_UBYTE4)) ? 0 : -1); /* WARNING can be < 0 because -2 */
411 if (numBlends > 0) {
412 canDoViaGLPointers = FALSE;
413 strided->u.s.blendWeights.lpData = data;
414 strided->u.s.blendWeights.dwType = D3DVSDT_FLOAT1 + (numBlends - 1);
415 strided->u.s.blendWeights.dwStride = stride;
416 data += numBlends * sizeof(FLOAT);
417
418 if (thisFVF & D3DFVF_LASTBETA_UBYTE4) {
419 strided->u.s.blendMatrixIndices.lpData = data;
420 strided->u.s.blendMatrixIndices.dwType = D3DVSDT_UBYTE4;
421 strided->u.s.blendMatrixIndices.dwStride= stride;
422 data += sizeof(DWORD);
423 }
424 }
425
426 /* Normal is always 3 floats */
427 if (thisFVF & D3DFVF_NORMAL) {
428 strided->u.s.normal.lpData = data;
429 strided->u.s.normal.dwType = D3DVSDT_FLOAT3;
430 strided->u.s.normal.dwStride = stride;
431 data += 3 * sizeof(FLOAT);
432 }
433
434 /* Pointsize is a single float */
435 if (thisFVF & D3DFVF_PSIZE) {
436 strided->u.s.pSize.lpData = data;
437 strided->u.s.pSize.dwType = D3DVSDT_FLOAT1;
438 strided->u.s.pSize.dwStride = stride;
439 data += sizeof(FLOAT);
440 }
441
442 /* Diffuse is 4 unsigned bytes */
443 if (thisFVF & D3DFVF_DIFFUSE) {
444 strided->u.s.diffuse.lpData = data;
445 strided->u.s.diffuse.dwType = D3DVSDT_SHORT4;
446 strided->u.s.diffuse.dwStride = stride;
447 data += sizeof(DWORD);
448 }
449
450 /* Specular is 4 unsigned bytes */
451 if (thisFVF & D3DFVF_SPECULAR) {
452 strided->u.s.specular.lpData = data;
453 strided->u.s.specular.dwType = D3DVSDT_SHORT4;
454 strided->u.s.specular.dwStride = stride;
455 data += sizeof(DWORD);
456 }
457
458 /* Texture coords */
459 numTextures = (thisFVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
460 coordIdxInfo = (thisFVF & 0x00FF0000) >> 16; /* 16 is from definition of D3DFVF_TEXCOORDSIZE1, and is 8 (0-7 stages) * 2bits long */
461
462 /* numTextures indicates the number of texture coordinates supplied */
463 /* However, the first set may not be for stage 0 texture - it all */
464 /* depends on D3DTSS_TEXCOORDINDEX. */
465 /* The number of bytes for each coordinate set is based off */
466 /* D3DFVF_TEXCOORDSIZEn, which are the bottom 2 bits */
467
468 /* So, for each supplied texture extract the coords */
469 for (textureNo = 0; textureNo < numTextures; ++textureNo) {
470
471 strided->u.s.texCoords[textureNo].lpData = data;
472 strided->u.s.texCoords[textureNo].dwType = D3DVSDT_FLOAT1;
473 strided->u.s.texCoords[textureNo].dwStride = stride;
474 numCoords[textureNo] = coordIdxInfo & 0x03;
475
476 /* Always one set */
477 data += sizeof(float);
478 if (numCoords[textureNo] != D3DFVF_TEXTUREFORMAT1) {
479 strided->u.s.texCoords[textureNo].dwType = D3DVSDT_FLOAT2;
480 data += sizeof(float);
481 if (numCoords[textureNo] != D3DFVF_TEXTUREFORMAT2) {
482 strided->u.s.texCoords[textureNo].dwType = D3DVSDT_FLOAT3;
483 data += sizeof(float);
484 if (numCoords[textureNo] != D3DFVF_TEXTUREFORMAT3) {
485 strided->u.s.texCoords[textureNo].dwType = D3DVSDT_FLOAT4;
486 data += sizeof(float);
487 }
488 }
489 }
490 coordIdxInfo = coordIdxInfo >> 2; /* Drop bottom two bits */
491 }
492 }
493 }
494
495 /* Draw a single vertex using this information */
496 void draw_vertex(LPDIRECT3DDEVICE8 iface, /* interface */
497 BOOL isXYZ, float x, float y, float z, float rhw, /* xyzn position*/
498 BOOL isNormal, float nx, float ny, float nz, /* normal */
499 BOOL isDiffuse, float *dRGBA, /* 1st colors */
500 BOOL isSpecular, float *sRGB, /* 2ndry colors */
501 BOOL isPtSize, float ptSize, /* pointSize */
502 D3DVECTOR_4 *texcoords, int *numcoords) /* texture info */
503 {
504 int textureNo;
505 float s, t, r, q;
506 ICOM_THIS(IDirect3DDevice8Impl,iface);
507
508 /* Diffuse -------------------------------- */
509 if (isDiffuse == TRUE) {
510 glColor4fv(dRGBA);
511 VTRACE(("glColor4f: r,g,b,a=%f,%f,%f,%f\n", dRGBA[0], dRGBA[1], dRGBA[2], dRGBA[3]));
512 }
513
514 /* Specular Colour ------------------------------------------*/
515 if (isSpecular == TRUE) {
516 #if defined(GL_EXT_secondary_color)
517 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
518 GL_EXTCALL(glSecondaryColor3fvEXT(sRGB));
519 VTRACE(("glSecondaryColor4f: r,g,b=%f,%f,%f\n", sRGB[0], sRGB[1], sRGB[2]));
520 }
521 #endif
522 }
523
524 /* Normal -------------------------------- */
525 if (isNormal == TRUE) {
526 VTRACE(("glNormal:nx,ny,nz=%f,%f,%f\n", nx,ny,nz));
527 glNormal3f(nx, ny, nz);
528 }
529
530 /* Point Size ----------------------------------------------*/
531 if (isPtSize == TRUE) {
532
533 /* no such functionality in the fixed function GL pipeline */
534 FIXME("Cannot change ptSize here in openGl\n");
535 }
536
537 /* Texture coords --------------------------- */
538 for (textureNo = 0; textureNo < GL_LIMITS(textures); ++textureNo) {
539
540 if (!GL_SUPPORT(ARB_MULTITEXTURE) && textureNo > 0) {
541 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
542 continue ;
543 }
544
545 /* Query tex coords */
546 if (This->StateBlock->textures[textureNo] != NULL) {
547
548 int coordIdx = This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX];
549 if (coordIdx > 7) {
550 VTRACE(("tex: %d - Skip tex coords, as being system generated\n", textureNo));
551 continue;
552 } else if (numcoords[coordIdx] == 0) {
553 TRACE("tex: %d - Skipping tex coords, as no data supplied or no coords supplied\n", textureNo);
554 continue;
555 } else {
556
557 /* Initialize vars */
558 s = 0.0f;
559 t = 0.0f;
560 r = 0.0f;
561 q = 0.0f;
562
563 switch (numcoords[coordIdx]) {
564 case 4: q = texcoords[coordIdx].w; /* drop through */
565 case 3: r = texcoords[coordIdx].z; /* drop through */
566 case 2: t = texcoords[coordIdx].y; /* drop through */
567 case 1: s = texcoords[coordIdx].x;
568 }
569
570 switch (numcoords[coordIdx]) { /* Supply the provided texture coords */
571 case D3DTTFF_COUNT1:
572 VTRACE(("tex:%d, s=%f\n", textureNo, s));
573 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
574 #if defined(GL_VERSION_1_3)
575 glMultiTexCoord1f(GL_TEXTURE0 + textureNo, s);
576 #else
577 glMultiTexCoord1fARB(GL_TEXTURE0_ARB + textureNo, s);
578 #endif
579 } else {
580 glTexCoord1f(s);
581 }
582 break;
583 case D3DTTFF_COUNT2:
584 VTRACE(("tex:%d, s=%f, t=%f\n", textureNo, s, t));
585 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
586 #if defined(GL_VERSION_1_3)
587 glMultiTexCoord2f(GL_TEXTURE0 + textureNo, s, t);
588 #else
589 glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t);
590 #endif
591 } else {
592 glTexCoord2f(s, t);
593 }
594 break;
595 case D3DTTFF_COUNT3:
596 VTRACE(("tex:%d, s=%f, t=%f, r=%f\n", textureNo, s, t, r));
597 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
598 #if defined(GL_VERSION_1_3)
599 glMultiTexCoord3f(GL_TEXTURE0 + textureNo, s, t, r);
600 #else
601 glMultiTexCoord3fARB(GL_TEXTURE0_ARB + textureNo, s, t, r);
602 #endif
603 } else {
604 glTexCoord3f(s, t, r);
605 }
606 break;
607 case D3DTTFF_COUNT4:
608 VTRACE(("tex:%d, s=%f, t=%f, r=%f, q=%f\n", textureNo, s, t, r, q));
609 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
610 #if defined(GL_VERSION_1_3)
611 glMultiTexCoord4f(GL_TEXTURE0 + textureNo, s, t, r, q);
612 #else
613 glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, s, t, r, q);
614 #endif
615 } else {
616 glTexCoord4f(s, t, r, q);
617 }
618 break;
619 default:
620 FIXME("Should not get here as numCoords should be 0->4 (%x)!\n", numcoords[coordIdx]);
621 }
622 }
623 }
624 } /* End of textures */
625
626 /* Position -------------------------------- */
627 if (isXYZ == TRUE) {
628 if (1.0f == rhw || rhw < 0.00001f) {
629 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z));
630 glVertex3f(x, y, z);
631 } else {
632 /* Cannot optimize by dividing through by rhw as rhw is required
633 later for perspective in the GL pipeline for vertex shaders */
634 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw));
635 glVertex4f(x,y,z,rhw);
636 }
637 }
638 }
639
640 /*
641 * Actually draw using the supplied information.
642 * Faster GL version using pointers to data, harder to debug though
643 * Note does not handle vertex shaders yet
644 */
645 void drawStridedFast(LPDIRECT3DDEVICE8 iface, Direct3DVertexStridedData *sd,
646 int PrimitiveType, ULONG NumPrimitives,
647 const void *idxData, short idxSize, ULONG minIndex, ULONG startIdx) {
648 int textureNo = 0;
649 GLenum glPrimType = GL_POINTS;
650 int NumVertexes = NumPrimitives;
651 ICOM_THIS(IDirect3DDevice8Impl,iface);
652
653 TRACE("Using fast vertex array code\n");
654
655 /* Vertex Pointers -----------------------------------------*/
656 if (sd->u.s.position.lpData != NULL) {
657
658 /* Note dwType == float3 or float4 == 2 or 3 */
659 VTRACE(("glVertexPointer(%ld, GL_FLOAT, %ld, %p)\n",
660 sd->u.s.position.dwStride,
661 sd->u.s.position.dwType + 1,
662 sd->u.s.position.lpData));
663
664 /* Disable RHW mode as 'w' coord handling for rhw mode should
665 not impact screen position whereas in GL it does. This may
666 result in very slightly distored textures in rhw mode, but
667 a very minimal different */
668 glVertexPointer(3, GL_FLOAT, /* RHW: Was 'sd->u.s.position.dwType + 1' */
669 sd->u.s.position.dwStride,
670 sd->u.s.position.lpData);
671 checkGLcall("glVertexPointer(...)");
672 glEnableClientState(GL_VERTEX_ARRAY);
673 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
674
675 } else {
676
677 glDisableClientState(GL_VERTEX_ARRAY);
678 checkGLcall("glDisableClientState(GL_VERTEX_ARRAY)");
679 }
680
681 /* Blend Data ----------------------------------------------*/
682 if ((sd->u.s.blendWeights.lpData != NULL) ||
683 (sd->u.s.blendMatrixIndices.lpData != NULL)) {
684 /* FIXME: Won't get here as will drop to slow method */
685 FIXME("Blending not supported in fast draw routine\n");
686
687 #if 0 /* Vertex blend support needs to be added */
688 if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
689 /*FIXME("TODO\n");*/
690 } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
691 /*FIXME("TODO\n");*/
692 /*
693 GLExtCall(glVertexWeightPointerEXT)(numBlends, GL_FLOAT, skip, curPos);
694 checkGLcall("glVertexWeightPointerEXT(numBlends, ...)");
695 glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
696 checkGLcall("glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
697 */
698 } else {
699 FIXME("unsupported blending in openGl\n");
700 }
701 } else {
702 if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
703 FIXME("TODO\n");
704 } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
705 FIXME("TODO\n");
706 /*
707 glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
708 checkGLcall("glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
709 */
710 }
711 #endif
712 }
713
714 /* Normals -------------------------------------------------*/
715 if (sd->u.s.normal.lpData != NULL) {
716
717 /* Note dwType == float3 or float4 == 2 or 3 */
718 VTRACE(("glNormalPointer(GL_FLOAT, %ld, %p)\n",
719 sd->u.s.normal.dwStride,
720 sd->u.s.normal.lpData));
721 glNormalPointer(GL_FLOAT,
722 sd->u.s.normal.dwStride,
723 sd->u.s.normal.lpData);
724 checkGLcall("glNormalPointer(...)");
725 glEnableClientState(GL_NORMAL_ARRAY);
726 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
727
728 } else {
729
730 glDisableClientState(GL_NORMAL_ARRAY);
731 checkGLcall("glDisableClientState(GL_NORMAL_ARRAY)");
732 glNormal3f(0, 0, 1);
733 checkGLcall("glNormal3f(0, 0, 1)");
734 }
735
736 /* Point Size ----------------------------------------------*/
737 if (sd->u.s.pSize.lpData != NULL) {
738
739 /* no such functionality in the fixed function GL pipeline */
740 /* FIXME: Won't get here as will drop to slow method */
741 FIXME("Cannot change ptSize here in openGl\n");
742 }
743
744 /* Diffuse Colour ------------------------------------------*/
745 /* WARNING: Data here MUST be in RGBA format, so cannot */
746 /* go directly into fast mode from app pgm, because */
747 /* directx requires data in BGRA format. */
748 if (sd->u.s.diffuse.lpData != NULL) {
749
750 /* Note dwType == float3 or float4 == 2 or 3 */
751 VTRACE(("glColorPointer(4, GL_UNSIGNED_BYTE, %ld, %p)\n",
752 sd->u.s.diffuse.dwStride,
753 sd->u.s.diffuse.lpData));
754 glColorPointer(4, GL_UNSIGNED_BYTE,
755 sd->u.s.diffuse.dwStride,
756 sd->u.s.diffuse.lpData);
757 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
758 glEnableClientState(GL_COLOR_ARRAY);
759 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
760
761 } else {
762
763 glDisableClientState(GL_COLOR_ARRAY);
764 checkGLcall("glDisableClientState(GL_COLOR_ARRAY)");
765 glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
766 checkGLcall("glColor4f(1, 1, 1, 1)");
767 }
768
769 /* Specular Colour ------------------------------------------*/
770 if (sd->u.s.specular.lpData != NULL) {
771
772 /* Note dwType == float3 or float4 == 2 or 3 */
773 VTRACE(("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, %ld, %p)\n",
774 sd->u.s.specular.dwStride,
775 sd->u.s.specular.lpData));
776
777 #if defined(GL_VERSION_1_4)
778 glSecondaryColorPointer(4, GL_UNSIGNED_BYTE,
779 sd->u.s.specular.dwStride,
780 sd->u.s.specular.lpData);
781 vcheckGLcall("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, ...)");
782 glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
783 vcheckGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY)");
784 #elif defined(GL_EXT_secondary_color)
785 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
786 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE,
787 sd->u.s.specular.dwStride,
788 sd->u.s.specular.lpData);
789 checkGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, ...)");
790 glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
791 checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
792 }
793 #else
794 /* Missing specular color is not critical, no warnings */
795 VTRACE(("Specular colour is not supported in this GL implementation\n"));
796 #endif
797
798 } else {
799
800 #if defined(GL_VERSION_1_4)
801 glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
802 checkGLcall("glDisableClientState(GL_SECONDARY_COLOR_ARRAY)");
803 glSecondaryColor3f(0, 0, 0);
804 checkGLcall("glSecondaryColor3f(0, 0, 0)");
805 #elif defined(GL_EXT_secondary_color)
806 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
807 glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
808 checkGLcall("glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
809 GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
810 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
811 }
812 #else
813 /* Do not worry if specular colour missing and disable request */
814 #endif
815 }
816
817 /* Texture coords -------------------------------------------*/
818 for (textureNo = 0; textureNo < GL_LIMITS(textures); ++textureNo) {
819
820 /* Select the correct texture stage */
821 #if defined(GL_VERSION_1_3)
822 glClientActiveTexture(GL_TEXTURE0 + textureNo);
823 #else
824 glClientActiveTextureARB(GL_TEXTURE0_ARB + textureNo);
825 #endif
826
827 /* Query tex coords */
828 if (This->StateBlock->textures[textureNo] != NULL) {
829 int coordIdx = This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX];
830
831 if (!GL_SUPPORT(ARB_MULTITEXTURE) && textureNo > 0) {
832 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
833 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
834 glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1);
835 continue;
836 }
837
838 if (coordIdx > 7) {
839 VTRACE(("tex: %d - Skip tex coords, as being system generated\n", textureNo));
840 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
841 glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1);
842 } else if (sd->u.s.texCoords[coordIdx].lpData == NULL) {
843 VTRACE(("Bound texture but no texture coordinates supplied, so skipping\n"));
844 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
845 glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1);
846 } else {
847
848 /* The coords to supply depend completely on the fvf / vertex shader */
849 GLint size;
850 GLenum type;
851
852 switch (sd->u.s.texCoords[coordIdx].dwType) {
853 case D3DVSDT_FLOAT1: size = 1, type = GL_FLOAT; break;
854 case D3DVSDT_FLOAT2: size = 2, type = GL_FLOAT; break;
855 case D3DVSDT_FLOAT3: size = 3, type = GL_FLOAT; break;
856 case D3DVSDT_FLOAT4: size = 4, type = GL_FLOAT; break;
857 case D3DVSDT_SHORT2: size = 2, type = GL_SHORT; break;
858 case D3DVSDT_SHORT4: size = 4, type = GL_SHORT; break;
859 case D3DVSDT_UBYTE4: size = 4, type = GL_UNSIGNED_BYTE; break;
860 default: FIXME("Unrecognized data type %ld\n", sd->u.s.texCoords[coordIdx].dwType);
861 size = 4; type = GL_UNSIGNED_BYTE;
862 }
863
864 glTexCoordPointer(size, type, sd->u.s.texCoords[coordIdx].dwStride, sd->u.s.texCoords[coordIdx].lpData);
865 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
866 }
867 } else {
868 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
869 glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1);
870 }
871 }
872
873 /* Ok, Work out which primitive is requested and how many vertexes that
874 will be */
875 NumVertexes = primitiveToGl(PrimitiveType, NumPrimitives, &glPrimType);
876
877 /* Finally do the drawing */
878 if (idxData != NULL) {
879
880 TRACE("glElements(%x, %d, %ld, ...)\n", glPrimType, NumVertexes, minIndex);
881 #if 1 /* FIXME: Want to use DrawRangeElements, but wrong calculation! */
882 glDrawElements(glPrimType, NumVertexes, idxSize==2?GL_UNSIGNED_SHORT:GL_UNSIGNED_INT,
883 (char *)idxData+(idxSize * startIdx));
884 #else
885 glDrawRangeElements(glPrimType, minIndex, minIndex+NumVertexes-1, NumVertexes,
886 idxSize==2?GL_UNSIGNED_SHORT:GL_UNSIGNED_INT,
887 (char *)idxData+(idxSize * startIdx));
888 #endif
889 checkGLcall("glDrawRangeElements");
890
891 } else {
892
893 /* Note first is now zero as we shuffled along earlier */
894 TRACE("glDrawArrays(%x, 0, %d)\n", glPrimType, NumVertexes);
895 glDrawArrays(glPrimType, 0, NumVertexes);
896 checkGLcall("glDrawArrays");
897
898 }
899 }
900
901 /*
902 * Actually draw using the supplied information.
903 * Slower GL version which extracts info about each vertex in turn
904 */
905 void drawStridedSlow(LPDIRECT3DDEVICE8 iface, Direct3DVertexStridedData *sd,
906 int PrimitiveType, ULONG NumPrimitives,
907 const void *idxData, short idxSize, ULONG minIndex, ULONG startIdx) {
908
909 int textureNo = 0;
910 GLenum glPrimType = GL_POINTS;
911 int NumVertexes = NumPrimitives;
912 const short *pIdxBufS = NULL;
913 const long *pIdxBufL = NULL;
914 LONG SkipnStrides = 0;
915 LONG vx_index;
916 float x = 0.0f, y = 0.0f, z = 0.0f; /* x,y,z coordinates */
917 float nx = 0.0f, ny = 0.0, nz = 0.0f; /* normal x,y,z coordinates */
918 float rhw = 0.0f; /* rhw */
919 float ptSize = 0.0f; /* Point size */
920 DWORD diffuseColor = 0xFFFFFFFF; /* Diffuse Color */
921 DWORD specularColor = 0; /* Specular Color */
922 ICOM_THIS(IDirect3DDevice8Impl,iface);
923
924 TRACE("Using slow vertex array code\n");
925
926 /* Variable Initialization */
927 if (idxData != NULL) {
928 if (idxSize == 2) pIdxBufS = (short *) idxData;
929 else pIdxBufL = (long *) idxData;
930 }
931
932 /* Ok, Work out which primitive is requested and how many vertexes that will be */
933 NumVertexes = primitiveToGl(PrimitiveType, NumPrimitives, &glPrimType);
934
935 /* Start drawing in GL */
936 VTRACE(("glBegin(%x)\n", glPrimType));
937 glBegin(glPrimType);
938
939 /* For each primitive */
940 for (vx_index = 0; vx_index < NumVertexes; vx_index++) {
941
942 /* Initialize diffuse color */
943 diffuseColor = 0xFFFFFFFF;
944
945 /* For indexed data, we need to go a few more strides in */
946 if (idxData != NULL) {
947
948 /* Indexed so work out the number of strides to skip */
949 if (idxSize == 2) {
950 VTRACE(("Idx for vertex %ld = %d\n", vx_index, pIdxBufS[startIdx+vx_index]));
951 SkipnStrides = pIdxBufS[startIdx+vx_index];
952 } else {
953 VTRACE(("Idx for vertex %ld = %ld\n", vx_index, pIdxBufL[startIdx+vx_index]));
954 SkipnStrides = pIdxBufL[startIdx+vx_index];
955 }
956 }
957
958 /* Position Information ------------------ */
959 if (sd->u.s.position.lpData != NULL) {
960
961 float *ptrToCoords = (float *)(sd->u.s.position.lpData + (SkipnStrides * sd->u.s.position.dwStride));
962 x = ptrToCoords[0];
963 y = ptrToCoords[1];
964 z = ptrToCoords[2];
965 rhw = 1.0;
966 VTRACE(("x,y,z=%f,%f,%f\n", x,y,z));
967
968 /* RHW follows, only if transformed, ie 4 floats were provided */
969 if (sd->u.s.position.dwType == D3DVSDT_FLOAT4) {
970 rhw = ptrToCoords[3];
971 VTRACE(("rhw=%f\n", rhw));
972 }
973 }
974
975 /* Blending data -------------------------- */
976 if (sd->u.s.blendWeights.lpData != NULL) {
977 /*float *ptrToCoords = (float *)(sd->u.s.blendWeights.lpData + (SkipnStrides * sd->u.s.blendWeights.dwStride));*/
978 FIXME("Blending not supported yet\n");
979
980 if (sd->u.s.blendMatrixIndices.lpData != NULL) {
981 /*DWORD *ptrToCoords = (DWORD *)(sd->u.s.blendMatrixIndices.lpData + (SkipnStrides * sd->u.s.blendMatrixIndices.dwStride));*/
982 }
983 }
984
985 /* Vertex Normal Data (untransformed only)- */
986 if (sd->u.s.normal.lpData != NULL) {
987
988 float *ptrToCoords = (float *)(sd->u.s.normal.lpData + (SkipnStrides * sd->u.s.normal.dwStride));
989 nx = ptrToCoords[0];
990 ny = ptrToCoords[1];
991 nz = ptrToCoords[2];
992 VTRACE(("nx,ny,nz=%f,%f,%f\n", nx, ny, nz));
993 }
994
995 /* Point Size ----------------------------- */
996 if (sd->u.s.pSize.lpData != NULL) {
997
998 float *ptrToCoords = (float *)(sd->u.s.pSize.lpData + (SkipnStrides * sd->u.s.pSize.dwStride));
999 ptSize = ptrToCoords[0];
1000 VTRACE(("ptSize=%f\n", ptSize));
1001 FIXME("No support for ptSize yet\n");
1002 }
1003
1004 /* Diffuse -------------------------------- */
1005 if (sd->u.s.diffuse.lpData != NULL) {
1006
1007 DWORD *ptrToCoords = (DWORD *)(sd->u.s.diffuse.lpData + (SkipnStrides * sd->u.s.diffuse.dwStride));
1008 diffuseColor = ptrToCoords[0];
1009 VTRACE(("diffuseColor=%lx\n", diffuseColor));
1010 }
1011
1012 /* Specular -------------------------------- */
1013 if (sd->u.s.specular.lpData != NULL) {
1014
1015 DWORD *ptrToCoords = (DWORD *)(sd->u.s.specular.lpData + (SkipnStrides * sd->u.s.specular.dwStride));
1016 specularColor = ptrToCoords[0];
1017 VTRACE(("specularColor=%lx\n", specularColor));
1018 }
1019
1020 /* Texture coords --------------------------- */
1021 for (textureNo = 0; textureNo < GL_LIMITS(textures); ++textureNo) {
1022
1023 if (!GL_SUPPORT(ARB_MULTITEXTURE) && textureNo > 0) {
1024 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1025 continue ;
1026 }
1027
1028 /* Query tex coords */
1029 if (This->StateBlock->textures[textureNo] != NULL) {
1030
1031 int coordIdx = This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXCOORDINDEX];
1032 float *ptrToCoords = (float *)(sd->u.s.texCoords[coordIdx].lpData + (SkipnStrides * sd->u.s.texCoords[coordIdx].dwStride));
1033 float s = 0.0, t = 0.0, r = 0.0, q = 0.0;
1034
1035 if (coordIdx > 7) {
1036 VTRACE(("tex: %d - Skip tex coords, as being system generated\n", textureNo));
1037 continue;
1038 } else if (sd->u.s.texCoords[coordIdx].lpData == NULL) {
1039 TRACE("tex: %d - Skipping tex coords, as no data supplied\n", textureNo);
1040 continue;
1041 } else {
1042
1043 int coordsToUse = sd->u.s.texCoords[coordIdx].dwType + 1; /* 0 == D3DVSDT_FLOAT1 etc */
1044
1045 /* The coords to supply depend completely on the fvf / vertex shader */
1046 switch (coordsToUse) {
1047 case 4: q = ptrToCoords[3]; /* drop through */
1048 case 3: r = ptrToCoords[2]; /* drop through */
1049 case 2: t = ptrToCoords[1]; /* drop through */
1050 case 1: s = ptrToCoords[0];
1051 }
1052
1053 /* Projected is more 'fun' - Move the last coord to the 'q'
1054 parameter (see comments under D3DTSS_TEXTURETRANSFORMFLAGS */
1055 if ((This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXTURETRANSFORMFLAGS] != D3DTTFF_DISABLE) &&
1056 (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXTURETRANSFORMFLAGS] & D3DTTFF_PROJECTED)) {
1057
1058 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXTURETRANSFORMFLAGS] & D3DTTFF_PROJECTED) {
1059 switch (coordsToUse) {
1060 case 0: /* Drop Through */
1061 case 1:
1062 FIXME("D3DTTFF_PROJECTED but only zero or one coordinate?\n");
1063 break;
1064 case 2:
1065 q = t;
1066 t = 0.0;
1067 coordsToUse = 4;
1068 break;
1069 case 3:
1070 q = r;
1071 r = 0.0;
1072 coordsToUse = 4;
1073 break;
1074 case 4: /* Nop here */
1075 break;
1076 default:
1077 FIXME("Unexpected D3DTSS_TEXTURETRANSFORMFLAGS value of %ld\n",
1078 This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXTURETRANSFORMFLAGS] & D3DTTFF_PROJECTED);
1079 }
1080 }
1081 }
1082
1083 switch (coordsToUse) { /* Supply the provided texture coords */
1084 case D3DTTFF_COUNT1:
1085 VTRACE(("tex:%d, s=%f\n", textureNo, s));
1086 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1087 #if defined(GL_VERSION_1_3)
1088 glMultiTexCoord1f(GL_TEXTURE0 + textureNo, s);
1089 #else
1090 glMultiTexCoord1fARB(GL_TEXTURE0_ARB + textureNo, s);
1091 #endif
1092 } else {
1093 glTexCoord1f(s);
1094 }
1095 break;
1096 case D3DTTFF_COUNT2:
1097 VTRACE(("tex:%d, s=%f, t=%f\n", textureNo, s, t));
1098 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1099 #if defined(GL_VERSION_1_3)
1100 glMultiTexCoord2f(GL_TEXTURE0 + textureNo, s, t);
1101 #else
1102 glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t);
1103 #endif
1104 } else {
1105 glTexCoord2f(s, t);
1106 }
1107 break;
1108 case D3DTTFF_COUNT3:
1109 VTRACE(("tex:%d, s=%f, t=%f, r=%f\n", textureNo, s, t, r));
1110 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1111 #if defined(GL_VERSION_1_3)
1112 glMultiTexCoord3f(GL_TEXTURE0 + textureNo, s, t, r);
1113 #else
1114 glMultiTexCoord3fARB(GL_TEXTURE0_ARB + textureNo, s, t, r);
1115 #endif
1116 } else {
1117 glTexCoord3f(s, t, r);
1118 }
1119 break;
1120 case D3DTTFF_COUNT4:
1121 VTRACE(("tex:%d, s=%f, t=%f, r=%f, q=%f\n", textureNo, s, t, r, q));
1122 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1123 #if defined(GL_VERSION_1_3)
1124 glMultiTexCoord4f(GL_TEXTURE0 + textureNo, s, t, r, q);
1125 #else
1126 glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, s, t, r, q);
1127 #endif
1128 } else {
1129 glTexCoord4f(s, t, r, q);
1130 }
1131 break;
1132 default:
1133 FIXME("Should not get here as coordsToUse is two bits only (%x)!\n", coordsToUse);
1134 }
1135 }
1136 }
1137 } /* End of textures */
1138
1139 /* Diffuse -------------------------------- */
1140 if (sd->u.s.diffuse.lpData != NULL) {
1141 glColor4ub((diffuseColor >> 16) & 0xFF,
1142 (diffuseColor >> 8) & 0xFF,
1143 (diffuseColor >> 0) & 0xFF,
1144 (diffuseColor >> 24) & 0xFF);
1145 VTRACE(("glColor4f: r,g,b,a=%f,%f,%f,%f\n",
1146 ((diffuseColor >> 16) & 0xFF) / 255.0f,
1147 ((diffuseColor >> 8) & 0xFF) / 255.0f,
1148 ((diffuseColor >> 0) & 0xFF) / 255.0f,
1149 ((diffuseColor >> 24) & 0xFF) / 255.0f));
1150 } else {
1151 if (vx_index == 0) glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
1152 }
1153
1154 #if 1
1155 /* Specular ------------------------------- */
1156 if (sd->u.s.diffuse.lpData != NULL) {
1157 VTRACE(("glSecondaryColor4ub: r,g,b=%f,%f,%f\n",
1158 ((specularColor >> 16) & 0xFF) / 255.0f,
1159 ((specularColor >> 8) & 0xFF) / 255.0f,
1160 ((specularColor >> 0) & 0xFF) / 255.0f));
1161 #if defined(GL_VERSION_1_4)
1162 glSecondaryColor3ub((specularColor >> 16) & 0xFF,
1163 (specularColor >> 8) & 0xFF,
1164 (specularColor >> 0) & 0xFF);
1165 #elif defined(GL_EXT_secondary_color)
1166 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
1167 GL_EXTCALL(glSecondaryColor3ubEXT)(
1168 (specularColor >> 16) & 0xFF,
1169 (specularColor >> 8) & 0xFF,
1170 (specularColor >> 0) & 0xFF);
1171 }
1172 #else
1173 /* Do not worry if specular colour missing and disable request */
1174 VTRACE(("Specular color extensions not supplied\n"));
1175 #endif
1176 } else {
1177 #if defined(GL_VERSION_1_4)
1178 if (vx_index == 0) glSecondaryColor3f(0, 0, 0);
1179 #elif defined(GL_EXT_secondary_color)
1180 if (vx_index == 0 && GL_SUPPORT(EXT_SECONDARY_COLOR)) {
1181 GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
1182 }
1183 #else
1184 /* Do not worry if specular colour missing and disable request */
1185 #endif
1186 }
1187 #endif
1188
1189 /* Normal -------------------------------- */
1190 if (sd->u.s.normal.lpData != NULL) {
1191 VTRACE(("glNormal:nx,ny,nz=%f,%f,%f\n", nx,ny,nz));
1192 glNormal3f(nx, ny, nz);
1193 } else {
1194 if (vx_index == 0) glNormal3f(0, 0, 1);
1195 }
1196
1197 /* Position -------------------------------- */
1198 if (sd->u.s.position.lpData != NULL) {
1199 if (1.0f == rhw || rhw < 0.0001f) {
1200 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z));
1201 glVertex3f(x, y, z);
1202 } else {
1203 VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw));
1204 /* Disable RHW mode as 'w' coord handling for rhw mode should
1205 not impact screen position whereas in GL it does. This may
1206 result in very slightly distored textures in rhw mode, but
1207 a very minimal different. In slow mode a possible 'fix' is
1208 glVertex4f(x*rhw,y*rhw,z*rhw,rhw) but not sure this is right */
1209 glVertex3f(x,y,z);
1210 }
1211 }
1212
1213 /* For non indexed mode, step onto next parts */
1214 if (idxData == NULL) {
1215 SkipnStrides += 1;
1216 }
1217 }
1218
1219 glEnd();
1220 checkGLcall("glEnd and previous calls");
1221 }
1222
1223 /*
1224 * Draw with emulated vertex shaders
1225 * Note: strided data is uninitialized, as we need to pass the vertex
1226 * shader directly as ordering irs yet
1227 */
1228 void drawStridedSoftwareVS(LPDIRECT3DDEVICE8 iface, Direct3DVertexStridedData *sd,
1229 int PrimitiveType, ULONG NumPrimitives,
1230 const void *idxData, short idxSize, ULONG minIndex, ULONG startIdx) {
1231
1232 int textureNo = 0;
1233 GLenum glPrimType = GL_POINTS;
1234 int NumVertexes = NumPrimitives;
1235 const short *pIdxBufS = NULL;
1236 const long *pIdxBufL = NULL;
1237 LONG SkipnStrides = 0;
1238 LONG vx_index;
1239 float x = 0.0f, y = 0.0f, z = 0.0f; /* x,y,z coordinates */
1240 float rhw = 0.0f; /* rhw */
1241 float ptSize = 0.0f; /* Point size */
1242 D3DVECTOR_4 texcoords[8]; /* Texture Coords */
1243 int numcoords[8]; /* Number of coords */
1244 ICOM_THIS(IDirect3DDevice8Impl,iface);
1245
1246 IDirect3DVertexShaderImpl* vertex_shader = NULL;
1247
1248 TRACE("Using slow software vertex shader code\n");
1249
1250 /* Variable Initialization */
1251 if (idxData != NULL) {
1252 if (idxSize == 2) pIdxBufS = (short *) idxData;
1253 else pIdxBufL = (long *) idxData;
1254 }
1255
1256 /* Ok, Work out which primitive is requested and how many vertexes that will be */
1257 NumVertexes = primitiveToGl(PrimitiveType, NumPrimitives, &glPrimType);
1258
1259 /* Retrieve the VS information */
1260 vertex_shader = VERTEX_SHADER(This->StateBlock->VertexShader);
1261
1262 /* Start drawing in GL */
1263 VTRACE(("glBegin(%x)\n", glPrimType));
1264 glBegin(glPrimType);
1265
1266 /* For each primitive */
1267 for (vx_index = 0; vx_index < NumVertexes; vx_index++) {
1268
1269 /* For indexed data, we need to go a few more strides in */
1270 if (idxData != NULL) {
1271
1272 /* Indexed so work out the number of strides to skip */
1273 if (idxSize == 2) {
1274 VTRACE(("Idx for vertex %ld = %d\n", vx_index, pIdxBufS[startIdx+vx_index]));
1275 SkipnStrides = pIdxBufS[startIdx+vx_index];
1276 } else {
1277 VTRACE(("Idx for vertex %ld = %ld\n", vx_index, pIdxBufL[startIdx+vx_index]));
1278 SkipnStrides = pIdxBufL[startIdx+vx_index];
1279 }
1280 }
1281
1282 /* Fill the vertex shader input */
1283 IDirect3DDeviceImpl_FillVertexShaderInput(This, vertex_shader, SkipnStrides);
1284
1285 /* Initialize the output fields to the same defaults as it would normally have */
1286 memset(&vertex_shader->output, 0, sizeof(VSHADEROUTPUTDATA8));
1287 vertex_shader->output.oD[0].x = 1.0;
1288 vertex_shader->output.oD[0].y = 1.0;
1289 vertex_shader->output.oD[0].z = 1.0;
1290 vertex_shader->output.oD[0].w = 1.0;
1291
1292 /* Now execute the vertex shader */
1293 IDirect3DVertexShaderImpl_ExecuteSW(vertex_shader, &vertex_shader->input, &vertex_shader->output);
1294
1295 /*
1296 TRACE_VECTOR(vertex_shader->output.oPos);
1297 TRACE_VECTOR(vertex_shader->output.oD[0]);
1298 TRACE_VECTOR(vertex_shader->output.oD[1]);
1299 TRACE_VECTOR(vertex_shader->output.oT[0]);
1300 TRACE_VECTOR(vertex_shader->output.oT[1]);
1301 TRACE_VECTOR(vertex_shader->input.V[0]);
1302 TRACE_VECTOR(vertex_shader->data->C[0]);
1303 TRACE_VECTOR(vertex_shader->data->C[1]);
1304 TRACE_VECTOR(vertex_shader->data->C[2]);
1305 TRACE_VECTOR(vertex_shader->data->C[3]);
1306 TRACE_VECTOR(vertex_shader->data->C[4]);
1307 TRACE_VECTOR(vertex_shader->data->C[5]);
1308 TRACE_VECTOR(vertex_shader->data->C[6]);
1309 TRACE_VECTOR(vertex_shader->data->C[7]);
1310 */
1311
1312 /* Extract out the output */
1313 /*FIXME: Fog coords? */
1314 x = vertex_shader->output.oPos.x;
1315 y = vertex_shader->output.oPos.y;
1316 z = vertex_shader->output.oPos.z;
1317 rhw = vertex_shader->output.oPos.w;
1318 ptSize = vertex_shader->output.oPts.x; /* Fixme - Is this right? */
1319
1320 /** Update textures coords using vertex_shader->output.oT[0->7] */
1321 memset(texcoords, 0x00, sizeof(texcoords));
1322 memset(numcoords, 0x00, sizeof(numcoords));
1323 for (textureNo = 0; textureNo < GL_LIMITS(textures); ++textureNo) {
1324 if (This->StateBlock->textures[textureNo] != NULL) {
1325 texcoords[textureNo].x = vertex_shader->output.oT[textureNo].x;
1326 texcoords[textureNo].y = vertex_shader->output.oT[textureNo].y;
1327 texcoords[textureNo].z = vertex_shader->output.oT[textureNo].z;
1328 texcoords[textureNo].w = vertex_shader->output.oT[textureNo].w;
1329 if (This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXTURETRANSFORMFLAGS] != D3DTTFF_DISABLE) {
1330 numcoords[textureNo] = This->UpdateStateBlock->texture_state[textureNo][D3DTSS_TEXTURETRANSFORMFLAGS] & ~D3DTTFF_PROJECTED;
1331 } else {
1332 switch (IDirect3DBaseTexture8Impl_GetType((LPDIRECT3DBASETEXTURE8) This->StateBlock->textures[textureNo])) {
1333 case D3DRTYPE_TEXTURE: numcoords[textureNo] = 2; break;
1334 case D3DRTYPE_VOLUMETEXTURE: numcoords[textureNo] = 3; break;
1335 default: numcoords[textureNo] = 4;
1336 }
1337 }
1338 } else {
1339 numcoords[textureNo] = 0;
1340 }
1341 }
1342
1343 /* Draw using this information */
1344 draw_vertex(iface,
1345 TRUE, x, y, z, rhw,
1346 TRUE, 0.0f, 0.0f, 1.0f,
1347 TRUE, (float*) &vertex_shader->output.oD[0],
1348 TRUE, (float*) &vertex_shader->output.oD[1],
1349 FALSE, ptSize, /* FIXME: Change back when supported */
1350 texcoords, numcoords);
1351
1352 /* For non indexed mode, step onto next parts */
1353 if (idxData == NULL) {
1354 SkipnStrides += 1;
1355 }
1356
1357 } /* for each vertex */
1358
1359 glEnd();
1360 checkGLcall("glEnd and previous calls");
1361 }
1362
1363 /* Routine common to the draw primitive and draw indexed primitive routines */
1364 void drawPrimitive(LPDIRECT3DDEVICE8 iface,
1365 int PrimitiveType, long NumPrimitives,
1366
1367 /* for Indexed: */
1368 long StartVertexIndex,
1369 long StartIdx,
1370 short idxSize,
1371 const void *idxData,
1372 int minIndex) {
1373
1374 BOOL rc = FALSE;
1375 DWORD fvf = 0;
1376 IDirect3DVertexShaderImpl *vertex_shader = NULL;
1377 BOOL useVertexShaderFunction = FALSE;
1378 BOOL isLightingOn = FALSE;
1379 Direct3DVertexStridedData dataLocations;
1380 ICOM_THIS(IDirect3DDevice8Impl,iface);
1381
1382
1383 /* Work out what the FVF should look like */
1384 rc = initializeFVF(iface, &fvf, &useVertexShaderFunction);
1385 if (rc) return;
1386
1387 /* If we will be using a vertex shader, do some initialization for it */
1388 if (useVertexShaderFunction == TRUE) {
1389 vertex_shader = VERTEX_SHADER(This->UpdateStateBlock->VertexShader);
1390 memset(&vertex_shader->input, 0, sizeof(VSHADERINPUTDATA8));
1391
1392 /** init Constants */
1393 if (TRUE == This->UpdateStateBlock->Changed.vertexShaderConstant) {
1394 TRACE_(d3d_shader)("vertex shader initializing constants\n");
1395 IDirect3DVertexShaderImpl_SetConstantF(vertex_shader, 0, (CONST FLOAT*) &This->UpdateStateBlock->vertexShaderConstant[0], 96);
1396 }
1397 }
1398
1399 /* Ok, we will be updating the screen from here onwards so grab the lock */
1400 ENTER_GL();
1401
1402 /* Setup transform matrices and sort out */
1403 isLightingOn = primitiveInitState(iface,
1404 fvf & D3DFVF_XYZRHW,
1405 !(fvf & D3DFVF_NORMAL),
1406 useVertexShaderFunction);
1407
1408 /* Initialize all values to null */
1409 if (useVertexShaderFunction == FALSE) {
1410 memset(&dataLocations, 0x00, sizeof(dataLocations));
1411
1412 /* Convert to strided data */
1413 primitiveConvertToStridedData(iface, &dataLocations, StartVertexIndex);
1414
1415 /* Dump out what parts we have supplied */
1416 TRACE("Strided Data (from FVF/VS): %lx\n", fvf);
1417 TRACE_STRIDED((&dataLocations), position);
1418 TRACE_STRIDED((&dataLocations), blendWeights);
1419 TRACE_STRIDED((&dataLocations), blendMatrixIndices);
1420 TRACE_STRIDED((&dataLocations), normal);
1421 TRACE_STRIDED((&dataLocations), pSize);
1422 TRACE_STRIDED((&dataLocations), diffuse);
1423 TRACE_STRIDED((&dataLocations), specular);
1424 TRACE_STRIDED((&dataLocations), texCoords[0]);
1425 TRACE_STRIDED((&dataLocations), texCoords[1]);
1426 TRACE_STRIDED((&dataLocations), texCoords[2]);
1427 TRACE_STRIDED((&dataLocations), texCoords[3]);
1428 TRACE_STRIDED((&dataLocations), texCoords[4]);
1429 TRACE_STRIDED((&dataLocations), texCoords[5]);
1430 TRACE_STRIDED((&dataLocations), texCoords[6]);
1431 TRACE_STRIDED((&dataLocations), texCoords[7]);
1432 }
1433
1434 /* Now initialize the materials state */
1435 init_materials(iface, (dataLocations.u.s.diffuse.lpData != NULL));
1436
1437 /* Now draw the graphics to the screen */
1438 if (useVertexShaderFunction == TRUE) {
1439
1440 /* Ideally, we should have software FV and hardware VS, possibly
1441 depending on the device type? */
1442
1443 /* We will have to use the very, very slow emulation layer */
1444 drawStridedSoftwareVS(iface, &dataLocations, PrimitiveType, NumPrimitives,
1445 idxData, idxSize, minIndex, StartIdx);
1446
1447 } else if ((dataLocations.u.s.pSize.lpData != NULL) ||
1448 (dataLocations.u.s.diffuse.lpData != NULL) ||
1449 (dataLocations.u.s.blendWeights.lpData != NULL)) {
1450
1451 /* Fixme, Ideally, only use the per-vertex code for software HAL
1452 but until opengl supports all the functions returned to setup
1453 vertex arrays, we need to drop down to the slow mechanism for
1454 certain functions */
1455
1456 /* We will have to use the slow version of GL per vertex setup */
1457 drawStridedSlow(iface, &dataLocations, PrimitiveType, NumPrimitives,
1458 idxData, idxSize, minIndex, StartIdx);
1459
1460 } else {
1461
1462 /* We can use the fast version of GL pointers */
1463 drawStridedFast(iface, &dataLocations, PrimitiveType, NumPrimitives,
1464 idxData, idxSize, minIndex, StartIdx);
1465 }
1466
1467 /* If vertex shaders or no normals, restore previous lighting state */
1468 if (useVertexShaderFunction || !(fvf & D3DFVF_NORMAL)) {
1469 if (isLightingOn) glEnable(GL_LIGHTING);
1470 else glDisable(GL_LIGHTING);
1471 TRACE("Restored lighting to original state\n");
1472 }
1473
1474 /* Finshed updating the screen, restore lock */
1475 LEAVE_GL();
1476 TRACE("Done all gl drawing\n");
1477
1478 /* Diagnostics */
1479 #if defined(SHOW_FRAME_MAKEUP)
1480 {
1481 if (isDumpingFrames == TRUE) {
1482 D3DLOCKED_RECT r;
1483 char buffer[80];
1484 IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8) This->backBuffer, &r, NULL, D3DLOCK_READONLY);
1485 sprintf(buffer, "/tmp/backbuffer_%ld.ppm", primCounter);
1486 TRACE("Saving screenshot %s\n", buffer);
1487 IDirect3DSurface8Impl_SaveSnapshot((LPDIRECT3DSURFACE8) This->backBuffer, buffer);
1488 IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8) This->backBuffer);
1489
1490 #if defined(SHOW_TEXTURE_MAKEUP)
1491 {
1492 LPDIRECT3DSURFACE8 pSur;
1493 int textureNo;
1494 for (textureNo = 0; textureNo < GL_LIMITS(textures); ++textureNo) {
1495 if (This->StateBlock->textures[textureNo] != NULL) {
1496 sprintf(buffer, "/tmp/texture_%ld_%d.ppm", primCounter, textureNo);
1497 TRACE("Saving texture %s (Format:%s)\n", buffer, debug_d3dformat(((IDirect3DBaseTexture8Impl *)This->StateBlock->textures[textureNo])->format));
1498 IDirect3DTexture8Impl_GetSurfaceLevel((LPDIRECT3DTEXTURE8) This->StateBlock->textures[textureNo], 0, &pSur);
1499 IDirect3DSurface8Impl_SaveSnapshot(pSur, buffer);
1500 IDirect3DSurface8Impl_Release(pSur);
1501 }
1502 }
1503 }
1504 #endif
1505 primCounter = primCounter + 1;
1506 }
1507 }
1508 #endif
1509 }
Windows API implementation