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