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