2 * IWineD3DDevice implementation
4 * Copyright 2002-2005 Jason Edmeades
5 * Copyright 2003-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
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.
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.
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
28 #include "wined3d_private.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
31 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
33 /* x11drv GDI escapes */
34 #define X11DRV_ESCAPE 6789
35 enum x11drv_escape_codes
37 X11DRV_GET_DISPLAY, /* get X11 display for a DC */
38 X11DRV_GET_DRAWABLE, /* get current drawable for a DC */
39 X11DRV_GET_FONT, /* get current X font for a DC */
42 /* retrieve the X display to use on a given DC */
43 inline static Display *get_display( HDC hdc )
46 enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY;
48 if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
49 sizeof(display), (LPSTR)&display )) display = NULL;
53 /* Memory tracking and object counting */
54 static unsigned int emulated_textureram = 64*1024*1024;
56 /* TODO: setup some flags in the regestry to enable, disable pbuffer support */
57 /* enable pbuffer support for offscreen textures */
58 BOOL pbuffer_support = FALSE;
59 /* allocate one pbuffer per surface */
60 BOOL pbuffer_per_surface = FALSE;
62 /* static function declarations */
63 static void WINAPI IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource);
65 static void WINAPI IWineD3DDeviceImpl_ApplyTextureUnitState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type);
68 #define D3DMEMCHECK(object, ppResult) if(NULL == object) { *ppResult = NULL; WARN("Out of memory\n"); return D3DERR_OUTOFVIDEOMEMORY;}
70 #define D3DCREATEOBJECTINSTANCE(object, type) { \
71 object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
72 D3DMEMCHECK(object, pp##type); \
73 object->lpVtbl = &IWineD3D##type##_Vtbl; \
74 object->wineD3DDevice = This; \
75 object->parent = parent; \
77 *pp##type = (IWineD3D##type *) object; \
80 #define D3DCREATERESOURCEOBJECTINSTANCE(object, type, d3dtype, _size){ \
81 object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
82 D3DMEMCHECK(object, pp##type); \
83 object->lpVtbl = &IWineD3D##type##_Vtbl; \
84 object->resource.wineD3DDevice = This; \
85 object->resource.parent = parent; \
86 object->resource.resourceType = d3dtype; \
87 object->resource.ref = 1; \
88 object->resource.pool = Pool; \
89 object->resource.format = Format; \
90 object->resource.usage = Usage; \
91 object->resource.size = _size; \
92 /* Check that we have enough video ram left */ \
93 if (Pool == WINED3DPOOL_DEFAULT) { \
94 if (IWineD3DDevice_GetAvailableTextureMem(iface) <= _size) { \
95 WARN("Out of 'bogus' video memory\n"); \
96 HeapFree(GetProcessHeap(), 0, object); \
98 return D3DERR_OUTOFVIDEOMEMORY; \
100 globalChangeGlRam(_size); \
102 object->resource.allocatedMemory = (0 == _size ? NULL : Pool == WINED3DPOOL_DEFAULT ? NULL : HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, _size)); \
103 if (object->resource.allocatedMemory == NULL && _size != 0 && Pool != WINED3DPOOL_DEFAULT) { \
104 FIXME("Out of memory!\n"); \
105 HeapFree(GetProcessHeap(), 0, object); \
107 return D3DERR_OUTOFVIDEOMEMORY; \
109 *pp##type = (IWineD3D##type *) object; \
110 IWineD3DDeviceImpl_AddResource(iface, (IWineD3DResource *)object) ;\
111 TRACE("(%p) : Created resource %p\n", This, object); \
114 #define D3DINITIALIZEBASETEXTURE(_basetexture) { \
115 _basetexture.levels = Levels; \
116 _basetexture.filterType = (Usage & WINED3DUSAGE_AUTOGENMIPMAP) ? D3DTEXF_LINEAR : D3DTEXF_NONE; \
117 _basetexture.LOD = 0; \
118 _basetexture.dirty = TRUE; \
121 /**********************************************************
122 * Global variable / Constants follow
123 **********************************************************/
124 const float identity[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1}; /* When needed for comparisons */
126 /**********************************************************
127 * Utility functions follow
128 **********************************************************/
129 /* Convert the D3DLIGHT properties into equivalent gl lights */
130 static void setup_light(IWineD3DDevice *iface, LONG Index, PLIGHTINFOEL *lightInfo) {
133 float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
134 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
136 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
137 glMatrixMode(GL_MODELVIEW);
139 glLoadMatrixf((float *)&This->stateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
142 colRGBA[0] = lightInfo->OriginalParms.Diffuse.r;
143 colRGBA[1] = lightInfo->OriginalParms.Diffuse.g;
144 colRGBA[2] = lightInfo->OriginalParms.Diffuse.b;
145 colRGBA[3] = lightInfo->OriginalParms.Diffuse.a;
146 glLightfv(GL_LIGHT0+Index, GL_DIFFUSE, colRGBA);
147 checkGLcall("glLightfv");
150 colRGBA[0] = lightInfo->OriginalParms.Specular.r;
151 colRGBA[1] = lightInfo->OriginalParms.Specular.g;
152 colRGBA[2] = lightInfo->OriginalParms.Specular.b;
153 colRGBA[3] = lightInfo->OriginalParms.Specular.a;
154 glLightfv(GL_LIGHT0+Index, GL_SPECULAR, colRGBA);
155 checkGLcall("glLightfv");
158 colRGBA[0] = lightInfo->OriginalParms.Ambient.r;
159 colRGBA[1] = lightInfo->OriginalParms.Ambient.g;
160 colRGBA[2] = lightInfo->OriginalParms.Ambient.b;
161 colRGBA[3] = lightInfo->OriginalParms.Ambient.a;
162 glLightfv(GL_LIGHT0+Index, GL_AMBIENT, colRGBA);
163 checkGLcall("glLightfv");
165 /* Attenuation - Are these right? guessing... */
166 glLightf(GL_LIGHT0+Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
167 checkGLcall("glLightf");
168 glLightf(GL_LIGHT0+Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
169 checkGLcall("glLightf");
171 if ((lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range) >= FLT_MIN) {
172 quad_att = 1.4/(lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range);
174 quad_att = 0; /* 0 or MAX? (0 seems to be ok) */
177 if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
178 glLightf(GL_LIGHT0+Index, GL_QUADRATIC_ATTENUATION, quad_att);
179 checkGLcall("glLightf");
181 switch (lightInfo->OriginalParms.Type) {
184 glLightfv(GL_LIGHT0+Index, GL_POSITION, &lightInfo->lightPosn[0]);
185 checkGLcall("glLightfv");
186 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
187 checkGLcall("glLightf");
193 glLightfv(GL_LIGHT0+Index, GL_POSITION, &lightInfo->lightPosn[0]);
194 checkGLcall("glLightfv");
196 glLightfv(GL_LIGHT0+Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]);
197 checkGLcall("glLightfv");
198 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent);
199 checkGLcall("glLightf");
200 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
201 checkGLcall("glLightf");
205 case D3DLIGHT_DIRECTIONAL:
207 glLightfv(GL_LIGHT0+Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */
208 checkGLcall("glLightfv");
209 glLightf(GL_LIGHT0+Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
210 checkGLcall("glLightf");
211 glLightf(GL_LIGHT0+Index, GL_SPOT_EXPONENT, 0.0f);
212 checkGLcall("glLightf");
216 FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type);
219 /* Restore the modelview matrix */
223 /* Apply the current values to the specified texture stage */
224 void WINAPI IWineD3DDeviceImpl_SetupTextureStates(IWineD3DDevice *iface, DWORD Sampler, DWORD Flags) {
225 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
233 /* In addition, IDirect3DDevice9::SetSamplerState will now be used for filtering, tiling,
234 clamping, MIPLOD, etc. This will work for up to 16 samplers.
237 if (Sampler >= GL_LIMITS(samplers)) {
238 FIXME("Trying to set the state of more samplers %ld than are supported %d by this openGL implementation\n", Sampler, GL_LIMITS(samplers));
241 VTRACE(("Activating appropriate texture state %ld\n", Sampler));
242 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
244 GLACTIVETEXTURE(Sampler);
246 /* Could we use bindTexture and then apply the states instead of GLACTIVETEXTURE */
247 } else if (Sampler > 0) {
248 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
252 /* TODO: change this to a lookup table
253 LOOKUP_TEXTURE_STATES lists all texture states that should be applied.
254 LOOKUP_CONTEXT_SATES list all context applicable states that can be applied
255 etc.... it's a lot cleaner, quicker and possibly easier to maintain than running a switch and setting a skip flag...
256 especially when there are a number of groups of states. */
258 TRACE("-----------------------> Updating the texture at Sampler %ld to have new texture state information\n", Sampler);
260 /* The list of states not to apply is a big as the list of states to apply, so it makes sense to produce an inclusive list */
261 #define APPLY_STATE(_state) IWineD3DDeviceImpl_ApplyTextureUnitState(iface, Sampler, _state)
262 /* these are the only two supported states that need to be applied */
263 APPLY_STATE(WINED3DTSS_TEXCOORDINDEX);
264 APPLY_STATE(WINED3DTSS_TEXTURETRANSFORMFLAGS);
265 #if 0 /* not supported at the moment */
266 APPLY_STATE(WINED3DTSS_BUMPENVMAT00);
267 APPLY_STATE(WINED3DTSS_BUMPENVMAT01);
268 APPLY_STATE(WINED3DTSS_BUMPENVMAT10);
269 APPLY_STATE(WINED3DTSS_BUMPENVMAT11);
270 APPLY_STATE(WINED3DTSS_BUMPENVLSCALE);
271 APPLY_STATE(WINED3DTSS_BUMPENVLOFFSET);
272 APPLY_STATE(WINED3DTSS_RESULTARG);
273 APPLY_STATE(WINED3DTSS_CONSTANT);
275 /* a quick sanity check in case someone forgot to update this function */
276 if (WINED3D_HIGHEST_TEXTURE_STATE > WINED3DTSS_CONSTANT) {
277 FIXME("(%p) : There are more texture states than expected, update device.c to match\n", This);
281 /* apply any sampler states that always need applying */
282 if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
283 tmpvalue.d = This->stateBlock->samplerState[Sampler][WINED3DSAMP_MIPMAPLODBIAS];
284 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
285 GL_TEXTURE_LOD_BIAS_EXT,
287 checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
290 /* Note the D3DRS value applies to all textures, but GL has one
291 * per texture, so apply it now ready to be used!
293 D3DCOLORTOGLFLOAT4(This->stateBlock->renderState[WINED3DRS_TEXTUREFACTOR], col);
294 /* Set the default alpha blend color */
295 glBlendColor(col[0], col[1], col[2], col[3]);
296 checkGLcall("glBlendColor");
298 D3DCOLORTOGLFLOAT4(This->stateBlock->renderState[WINED3DRS_TEXTUREFACTOR], col);
299 glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
300 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
302 /* TODO: NV_POINT_SPRITE */
303 if (GL_SUPPORT(ARB_POINT_SPRITE)) {
304 if (This->stateBlock->renderState[WINED3DRS_POINTSPRITEENABLE] != FALSE) {
305 /* Doesn't work with GL_POINT_SMOOTH on on my ATI 9600, but then ATI drivers are buggered! */
306 glDisable(GL_POINT_SMOOTH);
308 /* Centre the texture on the vertex */
309 VTRACE("glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE)\n");
310 glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
312 VTRACE("glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE)\n");
313 glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
314 checkGLcall("glTexEnvf(...)");
315 VTRACE("glEnable( GL_POINT_SPRITE_ARB )\n");
316 glEnable( GL_POINT_SPRITE_ARB );
317 checkGLcall("glEnable(...)");
319 VTRACE("glDisable( GL_POINT_SPRITE_ARB )\n");
320 glDisable( GL_POINT_SPRITE_ARB );
321 checkGLcall("glEnable(...)");
325 TRACE("-----------------------> Updated the texture at Sampler %ld to have new texture state information\n", Sampler);
328 /**********************************************************
329 * IUnknown parts follows
330 **********************************************************/
332 HRESULT WINAPI IWineD3DDeviceImpl_QueryInterface(IWineD3DDevice *iface,REFIID riid,LPVOID *ppobj)
334 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
336 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
337 if (IsEqualGUID(riid, &IID_IUnknown)
338 || IsEqualGUID(riid, &IID_IWineD3DBase)
339 || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
340 IUnknown_AddRef(iface);
345 return E_NOINTERFACE;
348 ULONG WINAPI IWineD3DDeviceImpl_AddRef(IWineD3DDevice *iface) {
349 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
350 ULONG refCount = InterlockedIncrement(&This->ref);
352 TRACE("(%p) : AddRef increasing from %ld\n", This, refCount - 1);
356 ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
357 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
358 ULONG refCount = InterlockedDecrement(&This->ref);
360 TRACE("(%p) : Releasing from %ld\n", This, refCount + 1);
363 /* TODO: Clean up all the surfaces and textures! */
364 /* FIXME: Create targets and state blocks in d3d8 */
365 if (((IWineD3DImpl *)This->wineD3D)->dxVersion >= 8) { /*We don't create state blocks for d3d7 yet*/
366 /* NOTE: You must release the parent if the object was created via a callback
367 ** ***************************/
368 /* TODO: this is exactly the same as required by _Reset.., so at some point we need to move the code so that is can be called by reset add release... */
369 /* Release all of the swapchains, except the implicit swapchain */
370 IUnknown* stencilBufferParent;
371 IUnknown* swapChainParent;
373 /* NOTE: Don't release swapchain 0 here, it's 'special' */
374 SwapChainList *nextSwapchain = This->swapchains;
375 if (nextSwapchain != NULL) {
376 nextSwapchain = nextSwapchain->next;
378 WARN("Expected to find the implicit swapchain\n");
381 /* release all the other swapchains */
382 while (nextSwapchain != NULL) {
383 SwapChainList *prevSwapchain = nextSwapchain;
384 nextSwapchain = nextSwapchain->next;
385 IWineD3DSwapChain_Release(prevSwapchain->swapchain);
386 /* NOTE: no need to free the list element, it will be done by the release callback
387 HeapFree(GetProcessHeap(), 0, prevSwapchain); */
389 /* Release the buffers (with sanity checks)*/
390 if(This->stencilBufferTarget != NULL && (IWineD3DSurface_Release(This->stencilBufferTarget) >0)){
391 if(This->depthStencilBuffer != This->stencilBufferTarget)
392 FIXME("(%p) Something's still holding the depthStencilBuffer\n",This);
394 This->stencilBufferTarget = NULL;
396 if(IWineD3DSurface_Release(This->renderTarget) >0){
397 /* This check is a bit silly, itshould be in swapchain_release FIXME("(%p) Something's still holding the renderTarget\n",This); */
399 This->renderTarget = NULL;
401 IWineD3DSurface_GetParent(This->depthStencilBuffer, &stencilBufferParent);
402 IUnknown_Release(stencilBufferParent); /* once for the get parent */
403 if(IUnknown_Release(stencilBufferParent) >0){ /* the second time for when it was created */
404 FIXME("(%p) Something's still holding the depthStencilBuffer\n",This);
406 This->depthStencilBuffer = NULL;
408 /* Release the update stateblock */
409 if(IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->updateStateBlock) > 0){
410 if(This->updateStateBlock != This->stateBlock)
411 FIXME("(%p) Something's still holding the Update stateblock\n",This);
413 This->updateStateBlock = NULL;
414 { /* because were not doing proper internal refcounts releasing the primary state block
415 causes recursion with the extra checks in ResourceReleased, to avoid this we have
416 to set this->stateBlock = NULL; first */
417 IWineD3DStateBlock *stateBlock = (IWineD3DStateBlock *)This->stateBlock;
418 This->stateBlock = NULL;
420 /* Release the stateblock */
421 if(IWineD3DStateBlock_Release(stateBlock) > 0){
422 FIXME("(%p) Something's still holding the Update stateblock\n",This);
426 if (This->swapchains != NULL) {
427 /* Swapchain 0 is special because it's created in startup with a hanging parent, so we have to release its parent now */
428 IWineD3DSwapChain_GetParent(This->swapchains->swapchain, &swapChainParent);
429 IUnknown_Release(swapChainParent); /* once for the get parent */
430 if (IUnknown_Release(swapChainParent) > 0) { /* the second time for when it was created */
431 FIXME("(%p) Something's still holding the implicit swapchain\n", This);
435 if (This->resources != NULL ) {
436 FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This);
438 #if 0 /* TODO: Dump a list of all the resources still bound */
439 dumpResources(This->resources);
441 /* TODO: set the resources to a lost state */
445 IWineD3D_Release(This->wineD3D);
446 This->wineD3D = NULL;
447 HeapFree(GetProcessHeap(), 0, This);
448 TRACE("Freed device %p\n", This);
454 /**********************************************************
455 * IWineD3DDevice implementation follows
456 **********************************************************/
457 HRESULT WINAPI IWineD3DDeviceImpl_GetParent(IWineD3DDevice *iface, IUnknown **pParent) {
458 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
459 *pParent = This->parent;
460 IUnknown_AddRef(This->parent);
464 HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface, UINT Size, DWORD Usage,
465 DWORD FVF, WINED3DPOOL Pool, IWineD3DVertexBuffer** ppVertexBuffer, HANDLE *sharedHandle,
467 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
468 IWineD3DVertexBufferImpl *object;
469 WINED3DFORMAT Format = WINED3DFMT_VERTEXDATA; /* Dummy format for now */
470 D3DCREATERESOURCEOBJECTINSTANCE(object, VertexBuffer, WINED3DRTYPE_VERTEXBUFFER, Size)
473 if (Pool == WINED3DPOOL_DEFAULT ) { /* Allocate some system memory for now */
474 object->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->resource.size);
478 TRACE("(%p) : Size=%d, Usage=%ld, FVF=%lx, Pool=%d - Memory@%p, Iface@%p\n", This, Size, Usage, FVF, Pool, object->resource.allocatedMemory, object);
479 *ppVertexBuffer = (IWineD3DVertexBuffer *)object;
484 HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage,
485 WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DIndexBuffer** ppIndexBuffer,
486 HANDLE *sharedHandle, IUnknown *parent) {
487 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
488 IWineD3DIndexBufferImpl *object;
489 TRACE("(%p) Creating index buffer\n", This);
491 /* Allocate the storage for the device */
492 D3DCREATERESOURCEOBJECTINSTANCE(object,IndexBuffer,WINED3DRTYPE_INDEXBUFFER, Length)
495 if (Pool == WINED3DPOOL_DEFAULT ) { /* Allocate some system memory for now */
496 object->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,object->resource.size);
499 TRACE("(%p) : Len=%d, Use=%lx, Format=(%u,%s), Pool=%d - Memory@%p, Iface@%p\n", This, Length, Usage, Format,
500 debug_d3dformat(Format), Pool, object, object->resource.allocatedMemory);
501 *ppIndexBuffer = (IWineD3DIndexBuffer *) object;
506 HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface, WINED3DSTATEBLOCKTYPE Type, IWineD3DStateBlock** ppStateBlock, IUnknown *parent) {
508 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
509 IWineD3DStateBlockImpl *object;
512 D3DCREATEOBJECTINSTANCE(object, StateBlock)
513 object->blockType = Type;
515 /* Special case - Used during initialization to produce a placeholder stateblock
516 so other functions called can update a state block */
517 if (Type == WINED3DSBT_INIT) {
518 /* Don't bother increasing the reference count otherwise a device will never
519 be freed due to circular dependencies */
523 /* Otherwise, might as well set the whole state block to the appropriate values */
524 if ( This->stateBlock != NULL) {
525 memcpy(object, This->stateBlock, sizeof(IWineD3DStateBlockImpl));
527 memset(object->streamFreq, 1, sizeof(object->streamFreq));
530 /* Reset the ref and type after kludging it */
531 object->wineD3DDevice = This;
533 object->blockType = Type;
535 TRACE("Updating changed flags appropriate for type %d\n", Type);
537 if (Type == WINED3DSBT_ALL) {
539 TRACE("ALL => Pretend everything has changed\n");
540 memset(&object->changed, TRUE, sizeof(This->stateBlock->changed));
541 } else if (Type == WINED3DSBT_PIXELSTATE) {
543 TRACE("PIXELSTATE => Pretend all pixel shates have changed\n");
544 memset(&object->changed, FALSE, sizeof(This->stateBlock->changed));
546 object->changed.pixelShader = TRUE;
548 /* Pixel Shader Constants */
549 for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
550 object->changed.pixelShaderConstants[i] = TRUE;
552 for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
553 object->changed.renderState[SavedPixelStates_R[i]] = TRUE;
555 for (j = 0; j < GL_LIMITS(textures); j++) {
556 for (i = 0; i < NUM_SAVEDPIXELSTATES_T; i++) {
557 object->changed.textureState[j][SavedPixelStates_T[i]] = TRUE;
560 for (j = 0 ; j < 16; j++) {
561 for (i =0; i < NUM_SAVEDPIXELSTATES_S;i++) {
563 object->changed.samplerState[j][SavedPixelStates_S[i]] = TRUE;
567 } else if (Type == WINED3DSBT_VERTEXSTATE) {
569 TRACE("VERTEXSTATE => Pretend all vertex shates have changed\n");
570 memset(&object->changed, FALSE, sizeof(This->stateBlock->changed));
572 object->changed.vertexShader = TRUE;
574 /* Vertex Shader Constants */
575 for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
576 object->changed.vertexShaderConstants[i] = TRUE;
578 for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
579 object->changed.renderState[SavedVertexStates_R[i]] = TRUE;
581 for (j = 0; j < GL_LIMITS(textures); j++) {
582 for (i = 0; i < NUM_SAVEDVERTEXSTATES_T; i++) {
583 object->changed.textureState[j][SavedVertexStates_T[i]] = TRUE;
586 for (j = 0 ; j < 16; j++){
587 for (i =0; i < NUM_SAVEDVERTEXSTATES_S;i++) {
588 object->changed.samplerState[j][SavedVertexStates_S[i]] = TRUE;
592 /* Duplicate light chain */
594 PLIGHTINFOEL *src = NULL;
595 PLIGHTINFOEL *dst = NULL;
596 PLIGHTINFOEL *newEl = NULL;
597 src = This->stateBlock->lights;
598 object->lights = NULL;
602 newEl = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL));
603 if (newEl == NULL) return D3DERR_OUTOFVIDEOMEMORY;
604 memcpy(newEl, src, sizeof(PLIGHTINFOEL));
606 newEl->changed = TRUE;
607 newEl->enabledChanged = TRUE;
609 object->lights = newEl;
620 FIXME("Unrecognized state block type %d\n", Type);
623 TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, object);
628 /* ************************************
630 [in] Render targets are not lockable unless the application specifies TRUE for Lockable. Note that lockable render targets reduce performance on some graphics hardware.
633 [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
635 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.
637 ******************************** */
639 HRESULT WINAPI IWineD3DDeviceImpl_CreateSurface(IWineD3DDevice *iface, UINT Width, UINT Height, WINED3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IWineD3DSurface **ppSurface,WINED3DRESOURCETYPE Type, DWORD Usage, WINED3DPOOL Pool, WINED3DMULTISAMPLE_TYPE MultiSample ,DWORD MultisampleQuality, HANDLE* pSharedHandle, IUnknown *parent) {
640 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
641 IWineD3DSurfaceImpl *object; /*NOTE: impl ref allowed since this is a create function */
642 unsigned int pow2Width, pow2Height;
643 unsigned int Size = 1;
644 TRACE("(%p) Create surface\n",This);
646 /** FIXME: Check ranges on the inputs are valid
649 * [in] Quality level. The valid range is between zero and one less than the level
650 * returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType.
651 * Passing a larger value returns the error D3DERR_INVALIDCALL. The MultisampleQuality
652 * values of paired render targets, depth stencil surfaces, and the MultiSample type
654 *******************************/
659 * [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
661 * If this flag is set, the contents of the depth stencil buffer will be
662 * invalid after calling either IDirect3DDevice9::Present or * IDirect3DDevice9::SetDepthStencilSurface
663 * with a different depth surface.
665 *This flag has the same behavior as the constant, D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL, in D3DPRESENTFLAG.
666 ***************************/
668 if(MultisampleQuality < 0) {
669 FIXME("Invalid multisample level %ld\n", MultisampleQuality);
670 return D3DERR_INVALIDCALL; /* TODO: Check that this is the case! */
673 if(MultisampleQuality > 0) {
674 FIXME("MultisampleQuality set to %ld, substituting 0\n", MultisampleQuality);
675 MultisampleQuality=0;
678 /** FIXME: Check that the format is supported
680 *******************************/
682 /* Non-power2 support */
684 /* Find the nearest pow2 match */
685 pow2Width = pow2Height = 1;
686 while (pow2Width < Width) pow2Width <<= 1;
687 while (pow2Height < Height) pow2Height <<= 1;
689 if (pow2Width > Width || pow2Height > Height) {
690 /** TODO: add support for non power two compressed textures (OpenGL 2 provices support for * non-power-two textures gratis) **/
691 if (Format == WINED3DFMT_DXT1 || Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3
692 || Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5) {
693 FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
694 This, Width, Height);
695 return D3DERR_NOTAVAILABLE;
699 /** Check against the maximum texture sizes supported by the video card **/
700 if (pow2Width > GL_LIMITS(texture_size) || pow2Height > GL_LIMITS(texture_size)) {
701 /* one of three options
702 1: Do the same as we do with nonpow 2 and scale the texture, (any texture ops would require the texture to be scaled which is potentially slow)
703 2: Set the texture to the maxium size (bad idea)
704 3: WARN and return D3DERR_NOTAVAILABLE;
706 WARN("(%p) Application requested a surface w %d, h %d, but the graphics card only supports %d\n", This, Width, Height, GL_LIMITS(texture_size));
707 return D3DERR_NOTAVAILABLE;
712 /** DXTn mipmaps use the same number of 'levels' down to eg. 8x1, but since
713 * it is based around 4x4 pixel blocks it requires padding, so allocate enough
715 *********************************/
716 if (WINED3DFMT_UNKNOWN == Format) {
718 } else if (Format == WINED3DFMT_DXT1) {
719 /* DXT1 is half byte per pixel */
720 Size = ((max(pow2Width,4) * D3DFmtGetBpp(This, Format)) * max(pow2Height,4)) >> 1;
722 } else if (Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3 ||
723 Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5) {
724 Size = ((max(pow2Width,4) * D3DFmtGetBpp(This, Format)) * max(pow2Height,4));
726 Size = (pow2Width * D3DFmtGetBpp(This, Format)) * pow2Height;
729 /** Create and initialise the surface resource **/
730 D3DCREATERESOURCEOBJECTINSTANCE(object,Surface,WINED3DRTYPE_SURFACE, Size)
731 /* "Standalone" surface */
732 IWineD3DSurface_SetContainer((IWineD3DSurface *)object, NULL);
734 object->currentDesc.Width = Width;
735 object->currentDesc.Height = Height;
736 object->currentDesc.MultiSampleType = MultiSample;
737 object->currentDesc.MultiSampleQuality = MultisampleQuality;
739 /* Setup some glformat defaults */
740 if (WINED3DFMT_UNKNOWN != Format) {
741 object->glDescription.glFormat = D3DFmt2GLFmt(This, object->resource.format);
742 object->glDescription.glFormatInternal = D3DFmt2GLIntFmt(This, object->resource.format);
743 object->glDescription.glType = D3DFmt2GLType(This, object->resource.format);
745 object->glDescription.glFormat = 0;
746 object->glDescription.glFormatInternal = 0;
747 object->glDescription.glType = 0;
750 object->glDescription.textureName = 0;
751 object->glDescription.level = Level;
752 object->glDescription.target = GL_TEXTURE_2D;
755 object->pow2Width = pow2Width;
756 object->pow2Height = pow2Height;
757 object->nonpow2 = (pow2Width != Width || pow2Height != Height) ? TRUE : FALSE;
758 object->discard = Discard;
759 object->activeLock = FALSE;
761 if (WINED3DFMT_UNKNOWN != Format) {
762 object->bytesPerPixel = D3DFmtGetBpp(This, Format);
763 object->pow2Size = (pow2Width * object->bytesPerPixel) * pow2Height;
765 object->bytesPerPixel = 0;
766 object->pow2Size = 0;
769 /** TODO: change this into a texture transform matrix so that it's processed in hardware **/
771 TRACE("Pool %d %d %d %d",Pool, WINED3DPOOL_DEFAULT, WINED3DPOOL_MANAGED, WINED3DPOOL_SYSTEMMEM);
773 /** Quick lockable sanity check TODO: remove this after surfaces, usage and locablility have been debugged properly
774 * this function is too deap to need to care about things like this.
775 * Levels need to be checked too, and possibly Type wince they all affect what can be done.
776 * ****************************************/
778 case WINED3DPOOL_SCRATCH:
779 if(Lockable == FALSE)
780 FIXME("Create suface called with a pool of SCRATCH and a Lockable of FALSE \
781 which are mutually exclusive, setting lockable to true\n");
784 case WINED3DPOOL_SYSTEMMEM:
785 if(Lockable == FALSE) FIXME("Create surface called with a pool of SYSTEMMEM and a Lockable of FALSE, \
786 this is acceptable but unexpected (I can't know how the surface can be usable!)\n");
787 case WINED3DPOOL_MANAGED:
788 if(Usage == WINED3DUSAGE_DYNAMIC) FIXME("Create surface called with a pool of MANAGED and a \
789 Usage of DYNAMIC which are mutually exclusive, not doing \
790 anything just telling you.\n");
792 case WINED3DPOOL_DEFAULT: /*TODO: Create offscreen plain can cause this check to fail..., find out if it should */
793 if(!(Usage & WINED3DUSAGE_DYNAMIC) && !(Usage & WINED3DUSAGE_RENDERTARGET)
794 && !(Usage && WINED3DUSAGE_DEPTHSTENCIL ) && Lockable == TRUE)
795 FIXME("Creating a surface with a POOL of DEFAULT with Locable true, that doesn't specify DYNAMIC usage.\n");
798 FIXME("(%p) Unknown pool %d\n", This, Pool);
802 if (Usage & WINED3DUSAGE_RENDERTARGET && Pool != WINED3DPOOL_DEFAULT) {
803 FIXME("Trying to create a render target that isn't in the default pool\n");
807 object->locked = FALSE;
808 object->lockable = (WINED3DFMT_D16_LOCKABLE == Format) ? TRUE : Lockable;
810 /* mark the texture as dirty so that it get's loaded first time around*/
811 IWineD3DSurface_AddDirtyRect(*ppSurface, NULL);
812 TRACE("(%p) : w(%d) h(%d) fmt(%d,%s) lockable(%d) surf@%p, surfmem@%p, %d bytes\n",
813 This, Width, Height, Format, debug_d3dformat(Format),
814 (WINED3DFMT_D16_LOCKABLE == Format), *ppSurface, object->resource.allocatedMemory, object->resource.size);
819 HRESULT WINAPI IWineD3DDeviceImpl_CreateTexture(IWineD3DDevice *iface, UINT Width, UINT Height, UINT Levels,
820 DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool,
821 IWineD3DTexture** ppTexture, HANDLE* pSharedHandle, IUnknown *parent,
822 D3DCB_CREATESURFACEFN D3DCB_CreateSurface) {
824 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
825 IWineD3DTextureImpl *object;
830 unsigned int pow2Width = Width;
831 unsigned int pow2Height = Height;
834 TRACE("(%p), Width(%d) Height(%d) Levels(%d) Usage(%ld) ....\n", This, Width, Height, Levels, Usage);
836 /* TODO: It should only be possible to create textures for formats
837 that are reported as supported */
838 if (WINED3DFMT_UNKNOWN >= Format) {
839 WARN("(%p) : Texture cannot be created with a format of D3DFMT_UNKNOWN\n", This);
840 return D3DERR_INVALIDCALL;
843 D3DCREATERESOURCEOBJECTINSTANCE(object, Texture, WINED3DRTYPE_TEXTURE, 0);
844 D3DINITIALIZEBASETEXTURE(object->baseTexture);
845 object->width = Width;
846 object->height = Height;
848 /** Non-power2 support **/
849 /* Find the nearest pow2 match */
850 pow2Width = pow2Height = 1;
851 while (pow2Width < Width) pow2Width <<= 1;
852 while (pow2Height < Height) pow2Height <<= 1;
854 /** FIXME: add support for real non-power-two if it's provided by the video card **/
855 /* Precalculated scaling for 'faked' non power of two texture coords */
856 object->pow2scalingFactorX = (((float)Width) / ((float)pow2Width));
857 object->pow2scalingFactorY = (((float)Height) / ((float)pow2Height));
858 TRACE(" xf(%f) yf(%f)\n", object->pow2scalingFactorX, object->pow2scalingFactorY);
860 /* Calculate levels for mip mapping */
862 TRACE("calculating levels %d\n", object->baseTexture.levels);
863 object->baseTexture.levels++;
866 while (tmpW > 1 && tmpH > 1) {
867 tmpW = max(1, tmpW >> 1);
868 tmpH = max(1, tmpH >> 1);
869 object->baseTexture.levels++;
871 TRACE("Calculated levels = %d\n", object->baseTexture.levels);
874 /* Generate all the surfaces */
877 for (i = 0; i < object->baseTexture.levels; i++)
879 /* use the callback to create the texture surface */
880 hr = D3DCB_CreateSurface(This->parent, tmpW, tmpH, Format, Usage, Pool, i, &object->surfaces[i],NULL);
883 FIXME("Failed to create surface %p\n", object);
885 for (j = 0 ; j < i ; j++) {
886 IWineD3DSurface_Release(object->surfaces[j]);
888 /* heap free object */
889 HeapFree(GetProcessHeap(), 0, object);
895 IWineD3DSurface_SetContainer(object->surfaces[i], (IWineD3DBase *)object);
896 TRACE("Created surface level %d @ %p\n", i, object->surfaces[i]);
897 /* calculate the next mipmap level */
898 tmpW = max(1, tmpW >> 1);
899 tmpH = max(1, tmpH >> 1);
902 TRACE("(%p) : Created texture %p\n", This, object);
906 HRESULT WINAPI IWineD3DDeviceImpl_CreateVolumeTexture(IWineD3DDevice *iface,
907 UINT Width, UINT Height, UINT Depth,
908 UINT Levels, DWORD Usage,
909 WINED3DFORMAT Format, WINED3DPOOL Pool,
910 IWineD3DVolumeTexture **ppVolumeTexture,
911 HANDLE *pSharedHandle, IUnknown *parent,
912 D3DCB_CREATEVOLUMEFN D3DCB_CreateVolume) {
914 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
915 IWineD3DVolumeTextureImpl *object;
921 /* TODO: It should only be possible to create textures for formats
922 that are reported as supported */
923 if (WINED3DFMT_UNKNOWN >= Format) {
924 WARN("(%p) : Texture cannot be created with a format of D3DFMT_UNKNOWN\n", This);
925 return D3DERR_INVALIDCALL;
928 D3DCREATERESOURCEOBJECTINSTANCE(object, VolumeTexture, WINED3DRTYPE_VOLUMETEXTURE, 0);
929 D3DINITIALIZEBASETEXTURE(object->baseTexture);
931 TRACE("(%p) : W(%d) H(%d) D(%d), Lvl(%d) Usage(%ld), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
932 Depth, Levels, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
934 object->width = Width;
935 object->height = Height;
936 object->depth = Depth;
938 /* Calculate levels for mip mapping */
940 object->baseTexture.levels++;
944 while (tmpW > 1 && tmpH > 1 && tmpD > 1) {
945 tmpW = max(1, tmpW >> 1);
946 tmpH = max(1, tmpH >> 1);
947 tmpD = max(1, tmpD >> 1);
948 object->baseTexture.levels++;
950 TRACE("Calculated levels = %d\n", object->baseTexture.levels);
953 /* Generate all the surfaces */
958 for (i = 0; i < object->baseTexture.levels; i++)
960 /* Create the volume */
961 D3DCB_CreateVolume(This->parent, Width, Height, Depth, Format, Pool, Usage,
962 (IWineD3DVolume **)&object->volumes[i], pSharedHandle);
964 /* Set it's container to this object */
965 IWineD3DVolume_SetContainer(object->volumes[i], (IWineD3DBase *)object);
967 /* calcualte the next mipmap level */
968 tmpW = max(1, tmpW >> 1);
969 tmpH = max(1, tmpH >> 1);
970 tmpD = max(1, tmpD >> 1);
973 *ppVolumeTexture = (IWineD3DVolumeTexture *) object;
974 TRACE("(%p) : Created volume texture %p\n", This, object);
978 HRESULT WINAPI IWineD3DDeviceImpl_CreateVolume(IWineD3DDevice *iface,
979 UINT Width, UINT Height, UINT Depth,
981 WINED3DFORMAT Format, WINED3DPOOL Pool,
982 IWineD3DVolume** ppVolume,
983 HANDLE* pSharedHandle, IUnknown *parent) {
985 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
986 IWineD3DVolumeImpl *object; /** NOTE: impl ref allowed since this is a create function **/
988 D3DCREATERESOURCEOBJECTINSTANCE(object, Volume, WINED3DRTYPE_VOLUME, ((Width * D3DFmtGetBpp(This, Format)) * Height * Depth))
990 TRACE("(%p) : W(%d) H(%d) D(%d), Usage(%ld), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
991 Depth, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
993 object->currentDesc.Width = Width;
994 object->currentDesc.Height = Height;
995 object->currentDesc.Depth = Depth;
996 object->bytesPerPixel = D3DFmtGetBpp(This, Format);
998 /** Note: Volume textures cannot be dxtn, hence no need to check here **/
999 object->lockable = TRUE;
1000 object->locked = FALSE;
1001 memset(&object->lockedBox, 0, sizeof(D3DBOX));
1002 object->dirty = TRUE;
1004 return IWineD3DVolume_AddDirtyBox((IWineD3DVolume *) object, NULL);
1007 HRESULT WINAPI IWineD3DDeviceImpl_CreateCubeTexture(IWineD3DDevice *iface, UINT EdgeLength,
1008 UINT Levels, DWORD Usage,
1009 WINED3DFORMAT Format, WINED3DPOOL Pool,
1010 IWineD3DCubeTexture **ppCubeTexture,
1011 HANDLE *pSharedHandle, IUnknown *parent,
1012 D3DCB_CREATESURFACEFN D3DCB_CreateSurface) {
1014 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1015 IWineD3DCubeTextureImpl *object; /** NOTE: impl ref allowed since this is a create function **/
1019 unsigned int pow2EdgeLength = EdgeLength;
1021 /* TODO: It should only be possible to create textures for formats
1022 that are reported as supported */
1023 if (WINED3DFMT_UNKNOWN >= Format) {
1024 WARN("(%p) : Texture cannot be created with a format of D3DFMT_UNKNOWN\n", This);
1025 return D3DERR_INVALIDCALL;
1028 D3DCREATERESOURCEOBJECTINSTANCE(object, CubeTexture, WINED3DRTYPE_CUBETEXTURE, 0);
1029 D3DINITIALIZEBASETEXTURE(object->baseTexture);
1031 TRACE("(%p) Create Cube Texture\n", This);
1033 /** Non-power2 support **/
1035 /* Find the nearest pow2 match */
1037 while (pow2EdgeLength < EdgeLength) pow2EdgeLength <<= 1;
1039 object->edgeLength = EdgeLength;
1040 /* TODO: support for native non-power 2 */
1041 /* Precalculated scaling for 'faked' non power of two texture coords */
1042 object->pow2scalingFactor = ((float)EdgeLength) / ((float)pow2EdgeLength);
1044 /* Calculate levels for mip mapping */
1046 object->baseTexture.levels++;
1049 tmpW = max(1, tmpW >> 1);
1050 object->baseTexture.levels++;
1052 TRACE("Calculated levels = %d\n", object->baseTexture.levels);
1055 /* Generate all the surfaces */
1057 for (i = 0; i < object->baseTexture.levels; i++) {
1059 /* Create the 6 faces */
1060 for (j = 0; j < 6; j++) {
1062 hr=D3DCB_CreateSurface(This->parent, tmpW, tmpW, Format, Usage, Pool,
1063 i /* Level */, &object->surfaces[j][i],pSharedHandle);
1069 for (l = 0; l < j; l++) {
1070 IWineD3DSurface_Release(object->surfaces[j][i]);
1072 for (k = 0; k < i; k++) {
1073 for (l = 0; l < 6; l++) {
1074 IWineD3DSurface_Release(object->surfaces[l][j]);
1078 FIXME("(%p) Failed to create surface\n",object);
1079 HeapFree(GetProcessHeap(),0,object);
1080 *ppCubeTexture = NULL;
1083 IWineD3DSurface_SetContainer(object->surfaces[j][i], (IWineD3DBase *)object);
1084 TRACE("Created surface level %d @ %p,\n", i, object->surfaces[j][i]);
1086 tmpW = max(1, tmpW >> 1);
1089 TRACE("(%p) : Created Cube Texture %p\n", This, object);
1090 *ppCubeTexture = (IWineD3DCubeTexture *) object;
1094 HRESULT WINAPI IWineD3DDeviceImpl_CreateQuery(IWineD3DDevice *iface, WINED3DQUERYTYPE Type, IWineD3DQuery **ppQuery, IUnknown* parent) {
1095 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1096 IWineD3DQueryImpl *object; /*NOTE: impl ref allowed since this is a create function */
1098 if (NULL == ppQuery) {
1099 /* Just a check to see if we support this type of query */
1100 HRESULT hr = D3DERR_NOTAVAILABLE;
1102 case WINED3DQUERYTYPE_OCCLUSION:
1103 TRACE("(%p) occlusion query\n", This);
1104 if (GL_SUPPORT(ARB_OCCLUSION_QUERY) || GL_SUPPORT(NV_OCCLUSION_QUERY))
1107 WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY/NV_OCCLUSION_QUERY\n");
1109 case WINED3DQUERYTYPE_VCACHE:
1110 case WINED3DQUERYTYPE_RESOURCEMANAGER:
1111 case WINED3DQUERYTYPE_VERTEXSTATS:
1112 case WINED3DQUERYTYPE_EVENT:
1113 case WINED3DQUERYTYPE_TIMESTAMP:
1114 case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
1115 case WINED3DQUERYTYPE_TIMESTAMPFREQ:
1116 case WINED3DQUERYTYPE_PIPELINETIMINGS:
1117 case WINED3DQUERYTYPE_INTERFACETIMINGS:
1118 case WINED3DQUERYTYPE_VERTEXTIMINGS:
1119 case WINED3DQUERYTYPE_PIXELTIMINGS:
1120 case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
1121 case WINED3DQUERYTYPE_CACHEUTILIZATION:
1123 FIXME("(%p) Unhandled query type %d\n", This, Type);
1128 D3DCREATEOBJECTINSTANCE(object, Query)
1129 object->type = Type;
1130 /* allocated the 'extended' data based on the type of query requested */
1132 case D3DQUERYTYPE_OCCLUSION:
1133 if(GL_SUPPORT(ARB_OCCLUSION_QUERY) || GL_SUPPORT(NV_OCCLUSION_QUERY)) {
1134 TRACE("(%p) Allocating data for an occlusion query\n", This);
1135 object->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WineQueryOcclusionData));
1138 case D3DQUERYTYPE_VCACHE:
1139 case D3DQUERYTYPE_RESOURCEMANAGER:
1140 case D3DQUERYTYPE_VERTEXSTATS:
1141 case D3DQUERYTYPE_EVENT:
1142 case D3DQUERYTYPE_TIMESTAMP:
1143 case D3DQUERYTYPE_TIMESTAMPDISJOINT:
1144 case D3DQUERYTYPE_TIMESTAMPFREQ:
1145 case D3DQUERYTYPE_PIPELINETIMINGS:
1146 case D3DQUERYTYPE_INTERFACETIMINGS:
1147 case D3DQUERYTYPE_VERTEXTIMINGS:
1148 case D3DQUERYTYPE_PIXELTIMINGS:
1149 case D3DQUERYTYPE_BANDWIDTHTIMINGS:
1150 case D3DQUERYTYPE_CACHEUTILIZATION:
1152 object->extendedData = 0;
1153 FIXME("(%p) Unhandled query type %d\n",This , Type);
1155 TRACE("(%p) : Created Query %p\n", This, object);
1159 /* example at http://www.fairyengine.com/articles/dxmultiviews.htm */
1160 HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters, IWineD3DSwapChain** ppSwapChain,
1162 D3DCB_CREATERENDERTARGETFN D3DCB_CreateRenderTarget,
1163 D3DCB_CREATEDEPTHSTENCILSURFACEFN D3DCB_CreateDepthStencil) {
1164 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1167 IWineD3DSwapChainImpl *object; /** NOTE: impl ref allowed since this is a create function **/
1169 XVisualInfo template;
1170 GLXContext oldContext;
1171 Drawable oldDrawable;
1172 HRESULT hr = D3D_OK;
1174 TRACE("(%p) : Created Aditional Swap Chain\n", This);
1176 /** FIXME: Test under windows to find out what the life cycle of a swap chain is,
1177 * does a device hold a reference to a swap chain giving them a lifetime of the device
1178 * or does the swap chain notify the device of its destruction.
1179 *******************************/
1181 D3DCREATEOBJECTINSTANCE(object, SwapChain)
1183 /* Initialize other useful values */
1184 object->presentParms.BackBufferCount = 1; /* TODO:? support for gl_aux buffers */
1186 /*********************
1187 * Lookup the window Handle and the relating X window handle
1188 ********************/
1190 /* Setup hwnd we are using, plus which display this equates to */
1191 object->win_handle = *(pPresentationParameters->hDeviceWindow);
1192 if (!object->win_handle) {
1193 object->win_handle = This->createParms.hFocusWindow;
1196 object->win = (Window)GetPropA(object->win_handle, "__wine_x11_whole_window" );
1197 hDc = GetDC(object->win_handle);
1198 object->display = get_display(hDc);
1199 ReleaseDC(object->win_handle, hDc);
1200 TRACE("Using a display of %p %p\n", object->display, hDc);
1202 if (NULL == object->display || NULL == hDc) {
1203 WARN("Failed to get a display and HDc for Window %p\n", object->win_handle);
1204 return D3DERR_NOTAVAILABLE;
1207 if (object->win == 0) {
1208 WARN("Failed to get a valid XVisuial ID for the window %p\n", object->win_handle);
1209 return D3DERR_NOTAVAILABLE;
1212 * Create an opengl context for the display visual
1213 * NOTE: the visual is chosen as the window is created and the glcontext cannot
1214 * use different properties after that point in time. FIXME: How to handle when requested format
1215 * doesn't match actual visual? Cannot choose one here - code removed as it ONLY works if the one
1216 * it chooses is identical to the one already being used!
1217 **********************************/
1219 /** FIXME: Handle stencil appropriately via EnableAutoDepthStencil / AutoDepthStencilFormat **/
1222 /* Create a new context for this swapchain */
1223 template.visualid = (VisualID)GetPropA(GetDesktopWindow(), "__wine_x11_visual_id");
1224 /* TODO: change this to find a similar visual, but one with a stencil/zbuffer buffer that matches the request
1225 (or the best possible if none is requested) */
1226 TRACE("Found x visual ID : %ld\n", template.visualid);
1228 object->visInfo = XGetVisualInfo(object->display, VisualIDMask, &template, &num);
1229 if (NULL == object->visInfo) {
1230 ERR("cannot really get XVisual\n");
1232 return D3DERR_NOTAVAILABLE;
1235 /* Write out some debug info about the visual/s */
1236 TRACE("Using x visual ID : %ld\n", template.visualid);
1237 TRACE(" visual info: %p\n", object->visInfo);
1238 TRACE(" num items : %d\n", num);
1239 for (n = 0;n < num; n++) {
1240 TRACE("=====item=====: %d\n", n + 1);
1241 TRACE(" visualid : %ld\n", object->visInfo[n].visualid);
1242 TRACE(" screen : %d\n", object->visInfo[n].screen);
1243 TRACE(" depth : %u\n", object->visInfo[n].depth);
1244 TRACE(" class : %d\n", object->visInfo[n].class);
1245 TRACE(" red_mask : %ld\n", object->visInfo[n].red_mask);
1246 TRACE(" green_mask : %ld\n", object->visInfo[n].green_mask);
1247 TRACE(" blue_mask : %ld\n", object->visInfo[n].blue_mask);
1248 TRACE(" colormap_size : %d\n", object->visInfo[n].colormap_size);
1249 TRACE(" bits_per_rgb : %d\n", object->visInfo[n].bits_per_rgb);
1250 /* log some extra glx info */
1251 glXGetConfig(object->display, object->visInfo, GLX_AUX_BUFFERS, &value);
1252 TRACE(" gl_aux_buffers : %d\n", value);
1253 glXGetConfig(object->display, object->visInfo, GLX_BUFFER_SIZE ,&value);
1254 TRACE(" gl_buffer_size : %d\n", value);
1255 glXGetConfig(object->display, object->visInfo, GLX_RED_SIZE, &value);
1256 TRACE(" gl_red_size : %d\n", value);
1257 glXGetConfig(object->display, object->visInfo, GLX_GREEN_SIZE, &value);
1258 TRACE(" gl_green_size : %d\n", value);
1259 glXGetConfig(object->display, object->visInfo, GLX_BLUE_SIZE, &value);
1260 TRACE(" gl_blue_size : %d\n", value);
1261 glXGetConfig(object->display, object->visInfo, GLX_ALPHA_SIZE, &value);
1262 TRACE(" gl_alpha_size : %d\n", value);
1263 glXGetConfig(object->display, object->visInfo, GLX_DEPTH_SIZE ,&value);
1264 TRACE(" gl_depth_size : %d\n", value);
1265 glXGetConfig(object->display, object->visInfo, GLX_STENCIL_SIZE, &value);
1266 TRACE(" gl_stencil_size : %d\n", value);
1268 /* Now choose a simila visual ID*/
1270 #ifdef USE_CONTEXT_MANAGER
1272 /** TODO: use a context mamager **/
1276 IWineD3DSwapChain *implSwapChain;
1277 if (D3D_OK != IWineD3DDevice_GetSwapChain(iface, 0, &implSwapChain)) {
1278 /* The first time around we create the context that is shared with all other swapchains and render targets */
1279 object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE);
1280 TRACE("Creating implicit context for vis %p, hwnd %p\n", object->display, object->visInfo);
1283 TRACE("Creating context for vis %p, hwnd %p\n", object->display, object->visInfo);
1284 /* TODO: don't use Impl structures outside of create functions! (a context manager will replace the ->glCtx) */
1285 /* and create a new context with the implicit swapchains context as the shared context */
1286 object->glCtx = glXCreateContext(object->display, object->visInfo, ((IWineD3DSwapChainImpl *)implSwapChain)->glCtx, GL_TRUE);
1287 IWineD3DSwapChain_Release(implSwapChain);
1292 XFree(object->visInfo);
1293 object->visInfo = NULL;
1295 if (NULL == object->glCtx) {
1296 ERR("cannot create glxContext\n");
1298 return D3DERR_NOTAVAILABLE;
1302 if (object->glCtx == NULL) {
1303 ERR("Error in context creation !\n");
1304 return D3DERR_INVALIDCALL;
1306 TRACE("Context created (HWND=%p, glContext=%p, Window=%ld, VisInfo=%p)\n",
1307 object->win_handle, object->glCtx, object->win, object->visInfo);
1310 /*********************
1311 * Windowed / Fullscreen
1312 *******************/
1315 * TODO: MSDN says that we are only allowed one fullscreen swapchain per device,
1316 * so we should really check to see if there is a fullscreen swapchain already
1317 * I think Windows and X have different ideas about fullscreen, does a single head count as full screen?
1318 **************************************/
1320 if (!*(pPresentationParameters->Windowed)) {
1326 /* Get info on the current display setup */
1327 hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1328 bpp = GetDeviceCaps(hdc, BITSPIXEL);
1331 /* Change the display settings */
1332 memset(&devmode, 0, sizeof(DEVMODEW));
1333 devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1334 devmode.dmBitsPerPel = (bpp >= 24) ? 32 : bpp; /* Stupid XVidMode cannot change bpp */
1335 devmode.dmPelsWidth = *(pPresentationParameters->BackBufferWidth);
1336 devmode.dmPelsHeight = *(pPresentationParameters->BackBufferHeight);
1337 MultiByteToWideChar(CP_ACP, 0, "Gamers CG", -1, devmode.dmDeviceName, CCHDEVICENAME);
1338 ChangeDisplaySettingsExW(devmode.dmDeviceName, &devmode, object->win_handle, CDS_FULLSCREEN, NULL);
1340 /* Make popup window */
1341 SetWindowLongA(object->win_handle, GWL_STYLE, WS_POPUP);
1342 SetWindowPos(object->win_handle, HWND_TOP, 0, 0,
1343 *(pPresentationParameters->BackBufferWidth),
1344 *(pPresentationParameters->BackBufferHeight), SWP_SHOWWINDOW | SWP_FRAMECHANGED);
1350 /** MSDN: If Windowed is TRUE and either of the BackBufferWidth/Height values is zero,
1351 * then the corresponding dimension of the client area of the hDeviceWindow
1352 * (or the focus window, if hDeviceWindow is NULL) is taken.
1353 **********************/
1355 if (*(pPresentationParameters->Windowed) &&
1356 ((*(pPresentationParameters->BackBufferWidth) == 0) ||
1357 (*(pPresentationParameters->BackBufferHeight) == 0))) {
1360 GetClientRect(object->win_handle, &Rect);
1362 if (*(pPresentationParameters->BackBufferWidth) == 0) {
1363 *(pPresentationParameters->BackBufferWidth) = Rect.right;
1364 TRACE("Updating width to %d\n", *(pPresentationParameters->BackBufferWidth));
1366 if (*(pPresentationParameters->BackBufferHeight) == 0) {
1367 *(pPresentationParameters->BackBufferHeight) = Rect.bottom;
1368 TRACE("Updating height to %d\n", *(pPresentationParameters->BackBufferHeight));
1372 /*********************
1373 * finish off parameter initialization
1374 *******************/
1376 /* Put the correct figures in the presentation parameters */
1377 TRACE("Coppying accross presentaion paraneters\n");
1378 object->presentParms.BackBufferWidth = *(pPresentationParameters->BackBufferWidth);
1379 object->presentParms.BackBufferHeight = *(pPresentationParameters->BackBufferHeight);
1380 object->presentParms.BackBufferFormat = *(pPresentationParameters->BackBufferFormat);
1381 object->presentParms.BackBufferCount = *(pPresentationParameters->BackBufferCount);
1382 object->presentParms.MultiSampleType = *(pPresentationParameters->MultiSampleType);
1383 object->presentParms.MultiSampleQuality = NULL == pPresentationParameters->MultiSampleQuality ? 0 : *(pPresentationParameters->MultiSampleQuality);
1384 object->presentParms.SwapEffect = *(pPresentationParameters->SwapEffect);
1385 object->presentParms.hDeviceWindow = *(pPresentationParameters->hDeviceWindow);
1386 object->presentParms.Windowed = *(pPresentationParameters->Windowed);
1387 object->presentParms.EnableAutoDepthStencil = *(pPresentationParameters->EnableAutoDepthStencil);
1388 object->presentParms.AutoDepthStencilFormat = *(pPresentationParameters->AutoDepthStencilFormat);
1389 object->presentParms.Flags = *(pPresentationParameters->Flags);
1390 object->presentParms.FullScreen_RefreshRateInHz = *(pPresentationParameters->FullScreen_RefreshRateInHz);
1391 object->presentParms.PresentationInterval = *(pPresentationParameters->PresentationInterval);
1394 /*********************
1395 * Create the back, front and stencil buffers
1396 *******************/
1397 TRACE("calling rendertarget CB\n");
1398 hr = D3DCB_CreateRenderTarget((IUnknown *) This->parent,
1399 object->presentParms.BackBufferWidth,
1400 object->presentParms.BackBufferHeight,
1401 object->presentParms.BackBufferFormat,
1402 object->presentParms.MultiSampleType,
1403 object->presentParms.MultiSampleQuality,
1404 TRUE /* Lockable */,
1405 &object->frontBuffer,
1406 NULL /* pShared (always null)*/);
1407 if (object->frontBuffer != NULL)
1408 IWineD3DSurface_SetContainer(object->frontBuffer, (IWineD3DBase *)object);
1409 TRACE("calling rendertarget CB\n");
1410 hr = D3DCB_CreateRenderTarget((IUnknown *) This->parent,
1411 object->presentParms.BackBufferWidth,
1412 object->presentParms.BackBufferHeight,
1413 object->presentParms.BackBufferFormat,
1414 object->presentParms.MultiSampleType,
1415 object->presentParms.MultiSampleQuality,
1416 TRUE /* Lockable */,
1417 &object->backBuffer,
1418 NULL /* pShared (always null)*/);
1419 if (object->backBuffer != NULL)
1420 IWineD3DSurface_SetContainer(object->backBuffer, (IWineD3DBase *)object);
1422 /* Under directX swapchains share the depth stencil, so only create one depth-stencil */
1423 if (pPresentationParameters->EnableAutoDepthStencil) {
1424 TRACE("Creating depth stencil buffer\n");
1425 if (This->depthStencilBuffer == NULL ) {
1426 hr = D3DCB_CreateDepthStencil((IUnknown *) This->parent,
1427 object->presentParms.BackBufferWidth,
1428 object->presentParms.BackBufferHeight,
1429 object->presentParms.AutoDepthStencilFormat,
1430 object->presentParms.MultiSampleType,
1431 object->presentParms.MultiSampleQuality,
1432 FALSE /* FIXME: Discard */,
1433 &This->depthStencilBuffer,
1434 NULL /* pShared (always null)*/ );
1435 if (This->depthStencilBuffer != NULL)
1436 IWineD3DSurface_SetContainer(This->depthStencilBuffer, 0);
1439 /** TODO: A check on width, height and multisample types
1440 *(since the zbuffer must be at least as large as the render target and have the same multisample parameters)
1441 ****************************/
1442 object->wantsDepthStencilBuffer = TRUE;
1444 object->wantsDepthStencilBuffer = FALSE;
1447 TRACE("FrontBuf @ %p, BackBuf @ %p, DepthStencil %d\n",object->frontBuffer, object->backBuffer, object->wantsDepthStencilBuffer);
1450 /*********************
1451 * init the default renderTarget management
1452 *******************/
1453 object->drawable = object->win;
1454 object->render_ctx = object->glCtx;
1457 /*********************
1458 * Setup some defaults and clear down the buffers
1459 *******************/
1461 /** save current context and drawable **/
1462 oldContext = glXGetCurrentContext();
1463 oldDrawable = glXGetCurrentDrawable();
1465 TRACE("Activating context (display %p context %p drawable %ld)!\n", object->display, object->glCtx, object->win);
1466 if (glXMakeCurrent(object->display, object->win, object->glCtx) == False) {
1467 ERR("Error in setting current context (display %p context %p drawable %ld)!\n", object->display, object->glCtx, object->win);
1469 checkGLcall("glXMakeCurrent");
1471 TRACE("Setting up the screen\n");
1472 /* Clear the screen */
1473 glClearColor(1.0, 0.0, 0.0, 0.0);
1474 checkGLcall("glClearColor");
1477 glClearStencil(0xffff);
1479 checkGLcall("glClear");
1481 glColor3f(1.0, 1.0, 1.0);
1482 checkGLcall("glColor3f");
1484 glEnable(GL_LIGHTING);
1485 checkGLcall("glEnable");
1487 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
1488 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
1490 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
1491 checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
1493 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1494 checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
1496 /* switch back to the original context (if there was one)*/
1497 if (This->swapchains != NULL) {
1498 /** TODO: restore the context and drawable **/
1499 glXMakeCurrent(object->display, oldDrawable, oldContext);
1504 { /* Finally add the swapchain to the end of the devices' swapchain list */
1505 SwapChainList **nextSwapchain;
1506 nextSwapchain = &This->swapchains;
1507 while (*nextSwapchain != NULL) {
1508 nextSwapchain = &((*nextSwapchain)->next);
1510 (*nextSwapchain) = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This->swapchains));
1511 (*nextSwapchain)->swapchain = (IWineD3DSwapChain *)object;
1513 TRACE("Set swapchain to %p\n", object);
1514 } else { /* something went wrong so clean up */
1515 IUnknown* bufferParent;
1516 if (object->frontBuffer) {
1518 IWineD3DSurface_GetParent(object->frontBuffer, &bufferParent);
1519 IUnknown_Release(bufferParent); /* once for the get parent */
1520 if (IUnknown_Release(bufferParent) > 0) {
1521 FIXME("(%p) Something's still holding the front buffer\n",This);
1524 if (object->backBuffer) {
1525 IWineD3DSurface_GetParent(object->backBuffer, &bufferParent);
1526 IUnknown_Release(bufferParent); /* once for the get parent */
1527 if (IUnknown_Release(bufferParent) > 0) {
1528 FIXME("(%p) Something's still holding the back buffer\n",This);
1531 /* NOTE: don't clean up the depthstencil buffer because it belongs to the device */
1532 /* Clean up the context */
1533 /* check that we are the current context first (we shouldn't be though!) */
1534 if (object->glCtx != 0) {
1535 if(glXGetCurrentContext() == object->glCtx) {
1536 glXMakeCurrent(object->display, None, NULL);
1538 glXDestroyContext(object->display, object->glCtx);
1540 HeapFree(GetProcessHeap(), 0, object);
1547 /** NOTE: These are ahead of the other getters and setters to save using a forward declaration **/
1548 UINT WINAPI IWineD3DDeviceImpl_GetNumberOfSwapChains(IWineD3DDevice *iface) {
1549 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1550 unsigned int numberOfSwapChains = 0;
1551 SwapChainList *swapchain;
1553 swapchain = This->swapchains;
1554 /* itterate through the list to get a count */
1555 while (swapchain != NULL) {
1556 swapchain = swapchain->next;
1557 numberOfSwapChains++;
1560 TRACE("(%p) returning %d\n", This, numberOfSwapChains);
1561 return numberOfSwapChains;
1564 HRESULT WINAPI IWineD3DDeviceImpl_GetSwapChain(IWineD3DDevice *iface, UINT iSwapChain, IWineD3DSwapChain **pSwapChain) {
1565 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1566 SwapChainList *swapchain;
1568 HRESULT hr = D3DERR_INVALIDCALL;
1569 swapchain = This->swapchains;
1570 TRACE("(%p) : swapchain %d\n", This, iSwapChain);
1573 TRACE("(%p) Finding swapchain %d\n", This, iSwapChain);
1574 while (i > 0 && swapchain != NULL) {
1575 swapchain = swapchain->next;
1580 FIXME("(%p) Unable to find swapchain %d\n", This, iSwapChain);
1582 } else if (swapchain != NULL) {
1583 /** TODO: move off to a linkesList implementation **/
1584 *pSwapChain = swapchain->swapchain;
1585 IWineD3DSwapChain_AddRef(*pSwapChain);
1589 TRACE("(%p) returning %p\n", This, *pSwapChain);
1593 HRESULT WINAPI IWineD3DDeviceImpl_Reset(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters) {
1594 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1596 FIXME("(%p) : Stub\n",This);
1602 * Vertex Declaration
1604 HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclaration(IWineD3DDevice* iface, CONST VOID* pDeclaration, IWineD3DVertexDeclaration** ppVertexDeclaration, IUnknown *parent) {
1605 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1606 IWineD3DVertexDeclarationImpl *object = NULL;
1607 HRESULT hr = D3D_OK;
1608 TRACE("(%p) : directXVersion=%u, pFunction=%p, ppDecl=%p\n", This, ((IWineD3DImpl *)This->wineD3D)->dxVersion, pDeclaration, ppVertexDeclaration);
1609 D3DCREATEOBJECTINSTANCE(object, VertexDeclaration)
1612 hr = IWineD3DVertexDeclaration_SetDeclaration((IWineD3DVertexDeclaration *)object, (void *)pDeclaration);
1617 /* http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/programmable/vertexshaders/vscreate.asp */
1618 HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexShader(IWineD3DDevice *iface, CONST DWORD *pDeclaration, CONST DWORD *pFunction, IWineD3DVertexShader **ppVertexShader, IUnknown *parent) {
1619 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1620 IWineD3DVertexShaderImpl *object; /* NOTE: impl usage is ok, this is a create */
1621 HRESULT hr = D3D_OK;
1622 D3DCREATEOBJECTINSTANCE(object, VertexShader)
1623 object->shader_ins = IWineD3DVertexShaderImpl_shader_ins;
1625 TRACE("(%p) : Created Vertex shader %p\n", This, *ppVertexShader);
1627 /* If a vertex declaration has been passed, save it to the vertex shader, this affects d3d8 only. */
1628 /* Further it needs to be set before calling SetFunction as SetFunction needs the declaration. */
1629 if (pDeclaration != NULL) {
1630 IWineD3DVertexDeclaration *vertexDeclaration;
1631 hr = IWineD3DDevice_CreateVertexDeclaration(iface, pDeclaration, &vertexDeclaration ,NULL);
1633 TRACE("(%p) : Setting vertex declaration to %p\n", This, vertexDeclaration);
1634 object->vertexDeclaration = vertexDeclaration;
1636 FIXME("(%p) : Failed to set the declaration, returning D3DERR_INVALIDCALL\n", iface);
1637 IWineD3DVertexShader_Release(*ppVertexShader);
1638 return D3DERR_INVALIDCALL;
1642 hr = IWineD3DVertexShader_SetFunction(*ppVertexShader, pFunction);
1645 FIXME("(%p) : Failed to set the function, returning D3DERR_INVALIDCALL\n", iface);
1646 IWineD3DVertexShader_Release(*ppVertexShader);
1647 return D3DERR_INVALIDCALL;
1650 #if 0 /* TODO: In D3D* SVP is atatched to the shader, in D3D9 it's attached to the device and isn't stored in the stateblock. */
1651 if(Usage == WINED3DUSAGE_SOFTWAREVERTEXPROCESSING) {
1662 HRESULT WINAPI IWineD3DDeviceImpl_CreatePixelShader(IWineD3DDevice *iface, CONST DWORD *pFunction, IWineD3DPixelShader **ppPixelShader, IUnknown *parent) {
1663 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1664 IWineD3DPixelShaderImpl *object; /* NOTE: impl allowed, this is a create */
1665 HRESULT hr = D3D_OK;
1667 D3DCREATEOBJECTINSTANCE(object, PixelShader)
1668 object->shader_ins = IWineD3DPixelShaderImpl_shader_ins;
1669 hr = IWineD3DPixelShader_SetFunction(*ppPixelShader, pFunction);
1671 TRACE("(%p) : Created Pixel shader %p\n", This, *ppPixelShader);
1673 WARN("(%p) : Failed to create pixel shader\n", This);
1679 HRESULT WINAPI IWineD3DDeviceImpl_GetDirect3D(IWineD3DDevice *iface, IWineD3D **ppD3D) {
1680 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1681 *ppD3D= This->wineD3D;
1682 TRACE("(%p) : wineD3D returning %p\n", This, *ppD3D);
1683 IWineD3D_AddRef(*ppD3D);
1687 UINT WINAPI IWineD3DDeviceImpl_GetAvailableTextureMem(IWineD3DDevice *iface) {
1688 /** NOTE: There's a probably a hack-around for this one by putting as many pbuffers, VBO's (or whatever)
1689 * Into the video ram as possible and seeing how many fit
1690 * you can also get the correct initial value from via X and ATI's driver
1691 *******************/
1692 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1693 static BOOL showfixmes = TRUE;
1695 FIXME("(%p) : stub, emulating %dMib for now, returning %dMib\n", This, (emulated_textureram/(1024*1024)),
1696 ((emulated_textureram - wineD3DGlobalStatistics->glsurfaceram) / (1024*1024)));
1699 TRACE("(%p) : emulating %dMib for now, returning %dMib\n", This, (emulated_textureram/(1024*1024)),
1700 ((emulated_textureram - wineD3DGlobalStatistics->glsurfaceram) / (1024*1024)));
1701 /* videomemory is simulated videomemory + AGP memory left */
1702 return (emulated_textureram - wineD3DGlobalStatistics->glsurfaceram);
1710 HRESULT WINAPI IWineD3DDeviceImpl_SetFVF(IWineD3DDevice *iface, DWORD fvf) {
1711 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1712 HRESULT hr = D3D_OK;
1714 /* Update the current state block */
1715 This->updateStateBlock->fvf = fvf;
1716 This->updateStateBlock->changed.fvf = TRUE;
1717 This->updateStateBlock->set.fvf = TRUE;
1719 TRACE("(%p) : FVF Shader FVF set to %lx\n", This, fvf);
1722 /* clear down the vertex declaration
1723 NOTE: Axis and Allies doesn't work properly otherwise
1724 (may be a stateblock problem though!)
1726 hr = IWineD3DDevice_SetVertexDeclaration(iface, NULL);
1733 HRESULT WINAPI IWineD3DDeviceImpl_GetFVF(IWineD3DDevice *iface, DWORD *pfvf) {
1734 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1735 TRACE("(%p) : GetFVF returning %lx\n", This, This->stateBlock->fvf);
1736 *pfvf = This->stateBlock->fvf;
1741 * Get / Set Stream Source
1743 HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer* pStreamData, UINT OffsetInBytes, UINT Stride) {
1744 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1745 IWineD3DVertexBuffer *oldSrc;
1747 /**TODO: instance and index data, see
1748 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/advancedtopics/DrawingMultipleInstances.asp
1750 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/SetStreamSourceFreq.asp
1753 /* D3d9 only, but shouldn't hurt d3d8 */
1756 streamFlags = StreamNumber &(D3DSTREAMSOURCE_INDEXEDDATA | D3DSTREAMSOURCE_INSTANCEDATA);
1758 if (streamFlags & D3DSTREAMSOURCE_INDEXEDDATA) {
1759 FIXME("stream index data not supported\n");
1761 if (streamFlags & D3DSTREAMSOURCE_INDEXEDDATA) {
1762 FIXME("stream instance data not supported\n");
1766 StreamNumber&= ~(D3DSTREAMSOURCE_INDEXEDDATA | D3DSTREAMSOURCE_INSTANCEDATA);
1768 if (StreamNumber >= MAX_STREAMS) {
1769 WARN("Stream out of range %d\n", StreamNumber);
1770 return D3DERR_INVALIDCALL;
1773 oldSrc = This->stateBlock->streamSource[StreamNumber];
1774 TRACE("(%p) : StreamNo: %d, OldStream (%p), NewStream (%p), NewStride %d\n", This, StreamNumber, oldSrc, pStreamData, Stride);
1776 This->updateStateBlock->changed.streamSource[StreamNumber] = TRUE;
1777 This->updateStateBlock->set.streamSource[StreamNumber] = TRUE;
1778 This->updateStateBlock->streamStride[StreamNumber] = Stride;
1779 This->updateStateBlock->streamSource[StreamNumber] = pStreamData;
1780 This->updateStateBlock->streamOffset[StreamNumber] = OffsetInBytes;
1781 This->updateStateBlock->streamFlags[StreamNumber] = streamFlags;
1783 /* Handle recording of state blocks */
1784 if (This->isRecordingState) {
1785 TRACE("Recording... not performing anything\n");
1789 /* Not recording... */
1790 /* Need to do a getParent and pass the reffs up */
1791 /* MSDN says ..... When an application no longer holds a references to this interface, the interface will automatically be freed.
1792 which suggests that we shouldn't be ref counting? and do need a _release on the stream source to reset the stream source
1793 so for now, just count internally */
1794 if (pStreamData != NULL) {
1795 IWineD3DVertexBuffer_AddRef(pStreamData);
1797 if (oldSrc != NULL) {
1798 IWineD3DVertexBuffer_Release(oldSrc);
1804 HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer** pStream, UINT *pOffset, UINT* pStride) {
1805 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1808 TRACE("(%p) : StreamNo: %d, Stream (%p), Stride %d\n", This, StreamNumber,
1809 This->stateBlock->streamSource[StreamNumber], This->stateBlock->streamStride[StreamNumber]);
1812 streamFlags = StreamNumber &(D3DSTREAMSOURCE_INDEXEDDATA | D3DSTREAMSOURCE_INSTANCEDATA);
1814 if (streamFlags & D3DSTREAMSOURCE_INDEXEDDATA) {
1815 FIXME("stream index data not supported\n");
1817 if (streamFlags & D3DSTREAMSOURCE_INDEXEDDATA) {
1818 FIXME("stream instance data not supported\n");
1822 StreamNumber&= ~(D3DSTREAMSOURCE_INDEXEDDATA | D3DSTREAMSOURCE_INSTANCEDATA);
1824 if (StreamNumber >= MAX_STREAMS) {
1825 WARN("Stream out of range %d\n", StreamNumber);
1826 return D3DERR_INVALIDCALL;
1828 *pStream = This->stateBlock->streamSource[StreamNumber];
1829 *pStride = This->stateBlock->streamStride[StreamNumber];
1830 *pOffset = This->stateBlock->streamOffset[StreamNumber];
1832 if (*pStream == NULL) {
1833 FIXME("Attempting to get an empty stream %d, returning D3DERR_INVALIDCALL\n", StreamNumber);
1834 return D3DERR_INVALIDCALL;
1837 IWineD3DVertexBuffer_AddRef(*pStream); /* We have created a new reference to the VB */
1841 /*Should be quite easy, just an extension of vertexdata
1843 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c_Summer_04/directx/graphics/programmingguide/advancedtopics/DrawingMultipleInstances.asp
1845 The divider is a bit odd though
1847 VertexOffset = StartVertex / Divider * StreamStride +
1848 VertexIndex / Divider * StreamStride + StreamOffset
1851 HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSourceFreq(IWineD3DDevice *iface, UINT StreamNumber, UINT Divider) {
1852 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1854 TRACE("(%p) StreamNumber(%d), Divider(%d)\n", This, StreamNumber, Divider);
1855 This->updateStateBlock->streamFlags[StreamNumber] = Divider & (D3DSTREAMSOURCE_INSTANCEDATA | D3DSTREAMSOURCE_INDEXEDDATA );
1857 This->updateStateBlock->changed.streamFreq[StreamNumber] = TRUE;
1858 This->updateStateBlock->set.streamFreq[StreamNumber] = TRUE;
1859 This->updateStateBlock->streamFreq[StreamNumber] = Divider & 0x7FFFFF;
1861 if (This->updateStateBlock->streamFlags[StreamNumber] || This->updateStateBlock->streamFreq[StreamNumber] != 1) {
1862 FIXME("Stream indexing not fully supported\n");
1868 HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSourceFreq(IWineD3DDevice *iface, UINT StreamNumber, UINT* Divider) {
1869 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1871 TRACE("(%p) StreamNumber(%d), Divider(%p)\n", This, StreamNumber, Divider);
1872 *Divider = This->updateStateBlock->streamFreq[StreamNumber] | This->updateStateBlock->streamFlags[StreamNumber];
1874 TRACE("(%p) : returning %d\n", This, *Divider);
1880 * Get / Set & Multiply Transform
1882 HRESULT WINAPI IWineD3DDeviceImpl_SetTransform(IWineD3DDevice *iface, D3DTRANSFORMSTATETYPE d3dts, CONST D3DMATRIX* lpmatrix) {
1883 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1885 /* Most of this routine, comments included copied from ddraw tree initially: */
1886 TRACE("(%p) : Transform State=%d\n", This, d3dts);
1888 /* Handle recording of state blocks */
1889 if (This->isRecordingState) {
1890 TRACE("Recording... not performing anything\n");
1891 This->updateStateBlock->changed.transform[d3dts] = TRUE;
1892 This->updateStateBlock->set.transform[d3dts] = TRUE;
1893 memcpy(&This->updateStateBlock->transforms[d3dts], lpmatrix, sizeof(D3DMATRIX));
1898 * If the new matrix is the same as the current one,
1899 * we cut off any further processing. this seems to be a reasonable
1900 * optimization because as was noticed, some apps (warcraft3 for example)
1901 * tend towards setting the same matrix repeatedly for some reason.
1903 * From here on we assume that the new matrix is different, wherever it matters.
1905 if (!memcmp(&This->stateBlock->transforms[d3dts].u.m[0][0], lpmatrix, sizeof(D3DMATRIX))) {
1906 TRACE("The app is setting the same matrix over again\n");
1909 conv_mat(lpmatrix, &This->stateBlock->transforms[d3dts].u.m[0][0]);
1913 ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
1914 where ViewMat = Camera space, WorldMat = world space.
1916 In OpenGL, camera and world space is combined into GL_MODELVIEW
1917 matrix. The Projection matrix stay projection matrix.
1920 /* Capture the times we can just ignore the change for now */
1921 if (d3dts == D3DTS_WORLDMATRIX(0)) {
1922 This->modelview_valid = FALSE;
1925 } else if (d3dts == D3DTS_PROJECTION) {
1926 This->proj_valid = FALSE;
1929 } else if (d3dts >= D3DTS_WORLDMATRIX(1) && d3dts <= D3DTS_WORLDMATRIX(255)) {
1930 /* Indexed Vertex Blending Matrices 256 -> 511 */
1931 /* Use arb_vertex_blend or NV_VERTEX_WEIGHTING? */
1932 FIXME("D3DTS_WORLDMATRIX(1..255) not handled\n");
1936 /* Now we really are going to have to change a matrix */
1939 if (d3dts >= D3DTS_TEXTURE0 && d3dts <= D3DTS_TEXTURE7) { /* handle texture matrices */
1940 /* This is now set with the texture unit states, it may be a good idea to flag the change though! */
1941 } else if (d3dts == D3DTS_VIEW) { /* handle the VIEW matrice */
1944 /* If we are changing the View matrix, reset the light and clipping planes to the new view
1945 * NOTE: We have to reset the positions even if the light/plane is not currently
1946 * enabled, since the call to enable it will not reset the position.
1947 * NOTE2: Apparently texture transforms do NOT need reapplying
1950 PLIGHTINFOEL *lightChain = NULL;
1951 This->modelview_valid = FALSE;
1952 This->view_ident = !memcmp(lpmatrix, identity, 16 * sizeof(float));
1954 glMatrixMode(GL_MODELVIEW);
1955 checkGLcall("glMatrixMode(GL_MODELVIEW)");
1957 glLoadMatrixf((float *)lpmatrix);
1958 checkGLcall("glLoadMatrixf(...)");
1961 lightChain = This->stateBlock->lights;
1962 while (lightChain && lightChain->glIndex != -1) {
1963 glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_POSITION, lightChain->lightPosn);
1964 checkGLcall("glLightfv posn");
1965 glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_SPOT_DIRECTION, lightChain->lightDirn);
1966 checkGLcall("glLightfv dirn");
1967 lightChain = lightChain->next;
1970 /* Reset Clipping Planes if clipping is enabled */
1971 for (k = 0; k < GL_LIMITS(clipplanes); k++) {
1972 glClipPlane(GL_CLIP_PLANE0 + k, This->stateBlock->clipplane[k]);
1973 checkGLcall("glClipPlane");
1977 } else { /* What was requested!?? */
1978 WARN("invalid matrix specified: %i\n", d3dts);
1981 /* Release lock, all done */
1986 HRESULT WINAPI IWineD3DDeviceImpl_GetTransform(IWineD3DDevice *iface, D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) {
1987 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1988 TRACE("(%p) : for Transform State %d\n", This, State);
1989 memcpy(pMatrix, &This->stateBlock->transforms[State], sizeof(D3DMATRIX));
1993 HRESULT WINAPI IWineD3DDeviceImpl_MultiplyTransform(IWineD3DDevice *iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) {
1994 D3DMATRIX *mat = NULL;
1997 /* Note: Using 'updateStateBlock' rather than 'stateblock' in the code
1998 * below means it will be recorded in a state block change, but it
1999 * works regardless where it is recorded.
2000 * If this is found to be wrong, change to StateBlock.
2002 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2003 TRACE("(%p) : For state %u\n", This, State);
2005 if (State < HIGHEST_TRANSFORMSTATE)
2007 mat = &This->updateStateBlock->transforms[State];
2009 FIXME("Unhandled transform state!!\n");
2012 /* Copied from ddraw code: */
2013 temp.u.s._11 = (mat->u.s._11 * pMatrix->u.s._11) + (mat->u.s._21 * pMatrix->u.s._12) +
2014 (mat->u.s._31 * pMatrix->u.s._13) + (mat->u.s._41 * pMatrix->u.s._14);
2015 temp.u.s._21 = (mat->u.s._11 * pMatrix->u.s._21) + (mat->u.s._21 * pMatrix->u.s._22) +
2016 (mat->u.s._31 * pMatrix->u.s._23) + (mat->u.s._41 * pMatrix->u.s._24);
2017 temp.u.s._31 = (mat->u.s._11 * pMatrix->u.s._31) + (mat->u.s._21 * pMatrix->u.s._32) +
2018 (mat->u.s._31 * pMatrix->u.s._33) + (mat->u.s._41 * pMatrix->u.s._34);
2019 temp.u.s._41 = (mat->u.s._11 * pMatrix->u.s._41) + (mat->u.s._21 * pMatrix->u.s._42) +
2020 (mat->u.s._31 * pMatrix->u.s._43) + (mat->u.s._41 * pMatrix->u.s._44);
2022 temp.u.s._12 = (mat->u.s._12 * pMatrix->u.s._11) + (mat->u.s._22 * pMatrix->u.s._12) +
2023 (mat->u.s._32 * pMatrix->u.s._13) + (mat->u.s._42 * pMatrix->u.s._14);
2024 temp.u.s._22 = (mat->u.s._12 * pMatrix->u.s._21) + (mat->u.s._22 * pMatrix->u.s._22) +
2025 (mat->u.s._32 * pMatrix->u.s._23) + (mat->u.s._42 * pMatrix->u.s._24);
2026 temp.u.s._32 = (mat->u.s._12 * pMatrix->u.s._31) + (mat->u.s._22 * pMatrix->u.s._32) +
2027 (mat->u.s._32 * pMatrix->u.s._33) + (mat->u.s._42 * pMatrix->u.s._34);
2028 temp.u.s._42 = (mat->u.s._12 * pMatrix->u.s._41) + (mat->u.s._22 * pMatrix->u.s._42) +
2029 (mat->u.s._32 * pMatrix->u.s._43) + (mat->u.s._42 * pMatrix->u.s._44);
2031 temp.u.s._13 = (mat->u.s._13 * pMatrix->u.s._11) + (mat->u.s._23 * pMatrix->u.s._12) +
2032 (mat->u.s._33 * pMatrix->u.s._13) + (mat->u.s._43 * pMatrix->u.s._14);
2033 temp.u.s._23 = (mat->u.s._13 * pMatrix->u.s._21) + (mat->u.s._23 * pMatrix->u.s._22) +
2034 (mat->u.s._33 * pMatrix->u.s._23) + (mat->u.s._43 * pMatrix->u.s._24);
2035 temp.u.s._33 = (mat->u.s._13 * pMatrix->u.s._31) + (mat->u.s._23 * pMatrix->u.s._32) +
2036 (mat->u.s._33 * pMatrix->u.s._33) + (mat->u.s._43 * pMatrix->u.s._34);
2037 temp.u.s._43 = (mat->u.s._13 * pMatrix->u.s._41) + (mat->u.s._23 * pMatrix->u.s._42) +
2038 (mat->u.s._33 * pMatrix->u.s._43) + (mat->u.s._43 * pMatrix->u.s._44);
2040 temp.u.s._14 = (mat->u.s._14 * pMatrix->u.s._11) + (mat->u.s._24 * pMatrix->u.s._12) +
2041 (mat->u.s._34 * pMatrix->u.s._13) + (mat->u.s._44 * pMatrix->u.s._14);
2042 temp.u.s._24 = (mat->u.s._14 * pMatrix->u.s._21) + (mat->u.s._24 * pMatrix->u.s._22) +
2043 (mat->u.s._34 * pMatrix->u.s._23) + (mat->u.s._44 * pMatrix->u.s._24);
2044 temp.u.s._34 = (mat->u.s._14 * pMatrix->u.s._31) + (mat->u.s._24 * pMatrix->u.s._32) +
2045 (mat->u.s._34 * pMatrix->u.s._33) + (mat->u.s._44 * pMatrix->u.s._34);
2046 temp.u.s._44 = (mat->u.s._14 * pMatrix->u.s._41) + (mat->u.s._24 * pMatrix->u.s._42) +
2047 (mat->u.s._34 * pMatrix->u.s._43) + (mat->u.s._44 * pMatrix->u.s._44);
2049 /* Apply change via set transform - will reapply to eg. lights this way */
2050 return IWineD3DDeviceImpl_SetTransform(iface, State, &temp);
2055 * WARNING: This code relies on the fact that D3DLIGHT8 == D3DLIGHT9
2057 /* Note lights are real special cases. Although the device caps state only eg. 8 are supported,
2058 you can reference any indexes you want as long as that number max are enabled at any
2059 one point in time! Therefore since the indexes can be anything, we need a linked list of them.
2060 However, this causes stateblock problems. When capturing the state block, I duplicate the list,
2061 but when recording, just build a chain pretty much of commands to be replayed. */
2063 HRESULT WINAPI IWineD3DDeviceImpl_SetLight(IWineD3DDevice *iface, DWORD Index, CONST WINED3DLIGHT* pLight) {
2065 PLIGHTINFOEL *object, *temp;
2067 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2068 TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight);
2070 /* If recording state block, just add to end of lights chain */
2071 if (This->isRecordingState) {
2072 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL));
2073 if (NULL == object) {
2074 return D3DERR_OUTOFVIDEOMEMORY;
2076 memcpy(&object->OriginalParms, pLight, sizeof(D3DLIGHT9));
2077 object->OriginalIndex = Index;
2078 object->glIndex = -1;
2079 object->changed = TRUE;
2081 /* Add to the END of the chain of lights changes to be replayed */
2082 if (This->updateStateBlock->lights == NULL) {
2083 This->updateStateBlock->lights = object;
2085 temp = This->updateStateBlock->lights;
2086 while (temp->next != NULL) temp=temp->next;
2087 temp->next = object;
2089 TRACE("Recording... not performing anything more\n");
2093 /* Ok, not recording any longer so do real work */
2094 object = This->stateBlock->lights;
2095 while (object != NULL && object->OriginalIndex != Index) object = object->next;
2097 /* If we didn't find it in the list of lights, time to add it */
2098 if (object == NULL) {
2099 PLIGHTINFOEL *insertAt,*prevPos;
2101 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL));
2102 if (NULL == object) {
2103 return D3DERR_OUTOFVIDEOMEMORY;
2105 object->OriginalIndex = Index;
2106 object->glIndex = -1;
2108 /* Add it to the front of list with the idea that lights will be changed as needed
2109 BUT after any lights currently assigned GL indexes */
2110 insertAt = This->stateBlock->lights;
2112 while (insertAt != NULL && insertAt->glIndex != -1) {
2114 insertAt = insertAt->next;
2117 if (insertAt == NULL && prevPos == NULL) { /* Start of list */
2118 This->stateBlock->lights = object;
2119 } else if (insertAt == NULL) { /* End of list */
2120 prevPos->next = object;
2121 object->prev = prevPos;
2122 } else { /* Middle of chain */
2123 if (prevPos == NULL) {
2124 This->stateBlock->lights = object;
2126 prevPos->next = object;
2128 object->prev = prevPos;
2129 object->next = insertAt;
2130 insertAt->prev = object;
2134 /* Initialize the object */
2135 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,
2136 pLight->Diffuse.r, pLight->Diffuse.g, pLight->Diffuse.b, pLight->Diffuse.a,
2137 pLight->Specular.r, pLight->Specular.g, pLight->Specular.b, pLight->Specular.a,
2138 pLight->Ambient.r, pLight->Ambient.g, pLight->Ambient.b, pLight->Ambient.a);
2139 TRACE("... Pos(%f,%f,%f), Dirn(%f,%f,%f)\n", pLight->Position.x, pLight->Position.y, pLight->Position.z,
2140 pLight->Direction.x, pLight->Direction.y, pLight->Direction.z);
2141 TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n", pLight->Range, pLight->Falloff, pLight->Theta, pLight->Phi);
2143 /* Save away the information */
2144 memcpy(&object->OriginalParms, pLight, sizeof(D3DLIGHT9));
2146 switch (pLight->Type) {
2147 case D3DLIGHT_POINT:
2149 object->lightPosn[0] = pLight->Position.x;
2150 object->lightPosn[1] = pLight->Position.y;
2151 object->lightPosn[2] = pLight->Position.z;
2152 object->lightPosn[3] = 1.0f;
2153 object->cutoff = 180.0f;
2157 case D3DLIGHT_DIRECTIONAL:
2159 object->lightPosn[0] = -pLight->Direction.x;
2160 object->lightPosn[1] = -pLight->Direction.y;
2161 object->lightPosn[2] = -pLight->Direction.z;
2162 object->lightPosn[3] = 0.0;
2163 object->exponent = 0.0f;
2164 object->cutoff = 180.0f;
2169 object->lightPosn[0] = pLight->Position.x;
2170 object->lightPosn[1] = pLight->Position.y;
2171 object->lightPosn[2] = pLight->Position.z;
2172 object->lightPosn[3] = 1.0;
2175 object->lightDirn[0] = pLight->Direction.x;
2176 object->lightDirn[1] = pLight->Direction.y;
2177 object->lightDirn[2] = pLight->Direction.z;
2178 object->lightDirn[3] = 1.0;
2181 * opengl-ish and d3d-ish spot lights use too different models for the
2182 * light "intensity" as a function of the angle towards the main light direction,
2183 * so we only can approximate very roughly.
2184 * however spot lights are rather rarely used in games (if ever used at all).
2185 * furthermore if still used, probably nobody pays attention to such details.
2187 if (pLight->Falloff == 0) {
2190 rho = pLight->Theta + (pLight->Phi - pLight->Theta)/(2*pLight->Falloff);
2192 if (rho < 0.0001) rho = 0.0001f;
2193 object->exponent = -0.3/log(cos(rho/2));
2194 object->cutoff = pLight->Phi*90/M_PI;
2200 FIXME("Unrecognized light type %d\n", pLight->Type);
2203 /* Update the live definitions if the light is currently assigned a glIndex */
2204 if (object->glIndex != -1) {
2205 setup_light(iface, object->glIndex, object);
2210 HRESULT WINAPI IWineD3DDeviceImpl_GetLight(IWineD3DDevice *iface, DWORD Index, WINED3DLIGHT* pLight) {
2211 PLIGHTINFOEL *lightInfo = NULL;
2212 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2213 TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight);
2215 /* Locate the light in the live lights */
2216 lightInfo = This->stateBlock->lights;
2217 while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next;
2219 if (lightInfo == NULL) {
2220 TRACE("Light information requested but light not defined\n");
2221 return D3DERR_INVALIDCALL;
2224 memcpy(pLight, &lightInfo->OriginalParms, sizeof(D3DLIGHT9));
2229 * Get / Set Light Enable
2230 * (Note for consistency, renamed d3dx function by adding the 'set' prefix)
2232 HRESULT WINAPI IWineD3DDeviceImpl_SetLightEnable(IWineD3DDevice *iface, DWORD Index, BOOL Enable) {
2233 PLIGHTINFOEL *lightInfo = NULL;
2234 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2235 TRACE("(%p) : Idx(%ld), enable? %d\n", This, Index, Enable);
2237 /* If recording state block, just add to end of lights chain with changedEnable set to true */
2238 if (This->isRecordingState) {
2239 lightInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL));
2240 if (NULL == lightInfo) {
2241 return D3DERR_OUTOFVIDEOMEMORY;
2243 lightInfo->OriginalIndex = Index;
2244 lightInfo->glIndex = -1;
2245 lightInfo->enabledChanged = TRUE;
2247 /* Add to the END of the chain of lights changes to be replayed */
2248 if (This->updateStateBlock->lights == NULL) {
2249 This->updateStateBlock->lights = lightInfo;
2251 PLIGHTINFOEL *temp = This->updateStateBlock->lights;
2252 while (temp->next != NULL) temp=temp->next;
2253 temp->next = lightInfo;
2255 TRACE("Recording... not performing anything more\n");
2259 /* Not recording... So, locate the light in the live lights */
2260 lightInfo = This->stateBlock->lights;
2261 while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next;
2263 /* Special case - enabling an undefined light creates one with a strict set of parms! */
2264 if (lightInfo == NULL) {
2265 D3DLIGHT9 lightParms;
2266 /* Warning - untested code :-) Prob safe to change fixme to a trace but
2267 wait until someone confirms it seems to work! */
2268 TRACE("Light enabled requested but light not defined, so defining one!\n");
2269 lightParms.Type = D3DLIGHT_DIRECTIONAL;
2270 lightParms.Diffuse.r = 1.0;
2271 lightParms.Diffuse.g = 1.0;
2272 lightParms.Diffuse.b = 1.0;
2273 lightParms.Diffuse.a = 0.0;
2274 lightParms.Specular.r = 0.0;
2275 lightParms.Specular.g = 0.0;
2276 lightParms.Specular.b = 0.0;
2277 lightParms.Specular.a = 0.0;
2278 lightParms.Ambient.r = 0.0;
2279 lightParms.Ambient.g = 0.0;
2280 lightParms.Ambient.b = 0.0;
2281 lightParms.Ambient.a = 0.0;
2282 lightParms.Position.x = 0.0;
2283 lightParms.Position.y = 0.0;
2284 lightParms.Position.z = 0.0;
2285 lightParms.Direction.x = 0.0;
2286 lightParms.Direction.y = 0.0;
2287 lightParms.Direction.z = 1.0;
2288 lightParms.Range = 0.0;
2289 lightParms.Falloff = 0.0;
2290 lightParms.Attenuation0 = 0.0;
2291 lightParms.Attenuation1 = 0.0;
2292 lightParms.Attenuation2 = 0.0;
2293 lightParms.Theta = 0.0;
2294 lightParms.Phi = 0.0;
2295 IWineD3DDeviceImpl_SetLight(iface, Index, &lightParms);
2297 /* Search for it again! Should be fairly quick as near head of list */
2298 lightInfo = This->stateBlock->lights;
2299 while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next;
2300 if (lightInfo == NULL) {
2301 FIXME("Adding default lights has failed dismally\n");
2302 return D3DERR_INVALIDCALL;
2306 /* OK, we now have a light... */
2307 if (Enable == FALSE) {
2309 /* If we are disabling it, check it was enabled, and
2310 still only do something if it has assigned a glIndex (which it should have!) */
2311 if ((lightInfo->lightEnabled) && (lightInfo->glIndex != -1)) {
2312 TRACE("Disabling light set up at gl idx %ld\n", lightInfo->glIndex);
2314 glDisable(GL_LIGHT0 + lightInfo->glIndex);
2315 checkGLcall("glDisable GL_LIGHT0+Index");
2318 TRACE("Nothing to do as light was not enabled\n");
2320 lightInfo->lightEnabled = FALSE;
2323 /* We are enabling it. If it is enabled, it's really simple */
2324 if (lightInfo->lightEnabled) {
2326 TRACE("Nothing to do as light was enabled\n");
2328 /* If it already has a glIndex, it's still simple */
2329 } else if (lightInfo->glIndex != -1) {
2330 TRACE("Reusing light as already set up at gl idx %ld\n", lightInfo->glIndex);
2331 lightInfo->lightEnabled = TRUE;
2333 glEnable(GL_LIGHT0 + lightInfo->glIndex);
2334 checkGLcall("glEnable GL_LIGHT0+Index already setup");
2337 /* Otherwise got to find space - lights are ordered gl indexes first */
2339 PLIGHTINFOEL *bsf = NULL;
2340 PLIGHTINFOEL *pos = This->stateBlock->lights;
2341 PLIGHTINFOEL *prev = NULL;
2345 /* Try to minimize changes as much as possible */
2346 while (pos != NULL && pos->glIndex != -1 && Index < This->maxConcurrentLights) {
2348 /* Try to remember which index can be replaced if necessary */
2349 if (bsf==NULL && pos->lightEnabled == FALSE) {
2350 /* Found a light we can replace, save as best replacement */
2354 /* Step to next space */
2360 /* If we have too many active lights, fail the call */
2361 if ((Index == This->maxConcurrentLights) && (bsf == NULL)) {
2362 FIXME("Program requests too many concurrent lights\n");
2363 return D3DERR_INVALIDCALL;
2365 /* If we have allocated all lights, but not all are enabled,
2366 reuse one which is not enabled */
2367 } else if (Index == This->maxConcurrentLights) {
2368 /* use bsf - Simply swap the new light and the BSF one */
2369 PLIGHTINFOEL *bsfNext = bsf->next;
2370 PLIGHTINFOEL *bsfPrev = bsf->prev;
2373 if (lightInfo->next != NULL) lightInfo->next->prev = bsf;
2374 if (bsf->prev != NULL) {
2375 bsf->prev->next = lightInfo;
2377 This->stateBlock->lights = lightInfo;
2380 /* If not side by side, lots of chains to update */
2381 if (bsf->next != lightInfo) {
2382 lightInfo->prev->next = bsf;
2383 bsf->next->prev = lightInfo;
2384 bsf->next = lightInfo->next;
2385 bsf->prev = lightInfo->prev;
2386 lightInfo->next = bsfNext;
2387 lightInfo->prev = bsfPrev;
2391 bsf->prev = lightInfo;
2392 bsf->next = lightInfo->next;
2393 lightInfo->next = bsf;
2394 lightInfo->prev = bsfPrev;
2399 glIndex = bsf->glIndex;
2401 lightInfo->glIndex = glIndex;
2402 lightInfo->lightEnabled = TRUE;
2404 /* Finally set up the light in gl itself */
2405 TRACE("Replacing light which was set up at gl idx %ld\n", lightInfo->glIndex);
2407 setup_light(iface, glIndex, lightInfo);
2408 glEnable(GL_LIGHT0 + glIndex);
2409 checkGLcall("glEnable GL_LIGHT0 new setup");
2412 /* If we reached the end of the allocated lights, with space in the
2413 gl lights, setup a new light */
2414 } else if (pos->glIndex == -1) {
2416 /* We reached the end of the allocated gl lights, so already
2417 know the index of the next one! */
2419 lightInfo->glIndex = glIndex;
2420 lightInfo->lightEnabled = TRUE;
2422 /* In an ideal world, it's already in the right place */
2423 if (lightInfo->prev == NULL || lightInfo->prev->glIndex!=-1) {
2424 /* No need to move it */
2426 /* Remove this light from the list */
2427 lightInfo->prev->next = lightInfo->next;
2428 if (lightInfo->next != NULL) {
2429 lightInfo->next->prev = lightInfo->prev;
2432 /* Add in at appropriate place (inbetween prev and pos) */
2433 lightInfo->prev = prev;
2434 lightInfo->next = pos;
2436 This->stateBlock->lights = lightInfo;
2438 prev->next = lightInfo;
2441 pos->prev = lightInfo;
2445 /* Finally set up the light in gl itself */
2446 TRACE("Defining new light at gl idx %ld\n", lightInfo->glIndex);
2448 setup_light(iface, glIndex, lightInfo);
2449 glEnable(GL_LIGHT0 + glIndex);
2450 checkGLcall("glEnable GL_LIGHT0 new setup");
2459 HRESULT WINAPI IWineD3DDeviceImpl_GetLightEnable(IWineD3DDevice *iface, DWORD Index,BOOL* pEnable) {
2461 PLIGHTINFOEL *lightInfo = NULL;
2462 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2463 TRACE("(%p) : for idx(%ld)\n", This, Index);
2465 /* Locate the light in the live lights */
2466 lightInfo = This->stateBlock->lights;
2467 while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next;
2469 if (lightInfo == NULL) {
2470 TRACE("Light enabled state requested but light not defined\n");
2471 return D3DERR_INVALIDCALL;
2473 *pEnable = lightInfo->lightEnabled;
2478 * Get / Set Clip Planes
2480 HRESULT WINAPI IWineD3DDeviceImpl_SetClipPlane(IWineD3DDevice *iface, DWORD Index, CONST float *pPlane) {
2481 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2482 TRACE("(%p) : for idx %ld, %p\n", This, Index, pPlane);
2484 /* Validate Index */
2485 if (Index >= GL_LIMITS(clipplanes)) {
2486 TRACE("Application has requested clipplane this device doesn't support\n");
2487 return D3DERR_INVALIDCALL;
2490 This->updateStateBlock->changed.clipplane[Index] = TRUE;
2491 This->updateStateBlock->set.clipplane[Index] = TRUE;
2492 This->updateStateBlock->clipplane[Index][0] = pPlane[0];
2493 This->updateStateBlock->clipplane[Index][1] = pPlane[1];
2494 This->updateStateBlock->clipplane[Index][2] = pPlane[2];
2495 This->updateStateBlock->clipplane[Index][3] = pPlane[3];
2497 /* Handle recording of state blocks */
2498 if (This->isRecordingState) {
2499 TRACE("Recording... not performing anything\n");
2507 /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
2508 glMatrixMode(GL_MODELVIEW);
2510 glLoadMatrixf((float *) &This->stateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
2512 TRACE("Clipplane [%f,%f,%f,%f]\n",
2513 This->updateStateBlock->clipplane[Index][0],
2514 This->updateStateBlock->clipplane[Index][1],
2515 This->updateStateBlock->clipplane[Index][2],
2516 This->updateStateBlock->clipplane[Index][3]);
2517 glClipPlane(GL_CLIP_PLANE0 + Index, This->updateStateBlock->clipplane[Index]);
2518 checkGLcall("glClipPlane");
2526 HRESULT WINAPI IWineD3DDeviceImpl_GetClipPlane(IWineD3DDevice *iface, DWORD Index, float *pPlane) {
2527 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2528 TRACE("(%p) : for idx %ld\n", This, Index);
2530 /* Validate Index */
2531 if (Index >= GL_LIMITS(clipplanes)) {
2532 TRACE("Application has requested clipplane this device doesn't support\n");
2533 return D3DERR_INVALIDCALL;
2536 pPlane[0] = This->stateBlock->clipplane[Index][0];
2537 pPlane[1] = This->stateBlock->clipplane[Index][1];
2538 pPlane[2] = This->stateBlock->clipplane[Index][2];
2539 pPlane[3] = This->stateBlock->clipplane[Index][3];
2544 * Get / Set Clip Plane Status
2545 * WARNING: This code relies on the fact that D3DCLIPSTATUS8 == D3DCLIPSTATUS9
2547 HRESULT WINAPI IWineD3DDeviceImpl_SetClipStatus(IWineD3DDevice *iface, CONST WINED3DCLIPSTATUS* pClipStatus) {
2548 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2549 FIXME("(%p) : stub\n", This);
2550 if (NULL == pClipStatus) {
2551 return D3DERR_INVALIDCALL;
2553 This->updateStateBlock->clip_status.ClipUnion = pClipStatus->ClipUnion;
2554 This->updateStateBlock->clip_status.ClipIntersection = pClipStatus->ClipIntersection;
2558 HRESULT WINAPI IWineD3DDeviceImpl_GetClipStatus(IWineD3DDevice *iface, WINED3DCLIPSTATUS* pClipStatus) {
2559 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2560 FIXME("(%p) : stub\n", This);
2561 if (NULL == pClipStatus) {
2562 return D3DERR_INVALIDCALL;
2564 pClipStatus->ClipUnion = This->updateStateBlock->clip_status.ClipUnion;
2565 pClipStatus->ClipIntersection = This->updateStateBlock->clip_status.ClipIntersection;
2570 * Get / Set Material
2571 * WARNING: This code relies on the fact that D3DMATERIAL8 == D3DMATERIAL9
2573 HRESULT WINAPI IWineD3DDeviceImpl_SetMaterial(IWineD3DDevice *iface, CONST WINED3DMATERIAL* pMaterial) {
2574 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2576 This->updateStateBlock->changed.material = TRUE;
2577 This->updateStateBlock->set.material = TRUE;
2578 memcpy(&This->updateStateBlock->material, pMaterial, sizeof(WINED3DMATERIAL));
2580 /* Handle recording of state blocks */
2581 if (This->isRecordingState) {
2582 TRACE("Recording... not performing anything\n");
2587 TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g,
2588 pMaterial->Diffuse.b, pMaterial->Diffuse.a);
2589 TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g,
2590 pMaterial->Ambient.b, pMaterial->Ambient.a);
2591 TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g,
2592 pMaterial->Specular.b, pMaterial->Specular.a);
2593 TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g,
2594 pMaterial->Emissive.b, pMaterial->Emissive.a);
2595 TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
2597 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*) &This->updateStateBlock->material.Ambient);
2598 checkGLcall("glMaterialfv(GL_AMBIENT)");
2599 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*) &This->updateStateBlock->material.Diffuse);
2600 checkGLcall("glMaterialfv(GL_DIFFUSE)");
2602 /* Only change material color if specular is enabled, otherwise it is set to black */
2603 if (This->stateBlock->renderState[WINED3DRS_SPECULARENABLE]) {
2604 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &This->updateStateBlock->material.Specular);
2605 checkGLcall("glMaterialfv(GL_SPECULAR");
2607 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
2608 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
2609 checkGLcall("glMaterialfv(GL_SPECULAR");
2611 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*) &This->updateStateBlock->material.Emissive);
2612 checkGLcall("glMaterialfv(GL_EMISSION)");
2613 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, This->updateStateBlock->material.Power);
2614 checkGLcall("glMaterialf(GL_SHININESS");
2620 HRESULT WINAPI IWineD3DDeviceImpl_GetMaterial(IWineD3DDevice *iface, WINED3DMATERIAL* pMaterial) {
2621 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2622 memcpy(pMaterial, &This->updateStateBlock->material, sizeof (WINED3DMATERIAL));
2623 TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g,
2624 pMaterial->Diffuse.b, pMaterial->Diffuse.a);
2625 TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g,
2626 pMaterial->Ambient.b, pMaterial->Ambient.a);
2627 TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g,
2628 pMaterial->Specular.b, pMaterial->Specular.a);
2629 TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g,
2630 pMaterial->Emissive.b, pMaterial->Emissive.a);
2631 TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
2639 HRESULT WINAPI IWineD3DDeviceImpl_SetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer* pIndexData,
2640 UINT BaseVertexIndex) {
2641 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2642 IWineD3DIndexBuffer *oldIdxs;
2644 TRACE("(%p) : Setting to %p, base %d\n", This, pIndexData, BaseVertexIndex);
2645 oldIdxs = This->updateStateBlock->pIndexData;
2647 This->updateStateBlock->changed.indices = TRUE;
2648 This->updateStateBlock->set.indices = TRUE;
2649 This->updateStateBlock->pIndexData = pIndexData;
2650 This->updateStateBlock->baseVertexIndex = BaseVertexIndex;
2652 /* Handle recording of state blocks */
2653 if (This->isRecordingState) {
2654 TRACE("Recording... not performing anything\n");
2658 if (NULL != pIndexData) {
2659 IWineD3DIndexBuffer_AddRef(pIndexData);
2661 if (NULL != oldIdxs) {
2662 IWineD3DIndexBuffer_Release(oldIdxs);
2667 HRESULT WINAPI IWineD3DDeviceImpl_GetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer** ppIndexData, UINT* pBaseVertexIndex) {
2668 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2670 *ppIndexData = This->stateBlock->pIndexData;
2672 /* up ref count on ppindexdata */
2674 IWineD3DIndexBuffer_AddRef(*ppIndexData);
2675 *pBaseVertexIndex = This->stateBlock->baseVertexIndex;
2676 TRACE("(%p) index data set to %p + %u\n", This, ppIndexData, This->stateBlock->baseVertexIndex);
2678 TRACE("(%p) No index data set\n", This);
2680 TRACE("Returning %p %d\n", *ppIndexData, *pBaseVertexIndex);
2686 * Get / Set Viewports
2688 HRESULT WINAPI IWineD3DDeviceImpl_SetViewport(IWineD3DDevice *iface, CONST WINED3DVIEWPORT* pViewport) {
2689 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2691 TRACE("(%p)\n", This);
2692 This->updateStateBlock->changed.viewport = TRUE;
2693 This->updateStateBlock->set.viewport = TRUE;
2694 memcpy(&This->updateStateBlock->viewport, pViewport, sizeof(WINED3DVIEWPORT));
2696 /* Handle recording of state blocks */
2697 if (This->isRecordingState) {
2698 TRACE("Recording... not performing anything\n");
2701 This->viewport_changed = TRUE;
2705 TRACE("(%p) : x=%ld, y=%ld, wid=%ld, hei=%ld, minz=%f, maxz=%f\n", This,
2706 pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ);
2708 glDepthRange(pViewport->MinZ, pViewport->MaxZ);
2709 checkGLcall("glDepthRange");
2710 /* Note: GL requires lower left, DirectX supplies upper left */
2711 /* TODO: replace usage of renderTarget with context management */
2712 glViewport(pViewport->X,
2713 (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height - (pViewport->Y + pViewport->Height)),
2714 pViewport->Width, pViewport->Height);
2716 checkGLcall("glViewport");
2724 HRESULT WINAPI IWineD3DDeviceImpl_GetViewport(IWineD3DDevice *iface, WINED3DVIEWPORT* pViewport) {
2725 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2726 TRACE("(%p)\n", This);
2727 memcpy(pViewport, &This->stateBlock->viewport, sizeof(WINED3DVIEWPORT));
2732 * Get / Set Render States
2733 * TODO: Verify against dx9 definitions
2735 HRESULT WINAPI IWineD3DDeviceImpl_SetRenderState(IWineD3DDevice *iface, D3DRENDERSTATETYPE State, DWORD Value) {
2737 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2738 DWORD OldValue = This->stateBlock->renderState[State];
2740 /* Simple way of referring to either a DWORD or a 4 byte float */
2746 TRACE("(%p)->state = %s(%d), value = %ld\n", This, debug_d3drenderstate(State), State, Value);
2747 This->updateStateBlock->changed.renderState[State] = TRUE;
2748 This->updateStateBlock->set.renderState[State] = TRUE;
2749 This->updateStateBlock->renderState[State] = Value;
2751 /* Handle recording of state blocks */
2752 if (This->isRecordingState) {
2753 TRACE("Recording... not performing anything\n");
2760 case WINED3DRS_FILLMODE :
2761 switch ((D3DFILLMODE) Value) {
2762 case D3DFILL_POINT : glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); break;
2763 case D3DFILL_WIREFRAME : glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break;
2764 case D3DFILL_SOLID : glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break;
2766 FIXME("Unrecognized WINED3DRS_FILLMODE value %ld\n", Value);
2768 checkGLcall("glPolygonMode (fillmode)");
2771 case WINED3DRS_LIGHTING :
2773 glEnable(GL_LIGHTING);
2774 checkGLcall("glEnable GL_LIGHTING");
2776 glDisable(GL_LIGHTING);
2777 checkGLcall("glDisable GL_LIGHTING");
2781 case WINED3DRS_ZENABLE :
2782 switch ((D3DZBUFFERTYPE) Value) {
2784 glDisable(GL_DEPTH_TEST);
2785 checkGLcall("glDisable GL_DEPTH_TEST");
2788 glEnable(GL_DEPTH_TEST);
2789 checkGLcall("glEnable GL_DEPTH_TEST");
2792 glEnable(GL_DEPTH_TEST);
2793 checkGLcall("glEnable GL_DEPTH_TEST");
2794 FIXME("W buffer is not well handled\n");
2797 FIXME("Unrecognized D3DZBUFFERTYPE value %ld\n", Value);
2801 case WINED3DRS_CULLMODE :
2803 /* If we are culling "back faces with clockwise vertices" then
2804 set front faces to be counter clockwise and enable culling
2806 switch ((D3DCULL) Value) {
2808 glDisable(GL_CULL_FACE);
2809 checkGLcall("glDisable GL_CULL_FACE");
2812 glEnable(GL_CULL_FACE);
2813 checkGLcall("glEnable GL_CULL_FACE");
2814 if (This->renderUpsideDown) {
2816 checkGLcall("glFrontFace GL_CW");
2818 glFrontFace(GL_CCW);
2819 checkGLcall("glFrontFace GL_CCW");
2821 glCullFace(GL_BACK);
2824 glEnable(GL_CULL_FACE);
2825 checkGLcall("glEnable GL_CULL_FACE");
2826 if (This->renderUpsideDown) {
2827 glFrontFace(GL_CCW);
2828 checkGLcall("glFrontFace GL_CCW");
2831 checkGLcall("glFrontFace GL_CW");
2833 glCullFace(GL_BACK);
2836 FIXME("Unrecognized/Unhandled D3DCULL value %ld\n", Value);
2840 case WINED3DRS_SHADEMODE :
2841 switch ((D3DSHADEMODE) Value) {
2843 glShadeModel(GL_FLAT);
2844 checkGLcall("glShadeModel");
2846 case D3DSHADE_GOURAUD:
2847 glShadeModel(GL_SMOOTH);
2848 checkGLcall("glShadeModel");
2850 case D3DSHADE_PHONG:
2851 FIXME("D3DSHADE_PHONG isn't supported?\n");
2854 return D3DERR_INVALIDCALL;
2856 FIXME("Unrecognized/Unhandled D3DSHADEMODE value %ld\n", Value);
2860 case WINED3DRS_DITHERENABLE :
2862 glEnable(GL_DITHER);
2863 checkGLcall("glEnable GL_DITHER");
2865 glDisable(GL_DITHER);
2866 checkGLcall("glDisable GL_DITHER");
2870 case WINED3DRS_ZWRITEENABLE :
2873 checkGLcall("glDepthMask");
2876 checkGLcall("glDepthMask");
2880 case WINED3DRS_ZFUNC :
2882 int glParm = GL_LESS;
2884 switch ((D3DCMPFUNC) Value) {
2885 case D3DCMP_NEVER: glParm=GL_NEVER; break;
2886 case D3DCMP_LESS: glParm=GL_LESS; break;
2887 case D3DCMP_EQUAL: glParm=GL_EQUAL; break;
2888 case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break;
2889 case D3DCMP_GREATER: glParm=GL_GREATER; break;
2890 case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break;
2891 case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break;
2892 case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break;
2894 FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value);
2896 glDepthFunc(glParm);
2897 checkGLcall("glDepthFunc");
2901 case WINED3DRS_AMBIENT :
2904 D3DCOLORTOGLFLOAT4(Value, col);
2905 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
2906 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
2907 checkGLcall("glLightModel for MODEL_AMBIENT");
2912 case WINED3DRS_ALPHABLENDENABLE :
2915 checkGLcall("glEnable GL_BLEND");
2917 glDisable(GL_BLEND);
2918 checkGLcall("glDisable GL_BLEND");
2922 case WINED3DRS_SRCBLEND :
2923 case WINED3DRS_DESTBLEND :
2925 int newVal = GL_ZERO;
2927 case D3DBLEND_ZERO : newVal = GL_ZERO; break;
2928 case D3DBLEND_ONE : newVal = GL_ONE; break;
2929 case D3DBLEND_SRCCOLOR : newVal = GL_SRC_COLOR; break;
2930 case D3DBLEND_INVSRCCOLOR : newVal = GL_ONE_MINUS_SRC_COLOR; break;
2931 case D3DBLEND_SRCALPHA : newVal = GL_SRC_ALPHA; break;
2932 case D3DBLEND_INVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA; break;
2933 case D3DBLEND_DESTALPHA : newVal = GL_DST_ALPHA; break;
2934 case D3DBLEND_INVDESTALPHA : newVal = GL_ONE_MINUS_DST_ALPHA; break;
2935 case D3DBLEND_DESTCOLOR : newVal = GL_DST_COLOR; break;
2936 case D3DBLEND_INVDESTCOLOR : newVal = GL_ONE_MINUS_DST_COLOR; break;
2937 case D3DBLEND_SRCALPHASAT : newVal = GL_SRC_ALPHA_SATURATE; break;
2939 case D3DBLEND_BOTHSRCALPHA : newVal = GL_SRC_ALPHA;
2940 This->srcBlend = newVal;
2941 This->dstBlend = newVal;
2944 case D3DBLEND_BOTHINVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA;
2945 This->srcBlend = newVal;
2946 This->dstBlend = newVal;
2949 FIXME("Unrecognized src/dest blend value %ld (%d)\n", Value, State);
2952 if (State == WINED3DRS_SRCBLEND) This->srcBlend = newVal;
2953 if (State == WINED3DRS_DESTBLEND) This->dstBlend = newVal;
2954 TRACE("glBlendFunc src=%x, dst=%x\n", This->srcBlend, This->dstBlend);
2955 glBlendFunc(This->srcBlend, This->dstBlend);
2957 checkGLcall("glBlendFunc");
2961 case WINED3DRS_ALPHATESTENABLE :
2963 glEnable(GL_ALPHA_TEST);
2964 checkGLcall("glEnable GL_ALPHA_TEST");
2966 glDisable(GL_ALPHA_TEST);
2967 checkGLcall("glDisable GL_ALPHA_TEST");
2971 case WINED3DRS_ALPHAFUNC :
2973 int glParm = GL_LESS;
2974 float ref = ((float) This->stateBlock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
2976 switch ((D3DCMPFUNC) Value) {
2977 case D3DCMP_NEVER: glParm = GL_NEVER; break;
2978 case D3DCMP_LESS: glParm = GL_LESS; break;
2979 case D3DCMP_EQUAL: glParm = GL_EQUAL; break;
2980 case D3DCMP_LESSEQUAL: glParm = GL_LEQUAL; break;
2981 case D3DCMP_GREATER: glParm = GL_GREATER; break;
2982 case D3DCMP_NOTEQUAL: glParm = GL_NOTEQUAL; break;
2983 case D3DCMP_GREATEREQUAL: glParm = GL_GEQUAL; break;
2984 case D3DCMP_ALWAYS: glParm = GL_ALWAYS; break;
2986 FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value);
2988 TRACE("glAlphaFunc with Parm=%x, ref=%f\n", glParm, ref);
2989 glAlphaFunc(glParm, ref);
2990 This->alphafunc = glParm;
2991 checkGLcall("glAlphaFunc");
2995 case WINED3DRS_ALPHAREF :
2997 int glParm = This->alphafunc;
3000 ref = ((float) Value) / 255.0f;
3001 TRACE("glAlphaFunc with Parm=%x, ref=%f\n", glParm, ref);
3002 glAlphaFunc(glParm, ref);
3003 checkGLcall("glAlphaFunc");
3007 case WINED3DRS_CLIPPLANEENABLE :
3008 case WINED3DRS_CLIPPING :
3010 /* Ensure we only do the changed clip planes */
3011 DWORD enable = 0xFFFFFFFF;
3012 DWORD disable = 0x00000000;
3014 /* If enabling / disabling all */
3015 if (State == WINED3DRS_CLIPPING) {
3017 enable = This->stateBlock->renderState[WINED3DRS_CLIPPLANEENABLE];
3020 disable = This->stateBlock->renderState[WINED3DRS_CLIPPLANEENABLE];
3024 enable = Value & ~OldValue;
3025 disable = ~Value & OldValue;
3028 if (enable & D3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
3029 if (enable & D3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
3030 if (enable & D3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
3031 if (enable & D3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
3032 if (enable & D3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
3033 if (enable & D3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
3035 if (disable & D3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
3036 if (disable & D3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
3037 if (disable & D3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
3038 if (disable & D3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
3039 if (disable & D3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
3040 if (disable & D3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
3042 /** update clipping status */
3044 This->stateBlock->clip_status.ClipUnion = 0;
3045 This->stateBlock->clip_status.ClipIntersection = 0xFFFFFFFF;
3047 This->stateBlock->clip_status.ClipUnion = 0;
3048 This->stateBlock->clip_status.ClipIntersection = 0;
3053 case WINED3DRS_BLENDOP :
3055 int glParm = GL_FUNC_ADD;
3057 switch ((D3DBLENDOP) Value) {
3058 case D3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break;
3059 case D3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break;
3060 case D3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
3061 case D3DBLENDOP_MIN : glParm = GL_MIN; break;
3062 case D3DBLENDOP_MAX : glParm = GL_MAX; break;
3064 FIXME("Unrecognized/Unhandled D3DBLENDOP value %ld\n", Value);
3066 TRACE("glBlendEquation(%x)\n", glParm);
3067 glBlendEquation(glParm);
3068 checkGLcall("glBlendEquation");
3072 case WINED3DRS_TEXTUREFACTOR :
3076 /* Note the texture color applies to all textures whereas
3077 GL_TEXTURE_ENV_COLOR applies to active only */
3079 D3DCOLORTOGLFLOAT4(Value, col);
3080 /* Set the default alpha blend color */
3081 glBlendColor(col[0], col[1], col[2], col[3]);
3082 checkGLcall("glBlendColor");
3084 /* And now the default texture color as well */
3085 for (i = 0; i < GL_LIMITS(textures); i++) {
3087 /* Note the D3DRS value applies to all textures, but GL has one
3088 per texture, so apply it now ready to be used! */
3089 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
3092 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
3095 glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
3096 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
3101 case WINED3DRS_SPECULARENABLE :
3103 /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
3104 and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
3105 specular color. This is wrong:
3106 Separate specular color means the specular colour is maintained separately, whereas
3107 single color means it is merged in. However in both cases they are being used to
3109 To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
3110 NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
3114 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &This->updateStateBlock->material.Specular);
3115 checkGLcall("glMaterialfv");
3116 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3117 glEnable(GL_COLOR_SUM_EXT);
3119 TRACE("Specular colors cannot be enabled in this version of opengl\n");
3121 checkGLcall("glEnable(GL_COLOR_SUM)");
3123 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
3125 /* for the case of enabled lighting: */
3126 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
3127 checkGLcall("glMaterialfv");
3129 /* for the case of disabled lighting: */
3130 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3131 glDisable(GL_COLOR_SUM_EXT);
3133 TRACE("Specular colors cannot be disabled in this version of opengl\n");
3135 checkGLcall("glDisable(GL_COLOR_SUM)");
3140 case WINED3DRS_STENCILENABLE :
3142 glEnable(GL_STENCIL_TEST);
3143 checkGLcall("glEnable GL_STENCIL_TEST");
3145 glDisable(GL_STENCIL_TEST);
3146 checkGLcall("glDisable GL_STENCIL_TEST");
3150 case WINED3DRS_STENCILFUNC :
3153 GLint ref = This->stateBlock->renderState[WINED3DRS_STENCILREF];
3154 GLuint mask = This->stateBlock->renderState[WINED3DRS_STENCILMASK];
3157 switch ((D3DCMPFUNC)Value) {
3158 case D3DCMP_NEVER: func = GL_NEVER; break;
3159 case D3DCMP_LESS: func = GL_LESS; break;
3160 case D3DCMP_EQUAL: func = GL_EQUAL; break;
3161 case D3DCMP_LESSEQUAL: func = GL_LEQUAL; break;
3162 case D3DCMP_GREATER: func = GL_GREATER; break;
3163 case D3DCMP_NOTEQUAL: func = GL_NOTEQUAL; break;
3164 case D3DCMP_GREATEREQUAL: func = GL_GEQUAL; break;
3165 case D3DCMP_ALWAYS: func = GL_ALWAYS; break;
3167 FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value);
3169 This->stencilfunc = func;
3170 if(!This->stateBlock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE]) {
3171 #if 0 /* Don't use OpenGL 2.0 calls for now */
3172 if(GL_EXTCALL(glStencilFuncSeparate)) {
3173 GL_EXTCALL(glStencilFuncSeparate(GL_FRONT, func, ref, mask));
3174 checkGLcall("glStencilFuncSeparate(GL_FRONT,...)");
3178 if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
3179 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
3180 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
3181 GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT));
3182 checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
3183 glStencilFunc(func, ref, mask);
3184 checkGLcall("glStencilFunc(...)");
3186 else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
3187 GL_EXTCALL(glStencilFuncSeparateATI(GL_FRONT, func, ref, mask));
3188 checkGLcall("glStencilFuncSeparateATI(GL_FRONT,...)");
3190 TRACE("Separate stencil function not supported on this version of opengl");
3191 glStencilFunc(func, ref, mask);
3192 checkGLcall("glStencilFunc(...)");
3195 glStencilFunc(func, ref, mask);
3196 checkGLcall("glStencilFunc(...)");
3200 case WINED3DRS_STENCILREF :
3202 int glParm = This->stencilfunc;
3204 GLuint mask = This->stateBlock->renderState[WINED3DRS_STENCILMASK];
3207 TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask);
3208 glStencilFunc(glParm, ref, mask);
3209 checkGLcall("glStencilFunc");
3213 case WINED3DRS_STENCILMASK :
3215 int glParm = This->stencilfunc;
3216 int ref = This->stateBlock->renderState[WINED3DRS_STENCILREF];
3217 GLuint mask = Value;
3219 TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask);
3220 glStencilFunc(glParm, ref, mask);
3221 checkGLcall("glStencilFunc");
3225 case WINED3DRS_STENCILFAIL :
3226 case WINED3DRS_STENCILZFAIL :
3227 case WINED3DRS_STENCILPASS :
3233 GLint action = StencilOp(Value);
3235 glGetIntegerv(GL_STENCIL_FAIL, &stencilFail);
3236 glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &depthFail);
3237 glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &stencilPass);
3239 if(WINED3DRS_STENCILFAIL == State) {
3240 stencilFail = action;
3242 else if(WINED3DRS_STENCILZFAIL == State) {
3245 else if(WINED3DRS_STENCILPASS == State) {
3246 stencilPass = action;
3249 if(!This->stateBlock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE]) {
3250 #if 0 /* Don't use OpenGL 2.0 calls for now */
3251 if(GL_EXTCALL(glStencilOpSeparate)) {
3252 GL_EXTCALL(glStencilOpSeparate(GL_FRONT, stencilFail, depthFail, stencilPass));
3253 checkGLcall("glStencilOpSeparate(GL_FRONT,...)");
3257 if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
3258 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
3259 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
3260 GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT));
3261 checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
3262 glStencilOp(stencilFail, depthFail, stencilPass);
3263 checkGLcall("glStencilOp(...)");
3265 else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
3266 GL_EXTCALL(glStencilOpSeparateATI(GL_FRONT, stencilFail, depthFail, stencilPass));
3267 checkGLcall("glStencilOpSeparateATI(GL_FRONT,...)");
3269 TRACE("Separate stencil operation not supported on this version of opengl");
3270 glStencilOp(stencilFail, depthFail, stencilPass);
3271 checkGLcall("glStencilOp(...)");
3274 glStencilOp(stencilFail, depthFail, stencilPass);
3275 checkGLcall("glStencilOp(...)");
3279 case WINED3DRS_STENCILWRITEMASK :
3281 glStencilMask(Value);
3282 TRACE("glStencilMask(%lu)\n", Value);
3283 checkGLcall("glStencilMask");
3287 case WINED3DRS_FOGENABLE :
3289 if (Value/* && This->stateBlock->renderState[WINED3DRS_FOGTABLEMODE] != D3DFOG_NONE*/) {
3291 checkGLcall("glEnable GL_FOG");
3294 checkGLcall("glDisable GL_FOG");
3299 case WINED3DRS_RANGEFOGENABLE :
3302 TRACE("Enabled RANGEFOG");
3304 TRACE("Disabled RANGEFOG");
3309 case WINED3DRS_FOGCOLOR :
3312 D3DCOLORTOGLFLOAT4(Value, col);
3313 /* Set the default alpha blend color */
3314 glFogfv(GL_FOG_COLOR, &col[0]);
3315 checkGLcall("glFog GL_FOG_COLOR");
3319 case WINED3DRS_FOGTABLEMODE :
3321 glHint(GL_FOG_HINT, GL_NICEST);
3323 case D3DFOG_NONE: /* I don't know what to do here */ checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break;
3324 case D3DFOG_EXP: glFogi(GL_FOG_MODE, GL_EXP); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break;
3325 case D3DFOG_EXP2: glFogi(GL_FOG_MODE, GL_EXP2); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2"); break;
3326 case D3DFOG_LINEAR: glFogi(GL_FOG_MODE, GL_LINEAR); checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR"); break;
3328 FIXME("Unsupported Value(%lu) for WINED3DRS_FOGTABLEMODE!\n", Value);
3330 if (GL_SUPPORT(NV_FOG_DISTANCE)) {
3331 glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
3336 case WINED3DRS_FOGVERTEXMODE :
3338 glHint(GL_FOG_HINT, GL_FASTEST);
3340 case D3DFOG_NONE: /* I don't know what to do here */ checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break;
3341 case D3DFOG_EXP: glFogi(GL_FOG_MODE, GL_EXP); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break;
3342 case D3DFOG_EXP2: glFogi(GL_FOG_MODE, GL_EXP2); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2"); break;
3343 case D3DFOG_LINEAR: glFogi(GL_FOG_MODE, GL_LINEAR); checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR"); break;
3345 FIXME("Unsupported Value(%lu) for WINED3DRS_FOGTABLEMODE!\n", Value);
3347 if (GL_SUPPORT(NV_FOG_DISTANCE)) {
3348 glFogi(GL_FOG_DISTANCE_MODE_NV, This->stateBlock->renderState[WINED3DRS_RANGEFOGENABLE] ? GL_EYE_RADIAL_NV : GL_EYE_PLANE_ABSOLUTE_NV);
3353 case WINED3DRS_FOGSTART :
3356 glFogfv(GL_FOG_START, &tmpvalue.f);
3357 checkGLcall("glFogf(GL_FOG_START, (float) Value)");
3358 TRACE("Fog Start == %f\n", tmpvalue.f);
3362 case WINED3DRS_FOGEND :
3365 glFogfv(GL_FOG_END, &tmpvalue.f);
3366 checkGLcall("glFogf(GL_FOG_END, (float) Value)");
3367 TRACE("Fog End == %f\n", tmpvalue.f);
3371 case WINED3DRS_FOGDENSITY :
3374 glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
3375 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
3379 case WINED3DRS_VERTEXBLEND :
3381 This->updateStateBlock->vertex_blend = (D3DVERTEXBLENDFLAGS) Value;
3382 TRACE("Vertex Blending state to %ld\n", Value);
3386 case WINED3DRS_TWEENFACTOR :
3389 This->updateStateBlock->tween_factor = tmpvalue.f;
3390 TRACE("Vertex Blending Tween Factor to %f\n", This->updateStateBlock->tween_factor);
3394 case WINED3DRS_INDEXEDVERTEXBLENDENABLE :
3396 TRACE("Indexed Vertex Blend Enable to %ul\n", (BOOL) Value);
3400 case WINED3DRS_COLORVERTEX :
3401 case WINED3DRS_DIFFUSEMATERIALSOURCE :
3402 case WINED3DRS_SPECULARMATERIALSOURCE :
3403 case WINED3DRS_AMBIENTMATERIALSOURCE :
3404 case WINED3DRS_EMISSIVEMATERIALSOURCE :
3406 GLenum Parm = GL_AMBIENT_AND_DIFFUSE;
3408 if (This->stateBlock->renderState[WINED3DRS_COLORVERTEX]) {
3409 TRACE("diff %ld, amb %ld, emis %ld, spec %ld\n",
3410 This->stateBlock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
3411 This->stateBlock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
3412 This->stateBlock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
3413 This->stateBlock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
3415 if (This->stateBlock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) {
3416 if (This->stateBlock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
3417 Parm = GL_AMBIENT_AND_DIFFUSE;
3421 } else if (This->stateBlock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
3423 } else if (This->stateBlock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) {
3425 } else if (This->stateBlock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) {
3432 if (This->tracking_color != DISABLED_TRACKING) This->tracking_color = NEEDS_DISABLE;
3434 This->tracking_color = NEEDS_TRACKING;
3435 This->tracking_parm = Parm;
3439 if (This->tracking_color != DISABLED_TRACKING) This->tracking_color = NEEDS_DISABLE;
3444 case WINED3DRS_LINEPATTERN :
3450 tmppattern.d = Value;
3452 TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
3454 if (tmppattern.lp.wRepeatFactor) {
3455 glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
3456 checkGLcall("glLineStipple(repeat, linepattern)");
3457 glEnable(GL_LINE_STIPPLE);
3458 checkGLcall("glEnable(GL_LINE_STIPPLE);");
3460 glDisable(GL_LINE_STIPPLE);
3461 checkGLcall("glDisable(GL_LINE_STIPPLE);");
3466 case WINED3DRS_ZBIAS : /* D3D8 only */
3470 TRACE("ZBias value %f\n", tmpvalue.f);
3471 glPolygonOffset(0, -tmpvalue.f);
3472 checkGLcall("glPolygonOffset(0, -Value)");
3473 glEnable(GL_POLYGON_OFFSET_FILL);
3474 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
3475 glEnable(GL_POLYGON_OFFSET_LINE);
3476 checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
3477 glEnable(GL_POLYGON_OFFSET_POINT);
3478 checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
3480 glDisable(GL_POLYGON_OFFSET_FILL);
3481 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
3482 glDisable(GL_POLYGON_OFFSET_LINE);
3483 checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
3484 glDisable(GL_POLYGON_OFFSET_POINT);
3485 checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
3490 case WINED3DRS_NORMALIZENORMALS :
3492 glEnable(GL_NORMALIZE);
3493 checkGLcall("glEnable(GL_NORMALIZE);");
3495 glDisable(GL_NORMALIZE);
3496 checkGLcall("glDisable(GL_NORMALIZE);");
3500 case WINED3DRS_POINTSIZE :
3501 /* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
3503 TRACE("Set point size to %f\n", tmpvalue.f);
3504 glPointSize(tmpvalue.f);
3505 checkGLcall("glPointSize(...);");
3508 case WINED3DRS_POINTSIZE_MIN :
3509 if (GL_SUPPORT(EXT_POINT_PARAMETERS)) {
3511 GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
3512 checkGLcall("glPointParameterfEXT(...);");
3514 FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl\n");
3518 case WINED3DRS_POINTSIZE_MAX :
3519 if (GL_SUPPORT(EXT_POINT_PARAMETERS)) {
3521 GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
3522 checkGLcall("glPointParameterfEXT(...);");
3524 FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl\n");
3528 case WINED3DRS_POINTSCALE_A :
3529 case WINED3DRS_POINTSCALE_B :
3530 case WINED3DRS_POINTSCALE_C :
3531 case WINED3DRS_POINTSCALEENABLE :
3534 * POINTSCALEENABLE controls how point size value is treated. If set to
3535 * true, the point size is scaled with respect to height of viewport.
3536 * When set to false point size is in pixels.
3538 * http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
3541 /* Default values */
3542 GLfloat att[3] = {1.0f, 0.0f, 0.0f};
3545 * Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
3546 * This means that OpenGL will clamp really small point sizes to 1.0f.
3547 * To correct for this we need to multiply by the scale factor when sizes
3548 * are less than 1.0f. scale_factor = 1.0f / point_size.
3550 GLfloat pointSize = *((float*)&This->stateBlock->renderState[WINED3DRS_POINTSIZE]);
3551 if(pointSize > 0.0f) {
3552 GLfloat scaleFactor;
3554 if(pointSize < 1.0f) {
3555 scaleFactor = pointSize * pointSize;
3560 if(This->stateBlock->renderState[WINED3DRS_POINTSCALEENABLE]) {
3561 att[0] = *((float*)&This->stateBlock->renderState[WINED3DRS_POINTSCALE_A]) /
3562 (This->stateBlock->viewport.Height * This->stateBlock->viewport.Height * scaleFactor);
3563 att[1] = *((float*)&This->stateBlock->renderState[WINED3DRS_POINTSCALE_B]) /
3564 (This->stateBlock->viewport.Height * This->stateBlock->viewport.Height * scaleFactor);
3565 att[2] = *((float*)&This->stateBlock->renderState[WINED3DRS_POINTSCALE_C]) /
3566 (This->stateBlock->viewport.Height * This->stateBlock->viewport.Height * scaleFactor);
3570 if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
3571 GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
3572 checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
3574 else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
3575 GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
3576 checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
3578 TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
3582 case WINED3DRS_COLORWRITEENABLE :
3584 TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
3585 Value & D3DCOLORWRITEENABLE_RED ? 1 : 0,
3586 Value & D3DCOLORWRITEENABLE_GREEN ? 1 : 0,
3587 Value & D3DCOLORWRITEENABLE_BLUE ? 1 : 0,
3588 Value & D3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
3589 glColorMask(Value & D3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
3590 Value & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
3591 Value & D3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
3592 Value & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
3593 checkGLcall("glColorMask(...)");
3597 case WINED3DRS_LOCALVIEWER :
3599 GLint state = (Value) ? 1 : 0;
3600 TRACE("Local Viewer Enable to %ul\n", (BOOL) Value);
3601 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, state);
3605 case WINED3DRS_LASTPIXEL :
3608 TRACE("Last Pixel Drawing Enabled\n");
3610 FIXME("Last Pixel Drawing Disabled, not handled yet\n");
3615 case WINED3DRS_SOFTWAREVERTEXPROCESSING :
3618 TRACE("Software Processing Enabled\n");
3620 TRACE("Software Processing Disabled\n");
3625 /** not supported */
3626 case WINED3DRS_ZVISIBLE :
3629 return D3DERR_INVALIDCALL;
3631 case WINED3DRS_POINTSPRITEENABLE :
3633 /* TODO: NV_POINT_SPRITE */
3634 if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
3635 TRACE("Point sprites not supported\n");
3640 * Point sprites are always enabled. Value controls texture coordinate
3641 * replacement mode. Must be set true for point sprites to use
3644 glEnable(GL_POINT_SPRITE_ARB);
3645 checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
3648 glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, TRUE);
3649 checkGLcall("glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, TRUE)");
3651 glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, FALSE);
3652 checkGLcall("glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, FALSE)");
3656 case WINED3DRS_EDGEANTIALIAS :
3659 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3661 checkGLcall("glEnable(GL_BLEND)");
3662 glEnable(GL_LINE_SMOOTH);
3663 checkGLcall("glEnable(GL_LINE_SMOOTH)");
3665 glDisable(GL_BLEND);
3666 checkGLcall("glDisable(GL_BLEND)");
3667 glDisable(GL_LINE_SMOOTH);
3668 checkGLcall("glDisable(GL_LINE_SMOOTH)");
3672 case WINED3DRS_WRAP0 :
3673 case WINED3DRS_WRAP1 :
3674 case WINED3DRS_WRAP2 :
3675 case WINED3DRS_WRAP3 :
3676 case WINED3DRS_WRAP4 :
3677 case WINED3DRS_WRAP5 :
3678 case WINED3DRS_WRAP6 :
3679 case WINED3DRS_WRAP7 :
3681 http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
3682 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
3683 http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
3684 Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
3685 http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
3687 so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
3689 TRACE("(%p)->(%d,%ld) Texture wraping not yet supported\n",This, State, Value);
3691 case WINED3DRS_MULTISAMPLEANTIALIAS :
3693 if (!GL_SUPPORT(ARB_MULTISAMPLE)) {
3694 TRACE("Multisample antialiasing not supported\n");
3699 glEnable(GL_MULTISAMPLE_ARB);
3700 checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
3702 glDisable(GL_MULTISAMPLE_ARB);
3703 checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
3707 case WINED3DRS_SCISSORTESTENABLE :
3710 glEnable(GL_SCISSOR_TEST);
3711 checkGLcall("glEnable(GL_SCISSOR_TEST)");
3713 glDisable(GL_SCISSOR_TEST);
3714 checkGLcall("glDisable(GL_SCISSOR_TEST)");
3718 case WINED3DRS_SLOPESCALEDEPTHBIAS :
3722 glEnable(GL_POLYGON_OFFSET_FILL);
3723 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
3724 glPolygonOffset(tmpvalue.f, *((float*)&This->stateBlock->renderState[WINED3DRS_DEPTHBIAS]));
3725 checkGLcall("glPolygonOffset(...)");
3727 glDisable(GL_POLYGON_OFFSET_FILL);
3728 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
3732 case WINED3DRS_ANTIALIASEDLINEENABLE :
3735 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3737 checkGLcall("glEnable(GL_BLEND)");
3738 glEnable(GL_LINE_SMOOTH);
3739 checkGLcall("glEnable(GL_LINE_SMOOTH)");
3741 glDisable(GL_BLEND);
3742 checkGLcall("glDisable(GL_BLEND)");
3743 glDisable(GL_LINE_SMOOTH);
3744 checkGLcall("glDisable(GL_LINE_SMOOTH)");
3748 case WINED3DRS_MULTISAMPLEMASK :
3749 case WINED3DRS_PATCHEDGESTYLE :
3750 case WINED3DRS_PATCHSEGMENTS :
3751 case WINED3DRS_DEBUGMONITORTOKEN :
3752 case WINED3DRS_POSITIONORDER :
3753 case WINED3DRS_NORMALORDER :
3754 /* Direct3D9 render states */
3755 case WINED3DRS_MINTESSELLATIONLEVEL :
3756 case WINED3DRS_MAXTESSELLATIONLEVEL :
3757 case WINED3DRS_ADAPTIVETESS_X :
3758 case WINED3DRS_ADAPTIVETESS_Y :
3759 case WINED3DRS_ADAPTIVETESS_Z :
3760 case WINED3DRS_ADAPTIVETESS_W :
3761 case WINED3DRS_ENABLEADAPTIVETESSELLATION :
3763 FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value);
3766 case WINED3DRS_TWOSIDEDSTENCILMODE :
3769 TRACE("Two-sided stencil mode enabled\n");
3771 TRACE("Two-sided stencil mode disabled\n");
3775 case WINED3DRS_CCW_STENCILFAIL :
3776 case WINED3DRS_CCW_STENCILZFAIL :
3777 case WINED3DRS_CCW_STENCILPASS :
3783 GLint action = StencilOp(Value);
3785 glGetIntegerv(GL_STENCIL_BACK_FAIL, &stencilFail);
3786 glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &depthFail);
3787 glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &stencilPass);
3789 if(WINED3DRS_CCW_STENCILFAIL == State) {
3790 stencilFail = action;
3792 else if(WINED3DRS_CCW_STENCILZFAIL == State) {
3795 else if(WINED3DRS_CCW_STENCILPASS == State) {
3796 stencilPass = action;
3799 if(!This->stateBlock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE]) {
3800 #if 0 /* Don't use OpenGL 2.0 calls for now */
3801 if(GL_EXTCALL(glStencilOpSeparate)) {
3802 GL_EXTCALL(glStencilOpSeparate(GL_BACK, stencilFail, depthFail, stencilPass));
3803 checkGLcall("glStencilOpSeparate(GL_BACK,...)");
3807 if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
3808 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
3809 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
3810 GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK));
3811 checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
3812 glStencilOp(stencilFail, depthFail, stencilPass);
3813 checkGLcall("glStencilOp(...)");
3815 else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
3816 GL_EXTCALL(glStencilOpSeparateATI(GL_BACK, stencilFail, depthFail, stencilPass));
3817 checkGLcall("glStencilOpSeparateATI(GL_BACK,...)");
3819 TRACE("Separate stencil operation not supported on this version of opengl");
3820 glStencilOp(stencilFail, depthFail, stencilPass);
3821 checkGLcall("glStencilOp(...)");
3824 glStencilOp(stencilFail, depthFail, stencilPass);
3825 checkGLcall("glStencilOp(...)");
3829 case WINED3DRS_CCW_STENCILFUNC :
3832 GLint ref = This->stateBlock->renderState[WINED3DRS_STENCILREF];
3833 GLuint mask = This->stateBlock->renderState[WINED3DRS_STENCILMASK];
3836 switch ((D3DCMPFUNC)Value) {
3837 case D3DCMP_NEVER: func = GL_NEVER; break;
3838 case D3DCMP_LESS: func = GL_LESS; break;
3839 case D3DCMP_EQUAL: func = GL_EQUAL; break;
3840 case D3DCMP_LESSEQUAL: func = GL_LEQUAL; break;
3841 case D3DCMP_GREATER: func = GL_GREATER; break;
3842 case D3DCMP_NOTEQUAL: func = GL_NOTEQUAL; break;
3843 case D3DCMP_GREATEREQUAL: func = GL_GEQUAL; break;
3844 case D3DCMP_ALWAYS: func = GL_ALWAYS; break;
3846 FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value);
3848 This->stencilfunc = func;
3849 if(!This->stateBlock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE]) {
3850 #if 0 /* Don't use OpenGL 2.0 calls for now */
3851 if(GL_EXTCALL(glStencilFuncSeparate)) {
3852 GL_EXTCALL(glStencilFuncSeparate(GL_BACK, func, ref, mask));
3853 checkGLcall("glStencilFuncSeparate(GL_BACK,...)");
3857 if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
3858 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
3859 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
3860 GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK));
3861 checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
3862 glStencilFunc(func, ref, mask);
3863 checkGLcall("glStencilFunc(...)");
3865 else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
3866 GL_EXTCALL(glStencilFuncSeparateATI(GL_BACK, func, ref, mask));
3867 checkGLcall("glStencilFuncSeparateATI(GL_BACK,...)");
3869 TRACE("Separate stencil function not supported on this version of opengl");
3870 glStencilFunc(func, ref, mask);
3871 checkGLcall("glStencilFunc(...)");
3874 glStencilFunc(func, ref, mask);
3875 checkGLcall("glStencilFunc(...)");
3879 case WINED3DRS_COLORWRITEENABLE1 :
3880 case WINED3DRS_COLORWRITEENABLE2 :
3881 case WINED3DRS_COLORWRITEENABLE3 :
3882 case WINED3DRS_BLENDFACTOR :
3883 case WINED3DRS_SRGBWRITEENABLE :
3885 FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value);
3888 case WINED3DRS_DEPTHBIAS :
3892 glEnable(GL_POLYGON_OFFSET_FILL);
3893 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
3894 glPolygonOffset(*((float*)&This->stateBlock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS]), tmpvalue.f);
3895 checkGLcall("glPolygonOffset(...)");
3897 glDisable(GL_POLYGON_OFFSET_FILL);
3898 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
3902 case WINED3DRS_WRAP8 :
3903 case WINED3DRS_WRAP9 :
3904 case WINED3DRS_WRAP10 :
3905 case WINED3DRS_WRAP11 :
3906 case WINED3DRS_WRAP12 :
3907 case WINED3DRS_WRAP13 :
3908 case WINED3DRS_WRAP14 :
3909 case WINED3DRS_WRAP15 :
3910 case WINED3DRS_SEPARATEALPHABLENDENABLE :
3911 case WINED3DRS_SRCBLENDALPHA :
3912 case WINED3DRS_DESTBLENDALPHA :
3913 case WINED3DRS_BLENDOPALPHA :
3914 /*Put back later: FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value); */
3915 FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value);
3918 FIXME("(%p)->(%d,%ld) unrecognized\n", This, State, Value);
3926 HRESULT WINAPI IWineD3DDeviceImpl_GetRenderState(IWineD3DDevice *iface, D3DRENDERSTATETYPE State, DWORD *pValue) {
3927 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3928 TRACE("(%p) for State %d = %ld\n", This, State, This->stateBlock->renderState[State]);
3929 *pValue = This->stateBlock->renderState[State];
3934 * Get / Set Sampler States
3935 * TODO: Verify against dx9 definitions
3938 HRESULT WINAPI IWineD3DDeviceImpl_SetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD Value) {
3939 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3941 * SetSampler is designed to allow for more than the standard up to 8 textures
3942 * and Geforce has stopped supporting more than 6 standard textures in openGL.
3943 * So I have to use ARB for Gforce. (maybe if the sampler > 4 then use ARB?)
3945 * http://developer.nvidia.com/object/General_FAQ.html#t6
3947 * There are two new settings for GForce
3949 * GL_MAX_TEXTURE_IMAGE_UNITS_ARB
3950 * and the texture one:
3951 * GL_MAX_TEXTURE_COORDS_ARB.
3952 * Ok GForce say it's ok to use glTexParameter/glGetTexParameter(...).
3954 /** NOTE: States are appled in IWineD3DBaseTextre ApplyStateChanges and IWineD3DDevice SetupTextureStates**/
3955 TRACE("(%p) Sampler(%ld), Type(%d) Value(%ld)\n",This, Sampler ,Type, Value);
3957 if(Sampler > GL_LIMITS(samplers) || Sampler < 0 || Type > WINED3D_HIGHEST_SAMPLER_STATE || Type < 0) {
3958 FIXME("out of range %d %d sampler %ld type %u\n", GL_LIMITS(samplers), WINED3D_HIGHEST_SAMPLER_STATE, Sampler, Type);
3959 return D3DERR_INVALIDCALL;
3961 TRACE("Setting sampler %ld %d to %ld\n", Sampler, Type, Value);
3962 This->updateStateBlock->samplerState[Sampler][Type] = Value;
3963 This->updateStateBlock->set.samplerState[Sampler][Type] = Value;
3964 This->updateStateBlock->changed.samplerState[Sampler][Type] = Value;
3966 /* Handle recording of state blocks */
3967 if (This->isRecordingState) {
3968 TRACE("Recording... not performing anything\n");
3975 HRESULT WINAPI IWineD3DDeviceImpl_GetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD* Value) {
3976 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3977 /** TODO: check that sampler is in range **/
3978 *Value = This->updateStateBlock->samplerState[Sampler][Type];
3979 TRACE("(%p) : Sampler %ld Type %u Returning %ld\n", This, Sampler, Type, *Value);
3984 HRESULT WINAPI IWineD3DDeviceImpl_SetScissorRect(IWineD3DDevice *iface, CONST RECT* pRect) {
3985 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3988 /** FIXME: Windows uses a top,left origin openGL uses a bottom Right? **/
3989 TRACE("(%p)Setting new Scissor Rect to %ld:%ld-%ld:%ld\n", This, pRect->left, pRect->top, pRect->right, pRect->bottom);
3990 glScissor(pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
3996 HRESULT WINAPI IWineD3DDeviceImpl_GetScissorRect(IWineD3DDevice *iface, RECT* pRect) {
3997 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3998 GLint scissorBox[4];
4001 /** FIXME: Windows uses a top,left origin openGL uses a bottom Right? **/
4002 glGetIntegerv(GL_SCISSOR_BOX, scissorBox);
4003 pRect->left = scissorBox[1];
4004 pRect->top = scissorBox[2];
4005 pRect->right = scissorBox[1] + scissorBox[3];
4006 pRect->bottom = scissorBox[2] + scissorBox[4];
4007 TRACE("(%p)Returning a Scissor Rect of %ld:%ld-%ld:%ld\n", This, pRect->left, pRect->top, pRect->right, pRect->bottom);
4012 HRESULT WINAPI IWineD3DDeviceImpl_SetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration* pDecl) {
4013 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
4014 IWineD3DVertexDeclaration *oldDecl = This->updateStateBlock->vertexDecl;
4016 TRACE("(%p) : pDecl=%p\n", This, pDecl);
4018 This->updateStateBlock->vertexDecl = pDecl;
4019 This->updateStateBlock->changed.vertexDecl = TRUE;
4020 This->updateStateBlock->set.vertexDecl = TRUE;
4022 if (This->isRecordingState) {
4023 TRACE("Recording... not performing anything\n");
4026 if (NULL != pDecl) {
4027 IWineD3DVertexDeclaration_AddRef(pDecl);
4029 if (NULL != oldDecl) {
4030 IWineD3DVertexDeclaration_Release(oldDecl);
4035 HRESULT WINAPI IWineD3DDeviceImpl_GetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppDecl) {
4036 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4038 TRACE("(%p) : ppDecl=%p\n", This, ppDecl);
4040 *ppDecl = This->stateBlock->vertexDecl;
4041 if (NULL != *ppDecl) IWineD3DVertexDeclaration_AddRef(*ppDecl);
4045 HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader* pShader) {
4046 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4047 IWineD3DVertexShader* oldShader = This->updateStateBlock->vertexShader;
4049 This->updateStateBlock->vertexShader = pShader;
4050 This->updateStateBlock->changed.vertexShader = TRUE;
4051 This->updateStateBlock->set.vertexShader = TRUE;
4053 if (This->isRecordingState) {
4054 TRACE("Recording... not performing anything\n");
4057 if (NULL != pShader) {
4058 IWineD3DVertexShader_AddRef(pShader);
4060 if (NULL != oldShader) {
4061 IWineD3DVertexShader_Release(oldShader);
4064 if (pShader != NULL && ((IWineD3DVertexShaderImpl *)pShader)->vertexDeclaration != NULL) {
4065 TRACE("(%p) : setting vertexDeclaration(%p)\n", This, ((IWineD3DVertexShaderImpl *)pShader)->vertexDeclaration);
4066 IWineD3DDevice_SetVertexDeclaration(iface, ((IWineD3DVertexShaderImpl *)pShader)->vertexDeclaration);
4069 TRACE("(%p) : setting pShader(%p)\n", This, pShader);
4071 * TODO: merge HAL shaders context switching from prototype
4076 HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader** ppShader) {
4077 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4079 if (NULL == ppShader) {
4080 return D3DERR_INVALIDCALL;
4082 *ppShader = This->stateBlock->vertexShader;
4083 if( NULL != *ppShader)
4084 IWineD3DVertexShader_AddRef(*ppShader);
4086 TRACE("(%p) : returning %p\n", This, *ppShader);
4090 HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
4091 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4094 int cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
4096 TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
4097 iface, dstData, srcData, type, start, count, registersize);
4099 if (type != WINESHADERCNST_NONE) {
4100 if (srcData == NULL || cnt < 0) {
4101 return D3DERR_INVALIDCALL;
4104 CopyMemory((char *)dstData + (start * registersize), srcData, cnt * registersize);
4107 for (i = start; i < cnt + start; ++i) {
4108 This->updateStateBlock->changed.vertexShaderConstants[i] = TRUE;
4109 This->updateStateBlock->set.vertexShaderConstants[i] = TRUE;
4110 This->updateStateBlock->vertexShaderConstantT[i] = type;
4116 HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
4117 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4120 int cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
4122 TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
4123 iface, dstData, srcData, type, start, count, registersize);
4125 /* Verify that the requested shader constant was populated with the correct type */
4126 for (i = start; i < cnt + start; ++i) {
4127 if (This->updateStateBlock->vertexShaderConstantT[i] != type) {
4128 TRACE("(%p) : Caller requested 0x%x while type is 0x%x. Returning D3DERR_INVALIDCALL\n",
4129 This, type, This->updateStateBlock->vertexShaderConstantT[i]);
4130 return D3DERR_INVALIDCALL;
4134 if (dstData == NULL || cnt < 0) {
4135 return D3DERR_INVALIDCALL;
4138 CopyMemory(dstData, (char *)srcData + (start * registersize), cnt * registersize);
4143 HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, CONST BOOL *pConstantData, UINT BoolCount){
4144 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4146 return IWineD3DDeviceImpl_SetVertexShaderConstant(iface,
4147 This->updateStateBlock->vertexShaderConstantB,
4149 WINESHADERCNST_BOOL,
4152 sizeof(*pConstantData));
4155 HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, BOOL *pConstantData, UINT BoolCount){
4156 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4158 return IWineD3DDeviceImpl_GetVertexShaderConstant(iface,
4160 This->updateStateBlock->vertexShaderConstantB,
4161 WINESHADERCNST_BOOL,
4164 sizeof(*pConstantData));
4167 HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, CONST int *pConstantData, UINT Vector4iCount){
4168 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4170 return IWineD3DDeviceImpl_SetVertexShaderConstant(iface,
4171 This->updateStateBlock->vertexShaderConstantI,
4173 WINESHADERCNST_INTEGER,
4176 4 * sizeof(*pConstantData));
4179 HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, int *pConstantData, UINT Vector4iCount){
4180 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4182 return IWineD3DDeviceImpl_GetVertexShaderConstant(iface,
4184 This->updateStateBlock->vertexShaderConstantI,
4185 WINESHADERCNST_INTEGER,
4188 4 * sizeof(*pConstantData));
4192 HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, CONST float *pConstantData, UINT Vector4fCount){
4193 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4195 return IWineD3DDeviceImpl_SetVertexShaderConstant(iface,
4196 This->updateStateBlock->vertexShaderConstantF,
4198 WINESHADERCNST_FLOAT,
4201 4 * sizeof(*pConstantData));
4204 HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, float *pConstantData, UINT Vector4fCount){
4205 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4207 return IWineD3DDeviceImpl_GetVertexShaderConstant(iface,
4209 This->updateStateBlock->vertexShaderConstantF,
4210 WINESHADERCNST_FLOAT,
4213 4 * sizeof(*pConstantData));
4216 HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantN(IWineD3DDevice *iface, UINT StartRegister, UINT VectorNCount){
4217 return IWineD3DDeviceImpl_SetVertexShaderConstant(iface,
4220 WINESHADERCNST_NONE,
4226 HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader *pShader) {
4227 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4228 IWineD3DPixelShader *oldShader = This->updateStateBlock->pixelShader;
4229 This->updateStateBlock->pixelShader = pShader;
4230 This->updateStateBlock->changed.pixelShader = TRUE;
4231 This->updateStateBlock->set.pixelShader = TRUE;
4233 /* Handle recording of state blocks */
4234 if (This->isRecordingState) {
4235 TRACE("Recording... not performing anything\n");
4238 if (NULL != pShader) {
4239 IWineD3DPixelShader_AddRef(pShader);
4241 if (NULL != oldShader) {
4242 IWineD3DPixelShader_Release(oldShader);
4245 TRACE("(%p) : setting pShader(%p)\n", This, pShader);
4247 * TODO: merge HAL shaders context switching from prototype
4252 HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader **ppShader) {
4253 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4255 if (NULL == ppShader) {
4256 WARN("(%p) : PShader is NULL, returning INVALIDCALL\n", This);
4257 return D3DERR_INVALIDCALL;
4260 *ppShader = This->stateBlock->pixelShader;
4261 if (NULL != ppShader) {
4262 IWineD3DPixelShader_AddRef(*ppShader);
4264 TRACE("(%p) : returning %p\n", This, *ppShader);
4268 HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
4269 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4272 int cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
4274 TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
4275 iface, dstData, srcData, type, start, count, registersize);
4277 if (type != WINESHADERCNST_NONE) {
4278 if (srcData == NULL || cnt < 0) {
4279 return D3DERR_INVALIDCALL;
4282 CopyMemory((char *)dstData + (start * registersize), srcData, cnt * registersize);
4285 for (i = start; i < cnt + start; ++i) {
4286 This->updateStateBlock->changed.pixelShaderConstants[i] = TRUE;
4287 This->updateStateBlock->set.pixelShaderConstants[i] = TRUE;
4288 This->updateStateBlock->pixelShaderConstantT[i] = type;
4294 HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
4295 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4298 int cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
4300 TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
4301 iface, dstData, srcData, type, start, count, registersize);
4303 /* Verify that the requested shader constant was populated with the correct type */
4304 for (i = start; i < cnt + start; ++i) {
4305 if (This->updateStateBlock->pixelShaderConstantT[i] != type) {
4306 TRACE("(%p) : Caller requested 0x%x while type is 0x%x. Returning D3DERR_INVALIDCALL\n",
4307 This, type, This->updateStateBlock->pixelShaderConstantT[i]);
4308 return D3DERR_INVALIDCALL;
4312 if (dstData == NULL || cnt < 0) {
4313 return D3DERR_INVALIDCALL;
4316 CopyMemory(dstData, (char *)srcData + (start * registersize), cnt * registersize);
4321 HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, CONST BOOL *pConstantData, UINT BoolCount) {
4322 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4324 return IWineD3DDeviceImpl_SetPixelShaderConstant(iface,
4325 This->updateStateBlock->pixelShaderConstantB,
4327 WINESHADERCNST_BOOL,
4330 sizeof(*pConstantData));
4333 HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, BOOL *pConstantData, UINT BoolCount) {
4334 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4336 return IWineD3DDeviceImpl_GetPixelShaderConstant(iface,
4338 This->updateStateBlock->pixelShaderConstantB,
4339 WINESHADERCNST_BOOL,
4342 sizeof(*pConstantData));
4345 HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, CONST int *pConstantData, UINT Vector4iCount) {
4346 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4348 return IWineD3DDeviceImpl_SetPixelShaderConstant(iface,
4349 This->updateStateBlock->pixelShaderConstantI,
4351 WINESHADERCNST_INTEGER,
4354 4 * sizeof(*pConstantData));
4357 HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, int *pConstantData, UINT Vector4iCount) {
4358 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4360 return IWineD3DDeviceImpl_GetPixelShaderConstant(iface,
4362 This->updateStateBlock->pixelShaderConstantI,
4363 WINESHADERCNST_INTEGER,
4366 4 * sizeof(*pConstantData));
4369 HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, CONST float *pConstantData, UINT Vector4fCount) {
4370 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4372 return IWineD3DDeviceImpl_SetPixelShaderConstant(iface,
4373 This->updateStateBlock->pixelShaderConstantF,
4375 WINESHADERCNST_FLOAT,
4378 4 * sizeof(*pConstantData));
4381 HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, float *pConstantData, UINT Vector4fCount) {
4382 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4384 return IWineD3DDeviceImpl_GetPixelShaderConstant(iface,
4386 This->updateStateBlock->pixelShaderConstantF,
4387 WINESHADERCNST_FLOAT,
4390 4 * sizeof(*pConstantData));
4393 HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantN(IWineD3DDevice *iface, UINT StartRegister, UINT VectorNCount){
4394 return IWineD3DDeviceImpl_SetPixelShaderConstant(iface,
4397 WINESHADERCNST_NONE,
4403 HRESULT WINAPI IWineD3DDeviceImpl_ProcessVertices(IWineD3DDevice *iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IWineD3DVertexBuffer* pDestBuffer, IWineD3DVertexBuffer* pVertexDecl, DWORD Flags) {
4404 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4405 FIXME("(%p) : stub\n", This);
4410 * Apply / Get / Set Texture Stage States
4411 * TODO: Verify against dx9 definitions
4414 /* NOTE: It's expected that this function is going to be called lots of times with the same stage active, so make it the callers responsibility to GLACTIVETEXTURE(Stage) for better state management. Set the correct Texture unit active before calling ApplyTextureStageState */
4415 static void WINAPI IWineD3DDeviceImpl_ApplyTextureUnitState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type) {
4416 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4417 DWORD Value = This->updateStateBlock->textureState[Stage][Type];
4418 /* FIXME: Handle 3d textures? What if TSS value set before set texture? Need to reapply all values? */
4420 TRACE("(%p) : Stage=%ld, Type=%s(%d), Value=%ld\n", This, Stage, debug_d3dtexturestate(Type), Type, Value);
4422 /* Check that the stage is within limits */
4423 if (Stage >= GL_LIMITS(textures) || Stage < 0) {
4424 TRACE("Attempt to access invalid texture rejected\n");
4431 case WINED3DTSS_ALPHAOP :
4432 case WINED3DTSS_COLOROP :
4433 /* nothing to do as moved to drawprim for now */
4435 case WINED3DTSS_ADDRESSW :
4436 #if 0 /* I'm not sure what D3D does about ADDRESSW appearing twice */
4437 if (Value < minLookup[WINELOOKUP_WARPPARAM] || Value > maxLookup[WINELOOKUP_WARPPARAM]) {
4438 FIXME("Unrecognized or unsupported D3DTADDRESS_* value %ld, state %d\n", Value, Type);
4441 GLint wrapParm = stateLookup[WINELOOKUP_WARPPARAM][Value - minLookup[WINELOOKUP_WARPPARAM]];
4442 TRACE("Setting WRAP_R to %d for %x\n", wrapParm, This->stateBlock->textureDimensions[Stage]);
4443 glTexParameteri(This->stateBlock->textureDimensions[Stage], GL_TEXTURE_WRAP_R, wrapParm);
4444 checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_R, wrapParm)");
4447 case WINED3DTSS_TEXCOORDINDEX :
4449 /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive */
4451 /* FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
4452 one flag, you can still specify an index value, which the system uses to
4453 determine the texture wrapping mode.
4454 eg. SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION | 1 );
4455 means use the vertex position (camera-space) as the input texture coordinates
4456 for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
4457 state. We do not (yet) support the D3DRENDERSTATE_WRAPx values, nor tie them up
4458 to the TEXCOORDINDEX value */
4461 * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
4463 switch (Value & 0xFFFF0000) {
4464 case D3DTSS_TCI_PASSTHRU:
4465 /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
4466 glDisable(GL_TEXTURE_GEN_S);
4467 glDisable(GL_TEXTURE_GEN_T);
4468 glDisable(GL_TEXTURE_GEN_R);
4469 glDisable(GL_TEXTURE_GEN_Q);
4470 checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
4473 case D3DTSS_TCI_CAMERASPACEPOSITION:
4474 /* CameraSpacePosition means use the vertex position, transformed to camera space,
4475 as the input texture coordinates for this stage's texture transformation. This
4476 equates roughly to EYE_LINEAR */
4478 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
4479 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
4480 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
4481 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
4482 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
4484 glMatrixMode(GL_MODELVIEW);
4487 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
4488 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
4489 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
4490 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
4493 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
4494 glEnable(GL_TEXTURE_GEN_S);
4495 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
4496 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
4497 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
4498 glEnable(GL_TEXTURE_GEN_T);
4499 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
4500 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
4501 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
4502 glEnable(GL_TEXTURE_GEN_R);
4503 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
4504 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
4505 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
4509 case D3DTSS_TCI_CAMERASPACENORMAL:
4511 if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
4512 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
4513 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
4514 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
4515 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
4516 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
4518 glMatrixMode(GL_MODELVIEW);
4521 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
4522 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
4523 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
4524 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
4527 glEnable(GL_TEXTURE_GEN_S);
4528 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
4529 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
4530 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
4531 glEnable(GL_TEXTURE_GEN_T);
4532 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
4533 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
4534 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
4535 glEnable(GL_TEXTURE_GEN_R);
4536 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
4537 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
4538 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
4543 case D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
4545 if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
4546 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
4547 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
4548 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
4549 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
4550 TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
4552 glMatrixMode(GL_MODELVIEW);
4555 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
4556 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
4557 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
4558 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
4561 glEnable(GL_TEXTURE_GEN_S);
4562 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
4563 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
4564 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
4565 glEnable(GL_TEXTURE_GEN_T);
4566 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
4567 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
4568 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
4569 glEnable(GL_TEXTURE_GEN_R);
4570 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
4571 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
4572 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
4577 /* Unhandled types: */
4580 /* ? disable GL_TEXTURE_GEN_n ? */
4581 glDisable(GL_TEXTURE_GEN_S);
4582 glDisable(GL_TEXTURE_GEN_T);
4583 glDisable(GL_TEXTURE_GEN_R);
4584 glDisable(GL_TEXTURE_GEN_Q);
4585 FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %lx\n", Value);
4592 case WINED3DTSS_TEXTURETRANSFORMFLAGS :
4593 set_texture_matrix((float *)&This->stateBlock->transforms[D3DTS_TEXTURE0 + Stage].u.m[0][0], Value, (This->stateBlock->textureState[Stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != D3DTSS_TCI_PASSTHRU);
4596 case WINED3DTSS_BUMPENVMAT00 :
4597 case WINED3DTSS_BUMPENVMAT01 :
4598 TRACE("BUMPENVMAT0%u Stage=%ld, Type=%d, Value =%ld\n", Type - WINED3DTSS_BUMPENVMAT00, Stage, Type, Value);
4600 case WINED3DTSS_BUMPENVMAT10 :
4601 case WINED3DTSS_BUMPENVMAT11 :
4602 TRACE("BUMPENVMAT1%u Stage=%ld, Type=%d, Value =%ld\n", Type - WINED3DTSS_BUMPENVMAT10, Stage, Type, Value);
4605 case WINED3DTSS_BUMPENVLSCALE :
4606 TRACE("BUMPENVLSCALE Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value);
4609 case WINED3DTSS_BUMPENVLOFFSET :
4610 TRACE("BUMPENVLOFFSET Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value);
4613 case WINED3DTSS_RESULTARG :
4614 TRACE("RESULTARG Still a stub, Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value);
4618 /* Put back later: FIXME("(%p) : stub, Stage=%ld, Type=%d, Value =%ld\n", This, Stage, Type, Value); */
4619 TRACE("Still a stub, Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value);
4628 * Get / Set Texture Stage States
4629 * TODO: Verify against dx9 definitions
4631 HRESULT WINAPI IWineD3DDeviceImpl_SetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
4632 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4634 /* FIXME: Handle 3d textures? What if TSS value set before set texture? Need to reapply all values? */
4636 TRACE("(%p) : Stage=%ld, Type=%s(%d), Value=%ld\n", This, Stage, debug_d3dtexturestate(Type), Type, Value);
4638 /* Reject invalid texture units */
4639 if (Stage >= GL_LIMITS(textures)) {
4640 TRACE("Attempt to access invalid texture rejected\n");
4641 return D3DERR_INVALIDCALL;
4644 This->updateStateBlock->changed.textureState[Stage][Type] = TRUE;
4645 This->updateStateBlock->set.textureState[Stage][Type] = TRUE;
4646 This->updateStateBlock->textureState[Stage][Type] = Value;
4651 HRESULT WINAPI IWineD3DDeviceImpl_GetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) {
4652 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4653 TRACE("(%p) : requesting Stage %ld, Type %d getting %ld\n", This, Stage, Type, This->updateStateBlock->textureState[Stage][Type]);
4654 *pValue = This->updateStateBlock->textureState[Stage][Type];
4661 HRESULT WINAPI IWineD3DDeviceImpl_SetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture* pTexture) {
4663 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4664 IWineD3DBaseTexture *oldTexture;
4666 oldTexture = This->updateStateBlock->textures[Stage];
4667 TRACE("(%p) : Stage(%ld), Texture (%p)\n", This, Stage, pTexture);
4669 #if 0 /* TODO: check so vertex textures */
4670 if (Stage >= D3DVERTEXTEXTURESAMPLER && Stage <= D3DVERTEXTEXTURESAMPLER3){
4671 This->updateStateBlock->vertexTextures[Stage - D3DVERTEXTEXTURESAMPLER] = pTexture;
4676 /* Reject invalid texture units */
4677 if (Stage >= GL_LIMITS(textures) || Stage < 0) {
4678 WARN("Attempt to access invalid texture rejected\n");
4679 return D3DERR_INVALIDCALL;
4682 if(pTexture != NULL) {
4683 /* SetTexture isn't allowed on textures in WINED3DPOOL_SCRATCH; The same is
4684 * the case for WINED3DPOOL_SYSTEMMEM textures unless WINED3DDEVCAPS_TEXTURESYSTEMMORY is set.
4685 * We don't check the caps as GetDeviceCaps is inefficient and we don't set the cap anyway.
4687 if(((IWineD3DTextureImpl*)pTexture)->resource.pool == WINED3DPOOL_SCRATCH || ((IWineD3DTextureImpl*)pTexture)->resource.pool == WINED3DPOOL_SYSTEMMEM) {
4688 WARN("(%p) Attempt to set scratch texture rejected\n", pTexture);
4689 return D3DERR_INVALIDCALL;
4693 oldTexture = This->updateStateBlock->textures[Stage];
4694 TRACE("GL_LIMITS %d\n",GL_LIMITS(textures));
4695 TRACE("(%p) : oldtexture(%p)\n", This,oldTexture);
4697 This->updateStateBlock->set.textures[Stage] = TRUE;
4698 This->updateStateBlock->changed.textures[Stage] = TRUE;
4699 TRACE("(%p) : setting new texture to %p\n", This, pTexture);
4700 This->updateStateBlock->textures[Stage] = pTexture;
4702 /* Handle recording of state blocks */
4703 if (This->isRecordingState) {
4704 TRACE("Recording... not performing anything\n");
4708 /** NOTE: MSDN says that setTexture increases the reference count,
4709 * and the the application nust set the texture back to null (or have a leaky application),
4710 * This means we should pass the refcount up to the parent
4711 *******************************/
4712 if (NULL != This->updateStateBlock->textures[Stage]) {
4713 IWineD3DBaseTexture_AddRef(This->updateStateBlock->textures[Stage]);
4716 if (NULL != oldTexture) {
4717 IWineD3DBaseTexture_Release(oldTexture);
4723 HRESULT WINAPI IWineD3DDeviceImpl_GetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture** ppTexture) {
4724 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4725 TRACE("(%p) : (%ld /* Stage */,%p /* ppTexture */)\n", This, Stage, ppTexture);
4727 /* Reject invalid texture units */
4728 if (Stage >= GL_LIMITS(textures)) {
4729 TRACE("Attempt to access invalid texture rejected\n");
4730 return D3DERR_INVALIDCALL;
4732 *ppTexture=This->updateStateBlock->textures[Stage];
4734 IWineD3DBaseTexture_AddRef(*ppTexture);
4736 return D3DERR_INVALIDCALL;
4743 HRESULT WINAPI IWineD3DDeviceImpl_GetBackBuffer(IWineD3DDevice *iface, UINT iSwapChain, UINT BackBuffer, D3DBACKBUFFER_TYPE Type,
4744 IWineD3DSurface **ppBackBuffer) {
4745 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4746 IWineD3DSwapChain *swapChain;
4749 TRACE("(%p) : BackBuf %d Type %d SwapChain %d returning %p\n", This, BackBuffer, Type, iSwapChain, *ppBackBuffer);
4751 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
4753 hr = IWineD3DSwapChain_GetBackBuffer(swapChain, BackBuffer, Type, ppBackBuffer);
4754 IWineD3DSwapChain_Release(swapChain);
4756 *ppBackBuffer = NULL;
4761 HRESULT WINAPI IWineD3DDeviceImpl_GetDeviceCaps(IWineD3DDevice *iface, WINED3DCAPS* pCaps) {
4762 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4763 WARN("(%p) : stub, calling idirect3d for now\n", This);
4764 return IWineD3D_GetDeviceCaps(This->wineD3D, This->adapterNo, This->devType, pCaps);
4767 HRESULT WINAPI IWineD3DDeviceImpl_GetDisplayMode(IWineD3DDevice *iface, UINT iSwapChain, D3DDISPLAYMODE* pMode) {
4768 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4769 IWineD3DSwapChain *swapChain;
4772 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, (IWineD3DSwapChain **)&swapChain);
4774 hr = IWineD3DSwapChain_GetDisplayMode(swapChain, pMode);
4775 IWineD3DSwapChain_Release(swapChain);
4777 FIXME("(%p) Error getting display mode\n", This);
4782 * Stateblock related functions
4785 HRESULT WINAPI IWineD3DDeviceImpl_BeginStateBlock(IWineD3DDevice *iface) {
4786 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4787 IWineD3DStateBlockImpl *object;
4788 TRACE("(%p)", This);
4790 if (This->isRecordingState) {
4791 return D3DERR_INVALIDCALL;
4794 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DStateBlockImpl));
4795 if (NULL == object ) {
4796 FIXME("(%p)Error allocating memory for stateblock\n", This);
4797 return E_OUTOFMEMORY;
4799 TRACE("(%p) creted object %p\n", This, object);
4800 object->wineD3DDevice= This;
4801 /** FIXME: object->parent = parent; **/
4802 object->parent = NULL;
4803 object->blockType = WINED3DSBT_ALL;
4805 object->lpVtbl = &IWineD3DStateBlock_Vtbl;
4807 IWineD3DStateBlock_Release((IWineD3DStateBlock*)This->updateStateBlock);
4808 This->updateStateBlock = object;
4809 This->isRecordingState = TRUE;
4811 TRACE("(%p) recording stateblock %p\n",This , object);
4815 HRESULT WINAPI IWineD3DDeviceImpl_EndStateBlock(IWineD3DDevice *iface, IWineD3DStateBlock** ppStateBlock) {
4816 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4818 if (!This->isRecordingState) {
4819 FIXME("(%p) not recording! returning error\n", This);
4820 *ppStateBlock = NULL;
4821 return D3DERR_INVALIDCALL;
4824 *ppStateBlock = (IWineD3DStateBlock*)This->updateStateBlock;
4825 This->isRecordingState = FALSE;
4826 This->updateStateBlock = This->stateBlock;
4827 IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock);
4828 /* IWineD3DStateBlock_AddRef(*ppStateBlock); don't need to do this, since we should really just release UpdateStateBlock first */
4829 TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, *ppStateBlock);
4834 * Scene related functions
4836 HRESULT WINAPI IWineD3DDeviceImpl_BeginScene(IWineD3DDevice *iface) {
4837 /* At the moment we have no need for any functionality at the beginning
4839 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4840 TRACE("(%p) : stub\n", This);
4844 HRESULT WINAPI IWineD3DDeviceImpl_EndScene(IWineD3DDevice *iface) {
4845 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4846 TRACE("(%p)\n", This);
4848 /* We only have to do this if we need to read the, swapbuffers performs a flush for us */
4850 checkGLcall("glFlush");
4852 TRACE("End Scene\n");
4853 if(This->renderTarget != NULL) {
4855 /* If the container of the rendertarget is a texture then we need to save the data from the pbuffer */
4856 IUnknown *targetContainer = NULL;
4857 if (D3D_OK == IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DBaseTexture, (void **)&targetContainer)
4858 || D3D_OK == IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DDevice, (void **)&targetContainer)) {
4859 TRACE("(%p) : Texture rendertarget %p\n", This ,This->renderTarget);
4860 /** always dirtify for now. we must find a better way to see that surface have been modified
4861 (Modifications should will only occur via draw-primitive, but we do need better locking
4862 switching to render-to-texture should remove the overhead though.
4864 IWineD3DSurface_SetPBufferState(This->renderTarget, TRUE /* inPBuffer */, FALSE /* inTexture */);
4865 IWineD3DSurface_AddDirtyRect(This->renderTarget, NULL);
4866 IWineD3DSurface_PreLoad(This->renderTarget);
4867 IWineD3DSurface_SetPBufferState(This->renderTarget, FALSE /* inPBuffer */, FALSE /* inTexture */);
4868 IUnknown_Release(targetContainer);
4871 This->sceneEnded = TRUE;
4876 HRESULT WINAPI IWineD3DDeviceImpl_Present(IWineD3DDevice *iface,
4877 CONST RECT* pSourceRect, CONST RECT* pDestRect,
4878 HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion) {
4879 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4880 IWineD3DSwapChain *swapChain = NULL;
4882 int swapchains = IWineD3DDeviceImpl_GetNumberOfSwapChains(iface);
4884 TRACE("(%p) Presenting the frame\n", This);
4886 for(i = 0 ; i < swapchains ; i ++) {
4888 IWineD3DDeviceImpl_GetSwapChain(iface, i , (IWineD3DSwapChain **)&swapChain);
4889 TRACE("presentinng chain %d, %p\n", i, swapChain);
4890 IWineD3DSwapChain_Present(swapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, 0);
4891 IWineD3DSwapChain_Release(swapChain);
4897 HRESULT WINAPI IWineD3DDeviceImpl_Clear(IWineD3DDevice *iface, DWORD Count, CONST D3DRECT* pRects,
4898 DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) {
4899 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4901 /* TODO: From MSDN This method fails if you specify the D3DCLEAR_ZBUFFER or D3DCLEAR_STENCIL flags when the
4902 render target does not have an attached depth buffer. Similarly, if you specify the D3DCLEAR_STENCIL flag
4903 when the depth-buffer format does not contain stencil buffer information, this method fails. */
4904 GLbitfield glMask = 0;
4905 GLboolean old_ztest;
4906 GLfloat old_z_clear_value;
4907 GLint old_stencil_clear_value;
4908 GLfloat old_color_clear_value[4];
4910 CONST D3DRECT* curRect;
4912 TRACE("(%p) Count (%ld), pRects (%p), Flags (%lx), Z (%f), Stencil (%ld)\n", This,
4913 Count, pRects, Flags, Z, Stencil);
4917 glEnable(GL_SCISSOR_TEST);
4918 checkGLcall("glEnable GL_SCISSOR_TEST");
4920 if (Count > 0 && pRects) {
4926 /* Only set the values up once, as they are not changing */
4927 if (Flags & D3DCLEAR_STENCIL) {
4928 glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &old_stencil_clear_value);
4929 glClearStencil(Stencil);
4930 checkGLcall("glClearStencil");
4931 glMask = glMask | GL_STENCIL_BUFFER_BIT;
4932 glStencilMask(0xFFFFFFFF);
4935 if (Flags & D3DCLEAR_ZBUFFER) {
4936 glGetBooleanv(GL_DEPTH_WRITEMASK, &old_ztest);
4937 glDepthMask(GL_TRUE);
4938 glGetFloatv(GL_DEPTH_CLEAR_VALUE, &old_z_clear_value);
4940 checkGLcall("glClearDepth");
4941 glMask = glMask | GL_DEPTH_BUFFER_BIT;
4944 if (Flags & D3DCLEAR_TARGET) {
4945 TRACE("Clearing screen with glClear to color %lx\n", Color);
4946 glGetFloatv(GL_COLOR_CLEAR_VALUE, old_color_clear_value);
4947 glClearColor(D3DCOLOR_R(Color),
4951 checkGLcall("glClearColor");
4953 /* Clear ALL colors! */
4954 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
4955 glMask = glMask | GL_COLOR_BUFFER_BIT;
4958 /* Now process each rect in turn */
4959 for (i = 0; i < Count || i == 0; i++) {
4962 /* Note gl uses lower left, width/height */
4963 TRACE("(%p) %p Rect=(%ld,%ld)->(%ld,%ld) glRect=(%ld,%ld), len=%ld, hei=%ld\n", This, curRect,
4964 curRect->x1, curRect->y1, curRect->x2, curRect->y2,
4965 curRect->x1, (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height - curRect->y2),
4966 curRect->x2 - curRect->x1, curRect->y2 - curRect->y1);
4967 glScissor(curRect->x1, (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height - curRect->y2),
4968 curRect->x2 - curRect->x1, curRect->y2 - curRect->y1);
4969 checkGLcall("glScissor");
4971 glScissor(This->stateBlock->viewport.X,
4972 (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height -
4973 (This->stateBlock->viewport.Y + This->stateBlock->viewport.Height)),
4974 This->stateBlock->viewport.Width,
4975 This->stateBlock->viewport.Height);
4976 checkGLcall("glScissor");
4979 /* Clear the selected rectangle (or full screen) */
4981 checkGLcall("glClear");
4983 /* Step to the next rectangle */
4984 if (curRect) curRect = curRect + sizeof(D3DRECT);
4987 /* Restore the old values (why..?) */
4988 if (Flags & D3DCLEAR_STENCIL) {
4989 glClearStencil(old_stencil_clear_value);
4990 glStencilMask(This->stateBlock->renderState[WINED3DRS_STENCILWRITEMASK]);
4992 if (Flags & D3DCLEAR_ZBUFFER) {
4993 glDepthMask(old_ztest);
4994 glClearDepth(old_z_clear_value);
4996 if (Flags & D3DCLEAR_TARGET) {
4997 glClearColor(old_color_clear_value[0],
4998 old_color_clear_value[1],
4999 old_color_clear_value[2],
5000 old_color_clear_value[3]);
5001 glColorMask(This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
5002 This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
5003 This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
5004 This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
5007 glDisable(GL_SCISSOR_TEST);
5008 checkGLcall("glDisable");
5017 HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitive(IWineD3DDevice *iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex,
5018 UINT PrimitiveCount) {
5020 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5021 This->stateBlock->streamIsUP = FALSE;
5023 TRACE("(%p) : Type=(%d,%s), Start=%d, Count=%d\n", This, PrimitiveType,
5024 debug_d3dprimitivetype(PrimitiveType),
5025 StartVertex, PrimitiveCount);
5026 drawPrimitive(iface, PrimitiveType, PrimitiveCount, StartVertex, 0/* NumVertices */, -1 /* indxStart */,
5027 0 /* indxSize */, NULL /* indxData */, 0 /* minIndex */);
5033 /* TODO: baseVIndex needs to be provided from This->stateBlock->baseVertexIndex when called from d3d8 */
5034 HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitive(IWineD3DDevice *iface,
5035 D3DPRIMITIVETYPE PrimitiveType,
5036 INT baseVIndex, UINT minIndex,
5037 UINT NumVertices, UINT startIndex, UINT primCount) {
5039 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5041 IWineD3DIndexBuffer *pIB;
5042 WINED3DINDEXBUFFER_DESC IdxBufDsc;
5044 pIB = This->stateBlock->pIndexData;
5045 This->stateBlock->streamIsUP = FALSE;
5047 TRACE("(%p) : Type=(%d,%s), min=%d, CountV=%d, startIdx=%d, baseVidx=%d, countP=%d\n", This,
5048 PrimitiveType, debug_d3dprimitivetype(PrimitiveType),
5049 minIndex, NumVertices, startIndex, baseVIndex, primCount);
5051 IWineD3DIndexBuffer_GetDesc(pIB, &IdxBufDsc);
5052 if (IdxBufDsc.Format == WINED3DFMT_INDEX16) {
5058 drawPrimitive(iface, PrimitiveType, primCount, baseVIndex, NumVertices, startIndex,
5059 idxStride, ((IWineD3DIndexBufferImpl *) pIB)->resource.allocatedMemory, minIndex);
5064 HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveUP(IWineD3DDevice *iface, D3DPRIMITIVETYPE PrimitiveType,
5065 UINT PrimitiveCount, CONST void* pVertexStreamZeroData,
5066 UINT VertexStreamZeroStride) {
5067 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5069 TRACE("(%p) : Type=(%d,%s), pCount=%d, pVtxData=%p, Stride=%d\n", This, PrimitiveType,
5070 debug_d3dprimitivetype(PrimitiveType),
5071 PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
5073 /* release the stream source */
5074 if (This->stateBlock->streamSource[0] != NULL) {
5075 IWineD3DVertexBuffer_Release(This->stateBlock->streamSource[0]);
5078 /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
5079 This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData;
5080 This->stateBlock->streamStride[0] = VertexStreamZeroStride;
5081 This->stateBlock->streamIsUP = TRUE;
5083 drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* start vertex */, 0 /* NumVertices */,
5084 0 /* indxStart*/, 0 /* indxSize*/, NULL /* indxData */, 0 /* indxMin */);
5085 /* stream zero settings set to null at end, as per the msdn
5086 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/DrawPrimitiveUP.asp
5088 This->stateBlock->streamStride[0] = 0;
5089 This->stateBlock->streamSource[0] = NULL;
5091 /*stream zero settings set to null at end, as per the msdn */
5095 HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveUP(IWineD3DDevice *iface, D3DPRIMITIVETYPE PrimitiveType,
5096 UINT MinVertexIndex, UINT NumVertices,
5097 UINT PrimitiveCount, CONST void* pIndexData,
5098 WINED3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,
5099 UINT VertexStreamZeroStride) {
5101 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5103 TRACE("(%p) : Type=(%d,%s), MinVtxIdx=%d, NumVIdx=%d, PCount=%d, pidxdata=%p, IdxFmt=%d, pVtxdata=%p, stride=%d\n",
5104 This, PrimitiveType, debug_d3dprimitivetype(PrimitiveType),
5105 MinVertexIndex, NumVertices, PrimitiveCount, pIndexData,
5106 IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
5108 if (IndexDataFormat == WINED3DFMT_INDEX16) {
5114 /* release the stream and index data */
5115 if (This->stateBlock->streamSource[0] != NULL) {
5116 IWineD3DVertexBuffer_Release(This->stateBlock->streamSource[0]);
5118 if (This->stateBlock->pIndexData) {
5119 IWineD3DIndexBuffer_Release(This->stateBlock->pIndexData);
5122 /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
5123 This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData;
5124 This->stateBlock->streamIsUP = TRUE;
5125 This->stateBlock->streamStride[0] = VertexStreamZeroStride;
5127 drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* vertexStart */, NumVertices, 0 /* indxStart */, idxStride, pIndexData, MinVertexIndex);
5128 /* stream zero settings set to null at end as per the msdn
5129 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/DrawPrimitiveUP.asp
5132 /* stream zero settings set to null at end as per the msdn */
5133 This->stateBlock->streamSource[0] = NULL;
5134 This->stateBlock->streamStride[0] = 0;
5139 /* Yet another way to update a texture, some apps use this to load default textures instead of using surface/texture lock/unlock */
5140 HRESULT WINAPI IWineD3DDeviceImpl_UpdateTexture (IWineD3DDevice *iface, IWineD3DBaseTexture *pSourceTexture, IWineD3DBaseTexture *pDestinationTexture){
5141 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5142 HRESULT hr = D3D_OK;
5143 WINED3DRESOURCETYPE sourceType;
5144 WINED3DRESOURCETYPE destinationType;
5147 /* TODO: think about moving the code into IWineD3DBaseTexture */
5149 TRACE("(%p) Source %p Destination %p\n", This, pSourceTexture, pDestinationTexture);
5151 /* verify that the source and destination textures aren't NULL */
5152 if (NULL == pSourceTexture || NULL == pDestinationTexture) {
5153 WARN("(%p) : source (%p) and destination (%p) textures must not be NULL, returning D3DERR_INVALIDCALL\n",
5154 This, pSourceTexture, pDestinationTexture);
5155 hr = D3DERR_INVALIDCALL;
5158 if (pSourceTexture == pDestinationTexture) {
5159 WARN("(%p) : source (%p) and destination (%p) textures must be different, returning D3DERR_INVALIDCALL\n",
5160 This, pSourceTexture, pDestinationTexture);
5161 hr = D3DERR_INVALIDCALL;
5163 /* Verify that the source and destination textures are the same type */
5164 sourceType = IWineD3DBaseTexture_GetType(pSourceTexture);
5165 destinationType = IWineD3DBaseTexture_GetType(pDestinationTexture);
5167 if (sourceType != destinationType) {
5168 WARN("(%p) Sorce and destination types must match, returning D3DERR_INVALIDCALL\n",
5170 hr = D3DERR_INVALIDCALL;
5173 /* check that both textures have the identical numbers of levels */
5174 if (IWineD3DBaseTexture_GetLevelCount(pDestinationTexture) != IWineD3DBaseTexture_GetLevelCount(pSourceTexture)) {
5175 WARN("(%p) : source (%p) and destination (%p) textures must have identicle numbers of levels, returning D3DERR_INVALIDCALL\n", This, pSourceTexture, pDestinationTexture);
5176 hr = D3DERR_INVALIDCALL;
5181 /* Make sure that the destination texture is loaded */
5182 IWineD3DBaseTexture_PreLoad(pDestinationTexture);
5184 /* Update every surface level of the texture */
5185 levels = IWineD3DBaseTexture_GetLevelCount(pDestinationTexture);
5187 switch (sourceType) {
5188 case WINED3DRTYPE_TEXTURE:
5190 IWineD3DSurface *srcSurface;
5191 IWineD3DSurface *destSurface;
5193 for (i = 0 ; i < levels ; ++i) {
5194 IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)pSourceTexture, i, &srcSurface);
5195 IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)pDestinationTexture, i, &destSurface);
5196 hr = IWineD3DDevice_UpdateSurface(iface, srcSurface, NULL, destSurface, NULL);
5197 IWineD3DSurface_Release(srcSurface);
5198 IWineD3DSurface_Release(destSurface);
5200 WARN("(%p) : Call to update surface failed\n", This);
5206 case WINED3DRTYPE_CUBETEXTURE:
5208 IWineD3DSurface *srcSurface;
5209 IWineD3DSurface *destSurface;
5210 D3DCUBEMAP_FACES faceType;
5212 for (i = 0 ; i < levels ; ++i) {
5213 /* Update each cube face */
5214 for (faceType = D3DCUBEMAP_FACE_POSITIVE_X; faceType <= D3DCUBEMAP_FACE_NEGATIVE_Z; ++faceType){
5215 hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)pSourceTexture, faceType, i, &srcSurface);
5217 FIXME("(%p) : Failed to get src cube surface facetype %d, level %d\n", This, faceType, i);
5219 TRACE("Got srcSurface %p\n", srcSurface);
5221 hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)pDestinationTexture, faceType, i, &destSurface);
5223 FIXME("(%p) : Failed to get src cube surface facetype %d, level %d\n", This, faceType, i);
5225 TRACE("Got desrSurface %p\n", destSurface);
5227 hr = IWineD3DDevice_UpdateSurface(iface, srcSurface, NULL, destSurface, NULL);
5228 IWineD3DSurface_Release(srcSurface);
5229 IWineD3DSurface_Release(destSurface);
5231 WARN("(%p) : Call to update surface failed\n", This);
5238 #if 0 /* TODO: Add support for volume textures */
5239 case WINED3DRTYPE_VOLUMETEXTURE:
5241 IWineD3DVolume srcVolume = NULL;
5242 IWineD3DSurface destVolume = NULL;
5244 for (i = 0 ; i < levels ; ++i) {
5245 IWineD3DVolumeTexture_GetVolume((IWineD3DVolumeTexture *)pSourceTexture, i, &srcVolume);
5246 IWineD3DVolumeTexture_GetVolume((IWineD3DVolumeTexture *)pDestinationTexture, i, &destVolume);
5247 hr = IWineD3DFoo_UpdateVolume(iface, srcVolume, NULL, destVolume, NULL);
5248 IWineD3DVolume_Release(srcSurface);
5249 IWineD3DVolume_Release(destSurface);
5251 WARN("(%p) : Call to update volume failed\n", This);
5259 FIXME("(%p) : Unsupported source and destination type\n", This);
5260 hr = D3DERR_INVALIDCALL;
5267 HRESULT WINAPI IWineD3DDeviceImpl_StretchRect(IWineD3DDevice *iface, IWineD3DSurface *pSourceSurface,
5268 CONST RECT* pSourceRect, IWineD3DSurface *pDestinationSurface,
5269 CONST RECT* pDestRect, D3DTEXTUREFILTERTYPE Filter) {
5270 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5272 TRACE("(%p) : stub\n", This);
5275 HRESULT WINAPI IWineD3DDeviceImpl_GetRenderTargetData(IWineD3DDevice *iface, IWineD3DSurface *pRenderTarget, IWineD3DSurface *pSurface) {
5276 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5277 /** TODO: remove remove casts to IWineD3DSurfaceImpl *
5278 * NOTE It may be best to move the code into surface to occomplish this
5279 ****************************************/
5281 WINED3DSURFACE_DESC surfaceDesc;
5282 unsigned int surfaceWidth, surfaceHeight;
5283 glDescriptor *targetGlDescription = NULL;
5284 glDescriptor *surfaceGlDescription = NULL;
5285 IWineD3DSwapChainImpl *container = NULL;
5287 IWineD3DSurface_GetGlDesc(pRenderTarget, &targetGlDescription);
5288 IWineD3DSurface_GetGlDesc(pSurface, &surfaceGlDescription);
5289 memset(&surfaceDesc, 0, sizeof(surfaceDesc));
5291 surfaceDesc.Width = &surfaceWidth;
5292 surfaceDesc.Height = &surfaceHeight;
5293 IWineD3DSurface_GetDesc(pSurface, &surfaceDesc);
5294 /* check to see if it's the backbuffer or the frontbuffer being requested (to make sure the data is up to date)*/
5296 /* Ok, I may need to setup some kind of active swapchain reference on the device */
5297 IWineD3DSurface_GetContainer(pRenderTarget, &IID_IWineD3DSwapChain, (void **)&container);
5299 /* TODO: opengl Context switching for swapchains etc... */
5300 if (NULL != container || pRenderTarget == This->renderTarget || pRenderTarget == This->depthStencilBuffer) {
5301 if (NULL != container && (pRenderTarget == container->backBuffer)) {
5302 glReadBuffer(GL_BACK);
5303 vcheckGLcall("glReadBuffer(GL_BACK)");
5304 } else if ((NULL != container && (pRenderTarget == container->frontBuffer)) || (pRenderTarget == This->renderTarget)) {
5305 glReadBuffer(GL_FRONT);
5306 vcheckGLcall("glReadBuffer(GL_FRONT)");
5307 } else if (pRenderTarget == This->depthStencilBuffer) {
5308 FIXME("Reading of depthstencil not yet supported\n");
5311 glReadPixels(surfaceGlDescription->target,
5312 surfaceGlDescription->level,
5315 surfaceGlDescription->glFormat,
5316 surfaceGlDescription->glType,
5317 (void *)IWineD3DSurface_GetData(pSurface));
5318 vcheckGLcall("glReadPixels(...)");
5319 if(NULL != container ){
5320 IWineD3DSwapChain_Release((IWineD3DSwapChain*) container);
5323 IWineD3DBaseTexture *container;
5324 GLenum textureDimensions = GL_TEXTURE_2D;
5326 if (D3D_OK == IWineD3DSurface_GetContainer(pSurface, &IID_IWineD3DBaseTexture, (void **)&container)) {
5327 textureDimensions = IWineD3DBaseTexture_GetTextureDimensions(container);
5328 IWineD3DBaseTexture_Release(container);
5330 /* TODO: 2D -> Cube surface coppies etc.. */
5331 if (surfaceGlDescription->target != textureDimensions) {
5332 FIXME("(%p) : Texture dimension mismatch\n", This);
5334 glEnable(textureDimensions);
5335 vcheckGLcall("glEnable(GL_TEXTURE_...)");
5336 /* FIXME: this isn't correct, it need to add a dirty rect if nothing else... */
5337 glBindTexture(targetGlDescription->target, targetGlDescription->textureName);
5338 vcheckGLcall("glBindTexture");
5339 glGetTexImage(surfaceGlDescription->target,
5340 surfaceGlDescription->level,
5341 surfaceGlDescription->glFormat,
5342 surfaceGlDescription->glType,
5343 (void *)IWineD3DSurface_GetData(pSurface));
5344 glDisable(textureDimensions);
5345 vcheckGLcall("glDisable(GL_TEXTURE_...)");
5352 HRESULT WINAPI IWineD3DDeviceImpl_GetFrontBufferData(IWineD3DDevice *iface,UINT iSwapChain, IWineD3DSurface *pDestSurface) {
5353 IWineD3DSwapChain *swapChain;
5355 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, (IWineD3DSwapChain **)&swapChain);
5357 hr = IWineD3DSwapChain_GetFrontBufferData(swapChain, pDestSurface);
5358 IWineD3DSwapChain_Release(swapChain);
5363 HRESULT WINAPI IWineD3DDeviceImpl_ValidateDevice(IWineD3DDevice *iface, DWORD* pNumPasses) {
5364 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5365 /* return a sensible default */
5367 /* TODO: If the window is minimized then validate device should return something other than d3d_ok */
5368 FIXME("(%p) : stub\n", This);
5372 HRESULT WINAPI IWineD3DDeviceImpl_SetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) {
5373 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5375 TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5376 if ( PaletteNumber < 0 || PaletteNumber >= MAX_PALETTES) {
5377 WARN("(%p) : (%u) Out of range 0-%u, returning Invalid Call\n", This, PaletteNumber, MAX_PALETTES);
5378 return D3DERR_INVALIDCALL;
5380 for (j = 0; j < 256; ++j) {
5381 This->palettes[PaletteNumber][j].peRed = pEntries[j].peRed;
5382 This->palettes[PaletteNumber][j].peGreen = pEntries[j].peGreen;
5383 This->palettes[PaletteNumber][j].peBlue = pEntries[j].peBlue;
5384 This->palettes[PaletteNumber][j].peFlags = pEntries[j].peFlags;
5386 TRACE("(%p) : returning\n", This);
5390 HRESULT WINAPI IWineD3DDeviceImpl_GetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, PALETTEENTRY* pEntries) {
5391 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5393 TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5394 if ( PaletteNumber < 0 || PaletteNumber >= MAX_PALETTES) {
5395 WARN("(%p) : (%u) Out of range 0-%u, returning Invalid Call\n", This, PaletteNumber, MAX_PALETTES);
5396 return D3DERR_INVALIDCALL;
5398 for (j = 0; j < 256; ++j) {
5399 pEntries[j].peRed = This->palettes[PaletteNumber][j].peRed;
5400 pEntries[j].peGreen = This->palettes[PaletteNumber][j].peGreen;
5401 pEntries[j].peBlue = This->palettes[PaletteNumber][j].peBlue;
5402 pEntries[j].peFlags = This->palettes[PaletteNumber][j].peFlags;
5404 TRACE("(%p) : returning\n", This);
5408 HRESULT WINAPI IWineD3DDeviceImpl_SetCurrentTexturePalette(IWineD3DDevice *iface, UINT PaletteNumber) {
5409 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5410 TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5411 if ( PaletteNumber < 0 || PaletteNumber >= MAX_PALETTES) {
5412 WARN("(%p) : (%u) Out of range 0-%u, returning Invalid Call\n", This, PaletteNumber, MAX_PALETTES);
5413 return D3DERR_INVALIDCALL;
5415 /*TODO: stateblocks */
5416 This->currentPalette = PaletteNumber;
5417 TRACE("(%p) : returning\n", This);
5421 HRESULT WINAPI IWineD3DDeviceImpl_GetCurrentTexturePalette(IWineD3DDevice *iface, UINT* PaletteNumber) {
5422 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5423 if (PaletteNumber == NULL) {
5424 WARN("(%p) : returning Invalid Call\n", This);
5425 return D3DERR_INVALIDCALL;
5427 /*TODO: stateblocks */
5428 *PaletteNumber = This->currentPalette;
5429 TRACE("(%p) : returning %u\n", This, *PaletteNumber);
5433 HRESULT WINAPI IWineD3DDeviceImpl_SetSoftwareVertexProcessing(IWineD3DDevice *iface, BOOL bSoftware) {
5434 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5435 static BOOL showFixmes = TRUE;
5437 FIXME("(%p) : stub\n", This);
5441 This->softwareVertexProcessing = bSoftware;
5446 BOOL WINAPI IWineD3DDeviceImpl_GetSoftwareVertexProcessing(IWineD3DDevice *iface) {
5447 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5448 static BOOL showFixmes = TRUE;
5450 FIXME("(%p) : stub\n", This);
5453 return This->softwareVertexProcessing;
5457 HRESULT WINAPI IWineD3DDeviceImpl_GetRasterStatus(IWineD3DDevice *iface, UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) {
5458 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5459 IWineD3DSwapChain *swapChain;
5462 TRACE("(%p) : SwapChain %d returning %p\n", This, iSwapChain, pRasterStatus);
5464 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, (IWineD3DSwapChain **)&swapChain);
5466 hr = IWineD3DSwapChain_GetRasterStatus(swapChain, pRasterStatus);
5467 IWineD3DSwapChain_Release(swapChain);
5469 FIXME("(%p) IWineD3DSwapChain_GetRasterStatus returned in error\n", This);
5475 HRESULT WINAPI IWineD3DDeviceImpl_SetNPatchMode(IWineD3DDevice *iface, float nSegments) {
5476 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5477 static BOOL showfixmes = TRUE;
5478 if(nSegments != 0.0f) {
5480 FIXME("(%p) : stub nSegments(%f)\n", This, nSegments);
5487 float WINAPI IWineD3DDeviceImpl_GetNPatchMode(IWineD3DDevice *iface) {
5488 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5489 static BOOL showfixmes = TRUE;
5491 FIXME("(%p) : stub returning(%f)\n", This, 0.0f);
5497 HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface, IWineD3DSurface *pSourceSurface, CONST RECT* pSourceRect, IWineD3DSurface *pDestinationSurface, CONST POINT* pDestPoint) {
5498 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5499 /** TODO: remove casts to IWineD3DSurfaceImpl
5500 * NOTE: move code to surface to accomplish this
5501 ****************************************/
5502 IWineD3DSurfaceImpl *pSrcSurface = (IWineD3DSurfaceImpl *)pSourceSurface;
5503 int srcWidth, srcHeight;
5504 unsigned int srcSurfaceWidth, srcSurfaceHeight, destSurfaceWidth, destSurfaceHeight;
5505 WINED3DFORMAT destFormat, srcFormat;
5507 int destLeft, destTop;
5508 WINED3DPOOL srcPool, destPool;
5510 int rowoffset = 0; /* how many bytes to add onto the end of a row to wraparound to the beginning of the next */
5511 glDescriptor *glDescription = NULL;
5512 GLenum textureDimensions = GL_TEXTURE_2D;
5513 IWineD3DBaseTexture *baseTexture;
5515 WINED3DSURFACE_DESC winedesc;
5517 TRACE("(%p) : Source (%p) Rect (%p) Destination (%p) Point(%p)\n", This, pSourceSurface, pSourceRect, pDestinationSurface, pDestPoint);
5518 memset(&winedesc, 0, sizeof(winedesc));
5519 winedesc.Width = &srcSurfaceWidth;
5520 winedesc.Height = &srcSurfaceHeight;
5521 winedesc.Pool = &srcPool;
5522 winedesc.Format = &srcFormat;
5524 IWineD3DSurface_GetDesc(pSourceSurface, &winedesc);
5526 winedesc.Width = &destSurfaceWidth;
5527 winedesc.Height = &destSurfaceHeight;
5528 winedesc.Pool = &destPool;
5529 winedesc.Format = &destFormat;
5530 winedesc.Size = &destSize;
5532 IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
5534 if(srcPool != WINED3DPOOL_SYSTEMMEM || destPool != WINED3DPOOL_DEFAULT){
5535 WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning D3DERR_INVALIDCALL\n", pSourceSurface, pDestinationSurface);
5536 return D3DERR_INVALIDCALL;
5539 if (destFormat == WINED3DFMT_UNKNOWN) {
5540 TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", This);
5541 IWineD3DSurface_SetFormat(pDestinationSurface, srcFormat);
5543 /* Get the update surface description */
5544 IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
5547 /* Make sure the surface is loaded and up to date */
5548 IWineD3DSurface_PreLoad(pDestinationSurface);
5550 IWineD3DSurface_GetGlDesc(pDestinationSurface, &glDescription);
5554 /* this needs to be done in lines if the sourceRect != the sourceWidth */
5555 srcWidth = pSourceRect ? pSourceRect->right - pSourceRect->left : srcSurfaceWidth;
5556 srcHeight = pSourceRect ? pSourceRect->top - pSourceRect->bottom : srcSurfaceHeight;
5557 destLeft = pDestPoint ? pDestPoint->x : 0;
5558 destTop = pDestPoint ? pDestPoint->y : 0;
5561 /* This function doesn't support compressed textures
5562 the pitch is just bytesPerPixel * width */
5563 if(srcWidth != srcSurfaceWidth || (pSourceRect != NULL && pSourceRect->left != 0) ){
5564 rowoffset = (srcSurfaceWidth - srcWidth) * pSrcSurface->bytesPerPixel;
5565 offset += pSourceRect->left * pSrcSurface->bytesPerPixel;
5566 /* TODO: do we ever get 3bpp?, would a shift and an add be quicker than a mul (well maybe a cycle or two) */
5568 /* TODO DXT formats */
5570 if(pSourceRect != NULL && pSourceRect->top != 0){
5571 offset += pSourceRect->top * srcWidth * pSrcSurface->bytesPerPixel;
5573 TRACE("(%p) glTexSubImage2D, Level %d, left %d, top %d, width %d, height %d , ftm %d, type %d, memory %p\n"
5575 ,glDescription->level
5580 ,glDescription->glFormat
5581 ,glDescription->glType
5582 ,IWineD3DSurface_GetData(pSourceSurface)
5586 if (IWineD3DSurface_GetData(pSourceSurface) == NULL) {
5588 /* need to lock the surface to get the data */
5589 FIXME("Surfaces has no allocated memory, but should be an in memory only surface\n");
5592 /* TODO: Cube and volume support */
5594 /* not a whole row so we have to do it a line at a time */
5597 /* hopefully using pointer addtion will be quicker than using a point + j * rowoffset */
5598 unsigned char* data =((unsigned char *)IWineD3DSurface_GetData(pSourceSurface)) + offset;
5600 for(j = destTop ; j < (srcHeight + destTop) ; j++){
5602 glTexSubImage2D(glDescription->target
5603 ,glDescription->level
5608 ,glDescription->glFormat
5609 ,glDescription->glType
5610 ,data /* could be quicker using */
5615 } else { /* Full width, so just write out the whole texture */
5617 if (WINED3DFMT_DXT1 == destFormat ||
5618 WINED3DFMT_DXT2 == destFormat ||
5619 WINED3DFMT_DXT3 == destFormat ||
5620 WINED3DFMT_DXT4 == destFormat ||
5621 WINED3DFMT_DXT5 == destFormat) {
5622 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
5623 if (destSurfaceHeight != srcHeight || destSurfaceWidth != srcWidth) {
5624 /* FIXME: The easy way to do this is lock the destination, and copy the bits accross */
5625 FIXME("Updating part of a compressed texture is not supported at the moment\n");
5626 } if (destFormat != srcFormat) {
5627 FIXME("Updating mixed format compressed texture is not curretly support\n");
5629 GL_EXTCALL(glCompressedTexImage2DARB)(glDescription->target,
5630 glDescription->level,
5631 glDescription->glFormatInternal,
5636 IWineD3DSurface_GetData(pSourceSurface));
5639 FIXME("Attempting to update a DXT compressed texture without hardware support\n");
5644 if (NP2_REPACK == wined3d_settings.nonpower2_mode) {
5646 /* some applications cannot handle odd pitches returned by soft non-power2, so we have
5647 to repack the data from pow2Width/Height to expected Width,Height, this makes the
5648 data returned by GetData non-power2 width/height with hardware non-power2
5649 pow2Width/height are set to surface width height, repacking isn't needed so it
5650 doesn't matter which function gets called. */
5651 glTexSubImage2D(glDescription->target
5652 ,glDescription->level
5657 ,glDescription->glFormat
5658 ,glDescription->glType
5659 ,IWineD3DSurface_GetData(pSourceSurface)
5663 /* not repacked, the data returned by IWineD3DSurface_GetData is pow2Width x pow2Height */
5664 glTexSubImage2D(glDescription->target
5665 ,glDescription->level
5668 ,((IWineD3DSurfaceImpl *)pSourceSurface)->pow2Width
5669 ,((IWineD3DSurfaceImpl *)pSourceSurface)->pow2Height
5670 ,glDescription->glFormat
5671 ,glDescription->glType
5672 ,IWineD3DSurface_GetData(pSourceSurface)
5678 checkGLcall("glTexSubImage2D");
5680 /* I only need to look up baseTexture here, so it may be a good idea to hava a GL_TARGET ->
5681 * GL_DIMENSIONS lookup, or maybe store the dimensions on the surface (but that's making the
5682 * surface bigger than it needs to be hmm.. */
5683 if (D3D_OK == IWineD3DSurface_GetContainer(pDestinationSurface, &IID_IWineD3DBaseTexture, (void **)&baseTexture)) {
5684 textureDimensions = IWineD3DBaseTexture_GetTextureDimensions(baseTexture);
5685 IWineD3DBaseTexture_Release(baseTexture);
5688 glDisable(textureDimensions); /* This needs to be managed better.... */
5694 /* Used by DirectX 8 */
5695 HRESULT WINAPI IWineD3DDeviceImpl_CopyRects(IWineD3DDevice *iface,
5696 IWineD3DSurface* pSourceSurface, CONST RECT* pSourceRectsArray, UINT cRects,
5697 IWineD3DSurface* pDestinationSurface, CONST POINT* pDestPointsArray) {
5699 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5700 HRESULT hr = D3D_OK;
5701 WINED3DFORMAT srcFormat, destFormat;
5702 UINT srcWidth, destWidth;
5703 UINT srcHeight, destHeight;
5705 WINED3DSURFACE_DESC winedesc;
5707 TRACE("(%p) pSrcSur=%p, pSourceRects=%p, cRects=%d, pDstSur=%p, pDestPtsArr=%p\n", This,
5708 pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray);
5711 /* Check that the source texture is in WINED3DPOOL_SYSTEMMEM and the destination texture is in WINED3DPOOL_DEFAULT */
5712 memset(&winedesc, 0, sizeof(winedesc));
5714 winedesc.Format = &srcFormat;
5715 winedesc.Width = &srcWidth;
5716 winedesc.Height = &srcHeight;
5717 winedesc.Size = &srcSize;
5718 IWineD3DSurface_GetDesc(pSourceSurface, &winedesc);
5720 winedesc.Format = &destFormat;
5721 winedesc.Width = &destWidth;
5722 winedesc.Height = &destHeight;
5723 winedesc.Size = NULL;
5724 IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
5726 /* Check that the source and destination formats match */
5727 if (srcFormat != destFormat && WINED3DFMT_UNKNOWN != destFormat) {
5728 WARN("(%p) source %p format must match the dest %p format, returning D3DERR_INVALIDCALL\n", This, pSourceSurface, pDestinationSurface);
5729 return D3DERR_INVALIDCALL;
5730 } else if (WINED3DFMT_UNKNOWN == destFormat) {
5731 TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", This);
5732 IWineD3DSurface_SetFormat(pDestinationSurface, srcFormat);
5733 destFormat = srcFormat;
5736 /* Quick if complete copy ... */
5737 if (cRects == 0 && pSourceRectsArray == NULL && pDestPointsArray == NULL) {
5739 if (srcWidth == destWidth && srcHeight == destHeight) {
5740 D3DLOCKED_RECT lrSrc;
5741 D3DLOCKED_RECT lrDst;
5742 IWineD3DSurface_LockRect(pSourceSurface, &lrSrc, NULL, WINED3DLOCK_READONLY);
5743 IWineD3DSurface_LockRect(pDestinationSurface, &lrDst, NULL, 0L);
5744 TRACE("Locked src and dst, Direct copy as surfaces are equal, w=%d, h=%d\n", srcWidth, srcHeight);
5746 memcpy(lrDst.pBits, lrSrc.pBits, srcSize);
5748 IWineD3DSurface_UnlockRect(pSourceSurface);
5749 IWineD3DSurface_UnlockRect(pDestinationSurface);
5750 TRACE("Unlocked src and dst\n");
5754 FIXME("Wanted to copy all surfaces but size not compatible, returning D3DERR_INVALIDCALL\n");
5755 hr = D3DERR_INVALIDCALL;
5760 if (NULL != pSourceRectsArray && NULL != pDestPointsArray) {
5762 int bytesPerPixel = ((IWineD3DSurfaceImpl *) pSourceSurface)->bytesPerPixel;
5765 /* Copy rect by rect */
5766 for (i = 0; i < cRects; ++i) {
5767 CONST RECT* r = &pSourceRectsArray[i];
5768 CONST POINT* p = &pDestPointsArray[i];
5771 D3DLOCKED_RECT lrSrc;
5772 D3DLOCKED_RECT lrDst;
5775 TRACE("Copying rect %d (%ld,%ld),(%ld,%ld) -> (%ld,%ld)\n", i, r->left, r->top, r->right, r->bottom, p->x, p->y);
5776 if (srcFormat == WINED3DFMT_DXT1) {
5777 copyperline = ((r->right - r->left) * bytesPerPixel) / 2; /* DXT1 is half byte per pixel */
5779 copyperline = ((r->right - r->left) * bytesPerPixel);
5782 IWineD3DSurface_LockRect(pSourceSurface, &lrSrc, r, WINED3DLOCK_READONLY);
5783 dest_rect.left = p->x;
5784 dest_rect.top = p->y;
5785 dest_rect.right = p->x + (r->right - r->left);
5786 dest_rect.bottom= p->y + (r->bottom - r->top);
5787 IWineD3DSurface_LockRect(pDestinationSurface, &lrDst, &dest_rect, 0L);
5788 TRACE("Locked src and dst\n");
5790 /* Find where to start */
5791 for (j = 0; j < (r->bottom - r->top - 1); ++j) {
5792 memcpy((char*) lrDst.pBits + (j * lrDst.Pitch), (char*) lrSrc.pBits + (j * lrSrc.Pitch), copyperline);
5794 IWineD3DSurface_UnlockRect(pSourceSurface);
5795 IWineD3DSurface_UnlockRect(pDestinationSurface);
5796 TRACE("Unlocked src and dst\n");
5799 FIXME("Wanted to copy partial surfaces not implemented, returning D3DERR_INVALIDCALL\n");
5800 hr = D3DERR_INVALIDCALL;
5807 /* Implementation details at http://developer.nvidia.com/attach/6494
5809 http://oss.sgi.com/projects/ogl-sample/registry/NV/evaluators.txt
5810 hmm.. no longer supported use
5811 OpenGL evaluators or tessellate surfaces within your application.
5814 /* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/DrawRectPatch.asp */
5815 HRESULT WINAPI IWineD3DDeviceImpl_DrawRectPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST WINED3DRECTPATCH_INFO* pRectPatchInfo) {
5816 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5817 TRACE("(%p) Handle(%d) noSegs(%p) rectpatch(%p)\n", This, Handle, pNumSegs, pRectPatchInfo);
5818 FIXME("(%p) : Stub\n", This);
5823 /* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/DrawTriPatch.asp */
5824 HRESULT WINAPI IWineD3DDeviceImpl_DrawTriPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST WINED3DTRIPATCH_INFO* pTriPatchInfo) {
5825 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5826 TRACE("(%p) Handle(%d) noSegs(%p) tripatch(%p)\n", This, Handle, pNumSegs, pTriPatchInfo);
5827 FIXME("(%p) : Stub\n", This);
5831 HRESULT WINAPI IWineD3DDeviceImpl_DeletePatch(IWineD3DDevice *iface, UINT Handle) {
5832 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5833 TRACE("(%p) Handle(%d)\n", This, Handle);
5834 FIXME("(%p) : Stub\n", This);
5838 HRESULT WINAPI IWineD3DDeviceImpl_ColorFill(IWineD3DDevice *iface, IWineD3DSurface *pSurface, CONST D3DRECT* pRect, D3DCOLOR color) {
5839 /* I couldn't find a 'really' quick way of doing this in openGl so here goes
5840 fill a surface with a block of color! */
5841 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5842 /* TODO: get rid of the use of IWineD3DSurfaceImpl, move code into surface.c */
5843 IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)pSurface;
5844 IWineD3DSwapChainImpl *container = NULL;
5845 BOOL isRenderTarget = FALSE;
5846 unsigned int width, height;
5847 unsigned int top, left;
5850 TRACE("(%p) Colour fill Surface: %p rect: %p color: %ld\n", This, pSurface, pRect, color);
5852 if (surface->resource.pool != WINED3DPOOL_DEFAULT) {
5853 FIXME("call to colorfill with non WINED3DPOOL_DEFAULT surface\n");
5854 return D3DERR_INVALIDCALL;
5857 /* TODO: get rid of IWineD3DSwapChainImpl reference, a 'context' manager may help with this */
5858 if (D3D_OK == IWineD3DSurface_GetContainer(pSurface, &IID_IWineD3DSwapChain, (void **)&container) || pSurface == This->renderTarget) {
5859 if (WINED3DUSAGE_RENDERTARGET & surface->resource.usage) {
5860 /* TODO: make sure we set everything back to the way it was, and context management!
5861 glGetIntegerv(GL_READ_BUFFER, &prev_read);
5862 vcheckGLcall("glIntegerv");
5863 glGetIntegerv(GL_PACK_SWAP_BYTES, &prev_store);
5864 vcheckGLcall("glIntegerv");
5866 TRACE("Color fill to render targets may cause some graphics issues\n");
5867 if (pSurface == container->frontBuffer) {
5868 glDrawBuffer(GL_FRONT);
5870 glDrawBuffer(GL_BACK);
5873 if (WINED3DUSAGE_DEPTHSTENCIL & surface->resource.usage) {
5874 FIXME("colouring of depth_stencil? %p buffers is not yet supported? %ld\n", surface, surface->resource.usage);
5876 FIXME("(%p) : Regression %ld %p %p\n", This, surface->resource.usage, pSurface, This->renderTarget);
5878 if (container != NULL) {
5879 IWineD3DSwapChain_Release((IWineD3DSwapChain *)container);
5881 /* we can use GL_STENCIL_INDEX etc...*/
5884 if (container != NULL) {
5885 IWineD3DSwapChain_Release((IWineD3DSwapChain *)container);
5887 isRenderTarget = TRUE;
5889 /* TODO: drawing to GL_FRONT and GL_BACK */
5890 /* TODO: see if things can be speeded up by using the correct
5891 * colour model of the target texture from the start (16 bit graphics on 32 X are slow anyway!) */
5892 if (pRect == NULL) {
5895 width = surface->currentDesc.Width;
5896 height = surface->currentDesc.Height;
5900 width = pRect->x2 - left;
5901 height = pRect->y2 - top;
5904 data = HeapAlloc(GetProcessHeap(), 0, 4 * width);
5905 /* Create a 'line' of color color, in the correct format for the surface */
5906 for (u = 0 ; u < width ; u ++) {
5911 if (isRenderTarget == FALSE) {
5912 glDescriptor *glDesc;
5913 IWineD3DSurface_PreLoad(pSurface);
5915 /* draw a block of the coloured line on the sufrace */
5916 IWineD3DSurface_GetGlDesc(pSurface, &glDesc);
5917 for (v = 0 ; v< height;v++) {
5918 glTexSubImage2D(glDesc->target
5919 ,glDesc->level /* level */
5929 checkGLcall("glTexSubImage2D");
5931 glDisable(glDesc->target);
5933 /** FIXME: Using GLClear may be faster **/
5934 glRasterPos2i(left, top);
5935 glPixelZoom((float)width ,(float)height);
5936 glDrawPixels(1, 1, GL_RGBA, GL_UNSIGNED_BYTE, data);
5937 checkGLcall("glDrawPixels");
5939 HeapFree(GetProcessHeap(), 0, data);
5945 /* rendertarget and deptth stencil functions */
5946 HRESULT WINAPI IWineD3DDeviceImpl_GetRenderTarget(IWineD3DDevice* iface,DWORD RenderTargetIndex, IWineD3DSurface **ppRenderTarget) {
5947 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5949 /* FIXME: Implelent RenderTargetIndex >0 */
5950 if(RenderTargetIndex > 0)
5951 FIXME("(%p) : RenderTargetIndex %ld >0 not currently supported\n", This, RenderTargetIndex);
5953 *ppRenderTarget = This->renderTarget;
5954 TRACE("(%p) : RenderTarget %ld Index returning %p\n", This, RenderTargetIndex, *ppRenderTarget);
5955 /* Note inc ref on returned surface */
5956 if(*ppRenderTarget != NULL)
5957 IWineD3DSurface_AddRef(*ppRenderTarget);
5961 HRESULT WINAPI IWineD3DDeviceImpl_GetDepthStencilSurface(IWineD3DDevice* iface, IWineD3DSurface **ppZStencilSurface) {
5962 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5963 *ppZStencilSurface = This->depthStencilBuffer;
5964 TRACE("(%p) : zStencilSurface returning %p\n", This, *ppZStencilSurface);
5966 if(*ppZStencilSurface != NULL) {
5967 /* Note inc ref on returned surface */
5968 IWineD3DSurface_AddRef(*ppZStencilSurface);
5973 /* internal static helper functions */
5974 HRESULT WINAPI static IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
5975 IWineD3DSurface *RenderSurface);
5977 HRESULT WINAPI IWineD3DDeviceImpl_SetRenderTarget(IWineD3DDevice *iface, DWORD RenderTargetIndex, IWineD3DSurface *pRenderTarget) {
5978 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5979 HRESULT hr = D3D_OK;
5980 WINED3DVIEWPORT viewport;
5982 TRACE("(%p) Swapping rendertarget\n",This);
5983 if (RenderTargetIndex > 0) {
5984 FIXME("(%p) Render targets other than the first are not supported\n",This);
5985 RenderTargetIndex = 0;
5988 /* MSDN says that null disables the render target
5989 but a device must always be associated with a render target
5990 nope MSDN says that we return invalid call to a null rendertarget with an index of 0
5992 see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/AdvancedTopics/PixelPipe/MultipleRenderTarget.asp
5995 if (RenderTargetIndex == 0 && pRenderTarget == NULL) {
5996 FIXME("Trying to set render target 0 to NULL\n");
5997 return D3DERR_INVALIDCALL;
5999 /* TODO: replace Impl* usage with interface usage */
6000 if (!((IWineD3DSurfaceImpl *)pRenderTarget)->resource.usage & WINED3DUSAGE_RENDERTARGET) {
6001 FIXME("(%p)Trying to set the render target to a surface(%p) that wasn't created with a usage of WINED3DUSAGE_RENDERTARGET\n",This ,pRenderTarget);
6002 return D3DERR_INVALIDCALL;
6004 /** TODO: check that the depth stencil format matches the render target, this is only done in debug
6005 * builds, but I think wine counts as a 'debug' build for now.
6006 ******************************/
6007 /* If we are trying to set what we already have, don't bother */
6008 if (pRenderTarget == This->renderTarget) {
6009 TRACE("Trying to do a NOP SetRenderTarget operation\n");
6011 /* Otherwise, set the render target up */
6013 if (FALSE == This->sceneEnded) {
6014 IWineD3DDevice_EndScene(iface);
6016 TRACE("clearing renderer\n");
6017 /* IWineD3DDeviceImpl_CleanRender(iface); */
6018 /* OpenGL doesn't support 'sharing' of the stencilBuffer so we may incure an extra memory overhead
6019 depending on the renter target implementation being used.
6020 A shared context implementation will share all buffers between all rendertargets (including swapchains),
6021 implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the
6022 stencil buffer and incure an extra memory overhead */
6023 hr = IWineD3DDeviceImpl_ActiveRender(iface, pRenderTarget);
6026 if (SUCCEEDED(hr)) {
6027 /* Finally, reset the viewport as the MSDN states. */
6028 /* TODO: Replace impl usage */
6029 viewport.Height = ((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height;
6030 viewport.Width = ((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Width;
6033 viewport.MaxZ = 1.0f;
6034 viewport.MinZ = 0.0f;
6035 IWineD3DDeviceImpl_SetViewport(iface, &viewport);
6037 FIXME("Unknown error setting the render target\n");
6039 This->sceneEnded = FALSE;
6043 HRESULT WINAPI IWineD3DDeviceImpl_SetDepthStencilSurface(IWineD3DDevice *iface, IWineD3DSurface *pNewZStencil) {
6044 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6045 HRESULT hr = D3D_OK;
6046 IWineD3DSurface *tmp;
6048 TRACE("(%p) Swapping z-buffer\n",This);
6050 if (pNewZStencil == This->stencilBufferTarget) {
6051 TRACE("Trying to do a NOP SetRenderTarget operation\n");
6053 /** OpenGL doesn't support 'sharing' of the stencilBuffer so we may incure an extra memory overhead
6054 * depending on the renter target implementation being used.
6055 * A shared context implementation will share all buffers between all rendertargets (including swapchains),
6056 * implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the
6057 * stencil buffer and incure an extra memory overhead
6058 ******************************************************/
6061 tmp = This->stencilBufferTarget;
6062 This->stencilBufferTarget = pNewZStencil;
6063 /* should we be calling the parent or the wined3d surface? */
6064 if (NULL != This->stencilBufferTarget) IWineD3DSurface_AddRef(This->stencilBufferTarget);
6065 if (NULL != tmp) IWineD3DSurface_Release(tmp);
6067 /** TODO: glEnable/glDisable on depth/stencil depending on
6068 * pNewZStencil is NULL and the depth/stencil is enabled in d3d
6069 **********************************************************/
6076 #ifdef GL_VERSION_1_3
6077 /* Internal functions not in DirectX */
6078 /** TODO: move this off to the opengl context manager
6079 *(the swapchain doesn't need to know anything about offscreen rendering!)
6080 ****************************************************/
6082 HRESULT WINAPI IWineD3DDeviceImpl_CleanRender(IWineD3DDevice* iface, IWineD3DSwapChainImpl *swapchain)
6084 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6086 TRACE("(%p), %p\n", This, swapchain);
6088 if (swapchain->win != swapchain->drawable) {
6089 /* Set everything back the way it ws */
6090 swapchain->render_ctx = swapchain->glCtx;
6091 swapchain->drawable = swapchain->win;
6096 /* TODO: move this off into a context manager so that GLX_ATI_render_texture and other types of surface can be used. */
6097 HRESULT WINAPI IWineD3DDeviceImpl_FindGLContext(IWineD3DDevice *iface, IWineD3DSurface *pSurface, glContext **context) {
6098 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6101 unsigned int height;
6102 WINED3DFORMAT format;
6103 WINED3DSURFACE_DESC surfaceDesc;
6104 memset(&surfaceDesc, 0, sizeof(surfaceDesc));
6105 surfaceDesc.Width = &width;
6106 surfaceDesc.Height = &height;
6107 surfaceDesc.Format = &format;
6108 IWineD3DSurface_GetDesc(pSurface, &surfaceDesc);
6110 /* I need a get width/height function (and should do something with the format) */
6111 for (i = 0; i < CONTEXT_CACHE; ++i) {
6112 /** NOTE: the contextCache[i].pSurface == pSurface check ceates onepbuffer per surface
6113 ATI cards don't destroy pbuffers, but as soon as resource releasing callbacks are inplace
6114 the pSurface can be set to 0 allowing it to be reused from cache **/
6115 if (This->contextCache[i].Width == width && This->contextCache[i].Height == height
6116 && (pbuffer_per_surface == FALSE || This->contextCache[i].pSurface == pSurface || This->contextCache[i].pSurface == NULL)) {
6117 *context = &This->contextCache[i];
6120 if (This->contextCache[i].Width == 0) {
6121 This->contextCache[i].pSurface = pSurface;
6122 This->contextCache[i].Width = width;
6123 This->contextCache[i].Height = height;
6124 *context = &This->contextCache[i];
6128 if (i == CONTEXT_CACHE) {
6129 int minUsage = 0x7FFFFFFF; /* MAX_INT */
6130 glContext *dropContext = 0;
6131 for (i = 0; i < CONTEXT_CACHE; i++) {
6132 if (This->contextCache[i].usedcount < minUsage) {
6133 dropContext = &This->contextCache[i];
6134 minUsage = This->contextCache[i].usedcount;
6137 /* clean up the context (this doesn't work for ATI at the moment */
6139 glXDestroyContext(swapchain->display, dropContext->context);
6140 glXDestroyPbuffer(swapchain->display, dropContext->drawable);
6143 dropContext->Width = 0;
6144 dropContext->pSurface = pSurface;
6145 *context = dropContext;
6147 if (++This->contextCache[i].usedcount == 0x7FFFFFFF /* MAX_INT */ - 1 ) {
6148 for (i = 0; i < CONTEXT_CACHE; i++) {
6149 This->contextCache[i].usedcount = max(0, This->contextCache[i].usedcount - (0x7FFFFFFF /* MAX_INT */ >> 1));
6153 if (*context != NULL)
6156 return E_OUTOFMEMORY;
6160 /** FIXME: This is currently used called whenever SetRenderTarget or SetStencilBuffer are called
6161 * the functionality needs splitting up so that we don't do more than we should do.
6162 * this only seems to impact performance a little.
6163 ******************************/
6164 HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
6165 IWineD3DSurface *RenderSurface) {
6166 HRESULT ret = D3DERR_INVALIDCALL;
6169 * Currently only active for GLX >= 1.3
6170 * for others versions we'll have to use GLXPixmaps
6172 * normally we must test GLX_VERSION_1_3 but nvidia headers are not correct
6173 * as they implement GLX 1.3 but only define GLX_VERSION_1_2
6174 * so only check OpenGL version
6175 * ..........................
6176 * I don't believe that it is a problem with NVidia headers,
6177 * XFree only supports GLX1.2, nVidia (and ATI to some extent) provide 1.3 functions
6178 * in GLX 1.2, there is no mention of the correct way to tell if the extensions are provided.
6180 * Your application will report GLX version 1.2 on glXQueryVersion.
6181 * However, it is safe to call the GLX 1.3 functions as described below.
6183 #if defined(GL_VERSION_1_3)
6185 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6186 IWineD3DSurface *StencilSurface = This->stencilBufferTarget;
6187 IWineD3DSurface *tmp;
6188 /** TODO: we only need to look up the configuration !IF! we are setting the target to a texture **/
6189 GLXFBConfig* cfgs = NULL;
6193 IWineD3DSwapChain *currentSwapchain;
6194 IWineD3DSwapChainImpl *swapchain;
6195 /** TODO: get rid of Impl usage we should always create a zbuffer/stencil with our contexts if possible,
6196 * but switch them off if the StencilSurface is set to NULL
6197 ** *********************************************************/
6198 D3DFORMAT BackBufferFormat = ((IWineD3DSurfaceImpl *) RenderSurface)->resource.format;
6199 D3DFORMAT StencilBufferFormat = (NULL != StencilSurface) ? ((IWineD3DSurfaceImpl *) StencilSurface)->resource.format : 0;
6202 if StencilSurface == NULL && zBufferTarget != NULL then switch the zbuffer off,
6203 it StencilSurface != NULL && zBufferTarget == NULL switch it on
6206 #define PUSH1(att) attribs[nAttribs++] = (att);
6207 #define PUSH2(att,value) attribs[nAttribs++] = (att); attribs[nAttribs++] = (value);
6209 /* PUSH2(GLX_BIND_TO_TEXTURE_RGBA_ATI, True); examples of this are few and far between (but I've got a nice working one!)*/
6211 /** TODO: remove the reff to Impl (context manager should fix this!) **/
6212 IWineD3DSwapChainImpl *impSwapChain;
6213 IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **)&impSwapChain);
6214 if (NULL == impSwapChain) { /* NOTE: This should NEVER fail */
6215 ERR("(%p) Failed to get a the implicit swapchain\n", iface);
6220 PUSH2(GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT);
6221 PUSH2(GLX_X_RENDERABLE, TRUE);
6222 PUSH2(GLX_DOUBLEBUFFER, TRUE);
6223 TRACE("calling makeglcfg\n");
6224 D3DFmtMakeGlCfg(BackBufferFormat, StencilBufferFormat, attribs, &nAttribs, FALSE /* alternate */);
6227 TRACE("calling chooseFGConfig\n");
6228 cfgs = glXChooseFBConfig(impSwapChain->display, DefaultScreen(impSwapChain->display),
6231 if (!cfgs) { /* OK we didn't find the exact config, so use any reasonable match */
6232 /* TODO: fill in the 'requested' and 'current' depths, also make sure that's
6233 why we failed and only show this message once! */
6234 MESSAGE("Failed to find exact match, finding alternative but you may suffer performance issues, try changing xfree's depth to match the requested depth\n"); /**/
6236 PUSH2(GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT);
6237 /* PUSH2(GLX_X_RENDERABLE, TRUE); */
6238 PUSH2(GLX_RENDER_TYPE, GLX_RGBA_BIT);
6239 PUSH2(GLX_DOUBLEBUFFER, FALSE);
6240 TRACE("calling makeglcfg\n");
6241 D3DFmtMakeGlCfg(BackBufferFormat, StencilBufferFormat, attribs, &nAttribs, TRUE /* alternate */);
6243 cfgs = glXChooseFBConfig(impSwapChain->display, DefaultScreen(impSwapChain->display),
6250 for (i = 0; i < nCfgs; ++i) {
6251 TRACE("for (%u,%s)/(%u,%s) found config[%d]@%p\n", BackBufferFormat,
6252 debug_d3dformat(BackBufferFormat), StencilBufferFormat,
6253 debug_d3dformat(StencilBufferFormat), i, cfgs[i]);
6256 if (NULL != This->renderTarget) {
6258 vcheckGLcall("glFlush");
6259 /** This is only useful if the old render target was a swapchain,
6260 * we need to supercede this with a function that displays
6261 * the current buffer on the screen. This is easy to do in glx1.3 but
6262 * we need to do copy-write pixels in glx 1.2.
6263 ************************************************/
6264 glXSwapBuffers(impSwapChain->display, impSwapChain->drawable);
6266 printf("Hit Enter to get next frame ...\n");
6272 if (IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DSwapChain, (void **)¤tSwapchain) != D3D_OK) {
6273 /* the selected render target doesn't belong to a swapchain, so use the devices implicit swapchain */
6274 IWineD3DDevice_GetSwapChain(iface, 0, ¤tSwapchain);
6278 * TODO: remove the use of IWineD3DSwapChainImpl, a context manager will help since it will replace the
6279 * renderTarget = swapchain->backBuffer bit and anything to do with *glContexts
6280 **********************************************************************/
6281 if (IWineD3DSurface_GetContainer(RenderSurface, &IID_IWineD3DSwapChain, (void **)&swapchain) == D3D_OK) {
6282 /* We also need to make sure that the lights &co are also in the context of the swapchains */
6283 /* FIXME: If the render target gets sent to the frontBuffer should be be presenting it raw? */
6284 TRACE("making swapchain active\n");
6285 if (RenderSurface != This->renderTarget) {
6286 if (RenderSurface == swapchain->backBuffer) {
6288 /* This could be flagged so that some operations work directly with the front buffer */
6289 FIXME("Attempting to set the renderTarget to the frontBuffer\n");
6291 if (glXMakeCurrent(swapchain->display, swapchain->win, swapchain->glCtx)
6293 TRACE("Error in setting current context: context %p drawable %ld !\n",
6294 impSwapChain->glCtx, impSwapChain->win);
6297 IWineD3DDeviceImpl_CleanRender(iface, (IWineD3DSwapChainImpl *)currentSwapchain);
6299 checkGLcall("glXMakeContextCurrent");
6301 IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
6303 else if (pbuffer_support == TRUE && cfgs != NULL /* && some test to make sure that opengl supports pbuffers */) {
6305 /** ********************************************************************
6306 * This is a quickly hacked out implementation of offscreen textures.
6307 * It will work in most cases but there may be problems if the client
6308 * modifies the texture directly, or expects the contents of the rendertarget
6311 * There are some real speed vs compatibility issues here:
6312 * we should really use a new context for every texture, but that eats ram.
6313 * we should also be restoring the texture to the pbuffer but that eats CPU
6314 * we can also 'reuse' the current pbuffer if the size is larger than the requested buffer,
6315 * but if this means reusing the display backbuffer then we need to make sure that
6316 * states are correctly preserved.
6317 * In many cases I would expect that we can 'skip' some functions, such as preserving states,
6318 * and gain a good performance increase at the cost of compatibility.
6319 * I would suggest that, when this is the case, a user configurable flag be made
6320 * available, allowing the user to choose the best emulated experience for them.
6321 *********************************************************************/
6323 XVisualInfo *visinfo;
6324 glContext *newContext;
6326 /* Here were using a shared context model */
6327 if (D3D_OK != IWineD3DDeviceImpl_FindGLContext(iface, RenderSurface, &newContext)) {
6328 FIXME("(%p) : Failed to find a context for surface %p\n", iface, RenderSurface);
6331 /* If the context doesn't exist then create a new one */
6332 /* TODO: This should really be part of findGlContext */
6333 if (NULL == newContext->context) {
6335 TRACE("making new buffer\n");
6337 PUSH2(GLX_PBUFFER_WIDTH, newContext->Width);
6338 PUSH2(GLX_PBUFFER_HEIGHT, newContext->Height);
6341 newContext->drawable = glXCreatePbuffer(impSwapChain->display, cfgs[0], attribs);
6343 /** ****************************************
6344 *GLX1.3 isn't supported by XFree 'yet' until that point ATI emulates pBuffers
6346 * In future releases, we may provide the calls glXCreateNewContext,
6347 * glXQueryDrawable and glXMakeContextCurrent.
6348 * so until then we have to use glXGetVisualFromFBConfig &co..
6349 ********************************************/
6352 visinfo = glXGetVisualFromFBConfig(impSwapChain->display, cfgs[0]);
6354 ERR("Error: couldn't get an RGBA, double-buffered visual\n");
6356 newContext->context = glXCreateContext(impSwapChain->display, visinfo, impSwapChain->glCtx, GL_TRUE);
6360 if (NULL == newContext || NULL == newContext->context) {
6361 ERR("(%p) : Failed to find a context for surface %p\n", iface, RenderSurface);
6363 /* Debug logging, (this function leaks), change to a TRACE when the leak is plugged */
6364 if (glXMakeCurrent(impSwapChain->display, newContext->drawable, newContext->context) == False) {
6365 TRACE("Error in setting current context: context %p drawable %ld\n", newContext->context, newContext->drawable);
6368 /* Clean up the old context */
6369 IWineD3DDeviceImpl_CleanRender(iface, (IWineD3DSwapChainImpl *)currentSwapchain);
6370 /* Set the current context of the swapchain to the new context */
6371 impSwapChain->drawable = newContext->drawable;
6372 impSwapChain->render_ctx = newContext->context;
6376 #if 1 /* Apply the stateblock to the new context
6377 FIXME: This is a bit of a hack, each context should know it's own state,
6378 the directX current directX state should then be applied to the context */
6381 IWineD3DStateBlockImpl *oldUpdateStateBlock;
6382 oldUpdateStateBlock = This->updateStateBlock;
6383 oldRecording= This->isRecordingState;
6384 This->isRecordingState = FALSE;
6385 This->updateStateBlock = This->stateBlock;
6386 IWineD3DStateBlock_Apply((IWineD3DStateBlock *)This->stateBlock);
6388 This->isRecordingState = oldRecording;
6389 This->updateStateBlock = oldUpdateStateBlock;
6394 /* clean up the current rendertargets swapchain (if it belonged to one) */
6395 if (currentSwapchain != NULL) {
6396 IWineD3DSwapChain_Release((IWineD3DSwapChain *)currentSwapchain);
6399 /* Were done with the opengl context management, setup the rendertargets */
6401 tmp = This->renderTarget;
6402 This->renderTarget = RenderSurface;
6403 IWineD3DSurface_AddRef(This->renderTarget);
6404 IWineD3DSurface_Release(tmp);
6410 /* The surface must be rendered upside down to cancel the flip produce by glCopyTexImage */
6411 /* Check that the container is not a swapchain member */
6413 IWineD3DSwapChain *tmpSwapChain;
6414 if (D3D_OK != IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DSwapChain, (void **)&tmpSwapChain)) {
6415 This->renderUpsideDown = TRUE;
6417 This->renderUpsideDown = FALSE;
6418 IWineD3DSwapChain_Release(tmpSwapChain);
6420 /* Force updating the cull mode */
6421 TRACE("setting render state\n");
6422 IWineD3DDevice_GetRenderState(iface, WINED3DRS_CULLMODE, &value);
6423 IWineD3DDevice_SetRenderState(iface, WINED3DRS_CULLMODE, value);
6425 /* Force updating projection matrix */
6426 This->last_was_rhw = FALSE;
6427 This->proj_valid = FALSE;
6435 ERR("cannot get valides GLXFBConfig for (%u,%s)/(%u,%s)\n", BackBufferFormat,
6436 debug_d3dformat(BackBufferFormat), StencilBufferFormat, debug_d3dformat(StencilBufferFormat));
6441 if ( NULL != impSwapChain) {
6442 IWineD3DSwapChain_Release((IWineD3DSwapChain *)impSwapChain);
6450 HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice* iface, UINT XHotSpot,
6451 UINT YHotSpot, IWineD3DSurface *pCursorBitmap) {
6452 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6453 /* TODO: the use of Impl is deprecated. */
6454 /* some basic validation checks */
6455 IWineD3DSurfaceImpl * pSur = (IWineD3DSurfaceImpl *) pCursorBitmap;
6457 TRACE("(%p) : Spot Pos(%u,%u)\n", This, XHotSpot, YHotSpot);
6459 if (WINED3DFMT_A8R8G8B8 != pSur->resource.format) {
6460 ERR("(%p) : surface(%p) has an invalid format\n", This, pCursorBitmap);
6461 return D3DERR_INVALIDCALL;
6463 if (32 != pSur->currentDesc.Height || 32 != pSur->currentDesc.Width) {
6464 ERR("(%p) : surface(%p) has an invalid size\n", This, pCursorBitmap);
6465 return D3DERR_INVALIDCALL;
6467 /* TODO: make the cursor 'real' */
6469 This->xHotSpot = XHotSpot;
6470 This->yHotSpot = YHotSpot;
6475 void WINAPI IWineD3DDeviceImpl_SetCursorPosition(IWineD3DDevice* iface, int XScreenSpace, int YScreenSpace, DWORD Flags) {
6476 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6477 TRACE("(%p) : SetPos to (%u,%u)\n", This, XScreenSpace, YScreenSpace);
6479 This->xScreenSpace = XScreenSpace;
6480 This->yScreenSpace = YScreenSpace;
6486 BOOL WINAPI IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOOL bShow) {
6487 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6488 TRACE("(%p) : visible(%d)\n", This, bShow);
6490 This->bCursorVisible = bShow;
6495 HRESULT WINAPI IWineD3DDeviceImpl_TestCooperativeLevel(IWineD3DDevice* iface) {
6496 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6497 TRACE("(%p) : state (%lu)\n", This, This->state);
6498 /* TODO: Implement wrapping of the WndProc so that mimimize and maxamise can be monitored and the states adjusted. */
6499 switch (This->state) {
6502 case D3DERR_DEVICELOST:
6504 ResourceList *resourceList = This->resources;
6505 while (NULL != resourceList) {
6506 if (((IWineD3DResourceImpl *)resourceList->resource)->resource.pool == WINED3DPOOL_DEFAULT /* TODO: IWineD3DResource_GetPool(resourceList->resource)*/)
6507 return D3DERR_DEVICENOTRESET;
6508 resourceList = resourceList->next;
6510 return D3DERR_DEVICELOST;
6512 case D3DERR_DRIVERINTERNALERROR:
6513 return D3DERR_DRIVERINTERNALERROR;
6517 return D3DERR_DRIVERINTERNALERROR;
6521 HRESULT WINAPI IWineD3DDeviceImpl_EvictManagedResources(IWineD3DDevice* iface) {
6522 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6523 /** FIXME: Resource tracking needs to be done,
6524 * The closes we can do to this is set the priorities of all managed textures low
6525 * and then reset them.
6526 ***********************************************************/
6527 FIXME("(%p) : stub\n", This);
6531 HRESULT WINAPI IWineD3DDeviceImpl_Rest(IWineD3DDevice* iface, D3DPRESENT_PARAMETERS* pPresentationParameters) {
6532 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6533 /** FIXME: Resource trascking needs to be done.
6534 * in effect this pulls all non only default
6535 * textures out of video memory and deletes all glTextures (glDeleteTextures)
6536 * and should clear down the context and set it up according to pPresentationParameters
6537 ***********************************************************/
6538 FIXME("(%p) : stub\n", This);
6542 HRESULT WINAPI IWineD3DDeviceImpl_SetDialogBoxMode(IWineD3DDevice *iface, BOOL bEnableDialogs) {
6543 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6544 /** FIXME: always true at the moment **/
6545 if(bEnableDialogs == FALSE) {
6546 FIXME("(%p) Dialogs cannot be disabled yet\n", This);
6552 HRESULT WINAPI IWineD3DDeviceImpl_GetCreationParameters(IWineD3DDevice *iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) {
6553 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6554 TRACE("(%p) : pParameters %p\n", This, pParameters);
6556 *pParameters = This->createParms;
6560 void WINAPI IWineD3DDeviceImpl_SetGammaRamp(IWineD3DDevice * iface, UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp) {
6561 IWineD3DSwapChain *swapchain;
6562 HRESULT hrc = D3D_OK;
6564 TRACE("Relaying to swapchain\n");
6566 if ((hrc = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain)) == D3D_OK) {
6567 IWineD3DSwapChain_SetGammaRamp(swapchain, Flags, (D3DGAMMARAMP *)pRamp);
6568 IWineD3DSwapChain_Release(swapchain);
6573 void WINAPI IWineD3DDeviceImpl_GetGammaRamp(IWineD3DDevice *iface, UINT iSwapChain, D3DGAMMARAMP* pRamp) {
6574 IWineD3DSwapChain *swapchain;
6575 HRESULT hrc = D3D_OK;
6577 TRACE("Relaying to swapchain\n");
6579 if ((hrc = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain)) == D3D_OK) {
6580 hrc =IWineD3DSwapChain_GetGammaRamp(swapchain, pRamp);
6581 IWineD3DSwapChain_Release(swapchain);
6587 /** ********************************************************
6588 * Notification functions
6589 ** ********************************************************/
6590 /** This function must be called in the release of a resource when ref == 0,
6591 * the contents of resource must still be correct,
6592 * any handels to other resource held by the caller must be closed
6593 * (e.g. a texture should release all held surfaces because telling the device that it's been released.)
6594 *****************************************************/
6595 static void WINAPI IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource){
6596 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6597 ResourceList* resourceList;
6599 TRACE("(%p) : resource %p\n", This, resource);
6601 EnterCriticalSection(&resourceStoreCriticalSection);
6603 /* add a new texture to the frot of the linked list */
6604 resourceList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ResourceList));
6605 resourceList->resource = resource;
6607 /* Get the old head */
6608 resourceList->next = This->resources;
6610 This->resources = resourceList;
6611 TRACE("Added resource %p with element %p pointing to %p\n", resource, resourceList, resourceList->next);
6614 LeaveCriticalSection(&resourceStoreCriticalSection);
6619 static void WINAPI IWineD3DDeviceImpl_RemoveResource(IWineD3DDevice *iface, IWineD3DResource *resource){
6620 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6621 ResourceList* resourceList = NULL;
6622 ResourceList* previousResourceList = NULL;
6624 TRACE("(%p) : resource %p\n", This, resource);
6627 EnterCriticalSection(&resourceStoreCriticalSection);
6629 resourceList = This->resources;
6631 while (resourceList != NULL) {
6632 if(resourceList->resource == resource) break;
6633 previousResourceList = resourceList;
6634 resourceList = resourceList->next;
6637 if (resourceList == NULL) {
6638 FIXME("Attempted to remove resource %p that hasn't been stored\n", resource);
6640 LeaveCriticalSection(&resourceStoreCriticalSection);
6644 TRACE("Found resource %p with element %p pointing to %p (previous %p)\n", resourceList->resource, resourceList, resourceList->next, previousResourceList);
6646 /* make sure we don't leave a hole in the list */
6647 if (previousResourceList != NULL) {
6648 previousResourceList->next = resourceList->next;
6650 This->resources = resourceList->next;
6654 LeaveCriticalSection(&resourceStoreCriticalSection);
6660 void WINAPI IWineD3DDeviceImpl_ResourceReleased(IWineD3DDevice *iface, IWineD3DResource *resource){
6661 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6664 TRACE("(%p) : resource %p\n", This, resource);
6665 switch(IWineD3DResource_GetType(resource)){
6666 case WINED3DRTYPE_SURFACE:
6667 /* TODO: check front and back buffers, rendertargets etc.. possibly swapchains? */
6669 case WINED3DRTYPE_TEXTURE:
6670 case WINED3DRTYPE_CUBETEXTURE:
6671 case WINED3DRTYPE_VOLUMETEXTURE:
6672 for (counter = 0; counter < GL_LIMITS(textures); counter++) {
6673 if (This->stateBlock != NULL && This->stateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
6674 WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
6675 This->stateBlock->textures[counter] = NULL;
6677 if (This->updateStateBlock != This->stateBlock ){
6678 if (This->updateStateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
6679 WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
6680 This->updateStateBlock->textures[counter] = NULL;
6685 case WINED3DRTYPE_VOLUME:
6686 /* TODO: nothing really? */
6688 case WINED3DRTYPE_VERTEXBUFFER:
6689 /* MSDN: When an application no longer holds a references to this interface, the interface will automatically be freed. */
6692 TRACE("Cleaning up stream pointers\n");
6694 for(streamNumber = 0; streamNumber < MAX_STREAMS; streamNumber ++){
6695 /* FINDOUT: should a warn be generated if were recording and updateStateBlock->streamSource is lost?
6696 FINDOUT: should changes.streamSource[StreamNumber] be set ?
6698 if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
6699 if ((IWineD3DResource *)This->updateStateBlock->streamSource[streamNumber] == resource) {
6700 FIXME("Vertex buffer released whlst bound to a state block stream %d\n", streamNumber);
6701 This->updateStateBlock->streamSource[streamNumber] = 0;
6702 /* Set changed flag? */
6705 if (This->stateBlock != NULL ) { /* only happens if there is an error in the application, or on reset/release (because we don't manage internal tracking properly) */
6706 if ((IWineD3DResource *)This->stateBlock->streamSource[streamNumber] == resource) {
6707 TRACE("Vertex buffer released whlst bound to a state block stream %d\n", streamNumber);
6708 This->stateBlock->streamSource[streamNumber] = 0;
6711 #if 0 /* TODO: Manage internal tracking properly so that 'this shouldn't happen' */
6712 else { /* This shouldn't happen */
6713 FIXME("Calling application has released the device before relasing all the resources bound to the device\n");
6720 case WINED3DRTYPE_INDEXBUFFER:
6721 /* MSDN: When an application no longer holds a references to this interface, the interface will automatically be freed.*/
6722 if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
6723 if (This->updateStateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
6724 This->updateStateBlock->pIndexData = NULL;
6727 if (This->stateBlock != NULL ) { /* ==NULL when device is being destroyed */
6728 if (This->stateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
6729 This->stateBlock->pIndexData = NULL;
6735 FIXME("(%p) unknown resource type %p %u\n", This, resource, IWineD3DResource_GetType(resource));
6740 /* Remove the resoruce from the resourceStore */
6741 IWineD3DDeviceImpl_RemoveResource(iface, resource);
6743 TRACE("Resource released\n");
6748 /** This function is to be called by the swapchain when it is released and it's ref = 0
6749 *****************************************************/
6750 void WINAPI IWineD3DDeviceImpl_SwapChainReleased(IWineD3DDevice *iface, IWineD3DSwapChain *swapChain){
6751 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6752 SwapChainList **nextSwapchain;
6753 nextSwapchain = &This->swapchains;
6755 /* Check to see if the swapchian is being used as the render target */
6756 if (This->renderTarget != NULL) {
6757 IWineD3DSurface *swapchainBackBuffer;
6759 IWineD3DSwapChain_GetBackBuffer(swapChain, 0 ,( D3DBACKBUFFER_TYPE) 0, &swapchainBackBuffer);
6760 if (This->renderTarget == swapchainBackBuffer) {
6761 /* Don't know what to do, so warn and carry on as usual (which in this case leaves the renderterget in limbo) */
6762 FIXME("Atempting to release a swapchain that is currently beuing used as a render target, behaviour is undefined\n");
6766 /* Go through the swapchain list and try to find the swapchain being released */
6767 while(*nextSwapchain != NULL && (*nextSwapchain)->swapchain != swapChain) {
6768 nextSwapchain = &(*nextSwapchain)->next;
6771 /* Check to see if we found the swapchain */
6772 if (NULL != *nextSwapchain) {
6773 /* We found the swapchain so remove it from the list */
6774 TRACE("(%p) releasing swapchain(%p)\n", iface, swapChain);
6775 HeapFree(GetProcessHeap(), 0 , *nextSwapchain);
6776 *nextSwapchain = (*nextSwapchain)->next;
6778 /* We didn't find the swapchain on the list, this can only heppen because of a programming error in wined3d */
6779 FIXME("(%p) Attempting to release a swapchain (%p) that hasn't been stored\n", iface, swapChain);
6782 TRACE("swapchain (%p) released\n", swapChain);
6786 /**********************************************************
6787 * IWineD3DDevice VTbl follows
6788 **********************************************************/
6790 const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl =
6792 /*** IUnknown methods ***/
6793 IWineD3DDeviceImpl_QueryInterface,
6794 IWineD3DDeviceImpl_AddRef,
6795 IWineD3DDeviceImpl_Release,
6796 /*** IWineD3DDevice methods ***/
6797 IWineD3DDeviceImpl_GetParent,
6798 /*** Creation methods**/
6799 IWineD3DDeviceImpl_CreateVertexBuffer,
6800 IWineD3DDeviceImpl_CreateIndexBuffer,
6801 IWineD3DDeviceImpl_CreateStateBlock,
6802 IWineD3DDeviceImpl_CreateSurface,
6803 IWineD3DDeviceImpl_CreateTexture,
6804 IWineD3DDeviceImpl_CreateVolumeTexture,
6805 IWineD3DDeviceImpl_CreateVolume,
6806 IWineD3DDeviceImpl_CreateCubeTexture,
6807 IWineD3DDeviceImpl_CreateQuery,
6808 IWineD3DDeviceImpl_CreateAdditionalSwapChain,
6809 IWineD3DDeviceImpl_CreateVertexDeclaration,
6810 IWineD3DDeviceImpl_CreateVertexShader,
6811 IWineD3DDeviceImpl_CreatePixelShader,
6812 /*** Odd functions **/
6813 IWineD3DDeviceImpl_EvictManagedResources,
6814 IWineD3DDeviceImpl_GetAvailableTextureMem,
6815 IWineD3DDeviceImpl_GetBackBuffer,
6816 IWineD3DDeviceImpl_GetCreationParameters,
6817 IWineD3DDeviceImpl_GetDeviceCaps,
6818 IWineD3DDeviceImpl_GetDirect3D,
6819 IWineD3DDeviceImpl_GetDisplayMode,
6820 IWineD3DDeviceImpl_GetNumberOfSwapChains,
6821 IWineD3DDeviceImpl_GetRasterStatus,
6822 IWineD3DDeviceImpl_GetSwapChain,
6823 IWineD3DDeviceImpl_Reset,
6824 IWineD3DDeviceImpl_SetDialogBoxMode,
6825 IWineD3DDeviceImpl_SetCursorProperties,
6826 IWineD3DDeviceImpl_SetCursorPosition,
6827 IWineD3DDeviceImpl_ShowCursor,
6828 IWineD3DDeviceImpl_TestCooperativeLevel,
6829 /*** Getters and setters **/
6830 IWineD3DDeviceImpl_SetClipPlane,
6831 IWineD3DDeviceImpl_GetClipPlane,
6832 IWineD3DDeviceImpl_SetClipStatus,
6833 IWineD3DDeviceImpl_GetClipStatus,
6834 IWineD3DDeviceImpl_SetCurrentTexturePalette,
6835 IWineD3DDeviceImpl_GetCurrentTexturePalette,
6836 IWineD3DDeviceImpl_SetDepthStencilSurface,
6837 IWineD3DDeviceImpl_GetDepthStencilSurface,
6838 IWineD3DDeviceImpl_SetFVF,
6839 IWineD3DDeviceImpl_GetFVF,
6840 IWineD3DDeviceImpl_SetGammaRamp,
6841 IWineD3DDeviceImpl_GetGammaRamp,
6842 IWineD3DDeviceImpl_SetIndices,
6843 IWineD3DDeviceImpl_GetIndices,
6844 IWineD3DDeviceImpl_SetLight,
6845 IWineD3DDeviceImpl_GetLight,
6846 IWineD3DDeviceImpl_SetLightEnable,
6847 IWineD3DDeviceImpl_GetLightEnable,
6848 IWineD3DDeviceImpl_SetMaterial,
6849 IWineD3DDeviceImpl_GetMaterial,
6850 IWineD3DDeviceImpl_SetNPatchMode,
6851 IWineD3DDeviceImpl_GetNPatchMode,
6852 IWineD3DDeviceImpl_SetPaletteEntries,
6853 IWineD3DDeviceImpl_GetPaletteEntries,
6854 IWineD3DDeviceImpl_SetPixelShader,
6855 IWineD3DDeviceImpl_GetPixelShader,
6856 IWineD3DDeviceImpl_SetPixelShaderConstant,
6857 IWineD3DDeviceImpl_GetPixelShaderConstant,
6858 IWineD3DDeviceImpl_SetPixelShaderConstantB,
6859 IWineD3DDeviceImpl_GetPixelShaderConstantB,
6860 IWineD3DDeviceImpl_SetPixelShaderConstantI,
6861 IWineD3DDeviceImpl_GetPixelShaderConstantI,
6862 IWineD3DDeviceImpl_SetPixelShaderConstantF,
6863 IWineD3DDeviceImpl_GetPixelShaderConstantF,
6864 IWineD3DDeviceImpl_SetPixelShaderConstantN,
6865 IWineD3DDeviceImpl_SetRenderState,
6866 IWineD3DDeviceImpl_GetRenderState,
6867 IWineD3DDeviceImpl_SetRenderTarget,
6868 IWineD3DDeviceImpl_GetRenderTarget,
6869 IWineD3DDeviceImpl_SetSamplerState,
6870 IWineD3DDeviceImpl_GetSamplerState,
6871 IWineD3DDeviceImpl_SetScissorRect,
6872 IWineD3DDeviceImpl_GetScissorRect,
6873 IWineD3DDeviceImpl_SetSoftwareVertexProcessing,
6874 IWineD3DDeviceImpl_GetSoftwareVertexProcessing,
6875 IWineD3DDeviceImpl_SetStreamSource,
6876 IWineD3DDeviceImpl_GetStreamSource,
6877 IWineD3DDeviceImpl_SetStreamSourceFreq,
6878 IWineD3DDeviceImpl_GetStreamSourceFreq,
6879 IWineD3DDeviceImpl_SetTexture,
6880 IWineD3DDeviceImpl_GetTexture,
6881 IWineD3DDeviceImpl_SetTextureStageState,
6882 IWineD3DDeviceImpl_GetTextureStageState,
6883 IWineD3DDeviceImpl_SetTransform,
6884 IWineD3DDeviceImpl_GetTransform,
6885 IWineD3DDeviceImpl_SetVertexDeclaration,
6886 IWineD3DDeviceImpl_GetVertexDeclaration,
6887 IWineD3DDeviceImpl_SetVertexShader,
6888 IWineD3DDeviceImpl_GetVertexShader,
6889 IWineD3DDeviceImpl_SetVertexShaderConstant,
6890 IWineD3DDeviceImpl_GetVertexShaderConstant,
6891 IWineD3DDeviceImpl_SetVertexShaderConstantB,
6892 IWineD3DDeviceImpl_GetVertexShaderConstantB,
6893 IWineD3DDeviceImpl_SetVertexShaderConstantI,
6894 IWineD3DDeviceImpl_GetVertexShaderConstantI,
6895 IWineD3DDeviceImpl_SetVertexShaderConstantF,
6896 IWineD3DDeviceImpl_GetVertexShaderConstantF,
6897 IWineD3DDeviceImpl_SetVertexShaderConstantN,
6898 IWineD3DDeviceImpl_SetViewport,
6899 IWineD3DDeviceImpl_GetViewport,
6900 IWineD3DDeviceImpl_MultiplyTransform,
6901 IWineD3DDeviceImpl_ValidateDevice,
6902 IWineD3DDeviceImpl_ProcessVertices,
6903 /*** State block ***/
6904 IWineD3DDeviceImpl_BeginStateBlock,
6905 IWineD3DDeviceImpl_EndStateBlock,
6906 /*** Scene management ***/
6907 IWineD3DDeviceImpl_BeginScene,
6908 IWineD3DDeviceImpl_EndScene,
6909 IWineD3DDeviceImpl_Present,
6910 IWineD3DDeviceImpl_Clear,
6912 IWineD3DDeviceImpl_DrawPrimitive,
6913 IWineD3DDeviceImpl_DrawIndexedPrimitive,
6914 IWineD3DDeviceImpl_DrawPrimitiveUP,
6915 IWineD3DDeviceImpl_DrawIndexedPrimitiveUP,
6916 IWineD3DDeviceImpl_DrawRectPatch,
6917 IWineD3DDeviceImpl_DrawTriPatch,
6918 IWineD3DDeviceImpl_DeletePatch,
6919 IWineD3DDeviceImpl_ColorFill,
6920 IWineD3DDeviceImpl_UpdateTexture,
6921 IWineD3DDeviceImpl_UpdateSurface,
6922 IWineD3DDeviceImpl_CopyRects,
6923 IWineD3DDeviceImpl_StretchRect,
6924 IWineD3DDeviceImpl_GetRenderTargetData,
6925 IWineD3DDeviceImpl_GetFrontBufferData,
6926 /*** Internal use IWineD3DDevice methods ***/
6927 IWineD3DDeviceImpl_SetupTextureStates,
6928 /*** object tracking ***/
6929 IWineD3DDeviceImpl_SwapChainReleased,
6930 IWineD3DDeviceImpl_ResourceReleased
6934 const DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R] = {
6935 WINED3DRS_ALPHABLENDENABLE ,
6936 WINED3DRS_ALPHAFUNC ,
6937 WINED3DRS_ALPHAREF ,
6938 WINED3DRS_ALPHATESTENABLE ,
6940 WINED3DRS_COLORWRITEENABLE ,
6941 WINED3DRS_DESTBLEND ,
6942 WINED3DRS_DITHERENABLE ,
6943 WINED3DRS_FILLMODE ,
6944 WINED3DRS_FOGDENSITY ,
6946 WINED3DRS_FOGSTART ,
6947 WINED3DRS_LASTPIXEL ,
6948 WINED3DRS_SHADEMODE ,
6949 WINED3DRS_SRCBLEND ,
6950 WINED3DRS_STENCILENABLE ,
6951 WINED3DRS_STENCILFAIL ,
6952 WINED3DRS_STENCILFUNC ,
6953 WINED3DRS_STENCILMASK ,
6954 WINED3DRS_STENCILPASS ,
6955 WINED3DRS_STENCILREF ,
6956 WINED3DRS_STENCILWRITEMASK ,
6957 WINED3DRS_STENCILZFAIL ,
6958 WINED3DRS_TEXTUREFACTOR ,
6969 WINED3DRS_ZWRITEENABLE
6972 const DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T] = {
6973 WINED3DTSS_ADDRESSW ,
6974 WINED3DTSS_ALPHAARG0 ,
6975 WINED3DTSS_ALPHAARG1 ,
6976 WINED3DTSS_ALPHAARG2 ,
6977 WINED3DTSS_ALPHAOP ,
6978 WINED3DTSS_BUMPENVLOFFSET ,
6979 WINED3DTSS_BUMPENVLSCALE ,
6980 WINED3DTSS_BUMPENVMAT00 ,
6981 WINED3DTSS_BUMPENVMAT01 ,
6982 WINED3DTSS_BUMPENVMAT10 ,
6983 WINED3DTSS_BUMPENVMAT11 ,
6984 WINED3DTSS_COLORARG0 ,
6985 WINED3DTSS_COLORARG1 ,
6986 WINED3DTSS_COLORARG2 ,
6987 WINED3DTSS_COLOROP ,
6988 WINED3DTSS_RESULTARG ,
6989 WINED3DTSS_TEXCOORDINDEX ,
6990 WINED3DTSS_TEXTURETRANSFORMFLAGS
6993 const DWORD SavedPixelStates_S[NUM_SAVEDPIXELSTATES_S] = {
6994 WINED3DSAMP_ADDRESSU ,
6995 WINED3DSAMP_ADDRESSV ,
6996 WINED3DSAMP_ADDRESSW ,
6997 WINED3DSAMP_BORDERCOLOR ,
6998 WINED3DSAMP_MAGFILTER ,
6999 WINED3DSAMP_MINFILTER ,
7000 WINED3DSAMP_MIPFILTER ,
7001 WINED3DSAMP_MIPMAPLODBIAS ,
7002 WINED3DSAMP_MAXMIPLEVEL ,
7003 WINED3DSAMP_MAXANISOTROPY ,
7004 WINED3DSAMP_SRGBTEXTURE ,
7005 WINED3DSAMP_ELEMENTINDEX
7008 const DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R] = {
7010 WINED3DRS_AMBIENTMATERIALSOURCE ,
7011 WINED3DRS_CLIPPING ,
7012 WINED3DRS_CLIPPLANEENABLE ,
7013 WINED3DRS_COLORVERTEX ,
7014 WINED3DRS_DIFFUSEMATERIALSOURCE ,
7015 WINED3DRS_EMISSIVEMATERIALSOURCE ,
7016 WINED3DRS_FOGDENSITY ,
7018 WINED3DRS_FOGSTART ,
7019 WINED3DRS_FOGTABLEMODE ,
7020 WINED3DRS_FOGVERTEXMODE ,
7021 WINED3DRS_INDEXEDVERTEXBLENDENABLE ,
7022 WINED3DRS_LIGHTING ,
7023 WINED3DRS_LOCALVIEWER ,
7024 WINED3DRS_MULTISAMPLEANTIALIAS ,
7025 WINED3DRS_MULTISAMPLEMASK ,
7026 WINED3DRS_NORMALIZENORMALS ,
7027 WINED3DRS_PATCHEDGESTYLE ,
7028 WINED3DRS_POINTSCALE_A ,
7029 WINED3DRS_POINTSCALE_B ,
7030 WINED3DRS_POINTSCALE_C ,
7031 WINED3DRS_POINTSCALEENABLE ,
7032 WINED3DRS_POINTSIZE ,
7033 WINED3DRS_POINTSIZE_MAX ,
7034 WINED3DRS_POINTSIZE_MIN ,
7035 WINED3DRS_POINTSPRITEENABLE ,
7036 WINED3DRS_RANGEFOGENABLE ,
7037 WINED3DRS_SPECULARMATERIALSOURCE ,
7038 WINED3DRS_TWEENFACTOR ,
7039 WINED3DRS_VERTEXBLEND
7042 const DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T] = {
7043 WINED3DTSS_TEXCOORDINDEX ,
7044 WINED3DTSS_TEXTURETRANSFORMFLAGS
7047 const DWORD SavedVertexStates_S[NUM_SAVEDVERTEXSTATES_S] = {
7048 WINED3DSAMP_DMAPOFFSET