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