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