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