?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moved mode setting out of .spec file into Makefile.
[wine/gsoc_dplay.git] / dlls / ddraw / d3dexecutebuffer.c
blobbec04092e9127e7b49230d51b33fd23fdd310da3
1 /* Direct3D ExecuteBuffer
2 * Copyright (c) 1998 Lionel ULMER
3 *
4 * This file contains the implementation of Direct3DExecuteBuffer.
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 <string.h>
24
25 #include "windef.h"
26 #include "winerror.h"
27 #include "wine/obj_base.h"
28 #include "ddraw.h"
29 #include "d3d.h"
30 #include "wine/debug.h"
31
32 #include "mesa_private.h"
33
34 #define D3DDPRIVATE(x) mesa_d3dd_private *odev=((mesa_d3dd_private*)(x)->private)
35
36 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
37
38 /* Structure to store the 'semi transformed' vertices */
39 typedef struct {
40 D3DVALUE x;
41 D3DVALUE y;
42 D3DVALUE z;
43 D3DVALUE w;
44
45 D3DVALUE nx;
46 D3DVALUE ny;
47 D3DVALUE nz;
48
49 D3DVALUE u;
50 D3DVALUE v;
51 } OGL_Vertex;
52
53 typedef struct {
54 D3DVALUE x;
55 D3DVALUE y;
56 D3DVALUE z;
57 D3DVALUE w;
58
59 D3DCOLOR c;
60 D3DCOLOR sc;
61
62 D3DVALUE u;
63 D3DVALUE v;
64 } OGL_LVertex;
65
66 static ICOM_VTABLE(IDirect3DExecuteBuffer) executebuffer_vtable;
67
68 /*******************************************************************************
69 * ExecuteBuffer static functions
70 */
71 void _dump_d3dstatus(LPD3DSTATUS lpStatus) {
72
73 }
74
75 void _dump_executedata(LPD3DEXECUTEDATA lpData) {
76 DPRINTF("dwSize : %ld\n", lpData->dwSize);
77 DPRINTF("Vertex Offset : %ld Count : %ld\n", lpData->dwVertexOffset, lpData->dwVertexCount);
78 DPRINTF("Instruction Offset : %ld Length : %ld\n", lpData->dwInstructionOffset, lpData->dwInstructionLength);
79 DPRINTF("HVertex Offset : %ld\n", lpData->dwHVertexOffset);
80 _dump_d3dstatus(&(lpData->dsStatus));
81 }
82
83 #define DO_VERTEX(index) \
84 { \
85 glTexCoord2f(vx[index].u, \
86 vx[index].v); \
87 glNormal3f(vx[index].nx, \
88 vx[index].ny, \
89 vx[index].nz); \
90 glVertex4f(vx[index].x, \
91 vx[index].y, \
92 vx[index].z, \
93 vx[index].w); \
94 \
95 TRACE(" V: %f %f %f %f (%f %f %f) (%f %f)\n", \
96 vx[index].x, vx[index].y, vx[index].z, vx[index].w, \
97 vx[index].nx, vx[index].ny, vx[index].nz, \
98 vx[index].u, vx[index].v); \
99 }
100
101 #define DO_LVERTEX(index) \
102 { \
103 DWORD col = l_vx[index].c; \
104 \
105 glColor3f(((col >> 16) & 0xFF) / 255.0, \
106 ((col >> 8) & 0xFF) / 255.0, \
107 ((col >> 0) & 0xFF) / 255.0); \
108 glTexCoord2f(l_vx[index].u, \
109 l_vx[index].v); \
110 glVertex4f(l_vx[index].x, \
111 l_vx[index].y, \
112 l_vx[index].z, \
113 l_vx[index].w); \
114 \
115 TRACE(" LV: %f %f %f %f (%02lx %02lx %02lx) (%f %f)\n", \
116 l_vx[index].x, l_vx[index].y, l_vx[index].z, l_vx[index].w, \
117 ((col >> 16) & 0xFF), ((col >> 8) & 0xFF), ((col >> 0) & 0xFF), \
118 l_vx[index].u, l_vx[index].v); \
119 }
120
121 #define DO_TLVERTEX(index) \
122 { \
123 D3DTLVERTEX *vx = &(tl_vx[index]); \
124 DWORD col = vx->u5.color; \
125 \
126 glColor3f(((col >> 16) & 0xFF) / 255.0, \
127 ((col >> 8) & 0xFF) / 255.0, \
128 ((col >> 0) & 0xFF) / 255.0); \
129 glTexCoord2f(vx->u7.tu, vx->u8.tv); \
130 if (vx->u4.rhw < 0.01) \
131 glVertex3f(vx->u1.sx, \
132 vx->u2.sy, \
133 vx->u3.sz); \
134 else \
135 glVertex4f(vx->u1.sx / vx->u4.rhw, \
136 vx->u2.sy / vx->u4.rhw, \
137 vx->u3.sz / vx->u4.rhw, \
138 1.0 / vx->u4.rhw); \
139 TRACE(" TLV: %f %f %f (%02lx %02lx %02lx) (%f %f) (%f)\n", \
140 vx->u1.sx, vx->u2.sy, vx->u3.sz, \
141 ((col >> 16) & 0xFF), ((col >> 8) & 0xFF), ((col >> 0) & 0xFF), \
142 vx->u7.tu, vx->u8.tv, vx->u4.rhw); \
143 }
144
145 #define TRIANGLE_LOOP(macro) \
146 { \
147 glBegin(GL_TRIANGLES); { \
148 for (i = 0; i < count; i++) { \
149 LPD3DTRIANGLE ci = (LPD3DTRIANGLE) instr; \
150 \
151 TRACE(" v1: %d v2: %d v3: %d\n", \
152 ci->u1.v1, ci->u2.v2, ci->u3.v3); \
153 TRACE(" Flags : "); \
154 if (TRACE_ON(ddraw)) { \
155 /* Wireframe */ \
156 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1) \
157 DPRINTF("EDGEENABLE1 "); \
158 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE2) \
159 DPRINTF("EDGEENABLE2 "); \
160 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1) \
161 DPRINTF("EDGEENABLE3 "); \
162 \
163 /* Strips / Fans */ \
164 if (ci->wFlags == D3DTRIFLAG_EVEN) \
165 DPRINTF("EVEN "); \
166 if (ci->wFlags == D3DTRIFLAG_ODD) \
167 DPRINTF("ODD "); \
168 if (ci->wFlags == D3DTRIFLAG_START) \
169 DPRINTF("START "); \
170 if ((ci->wFlags > 0) && (ci->wFlags < 30)) \
171 DPRINTF("STARTFLAT(%d) ", ci->wFlags); \
172 DPRINTF("\n"); \
173 } \
174 \
175 /* Draw the triangle */ \
176 macro(ci->u1.v1); \
177 macro(ci->u2.v2); \
178 macro(ci->u3.v3); \
179 \
180 instr += size; \
181 } \
182 } glEnd(); \
183 }
184
185
186 static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
187 LPDIRECT3DDEVICE dev,
188 LPDIRECT3DVIEWPORT vp) {
189 IDirect3DExecuteBufferImpl* ilpBuff=(IDirect3DExecuteBufferImpl*)lpBuff;
190 IDirect3DViewport2Impl* ivp=(IDirect3DViewport2Impl*)vp;
191 /* DWORD bs = ilpBuff->desc.dwBufferSize; */
192 DWORD vs = ilpBuff->data.dwVertexOffset;
193 /* DWORD vc = ilpBuff->data.dwVertexCount; */
194 DWORD is = ilpBuff->data.dwInstructionOffset;
195 /* DWORD il = ilpBuff->data.dwInstructionLength; */
196
197 void *instr = ilpBuff->desc.lpData + is;
198 D3DDPRIVATE((IDirect3DDeviceImpl*)dev);
199
200 TRACE("ExecuteData : \n");
201 if (TRACE_ON(ddraw))
202 _dump_executedata(&(ilpBuff->data));
203
204 ENTER_GL();
205
206 while (1) {
207 LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr;
208 BYTE size;
209 WORD count;
210
211 count = current->wCount;
212 size = current->bSize;
213 instr += sizeof(D3DINSTRUCTION);
214
215 switch (current->bOpcode) {
216 case D3DOP_POINT: {
217 TRACE("POINT-s (%d)\n", count);
218
219 instr += count * size;
220 } break;
221
222 case D3DOP_LINE: {
223 TRACE("LINE-s (%d)\n", count);
224
225 instr += count * size;
226 } break;
227
228 case D3DOP_TRIANGLE: {
229 int i;
230 float z_inv_matrix[16] = {
231 1.0, 0.0, 0.0, 0.0,
232 0.0, 1.0, 0.0, 0.0,
233 0.0, 0.0, -1.0, 0.0,
234 0.0, 0.0, 1.0, 1.0
235 };
236
237 OGL_Vertex *vx = (OGL_Vertex *) ilpBuff->vertex_data;
238 OGL_LVertex *l_vx = (OGL_LVertex *) ilpBuff->vertex_data;
239 D3DTLVERTEX *tl_vx = (D3DTLVERTEX *) ilpBuff->vertex_data;
240
241 TRACE("TRIANGLE (%d)\n", count);
242
243 switch (ilpBuff->vertex_type) {
244 case D3DVT_VERTEX:
245 /* This time, there is lighting */
246 glEnable(GL_LIGHTING);
247
248 /* Use given matrixes */
249 glMatrixMode(GL_MODELVIEW);
250 glLoadIdentity(); /* The model transformation was done during the
251 transformation phase */
252 glMatrixMode(GL_PROJECTION);
253 TRACE(" Projection Matrix : (%p)\n", odev->proj_mat);
254 dump_mat(odev->proj_mat);
255 TRACE(" View Matrix : (%p)\n", odev->view_mat);
256 dump_mat(odev->view_mat);
257
258 glLoadMatrixf((float *) z_inv_matrix);
259 glMultMatrixf((float *) odev->proj_mat);
260 glMultMatrixf((float *) odev->view_mat);
261 break;
262
263 case D3DVT_LVERTEX:
264 /* No lighting */
265 glDisable(GL_LIGHTING);
266
267 /* Use given matrixes */
268 glMatrixMode(GL_MODELVIEW);
269 glLoadIdentity(); /* The model transformation was done during the
270 transformation phase */
271 glMatrixMode(GL_PROJECTION);
272
273 TRACE(" Projection Matrix : (%p)\n", odev->proj_mat);
274 dump_mat(odev->proj_mat);
275 TRACE(" View Matrix : (%p)\n", odev->view_mat);
276 dump_mat(odev->view_mat);
277
278 glLoadMatrixf((float *) z_inv_matrix);
279 glMultMatrixf((float *) odev->proj_mat);
280 glMultMatrixf((float *) odev->view_mat);
281 break;
282
283 case D3DVT_TLVERTEX: {
284 GLdouble height, width, minZ, maxZ;
285
286 /* First, disable lighting */
287 glDisable(GL_LIGHTING);
288
289 /* Then do not put any transformation matrixes */
290 glMatrixMode(GL_MODELVIEW);
291 glLoadIdentity();
292 glMatrixMode(GL_PROJECTION);
293 glLoadIdentity();
294
295 if (ivp == NULL) {
296 ERR("No current viewport !\n");
297 /* Using standard values */
298 height = 640.0;
299 width = 480.0;
300 minZ = -10.0;
301 maxZ = 10.0;
302 } else {
303 height = (GLdouble) ivp->viewport.vp1.dwHeight;
304 width = (GLdouble) ivp->viewport.vp1.dwWidth;
305 minZ = (GLdouble) ivp->viewport.vp1.dvMinZ;
306 maxZ = (GLdouble) ivp->viewport.vp1.dvMaxZ;
307
308 if (minZ == maxZ) {
309 /* I do not know why, but many Dx 3.0 games have minZ = maxZ = 0.0 */
310 minZ = 0.0;
311 maxZ = 1.0;
312 }
313 }
314
315 glOrtho(0.0, width, height, 0.0, -minZ, -maxZ);
316 } break;
317
318 default:
319 ERR("Unhandled vertex type !\n");
320 break;
321 }
322
323 switch (ilpBuff->vertex_type) {
324 case D3DVT_VERTEX:
325 TRIANGLE_LOOP(DO_VERTEX);
326 break;
327
328 case D3DVT_LVERTEX:
329 TRIANGLE_LOOP(DO_LVERTEX);
330 break;
331
332 case D3DVT_TLVERTEX:
333 TRIANGLE_LOOP(DO_TLVERTEX);
334 break;
335
336 default:
337 ERR("Unhandled vertex type !\n");
338 }
339
340 } break;
341
342 case D3DOP_MATRIXLOAD: {
343 TRACE("MATRIXLOAD-s (%d)\n", count);
344
345 instr += count * size;
346 } break;
347
348 case D3DOP_MATRIXMULTIPLY: {
349 int i;
350 TRACE("MATRIXMULTIPLY (%d)\n", count);
351
352 for (i = 0; i < count; i++) {
353 LPD3DMATRIXMULTIPLY ci = (LPD3DMATRIXMULTIPLY) instr;
354 LPD3DMATRIX a = (LPD3DMATRIX) ci->hDestMatrix;
355 LPD3DMATRIX b = (LPD3DMATRIX) ci->hSrcMatrix1;
356 LPD3DMATRIX c = (LPD3DMATRIX) ci->hSrcMatrix2;
357
358 TRACE(" Dest : %08lx Src1 : %08lx Src2 : %08lx\n",
359 ci->hDestMatrix, ci->hSrcMatrix1, ci->hSrcMatrix2);
360
361 /* Do the multiplication..
362 As I am VERY lazy, I let OpenGL do the multiplication for me */
363 glMatrixMode(GL_PROJECTION);
364 /* Save the current matrix */
365 glPushMatrix();
366 /* Load Matrix one and do the multiplication */
367 glLoadMatrixf((float *) c);
368 glMultMatrixf((float *) b);
369 glGetFloatv(GL_PROJECTION_MATRIX, (float *) a);
370 /* Restore the current matrix */
371 glPopMatrix();
372
373 instr += size;
374 }
375 } break;
376
377 case D3DOP_STATETRANSFORM: {
378 int i;
379 TRACE("STATETRANSFORM (%d)\n", count);
380
381 for (i = 0; i < count; i++) {
382 LPD3DSTATE ci = (LPD3DSTATE) instr;
383
384 /* Handle the state transform */
385 switch (ci->u1.dtstTransformStateType) {
386 case D3DTRANSFORMSTATE_WORLD: {
387 TRACE(" WORLD (%p)\n", (D3DMATRIX*) ci->u2.dwArg[0]);
388 odev->world_mat = (D3DMATRIX*) ci->u2.dwArg[0];
389 } break;
390
391 case D3DTRANSFORMSTATE_VIEW: {
392 TRACE(" VIEW (%p)\n", (D3DMATRIX*) ci->u2.dwArg[0]);
393 odev->view_mat = (D3DMATRIX*) ci->u2.dwArg[0];
394 } break;
395
396 case D3DTRANSFORMSTATE_PROJECTION: {
397 TRACE(" PROJECTION (%p)\n", (D3DMATRIX*) ci->u2.dwArg[0]);
398 odev->proj_mat = (D3DMATRIX*) ci->u2.dwArg[0];
399 } break;
400
401 default:
402 ERR(" Unhandled state transformation !! (%d)\n", (int) ci->u1.dtstTransformStateType);
403 break;
404
405 }
406
407 instr += size;
408 }
409 } break;
410
411 case D3DOP_STATELIGHT: {
412 int i;
413 TRACE("STATELIGHT (%d)\n", count);
414
415 for (i = 0; i < count; i++) {
416 LPD3DSTATE ci = (LPD3DSTATE) instr;
417
418 /* Handle the state transform */
419 switch (ci->u1.dlstLightStateType) {
420 case D3DLIGHTSTATE_MATERIAL: {
421 IDirect3DMaterial2Impl* mat = (IDirect3DMaterial2Impl*) ci->u2.dwArg[0];
422 TRACE(" MATERIAL\n");
423
424 if (mat != NULL) {
425 mat->activate(mat);
426 } else {
427 TRACE(" bad Material Handle\n");
428 }
429 } break ;
430
431 case D3DLIGHTSTATE_AMBIENT: {
432 float light[4];
433 DWORD dwLightState = ci->u2.dwArg[0];
434 TRACE(" AMBIENT\n");
435
436 light[0] = ((dwLightState >> 16) & 0xFF) / 255.0;
437 light[1] = ((dwLightState >> 8) & 0xFF) / 255.0;
438 light[2] = ((dwLightState >> 0) & 0xFF) / 255.0;
439 light[3] = 1.0;
440 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, (float *) light);
441
442 TRACE(" R:%02lx G:%02lx B:%02lx A:%02lx\n",
443 ((dwLightState >> 16) & 0xFF),
444 ((dwLightState >> 8) & 0xFF),
445 ((dwLightState >> 0) & 0xFF),
446 ((dwLightState >> 24) & 0xFF));
447 } break ;
448
449 case D3DLIGHTSTATE_COLORMODEL: {
450 TRACE(" COLORMODEL\n");
451 } break ;
452
453 case D3DLIGHTSTATE_FOGMODE: {
454 TRACE(" FOGMODE\n");
455 } break ;
456
457 case D3DLIGHTSTATE_FOGSTART: {
458 TRACE(" FOGSTART\n");
459 } break ;
460
461 case D3DLIGHTSTATE_FOGEND: {
462 TRACE(" FOGEND\n");
463 } break ;
464
465 case D3DLIGHTSTATE_FOGDENSITY: {
466 TRACE(" FOGDENSITY\n");
467 } break ;
468
469 default:
470 ERR(" Unhandled light state !! (%d)\n", (int) ci->u1.dlstLightStateType);
471 break;
472 }
473 instr += size;
474 }
475 } break;
476
477 case D3DOP_STATERENDER: {
478 int i;
479 TRACE("STATERENDER (%d)\n", count);
480
481 for (i = 0; i < count; i++) {
482 LPD3DSTATE ci = (LPD3DSTATE) instr;
483
484 /* Handle the state transform */
485 set_render_state(ci->u1.drstRenderStateType, ci->u2.dwArg[0], &(odev->rs));
486
487 instr += size;
488 }
489 } break;
490
491 case D3DOP_PROCESSVERTICES: {
492 int i;
493 TRACE("PROCESSVERTICES (%d)\n", count);
494
495 for (i = 0; i < count; i++) {
496 LPD3DPROCESSVERTICES ci = (LPD3DPROCESSVERTICES) instr;
497
498 TRACE(" Start : %d Dest : %d Count : %ld\n",
499 ci->wStart, ci->wDest, ci->dwCount);
500 TRACE(" Flags : ");
501 if (TRACE_ON(ddraw)) {
502 if (ci->dwFlags & D3DPROCESSVERTICES_COPY)
503 DPRINTF("COPY ");
504 if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
505 DPRINTF("NOCOLOR ");
506 if (ci->dwFlags == D3DPROCESSVERTICES_OPMASK)
507 DPRINTF("OPMASK ");
508 if (ci->dwFlags & D3DPROCESSVERTICES_TRANSFORM)
509 DPRINTF("TRANSFORM ");
510 if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT)
511 DPRINTF("TRANSFORMLIGHT ");
512 if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
513 DPRINTF("UPDATEEXTENTS ");
514 DPRINTF("\n");
515 }
516
517 /* This is where doing Direct3D on top on OpenGL is quite difficult.
518 This method transforms a set of vertices using the CURRENT state
519 (lighting, projection, ...) but does not rasterize them.
520 They will only be put on screen later (with the POINT / LINE and
521 TRIANGLE op-codes). The problem is that you can have a triangle
522 with each point having been transformed using another state...
523
524 In this implementation, I will emulate only ONE thing : each
525 vertex can have its own "WORLD" transformation (this is used in the
526 TWIST.EXE demo of the 5.2 SDK). I suppose that all vertices of the
527 execute buffer use the same state.
528
529 If I find applications that change other states, I will try to do a
530 more 'fine-tuned' state emulation (but I may become quite tricky if
531 it changes a light position in the middle of a triangle).
532
533 In this case, a 'direct' approach (i.e. without using OpenGL, but
534 writing our own 3D rasterizer) would be easier. */
535
536 /* The current method (with the hypothesis that only the WORLD matrix
537 will change between two points) is like this :
538 - I transform 'manually' all the vertices with the current WORLD
539 matrix and store them in the vertex buffer
540 - during the rasterization phase, the WORLD matrix will be set to
541 the Identity matrix */
542
543 /* Enough for the moment */
544 if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) {
545 int nb;
546 D3DVERTEX *src = ((LPD3DVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
547 OGL_Vertex *dst = ((OGL_Vertex *) (ilpBuff->vertex_data)) + ci->wDest;
548 D3DMATRIX *mat = odev->world_mat;
549
550 TRACE(" World Matrix : (%p)\n", mat);
551 dump_mat(mat);
552
553 ilpBuff->vertex_type = D3DVT_VERTEX;
554
555 for (nb = 0; nb < ci->dwCount; nb++) {
556 /* For the moment, no normal transformation... */
557 dst->nx = src->u4.nx;
558 dst->ny = src->u5.ny;
559 dst->nz = src->u6.nz;
560
561 dst->u = src->u7.tu;
562 dst->v = src->u8.tv;
563
564 /* Now, the matrix multiplication */
565 dst->x = (src->u1.x * mat->_11) + (src->u2.y * mat->_21) + (src->u3.z * mat->_31) + (1.0 * mat->_41);
566 dst->y = (src->u1.x * mat->_12) + (src->u2.y * mat->_22) + (src->u3.z * mat->_32) + (1.0 * mat->_42);
567 dst->z = (src->u1.x * mat->_13) + (src->u2.y * mat->_23) + (src->u3.z * mat->_33) + (1.0 * mat->_43);
568 dst->w = (src->u1.x * mat->_14) + (src->u2.y * mat->_24) + (src->u3.z * mat->_34) + (1.0 * mat->_44);
569
570 src++;
571 dst++;
572 }
573 } else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) {
574 int nb;
575 D3DLVERTEX *src = ((LPD3DLVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
576 OGL_LVertex *dst = ((OGL_LVertex *) (ilpBuff->vertex_data)) + ci->wDest;
577 D3DMATRIX *mat = odev->world_mat;
578
579 TRACE(" World Matrix : (%p)\n", mat);
580 dump_mat(mat);
581
582 ilpBuff->vertex_type = D3DVT_LVERTEX;
583
584 for (nb = 0; nb < ci->dwCount; nb++) {
585 dst->c = src->u4.color;
586 dst->sc = src->u5.specular;
587 dst->u = src->u6.tu;
588 dst->v = src->u7.tv;
589
590 /* Now, the matrix multiplication */
591 dst->x = (src->u1.x * mat->_11) + (src->u2.y * mat->_21) + (src->u3.z * mat->_31) + (1.0 * mat->_41);
592 dst->y = (src->u1.x * mat->_12) + (src->u2.y * mat->_22) + (src->u3.z * mat->_32) + (1.0 * mat->_42);
593 dst->z = (src->u1.x * mat->_13) + (src->u2.y * mat->_23) + (src->u3.z * mat->_33) + (1.0 * mat->_43);
594 dst->w = (src->u1.x * mat->_14) + (src->u2.y * mat->_24) + (src->u3.z * mat->_34) + (1.0 * mat->_44);
595
596 src++;
597 dst++;
598 }
599 } else if (ci->dwFlags == D3DPROCESSVERTICES_COPY) {
600 D3DTLVERTEX *src = ((LPD3DTLVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
601 D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (ilpBuff->vertex_data)) + ci->wDest;
602
603 ilpBuff->vertex_type = D3DVT_TLVERTEX;
604
605 memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX));
606 } else {
607 ERR("Unhandled vertex processing !\n");
608 }
609
610 instr += size;
611 }
612 } break;
613
614 case D3DOP_TEXTURELOAD: {
615 TRACE("TEXTURELOAD-s (%d)\n", count);
616
617 instr += count * size;
618 } break;
619
620 case D3DOP_EXIT: {
621 TRACE("EXIT (%d)\n", count);
622 /* We did this instruction */
623 instr += size;
624 /* Exit this loop */
625 goto end_of_buffer;
626 } break;
627
628 case D3DOP_BRANCHFORWARD: {
629 int i;
630 TRACE("BRANCHFORWARD (%d)\n", count);
631
632 for (i = 0; i < count; i++) {
633 LPD3DBRANCH ci = (LPD3DBRANCH) instr;
634
635 if ((ilpBuff->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue) {
636 if (!ci->bNegate) {
637 TRACE(" Should branch to %ld\n", ci->dwOffset);
638 }
639 } else {
640 if (ci->bNegate) {
641 TRACE(" Should branch to %ld\n", ci->dwOffset);
642 }
643 }
644
645 instr += size;
646 }
647 } break;
648
649 case D3DOP_SPAN: {
650 TRACE("SPAN-s (%d)\n", count);
651
652 instr += count * size;
653 } break;
654
655 case D3DOP_SETSTATUS: {
656 int i;
657 TRACE("SETSTATUS (%d)\n", count);
658
659 for (i = 0; i < count; i++) {
660 LPD3DSTATUS ci = (LPD3DSTATUS) instr;
661
662 ilpBuff->data.dsStatus = *ci;
663
664 instr += size;
665 }
666 } break;
667
668 default:
669 ERR("Unhandled OpCode !!!\n");
670 /* Try to save ... */
671 instr += count * size;
672 break;
673 }
674 }
675
676 end_of_buffer:
677 LEAVE_GL();
678 }
679
680 /*******************************************************************************
681 * ExecuteBuffer Creation functions
682 */
683 LPDIRECT3DEXECUTEBUFFER d3dexecutebuffer_create(IDirect3DDeviceImpl* d3ddev, LPD3DEXECUTEBUFFERDESC lpDesc)
684 {
685 IDirect3DExecuteBufferImpl* eb;
686
687 eb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DExecuteBufferImpl));
688 eb->ref = 1;
689 ICOM_VTBL(eb) = &executebuffer_vtable;
690 eb->d3ddev = d3ddev;
691
692 /* Initializes memory */
693 eb->desc = *lpDesc;
694
695 /* No buffer given */
696 if (!(eb->desc.dwFlags & D3DDEB_LPDATA))
697 eb->desc.lpData = NULL;
698
699 /* No buffer size given */
700 if (!(lpDesc->dwFlags & D3DDEB_BUFSIZE))
701 eb->desc.dwBufferSize = 0;
702
703 /* Create buffer if asked */
704 if ((eb->desc.lpData == NULL) && (eb->desc.dwBufferSize > 0)) {
705 eb->need_free = TRUE;
706 eb->desc.lpData = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,eb->desc.dwBufferSize);
707 } else {
708 eb->need_free = FALSE;
709 }
710
711 /* No vertices for the moment */
712 eb->vertex_data = NULL;
713
714 eb->desc.dwFlags |= D3DDEB_LPDATA;
715
716 eb->execute = execute;
717
718 return (LPDIRECT3DEXECUTEBUFFER)eb;
719 }
720
721 /*******************************************************************************
722 * IDirect3ExecuteBuffer methods
723 */
724
725 static HRESULT WINAPI IDirect3DExecuteBufferImpl_QueryInterface(LPDIRECT3DEXECUTEBUFFER iface,
726 REFIID riid,
727 LPVOID* ppvObj)
728 {
729 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
730
731 FIXME("(%p)->(%s,%p): stub\n", This, debugstr_guid(riid),ppvObj);
732
733 return S_OK;
734 }
735
736
737
738 static ULONG WINAPI IDirect3DExecuteBufferImpl_AddRef(LPDIRECT3DEXECUTEBUFFER iface)
739 {
740 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
741 TRACE("(%p)->()incrementing from %lu.\n", This, This->ref );
742
743 return ++(This->ref);
744 }
745
746
747
748 static ULONG WINAPI IDirect3DExecuteBufferImpl_Release(LPDIRECT3DEXECUTEBUFFER iface)
749 {
750 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
751 FIXME("(%p)->() decrementing from %lu.\n", This, This->ref );
752
753 if (!--(This->ref)) {
754 if ((This->desc.lpData != NULL) && This->need_free)
755 HeapFree(GetProcessHeap(),0,This->desc.lpData);
756
757 if (This->vertex_data != NULL)
758 HeapFree(GetProcessHeap(),0,This->vertex_data);
759
760 HeapFree(GetProcessHeap(),0,This);
761 return 0;
762 }
763
764 return This->ref;
765 }
766
767 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Initialize(LPDIRECT3DEXECUTEBUFFER iface,
768 LPDIRECT3DDEVICE lpDirect3DDevice,
769 LPD3DEXECUTEBUFFERDESC lpDesc)
770 {
771 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
772 FIXME("(%p)->(%p,%p): stub\n", This, lpDirect3DDevice, lpDesc);
773
774 return DD_OK;
775 }
776
777 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Lock(LPDIRECT3DEXECUTEBUFFER iface,
778 LPD3DEXECUTEBUFFERDESC lpDesc)
779 {
780 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
781 TRACE("(%p)->(%p)\n", This, lpDesc);
782
783 /* Copies the buffer description */
784 *lpDesc = This->desc;
785
786 return DD_OK;
787 }
788
789 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Unlock(LPDIRECT3DEXECUTEBUFFER iface)
790 {
791 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
792 TRACE("(%p)->()\n", This);
793
794 return DD_OK;
795 }
796
797 static HRESULT WINAPI IDirect3DExecuteBufferImpl_SetExecuteData(LPDIRECT3DEXECUTEBUFFER iface,
798 LPD3DEXECUTEDATA lpData)
799 {
800 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
801 DWORD nbvert;
802
803 TRACE("(%p)->(%p)\n", This, lpData);
804
805 This->data = *lpData;
806
807 /* Get the number of vertices in the execute buffer */
808 nbvert = This->data.dwVertexCount;
809
810 /* Prepares the transformed vertex buffer */
811 if (This->vertex_data != NULL)
812 HeapFree(GetProcessHeap(), 0, This->vertex_data);
813 This->vertex_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,nbvert * sizeof(OGL_Vertex));
814
815
816 if (TRACE_ON(ddraw)) {
817 _dump_executedata(lpData);
818 }
819
820 return DD_OK;
821 }
822
823 static HRESULT WINAPI IDirect3DExecuteBufferImpl_GetExecuteData(LPDIRECT3DEXECUTEBUFFER iface,
824 LPD3DEXECUTEDATA lpData)
825 {
826 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
827 TRACE("(%p)->(%p): stub\n", This, lpData);
828
829 *lpData = This->data;
830
831 return DD_OK;
832 }
833
834 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Validate(LPDIRECT3DEXECUTEBUFFER iface,
835 LPDWORD lpdwOffset,
836 LPD3DVALIDATECALLBACK lpFunc,
837 LPVOID lpUserArg,
838 DWORD dwReserved)
839 {
840 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
841 TRACE("(%p)->(%p,%p,%p,%lu)\n", This, lpdwOffset, lpFunc, lpUserArg, dwReserved);
842
843 return DD_OK;
844 }
845
846 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Optimize(LPDIRECT3DEXECUTEBUFFER iface,
847 DWORD dwReserved)
848 {
849 ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
850 TRACE("(%p)->(%lu)\n", This, dwReserved);
851
852 return DD_OK;
853 }
854
855
856 /*******************************************************************************
857 * IDirect3DLight VTable
858 */
859 static ICOM_VTABLE(IDirect3DExecuteBuffer) executebuffer_vtable =
860 {
861 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
862 /*** IUnknown methods ***/
863 IDirect3DExecuteBufferImpl_QueryInterface,
864 IDirect3DExecuteBufferImpl_AddRef,
865 IDirect3DExecuteBufferImpl_Release,
866 /*** IDirect3DExecuteBuffer methods ***/
867 IDirect3DExecuteBufferImpl_Initialize,
868 IDirect3DExecuteBufferImpl_Lock,
869 IDirect3DExecuteBufferImpl_Unlock,
870 IDirect3DExecuteBufferImpl_SetExecuteData,
871 IDirect3DExecuteBufferImpl_GetExecuteData,
872 IDirect3DExecuteBufferImpl_Validate,
873 IDirect3DExecuteBufferImpl_Optimize
874 };
DirectPlay implementation for GSoC