| /* | |
| * IWineD3DDevice implementation | |
| * | |
| * Copyright 2002-2005 Jason Edmeades | |
| * Copyright 2003-2004 Raphael Junqueira | |
| * Copyright 2004 Christian Costa | |
| * Copyright 2005 Oliver Stieber | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| */ | |
| #include "config.h" | |
| #include "wined3d_private.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(d3d); | |
| WINE_DECLARE_DEBUG_CHANNEL(d3d_caps); | |
| WINE_DECLARE_DEBUG_CHANNEL(d3d_fps); | |
| WINE_DECLARE_DEBUG_CHANNEL(d3d_shader); | |
| #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info | |
| /* x11drv GDI escapes */ | |
| #define X11DRV_ESCAPE 6789 | |
| enum x11drv_escape_codes | |
| { | |
| X11DRV_GET_DISPLAY, /* get X11 display for a DC */ | |
| X11DRV_GET_DRAWABLE, /* get current drawable for a DC */ | |
| X11DRV_GET_FONT, /* get current X font for a DC */ | |
| }; | |
| /* retrieve the X display to use on a given DC */ | |
| inline static Display *get_display( HDC hdc ) | |
| { | |
| Display *display; | |
| enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY; | |
| if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape, | |
| sizeof(display), (LPSTR)&display )) display = NULL; | |
| return display; | |
| } | |
| /* Memory tracking and object counting */ | |
| static unsigned int emulated_textureram = 64*1024*1024; | |
| /* TODO: setup some flags in the regestry to enable, disable pbuffer support */ | |
| /* enable pbuffer support for offscreen textures */ | |
| BOOL pbuffer_support = TRUE; | |
| /* allocate one pbuffer per surface */ | |
| BOOL pbuffer_per_surface = FALSE; | |
| /* helper macros */ | |
| #define D3DMEMCHECK(object, ppResult) if(NULL == object) { *ppResult = NULL; WARN("Out of memory\n"); return D3DERR_OUTOFVIDEOMEMORY;} | |
| #define D3DCREATEOBJECTINSTANCE(object, type) { \ | |
| object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \ | |
| D3DMEMCHECK(object, pp##type); \ | |
| object->lpVtbl = &IWineD3D##type##_Vtbl; \ | |
| object->wineD3DDevice = This; \ | |
| object->parent = parent; \ | |
| object->ref = 1; \ | |
| *pp##type = (IWineD3D##type *) object; \ | |
| } | |
| #define D3DCREATERESOURCEOBJECTINSTANCE(object, type, d3dtype, _size){ \ | |
| object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \ | |
| D3DMEMCHECK(object, pp##type); \ | |
| object->lpVtbl = &IWineD3D##type##_Vtbl; \ | |
| object->resource.wineD3DDevice = This; \ | |
| object->resource.parent = parent; \ | |
| object->resource.resourceType = d3dtype; \ | |
| object->resource.ref = 1; \ | |
| object->resource.pool = Pool; \ | |
| object->resource.format = Format; \ | |
| object->resource.usage = Usage; \ | |
| object->resource.size = _size; \ | |
| /* Check that we have enough video ram left */ \ | |
| if (Pool == D3DPOOL_DEFAULT) { \ | |
| if (IWineD3DDevice_GetAvailableTextureMem(iface) <= _size) { \ | |
| WARN("Out of 'bogus' video memory\n"); \ | |
| HeapFree(GetProcessHeap(),0,object); \ | |
| *pp##type = NULL; \ | |
| return D3DERR_OUTOFVIDEOMEMORY; \ | |
| } \ | |
| globalChangeGlRam(_size); \ | |
| } \ | |
| object->resource.allocatedMemory = (0 == _size ? NULL : Pool == D3DPOOL_DEFAULT ? NULL : HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, _size)); \ | |
| if (object->resource.allocatedMemory == NULL && _size != 0 && Pool != D3DPOOL_DEFAULT) { \ | |
| FIXME("Out of memory!\n"); \ | |
| HeapFree(GetProcessHeap(), 0, object); \ | |
| *pp##type = NULL; \ | |
| return D3DERR_OUTOFVIDEOMEMORY; \ | |
| } \ | |
| *pp##type = (IWineD3D##type *) object; \ | |
| TRACE("(%p) : Created resource %p\n", This, object); \ | |
| } | |
| #define D3DINITILIZEBASETEXTURE(_basetexture) { \ | |
| _basetexture.levels = Levels; \ | |
| _basetexture.filterType = (Usage & D3DUSAGE_AUTOGENMIPMAP) ? D3DTEXF_LINEAR : D3DTEXF_NONE; \ | |
| _basetexture.LOD = 0; \ | |
| _basetexture.dirty = TRUE; \ | |
| } | |
| /********************************************************** | |
| * Global variable / Constants follow | |
| **********************************************************/ | |
| const float identity[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1}; /* When needed for comparisons */ | |
| /********************************************************** | |
| * Utility functions follow | |
| **********************************************************/ | |
| /* Convert the D3DLIGHT properties into equivalent gl lights */ | |
| static void setup_light(IWineD3DDevice *iface, LONG Index, PLIGHTINFOEL *lightInfo) { | |
| float quad_att; | |
| float colRGBA[] = {0.0, 0.0, 0.0, 0.0}; | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/ | |
| glMatrixMode(GL_MODELVIEW); | |
| glPushMatrix(); | |
| glLoadMatrixf((float *) &This->stateBlock->transforms[D3DTS_VIEW].u.m[0][0]); | |
| /* Diffuse: */ | |
| colRGBA[0] = lightInfo->OriginalParms.Diffuse.r; | |
| colRGBA[1] = lightInfo->OriginalParms.Diffuse.g; | |
| colRGBA[2] = lightInfo->OriginalParms.Diffuse.b; | |
| colRGBA[3] = lightInfo->OriginalParms.Diffuse.a; | |
| glLightfv(GL_LIGHT0+Index, GL_DIFFUSE, colRGBA); | |
| checkGLcall("glLightfv"); | |
| /* Specular */ | |
| colRGBA[0] = lightInfo->OriginalParms.Specular.r; | |
| colRGBA[1] = lightInfo->OriginalParms.Specular.g; | |
| colRGBA[2] = lightInfo->OriginalParms.Specular.b; | |
| colRGBA[3] = lightInfo->OriginalParms.Specular.a; | |
| glLightfv(GL_LIGHT0+Index, GL_SPECULAR, colRGBA); | |
| checkGLcall("glLightfv"); | |
| /* Ambient */ | |
| colRGBA[0] = lightInfo->OriginalParms.Ambient.r; | |
| colRGBA[1] = lightInfo->OriginalParms.Ambient.g; | |
| colRGBA[2] = lightInfo->OriginalParms.Ambient.b; | |
| colRGBA[3] = lightInfo->OriginalParms.Ambient.a; | |
| glLightfv(GL_LIGHT0+Index, GL_AMBIENT, colRGBA); | |
| checkGLcall("glLightfv"); | |
| /* Attenuation - Are these right? guessing... */ | |
| glLightf(GL_LIGHT0+Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0); | |
| checkGLcall("glLightf"); | |
| glLightf(GL_LIGHT0+Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1); | |
| checkGLcall("glLightf"); | |
| if ((lightInfo->OriginalParms.Range * lightInfo->OriginalParms.Range) != 0 ) { | |
| quad_att = 1.4/(lightInfo->OriginalParms.Range*lightInfo->OriginalParms.Range); | |
| } else { | |
| quad_att = 0; /* 0 or MAX? (0 seems to be ok) */ | |
| } | |
| if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2; | |
| glLightf(GL_LIGHT0+Index, GL_QUADRATIC_ATTENUATION, quad_att); | |
| checkGLcall("glLightf"); | |
| switch (lightInfo->OriginalParms.Type) { | |
| case D3DLIGHT_POINT: | |
| /* Position */ | |
| glLightfv(GL_LIGHT0+Index, GL_POSITION, &lightInfo->lightPosn[0]); | |
| checkGLcall("glLightfv"); | |
| glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff); | |
| checkGLcall("glLightf"); | |
| /* FIXME: Range */ | |
| break; | |
| case D3DLIGHT_SPOT: | |
| /* Position */ | |
| glLightfv(GL_LIGHT0+Index, GL_POSITION, &lightInfo->lightPosn[0]); | |
| checkGLcall("glLightfv"); | |
| /* Direction */ | |
| glLightfv(GL_LIGHT0+Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]); | |
| checkGLcall("glLightfv"); | |
| glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent); | |
| checkGLcall("glLightf"); | |
| glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff); | |
| checkGLcall("glLightf"); | |
| /* FIXME: Range */ | |
| break; | |
| case D3DLIGHT_DIRECTIONAL: | |
| /* Direction */ | |
| glLightfv(GL_LIGHT0+Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */ | |
| checkGLcall("glLightfv"); | |
| glLightf(GL_LIGHT0+Index, GL_SPOT_CUTOFF, lightInfo->cutoff); | |
| checkGLcall("glLightf"); | |
| glLightf(GL_LIGHT0+Index, GL_SPOT_EXPONENT, 0.0f); | |
| checkGLcall("glLightf"); | |
| break; | |
| default: | |
| FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type); | |
| } | |
| /* Restore the modelview matrix */ | |
| glPopMatrix(); | |
| } | |
| /* Apply the current values to the specified texture stage */ | |
| void WINAPI IWineD3DDeviceImpl_SetupTextureStates(IWineD3DDevice *iface, DWORD Stage, DWORD Flags) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| int i = 0; | |
| float col[4]; | |
| BOOL changeTexture = TRUE; | |
| TRACE("-----------------------> Updating the texture at stage %ld to have new texture state information\n", Stage); | |
| for (i = 1; i < HIGHEST_TEXTURE_STATE; i++) { | |
| BOOL skip = FALSE; | |
| switch (i) { | |
| /* Performance: For texture states where multiples effect the outcome, only bother | |
| applying the last one as it will pick up all the other values */ | |
| case WINED3DTSS_COLORARG0: /* Will be picked up when setting color op */ | |
| case WINED3DTSS_COLORARG1: /* Will be picked up when setting color op */ | |
| case WINED3DTSS_COLORARG2: /* Will be picked up when setting color op */ | |
| case WINED3DTSS_ALPHAARG0: /* Will be picked up when setting alpha op */ | |
| case WINED3DTSS_ALPHAARG1: /* Will be picked up when setting alpha op */ | |
| case WINED3DTSS_ALPHAARG2: /* Will be picked up when setting alpha op */ | |
| skip = TRUE; | |
| break; | |
| /* Performance: If the texture states only impact settings for the texture unit | |
| (compared to the texture object) then there is no need to reapply them. The | |
| only time they need applying is the first time, since we cheat and put the | |
| values into the stateblock without applying. | |
| Per-texture unit: texture function (eg. combine), ops and args | |
| texture env color | |
| texture generation settings | |
| Note: Due to some special conditions there may be a need to do particular ones | |
| of these, which is what the Flags allows */ | |
| case WINED3DTSS_COLOROP: | |
| case WINED3DTSS_TEXCOORDINDEX: | |
| if (!(Flags == REAPPLY_ALL)) skip=TRUE; | |
| break; | |
| case WINED3DTSS_ALPHAOP: | |
| if (!(Flags & REAPPLY_ALPHAOP)) skip=TRUE; | |
| break; | |
| default: | |
| skip = FALSE; | |
| } | |
| if (skip == FALSE) { | |
| /* Performance: Only change to this texture if we have to */ | |
| if (changeTexture) { | |
| /* Make appropriate texture active */ | |
| if (GL_SUPPORT(ARB_MULTITEXTURE)) { | |
| GLACTIVETEXTURE(Stage); | |
| } else if (Stage > 0) { | |
| FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n"); | |
| } | |
| changeTexture = FALSE; | |
| } | |
| /* Now apply the change */ | |
| IWineD3DDevice_SetTextureStageState(iface, Stage, i, This->stateBlock->textureState[Stage][i]); | |
| } | |
| } | |
| /* apply the sampler states to the texture */ | |
| for (i = 1; i <= HIGHEST_SAMPLER_STATE;i++) { | |
| IWineD3DDevice_SetSamplerState(iface, Stage, i, This->stateBlock->samplerState[Stage][i]); | |
| } | |
| /* Note the D3DRS value applies to all textures, but GL has one | |
| * per texture, so apply it now ready to be used! | |
| */ | |
| D3DCOLORTOGLFLOAT4(This->stateBlock->renderState[WINED3DRS_TEXTUREFACTOR], col); | |
| glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]); | |
| checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);"); | |
| TRACE("-----------------------> Updated the texture at stage %ld to have new texture state information\n", Stage); | |
| } | |
| /********************************************************** | |
| * IUnknown parts follows | |
| **********************************************************/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_QueryInterface(IWineD3DDevice *iface,REFIID riid,LPVOID *ppobj) | |
| { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* FIXME: This needs to extend an IWineD3DBaseObject */ | |
| TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj); | |
| if (IsEqualGUID(riid, &IID_IUnknown) | |
| || IsEqualGUID(riid, &IID_IWineD3DDevice)) { | |
| IUnknown_AddRef(iface); | |
| *ppobj = This; | |
| return D3D_OK; | |
| } | |
| return E_NOINTERFACE; | |
| } | |
| ULONG WINAPI IWineD3DDeviceImpl_AddRef(IWineD3DDevice *iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| ULONG refCount = InterlockedIncrement(&This->ref); | |
| TRACE("(%p) : AddRef increasing from %ld\n", This, refCount - 1); | |
| return refCount; | |
| } | |
| ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| ULONG refCount = InterlockedDecrement(&This->ref); | |
| TRACE("(%p) : Releasing from %ld\n", This, refCount + 1); | |
| if (!refCount) { | |
| /* TODO: Clean up all the surfaces and textures! */ | |
| /* FIXME: Create targets and state blocks in d3d8 */ | |
| if (((IWineD3DImpl *)This->wineD3D)->dxVersion > 8) { /*We don't create a state block in d3d8 yet*/ | |
| /* NOTE: You must release the parent if the object was created via a callback | |
| ** ***************************/ | |
| int i; | |
| IUnknown* swapChainParent; | |
| /* Release all of the swapchains, except the implicit swapchain (#0) */ | |
| for(i = 1; i < This->numberOfSwapChains; i++) { | |
| /* TODO: don't access swapchains[x] directly! */ | |
| IWineD3DSwapChain_Release(This->swapchains[i]); | |
| } | |
| if (This->stateBlock != NULL) { | |
| IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->stateBlock); | |
| } | |
| if (This->swapchains[0] != NULL) { | |
| /* Swapchain 0 is special because it's created in startup with a hanging parent, so we have to release its parent now */ | |
| /* TODO: don't access swapchains[x] directly!, check that there are no-more swapchains left for this device! */ | |
| IWineD3DSwapChain_GetParent(This->swapchains[0], &swapChainParent); | |
| IUnknown_Release(swapChainParent); /* once for the get parent */ | |
| if (IUnknown_Release(swapChainParent) > 0) { /* the second time for when it was created */ | |
| FIXME("(%p) Something's still holding the implicit swapchain\n",This); | |
| } | |
| } | |
| } | |
| IWineD3D_Release(This->wineD3D); | |
| HeapFree(GetProcessHeap(), 0, This); | |
| } | |
| return refCount; | |
| } | |
| /********************************************************** | |
| * IWineD3DDevice implementation follows | |
| **********************************************************/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetParent(IWineD3DDevice *iface, IUnknown **pParent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| *pParent = This->parent; | |
| IUnknown_AddRef(This->parent); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface, UINT Size, DWORD Usage, | |
| DWORD FVF, D3DPOOL Pool, IWineD3DVertexBuffer** ppVertexBuffer, HANDLE *sharedHandle, | |
| IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DVertexBufferImpl *object; | |
| WINED3DFORMAT Format = WINED3DFMT_VERTEXDATA; /* Dummy format for now */ | |
| D3DCREATERESOURCEOBJECTINSTANCE(object, VertexBuffer, D3DRTYPE_VERTEXBUFFER, Size) | |
| /*TODO: use VBO's */ | |
| if (Pool == D3DPOOL_DEFAULT ) { /* Allocate some system memory for now */ | |
| object->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->resource.size); | |
| } | |
| object->fvf = FVF; | |
| TRACE("(%p) : Size=%d, Usage=%ld, FVF=%lx, Pool=%d - Memory@%p, Iface@%p\n", This, Size, Usage, FVF, Pool, object->resource.allocatedMemory, object); | |
| *ppVertexBuffer = (IWineD3DVertexBuffer *)object; | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage, | |
| WINED3DFORMAT Format, D3DPOOL Pool, IWineD3DIndexBuffer** ppIndexBuffer, | |
| HANDLE *sharedHandle, IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DIndexBufferImpl *object; | |
| TRACE("(%p) Creating index buffer\n", This); | |
| /* Allocate the storage for the device */ | |
| D3DCREATERESOURCEOBJECTINSTANCE(object,IndexBuffer,D3DRTYPE_INDEXBUFFER, Length) | |
| /*TODO: use VBO's */ | |
| if (Pool == D3DPOOL_DEFAULT ) { /* Allocate some system memory for now */ | |
| object->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,object->resource.size); | |
| } | |
| TRACE("(%p) : Len=%d, Use=%lx, Format=(%u,%s), Pool=%d - Memory@%p, Iface@%p\n", This, Length, Usage, Format, | |
| debug_d3dformat(Format), Pool, object, object->resource.allocatedMemory); | |
| *ppIndexBuffer = (IWineD3DIndexBuffer *) object; | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface, D3DSTATEBLOCKTYPE Type, IWineD3DStateBlock** ppStateBlock, IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DStateBlockImpl *object; | |
| int i,j; | |
| D3DCREATEOBJECTINSTANCE(object, StateBlock) | |
| object->blockType = Type; | |
| /* Special case - Used during initialization to produce a placeholder stateblock | |
| so other functions called can update a state block */ | |
| if (Type == (D3DSTATEBLOCKTYPE) 0) { | |
| /* Don't bother increasing the reference count otherwise a device will never | |
| be freed due to circular dependencies */ | |
| return D3D_OK; | |
| } | |
| /* Otherwise, might as well set the whole state block to the appropriate values */ | |
| IWineD3DDevice_AddRef(iface); | |
| /* Otherwise, might as well set the whole state block to the appropriate values */ | |
| if ( This->stateBlock != NULL) { | |
| memcpy(object, This->stateBlock, sizeof(IWineD3DStateBlockImpl)); | |
| } else { | |
| memset(object->streamFreq, 1, sizeof(object->streamFreq)); | |
| } | |
| /* Reset the ref and type after kludging it */ | |
| object->wineD3DDevice = This; | |
| object->ref = 1; | |
| object->blockType = Type; | |
| TRACE("Updating changed flags appropriate for type %d\n", Type); | |
| if (Type == D3DSBT_ALL) { | |
| TRACE("ALL => Pretend everything has changed\n"); | |
| memset(&object->changed, TRUE, sizeof(This->stateBlock->changed)); | |
| } else if (Type == D3DSBT_PIXELSTATE) { | |
| memset(&object->changed, FALSE, sizeof(This->stateBlock->changed)); | |
| /* TODO: Pixel Shader Constants */ | |
| object->changed.pixelShader = TRUE; | |
| for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) { | |
| object->changed.renderState[SavedPixelStates_R[i]] = TRUE; | |
| } | |
| for (j = 0; j < GL_LIMITS(textures); i++) { | |
| for (i = 0; i < NUM_SAVEDPIXELSTATES_T; i++) { | |
| object->changed.textureState[j][SavedPixelStates_T[i]] = TRUE; | |
| } | |
| } | |
| /* Setting sampler block changes states */ | |
| for (j = 0 ; j < GL_LIMITS(samplers); j++) { | |
| for (i =0; i < NUM_SAVEDPIXELSTATES_S;i++) { | |
| object->changed.samplerState[j][SavedPixelStates_S[i]] = TRUE; | |
| } | |
| } | |
| } else if (Type == D3DSBT_VERTEXSTATE) { | |
| memset(&object->changed, FALSE, sizeof(This->stateBlock->changed)); | |
| /* TODO: Vertex Shader Constants */ | |
| object->changed.vertexShader = TRUE; | |
| for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) { | |
| object->changed.renderState[SavedVertexStates_R[i]] = TRUE; | |
| } | |
| for (j = 0; j < GL_LIMITS(textures); i++) { | |
| for (i = 0; i < NUM_SAVEDVERTEXSTATES_T; i++) { | |
| object->changed.textureState[j][SavedVertexStates_T[i]] = TRUE; | |
| } | |
| } | |
| /* Setting sampler block changes states */ | |
| for (j = 0 ; j < GL_LIMITS(samplers); j++) { | |
| for (i =0; i < NUM_SAVEDVERTEXSTATES_S;i++) { | |
| object->changed.samplerState[j][SavedVertexStates_S[i]] = TRUE; | |
| } | |
| } | |
| /* Duplicate light chain */ | |
| { | |
| PLIGHTINFOEL *src = NULL; | |
| PLIGHTINFOEL *dst = NULL; | |
| PLIGHTINFOEL *newEl = NULL; | |
| src = This->stateBlock->lights; | |
| object->lights = NULL; | |
| while (src) { | |
| newEl = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL)); | |
| if (newEl == NULL) return D3DERR_OUTOFVIDEOMEMORY; | |
| memcpy(newEl, src, sizeof(PLIGHTINFOEL)); | |
| newEl->prev = dst; | |
| newEl->changed = TRUE; | |
| newEl->enabledChanged = TRUE; | |
| if (dst == NULL) { | |
| object->lights = newEl; | |
| } else { | |
| dst->next = newEl; | |
| } | |
| dst = newEl; | |
| src = src->next; | |
| } | |
| } | |
| } else { | |
| FIXME("Unrecognized state block type %d\n", Type); | |
| } | |
| TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, object); | |
| return D3D_OK; | |
| } | |
| /* ************************************ | |
| MSDN: | |
| [in] Render targets are not lockable unless the application specifies TRUE for Lockable. Note that lockable render targets reduce performance on some graphics hardware. | |
| Discard | |
| [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise. | |
| 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. | |
| ******************************** */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateSurface(IWineD3DDevice *iface, UINT Width, UINT Height, WINED3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IWineD3DSurface **ppSurface,D3DRESOURCETYPE Type, DWORD Usage, D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample ,DWORD MultisampleQuality, HANDLE* pSharedHandle, IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DSurfaceImpl *object; /*NOTE: impl ref allowed since this is a create function */ | |
| unsigned int pow2Width, pow2Height; | |
| unsigned int Size = 1; | |
| TRACE("(%p) Create surface\n",This); | |
| /** FIXME: Check ranges on the inputs are valid | |
| * MSDN | |
| * MultisampleQuality | |
| * [in] Quality level. The valid range is between zero and one less than the level | |
| * returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType. | |
| * Passing a larger value returns the error D3DERR_INVALIDCALL. The MultisampleQuality | |
| * values of paired render targets, depth stencil surfaces, and the MultiSample type | |
| * must all match. | |
| *******************************/ | |
| /** | |
| * TODO: Discard MSDN | |
| * [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise. | |
| * | |
| * 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. | |
| * | |
| *This flag has the same behavior as the constant, D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL, in D3DPRESENTFLAG. | |
| ***************************/ | |
| if(MultisampleQuality < 0) { | |
| FIXME("Invalid multisample level %ld \n", MultisampleQuality); | |
| return D3DERR_INVALIDCALL; /* TODO: Check that this is the case! */ | |
| } | |
| if(MultisampleQuality > 0) { | |
| FIXME("MultisampleQuality set to %ld, substituting 0 \n" , MultisampleQuality); | |
| MultisampleQuality=0; | |
| } | |
| /* Non-power2 support */ | |
| /* Find the nearest pow2 match */ | |
| pow2Width = pow2Height = 1; | |
| while (pow2Width < Width) pow2Width <<= 1; | |
| while (pow2Height < Height) pow2Height <<= 1; | |
| if (pow2Width > Width || pow2Height > Height) { | |
| /** TODO: add support for non power two compressed textures (OpenGL 2 provices support for * non-power-two textures gratis) **/ | |
| if (Format == WINED3DFMT_DXT1 || Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3 | |
| || Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5) { | |
| FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d) \n", | |
| This, Width, Height); | |
| return D3DERR_NOTAVAILABLE; | |
| } | |
| } | |
| /** TODO: Check against the maximum texture sizes supported by the video card **/ | |
| /** DXTn mipmaps use the same number of 'levels' down to eg. 8x1, but since | |
| * it is based around 4x4 pixel blocks it requires padding, so allocate enough | |
| * space! | |
| *********************************/ | |
| if (Format == WINED3DFMT_DXT1) { | |
| /* DXT1 is half byte per pixel */ | |
| Size = ((max(Width,4) * D3DFmtGetBpp(This, Format)) * max(Height,4)) >> 1; | |
| } else if (Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3 || | |
| Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5) { | |
| Size = ((max(Width,4) * D3DFmtGetBpp(This, Format)) * max(Height,4)); | |
| } else { | |
| Size = (Width * D3DFmtGetBpp(This, Format)) * Height; | |
| } | |
| /** Create the and initilise surface resource **/ | |
| D3DCREATERESOURCEOBJECTINSTANCE(object,Surface,D3DRTYPE_SURFACE, Size) | |
| object->container = (IUnknown*) This; | |
| object->currentDesc.Width = Width; | |
| object->currentDesc.Height = Height; | |
| object->currentDesc.MultiSampleType = MultiSample; | |
| object->currentDesc.MultiSampleQuality = MultisampleQuality; | |
| /* Setup some glformat defaults */ | |
| object->glDescription.glFormat = D3DFmt2GLFmt(This, object->resource.format); | |
| object->glDescription.glFormatInternal = D3DFmt2GLIntFmt(This, object->resource.format); | |
| object->glDescription.glType = D3DFmt2GLType(This, object->resource.format); | |
| object->glDescription.textureName = 0; | |
| object->glDescription.level = Level; | |
| object->glDescription.target = GL_TEXTURE_2D; | |
| /* Internal data */ | |
| object->pow2Width = pow2Width; | |
| object->pow2Height = pow2Height; | |
| object->nonpow2 = (pow2Width != Width || pow2Height != Height) ? TRUE : FALSE; | |
| object->discard = Discard; | |
| object->activeLock = FALSE; | |
| object->bytesPerPixel = D3DFmtGetBpp(This, Format); | |
| object->pow2Size = (pow2Width * object->bytesPerPixel) * pow2Height; | |
| /** TODO: change this into a texture transform matrix so that it's processed in hardware **/ | |
| /* Precalculated scaling for 'faked' non power of two texture coords */ | |
| object->pow2scalingFactorX = (((float)Width) / ((float)pow2Width)); | |
| object->pow2scalingFactorY = (((float)Height) / ((float)pow2Height)); | |
| TRACE(" xf(%f) yf(%f) \n", object->pow2scalingFactorX, object->pow2scalingFactorY); | |
| TRACE("Pool %d %d %d %d",Pool, D3DPOOL_DEFAULT, D3DPOOL_MANAGED, D3DPOOL_SYSTEMMEM); | |
| /** Quick lockable sanity check TODO: remove this after surfaces, usage and locablility have been debugged properly | |
| * this function is too deap to need to care about things like this. | |
| * Levels need to be checked too, and possibly Type wince they all affect what can be done. | |
| * ****************************************/ | |
| switch(Pool) { | |
| case D3DPOOL_SCRATCH: | |
| if(Lockable == FALSE) | |
| FIXME("Create suface called with a pool of SCRATCH and a Lockable of FALSE \ | |
| which are mutually exclusive, setting lockable to true\n"); | |
| Lockable = TRUE; | |
| break; | |
| case D3DPOOL_SYSTEMMEM: | |
| if(Lockable == FALSE) FIXME("Create surface called with a pool of SYSTEMMEM and a Lockable of FALSE, \ | |
| this is acceptable but unexpected (I can't know how the surface can be usable!)\n"); | |
| case D3DPOOL_MANAGED: | |
| if(Usage == D3DUSAGE_DYNAMIC) FIXME("Create surface called with a pool of MANAGED and a \ | |
| Usage of DYNAMIC which are mutually exclusive, not doing \ | |
| anything just telling you.\n"); | |
| break; | |
| case D3DPOOL_DEFAULT: /*TODO: Create offscreen plain can cause this check to fail..., find out if it should */ | |
| if(!(Usage & D3DUSAGE_DYNAMIC) && !(Usage & D3DUSAGE_RENDERTARGET) | |
| && !(Usage && D3DUSAGE_DEPTHSTENCIL ) && Lockable == TRUE) | |
| FIXME("Creating a surface with a POOL of DEFAULT with Locable true, that doesn't specify DYNAMIC usage.\n"); | |
| break; | |
| default: | |
| FIXME("(%p) Unknown pool %d\n", This, Pool); | |
| break; | |
| }; | |
| if (Usage & D3DUSAGE_RENDERTARGET && Pool != D3DPOOL_DEFAULT) { | |
| FIXME("Trying to create a render target that isn't in the default pool\n"); | |
| } | |
| object->locked = FALSE; | |
| object->lockable = (WINED3DFMT_D16_LOCKABLE == Format) ? TRUE : Lockable; | |
| /* mark the texture as dirty so that it get's loaded first time around*/ | |
| IWineD3DSurface_AddDirtyRect(*ppSurface, NULL); | |
| TRACE("(%p) : w(%d) h(%d) fmt(%d,%s) lockable(%d) surf@%p, surfmem@%p, %d bytes\n", | |
| This, Width, Height, Format, debug_d3dformat(Format), | |
| (WINED3DFMT_D16_LOCKABLE == Format), *ppSurface, object->resource.allocatedMemory, object->resource.size); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateTexture(IWineD3DDevice *iface, UINT Width, UINT Height, UINT Levels, | |
| DWORD Usage, WINED3DFORMAT Format, D3DPOOL Pool, | |
| IWineD3DTexture** ppTexture, HANDLE* pSharedHandle, IUnknown *parent, | |
| D3DCB_CREATESURFACEFN D3DCB_CreateSurface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DTextureImpl *object; | |
| unsigned int i; | |
| UINT tmpW; | |
| UINT tmpH; | |
| HRESULT hr; | |
| TRACE("(%p), Width(%d) Height(%d) Levels(%d) Usage(%ld) .... \n", This, Width, Height, Levels, Usage); | |
| D3DCREATERESOURCEOBJECTINSTANCE(object, Texture, D3DRTYPE_TEXTURE, 0); | |
| D3DINITILIZEBASETEXTURE(object->baseTexture); | |
| object->width = Width; | |
| object->height = Height; | |
| /* Calculate levels for mip mapping */ | |
| if (Levels == 0) { | |
| TRACE("calculating levels %d\n", object->baseTexture.levels); | |
| object->baseTexture.levels++; | |
| tmpW = Width; | |
| tmpH = Height; | |
| while (tmpW > 1 && tmpH > 1) { | |
| tmpW = max(1, tmpW >> 1); | |
| tmpH = max(1, tmpH >> 1); | |
| object->baseTexture.levels++; | |
| } | |
| TRACE("Calculated levels = %d\n", object->baseTexture.levels); | |
| } | |
| /* Generate all the surfaces */ | |
| tmpW = Width; | |
| tmpH = Height; | |
| for (i = 0; i < object->baseTexture.levels; i++) | |
| { | |
| /* use the callback to create the texture surface */ | |
| hr = D3DCB_CreateSurface(This->parent, tmpW, tmpH, Format, Usage, Pool, i, &object->surfaces[i],NULL); | |
| if(hr!= D3D_OK) { | |
| int j; | |
| FIXME("Failed to create surface %p \n",object); | |
| /* clean up */ | |
| for(j = 0 ; j < i ; j++) { | |
| IWineD3DSurface_Release(object->surfaces[j]); | |
| } | |
| /* heap free object */ | |
| HeapFree(GetProcessHeap(),0,object); | |
| *ppTexture = NULL; | |
| return hr; | |
| } | |
| IWineD3DSurface_SetContainer(object->surfaces[i], (IUnknown *)object); | |
| TRACE("Created surface level %d @ %p\n", i, object->surfaces[i]); | |
| /* calculate the next mipmap level */ | |
| tmpW = max(1, tmpW >> 1); | |
| tmpH = max(1, tmpH >> 1); | |
| } | |
| TRACE("(%p) : Created texture %p\n", This, object); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateVolumeTexture(IWineD3DDevice *iface, | |
| UINT Width, UINT Height, UINT Depth, | |
| UINT Levels, DWORD Usage, | |
| WINED3DFORMAT Format, D3DPOOL Pool, | |
| IWineD3DVolumeTexture** ppVolumeTexture, | |
| HANDLE* pSharedHandle, IUnknown *parent, | |
| D3DCB_CREATEVOLUMEFN D3DCB_CreateVolume) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DVolumeTextureImpl *object; | |
| unsigned int i; | |
| UINT tmpW; | |
| UINT tmpH; | |
| UINT tmpD; | |
| D3DCREATERESOURCEOBJECTINSTANCE(object, VolumeTexture, D3DRTYPE_VOLUMETEXTURE, 0); | |
| D3DINITILIZEBASETEXTURE(object->baseTexture); | |
| TRACE("(%p) : W(%d) H(%d) D(%d), Lvl(%d) Usage(%ld), Fmt(%u,%s), Pool(%s)\n", This, Width, Height, | |
| Depth, Levels, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool)); | |
| object->width = Width; | |
| object->height = Height; | |
| object->depth = Depth; | |
| /* Calculate levels for mip mapping */ | |
| if (Levels == 0) { | |
| object->baseTexture.levels++; | |
| tmpW = Width; | |
| tmpH = Height; | |
| tmpD = Depth; | |
| while (tmpW > 1 && tmpH > 1 && tmpD > 1) { | |
| tmpW = max(1, tmpW >> 1); | |
| tmpH = max(1, tmpH >> 1); | |
| tmpD = max(1, tmpD >> 1); | |
| object->baseTexture.levels++; | |
| } | |
| TRACE("Calculated levels = %d\n", object->baseTexture.levels); | |
| } | |
| /* Generate all the surfaces */ | |
| tmpW = Width; | |
| tmpH = Height; | |
| tmpD = Depth; | |
| for (i = 0; i < object->baseTexture.levels; i++) | |
| { | |
| /* Create the volume */ | |
| D3DCB_CreateVolume(This->parent, Width, Height, Depth, Format, Pool, Usage, | |
| (IWineD3DVolume **)&object->volumes[i], pSharedHandle); | |
| IWineD3DVolume_SetContainer(object->volumes[i], (IUnknown *)object); | |
| tmpW = max(1, tmpW >> 1); | |
| tmpH = max(1, tmpH >> 1); | |
| tmpD = max(1, tmpD >> 1); | |
| } | |
| *ppVolumeTexture = (IWineD3DVolumeTexture *) object; | |
| TRACE("(%p) : Created volume texture %p\n", This, object); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateVolume(IWineD3DDevice *iface, | |
| UINT Width, UINT Height, UINT Depth, | |
| DWORD Usage, | |
| WINED3DFORMAT Format, D3DPOOL Pool, | |
| IWineD3DVolume** ppVolume, | |
| HANDLE* pSharedHandle, IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DVolumeImpl *object; /** NOTE: impl ref allowed since this is a create function **/ | |
| D3DCREATERESOURCEOBJECTINSTANCE(object, Volume, D3DRTYPE_VOLUME, ((Width * D3DFmtGetBpp(This, Format)) * Height * Depth)) | |
| TRACE("(%p) : W(%d) H(%d) D(%d), Usage(%ld), Fmt(%u,%s), Pool(%s)\n", This, Width, Height, | |
| Depth, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool)); | |
| object->currentDesc.Width = Width; | |
| object->currentDesc.Height = Height; | |
| object->currentDesc.Depth = Depth; | |
| object->bytesPerPixel = D3DFmtGetBpp(This, Format); | |
| /** Note: Volume textures cannot be dxtn, hence no need to check here **/ | |
| object->lockable = TRUE; | |
| object->locked = FALSE; | |
| memset(&object->lockedBox, 0, sizeof(D3DBOX)); | |
| object->dirty = FALSE; | |
| return IWineD3DVolume_CleanDirtyBox((IWineD3DVolume *) object); | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateCubeTexture(IWineD3DDevice *iface, UINT EdgeLength, | |
| UINT Levels, DWORD Usage, | |
| WINED3DFORMAT Format, D3DPOOL Pool, | |
| IWineD3DCubeTexture** ppCubeTexture, | |
| HANDLE* pSharedHandle, IUnknown *parent, | |
| D3DCB_CREATESURFACEFN D3DCB_CreateSurface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DCubeTextureImpl *object; /** NOTE: impl ref allowed since this is a create function **/ | |
| unsigned int i,j; | |
| UINT tmpW; | |
| HRESULT hr; | |
| D3DCREATERESOURCEOBJECTINSTANCE(object, CubeTexture, D3DRTYPE_CUBETEXTURE, 0); | |
| D3DINITILIZEBASETEXTURE(object->baseTexture); | |
| TRACE("(%p) Create Cube Texture \n", This); | |
| object->edgeLength = EdgeLength; | |
| /* Calculate levels for mip mapping */ | |
| if (Levels == 0) { | |
| object->baseTexture.levels++; | |
| tmpW = EdgeLength; | |
| while (tmpW > 1) { | |
| tmpW = max(1, tmpW / 2); | |
| object->baseTexture.levels++; | |
| } | |
| TRACE("Calculated levels = %d\n", object->baseTexture.levels); | |
| } | |
| /* Generate all the surfaces */ | |
| tmpW = EdgeLength; | |
| for (i = 0; i < object->baseTexture.levels; i++) { | |
| /* Create the 6 faces */ | |
| for (j = 0; j < 6; j++) { | |
| hr=D3DCB_CreateSurface(This->parent, tmpW, tmpW, Format, Usage, Pool, | |
| i /* Level */, &object->surfaces[j][i],pSharedHandle); | |
| if(hr!= D3D_OK) { | |
| /* clean up */ | |
| int k; | |
| int l; | |
| for (l=0;l<j;l++) { | |
| IWineD3DSurface_Release(object->surfaces[j][i]); | |
| } | |
| for (k=0;k<i;k++) { | |
| for (l=0;l<6;l++) { | |
| IWineD3DSurface_Release(object->surfaces[l][j]); | |
| } | |
| } | |
| FIXME("(%p) Failed to create surface\n",object); | |
| HeapFree(GetProcessHeap(),0,object); | |
| *ppCubeTexture = NULL; | |
| return hr; | |
| } | |
| IWineD3DSurface_SetContainer(object->surfaces[j][i], (IUnknown *)object); | |
| TRACE("Created surface level %d @ %p, \n", i, object->surfaces[j][i]); | |
| } | |
| tmpW = max(1, tmpW >> 1); | |
| } | |
| TRACE("(%p) : Created Cube Texture %p\n", This, object); | |
| *ppCubeTexture = (IWineD3DCubeTexture *) object; | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateQuery(IWineD3DDevice *iface, WINED3DQUERYTYPE Type, IWineD3DQuery **ppQuery, IUnknown* parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DQueryImpl *object; /*NOTE: impl ref allowed since this is a create function */ | |
| if(NULL == ppQuery) { | |
| /* Just a check to see if we support this type of query */ | |
| HRESULT hr = D3DERR_NOTAVAILABLE; | |
| /* Lie and say everything is good (we can return ok fake data from a stub) */ | |
| switch(Type) { | |
| case WINED3DQUERYTYPE_VCACHE: | |
| case WINED3DQUERYTYPE_RESOURCEMANAGER: | |
| case WINED3DQUERYTYPE_VERTEXSTATS: | |
| case WINED3DQUERYTYPE_EVENT: | |
| case WINED3DQUERYTYPE_OCCLUSION: | |
| case WINED3DQUERYTYPE_TIMESTAMP: | |
| case WINED3DQUERYTYPE_TIMESTAMPDISJOINT: | |
| case WINED3DQUERYTYPE_TIMESTAMPFREQ: | |
| case WINED3DQUERYTYPE_PIPELINETIMINGS: | |
| case WINED3DQUERYTYPE_INTERFACETIMINGS: | |
| case WINED3DQUERYTYPE_VERTEXTIMINGS: | |
| case WINED3DQUERYTYPE_PIXELTIMINGS: | |
| case WINED3DQUERYTYPE_BANDWIDTHTIMINGS: | |
| case WINED3DQUERYTYPE_CACHEUTILIZATION: | |
| hr = D3D_OK; | |
| break; | |
| default: | |
| FIXME("(%p) Unhandled query type %d\n",This , Type); | |
| } | |
| FIXME("(%p) : Stub request for query type %d returned %ld\n", This, Type, hr); | |
| return hr; | |
| } | |
| D3DCREATEOBJECTINSTANCE(object, Query) | |
| object->type = Type; | |
| object->extendedData = 0; | |
| TRACE("(%p) : Created Query %p\n", This, object); | |
| return D3D_OK; | |
| } | |
| /* example at http://www.fairyengine.com/articles/dxmultiviews.htm */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters, IWineD3DSwapChain** ppSwapChain, | |
| IUnknown* parent, | |
| D3DCB_CREATERENDERTARGETFN D3DCB_CreateRenderTarget, | |
| D3DCB_CREATEDEPTHSTENCILSURFACEFN D3DCB_CreateDepthStencil) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| HDC hDc; | |
| IWineD3DSwapChainImpl *object; /** NOTE: impl ref allowed since this is a create function **/ | |
| int num; | |
| XVisualInfo template; | |
| GLXContext oldContext; | |
| Drawable oldDrawable; | |
| HRESULT hr = D3D_OK; | |
| TRACE("(%p) : Created Aditional Swap Chain\n", This); | |
| /** FIXME: Test under windows to find out what the life cycle of a swap chain is, | |
| * does a device hold a reference to a swap chain giving them a lifetime of the device | |
| * or does the swap chain notify the device of it'd destruction. | |
| *******************************/ | |
| D3DCREATEOBJECTINSTANCE(object, SwapChain) | |
| /* Initialize other useful values */ | |
| object->presentParms.BackBufferCount = 1; /* TODO:? support for gl_aux buffers */ | |
| /********************* | |
| * Lookup the window Handle and the relating X window handle | |
| ********************/ | |
| /* Setup hwnd we are using, plus which display this equates to */ | |
| object->win_handle = *(pPresentationParameters->hDeviceWindow); | |
| if (!object->win_handle) { | |
| object->win_handle = This->createParms.hFocusWindow; | |
| } | |
| object->win = (Window)GetPropA(object->win_handle, "__wine_x11_whole_window" ); | |
| hDc = GetDC(object->win_handle); | |
| object->display = get_display(hDc); | |
| ReleaseDC(object->win_handle, hDc); | |
| TRACE("Using a display of %p %p \n", object->display, hDc); | |
| if (NULL == object->display || NULL == hDc) { | |
| WARN("Failed to get a display and HDc for Window %p\n", object->win_handle); | |
| return D3DERR_NOTAVAILABLE; | |
| } | |
| if (object->win == 0) { | |
| WARN("Failed to get a valid XVisuial ID for the window %p\n", object->win_handle); | |
| return D3DERR_NOTAVAILABLE; | |
| } | |
| /** | |
| * Create an opengl context for the display visual | |
| * NOTE: the visual is chosen as the window is created and the glcontext cannot | |
| * use different properties after that point in time. FIXME: How to handle when requested format | |
| * doesn't match actual visual? Cannot choose one here - code removed as it ONLY works if the one | |
| * it chooses is identical to the one already being used! | |
| **********************************/ | |
| /** FIXME: Handle stencil appropriately via EnableAutoDepthStencil / AutoDepthStencilFormat **/ | |
| ENTER_GL(); | |
| /* Create a new context for this swapchain */ | |
| template.visualid = (VisualID)GetPropA(GetDesktopWindow(), "__wine_x11_visual_id"); | |
| /* TODO: change this to find a similar visual, but one with a stencil/zbuffer buffer that matches the request | |
| (or the best possible if none is requested) */ | |
| TRACE("Found x visual ID : %ld\n", template.visualid); | |
| object->visInfo = XGetVisualInfo(object->display, VisualIDMask, &template, &num); | |
| if (NULL == object->visInfo) { | |
| ERR("cannot really get XVisual\n"); | |
| LEAVE_GL(); | |
| return D3DERR_NOTAVAILABLE; | |
| } else { | |
| int n, value; | |
| /* Write out some debug info about the visual/s */ | |
| TRACE("Using x visual ID : %ld\n", template.visualid); | |
| TRACE(" visual info: %p\n", object->visInfo); | |
| TRACE(" num items : %d\n", num); | |
| for(n = 0;n < num; n++) { | |
| TRACE("=====item=====: %d\n", n + 1); | |
| TRACE(" visualid : %ld\n", object->visInfo[n].visualid); | |
| TRACE(" screen : %d\n", object->visInfo[n].screen); | |
| TRACE(" depth : %u\n", object->visInfo[n].depth); | |
| TRACE(" class : %d\n", object->visInfo[n].class); | |
| TRACE(" red_mask : %ld\n", object->visInfo[n].red_mask); | |
| TRACE(" green_mask : %ld\n", object->visInfo[n].green_mask); | |
| TRACE(" blue_mask : %ld\n", object->visInfo[n].blue_mask); | |
| TRACE(" colormap_size : %d\n", object->visInfo[n].colormap_size); | |
| TRACE(" bits_per_rgb : %d\n", object->visInfo[n].bits_per_rgb); | |
| /* log some extra glx info */ | |
| glXGetConfig(object->display, object->visInfo, GLX_AUX_BUFFERS, &value); | |
| TRACE(" gl_aux_buffers : %d\n", value); | |
| glXGetConfig(object->display, object->visInfo, GLX_BUFFER_SIZE ,&value); | |
| TRACE(" gl_buffer_size : %d\n", value); | |
| glXGetConfig(object->display, object->visInfo, GLX_RED_SIZE, &value); | |
| TRACE(" gl_red_size : %d\n", value); | |
| glXGetConfig(object->display, object->visInfo, GLX_GREEN_SIZE, &value); | |
| TRACE(" gl_green_size : %d\n", value); | |
| glXGetConfig(object->display, object->visInfo, GLX_BLUE_SIZE, &value); | |
| TRACE(" gl_blue_size : %d\n", value); | |
| glXGetConfig(object->display, object->visInfo, GLX_ALPHA_SIZE, &value); | |
| TRACE(" gl_alpha_size : %d\n", value); | |
| glXGetConfig(object->display, object->visInfo, GLX_DEPTH_SIZE ,&value); | |
| TRACE(" gl_depth_size : %d\n", value); | |
| glXGetConfig(object->display, object->visInfo, GLX_STENCIL_SIZE, &value); | |
| TRACE(" gl_stencil_size : %d\n", value); | |
| } | |
| /* Now choose a simila visual ID*/ | |
| } | |
| #ifdef USE_CONTEXT_MANAGER | |
| /** TODO: use a context mamager **/ | |
| #endif | |
| { | |
| IWineD3DSwapChain *implSwapChain; | |
| if (D3D_OK != IWineD3DDevice_GetSwapChain(iface, 0, &implSwapChain)) { | |
| /* The first time around we create the context that is shared with all other swapchains and render targets */ | |
| object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE); | |
| TRACE("Creating implicit context for vis %p, hwnd %p\n", object->display, object->visInfo); | |
| } else { | |
| TRACE("Creating context for vis %p, hwnd %p\n", object->display, object->visInfo); | |
| /* TODO: don't use Impl structures outside of create functions! (a context manager will replace the ->glCtx) */ | |
| /* and create a new context with the implicit swapchains context as the shared context */ | |
| object->glCtx = glXCreateContext(object->display, object->visInfo, ((IWineD3DSwapChainImpl *)implSwapChain)->glCtx, GL_TRUE); | |
| IWineD3DSwapChain_Release(implSwapChain); | |
| } | |
| } | |
| /* Cleanup */ | |
| XFree(object->visInfo); | |
| object->visInfo = NULL; | |
| if (NULL == object->glCtx) { | |
| ERR("cannot create glxContext\n"); | |
| LEAVE_GL(); | |
| return D3DERR_NOTAVAILABLE; | |
| } | |
| LEAVE_GL(); | |
| if (object->glCtx == NULL) { | |
| ERR("Error in context creation !\n"); | |
| return D3DERR_INVALIDCALL; | |
| } else { | |
| TRACE("Context created (HWND=%p, glContext=%p, Window=%ld, VisInfo=%p)\n", | |
| object->win_handle, object->glCtx, object->win, object->visInfo); | |
| } | |
| /********************* | |
| * Windowed / Fullscreen | |
| *******************/ | |
| /** | |
| * TODO: MSDN says that we are only allowed one fullscreen swapchain per device, | |
| * so we should really check to see if their is a fullscreen swapchain already | |
| * I think Windows and X have different ideas about fullscreen, does a single head count as full screen? | |
| **************************************/ | |
| if (!*(pPresentationParameters->Windowed)) { | |
| DEVMODEW devmode; | |
| HDC hdc; | |
| int bpp = 0; | |
| /* Get info on the current display setup */ | |
| hdc = CreateDCA("DISPLAY", NULL, NULL, NULL); | |
| bpp = GetDeviceCaps(hdc, BITSPIXEL); | |
| DeleteDC(hdc); | |
| /* Change the display settings */ | |
| memset(&devmode, 0, sizeof(DEVMODEW)); | |
| devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; | |
| devmode.dmBitsPerPel = (bpp >= 24) ? 32 : bpp; /* Stupid XVidMode cannot change bpp */ | |
| devmode.dmPelsWidth = *(pPresentationParameters->BackBufferWidth); | |
| devmode.dmPelsHeight = *(pPresentationParameters->BackBufferHeight); | |
| MultiByteToWideChar(CP_ACP, 0, "Gamers CG", -1, devmode.dmDeviceName, CCHDEVICENAME); | |
| ChangeDisplaySettingsExW(devmode.dmDeviceName, &devmode, object->win_handle, CDS_FULLSCREEN, NULL); | |
| /* Make popup window */ | |
| SetWindowLongA(object->win_handle, GWL_STYLE, WS_POPUP); | |
| SetWindowPos(object->win_handle, HWND_TOP, 0, 0, | |
| *(pPresentationParameters->BackBufferWidth), | |
| *(pPresentationParameters->BackBufferHeight), SWP_SHOWWINDOW | SWP_FRAMECHANGED); | |
| } | |
| /** MSDN: If Windowed is TRUE and either of the BackBufferWidth/Height values is zero, | |
| * then the corresponding dimension of the client area of the hDeviceWindow | |
| * (or the focus window, if hDeviceWindow is NULL) is taken. | |
| **********************/ | |
| if (*(pPresentationParameters->Windowed) && | |
| ((*(pPresentationParameters->BackBufferWidth) == 0) || | |
| (*(pPresentationParameters->BackBufferHeight) == 0))) { | |
| RECT Rect; | |
| GetClientRect(object->win_handle, &Rect); | |
| if (*(pPresentationParameters->BackBufferWidth) == 0) { | |
| *(pPresentationParameters->BackBufferWidth) = Rect.right; | |
| TRACE("Updating width to %d\n", *(pPresentationParameters->BackBufferWidth)); | |
| } | |
| if (*(pPresentationParameters->BackBufferHeight) == 0) { | |
| *(pPresentationParameters->BackBufferHeight) = Rect.bottom; | |
| TRACE("Updating height to %d\n", *(pPresentationParameters->BackBufferHeight)); | |
| } | |
| } | |
| /********************* | |
| * finish off parameter initialization | |
| *******************/ | |
| /* Put the correct figures in the presentation parameters */ | |
| TRACE("Coppying accross presentaion paraneters\n"); | |
| object->presentParms.BackBufferWidth = *(pPresentationParameters->BackBufferWidth); | |
| object->presentParms.BackBufferHeight = *(pPresentationParameters->BackBufferHeight); | |
| object->presentParms.BackBufferFormat = *(pPresentationParameters->BackBufferFormat); | |
| object->presentParms.BackBufferCount = *(pPresentationParameters->BackBufferCount); | |
| object->presentParms.MultiSampleType = *(pPresentationParameters->MultiSampleType); | |
| object->presentParms.MultiSampleQuality = *(pPresentationParameters->MultiSampleQuality); | |
| object->presentParms.SwapEffect = *(pPresentationParameters->SwapEffect); | |
| object->presentParms.hDeviceWindow = *(pPresentationParameters->hDeviceWindow); | |
| object->presentParms.Windowed = *(pPresentationParameters->Windowed); | |
| object->presentParms.EnableAutoDepthStencil = *(pPresentationParameters->EnableAutoDepthStencil); | |
| object->presentParms.AutoDepthStencilFormat = *(pPresentationParameters->AutoDepthStencilFormat); | |
| object->presentParms.Flags = *(pPresentationParameters->Flags); | |
| object->presentParms.FullScreen_RefreshRateInHz = *(pPresentationParameters->FullScreen_RefreshRateInHz); | |
| object->presentParms.PresentationInterval = *(pPresentationParameters->PresentationInterval); | |
| /* FIXME: check for any failures */ | |
| /********************* | |
| * Create the back, front and stencil buffers | |
| *******************/ | |
| TRACE("calling rendertarget CB\n"); | |
| hr = D3DCB_CreateRenderTarget((IUnknown *) This->parent, | |
| object->presentParms.BackBufferWidth, | |
| object->presentParms.BackBufferHeight, | |
| object->presentParms.BackBufferFormat, | |
| object->presentParms.MultiSampleType, | |
| object->presentParms.MultiSampleQuality, | |
| TRUE /* Lockable */, | |
| &object->frontBuffer, | |
| NULL /* pShared (always null)*/); | |
| if (object->frontBuffer != NULL) | |
| IWineD3DSurface_SetContainer(object->frontBuffer, (IUnknown *)object); | |
| TRACE("calling rendertarget CB\n"); | |
| hr = D3DCB_CreateRenderTarget((IUnknown *) This->parent, | |
| object->presentParms.BackBufferWidth, | |
| object->presentParms.BackBufferHeight, | |
| object->presentParms.BackBufferFormat, | |
| object->presentParms.MultiSampleType, | |
| object->presentParms.MultiSampleQuality, | |
| TRUE /* Lockable */, | |
| &object->backBuffer, | |
| NULL /* pShared (always null)*/); | |
| if (object->backBuffer != NULL) | |
| IWineD3DSurface_SetContainer(object->backBuffer, (IUnknown *)object); | |
| /* Under directX swapchains share the depth stencil, so only create one depth-stencil */ | |
| if (pPresentationParameters->EnableAutoDepthStencil) { | |
| TRACE("Creating depth stencil buffer\n"); | |
| if (This->depthStencilBuffer == NULL ) { | |
| hr = D3DCB_CreateDepthStencil((IUnknown *) This->parent, | |
| object->presentParms.BackBufferWidth, | |
| object->presentParms.BackBufferHeight, | |
| object->presentParms.AutoDepthStencilFormat, | |
| object->presentParms.MultiSampleType, | |
| object->presentParms.MultiSampleQuality, | |
| FALSE /* FIXME: Discard */, | |
| &This->depthStencilBuffer, | |
| NULL /* pShared (always null)*/ ); | |
| if (This->depthStencilBuffer != NULL) | |
| IWineD3DSurface_SetContainer(This->depthStencilBuffer, (IUnknown *)iface); | |
| } | |
| /** TODO: A check on width, height and multisample types | |
| *(since the zbuffer must be at least as large as the render target and have the same multisample parameters) | |
| ****************************/ | |
| object->wantsDepthStencilBuffer = TRUE; | |
| } else { | |
| object->wantsDepthStencilBuffer = FALSE; | |
| } | |
| TRACE("FrontBuf @ %p, BackBuf @ %p, DepthStencil %d\n",object->frontBuffer, object->backBuffer, object->wantsDepthStencilBuffer); | |
| /********************* | |
| * init the default renderTarget management | |
| *******************/ | |
| object->drawable = object->win; | |
| object->render_ctx = object->glCtx; | |
| if(hr == D3D_OK) { | |
| /********************* | |
| * Setup some defaults and clear down the buffers | |
| *******************/ | |
| ENTER_GL(); | |
| /** save current context and drawable **/ | |
| oldContext = glXGetCurrentContext(); | |
| oldDrawable = glXGetCurrentDrawable(); | |
| TRACE("Activating context (display %p context %p drawable %ld)!\n", object->display, object->glCtx, object->win); | |
| if (glXMakeCurrent(object->display, object->win, object->glCtx) == False) { | |
| ERR("Error in setting current context (display %p context %p drawable %ld)!\n", object->display, object->glCtx, object->win); | |
| } | |
| checkGLcall("glXMakeCurrent"); | |
| TRACE("Setting up the screen\n"); | |
| /* Clear the screen */ | |
| glClearColor(0.0, 0.0, 0.0, 0.0); | |
| checkGLcall("glClearColor"); | |
| glClearIndex(0); | |
| glClearDepth(1); | |
| glClearStencil(0xffff); | |
| glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ACCUM_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); | |
| checkGLcall("glClear"); | |
| glColor3f(1.0, 1.0, 1.0); | |
| checkGLcall("glColor3f"); | |
| glEnable(GL_LIGHTING); | |
| checkGLcall("glEnable"); | |
| glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); | |
| checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);"); | |
| glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT); | |
| checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);"); | |
| glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); | |
| checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);"); | |
| /* switch back to the original context (unless it was zero)*/ | |
| if (This->numberOfSwapChains != 0) { | |
| /** TODO: restore the context and drawable **/ | |
| glXMakeCurrent(object->display, oldDrawable, oldContext); | |
| } | |
| LEAVE_GL(); | |
| /* TODO: move this off into a linked list implementation! (add swapchain, remove swapchain or something along those lines) */ | |
| #if 0 | |
| IListOperator *listOperator; | |
| IListStore_CreateListOperator(This->swapchainStore, &listOperator); | |
| IListOperator_Append(listOperator, (void *)object); | |
| IListOperator_Release(listOperator); | |
| #endif | |
| This->swapchains[This->numberOfSwapChains++] = (IWineD3DSwapChain *)object; | |
| TRACE("Set swapchain to %p\n", object); | |
| } else { /* something went wrong so clean up */ | |
| IUnknown* bufferParent; | |
| if (object->frontBuffer) { | |
| IWineD3DSurface_GetParent(object->frontBuffer, &bufferParent); | |
| IUnknown_Release(bufferParent); /* once for the get parent */ | |
| if(IUnknown_Release(bufferParent) > 0) { | |
| FIXME("(%p) Something's still holding the front buffer\n",This); | |
| } | |
| } | |
| if (object->backBuffer) { | |
| IWineD3DSurface_GetParent(object->backBuffer, &bufferParent); | |
| IUnknown_Release(bufferParent); /* once for the get parent */ | |
| if(IUnknown_Release(bufferParent) > 0) { | |
| FIXME("(%p) Something's still holding the back buffer\n",This); | |
| } | |
| } | |
| /* NOTE: don't clean up the depthstencil buffer because it belongs to the device */ | |
| /* Clean up the context */ | |
| /* check that we are the current context first (we shouldn't be though!) */ | |
| if (object->glCtx != 0) { | |
| if(glXGetCurrentContext() == object->glCtx) { | |
| glXMakeCurrent(object->display, None, NULL); | |
| } | |
| glXDestroyContext(object->display, object->glCtx); | |
| } | |
| HeapFree(GetProcessHeap(), 0, object); | |
| } | |
| return hr; | |
| } | |
| /** NOTE: These are ahead of the other getters and setters to save using a forward declaration **/ | |
| UINT WINAPI IWineD3DDeviceImpl_GetNumberOfSwapChains(IWineD3DDevice *iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* TODO: move over to using a linked list. */ | |
| TRACE("(%p) returning %d\n", This, This->numberOfSwapChains); | |
| return This->numberOfSwapChains; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetSwapChain(IWineD3DDevice *iface, UINT iSwapChain, IWineD3DSwapChain **pSwapChain) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : swapchain %d \n", This, iSwapChain); | |
| if(iSwapChain >= IWineD3DDeviceImpl_GetNumberOfSwapChains(iface) || iSwapChain < 0) { | |
| *pSwapChain = NULL; | |
| return D3DERR_INVALIDCALL; | |
| }else{ | |
| /** TODO: move off to a linked list implementation **/ | |
| *pSwapChain = This->swapchains[iSwapChain]; | |
| } | |
| /* TODO: move over to using stores and linked lists. */ | |
| IWineD3DSwapChain_AddRef(*pSwapChain); | |
| TRACE("(%p) returning %p\n", This, *pSwapChain); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_Reset(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : Stub\n",This); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Vertex Declaration | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclaration(IWineD3DDevice* iface, CONST VOID* pDeclaration, IWineD3DVertexDeclaration** ppVertexDeclaration, IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DVertexDeclarationImpl *object = NULL; | |
| HRESULT hr = D3D_OK; | |
| TRACE("(%p) : directXVersion=%u, pFunction=%p, ppDecl=%p\n", This, ((IWineD3DImpl *)This->wineD3D)->dxVersion, pDeclaration, ppVertexDeclaration); | |
| D3DCREATEOBJECTINSTANCE(object, VertexDeclaration) | |
| object->allFVF = 0; | |
| hr = IWineD3DVertexDeclaration_SetDeclaration((IWineD3DVertexDeclaration *)object, (void *)pDeclaration); | |
| return hr; | |
| } | |
| /* http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/programmable/vertexshaders/vscreate.asp */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexShader(IWineD3DDevice* iface, CONST DWORD* pFunction, IWineD3DVertexShader** ppVertexShader, IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DVertexShaderImpl *object; /* NOTE: impl usage is ok, this is a create */ | |
| D3DCREATEOBJECTINSTANCE(object, VertexShader) | |
| object->function = pFunction; | |
| FIXME("(%p) : STUB: Created Vertex shader %p\n", This, ppVertexShader); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_CreatePixelShader(IWineD3DDevice* iface, CONST DWORD* pFunction, IWineD3DPixelShader** ppPixelShader, IUnknown *parent) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : Stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetDirect3D(IWineD3DDevice* iface, IWineD3D** ppD3D) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| *ppD3D= This->wineD3D; | |
| TRACE("(%p) : wineD3D returning %p\n", This, *ppD3D); | |
| IWineD3D_AddRef(*ppD3D); | |
| return D3D_OK; | |
| } | |
| UINT WINAPI IWineD3DDeviceImpl_GetAvailableTextureMem(IWineD3DDevice *iface) { | |
| /** NOTE: There's a probably a hack-around for this one by putting as many pbuffers, VBO's (or whatever) | |
| * Into the video ram as possible and seeing how many fit | |
| * you can also get the correct initial value from via X and ATI's driver | |
| *******************/ | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| static BOOL showfixmes = TRUE; | |
| if (showfixmes) { | |
| FIXME("(%p) : stub, emulating %dMib for now, returning %dMib\n", This, (emulated_textureram/(1024*1024)), | |
| ((emulated_textureram - wineD3DGlobalStatistics->glsurfaceram) / (1024*1024))); | |
| showfixmes = FALSE; | |
| } | |
| TRACE("(%p) : emulating %dMib for now, returning %dMib\n", This, (emulated_textureram/(1024*1024)), | |
| ((emulated_textureram - wineD3DGlobalStatistics->glsurfaceram) / (1024*1024))); | |
| /* videomemory is simulated videomemory + AGP memory left */ | |
| return (emulated_textureram - wineD3DGlobalStatistics->glsurfaceram); | |
| } | |
| /***** | |
| * Get / Set FVF | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetFVF(IWineD3DDevice *iface, DWORD fvf) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* Update the current state block */ | |
| This->updateStateBlock->fvf = fvf; | |
| This->updateStateBlock->changed.fvf = TRUE; | |
| This->updateStateBlock->set.fvf = TRUE; | |
| TRACE("(%p) : FVF Shader FVF set to %lx\n", This, fvf); | |
| /* clear down the vertex declaration | |
| NOTE: Axis and Allies doesn't work properly otherwise | |
| (may be a stateblock problem though!) | |
| */ | |
| /* No difference if recording or not */ | |
| return IWineD3DDevice_SetVertexDeclaration(iface, NULL); | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetFVF(IWineD3DDevice *iface, DWORD *pfvf) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : GetFVF returning %lx\n", This, This->stateBlock->fvf); | |
| *pfvf = This->stateBlock->fvf; | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Stream Source | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer* pStreamData, UINT OffsetInBytes, UINT Stride) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DVertexBuffer *oldSrc; | |
| oldSrc = This->stateBlock->streamSource[StreamNumber]; | |
| TRACE("(%p) : StreamNo: %d, OldStream (%p), NewStream (%p), NewStride %d\n", This, StreamNumber, oldSrc, pStreamData, Stride); | |
| This->updateStateBlock->changed.streamSource[StreamNumber] = TRUE; | |
| This->updateStateBlock->set.streamSource[StreamNumber] = TRUE; | |
| This->updateStateBlock->streamStride[StreamNumber] = Stride; | |
| This->updateStateBlock->streamSource[StreamNumber] = pStreamData; | |
| This->updateStateBlock->streamOffset[StreamNumber] = OffsetInBytes; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| /* Not recording... */ | |
| if (oldSrc != NULL) IWineD3DVertexBuffer_Release(oldSrc); | |
| if (pStreamData != NULL) IWineD3DVertexBuffer_AddRef(pStreamData); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer** pStream, UINT *pOffset, UINT* pStride) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : StreamNo: %d, Stream (%p), Stride %d\n", This, StreamNumber, This->stateBlock->streamSource[StreamNumber], This->stateBlock->streamStride[StreamNumber]); | |
| *pStream = This->stateBlock->streamSource[StreamNumber]; | |
| *pStride = This->stateBlock->streamStride[StreamNumber]; | |
| *pOffset = This->stateBlock->streamOffset[StreamNumber]; | |
| if (*pStream != NULL) IWineD3DVertexBuffer_AddRef(*pStream); /* We have created a new reference to the VB */ | |
| return D3D_OK; | |
| } | |
| /*Should be quite easy, just an extension of vertexdata | |
| ref... | |
| http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c_Summer_04/directx/graphics/programmingguide/advancedtopics/DrawingMultipleInstances.asp | |
| The divider is a bit odd though | |
| VertexOffset = StartVertex / Divider * StreamStride + | |
| VertexIndex / Divider * StreamStride + StreamOffset | |
| */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSourceFreq(IWineD3DDevice *iface, UINT StreamNumber, UINT Divider) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSourceFreq(IWineD3DDevice *iface, UINT StreamNumber, UINT* Divider) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set & Multiply Transform | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetTransform(IWineD3DDevice *iface, D3DTRANSFORMSTATETYPE d3dts, CONST D3DMATRIX* lpmatrix) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* Most of this routine, comments included copied from ddraw tree initially: */ | |
| TRACE("(%p) : Transform State=%d\n", This, d3dts); | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| This->updateStateBlock->changed.transform[d3dts] = TRUE; | |
| This->updateStateBlock->set.transform[d3dts] = TRUE; | |
| memcpy(&This->updateStateBlock->transforms[d3dts], lpmatrix, sizeof(D3DMATRIX)); | |
| return D3D_OK; | |
| } | |
| /* | |
| * If the new matrix is the same as the current one, | |
| * we cut off any further processing. this seems to be a reasonable | |
| * optimization because as was noticed, some apps (warcraft3 for example) | |
| * tend towards setting the same matrix repeatedly for some reason. | |
| * | |
| * From here on we assume that the new matrix is different, wherever it matters. | |
| */ | |
| if (!memcmp(&This->stateBlock->transforms[d3dts].u.m[0][0], lpmatrix, sizeof(D3DMATRIX))) { | |
| TRACE("The app is setting the same matrix over again\n"); | |
| return D3D_OK; | |
| } else { | |
| conv_mat(lpmatrix, &This->stateBlock->transforms[d3dts].u.m[0][0]); | |
| } | |
| /* | |
| ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord | |
| where ViewMat = Camera space, WorldMat = world space. | |
| In OpenGL, camera and world space is combined into GL_MODELVIEW | |
| matrix. The Projection matrix stay projection matrix. | |
| */ | |
| /* Capture the times we can just ignore the change for now */ | |
| if (d3dts == D3DTS_WORLDMATRIX(0)) { | |
| This->modelview_valid = FALSE; | |
| return D3D_OK; | |
| } else if (d3dts == D3DTS_PROJECTION) { | |
| This->proj_valid = FALSE; | |
| return D3D_OK; | |
| } else if (d3dts >= D3DTS_WORLDMATRIX(1) && d3dts <= D3DTS_WORLDMATRIX(255)) { | |
| /* Indexed Vertex Blending Matrices 256 -> 511 */ | |
| /* Use arb_vertex_blend or NV_VERTEX_WEIGHTING? */ | |
| FIXME("D3DTS_WORLDMATRIX(1..255) not handled\n"); | |
| return D3D_OK; | |
| } | |
| /* Now we really are going to have to change a matrix */ | |
| ENTER_GL(); | |
| if (d3dts >= D3DTS_TEXTURE0 && d3dts <= D3DTS_TEXTURE7) { /* handle texture matrices */ | |
| if (d3dts < GL_LIMITS(textures)) { | |
| int tex = d3dts - D3DTS_TEXTURE0; | |
| GLACTIVETEXTURE(tex); | |
| set_texture_matrix((float *)lpmatrix, | |
| This->updateStateBlock->textureState[tex][WINED3DTSS_TEXTURETRANSFORMFLAGS]); | |
| } | |
| } else if (d3dts == D3DTS_VIEW) { /* handle the VIEW matrice */ | |
| unsigned int k; | |
| /* If we are changing the View matrix, reset the light and clipping planes to the new view | |
| * NOTE: We have to reset the positions even if the light/plane is not currently | |
| * enabled, since the call to enable it will not reset the position. | |
| * NOTE2: Apparently texture transforms do NOT need reapplying | |
| */ | |
| PLIGHTINFOEL *lightChain = NULL; | |
| This->modelview_valid = FALSE; | |
| This->view_ident = !memcmp(lpmatrix, identity, 16 * sizeof(float)); | |
| glMatrixMode(GL_MODELVIEW); | |
| checkGLcall("glMatrixMode(GL_MODELVIEW)"); | |
| glPushMatrix(); | |
| glLoadMatrixf((float *)lpmatrix); | |
| checkGLcall("glLoadMatrixf(...)"); | |
| /* Reset lights */ | |
| lightChain = This->stateBlock->lights; | |
| while (lightChain && lightChain->glIndex != -1) { | |
| glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_POSITION, lightChain->lightPosn); | |
| checkGLcall("glLightfv posn"); | |
| glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_SPOT_DIRECTION, lightChain->lightDirn); | |
| checkGLcall("glLightfv dirn"); | |
| lightChain = lightChain->next; | |
| } | |
| /* Reset Clipping Planes if clipping is enabled */ | |
| for (k = 0; k < GL_LIMITS(clipplanes); k++) { | |
| glClipPlane(GL_CLIP_PLANE0 + k, This->stateBlock->clipplane[k]); | |
| checkGLcall("glClipPlane"); | |
| } | |
| glPopMatrix(); | |
| } else { /* What was requested!?? */ | |
| WARN("invalid matrix specified: %i\n", d3dts); | |
| } | |
| /* Release lock, all done */ | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetTransform(IWineD3DDevice *iface, D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : for Transform State %d\n", This, State); | |
| memcpy(pMatrix, &This->stateBlock->transforms[State], sizeof(D3DMATRIX)); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_MultiplyTransform(IWineD3DDevice *iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) { | |
| D3DMATRIX *mat = NULL; | |
| D3DMATRIX temp; | |
| /* Note: Using 'updateStateBlock' rather than 'stateblock' in the code | |
| * below means it will be recorded in a state block change, but it | |
| * works regardless where it is recorded. | |
| * If this is found to be wrong, change to StateBlock. | |
| */ | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : For state %u\n", This, State); | |
| if (State < HIGHEST_TRANSFORMSTATE) | |
| { | |
| mat = &This->updateStateBlock->transforms[State]; | |
| } else { | |
| FIXME("Unhandled transform state!!\n"); | |
| } | |
| /* Copied from ddraw code: */ | |
| temp.u.s._11 = (mat->u.s._11 * pMatrix->u.s._11) + (mat->u.s._21 * pMatrix->u.s._12) + (mat->u.s._31 * pMatrix->u.s._13) + (mat->u.s._41 * pMatrix->u.s._14); | |
| temp.u.s._21 = (mat->u.s._11 * pMatrix->u.s._21) + (mat->u.s._21 * pMatrix->u.s._22) + (mat->u.s._31 * pMatrix->u.s._23) + (mat->u.s._41 * pMatrix->u.s._24); | |
| temp.u.s._31 = (mat->u.s._11 * pMatrix->u.s._31) + (mat->u.s._21 * pMatrix->u.s._32) + (mat->u.s._31 * pMatrix->u.s._33) + (mat->u.s._41 * pMatrix->u.s._34); | |
| temp.u.s._41 = (mat->u.s._11 * pMatrix->u.s._41) + (mat->u.s._21 * pMatrix->u.s._42) + (mat->u.s._31 * pMatrix->u.s._43) + (mat->u.s._41 * pMatrix->u.s._44); | |
| temp.u.s._12 = (mat->u.s._12 * pMatrix->u.s._11) + (mat->u.s._22 * pMatrix->u.s._12) + (mat->u.s._32 * pMatrix->u.s._13) + (mat->u.s._42 * pMatrix->u.s._14); | |
| temp.u.s._22 = (mat->u.s._12 * pMatrix->u.s._21) + (mat->u.s._22 * pMatrix->u.s._22) + (mat->u.s._32 * pMatrix->u.s._23) + (mat->u.s._42 * pMatrix->u.s._24); | |
| temp.u.s._32 = (mat->u.s._12 * pMatrix->u.s._31) + (mat->u.s._22 * pMatrix->u.s._32) + (mat->u.s._32 * pMatrix->u.s._33) + (mat->u.s._42 * pMatrix->u.s._34); | |
| temp.u.s._42 = (mat->u.s._12 * pMatrix->u.s._41) + (mat->u.s._22 * pMatrix->u.s._42) + (mat->u.s._32 * pMatrix->u.s._43) + (mat->u.s._42 * pMatrix->u.s._44); | |
| temp.u.s._13 = (mat->u.s._13 * pMatrix->u.s._11) + (mat->u.s._23 * pMatrix->u.s._12) + (mat->u.s._33 * pMatrix->u.s._13) + (mat->u.s._43 * pMatrix->u.s._14); | |
| temp.u.s._23 = (mat->u.s._13 * pMatrix->u.s._21) + (mat->u.s._23 * pMatrix->u.s._22) + (mat->u.s._33 * pMatrix->u.s._23) + (mat->u.s._43 * pMatrix->u.s._24); | |
| temp.u.s._33 = (mat->u.s._13 * pMatrix->u.s._31) + (mat->u.s._23 * pMatrix->u.s._32) + (mat->u.s._33 * pMatrix->u.s._33) + (mat->u.s._43 * pMatrix->u.s._34); | |
| temp.u.s._43 = (mat->u.s._13 * pMatrix->u.s._41) + (mat->u.s._23 * pMatrix->u.s._42) + (mat->u.s._33 * pMatrix->u.s._43) + (mat->u.s._43 * pMatrix->u.s._44); | |
| temp.u.s._14 = (mat->u.s._14 * pMatrix->u.s._11) + (mat->u.s._24 * pMatrix->u.s._12) + (mat->u.s._34 * pMatrix->u.s._13) + (mat->u.s._44 * pMatrix->u.s._14); | |
| temp.u.s._24 = (mat->u.s._14 * pMatrix->u.s._21) + (mat->u.s._24 * pMatrix->u.s._22) + (mat->u.s._34 * pMatrix->u.s._23) + (mat->u.s._44 * pMatrix->u.s._24); | |
| temp.u.s._34 = (mat->u.s._14 * pMatrix->u.s._31) + (mat->u.s._24 * pMatrix->u.s._32) + (mat->u.s._34 * pMatrix->u.s._33) + (mat->u.s._44 * pMatrix->u.s._34); | |
| temp.u.s._44 = (mat->u.s._14 * pMatrix->u.s._41) + (mat->u.s._24 * pMatrix->u.s._42) + (mat->u.s._34 * pMatrix->u.s._43) + (mat->u.s._44 * pMatrix->u.s._44); | |
| /* Apply change via set transform - will reapply to eg. lights this way */ | |
| IWineD3DDeviceImpl_SetTransform(iface, State, &temp); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Light | |
| * WARNING: This code relies on the fact that D3DLIGHT8 == D3DLIGHT9 | |
| *****/ | |
| /* Note lights are real special cases. Although the device caps state only eg. 8 are supported, | |
| you can reference any indexes you want as long as that number max are enabled at any | |
| one point in time! Therefore since the indexes can be anything, we need a linked list of them. | |
| However, this causes stateblock problems. When capturing the state block, I duplicate the list, | |
| but when recording, just build a chain pretty much of commands to be replayed. */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetLight(IWineD3DDevice *iface, DWORD Index, CONST WINED3DLIGHT* pLight) { | |
| float rho; | |
| PLIGHTINFOEL *object, *temp; | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight); | |
| /* If recording state block, just add to end of lights chain */ | |
| if (This->isRecordingState) { | |
| object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL)); | |
| if (NULL == object) { | |
| return D3DERR_OUTOFVIDEOMEMORY; | |
| } | |
| memcpy(&object->OriginalParms, pLight, sizeof(D3DLIGHT9)); | |
| object->OriginalIndex = Index; | |
| object->glIndex = -1; | |
| object->changed = TRUE; | |
| /* Add to the END of the chain of lights changes to be replayed */ | |
| if (This->updateStateBlock->lights == NULL) { | |
| This->updateStateBlock->lights = object; | |
| } else { | |
| temp = This->updateStateBlock->lights; | |
| while (temp->next != NULL) temp=temp->next; | |
| temp->next = object; | |
| } | |
| TRACE("Recording... not performing anything more\n"); | |
| return D3D_OK; | |
| } | |
| /* Ok, not recording any longer so do real work */ | |
| object = This->stateBlock->lights; | |
| while (object != NULL && object->OriginalIndex != Index) object = object->next; | |
| /* If we didn't find it in the list of lights, time to add it */ | |
| if (object == NULL) { | |
| PLIGHTINFOEL *insertAt,*prevPos; | |
| object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL)); | |
| if (NULL == object) { | |
| return D3DERR_OUTOFVIDEOMEMORY; | |
| } | |
| object->OriginalIndex = Index; | |
| object->glIndex = -1; | |
| /* Add it to the front of list with the idea that lights will be changed as needed | |
| BUT after any lights currently assigned GL indexes */ | |
| insertAt = This->stateBlock->lights; | |
| prevPos = NULL; | |
| while (insertAt != NULL && insertAt->glIndex != -1) { | |
| prevPos = insertAt; | |
| insertAt = insertAt->next; | |
| } | |
| if (insertAt == NULL && prevPos == NULL) { /* Start of list */ | |
| This->stateBlock->lights = object; | |
| } else if (insertAt == NULL) { /* End of list */ | |
| prevPos->next = object; | |
| object->prev = prevPos; | |
| } else { /* Middle of chain */ | |
| if (prevPos == NULL) { | |
| This->stateBlock->lights = object; | |
| } else { | |
| prevPos->next = object; | |
| } | |
| object->prev = prevPos; | |
| object->next = insertAt; | |
| insertAt->prev = object; | |
| } | |
| } | |
| /* Initialze the object */ | |
| 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, | |
| pLight->Diffuse.r, pLight->Diffuse.g, pLight->Diffuse.b, pLight->Diffuse.a, | |
| pLight->Specular.r, pLight->Specular.g, pLight->Specular.b, pLight->Specular.a, | |
| pLight->Ambient.r, pLight->Ambient.g, pLight->Ambient.b, pLight->Ambient.a); | |
| TRACE("... Pos(%f,%f,%f), Dirn(%f,%f,%f)\n", pLight->Position.x, pLight->Position.y, pLight->Position.z, | |
| pLight->Direction.x, pLight->Direction.y, pLight->Direction.z); | |
| TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n", pLight->Range, pLight->Falloff, pLight->Theta, pLight->Phi); | |
| /* Save away the information */ | |
| memcpy(&object->OriginalParms, pLight, sizeof(D3DLIGHT9)); | |
| switch (pLight->Type) { | |
| case D3DLIGHT_POINT: | |
| /* Position */ | |
| object->lightPosn[0] = pLight->Position.x; | |
| object->lightPosn[1] = pLight->Position.y; | |
| object->lightPosn[2] = pLight->Position.z; | |
| object->lightPosn[3] = 1.0f; | |
| object->cutoff = 180.0f; | |
| /* FIXME: Range */ | |
| break; | |
| case D3DLIGHT_DIRECTIONAL: | |
| /* Direction */ | |
| object->lightPosn[0] = -pLight->Direction.x; | |
| object->lightPosn[1] = -pLight->Direction.y; | |
| object->lightPosn[2] = -pLight->Direction.z; | |
| object->lightPosn[3] = 0.0; | |
| object->exponent = 0.0f; | |
| object->cutoff = 180.0f; | |
| break; | |
| case D3DLIGHT_SPOT: | |
| /* Position */ | |
| object->lightPosn[0] = pLight->Position.x; | |
| object->lightPosn[1] = pLight->Position.y; | |
| object->lightPosn[2] = pLight->Position.z; | |
| object->lightPosn[3] = 1.0; | |
| /* Direction */ | |
| object->lightDirn[0] = pLight->Direction.x; | |
| object->lightDirn[1] = pLight->Direction.y; | |
| object->lightDirn[2] = pLight->Direction.z; | |
| object->lightDirn[3] = 1.0; | |
| /* | |
| * opengl-ish and d3d-ish spot lights use too different models for the | |
| * light "intensity" as a function of the angle towards the main light direction, | |
| * so we only can approximate very roughly. | |
| * however spot lights are rather rarely used in games (if ever used at all). | |
| * furthermore if still used, probably nobody pays attention to such details. | |
| */ | |
| if (pLight->Falloff == 0) { | |
| rho = 6.28f; | |
| } else { | |
| rho = pLight->Theta + (pLight->Phi - pLight->Theta)/(2*pLight->Falloff); | |
| } | |
| if (rho < 0.0001) rho = 0.0001f; | |
| object->exponent = -0.3/log(cos(rho/2)); | |
| object->cutoff = pLight->Phi*90/M_PI; | |
| /* FIXME: Range */ | |
| break; | |
| default: | |
| FIXME("Unrecognized light type %d\n", pLight->Type); | |
| } | |
| /* Update the live definitions if the light is currently assigned a glIndex */ | |
| if (object->glIndex != -1) { | |
| setup_light(iface, object->glIndex, object); | |
| } | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetLight(IWineD3DDevice *iface, DWORD Index, WINED3DLIGHT* pLight) { | |
| PLIGHTINFOEL *lightInfo = NULL; | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight); | |
| /* Locate the light in the live lights */ | |
| lightInfo = This->stateBlock->lights; | |
| while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next; | |
| if (lightInfo == NULL) { | |
| TRACE("Light information requested but light not defined\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| memcpy(pLight, &lightInfo->OriginalParms, sizeof(D3DLIGHT9)); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Light Enable | |
| * (Note for consistency, renamed d3dx function by adding the 'set' prefix) | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetLightEnable(IWineD3DDevice *iface, DWORD Index, BOOL Enable) { | |
| PLIGHTINFOEL *lightInfo = NULL; | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : Idx(%ld), enable? %d\n", This, Index, Enable); | |
| /* If recording state block, just add to end of lights chain with changedEnable set to true */ | |
| if (This->isRecordingState) { | |
| lightInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PLIGHTINFOEL)); | |
| if (NULL == lightInfo) { | |
| return D3DERR_OUTOFVIDEOMEMORY; | |
| } | |
| lightInfo->OriginalIndex = Index; | |
| lightInfo->glIndex = -1; | |
| lightInfo->enabledChanged = TRUE; | |
| /* Add to the END of the chain of lights changes to be replayed */ | |
| if (This->updateStateBlock->lights == NULL) { | |
| This->updateStateBlock->lights = lightInfo; | |
| } else { | |
| PLIGHTINFOEL *temp = This->updateStateBlock->lights; | |
| while (temp->next != NULL) temp=temp->next; | |
| temp->next = lightInfo; | |
| } | |
| TRACE("Recording... not performing anything more\n"); | |
| return D3D_OK; | |
| } | |
| /* Not recording... So, locate the light in the live lights */ | |
| lightInfo = This->stateBlock->lights; | |
| while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next; | |
| /* Special case - enabling an undefined light creates one with a strict set of parms! */ | |
| if (lightInfo == NULL) { | |
| D3DLIGHT9 lightParms; | |
| /* Warning - untested code :-) Prob safe to change fixme to a trace but | |
| wait until someone confirms it seems to work! */ | |
| TRACE("Light enabled requested but light not defined, so defining one!\n"); | |
| lightParms.Type = D3DLIGHT_DIRECTIONAL; | |
| lightParms.Diffuse.r = 1.0; | |
| lightParms.Diffuse.g = 1.0; | |
| lightParms.Diffuse.b = 1.0; | |
| lightParms.Diffuse.a = 0.0; | |
| lightParms.Specular.r = 0.0; | |
| lightParms.Specular.g = 0.0; | |
| lightParms.Specular.b = 0.0; | |
| lightParms.Specular.a = 0.0; | |
| lightParms.Ambient.r = 0.0; | |
| lightParms.Ambient.g = 0.0; | |
| lightParms.Ambient.b = 0.0; | |
| lightParms.Ambient.a = 0.0; | |
| lightParms.Position.x = 0.0; | |
| lightParms.Position.y = 0.0; | |
| lightParms.Position.z = 0.0; | |
| lightParms.Direction.x = 0.0; | |
| lightParms.Direction.y = 0.0; | |
| lightParms.Direction.z = 1.0; | |
| lightParms.Range = 0.0; | |
| lightParms.Falloff = 0.0; | |
| lightParms.Attenuation0 = 0.0; | |
| lightParms.Attenuation1 = 0.0; | |
| lightParms.Attenuation2 = 0.0; | |
| lightParms.Theta = 0.0; | |
| lightParms.Phi = 0.0; | |
| IWineD3DDeviceImpl_SetLight(iface, Index, &lightParms); | |
| /* Search for it again! Should be fairly quick as near head of list */ | |
| lightInfo = This->stateBlock->lights; | |
| while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next; | |
| if (lightInfo == NULL) { | |
| FIXME("Adding default lights has failed dismally\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| } | |
| /* OK, we now have a light... */ | |
| if (Enable == FALSE) { | |
| /* If we are disabling it, check it was enabled, and | |
| still only do something if it has assigned a glIndex (which it should have!) */ | |
| if ((lightInfo->lightEnabled) && (lightInfo->glIndex != -1)) { | |
| TRACE("Disabling light set up at gl idx %ld\n", lightInfo->glIndex); | |
| ENTER_GL(); | |
| glDisable(GL_LIGHT0 + lightInfo->glIndex); | |
| checkGLcall("glDisable GL_LIGHT0+Index"); | |
| LEAVE_GL(); | |
| } else { | |
| TRACE("Nothing to do as light was not enabled\n"); | |
| } | |
| lightInfo->lightEnabled = FALSE; | |
| } else { | |
| /* We are enabling it. If it is enabled, it's really simple */ | |
| if (lightInfo->lightEnabled) { | |
| /* nop */ | |
| TRACE("Nothing to do as light was enabled\n"); | |
| /* If it already has a glIndex, it's still simple */ | |
| } else if (lightInfo->glIndex != -1) { | |
| TRACE("Reusing light as already set up at gl idx %ld\n", lightInfo->glIndex); | |
| lightInfo->lightEnabled = TRUE; | |
| ENTER_GL(); | |
| glEnable(GL_LIGHT0 + lightInfo->glIndex); | |
| checkGLcall("glEnable GL_LIGHT0+Index already setup"); | |
| LEAVE_GL(); | |
| /* Otherwise got to find space - lights are ordered gl indexes first */ | |
| } else { | |
| PLIGHTINFOEL *bsf = NULL; | |
| PLIGHTINFOEL *pos = This->stateBlock->lights; | |
| PLIGHTINFOEL *prev = NULL; | |
| int Index= 0; | |
| int glIndex = -1; | |
| /* Try to minimize changes as much as possible */ | |
| while (pos != NULL && pos->glIndex != -1 && Index < This->maxConcurrentLights) { | |
| /* Try to remember which index can be replaced if necessary */ | |
| if (bsf==NULL && pos->lightEnabled == FALSE) { | |
| /* Found a light we can replace, save as best replacement */ | |
| bsf = pos; | |
| } | |
| /* Step to next space */ | |
| prev = pos; | |
| pos = pos->next; | |
| Index ++; | |
| } | |
| /* If we have too many active lights, fail the call */ | |
| if ((Index == This->maxConcurrentLights) && (bsf == NULL)) { | |
| FIXME("Program requests too many concurrent lights\n"); | |
| return D3DERR_INVALIDCALL; | |
| /* If we have allocated all lights, but not all are enabled, | |
| reuse one which is not enabled */ | |
| } else if (Index == This->maxConcurrentLights) { | |
| /* use bsf - Simply swap the new light and the BSF one */ | |
| PLIGHTINFOEL *bsfNext = bsf->next; | |
| PLIGHTINFOEL *bsfPrev = bsf->prev; | |
| /* Sort out ends */ | |
| if (lightInfo->next != NULL) lightInfo->next->prev = bsf; | |
| if (bsf->prev != NULL) { | |
| bsf->prev->next = lightInfo; | |
| } else { | |
| This->stateBlock->lights = lightInfo; | |
| } | |
| /* If not side by side, lots of chains to update */ | |
| if (bsf->next != lightInfo) { | |
| lightInfo->prev->next = bsf; | |
| bsf->next->prev = lightInfo; | |
| bsf->next = lightInfo->next; | |
| bsf->prev = lightInfo->prev; | |
| lightInfo->next = bsfNext; | |
| lightInfo->prev = bsfPrev; | |
| } else { | |
| /* Simple swaps */ | |
| bsf->prev = lightInfo; | |
| bsf->next = lightInfo->next; | |
| lightInfo->next = bsf; | |
| lightInfo->prev = bsfPrev; | |
| } | |
| /* Update states */ | |
| glIndex = bsf->glIndex; | |
| bsf->glIndex = -1; | |
| lightInfo->glIndex = glIndex; | |
| lightInfo->lightEnabled = TRUE; | |
| /* Finally set up the light in gl itself */ | |
| TRACE("Replacing light which was set up at gl idx %ld\n", lightInfo->glIndex); | |
| ENTER_GL(); | |
| setup_light(iface, glIndex, lightInfo); | |
| glEnable(GL_LIGHT0 + glIndex); | |
| checkGLcall("glEnable GL_LIGHT0 new setup"); | |
| LEAVE_GL(); | |
| /* If we reached the end of the allocated lights, with space in the | |
| gl lights, setup a new light */ | |
| } else if (pos->glIndex == -1) { | |
| /* We reached the end of the allocated gl lights, so already | |
| know the index of the next one! */ | |
| glIndex = Index; | |
| lightInfo->glIndex = glIndex; | |
| lightInfo->lightEnabled = TRUE; | |
| /* In an ideal world, it's already in the right place */ | |
| if (lightInfo->prev == NULL || lightInfo->prev->glIndex!=-1) { | |
| /* No need to move it */ | |
| } else { | |
| /* Remove this light from the list */ | |
| lightInfo->prev->next = lightInfo->next; | |
| if (lightInfo->next != NULL) { | |
| lightInfo->next->prev = lightInfo->prev; | |
| } | |
| /* Add in at appropriate place (inbetween prev and pos) */ | |
| lightInfo->prev = prev; | |
| lightInfo->next = pos; | |
| if (prev == NULL) { | |
| This->stateBlock->lights = lightInfo; | |
| } else { | |
| prev->next = lightInfo; | |
| } | |
| if (pos != NULL) { | |
| pos->prev = lightInfo; | |
| } | |
| } | |
| /* Finally set up the light in gl itself */ | |
| TRACE("Defining new light at gl idx %ld\n", lightInfo->glIndex); | |
| ENTER_GL(); | |
| setup_light(iface, glIndex, lightInfo); | |
| glEnable(GL_LIGHT0 + glIndex); | |
| checkGLcall("glEnable GL_LIGHT0 new setup"); | |
| LEAVE_GL(); | |
| } | |
| } | |
| } | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetLightEnable(IWineD3DDevice *iface, DWORD Index,BOOL* pEnable) { | |
| PLIGHTINFOEL *lightInfo = NULL; | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : for idx(%ld)\n", This, Index); | |
| /* Locate the light in the live lights */ | |
| lightInfo = This->stateBlock->lights; | |
| while (lightInfo != NULL && lightInfo->OriginalIndex != Index) lightInfo = lightInfo->next; | |
| if (lightInfo == NULL) { | |
| TRACE("Light enabled state requested but light not defined\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| *pEnable = lightInfo->lightEnabled; | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Clip Planes | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetClipPlane(IWineD3DDevice *iface, DWORD Index, CONST float *pPlane) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : for idx %ld, %p\n", This, Index, pPlane); | |
| /* Validate Index */ | |
| if (Index >= GL_LIMITS(clipplanes)) { | |
| TRACE("Application has requested clipplane this device doesn't support\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| This->updateStateBlock->changed.clipplane[Index] = TRUE; | |
| This->updateStateBlock->set.clipplane[Index] = TRUE; | |
| This->updateStateBlock->clipplane[Index][0] = pPlane[0]; | |
| This->updateStateBlock->clipplane[Index][1] = pPlane[1]; | |
| This->updateStateBlock->clipplane[Index][2] = pPlane[2]; | |
| This->updateStateBlock->clipplane[Index][3] = pPlane[3]; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| /* Apply it */ | |
| ENTER_GL(); | |
| /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */ | |
| glMatrixMode(GL_MODELVIEW); | |
| glPushMatrix(); | |
| glLoadMatrixf((float *) &This->stateBlock->transforms[D3DTS_VIEW].u.m[0][0]); | |
| TRACE("Clipplane [%f,%f,%f,%f]\n", | |
| This->updateStateBlock->clipplane[Index][0], | |
| This->updateStateBlock->clipplane[Index][1], | |
| This->updateStateBlock->clipplane[Index][2], | |
| This->updateStateBlock->clipplane[Index][3]); | |
| glClipPlane(GL_CLIP_PLANE0 + Index, This->updateStateBlock->clipplane[Index]); | |
| checkGLcall("glClipPlane"); | |
| glPopMatrix(); | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetClipPlane(IWineD3DDevice *iface, DWORD Index, float *pPlane) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : for idx %ld\n", This, Index); | |
| /* Validate Index */ | |
| if (Index >= GL_LIMITS(clipplanes)) { | |
| TRACE("Application has requested clipplane this device doesn't support\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| pPlane[0] = This->stateBlock->clipplane[Index][0]; | |
| pPlane[1] = This->stateBlock->clipplane[Index][1]; | |
| pPlane[2] = This->stateBlock->clipplane[Index][2]; | |
| pPlane[3] = This->stateBlock->clipplane[Index][3]; | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Clip Plane Status | |
| * WARNING: This code relies on the fact that D3DCLIPSTATUS8 == D3DCLIPSTATUS9 | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetClipStatus(IWineD3DDevice *iface, CONST WINED3DCLIPSTATUS* pClipStatus) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| if (NULL == pClipStatus) { | |
| return D3DERR_INVALIDCALL; | |
| } | |
| This->updateStateBlock->clip_status.ClipUnion = pClipStatus->ClipUnion; | |
| This->updateStateBlock->clip_status.ClipIntersection = pClipStatus->ClipIntersection; | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetClipStatus(IWineD3DDevice *iface, WINED3DCLIPSTATUS* pClipStatus) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| if (NULL == pClipStatus) { | |
| return D3DERR_INVALIDCALL; | |
| } | |
| pClipStatus->ClipUnion = This->updateStateBlock->clip_status.ClipUnion; | |
| pClipStatus->ClipIntersection = This->updateStateBlock->clip_status.ClipIntersection; | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Material | |
| * WARNING: This code relies on the fact that D3DMATERIAL8 == D3DMATERIAL9 | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetMaterial(IWineD3DDevice *iface, CONST WINED3DMATERIAL* pMaterial) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| This->updateStateBlock->changed.material = TRUE; | |
| This->updateStateBlock->set.material = TRUE; | |
| memcpy(&This->updateStateBlock->material, pMaterial, sizeof(WINED3DMATERIAL)); | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| ENTER_GL(); | |
| TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g, pMaterial->Diffuse.b, pMaterial->Diffuse.a); | |
| TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g, pMaterial->Ambient.b, pMaterial->Ambient.a); | |
| TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g, pMaterial->Specular.b, pMaterial->Specular.a); | |
| TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g, pMaterial->Emissive.b, pMaterial->Emissive.a); | |
| TRACE("(%p) : Power (%f)\n", This, pMaterial->Power); | |
| glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*) &This->updateStateBlock->material.Ambient); | |
| checkGLcall("glMaterialfv"); | |
| glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*) &This->updateStateBlock->material.Diffuse); | |
| checkGLcall("glMaterialfv"); | |
| /* Only change material color if specular is enabled, otherwise it is set to black */ | |
| if (This->stateBlock->renderState[WINED3DRS_SPECULARENABLE]) { | |
| glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &This->updateStateBlock->material.Specular); | |
| checkGLcall("glMaterialfv"); | |
| } else { | |
| float black[4] = {0.0f, 0.0f, 0.0f, 0.0f}; | |
| glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]); | |
| checkGLcall("glMaterialfv"); | |
| } | |
| glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*) &This->updateStateBlock->material.Emissive); | |
| checkGLcall("glMaterialfv"); | |
| glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, This->updateStateBlock->material.Power); | |
| checkGLcall("glMaterialf"); | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetMaterial(IWineD3DDevice *iface, WINED3DMATERIAL* pMaterial) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| memcpy(pMaterial, &This->updateStateBlock->material, sizeof (WINED3DMATERIAL)); | |
| TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g, pMaterial->Diffuse.b, pMaterial->Diffuse.a); | |
| TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g, pMaterial->Ambient.b, pMaterial->Ambient.a); | |
| TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g, pMaterial->Specular.b, pMaterial->Specular.a); | |
| TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g, pMaterial->Emissive.b, pMaterial->Emissive.a); | |
| TRACE("(%p) : Power (%f)\n", This, pMaterial->Power); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Indices | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer* pIndexData, | |
| UINT BaseVertexIndex) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DIndexBuffer *oldIdxs; | |
| TRACE("(%p) : Setting to %p, base %d\n", This, pIndexData, BaseVertexIndex); | |
| oldIdxs = This->updateStateBlock->pIndexData; | |
| This->updateStateBlock->changed.indices = TRUE; | |
| This->updateStateBlock->set.indices = TRUE; | |
| This->updateStateBlock->pIndexData = pIndexData; | |
| This->updateStateBlock->baseVertexIndex = BaseVertexIndex; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| if (oldIdxs) IWineD3DIndexBuffer_Release(oldIdxs); | |
| if (pIndexData) IWineD3DIndexBuffer_AddRef(This->stateBlock->pIndexData); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer** ppIndexData, UINT* pBaseVertexIndex) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| *ppIndexData = This->stateBlock->pIndexData; | |
| /* up ref count on ppindexdata */ | |
| if (*ppIndexData) IWineD3DIndexBuffer_AddRef(*ppIndexData); | |
| *pBaseVertexIndex = This->stateBlock->baseVertexIndex; | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Viewports | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetViewport(IWineD3DDevice *iface, CONST WINED3DVIEWPORT* pViewport) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p)\n", This); | |
| This->updateStateBlock->changed.viewport = TRUE; | |
| This->updateStateBlock->set.viewport = TRUE; | |
| memcpy(&This->updateStateBlock->viewport, pViewport, sizeof(WINED3DVIEWPORT)); | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| ENTER_GL(); | |
| TRACE("(%p) : x=%ld, y=%ld, wid=%ld, hei=%ld, minz=%f, maxz=%f\n", This, | |
| pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ); | |
| glDepthRange(pViewport->MinZ, pViewport->MaxZ); | |
| checkGLcall("glDepthRange"); | |
| /* Note: GL requires lower left, DirectX supplies upper left */ | |
| /* TODO: replace usage of renderTarget with context management */ | |
| glViewport(pViewport->X, | |
| (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height - (pViewport->Y + pViewport->Height)), | |
| pViewport->Width, pViewport->Height); | |
| checkGLcall("glViewport"); | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetViewport(IWineD3DDevice *iface, WINED3DVIEWPORT* pViewport) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p)\n", This); | |
| memcpy(pViewport, &This->stateBlock->viewport, sizeof(WINED3DVIEWPORT)); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Render States | |
| * TODO: Verify against dx9 definitions | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetRenderState(IWineD3DDevice *iface, D3DRENDERSTATETYPE State, DWORD Value) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| DWORD OldValue = This->stateBlock->renderState[State]; | |
| /* Simple way of referring to either a DWORD or a 4 byte float */ | |
| union { | |
| DWORD d; | |
| float f; | |
| } tmpvalue; | |
| TRACE("(%p)->state = %s(%d), value = %ld\n", This, debug_d3drenderstate(State), State, Value); | |
| This->updateStateBlock->changed.renderState[State] = TRUE; | |
| This->updateStateBlock->set.renderState[State] = TRUE; | |
| This->updateStateBlock->renderState[State] = Value; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| ENTER_GL(); | |
| switch (State) { | |
| case WINED3DRS_FILLMODE : | |
| switch ((D3DFILLMODE) Value) { | |
| case D3DFILL_POINT : glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); break; | |
| case D3DFILL_WIREFRAME : glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break; | |
| case D3DFILL_SOLID : glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break; | |
| default: | |
| FIXME("Unrecognized WINED3DRS_FILLMODE value %ld\n", Value); | |
| } | |
| checkGLcall("glPolygonMode (fillmode)"); | |
| break; | |
| case WINED3DRS_LIGHTING : | |
| if (Value) { | |
| glEnable(GL_LIGHTING); | |
| checkGLcall("glEnable GL_LIGHTING"); | |
| } else { | |
| glDisable(GL_LIGHTING); | |
| checkGLcall("glDisable GL_LIGHTING"); | |
| } | |
| break; | |
| case WINED3DRS_ZENABLE : | |
| switch ((D3DZBUFFERTYPE) Value) { | |
| case D3DZB_FALSE: | |
| glDisable(GL_DEPTH_TEST); | |
| checkGLcall("glDisable GL_DEPTH_TEST"); | |
| break; | |
| case D3DZB_TRUE: | |
| glEnable(GL_DEPTH_TEST); | |
| checkGLcall("glEnable GL_DEPTH_TEST"); | |
| break; | |
| case D3DZB_USEW: | |
| glEnable(GL_DEPTH_TEST); | |
| checkGLcall("glEnable GL_DEPTH_TEST"); | |
| FIXME("W buffer is not well handled\n"); | |
| break; | |
| default: | |
| FIXME("Unrecognized D3DZBUFFERTYPE value %ld\n", Value); | |
| } | |
| break; | |
| case WINED3DRS_CULLMODE : | |
| /* If we are culling "back faces with clockwise vertices" then | |
| set front faces to be counter clockwise and enable culling | |
| of back faces */ | |
| switch ((D3DCULL) Value) { | |
| case D3DCULL_NONE: | |
| glDisable(GL_CULL_FACE); | |
| checkGLcall("glDisable GL_CULL_FACE"); | |
| break; | |
| case D3DCULL_CW: | |
| glEnable(GL_CULL_FACE); | |
| checkGLcall("glEnable GL_CULL_FACE"); | |
| if (This->renderUpsideDown) { | |
| glFrontFace(GL_CW); | |
| checkGLcall("glFrontFace GL_CW"); | |
| } else { | |
| glFrontFace(GL_CCW); | |
| checkGLcall("glFrontFace GL_CCW"); | |
| } | |
| glCullFace(GL_BACK); | |
| break; | |
| case D3DCULL_CCW: | |
| glEnable(GL_CULL_FACE); | |
| checkGLcall("glEnable GL_CULL_FACE"); | |
| if (This->renderUpsideDown) { | |
| glFrontFace(GL_CCW); | |
| checkGLcall("glFrontFace GL_CCW"); | |
| } else { | |
| glFrontFace(GL_CW); | |
| checkGLcall("glFrontFace GL_CW"); | |
| } | |
| glCullFace(GL_BACK); | |
| break; | |
| default: | |
| FIXME("Unrecognized/Unhandled D3DCULL value %ld\n", Value); | |
| } | |
| break; | |
| case WINED3DRS_SHADEMODE : | |
| switch ((D3DSHADEMODE) Value) { | |
| case D3DSHADE_FLAT: | |
| glShadeModel(GL_FLAT); | |
| checkGLcall("glShadeModel"); | |
| break; | |
| case D3DSHADE_GOURAUD: | |
| glShadeModel(GL_SMOOTH); | |
| checkGLcall("glShadeModel"); | |
| break; | |
| case D3DSHADE_PHONG: | |
| FIXME("D3DSHADE_PHONG isn't supported?\n"); | |
| LEAVE_GL(); | |
| return D3DERR_INVALIDCALL; | |
| default: | |
| FIXME("Unrecognized/Unhandled D3DSHADEMODE value %ld\n", Value); | |
| } | |
| break; | |
| case WINED3DRS_DITHERENABLE : | |
| if (Value) { | |
| glEnable(GL_DITHER); | |
| checkGLcall("glEnable GL_DITHER"); | |
| } else { | |
| glDisable(GL_DITHER); | |
| checkGLcall("glDisable GL_DITHER"); | |
| } | |
| break; | |
| case WINED3DRS_ZWRITEENABLE : | |
| if (Value) { | |
| glDepthMask(1); | |
| checkGLcall("glDepthMask"); | |
| } else { | |
| glDepthMask(0); | |
| checkGLcall("glDepthMask"); | |
| } | |
| break; | |
| case WINED3DRS_ZFUNC : | |
| { | |
| int glParm = GL_LESS; | |
| switch ((D3DCMPFUNC) Value) { | |
| case D3DCMP_NEVER: glParm=GL_NEVER; break; | |
| case D3DCMP_LESS: glParm=GL_LESS; break; | |
| case D3DCMP_EQUAL: glParm=GL_EQUAL; break; | |
| case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break; | |
| case D3DCMP_GREATER: glParm=GL_GREATER; break; | |
| case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break; | |
| case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break; | |
| case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break; | |
| default: | |
| FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value); | |
| } | |
| glDepthFunc(glParm); | |
| checkGLcall("glDepthFunc"); | |
| } | |
| break; | |
| case WINED3DRS_AMBIENT : | |
| { | |
| float col[4]; | |
| D3DCOLORTOGLFLOAT4(Value, col); | |
| TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]); | |
| glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col); | |
| checkGLcall("glLightModel for MODEL_AMBIENT"); | |
| } | |
| break; | |
| case WINED3DRS_ALPHABLENDENABLE : | |
| if (Value) { | |
| glEnable(GL_BLEND); | |
| checkGLcall("glEnable GL_BLEND"); | |
| } else { | |
| glDisable(GL_BLEND); | |
| checkGLcall("glDisable GL_BLEND"); | |
| }; | |
| break; | |
| case WINED3DRS_SRCBLEND : | |
| case WINED3DRS_DESTBLEND : | |
| { | |
| int newVal = GL_ZERO; | |
| switch (Value) { | |
| case D3DBLEND_ZERO : newVal = GL_ZERO; break; | |
| case D3DBLEND_ONE : newVal = GL_ONE; break; | |
| case D3DBLEND_SRCCOLOR : newVal = GL_SRC_COLOR; break; | |
| case D3DBLEND_INVSRCCOLOR : newVal = GL_ONE_MINUS_SRC_COLOR; break; | |
| case D3DBLEND_SRCALPHA : newVal = GL_SRC_ALPHA; break; | |
| case D3DBLEND_INVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA; break; | |
| case D3DBLEND_DESTALPHA : newVal = GL_DST_ALPHA; break; | |
| case D3DBLEND_INVDESTALPHA : newVal = GL_ONE_MINUS_DST_ALPHA; break; | |
| case D3DBLEND_DESTCOLOR : newVal = GL_DST_COLOR; break; | |
| case D3DBLEND_INVDESTCOLOR : newVal = GL_ONE_MINUS_DST_COLOR; break; | |
| case D3DBLEND_SRCALPHASAT : newVal = GL_SRC_ALPHA_SATURATE; break; | |
| case D3DBLEND_BOTHSRCALPHA : newVal = GL_SRC_ALPHA; | |
| This->srcBlend = newVal; | |
| This->dstBlend = newVal; | |
| break; | |
| case D3DBLEND_BOTHINVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA; | |
| This->srcBlend = newVal; | |
| This->dstBlend = newVal; | |
| break; | |
| default: | |
| FIXME("Unrecognized src/dest blend value %ld (%d)\n", Value, State); | |
| } | |
| if (State == WINED3DRS_SRCBLEND) This->srcBlend = newVal; | |
| if (State == WINED3DRS_DESTBLEND) This->dstBlend = newVal; | |
| TRACE("glBlendFunc src=%x, dst=%x\n", This->srcBlend, This->dstBlend); | |
| glBlendFunc(This->srcBlend, This->dstBlend); | |
| checkGLcall("glBlendFunc"); | |
| } | |
| break; | |
| case WINED3DRS_ALPHATESTENABLE : | |
| if (Value) { | |
| glEnable(GL_ALPHA_TEST); | |
| checkGLcall("glEnable GL_ALPHA_TEST"); | |
| } else { | |
| glDisable(GL_ALPHA_TEST); | |
| checkGLcall("glDisable GL_ALPHA_TEST"); | |
| } | |
| break; | |
| case WINED3DRS_ALPHAFUNC : | |
| { | |
| int glParm = GL_LESS; | |
| float ref = ((float) This->stateBlock->renderState[WINED3DRS_ALPHAREF]) / 255.0f; | |
| switch ((D3DCMPFUNC) Value) { | |
| case D3DCMP_NEVER: glParm = GL_NEVER; break; | |
| case D3DCMP_LESS: glParm = GL_LESS; break; | |
| case D3DCMP_EQUAL: glParm = GL_EQUAL; break; | |
| case D3DCMP_LESSEQUAL: glParm = GL_LEQUAL; break; | |
| case D3DCMP_GREATER: glParm = GL_GREATER; break; | |
| case D3DCMP_NOTEQUAL: glParm = GL_NOTEQUAL; break; | |
| case D3DCMP_GREATEREQUAL: glParm = GL_GEQUAL; break; | |
| case D3DCMP_ALWAYS: glParm = GL_ALWAYS; break; | |
| default: | |
| FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value); | |
| } | |
| TRACE("glAlphaFunc with Parm=%x, ref=%f\n", glParm, ref); | |
| glAlphaFunc(glParm, ref); | |
| This->alphafunc = glParm; | |
| checkGLcall("glAlphaFunc"); | |
| } | |
| break; | |
| case WINED3DRS_ALPHAREF : | |
| { | |
| int glParm = This->alphafunc; | |
| float ref = 1.0f; | |
| ref = ((float) Value) / 255.0f; | |
| TRACE("glAlphaFunc with Parm=%x, ref=%f\n", glParm, ref); | |
| glAlphaFunc(glParm, ref); | |
| checkGLcall("glAlphaFunc"); | |
| } | |
| break; | |
| case WINED3DRS_CLIPPLANEENABLE : | |
| case WINED3DRS_CLIPPING : | |
| { | |
| /* Ensure we only do the changed clip planes */ | |
| DWORD enable = 0xFFFFFFFF; | |
| DWORD disable = 0x00000000; | |
| /* If enabling / disabling all */ | |
| if (State == WINED3DRS_CLIPPING) { | |
| if (Value) { | |
| enable = This->stateBlock->renderState[WINED3DRS_CLIPPLANEENABLE]; | |
| disable = 0x00; | |
| } else { | |
| disable = This->stateBlock->renderState[WINED3DRS_CLIPPLANEENABLE]; | |
| enable = 0x00; | |
| } | |
| } else { | |
| enable = Value & ~OldValue; | |
| disable = ~Value & OldValue; | |
| } | |
| if (enable & D3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); } | |
| if (enable & D3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); } | |
| if (enable & D3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); } | |
| if (enable & D3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); } | |
| if (enable & D3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); } | |
| if (enable & D3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); } | |
| if (disable & D3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); } | |
| if (disable & D3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); } | |
| if (disable & D3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); } | |
| if (disable & D3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); } | |
| if (disable & D3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); } | |
| if (disable & D3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); } | |
| /** update clipping status */ | |
| if (enable) { | |
| This->stateBlock->clip_status.ClipUnion = 0; | |
| This->stateBlock->clip_status.ClipIntersection = 0xFFFFFFFF; | |
| } else { | |
| This->stateBlock->clip_status.ClipUnion = 0; | |
| This->stateBlock->clip_status.ClipIntersection = 0; | |
| } | |
| } | |
| break; | |
| case WINED3DRS_BLENDOP : | |
| { | |
| int glParm = GL_FUNC_ADD; | |
| switch ((D3DBLENDOP) Value) { | |
| case D3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break; | |
| case D3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break; | |
| case D3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break; | |
| case D3DBLENDOP_MIN : glParm = GL_MIN; break; | |
| case D3DBLENDOP_MAX : glParm = GL_MAX; break; | |
| default: | |
| FIXME("Unrecognized/Unhandled D3DBLENDOP value %ld\n", Value); | |
| } | |
| TRACE("glBlendEquation(%x)\n", glParm); | |
| glBlendEquation(glParm); | |
| checkGLcall("glBlendEquation"); | |
| } | |
| break; | |
| case WINED3DRS_TEXTUREFACTOR : | |
| { | |
| unsigned int i; | |
| /* Note the texture color applies to all textures whereas | |
| GL_TEXTURE_ENV_COLOR applies to active only */ | |
| float col[4]; | |
| D3DCOLORTOGLFLOAT4(Value, col); | |
| /* Set the default alpha blend color */ | |
| glBlendColor(col[0], col[1], col[2], col[3]); | |
| checkGLcall("glBlendColor"); | |
| /* And now the default texture color as well */ | |
| for (i = 0; i < GL_LIMITS(textures); i++) { | |
| /* Note the D3DRS value applies to all textures, but GL has one | |
| per texture, so apply it now ready to be used! */ | |
| if (GL_SUPPORT(ARB_MULTITEXTURE)) { | |
| GLACTIVETEXTURE(i); | |
| } else if (i>0) { | |
| FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n"); | |
| } | |
| glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]); | |
| checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);"); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_SPECULARENABLE : | |
| { | |
| /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR) | |
| and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled | |
| specular color. This is wrong: | |
| Separate specular color means the specular colour is maintained separately, whereas | |
| single color means it is merged in. However in both cases they are being used to | |
| some extent. | |
| To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT | |
| NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are | |
| running 1.4 yet! | |
| */ | |
| if (Value) { | |
| glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &This->updateStateBlock->material.Specular); | |
| checkGLcall("glMaterialfv"); | |
| if (GL_SUPPORT(EXT_SECONDARY_COLOR)) { | |
| glEnable(GL_COLOR_SUM_EXT); | |
| } else { | |
| TRACE("Specular colors cannot be enabled in this version of opengl\n"); | |
| } | |
| checkGLcall("glEnable(GL_COLOR_SUM)"); | |
| } else { | |
| float black[4] = {0.0f, 0.0f, 0.0f, 0.0f}; | |
| /* for the case of enabled lighting: */ | |
| glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]); | |
| checkGLcall("glMaterialfv"); | |
| /* for the case of disabled lighting: */ | |
| if (GL_SUPPORT(EXT_SECONDARY_COLOR)) { | |
| glDisable(GL_COLOR_SUM_EXT); | |
| } else { | |
| TRACE("Specular colors cannot be disabled in this version of opengl\n"); | |
| } | |
| checkGLcall("glDisable(GL_COLOR_SUM)"); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_STENCILENABLE : | |
| if (Value) { | |
| glEnable(GL_STENCIL_TEST); | |
| checkGLcall("glEnable GL_STENCIL_TEST"); | |
| } else { | |
| glDisable(GL_STENCIL_TEST); | |
| checkGLcall("glDisable GL_STENCIL_TEST"); | |
| } | |
| break; | |
| case WINED3DRS_STENCILFUNC : | |
| { | |
| int glParm = GL_ALWAYS; | |
| int ref = This->stateBlock->renderState[WINED3DRS_STENCILREF]; | |
| GLuint mask = This->stateBlock->renderState[WINED3DRS_STENCILMASK]; | |
| switch ((D3DCMPFUNC) Value) { | |
| case D3DCMP_NEVER: glParm=GL_NEVER; break; | |
| case D3DCMP_LESS: glParm=GL_LESS; break; | |
| case D3DCMP_EQUAL: glParm=GL_EQUAL; break; | |
| case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break; | |
| case D3DCMP_GREATER: glParm=GL_GREATER; break; | |
| case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break; | |
| case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break; | |
| case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break; | |
| default: | |
| FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value); | |
| } | |
| TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask); | |
| This->stencilfunc = glParm; | |
| glStencilFunc(glParm, ref, mask); | |
| checkGLcall("glStencilFunc"); | |
| } | |
| break; | |
| case WINED3DRS_STENCILREF : | |
| { | |
| int glParm = This->stencilfunc; | |
| int ref = 0; | |
| GLuint mask = This->stateBlock->renderState[WINED3DRS_STENCILMASK]; | |
| ref = Value; | |
| TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask); | |
| glStencilFunc(glParm, ref, mask); | |
| checkGLcall("glStencilFunc"); | |
| } | |
| break; | |
| case WINED3DRS_STENCILMASK : | |
| { | |
| int glParm = This->stencilfunc; | |
| int ref = This->stateBlock->renderState[WINED3DRS_STENCILREF]; | |
| GLuint mask = Value; | |
| TRACE("glStencilFunc with Parm=%x, ref=%d, mask=%x\n", glParm, ref, mask); | |
| glStencilFunc(glParm, ref, mask); | |
| checkGLcall("glStencilFunc"); | |
| } | |
| break; | |
| case WINED3DRS_STENCILFAIL : | |
| { | |
| GLenum fail ; | |
| GLenum zpass ; | |
| GLenum zfail ; | |
| fail = StencilOp(Value); | |
| glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass); | |
| checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass);"); | |
| glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail); | |
| checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail);"); | |
| TRACE("StencilOp fail=%x, zfail=%x, zpass=%x\n", fail, zfail, zpass); | |
| glStencilOp(fail, zfail, zpass); | |
| checkGLcall("glStencilOp(fail, zfail, zpass);"); | |
| } | |
| break; | |
| case WINED3DRS_STENCILZFAIL : | |
| { | |
| GLenum fail ; | |
| GLenum zpass ; | |
| GLenum zfail ; | |
| glGetIntegerv(GL_STENCIL_FAIL, &fail); | |
| checkGLcall("glGetIntegerv(GL_STENCIL_FAIL, &fail);"); | |
| glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass); | |
| checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &zpass);"); | |
| zfail = StencilOp(Value); | |
| TRACE("StencilOp fail=%x, zfail=%x, zpass=%x\n", fail, zfail, zpass); | |
| glStencilOp(fail, zfail, zpass); | |
| checkGLcall("glStencilOp(fail, zfail, zpass);"); | |
| } | |
| break; | |
| case WINED3DRS_STENCILPASS : | |
| { | |
| GLenum fail ; | |
| GLenum zpass ; | |
| GLenum zfail ; | |
| glGetIntegerv(GL_STENCIL_FAIL, &fail); | |
| checkGLcall("glGetIntegerv(GL_STENCIL_FAIL, &fail);"); | |
| zpass = StencilOp(Value); | |
| glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail); | |
| checkGLcall("glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &zfail);"); | |
| TRACE("StencilOp fail=%x, zfail=%x, zpass=%x\n", fail, zfail, zpass); | |
| glStencilOp(fail, zfail, zpass); | |
| checkGLcall("glStencilOp(fail, zfail, zpass);"); | |
| } | |
| break; | |
| case WINED3DRS_STENCILWRITEMASK : | |
| { | |
| glStencilMask(Value); | |
| TRACE("glStencilMask(%lu)\n", Value); | |
| checkGLcall("glStencilMask"); | |
| } | |
| break; | |
| case WINED3DRS_FOGENABLE : | |
| { | |
| if (Value/* && This->stateBlock->renderState[WINED3DRS_FOGTABLEMODE] != D3DFOG_NONE*/) { | |
| glEnable(GL_FOG); | |
| checkGLcall("glEnable GL_FOG"); | |
| } else { | |
| glDisable(GL_FOG); | |
| checkGLcall("glDisable GL_FOG"); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_RANGEFOGENABLE : | |
| { | |
| if (Value) { | |
| TRACE("Enabled RANGEFOG"); | |
| } else { | |
| TRACE("Disabled RANGEFOG"); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_FOGCOLOR : | |
| { | |
| float col[4]; | |
| D3DCOLORTOGLFLOAT4(Value, col); | |
| /* Set the default alpha blend color */ | |
| glFogfv(GL_FOG_COLOR, &col[0]); | |
| checkGLcall("glFog GL_FOG_COLOR"); | |
| } | |
| break; | |
| case WINED3DRS_FOGTABLEMODE : | |
| { | |
| glHint(GL_FOG_HINT, GL_NICEST); | |
| switch (Value) { | |
| case D3DFOG_NONE: /* I don't know what to do here */ checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break; | |
| case D3DFOG_EXP: glFogi(GL_FOG_MODE, GL_EXP); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break; | |
| case D3DFOG_EXP2: glFogi(GL_FOG_MODE, GL_EXP2); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2"); break; | |
| case D3DFOG_LINEAR: glFogi(GL_FOG_MODE, GL_LINEAR); checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR"); break; | |
| default: | |
| FIXME("Unsupported Value(%lu) for WINED3DRS_FOGTABLEMODE!\n", Value); | |
| } | |
| if (GL_SUPPORT(NV_FOG_DISTANCE)) { | |
| glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_FOGVERTEXMODE : | |
| { | |
| glHint(GL_FOG_HINT, GL_FASTEST); | |
| switch (Value) { | |
| case D3DFOG_NONE: /* I don't know what to do here */ checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break; | |
| case D3DFOG_EXP: glFogi(GL_FOG_MODE, GL_EXP); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break; | |
| case D3DFOG_EXP2: glFogi(GL_FOG_MODE, GL_EXP2); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2"); break; | |
| case D3DFOG_LINEAR: glFogi(GL_FOG_MODE, GL_LINEAR); checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR"); break; | |
| default: | |
| FIXME("Unsupported Value(%lu) for WINED3DRS_FOGTABLEMODE!\n", Value); | |
| } | |
| if (GL_SUPPORT(NV_FOG_DISTANCE)) { | |
| glFogi(GL_FOG_DISTANCE_MODE_NV, This->stateBlock->renderState[WINED3DRS_RANGEFOGENABLE] ? GL_EYE_RADIAL_NV : GL_EYE_PLANE_ABSOLUTE_NV); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_FOGSTART : | |
| { | |
| tmpvalue.d = Value; | |
| glFogfv(GL_FOG_START, &tmpvalue.f); | |
| checkGLcall("glFogf(GL_FOG_START, (float) Value)"); | |
| TRACE("Fog Start == %f\n", tmpvalue.f); | |
| } | |
| break; | |
| case WINED3DRS_FOGEND : | |
| { | |
| tmpvalue.d = Value; | |
| glFogfv(GL_FOG_END, &tmpvalue.f); | |
| checkGLcall("glFogf(GL_FOG_END, (float) Value)"); | |
| TRACE("Fog End == %f\n", tmpvalue.f); | |
| } | |
| break; | |
| case WINED3DRS_FOGDENSITY : | |
| { | |
| tmpvalue.d = Value; | |
| glFogfv(GL_FOG_DENSITY, &tmpvalue.f); | |
| checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)"); | |
| } | |
| break; | |
| case WINED3DRS_VERTEXBLEND : | |
| { | |
| This->updateStateBlock->vertex_blend = (D3DVERTEXBLENDFLAGS) Value; | |
| TRACE("Vertex Blending state to %ld\n", Value); | |
| } | |
| break; | |
| case WINED3DRS_TWEENFACTOR : | |
| { | |
| tmpvalue.d = Value; | |
| This->updateStateBlock->tween_factor = tmpvalue.f; | |
| TRACE("Vertex Blending Tween Factor to %f\n", This->updateStateBlock->tween_factor); | |
| } | |
| break; | |
| case WINED3DRS_INDEXEDVERTEXBLENDENABLE : | |
| { | |
| TRACE("Indexed Vertex Blend Enable to %ul\n", (BOOL) Value); | |
| } | |
| break; | |
| case WINED3DRS_COLORVERTEX : | |
| case WINED3DRS_DIFFUSEMATERIALSOURCE : | |
| case WINED3DRS_SPECULARMATERIALSOURCE : | |
| case WINED3DRS_AMBIENTMATERIALSOURCE : | |
| case WINED3DRS_EMISSIVEMATERIALSOURCE : | |
| { | |
| GLenum Parm = GL_AMBIENT_AND_DIFFUSE; | |
| if (This->stateBlock->renderState[WINED3DRS_COLORVERTEX]) { | |
| TRACE("diff %ld, amb %ld, emis %ld, spec %ld\n", | |
| This->stateBlock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE], | |
| This->stateBlock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE], | |
| This->stateBlock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE], | |
| This->stateBlock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]); | |
| if (This->stateBlock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) { | |
| if (This->stateBlock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) { | |
| Parm = GL_AMBIENT_AND_DIFFUSE; | |
| } else { | |
| Parm = GL_DIFFUSE; | |
| } | |
| } else if (This->stateBlock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) { | |
| Parm = GL_AMBIENT; | |
| } else if (This->stateBlock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) { | |
| Parm = GL_EMISSION; | |
| } else if (This->stateBlock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) { | |
| Parm = GL_SPECULAR; | |
| } else { | |
| Parm = -1; | |
| } | |
| if (Parm == -1) { | |
| if (This->tracking_color != DISABLED_TRACKING) This->tracking_color = NEEDS_DISABLE; | |
| } else { | |
| This->tracking_color = NEEDS_TRACKING; | |
| This->tracking_parm = Parm; | |
| } | |
| } else { | |
| if (This->tracking_color != DISABLED_TRACKING) This->tracking_color = NEEDS_DISABLE; | |
| } | |
| } | |
| break; | |
| case WINED3DRS_LINEPATTERN : | |
| { | |
| union { | |
| DWORD d; | |
| D3DLINEPATTERN lp; | |
| } tmppattern; | |
| tmppattern.d = Value; | |
| TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern); | |
| if (tmppattern.lp.wRepeatFactor) { | |
| glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern); | |
| checkGLcall("glLineStipple(repeat, linepattern)"); | |
| glEnable(GL_LINE_STIPPLE); | |
| checkGLcall("glEnable(GL_LINE_STIPPLE);"); | |
| } else { | |
| glDisable(GL_LINE_STIPPLE); | |
| checkGLcall("glDisable(GL_LINE_STIPPLE);"); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_ZBIAS : | |
| { | |
| if (Value) { | |
| tmpvalue.d = Value; | |
| TRACE("ZBias value %f\n", tmpvalue.f); | |
| glPolygonOffset(0, -tmpvalue.f); | |
| checkGLcall("glPolygonOffset(0, -Value)"); | |
| glEnable(GL_POLYGON_OFFSET_FILL); | |
| checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);"); | |
| glEnable(GL_POLYGON_OFFSET_LINE); | |
| checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);"); | |
| glEnable(GL_POLYGON_OFFSET_POINT); | |
| checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);"); | |
| } else { | |
| glDisable(GL_POLYGON_OFFSET_FILL); | |
| checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);"); | |
| glDisable(GL_POLYGON_OFFSET_LINE); | |
| checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);"); | |
| glDisable(GL_POLYGON_OFFSET_POINT); | |
| checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);"); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_NORMALIZENORMALS : | |
| if (Value) { | |
| glEnable(GL_NORMALIZE); | |
| checkGLcall("glEnable(GL_NORMALIZE);"); | |
| } else { | |
| glDisable(GL_NORMALIZE); | |
| checkGLcall("glDisable(GL_NORMALIZE);"); | |
| } | |
| break; | |
| case WINED3DRS_POINTSIZE : | |
| tmpvalue.d = Value; | |
| TRACE("Set point size to %f\n", tmpvalue.f); | |
| glPointSize(tmpvalue.f); | |
| checkGLcall("glPointSize(...);"); | |
| break; | |
| case WINED3DRS_POINTSIZE_MIN : | |
| if (GL_SUPPORT(EXT_POINT_PARAMETERS)) { | |
| tmpvalue.d = Value; | |
| GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f); | |
| checkGLcall("glPointParameterfEXT(...);"); | |
| } else { | |
| FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl\n"); | |
| } | |
| break; | |
| case WINED3DRS_POINTSIZE_MAX : | |
| if (GL_SUPPORT(EXT_POINT_PARAMETERS)) { | |
| tmpvalue.d = Value; | |
| GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f); | |
| checkGLcall("glPointParameterfEXT(...);"); | |
| } else { | |
| FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl\n"); | |
| } | |
| break; | |
| case WINED3DRS_POINTSCALE_A : | |
| case WINED3DRS_POINTSCALE_B : | |
| case WINED3DRS_POINTSCALE_C : | |
| case WINED3DRS_POINTSCALEENABLE : | |
| { | |
| /* If enabled, supply the parameters, otherwise fall back to defaults */ | |
| if (This->stateBlock->renderState[WINED3DRS_POINTSCALEENABLE]) { | |
| GLfloat att[3] = {1.0f, 0.0f, 0.0f}; | |
| att[0] = *((float*)&This->stateBlock->renderState[WINED3DRS_POINTSCALE_A]); | |
| att[1] = *((float*)&This->stateBlock->renderState[WINED3DRS_POINTSCALE_B]); | |
| att[2] = *((float*)&This->stateBlock->renderState[WINED3DRS_POINTSCALE_C]); | |
| if (GL_SUPPORT(EXT_POINT_PARAMETERS)) { | |
| GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att); | |
| checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...);"); | |
| } else { | |
| TRACE("WINED3DRS_POINTSCALEENABLE not supported on this opengl\n"); | |
| } | |
| } else { | |
| GLfloat att[3] = {1.0f, 0.0f, 0.0f}; | |
| if (GL_SUPPORT(EXT_POINT_PARAMETERS)) { | |
| GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att); | |
| checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...);"); | |
| } else { | |
| TRACE("WINED3DRS_POINTSCALEENABLE not supported, but not on either\n"); | |
| } | |
| } | |
| break; | |
| } | |
| case WINED3DRS_COLORWRITEENABLE : | |
| { | |
| TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n", | |
| Value & D3DCOLORWRITEENABLE_RED ? 1 : 0, | |
| Value & D3DCOLORWRITEENABLE_GREEN ? 1 : 0, | |
| Value & D3DCOLORWRITEENABLE_BLUE ? 1 : 0, | |
| Value & D3DCOLORWRITEENABLE_ALPHA ? 1 : 0); | |
| glColorMask(Value & D3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE, | |
| Value & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE, | |
| Value & D3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE, | |
| Value & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE); | |
| checkGLcall("glColorMask(...)"); | |
| } | |
| break; | |
| case WINED3DRS_LOCALVIEWER : | |
| { | |
| GLint state = (Value) ? 1 : 0; | |
| TRACE("Local Viewer Enable to %ul\n", (BOOL) Value); | |
| glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, state); | |
| } | |
| break; | |
| case WINED3DRS_LASTPIXEL : | |
| { | |
| if (Value) { | |
| TRACE("Last Pixel Drawing Enabled\n"); | |
| } else { | |
| FIXME("Last Pixel Drawing Disabled, not handled yet\n"); | |
| } | |
| } | |
| break; | |
| case WINED3DRS_SOFTWAREVERTEXPROCESSING : | |
| { | |
| if (Value) { | |
| TRACE("Software Processing Enabled\n"); | |
| } else { | |
| TRACE("Software Processing Disabled\n"); | |
| } | |
| } | |
| break; | |
| /** not supported */ | |
| case WINED3DRS_ZVISIBLE : | |
| { | |
| LEAVE_GL(); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| /* Unhandled yet...! */ | |
| case WINED3DRS_EDGEANTIALIAS : | |
| case WINED3DRS_WRAP0 : | |
| case WINED3DRS_WRAP1 : | |
| case WINED3DRS_WRAP2 : | |
| case WINED3DRS_WRAP3 : | |
| case WINED3DRS_WRAP4 : | |
| case WINED3DRS_WRAP5 : | |
| case WINED3DRS_WRAP6 : | |
| case WINED3DRS_WRAP7 : | |
| case WINED3DRS_POINTSPRITEENABLE : | |
| case WINED3DRS_MULTISAMPLEANTIALIAS : | |
| case WINED3DRS_MULTISAMPLEMASK : | |
| case WINED3DRS_PATCHEDGESTYLE : | |
| case WINED3DRS_PATCHSEGMENTS : | |
| case WINED3DRS_DEBUGMONITORTOKEN : | |
| case WINED3DRS_POSITIONORDER : | |
| case WINED3DRS_NORMALORDER : | |
| /*Put back later: FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value); */ | |
| FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value); | |
| break; | |
| default: | |
| FIXME("(%p)->(%d,%ld) unrecognized\n", This, State, Value); | |
| } | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetRenderState(IWineD3DDevice *iface, D3DRENDERSTATETYPE State, DWORD *pValue) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) for State %d = %ld\n", This, State, This->stateBlock->renderState[State]); | |
| *pValue = This->stateBlock->renderState[State]; | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD Value) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /** | |
| * SetSampler is designed to allow for more than the standard up to 8 textures | |
| * and Geforce has stopped supporting more than 6 standard textures in openGL. | |
| * So I have to use ARB for Gforce. (maybe if the sampler > 4 then use ARB?) | |
| * | |
| * http://developer.nvidia.com/object/General_FAQ.html#t6 | |
| * | |
| * There are two new settings for GForce | |
| * the sampler one: | |
| * GL_MAX_TEXTURE_IMAGE_UNITS_ARB | |
| * and the texture one: | |
| * GL_MAX_TEXTURE_COORDS_ARB. | |
| * Ok GForce say it's ok to use glTexParameter/glGetTexParameter(...). | |
| ******************/ | |
| union { | |
| float f; | |
| DWORD d; | |
| } tmpvalue; | |
| TRACE("(%p) Sampler(%ld), Type(%d) Value(%ld)\n",This, Sampler ,Type, Value); | |
| if(Sampler > GL_LIMITS(samplers) || Sampler < 0 || Type > HIGHEST_SAMPLER_STATE || Type < 0) { | |
| FIXME("out of range %d %d sampler %ld type %u\n", GL_LIMITS(samplers), HIGHEST_SAMPLER_STATE, Sampler, Type); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| This->updateStateBlock->changed.samplerState[Sampler][Type] = TRUE; | |
| This->updateStateBlock->set.samplerState[Sampler][Type] = TRUE; | |
| TRACE("Setting sampler %ld %d to %ld \n", Sampler, Type, Value); | |
| This->updateStateBlock->samplerState[Sampler][Type] = Value; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| /* In addition, IDirect3DDevice9::SetSamplerState will now be used for filtering, tiling, | |
| clamping, MIPLOD, etc. This will work for up to 16 samplers. | |
| is this just GL_TEXTURE_2D or is it GL_TEXTURE_1D and GL_TEXTURE_3D as well? | |
| */ | |
| ENTER_GL(); | |
| VTRACE(("Activating appropriate texture state %ld\n", Sampler)); | |
| if (GL_SUPPORT(ARB_MULTITEXTURE)) { | |
| GLACTIVETEXTURE(Sampler); | |
| } else if (Sampler > 0) { | |
| FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n"); | |
| } | |
| switch (Type) { | |
| case WINED3DSAMP_ADDRESSU : /* 1 */ | |
| case WINED3DSAMP_ADDRESSV : /* 2 */ | |
| case WINED3DSAMP_ADDRESSW : /* 3 */ | |
| { | |
| GLint wrapParm = GL_REPEAT; | |
| switch (Value) { | |
| case D3DTADDRESS_WRAP: wrapParm = GL_REPEAT; break; | |
| case D3DTADDRESS_CLAMP: wrapParm = GL_CLAMP_TO_EDGE; break; | |
| case D3DTADDRESS_BORDER: | |
| { | |
| if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) { | |
| wrapParm = GL_CLAMP_TO_BORDER_ARB; | |
| } else { | |
| /* FIXME: Not right, but better */ | |
| TRACE("Unrecognized or unsupported D3DTADDRESS_* value %ld, state %d\n", Value, Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| } | |
| break; | |
| case D3DTADDRESS_MIRROR: | |
| { | |
| if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) { | |
| wrapParm = GL_MIRRORED_REPEAT_ARB; | |
| } else { | |
| /* Unsupported in OpenGL pre-1.4 */ | |
| TRACE("Unsupported D3DTADDRESS_MIRROR (needs GL_ARB_texture_mirrored_repeat) state %d\n", Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| } | |
| break; | |
| case D3DTADDRESS_MIRRORONCE: | |
| { | |
| if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) { | |
| wrapParm = GL_MIRROR_CLAMP_TO_EDGE_ATI; | |
| } else { | |
| TRACE("Unsupported D3DTADDRESS_MIRRORONCE (needs GL_ATI_texture_mirror_once) state %d\n", Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| } | |
| break; | |
| default: | |
| /* This is for the whole context, not just the sampler, | |
| so we should warn if two states are baing set for any given scene */ | |
| if (Type!=0) | |
| TRACE("Unrecognized or unsupported D3DTADDRESS_* value %ld, state %d\n", Value, Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| switch (Type) { | |
| case WINED3DSAMP_ADDRESSU: | |
| TRACE("Setting WRAP_S for %ld to %d \n", Sampler, wrapParm); | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], GL_TEXTURE_WRAP_S, wrapParm); | |
| checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_S, wrapParm)"); | |
| break; | |
| case WINED3DSAMP_ADDRESSV: | |
| TRACE("Setting WRAP_T for %ld to %d\n", Sampler, wrapParm); | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], GL_TEXTURE_WRAP_T, wrapParm); | |
| checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_T, wrapParm)"); | |
| break; | |
| case WINED3DSAMP_ADDRESSW: | |
| TRACE("Setting WRAP_R for %ld to %d\n", Sampler, wrapParm); | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], GL_TEXTURE_WRAP_R, wrapParm); | |
| checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_R, wrapParm)"); | |
| break; | |
| default: /* nop */ | |
| break; /** stupic compilator */ | |
| } | |
| } | |
| break; | |
| case WINED3DSAMP_BORDERCOLOR : /* 4 */ | |
| { | |
| float col[4]; | |
| D3DCOLORTOGLFLOAT4(Value, col); | |
| TRACE("Setting border color for %ld to %lx\n", Sampler, Value); | |
| glTexParameterfv(This->stateBlock->textureDimensions[Sampler], GL_TEXTURE_BORDER_COLOR, &col[0]); | |
| checkGLcall("glTexParameteri(..., GL_TEXTURE_BORDER_COLOR, ...)"); | |
| } | |
| break; | |
| case WINED3DSAMP_MAGFILTER : /* 5 */ | |
| { | |
| DWORD ValueMAG = This->stateBlock->samplerState[Sampler][WINED3DSAMP_MAGFILTER]; | |
| GLint realVal = GL_NEAREST; | |
| if (ValueMAG == D3DTEXF_POINT) { | |
| realVal = GL_NEAREST; | |
| } else if (ValueMAG == D3DTEXF_LINEAR) { | |
| realVal = GL_LINEAR; | |
| } else if (ValueMAG == D3DTEXF_ANISOTROPIC) { | |
| if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) { | |
| realVal = GL_LINEAR; | |
| } else { | |
| FIXME("Trying to use ANISOTROPIC_FILTERING for WINED3DTSS_MAGFILTER. But not supported by current OpenGL driver\n"); | |
| realVal = GL_NEAREST; | |
| } | |
| } else { | |
| FIXME("Unhandled WINED3DTSS_MAGFILTER value of %ld\n", ValueMAG); | |
| realVal = GL_NEAREST; | |
| } | |
| TRACE("ValueMAG=%ld setting MAGFILTER to %x\n", ValueMAG, realVal); | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], GL_TEXTURE_MAG_FILTER, realVal); | |
| checkGLcall("glTexParameter GL_TEXTURE_MAG_FILTER, ..."); | |
| /** | |
| * if we juste choose to use ANISOTROPIC filtering, refresh openGL state | |
| */ | |
| if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC) && D3DTEXF_ANISOTROPIC == ValueMAG) { | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], | |
| GL_TEXTURE_MAX_ANISOTROPY_EXT, | |
| This->stateBlock->samplerState[Sampler][WINED3DSAMP_MAXANISOTROPY]); | |
| checkGLcall("glTexParameter GL_TEXTURE_MAX_ANISOTROPY_EXT, ..."); | |
| } | |
| } | |
| break; | |
| case WINED3DSAMP_MINFILTER: /* 6 */ | |
| case WINED3DSAMP_MIPFILTER: /* 7 */ | |
| { | |
| DWORD ValueMIN = This->stateBlock->samplerState[Sampler][WINED3DSAMP_MINFILTER]; | |
| DWORD ValueMIP = This->stateBlock->samplerState[Sampler][WINED3DSAMP_MIPFILTER]; | |
| GLint realVal = GL_LINEAR; | |
| if (ValueMIN == D3DTEXF_NONE) { | |
| /* Doesn't really make sense - Windows just seems to disable | |
| mipmapping when this occurs */ | |
| FIXME("Odd - minfilter of none, just disabling mipmaps\n"); | |
| realVal = GL_LINEAR; | |
| } else if (ValueMIN == D3DTEXF_POINT) { | |
| /* GL_NEAREST_* */ | |
| if (ValueMIP == D3DTEXF_NONE) { | |
| realVal = GL_NEAREST; | |
| } else if (ValueMIP == D3DTEXF_POINT) { | |
| realVal = GL_NEAREST_MIPMAP_NEAREST; | |
| } else if (ValueMIP == D3DTEXF_LINEAR) { | |
| realVal = GL_NEAREST_MIPMAP_LINEAR; | |
| } else { | |
| FIXME("Unhandled WINED3DTSS_MIPFILTER value of %ld\n", ValueMIP); | |
| realVal = GL_NEAREST; | |
| } | |
| } else if (ValueMIN == D3DTEXF_LINEAR) { | |
| /* GL_LINEAR_* */ | |
| if (ValueMIP == D3DTEXF_NONE) { | |
| realVal = GL_LINEAR; | |
| } else if (ValueMIP == D3DTEXF_POINT) { | |
| realVal = GL_LINEAR_MIPMAP_NEAREST; | |
| } else if (ValueMIP == D3DTEXF_LINEAR) { | |
| realVal = GL_LINEAR_MIPMAP_LINEAR; | |
| } else { | |
| FIXME("Unhandled WINED3DTSS_MIPFILTER value of %ld\n", ValueMIP); | |
| realVal = GL_LINEAR; | |
| } | |
| } else if (ValueMIN == D3DTEXF_ANISOTROPIC) { | |
| if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) { | |
| if (ValueMIP == D3DTEXF_NONE) { | |
| realVal = GL_LINEAR_MIPMAP_LINEAR; | |
| } else if (ValueMIP == D3DTEXF_POINT) { | |
| realVal = GL_LINEAR_MIPMAP_NEAREST; | |
| } else if (ValueMIP == D3DTEXF_LINEAR) { | |
| realVal = GL_LINEAR_MIPMAP_LINEAR; | |
| } else { | |
| FIXME("Unhandled WINED3DTSS_MIPFILTER value of %ld\n", ValueMIP); | |
| realVal = GL_LINEAR; | |
| } | |
| } else { | |
| WARN("Trying to use ANISOTROPIC_FILTERING for WINED3DTSS_MINFILTER. But not supported by OpenGL driver\n"); | |
| realVal = GL_LINEAR; | |
| } | |
| } else { | |
| FIXME("Unhandled WINED3DTSS_MINFILTER value of %ld\n", ValueMIN); | |
| realVal = GL_LINEAR_MIPMAP_LINEAR; | |
| } | |
| TRACE("ValueMIN=%ld, ValueMIP=%ld, setting MINFILTER to %x\n", ValueMIN, ValueMIP, realVal); | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], GL_TEXTURE_MIN_FILTER, realVal); | |
| checkGLcall("glTexParameter GL_TEXTURE_MIN_FILTER, ..."); | |
| /** | |
| * if we just choose to use ANISOTROPIC filtering, refresh openGL state | |
| */ | |
| if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC) && D3DTEXF_ANISOTROPIC == ValueMIN) { | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], GL_TEXTURE_MAX_ANISOTROPY_EXT, | |
| This->stateBlock->samplerState[Sampler][WINED3DSAMP_MAXANISOTROPY]); | |
| checkGLcall("glTexParameter GL_TEXTURE_MAX_ANISOTROPY_EXT, ..."); | |
| } | |
| } | |
| break; | |
| case WINED3DSAMP_MIPMAPLODBIAS : /* 8 */ | |
| { | |
| if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) { | |
| tmpvalue.d = Value; | |
| glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, | |
| GL_TEXTURE_LOD_BIAS_EXT, | |
| tmpvalue.f); | |
| checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ..."); | |
| } | |
| } | |
| break; | |
| case WINED3DSAMP_MAXMIPLEVEL : /* 9 */ | |
| { | |
| /** | |
| * Not really the same, but the more apprioprate than nothing | |
| */ | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], | |
| GL_TEXTURE_BASE_LEVEL, | |
| This->stateBlock->samplerState[Sampler][WINED3DSAMP_MAXMIPLEVEL]); | |
| checkGLcall("glTexParameteri GL_TEXTURE_BASE_LEVEL ..."); | |
| } | |
| break; | |
| case WINED3DSAMP_MAXANISOTROPY : /* 10 */ | |
| { | |
| if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) { | |
| glTexParameteri(This->stateBlock->textureDimensions[Sampler], | |
| GL_TEXTURE_MAX_ANISOTROPY_EXT, | |
| This->stateBlock->samplerState[Sampler][WINED3DSAMP_MAXANISOTROPY]); | |
| checkGLcall("glTexParameteri GL_TEXTURE_MAX_ANISOTROPY_EXT ..."); | |
| } | |
| } | |
| break; | |
| case WINED3DSAMP_SRGBTEXTURE : /* 11 */ | |
| /* Per texture gamma correction, default 0 */ | |
| case WINED3DSAMP_ELEMENTINDEX : /* 12 */ | |
| /* When a multi-element textures is used this indicates the element, (what's a multielement texture?) */ | |
| case WINED3DSAMP_DMAPOFFSET : /* 13 */ | |
| /* Value of a precompiled displacement map used by the tesselator, default 0 */ | |
| TRACE("Unsupported sampler setting, Sampler=%ld, Type=%d, Value =%ld\n", Sampler, Type, Value); | |
| break; | |
| default: | |
| TRACE("invalid sampler setting, Sampler=%ld, Type=%d, Value =%ld\n", Sampler, Type, Value); | |
| }; | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD* Value) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /** TODO: check that sampler is in range **/ | |
| *Value = This->updateStateBlock->samplerState[Sampler][Type]; | |
| TRACE("(%p) : Sampler %ld Type %u Returning %ld\n", This, Sampler, Type, *Value); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetScissorRect(IWineD3DDevice *iface, CONST RECT* pRect) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| ENTER_GL(); | |
| /** FIXME: Windows uses a top,left origin openGL uses a bottom Right? **/ | |
| TRACE("(%p)Setting new Scissor Rect to %ld:%ld-%ld:%ld\n", This, pRect->left, pRect->top, pRect->right, pRect->bottom); | |
| glScissor(pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top); | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetScissorRect(IWineD3DDevice *iface, RECT* pRect) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| GLint scissorBox[4]; | |
| ENTER_GL(); | |
| /** FIXME: Windows uses a top,left origin openGL uses a bottom Right? **/ | |
| glGetIntegerv(GL_SCISSOR_BOX, scissorBox); | |
| pRect->left = scissorBox[1]; | |
| pRect->top = scissorBox[2]; | |
| pRect->right = scissorBox[1] + scissorBox[3]; | |
| pRect->bottom = scissorBox[2] + scissorBox[4]; | |
| TRACE("(%p)Returning a Scissor Rect of %ld:%ld-%ld:%ld\n", This, pRect->left, pRect->top, pRect->right, pRect->bottom); | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration* pDecl) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| TRACE("(%p) : pDecl=%p\n", This, pDecl); | |
| /* TODO: what about recording stateblocks? */ | |
| if (NULL != pDecl) { | |
| IWineD3DVertexDeclaration_AddRef(pDecl); | |
| } | |
| if (NULL != This->updateStateBlock->vertexDecl) { | |
| IWineD3DVertexDeclaration_Release(This->updateStateBlock->vertexDecl); | |
| } | |
| This->updateStateBlock->vertexDecl = pDecl; | |
| This->updateStateBlock->changed.vertexDecl = TRUE; | |
| This->updateStateBlock->set.vertexDecl = TRUE; | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppDecl) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : ppDecl=%p\n", This, ppDecl); | |
| *ppDecl = This->updateStateBlock->vertexDecl; | |
| if (NULL != *ppDecl) IWineD3DVertexDeclaration_AddRef(*ppDecl); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader* pShader) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| static BOOL showFixmes = TRUE; | |
| This->updateStateBlock->vertexShader = pShader; | |
| This->updateStateBlock->changed.vertexShader = TRUE; | |
| This->updateStateBlock->set.vertexShader = TRUE; | |
| if(pShader == NULL) { | |
| /* clear down the shader */ | |
| TRACE("Clear down the shader\n"); | |
| }else{ | |
| if(showFixmes) { | |
| FIXME("(%p) : stub pShader(%p)\n", This, pShader); | |
| showFixmes = FALSE; | |
| } | |
| } | |
| return D3D_OK; | |
| /** FIXME: refernece counting? **/ | |
| if (pShader == NULL) { /* only valid with non FVF shaders */ | |
| TRACE_(d3d_shader)("(%p) : FVF Shader, pShader=%p\n", This, pShader); | |
| This->updateStateBlock->vertexShader = NULL; | |
| } else { | |
| TRACE_(d3d_shader)("(%p) : Created shader, pShader=%p\n", This, pShader); | |
| This->updateStateBlock->vertexShader = pShader; | |
| } | |
| This->updateStateBlock->changed.vertexShader = TRUE; | |
| This->updateStateBlock->set.vertexShader = TRUE; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| /** | |
| * TODO: merge HAL shaders context switching from prototype | |
| */ | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader** ppShader) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| *ppShader = This->stateBlock->vertexShader; | |
| if(*ppShader != NULL) | |
| IWineD3DVertexShader_AddRef(*ppShader); | |
| TRACE("(%p) : returning %p\n", This, *ppShader); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, CONST BOOL *pConstantData, UINT BoolCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, BOOL *pConstantData, UINT BoolCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, CONST int *pConstantData, UINT Vector4iCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, int *pConstantData, UINT Vector4iCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, CONST float *pConstantData, UINT Vector4fCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, float *pConstantData, UINT Vector4fCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader *pShader) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader **ppShader) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, CONST BOOL *pConstantData, UINT BoolCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, BOOL *pConstantData, UINT BoolCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, CONST int *pConstantData, UINT Vector4iCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, int *pConstantData, UINT Vector4iCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, CONST float *pConstantData, UINT Vector4fCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, float *pConstantData, UINT Vector4fCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_ProcessVertices(IWineD3DDevice *iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IWineD3DVertexBuffer* pDestBuffer, IWineD3DVertexBuffer* pVertexDecl, DWORD Flags) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Texture Stage States | |
| * TODO: Verify against dx9 definitions | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD Value) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* FIXME: Handle 3d textures? What if TSS value set before set texture? Need to reapply all values? */ | |
| TRACE("(%p) : Stage=%ld, Type=%s(%d), Value=%ld\n", This, Stage, debug_d3dtexturestate(Type), Type, Value); | |
| /* Reject invalid texture units */ | |
| if (Stage >= GL_LIMITS(textures)) { | |
| TRACE("Attempt to access invalid texture rejected\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| This->updateStateBlock->changed.textureState[Stage][Type] = TRUE; | |
| This->updateStateBlock->set.textureState[Stage][Type] = TRUE; | |
| This->updateStateBlock->textureState[Stage][Type] = Value; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| ENTER_GL(); | |
| /* Make appropriate texture active */ | |
| VTRACE(("Activating appropriate texture state %ld\n", Stage)); | |
| if (GL_SUPPORT(ARB_MULTITEXTURE)) { | |
| GLACTIVETEXTURE(Stage); | |
| } else if (Stage > 0) { | |
| FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n"); | |
| } | |
| switch (Type) { | |
| case WINED3DTSS_ALPHAOP : | |
| case WINED3DTSS_COLOROP : | |
| { | |
| if ((Value == D3DTOP_DISABLE) && (Type == WINED3DTSS_COLOROP)) { | |
| /* TODO: Disable by making this and all later levels disabled */ | |
| glDisable(GL_TEXTURE_1D); | |
| checkGLcall("Disable GL_TEXTURE_1D"); | |
| glDisable(GL_TEXTURE_2D); | |
| checkGLcall("Disable GL_TEXTURE_2D"); | |
| glDisable(GL_TEXTURE_3D); | |
| checkGLcall("Disable GL_TEXTURE_3D"); | |
| break; /* Don't bother setting the texture operations */ | |
| } else { | |
| /* Enable only the appropriate texture dimension */ | |
| if (Type == WINED3DTSS_COLOROP) { | |
| if (This->stateBlock->textureDimensions[Stage] == GL_TEXTURE_1D) { | |
| glEnable(GL_TEXTURE_1D); | |
| checkGLcall("Enable GL_TEXTURE_1D"); | |
| } else { | |
| glDisable(GL_TEXTURE_1D); | |
| checkGLcall("Disable GL_TEXTURE_1D"); | |
| } | |
| if (This->stateBlock->textureDimensions[Stage] == GL_TEXTURE_2D) { | |
| if (GL_SUPPORT(NV_TEXTURE_SHADER) && This->texture_shader_active) { | |
| glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D); | |
| checkGLcall("Enable GL_TEXTURE_2D"); | |
| } else { | |
| glEnable(GL_TEXTURE_2D); | |
| checkGLcall("Enable GL_TEXTURE_2D"); | |
| } | |
| } else { | |
| glDisable(GL_TEXTURE_2D); | |
| checkGLcall("Disable GL_TEXTURE_2D"); | |
| } | |
| if (This->stateBlock->textureDimensions[Stage] == GL_TEXTURE_3D) { | |
| glEnable(GL_TEXTURE_3D); | |
| checkGLcall("Enable GL_TEXTURE_3D"); | |
| } else { | |
| glDisable(GL_TEXTURE_3D); | |
| checkGLcall("Disable GL_TEXTURE_3D"); | |
| } | |
| if (This->stateBlock->textureDimensions[Stage] == GL_TEXTURE_CUBE_MAP_ARB) { | |
| glEnable(GL_TEXTURE_CUBE_MAP_ARB); | |
| checkGLcall("Enable GL_TEXTURE_CUBE_MAP"); | |
| } else { | |
| glDisable(GL_TEXTURE_CUBE_MAP_ARB); | |
| checkGLcall("Disable GL_TEXTURE_CUBE_MAP"); | |
| } | |
| } | |
| } | |
| /* Drop through... (Except disable case) */ | |
| case WINED3DTSS_COLORARG0 : | |
| case WINED3DTSS_COLORARG1 : | |
| case WINED3DTSS_COLORARG2 : | |
| case WINED3DTSS_ALPHAARG0 : | |
| case WINED3DTSS_ALPHAARG1 : | |
| case WINED3DTSS_ALPHAARG2 : | |
| { | |
| BOOL isAlphaArg = (Type == WINED3DTSS_ALPHAOP || Type == WINED3DTSS_ALPHAARG1 || | |
| Type == WINED3DTSS_ALPHAARG2 || Type == WINED3DTSS_ALPHAARG0); | |
| if (isAlphaArg) { | |
| set_tex_op(iface, TRUE, Stage, This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP], | |
| This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAARG1], | |
| This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAARG2], | |
| This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAARG0]); | |
| } else { | |
| set_tex_op(iface, FALSE, Stage, This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP], | |
| This->stateBlock->textureState[Stage][WINED3DTSS_COLORARG1], | |
| This->stateBlock->textureState[Stage][WINED3DTSS_COLORARG2], | |
| This->stateBlock->textureState[Stage][WINED3DTSS_COLORARG0]); | |
| } | |
| } | |
| break; | |
| } | |
| case WINED3DTSS_ADDRESSW : | |
| { | |
| GLint wrapParm = GL_REPEAT; | |
| switch (Value) { | |
| case D3DTADDRESS_WRAP: wrapParm = GL_REPEAT; break; | |
| case D3DTADDRESS_CLAMP: wrapParm = GL_CLAMP_TO_EDGE; break; | |
| case D3DTADDRESS_BORDER: | |
| { | |
| if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) { | |
| wrapParm = GL_CLAMP_TO_BORDER_ARB; | |
| } else { | |
| /* FIXME: Not right, but better */ | |
| FIXME("Unrecognized or unsupported D3DTADDRESS_* value %ld, state %d\n", Value, Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| } | |
| break; | |
| case D3DTADDRESS_MIRROR: | |
| { | |
| if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) { | |
| wrapParm = GL_MIRRORED_REPEAT_ARB; | |
| } else { | |
| /* Unsupported in OpenGL pre-1.4 */ | |
| FIXME("Unsupported D3DTADDRESS_MIRROR (needs GL_ARB_texture_mirrored_repeat) state %d\n", Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| } | |
| break; | |
| case D3DTADDRESS_MIRRORONCE: | |
| { | |
| if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) { | |
| wrapParm = GL_MIRROR_CLAMP_TO_EDGE_ATI; | |
| } else { | |
| FIXME("Unsupported D3DTADDRESS_MIRRORONCE (needs GL_ATI_texture_mirror_once) state %d\n", Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| } | |
| break; | |
| default: | |
| FIXME("Unrecognized or unsupported D3DTADDRESS_* value %ld, state %d\n", Value, Type); | |
| wrapParm = GL_REPEAT; | |
| } | |
| TRACE("Setting WRAP_R to %d for %x\n", wrapParm, This->stateBlock->textureDimensions[Stage]); | |
| glTexParameteri(This->stateBlock->textureDimensions[Stage], GL_TEXTURE_WRAP_R, wrapParm); | |
| checkGLcall("glTexParameteri(..., GL_TEXTURE_WRAP_R, wrapParm)"); | |
| } | |
| break; | |
| case WINED3DTSS_TEXCOORDINDEX : | |
| { | |
| /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive */ | |
| /* FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include | |
| one flag, you can still specify an index value, which the system uses to | |
| determine the texture wrapping mode. | |
| eg. SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION | 1 ); | |
| means use the vertex position (camera-space) as the input texture coordinates | |
| for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render | |
| state. We do not (yet) support the D3DRENDERSTATE_WRAPx values, nor tie them up | |
| to the TEXCOORDINDEX value */ | |
| /** | |
| * Be careful the value of the mask 0xF0000 come from d3d8types.h infos | |
| */ | |
| switch (Value & 0xFFFF0000) { | |
| case D3DTSS_TCI_PASSTHRU: | |
| /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/ | |
| glDisable(GL_TEXTURE_GEN_S); | |
| glDisable(GL_TEXTURE_GEN_T); | |
| glDisable(GL_TEXTURE_GEN_R); | |
| checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R)"); | |
| break; | |
| case D3DTSS_TCI_CAMERASPACEPOSITION: | |
| /* CameraSpacePosition means use the vertex position, transformed to camera space, | |
| as the input texture coordinates for this stage's texture transformation. This | |
| equates roughly to EYE_LINEAR */ | |
| { | |
| float s_plane[] = { 1.0, 0.0, 0.0, 0.0 }; | |
| float t_plane[] = { 0.0, 1.0, 0.0, 0.0 }; | |
| float r_plane[] = { 0.0, 0.0, 1.0, 0.0 }; | |
| float q_plane[] = { 0.0, 0.0, 0.0, 1.0 }; | |
| TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n"); | |
| glMatrixMode(GL_MODELVIEW); | |
| glPushMatrix(); | |
| glLoadIdentity(); | |
| glTexGenfv(GL_S, GL_EYE_PLANE, s_plane); | |
| glTexGenfv(GL_T, GL_EYE_PLANE, t_plane); | |
| glTexGenfv(GL_R, GL_EYE_PLANE, r_plane); | |
| glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane); | |
| glPopMatrix(); | |
| TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n"); | |
| glEnable(GL_TEXTURE_GEN_S); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_S);"); | |
| glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); | |
| checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)"); | |
| glEnable(GL_TEXTURE_GEN_T); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_T);"); | |
| glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); | |
| checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)"); | |
| glEnable(GL_TEXTURE_GEN_R); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_R);"); | |
| glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); | |
| checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)"); | |
| } | |
| break; | |
| case D3DTSS_TCI_CAMERASPACENORMAL: | |
| { | |
| if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) { | |
| float s_plane[] = { 1.0, 0.0, 0.0, 0.0 }; | |
| float t_plane[] = { 0.0, 1.0, 0.0, 0.0 }; | |
| float r_plane[] = { 0.0, 0.0, 1.0, 0.0 }; | |
| float q_plane[] = { 0.0, 0.0, 0.0, 1.0 }; | |
| TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n"); | |
| glMatrixMode(GL_MODELVIEW); | |
| glPushMatrix(); | |
| glLoadIdentity(); | |
| glTexGenfv(GL_S, GL_EYE_PLANE, s_plane); | |
| glTexGenfv(GL_T, GL_EYE_PLANE, t_plane); | |
| glTexGenfv(GL_R, GL_EYE_PLANE, r_plane); | |
| glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane); | |
| glPopMatrix(); | |
| glEnable(GL_TEXTURE_GEN_S); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_S);"); | |
| glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV); | |
| checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)"); | |
| glEnable(GL_TEXTURE_GEN_T); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_T);"); | |
| glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV); | |
| checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)"); | |
| glEnable(GL_TEXTURE_GEN_R); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_R);"); | |
| glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV); | |
| checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)"); | |
| } | |
| } | |
| break; | |
| case D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR: | |
| { | |
| if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) { | |
| float s_plane[] = { 1.0, 0.0, 0.0, 0.0 }; | |
| float t_plane[] = { 0.0, 1.0, 0.0, 0.0 }; | |
| float r_plane[] = { 0.0, 0.0, 1.0, 0.0 }; | |
| float q_plane[] = { 0.0, 0.0, 0.0, 1.0 }; | |
| TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n"); | |
| glMatrixMode(GL_MODELVIEW); | |
| glPushMatrix(); | |
| glLoadIdentity(); | |
| glTexGenfv(GL_S, GL_EYE_PLANE, s_plane); | |
| glTexGenfv(GL_T, GL_EYE_PLANE, t_plane); | |
| glTexGenfv(GL_R, GL_EYE_PLANE, r_plane); | |
| glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane); | |
| glPopMatrix(); | |
| glEnable(GL_TEXTURE_GEN_S); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_S);"); | |
| glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV); | |
| checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)"); | |
| glEnable(GL_TEXTURE_GEN_T); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_T);"); | |
| glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV); | |
| checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)"); | |
| glEnable(GL_TEXTURE_GEN_R); | |
| checkGLcall("glEnable(GL_TEXTURE_GEN_R);"); | |
| glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV); | |
| checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)"); | |
| } | |
| } | |
| break; | |
| /* Unhandled types: */ | |
| default: | |
| /* Todo: */ | |
| /* ? disable GL_TEXTURE_GEN_n ? */ | |
| glDisable(GL_TEXTURE_GEN_S); | |
| glDisable(GL_TEXTURE_GEN_T); | |
| glDisable(GL_TEXTURE_GEN_R); | |
| FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %lx\n", Value); | |
| break; | |
| } | |
| } | |
| break; | |
| /* Unhandled */ | |
| case WINED3DTSS_TEXTURETRANSFORMFLAGS : | |
| set_texture_matrix((float *)&This->stateBlock->transforms[D3DTS_TEXTURE0 + Stage].u.m[0][0], Value); | |
| break; | |
| case WINED3DTSS_BUMPENVMAT00 : | |
| case WINED3DTSS_BUMPENVMAT01 : | |
| TRACE("BUMPENVMAT0%u Stage=%ld, Type=%d, Value =%ld\n", Type - WINED3DTSS_BUMPENVMAT00, Stage, Type, Value); | |
| break; | |
| case WINED3DTSS_BUMPENVMAT10 : | |
| case WINED3DTSS_BUMPENVMAT11 : | |
| TRACE("BUMPENVMAT1%u Stage=%ld, Type=%d, Value =%ld\n", Type - WINED3DTSS_BUMPENVMAT10, Stage, Type, Value); | |
| break; | |
| case WINED3DTSS_BUMPENVLSCALE : | |
| TRACE("BUMPENVLSCALE Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value); | |
| break; | |
| case WINED3DTSS_BUMPENVLOFFSET : | |
| TRACE("BUMPENVLOFFSET Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value); | |
| break; | |
| case WINED3DTSS_RESULTARG : | |
| TRACE("RESULTARG Still a stub, Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value); | |
| break; | |
| default: | |
| /* Put back later: FIXME("(%p) : stub, Stage=%ld, Type=%d, Value =%ld\n", This, Stage, Type, Value); */ | |
| TRACE("Still a stub, Stage=%ld, Type=%d, Value =%ld\n", Stage, Type, Value); | |
| } | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : requesting Stage %ld, Type %d getting %ld\n", This, Stage, Type, This->updateStateBlock->textureState[Stage][Type]); | |
| *pValue = This->updateStateBlock->textureState[Stage][Type]; | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get / Set Texture | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture* pTexture) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DBaseTexture *oldTexture; | |
| BOOL reapplyStates = TRUE; | |
| DWORD reapplyFlags = 0; | |
| INT oldTextureDimensions = -1; | |
| D3DRESOURCETYPE textureType; | |
| oldTexture = This->updateStateBlock->textures[Stage]; | |
| TRACE("(%p) : Stage(%ld), Texture (%p)\n", This, Stage, pTexture); | |
| /* Reject invalid texture units */ | |
| if (Stage >= GL_LIMITS(textures)) { | |
| TRACE("Attempt to access invalid texture rejected\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| This->updateStateBlock->set.textures[Stage] = TRUE; | |
| This->updateStateBlock->changed.textures[Stage] = TRUE; | |
| This->updateStateBlock->textures[Stage] = pTexture; | |
| /* Handle recording of state blocks */ | |
| if (This->isRecordingState) { | |
| TRACE("Recording... not performing anything\n"); | |
| return D3D_OK; | |
| } | |
| oldTextureDimensions = This->updateStateBlock->textureDimensions[Stage]; | |
| ENTER_GL(); | |
| /* Make appropriate texture active */ | |
| if (GL_SUPPORT(ARB_MULTITEXTURE)) { | |
| GLACTIVETEXTURE(Stage); | |
| } else if (Stage>0) { | |
| FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n"); | |
| } | |
| /** NOTE: MSDN says that setTexture increases the reference count, | |
| * and the the application nust set the texture back to null (or have a leaky application), | |
| * This means we should pass the refcount upto the parent | |
| *******************************/ | |
| if (NULL != oldTexture) { | |
| IUnknown *textureParent; | |
| IWineD3DBaseTexture_GetParent(oldTexture, (IUnknown **)&textureParent); | |
| IUnknown_Release(textureParent); | |
| IUnknown_Release(textureParent); /** NOTE: Twice because GetParent adds a ref **/ | |
| oldTexture = NULL; | |
| } | |
| if (NULL != pTexture) { | |
| IUnknown *textureParent; | |
| IWineD3DBaseTexture_GetParent(This->updateStateBlock->textures[Stage], (IUnknown **)&textureParent); | |
| /** NOTE: GetParent will increase the ref count for me, I won't clean up untill the texture is set to NULL **/ | |
| /* Now setup the texture appropraitly */ | |
| textureType = IWineD3DBaseTexture_GetType(pTexture); | |
| if (textureType == D3DRTYPE_TEXTURE) { | |
| if (oldTexture == pTexture && !IWineD3DBaseTexture_GetDirty(pTexture)) { | |
| TRACE("Skipping setting texture as old == new\n"); | |
| reapplyStates = FALSE; | |
| } else { | |
| /* Standard 2D texture */ | |
| TRACE("Standard 2d texture\n"); | |
| This->updateStateBlock->textureDimensions[Stage] = GL_TEXTURE_2D; | |
| /* Load up the texture now */ | |
| IWineD3DTexture_PreLoad((IWineD3DTexture *) pTexture); | |
| } | |
| } else if (textureType == D3DRTYPE_VOLUMETEXTURE) { | |
| if (oldTexture == pTexture && !IWineD3DBaseTexture_GetDirty(pTexture)) { | |
| TRACE("Skipping setting texture as old == new\n"); | |
| reapplyStates = FALSE; | |
| } else { | |
| /* Standard 3D (volume) texture */ | |
| TRACE("Standard 3d texture\n"); | |
| This->updateStateBlock->textureDimensions[Stage] = GL_TEXTURE_3D; | |
| /* Load up the texture now */ | |
| IWineD3DVolumeTexture_PreLoad((IWineD3DVolumeTexture *) pTexture); | |
| } | |
| } else if (textureType == D3DRTYPE_CUBETEXTURE) { | |
| if (oldTexture == pTexture && !IWineD3DBaseTexture_GetDirty(pTexture)) { | |
| TRACE("Skipping setting texture as old == new\n"); | |
| reapplyStates = FALSE; | |
| } else { | |
| /* Standard Cube texture */ | |
| TRACE("Standard Cube texture\n"); | |
| This->updateStateBlock->textureDimensions[Stage] = GL_TEXTURE_CUBE_MAP_ARB; | |
| /* Load up the texture now */ | |
| IWineD3DCubeTexture_PreLoad((IWineD3DCubeTexture *) pTexture); | |
| } | |
| } else { | |
| FIXME("(%p) : Incorrect type for a texture : (%d,%s)\n", This, textureType, debug_d3dresourcetype(textureType)); | |
| } | |
| } else { | |
| TRACE("Setting to no texture (ie default texture)\n"); | |
| This->updateStateBlock->textureDimensions[Stage] = GL_TEXTURE_1D; | |
| glBindTexture(GL_TEXTURE_1D, This->dummyTextureName[Stage]); | |
| checkGLcall("glBindTexture"); | |
| TRACE("Bound dummy Texture to stage %ld (gl name %d)\n", Stage, This->dummyTextureName[Stage]); | |
| } | |
| /* Disable the old texture binding and enable the new one (unless operations are disabled) */ | |
| if (oldTextureDimensions != This->updateStateBlock->textureDimensions[Stage]) { | |
| glDisable(oldTextureDimensions); | |
| checkGLcall("Disable oldTextureDimensions"); | |
| if (This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP] != D3DTOP_DISABLE) { | |
| glEnable(This->updateStateBlock->textureDimensions[Stage]); | |
| checkGLcall("glEnable new texture dimensions"); | |
| } | |
| /* If Alpha arg1 is texture then handle the special case when there changes between a | |
| texture and no texture - See comments in set_tex_op */ | |
| if ((This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAARG1] == D3DTA_TEXTURE) && | |
| (((oldTexture == NULL) && (pTexture != NULL)) || ((pTexture == NULL) && (oldTexture != NULL)))) | |
| { | |
| reapplyFlags |= REAPPLY_ALPHAOP; | |
| } | |
| } | |
| /* Even if the texture has been set to null, reapply the stages as a null texture to directx requires | |
| a dummy texture in opengl, and we always need to ensure the current view of the TextureStates apply */ | |
| if (reapplyStates) { | |
| IWineD3DDeviceImpl_SetupTextureStates(iface, Stage, reapplyFlags); | |
| } | |
| LEAVE_GL(); | |
| TRACE("Texture now fully setup\n"); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture** ppTexture) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : returning %p for stage %ld\n", This, This->updateStateBlock->textures[Stage], Stage); | |
| *ppTexture = (IWineD3DBaseTexture *) This->updateStateBlock->textures[Stage]; | |
| if (*ppTexture) | |
| IWineD3DBaseTexture_AddRef(*ppTexture); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Get Back Buffer | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetBackBuffer(IWineD3DDevice *iface, UINT iSwapChain, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, | |
| IWineD3DSurface** ppBackBuffer) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DSwapChain *swapChain; | |
| HRESULT hr; | |
| TRACE("(%p) : BackBuf %d Type %d SwapChain %d returning %p\n", This, BackBuffer, Type, iSwapChain, *ppBackBuffer); | |
| hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain); | |
| if(hr == D3D_OK) { | |
| hr = IWineD3DSwapChain_GetBackBuffer(swapChain, BackBuffer, Type, ppBackBuffer); | |
| IWineD3DSwapChain_Release(swapChain); | |
| }else{ | |
| *ppBackBuffer = NULL; | |
| } | |
| return hr; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetDeviceCaps(IWineD3DDevice *iface, WINED3DCAPS* pCaps) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| WARN("(%p) : stub, calling idirect3d for now\n", This); | |
| return IWineD3D_GetDeviceCaps(This->wineD3D, This->adapterNo, This->devType, pCaps); | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetDisplayMode(IWineD3DDevice *iface, UINT iSwapChain, D3DDISPLAYMODE* pMode) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DSwapChain *swapChain; | |
| HRESULT hr; | |
| hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, (IWineD3DSwapChain **)&swapChain); | |
| if (hr == D3D_OK) { | |
| hr = IWineD3DSwapChain_GetDisplayMode(swapChain, pMode); | |
| IWineD3DSwapChain_Release(swapChain); | |
| }else{ | |
| FIXME("(%p) Error getting display mode\n", This); | |
| } | |
| return hr; | |
| } | |
| /***** | |
| * Stateblock related functions | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_BeginStateBlock(IWineD3DDevice *iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DStateBlockImpl *object; | |
| TRACE("(%p)", This); | |
| object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DStateBlockImpl)); | |
| if(NULL == object ) { | |
| FIXME("(%p)Error allocating memory for stateblock\n", This); | |
| return E_OUTOFMEMORY; | |
| } | |
| TRACE("(%p) creted object %p\n", This, object); | |
| object->wineD3DDevice= This; | |
| /** FIXME: object->parent = parent; **/ | |
| object->parent = NULL; | |
| object->blockType = D3DSBT_ALL; | |
| object->ref = 1; | |
| object->lpVtbl = &IWineD3DStateBlock_Vtbl; | |
| IWineD3DStateBlock_Release((IWineD3DStateBlock*)This->updateStateBlock); | |
| This->updateStateBlock = object; | |
| This->isRecordingState = TRUE; | |
| TRACE("(%p) recording stateblock %p\n",This , object); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_EndStateBlock(IWineD3DDevice *iface, IWineD3DStateBlock** ppStateBlock) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| if (!This->isRecordingState) { | |
| FIXME("(%p) not recording! returning error\n", This); | |
| *ppStateBlock = NULL; | |
| return D3DERR_INVALIDCALL; | |
| } | |
| *ppStateBlock = (IWineD3DStateBlock*)This->updateStateBlock; | |
| This->isRecordingState = FALSE; | |
| This->updateStateBlock = This->stateBlock; | |
| IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock); | |
| /* IWineD3DStateBlock_AddRef(*ppStateBlock); don't need to do this, since we should really just release UpdateStateBlock first */ | |
| TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, *ppStateBlock); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Scene related functions | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_BeginScene(IWineD3DDevice *iface) { | |
| /* At the moment we have no need for any functionality at the beginning | |
| of a scene */ | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_EndScene(IWineD3DDevice *iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p)\n", This); | |
| ENTER_GL(); | |
| /* We only have to do this if we need to read the, swapbuffers performs a flush for us */ | |
| glFlush(); | |
| checkGLcall("glFlush"); | |
| TRACE("End Scene\n"); | |
| if(This->renderTarget != NULL) { | |
| /* If the container of the rendertarget is a texture then we need to save the data from the pbuffer */ | |
| IUnknown *targetContainer = NULL; | |
| if (D3D_OK == IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DBaseTexture, (void **)&targetContainer) | |
| || D3D_OK == IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DDevice, (void **)&targetContainer)) { | |
| TRACE("(%p) : Texture rendertarget %p\n", This ,This->renderTarget); | |
| /** always dirtify for now. we must find a better way to see that surface have been modified | |
| (Modifications should will only occur via draw-primitive, but we do need better locking | |
| switching to render-to-texture should remove the overhead though. | |
| */ | |
| IWineD3DSurface_SetPBufferState(This->renderTarget, TRUE /* inPBuffer */, FALSE /* inTexture */); | |
| IWineD3DSurface_AddDirtyRect(This->renderTarget, NULL); | |
| IWineD3DSurface_PreLoad(This->renderTarget); | |
| IWineD3DSurface_SetPBufferState(This->renderTarget, FALSE /* inPBuffer */, FALSE /* inTexture */); | |
| IUnknown_Release(targetContainer); | |
| } | |
| } | |
| This->sceneEnded = TRUE; | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_Present(IWineD3DDevice *iface, | |
| CONST RECT* pSourceRect, CONST RECT* pDestRect, | |
| HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DSwapChain *swapChain = NULL; | |
| int i; | |
| int swapchains = IWineD3DDeviceImpl_GetNumberOfSwapChains(iface); | |
| TRACE("(%p) Presenting the frame\n", This); | |
| for(i = 0 ; i < swapchains ; i ++) { | |
| IWineD3DDeviceImpl_GetSwapChain(iface, i , (IWineD3DSwapChain **)&swapChain); | |
| TRACE("presentinng chain %d, %p\n", i, swapChain); | |
| IWineD3DSwapChain_Present(swapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, 0); | |
| IWineD3DSwapChain_Release(swapChain); | |
| } | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_Clear(IWineD3DDevice *iface, DWORD Count, CONST D3DRECT* pRects, | |
| DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* TODO: From MSDN This method fails if you specify the D3DCLEAR_ZBUFFER or D3DCLEAR_STENCIL flags when the | |
| render target does not have an attached depth buffer. Similarly, if you specify the D3DCLEAR_STENCIL flag | |
| when the depth-buffer format does not contain stencil buffer information, this method fails. */ | |
| GLbitfield glMask = 0; | |
| GLboolean old_ztest; | |
| GLfloat old_z_clear_value; | |
| GLint old_stencil_clear_value; | |
| GLfloat old_color_clear_value[4]; | |
| unsigned int i; | |
| CONST D3DRECT* curRect; | |
| TRACE("(%p) Count (%ld), pRects (%p), Flags (%lx), Z (%f), Stencil (%ld)\n", This, | |
| Count, pRects, Flags, Z, Stencil); | |
| ENTER_GL(); | |
| glEnable(GL_SCISSOR_TEST); | |
| checkGLcall("glEnable GL_SCISSOR_TEST"); | |
| if (Count > 0 && pRects) { | |
| curRect = pRects; | |
| } else { | |
| curRect = NULL; | |
| } | |
| /* Only set the values up once, as they are not changing */ | |
| if (Flags & D3DCLEAR_STENCIL) { | |
| glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &old_stencil_clear_value); | |
| glClearStencil(Stencil); | |
| checkGLcall("glClearStencil"); | |
| glMask = glMask | GL_STENCIL_BUFFER_BIT; | |
| glStencilMask(0xFFFFFFFF); | |
| } | |
| if (Flags & D3DCLEAR_ZBUFFER) { | |
| glGetBooleanv(GL_DEPTH_WRITEMASK, &old_ztest); | |
| glDepthMask(GL_TRUE); | |
| glGetFloatv(GL_DEPTH_CLEAR_VALUE, &old_z_clear_value); | |
| glClearDepth(Z); | |
| checkGLcall("glClearDepth"); | |
| glMask = glMask | GL_DEPTH_BUFFER_BIT; | |
| } | |
| if (Flags & D3DCLEAR_TARGET) { | |
| TRACE("Clearing screen with glClear to color %lx\n", Color); | |
| glGetFloatv(GL_COLOR_CLEAR_VALUE, old_color_clear_value); | |
| glClearColor(((Color >> 16) & 0xFF) / 255.0f, | |
| ((Color >> 8) & 0xFF) / 255.0f, | |
| ((Color >> 0) & 0xFF) / 255.0f, | |
| ((Color >> 24) & 0xFF) / 255.0f); | |
| checkGLcall("glClearColor"); | |
| /* Clear ALL colors! */ | |
| glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); | |
| glMask = glMask | GL_COLOR_BUFFER_BIT; | |
| } | |
| /* Now process each rect in turn */ | |
| for (i = 0; i < Count || i == 0; i++) { | |
| if (curRect) { | |
| /* Note gl uses lower left, width/height */ | |
| TRACE("(%p) %p Rect=(%ld,%ld)->(%ld,%ld) glRect=(%ld,%ld), len=%ld, hei=%ld\n", This, curRect, | |
| curRect->x1, curRect->y1, curRect->x2, curRect->y2, | |
| curRect->x1, (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height - curRect->y2), | |
| curRect->x2 - curRect->x1, curRect->y2 - curRect->y1); | |
| glScissor(curRect->x1, (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height - curRect->y2), | |
| curRect->x2 - curRect->x1, curRect->y2 - curRect->y1); | |
| checkGLcall("glScissor"); | |
| } else { | |
| glScissor(This->stateBlock->viewport.X, | |
| (((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height - (This->stateBlock->viewport.Y + This->stateBlock->viewport.Height)), | |
| This->stateBlock->viewport.Width, | |
| This->stateBlock->viewport.Height); | |
| checkGLcall("glScissor"); | |
| } | |
| /* Clear the selected rectangle (or full screen) */ | |
| glClear(glMask); | |
| checkGLcall("glClear"); | |
| /* Step to the next rectangle */ | |
| if (curRect) curRect = curRect + sizeof(D3DRECT); | |
| } | |
| /* Restore the old values (why..?) */ | |
| if (Flags & D3DCLEAR_STENCIL) { | |
| glClearStencil(old_stencil_clear_value); | |
| glStencilMask(This->stateBlock->renderState[WINED3DRS_STENCILWRITEMASK]); | |
| } | |
| if (Flags & D3DCLEAR_ZBUFFER) { | |
| glDepthMask(old_ztest); | |
| glClearDepth(old_z_clear_value); | |
| } | |
| if (Flags & D3DCLEAR_TARGET) { | |
| glClearColor(old_color_clear_value[0], | |
| old_color_clear_value[1], | |
| old_color_clear_value[2], | |
| old_color_clear_value[3]); | |
| glColorMask(This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE, | |
| This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE, | |
| This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE, | |
| This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE] & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE); | |
| } | |
| glDisable(GL_SCISSOR_TEST); | |
| checkGLcall("glDisable"); | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| /***** | |
| * Drawing functions | |
| *****/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitive(IWineD3DDevice *iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, | |
| UINT PrimitiveCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| This->stateBlock->streamIsUP = FALSE; | |
| TRACE("(%p) : Type=(%d,%s), Start=%d, Count=%d\n", This, PrimitiveType, | |
| debug_d3dprimitivetype(PrimitiveType), | |
| StartVertex, PrimitiveCount); | |
| drawPrimitive(iface, PrimitiveType, PrimitiveCount, StartVertex, -1, 0, NULL, 0); | |
| return D3D_OK; | |
| } | |
| /* TODO: baseVIndex needs to be provided from This->stateBlock->baseVertexIndex when called from d3d8 */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitive(IWineD3DDevice *iface, | |
| D3DPRIMITIVETYPE PrimitiveType, | |
| INT baseVIndex, UINT minIndex, | |
| UINT NumVertices,UINT startIndex,UINT primCount) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| UINT idxStride = 2; | |
| IWineD3DIndexBuffer *pIB; | |
| D3DINDEXBUFFER_DESC IdxBufDsc; | |
| pIB = This->stateBlock->pIndexData; | |
| This->stateBlock->streamIsUP = FALSE; | |
| TRACE("(%p) : Type=(%d,%s), min=%d, CountV=%d, startIdx=%d, baseVidx=%d, countP=%d \n", This, | |
| PrimitiveType, debug_d3dprimitivetype(PrimitiveType), | |
| minIndex, NumVertices, startIndex, baseVIndex, primCount); | |
| IWineD3DIndexBuffer_GetDesc(pIB, &IdxBufDsc); | |
| if (IdxBufDsc.Format == WINED3DFMT_INDEX16) { | |
| idxStride = 2; | |
| } else { | |
| idxStride = 4; | |
| } | |
| drawPrimitive(iface, PrimitiveType, primCount, baseVIndex, | |
| startIndex, idxStride, | |
| ((IWineD3DIndexBufferImpl *) pIB)->resource.allocatedMemory, | |
| minIndex); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveUP(IWineD3DDevice *iface, D3DPRIMITIVETYPE PrimitiveType, | |
| UINT PrimitiveCount, CONST void* pVertexStreamZeroData, | |
| UINT VertexStreamZeroStride) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : Type=(%d,%s), pCount=%d, pVtxData=%p, Stride=%d\n", This, PrimitiveType, | |
| debug_d3dprimitivetype(PrimitiveType), | |
| PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride); | |
| if (This->stateBlock->streamSource[0] != NULL) IWineD3DVertexBuffer_Release(This->stateBlock->streamSource[0]); | |
| /* Note in the following, it's not this type, but that's the purpose of streamIsUP */ | |
| This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData; | |
| This->stateBlock->streamStride[0] = VertexStreamZeroStride; | |
| This->stateBlock->streamIsUP = TRUE; | |
| drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0, 0, 0, NULL, 0); | |
| This->stateBlock->streamStride[0] = 0; | |
| This->stateBlock->streamSource[0] = NULL; | |
| /*stream zero settings set to null at end, as per the msdn */ | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveUP(IWineD3DDevice *iface, D3DPRIMITIVETYPE PrimitiveType, | |
| UINT MinVertexIndex, | |
| UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData, | |
| WINED3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, | |
| UINT VertexStreamZeroStride) { | |
| int idxStride; | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : Type=(%d,%s), MinVtxIdx=%d, NumVIdx=%d, PCount=%d, pidxdata=%p, IdxFmt=%d, pVtxdata=%p, stride=%d\n", | |
| This, PrimitiveType, debug_d3dprimitivetype(PrimitiveType), | |
| MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, | |
| IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); | |
| if (This->stateBlock->streamSource[0] != NULL) IWineD3DVertexBuffer_Release(This->stateBlock->streamSource[0]); | |
| if (IndexDataFormat == WINED3DFMT_INDEX16) { | |
| idxStride = 2; | |
| } else { | |
| idxStride = 4; | |
| } | |
| /* Note in the following, it's not this type, but that's the purpose of streamIsUP */ | |
| This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData; | |
| This->stateBlock->streamIsUP = TRUE; | |
| This->stateBlock->streamStride[0] = VertexStreamZeroStride; | |
| drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0, 0, idxStride, pIndexData, MinVertexIndex); | |
| /* stream zero settings set to null at end as per the msdn */ | |
| This->stateBlock->streamSource[0] = NULL; | |
| This->stateBlock->streamStride[0] = 0; | |
| IWineD3DDevice_SetIndices(iface, NULL, 0); | |
| return D3D_OK; | |
| } | |
| /* Yet another way to update a texture, some apps use this to load default textures instead of using surface/texture lock/unlock */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_UpdateTexture (IWineD3DDevice *iface, IWineD3DBaseTexture *pSourceTexture, IWineD3DBaseTexture *pDestinationTexture){ | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| D3DRESOURCETYPE sourceType; | |
| D3DRESOURCETYPE destinationType; | |
| IWineD3DTextureImpl *pDestTexture = (IWineD3DTextureImpl *)pDestinationTexture; | |
| IWineD3DTextureImpl *pSrcTexture = (IWineD3DTextureImpl *)pSourceTexture; | |
| int i; | |
| sourceType = IWineD3DBaseTexture_GetType(pSourceTexture); | |
| destinationType = IWineD3DBaseTexture_GetType(pDestinationTexture); | |
| if(sourceType != D3DRTYPE_TEXTURE && destinationType != D3DRTYPE_TEXTURE){ | |
| FIXME("(%p) Only D3DRTYPE_TEXTURE to D3DRTYPE_TEXTURE supported\n", This); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| TRACE("(%p) Source %p Destination %p\n", This, pSourceTexture, pDestinationTexture); | |
| /** TODO: Get rid of the casts to IWineD3DBaseTextureImpl | |
| repalce surfaces[x] with GetSurfaceLevel, or GetCubeMapSurface etc.. | |
| think about moving the code into texture, and adding a member to base texture to occomplish this **/ | |
| /* Make sure that the destination texture is loaded */ | |
| IWineD3DBaseTexture_PreLoad(pDestinationTexture); | |
| TRACE("Loading source texture\n"); | |
| if(pSrcTexture->surfaces[0] == NULL || pDestTexture->surfaces[0] == NULL){ | |
| FIXME("(%p) Texture src %p or dest %p has not surface %p %p\n", This, pSrcTexture, pDestTexture, | |
| pSrcTexture->surfaces[0], pDestTexture->surfaces[0]); | |
| } | |
| if(((IWineD3DSurfaceImpl *)pSrcTexture->surfaces[0])->resource.pool != D3DPOOL_SYSTEMMEM || | |
| ((IWineD3DSurfaceImpl *)pDestTexture->surfaces[0])->resource.pool != D3DPOOL_DEFAULT){ | |
| FIXME("(%p) source %p must be SYSTEMMEM and dest %p must be DEFAULT\n",This, pSrcTexture, pDestTexture); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| /** TODO: check that both textures have the same number of levels **/ | |
| #if 0 | |
| if(IWineD3DBaseTexture_GetLevelCount(pDestinationTexture) !=IWineD3DBaseTexture_GetLevelCount(pSourceTexture)) | |
| return D3DERR_INVALIDCALL; | |
| #endif | |
| /** TODO: move this code into baseTexture? device should never touch impl*'s **/ | |
| for(i = 0 ; i < IWineD3DBaseTexture_GetLevelCount(pDestinationTexture) ; i++){ | |
| IWineD3DDevice_UpdateSurface(iface, pSrcTexture->surfaces[i], NULL, pDestTexture->surfaces[i], NULL); | |
| } | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_StretchRect(IWineD3DDevice *iface, IWineD3DSurface *pSourceSurface, | |
| CONST RECT* pSourceRect, IWineD3DSurface *pDestinationSurface, | |
| CONST RECT* pDestRect, D3DTEXTUREFILTERTYPE Filter) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetRenderTargetData(IWineD3DDevice *iface, IWineD3DSurface *pRenderTarget, IWineD3DSurface *pSurface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetFrontBufferData(IWineD3DDevice *iface,UINT iSwapChain, IWineD3DSurface *pDestSurface) { | |
| IWineD3DSwapChain *swapChain; | |
| HRESULT hr; | |
| hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, (IWineD3DSwapChain **)&swapChain); | |
| if(hr == D3D_OK) { | |
| hr = IWineD3DSwapChain_GetFrontBufferData(swapChain, pDestSurface); | |
| IWineD3DSwapChain_Release(swapChain); | |
| } | |
| return hr; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_ValidateDevice(IWineD3DDevice *iface, DWORD* pNumPasses) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* return a sensible default */ | |
| *pNumPasses = 1; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, PALETTEENTRY* pEntries) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetCurrentTexturePalette(IWineD3DDevice *iface, UINT PaletteNumber) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetCurrentTexturePalette(IWineD3DDevice *iface, UINT* PaletteNumber) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetSoftwareVertexProcessing(IWineD3DDevice *iface, BOOL bSoftware) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| BOOL WINAPI IWineD3DDeviceImpl_GetSoftwareVertexProcessing(IWineD3DDevice *iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| FIXME("(%p) : stub\n", This); | |
| return FALSE; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetRasterStatus(IWineD3DDevice *iface, UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| pRasterStatus->InVBlank = TRUE; | |
| pRasterStatus->ScanLine = 0; | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetNPatchMode(IWineD3DDevice *iface, float nSegments) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| static BOOL showfixmes = TRUE; | |
| if(nSegments != 0.0f) { | |
| if( showfixmes) { | |
| FIXME("(%p) : stub nSegments(%f)\n", This, nSegments); | |
| showfixmes = FALSE; | |
| } | |
| } | |
| return D3D_OK; | |
| } | |
| float WINAPI IWineD3DDeviceImpl_GetNPatchMode(IWineD3DDevice *iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| static BOOL showfixmes = TRUE; | |
| if( showfixmes) { | |
| FIXME("(%p) : stub returning(%f)\n", This, 0.0f); | |
| showfixmes = FALSE; | |
| } | |
| return 0.0f; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface, IWineD3DSurface *pSourceSurface, CONST RECT* pSourceRect, IWineD3DSurface *pDestinationSurface, CONST POINT* pDestPoint) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| /** TODO: remove casts to IWineD3DSurfaceImpl | |
| * NOTE: move code to surface to accomplish this | |
| ****************************************/ | |
| IWineD3DSurfaceImpl *pSrcSurface = (IWineD3DSurfaceImpl *)pSourceSurface; | |
| int srcWidth, srcHeight, srcSurfaceWidth, srcSurfaceHeight, destSurfaceWidth, destSurfaceHeight; | |
| WINED3DFORMAT destFormat, srcFormat; | |
| UINT destSize; | |
| int destLeft, destTop; | |
| D3DPOOL srcPool, destPool; | |
| int offset = 0; | |
| int rowoffset = 0; /* how many bytes to add onto the end of a row to wraparound to the beginning of the next */ | |
| glDescriptor *glDescription = NULL; | |
| GLenum textureDimensions = GL_TEXTURE_2D; | |
| IWineD3DBaseTexture *baseTexture; | |
| WINED3DSURFACE_DESC winedesc; | |
| memset(&winedesc, 0, sizeof(winedesc)); | |
| winedesc.Width = &srcSurfaceWidth; | |
| winedesc.Height = &srcSurfaceHeight; | |
| winedesc.Pool = &srcPool; | |
| winedesc.Format = &srcFormat; | |
| IWineD3DSurface_GetDesc(pSourceSurface, &winedesc); | |
| winedesc.Width = &destSurfaceWidth; | |
| winedesc.Height = &destSurfaceHeight; | |
| winedesc.Pool = &destPool; | |
| winedesc.Format = &destFormat; | |
| winedesc.Size = &destSize; | |
| IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc); | |
| if(srcPool != D3DPOOL_SYSTEMMEM || destPool != D3DPOOL_DEFAULT){ | |
| FIXME("source %p must be SYSTEMMEM and dest %p must be DEFAULT\n", pSourceSurface, pDestinationSurface); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| /* TODO: change this to use bindTexture */ | |
| /* Make sure the surface is loaded and upto date */ | |
| IWineD3DSurface_PreLoad(pDestinationSurface); | |
| IWineD3DSurface_GetGlDesc(pDestinationSurface, &glDescription); | |
| ENTER_GL(); | |
| /* this needs to be done in lines if the sourceRect != the sourceWidth */ | |
| srcWidth = pSourceRect ? pSourceRect->right - pSourceRect->left : srcSurfaceWidth; | |
| srcHeight = pSourceRect ? pSourceRect->top - pSourceRect->bottom : srcSurfaceHeight; | |
| destLeft = pDestPoint ? pDestPoint->x : 0; | |
| destTop = pDestPoint ? pDestPoint->y : 0; | |
| /* This function doesn't support compressed textures | |
| the pitch is just bytesPerPixel * width */ | |
| if(srcWidth != srcSurfaceWidth || (pSourceRect != NULL && pSourceRect->left != 0) ){ | |
| rowoffset = (srcSurfaceWidth - srcWidth) * pSrcSurface->bytesPerPixel; | |
| offset += pSourceRect->left * pSrcSurface->bytesPerPixel; | |
| /* TODO: do we ever get 3bpp?, would a shift and an add be quicker than a mul (well maybe a cycle or two) */ | |
| } | |
| /* TODO DXT formats */ | |
| if(pSourceRect != NULL && pSourceRect->top != 0){ | |
| offset += pSourceRect->top * srcWidth * pSrcSurface->bytesPerPixel; | |
| } | |
| TRACE("(%p) glTexSubImage2D, Level %d, left %d, top %d, width %d, height %d , ftm %d, type %d, memory %p\n" | |
| ,This | |
| ,glDescription->level | |
| ,destLeft | |
| ,destTop | |
| ,srcWidth | |
| ,srcHeight | |
| ,glDescription->glFormat | |
| ,glDescription->glType | |
| ,IWineD3DSurface_GetData(pSourceSurface) | |
| ); | |
| /* Sanity check */ | |
| if (IWineD3DSurface_GetData(pSourceSurface) == NULL) { | |
| /* need to lock the surface to get the data */ | |
| FIXME("Surfaces has no allocated memory, but should be an in memory only surface\n"); | |
| } | |
| /* TODO: Cube and volume support */ | |
| if(rowoffset != 0){ | |
| /* not a whole row so we have to do it a line at a time */ | |
| int j; | |
| /* hopefully using pointer addtion will be quicker than using a point + j * rowoffset */ | |
| unsigned char* data =((unsigned char *)IWineD3DSurface_GetData(pSourceSurface)) + offset; | |
| for(j = destTop ; j < (srcHeight + destTop) ; j++){ | |
| glTexSubImage2D(glDescription->target | |
| ,glDescription->level | |
| ,destLeft | |
| ,j | |
| ,srcWidth | |
| ,1 | |
| ,glDescription->glFormat | |
| ,glDescription->glType | |
| ,data/* could be quicker using */ | |
| ); | |
| data += rowoffset; | |
| } | |
| } else { /* Full width, so just write out the whole texture */ | |
| if (WINED3DFMT_DXT1 == destFormat || | |
| WINED3DFMT_DXT3 == destFormat || | |
| WINED3DFMT_DXT5 == destFormat) { | |
| if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) { | |
| if (destSurfaceHeight != srcHeight || destSurfaceWidth != srcWidth) { | |
| /* FIXME: The easy way to do this is lock the destination, and copy the bits accross */ | |
| FIXME("Updating part of a compressed texture is not supported at the moment\n"); | |
| } if (destFormat != srcFormat) { | |
| FIXME("Updating mixed format compressed texture is not curretly support\n"); | |
| } else { | |
| GL_EXTCALL(glCompressedTexImage2DARB)(glDescription->target, | |
| glDescription->level, | |
| glDescription->glFormatInternal, | |
| srcWidth, | |
| srcHeight, | |
| 0, | |
| destSize, | |
| IWineD3DSurface_GetData(pSourceSurface)); | |
| } | |
| } else { | |
| FIXME("Attempting to update a DXT compressed texture without hardware support\n"); | |
| } | |
| } else { | |
| /* some applications cannot handle odd pitches returned by soft non-power2, so we have | |
| to repack the data from pow2Width/Height to expected Width,Height, this makes the | |
| data returned by GetData non-power2 width/height with hardware non-power2 | |
| pow2Width/height are set to surface width height, repacking isn't needed so it | |
| doesn't matter which function gets called. */ | |
| glTexSubImage2D(glDescription->target | |
| ,glDescription->level | |
| ,destLeft | |
| ,destTop | |
| ,srcWidth | |
| ,srcHeight | |
| ,glDescription->glFormat | |
| ,glDescription->glType | |
| ,IWineD3DSurface_GetData(pSourceSurface) | |
| ); | |
| } | |
| } | |
| checkGLcall("glTexSubImage2D"); | |
| /* I only need to look up baseTexture here, so it may be a good idea to hava a GL_TARGET -> | |
| * GL_DIMENSIONS lookup, or maybe store the dimensions on the surface (but that's making the | |
| * surface bigger than it needs to be hmm.. */ | |
| if (D3D_OK == IWineD3DSurface_GetContainer(pDestinationSurface, &IID_IWineD3DBaseTexture, (void **)&baseTexture)) { | |
| textureDimensions = IWineD3DBaseTexture_GetTextureDimensions(baseTexture); | |
| IWineD3DBaseTexture_Release(baseTexture); | |
| } | |
| glDisable(textureDimensions); /* This needs to be managed better.... */ | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| /* Implementation details at http://developer.nvidia.com/attach/6494 | |
| and | |
| http://oss.sgi.com/projects/ogl-sample/registry/NV/evaluators.txt | |
| hmm.. no longer supported use | |
| OpenGL evaluators or tessellate surfaces within your application. | |
| */ | |
| /* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/DrawRectPatch.asp */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_DrawRectPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST D3DRECTPATCH_INFO* pRectPatchInfo) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) Handle(%d) noSegs(%p) rectpatch(%p) \n", This, Handle, pNumSegs, pRectPatchInfo); | |
| FIXME("(%p) : Stub\n", This); | |
| return D3D_OK; | |
| } | |
| /* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/DrawTriPatch.asp */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_DrawTriPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST D3DTRIPATCH_INFO* pTriPatchInfo) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) Handle(%d) noSegs(%p) tripatch(%p) \n", This, Handle, pNumSegs, pTriPatchInfo); | |
| FIXME("(%p) : Stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_DeletePatch(IWineD3DDevice *iface, UINT Handle) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p) Handle(%d)\n", This, Handle); | |
| FIXME("(%p) : Stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_ColorFill(IWineD3DDevice *iface, IWineD3DSurface *pSurface, CONST D3DRECT* pRect, D3DCOLOR color) { | |
| /* I couldn't find a 'really' quick way of doing this in openGl so here goes | |
| fill a surface with a block of color! */ | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* TODO: get rid of the use of IWineD3DSurfaceImpl, move code into surface.c */ | |
| IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)pSurface; | |
| IWineD3DSwapChainImpl *container = NULL; | |
| BOOL isRenderTarget = FALSE; | |
| unsigned int width, height; | |
| unsigned int top, left; | |
| unsigned int u, v; | |
| DWORD *data; | |
| TRACE("(%p) Colour fill Surface: %p rect: %p color: %ld\n", This, pSurface, pRect, color); | |
| if (surface->resource.pool != D3DPOOL_DEFAULT) { | |
| FIXME("call to colorfill with non D3DPOOL_DEFAULT surface\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| /* TODO: get rid of IWineD3DSwapChainImpl reference, a 'context' manager may help with this */ | |
| if (D3D_OK == IWineD3DSurface_GetContainer(pSurface, &IID_IWineD3DSwapChain, (void **)&container) || pSurface == This->renderTarget) { | |
| if (D3DUSAGE_RENDERTARGET & surface->resource.usage) { | |
| /* TODO: make sure we set everything back to the way it was, and context management! | |
| glGetIntegerv(GL_READ_BUFFER, &prev_read); | |
| vcheckGLcall("glIntegerv"); | |
| glGetIntegerv(GL_PACK_SWAP_BYTES, &prev_store); | |
| vcheckGLcall("glIntegerv"); | |
| */ | |
| TRACE("Color fill to render targets may cause some graphics issues\n"); | |
| if (pSurface == container->frontBuffer) { | |
| glDrawBuffer(GL_FRONT); | |
| } else { | |
| glDrawBuffer(GL_BACK); | |
| } | |
| } else { | |
| if (D3DUSAGE_DEPTHSTENCIL & surface->resource.usage) { | |
| FIXME("colouring of depth_stencil? %p buffers is not yet supported? %ld \n", surface, surface->resource.usage); | |
| } else { | |
| FIXME("(%p) : Regression %ld %p %p\n", This, surface->resource.usage, pSurface, This->renderTarget); | |
| } | |
| if (container != NULL) { | |
| IWineD3DSwapChain_Release((IWineD3DSwapChain *)container); | |
| } | |
| /* we can use GL_STENCIL_INDEX etc...*/ | |
| return D3D_OK; | |
| } | |
| if (container != NULL) { | |
| IWineD3DSwapChain_Release((IWineD3DSwapChain *)container); | |
| } | |
| isRenderTarget = TRUE; | |
| } | |
| /* TODO: drawing to GL_FRONT and GL_BACK */ | |
| /* TODO: see if things can be speeded up by using the correct | |
| * colour model of the target texture from the start (16 bit graphics on 32 X are slow anyway!) */ | |
| if (pRect == NULL) { | |
| top = 0; | |
| left = 0; | |
| width = surface->currentDesc.Width; | |
| height = surface->currentDesc.Height; | |
| } else { | |
| left = pRect->x1; | |
| top = pRect->y1; | |
| width = pRect->x2 - left; | |
| height = pRect->y2 - top; | |
| } | |
| data = HeapAlloc(GetProcessHeap(), 0, 4 * width); | |
| /* Create a 'line' of color color, in the correct format for the surface */ | |
| for (u = 0 ; u < width ; u ++) { | |
| data[u] = color; | |
| } | |
| ENTER_GL(); | |
| if (isRenderTarget == FALSE) { | |
| glDescriptor *glDesc; | |
| IWineD3DSurface_PreLoad(pSurface); | |
| /* draw a block of the coloured line on the sufrace */ | |
| IWineD3DSurface_GetGlDesc(pSurface, &glDesc); | |
| for (v = 0 ; v< height;v++) { | |
| glTexSubImage2D(glDesc->target | |
| ,glDesc->level /* level */ | |
| ,left | |
| ,top + v | |
| ,width | |
| ,1 /* height */ | |
| ,GL_RGBA | |
| ,GL_UNSIGNED_BYTE | |
| ,data | |
| ); | |
| } | |
| checkGLcall("glTexSubImage2D"); | |
| /* clean up */ | |
| glDisable(glDesc->target); | |
| } else { | |
| /** FIXME: Using GLClear may be faster **/ | |
| glRasterPos2i(left, top); | |
| glPixelZoom((float)width ,(float)height); | |
| glDrawPixels(1, 1, GL_RGBA, GL_UNSIGNED_BYTE, data); | |
| checkGLcall("glDrawPixels"); | |
| } | |
| HeapFree(GetProcessHeap(), 0, data); | |
| LEAVE_GL(); | |
| return D3D_OK; | |
| } | |
| /* rendertarget and deptth stencil functions */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetRenderTarget(IWineD3DDevice* iface,DWORD RenderTargetIndex, IWineD3DSurface **ppRenderTarget) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /* FIXME: Implelent RenderTargetIndex >0 */ | |
| if(RenderTargetIndex > 0) | |
| FIXME("(%p) : RenderTargetIndex %ld >0 not currently supported\n", This, RenderTargetIndex); | |
| *ppRenderTarget = (IWineD3DSurface *)This->renderTarget; | |
| TRACE("(%p) : RenderTarget %ld Index returning %p\n", This, RenderTargetIndex, *ppRenderTarget); | |
| /* Note inc ref on returned surface */ | |
| if(*ppRenderTarget != NULL) | |
| IWineD3DSurface_AddRef(*ppRenderTarget); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetDepthStencilSurface(IWineD3DDevice* iface, IWineD3DSurface **ppZStencilSurface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| *ppZStencilSurface = (IWineD3DSurface *)This->depthStencilBuffer; | |
| TRACE("(%p) : zStencilSurface returning %p\n", This, *ppZStencilSurface); | |
| if(*ppZStencilSurface != NULL) { | |
| /* Note inc ref on returned surface */ | |
| IWineD3DSurface_AddRef(*ppZStencilSurface); | |
| } | |
| return D3D_OK; | |
| } | |
| /* internal static helper functions */ | |
| HRESULT WINAPI static IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface, | |
| IWineD3DSurface *RenderSurface); | |
| HRESULT WINAPI static IWineD3DDeviceImpl_CleanRender(IWineD3DDevice* iface, IWineD3DSwapChainImpl *swapchain); | |
| HRESULT WINAPI static IWineD3DDeviceImpl_FindGLContext(IWineD3DDevice *iface, IWineD3DSurface *pSurface, glContext **context); | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetRenderTarget(IWineD3DDevice *iface, DWORD RenderTargetIndex, IWineD3DSurface *pRenderTarget) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| HRESULT hr = D3D_OK; | |
| WINED3DVIEWPORT viewport; | |
| TRACE("(%p) Swapping rendertarget\n",This); | |
| if (RenderTargetIndex > 0) { | |
| FIXME("(%p) Render targets other than the first are not supported\n",This); | |
| RenderTargetIndex = 0; | |
| } | |
| /* MSDN says that null disables the render target | |
| but a device must always be associated with a render target | |
| nope MSDN says that we return invalid call to a null rendertarget with an index of 0 | |
| see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/AdvancedTopics/PixelPipe/MultipleRenderTarget.asp | |
| for more details | |
| */ | |
| if (RenderTargetIndex == 0 && pRenderTarget == NULL) { | |
| FIXME("Trying to set render target 0 to NULL\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| /* TODO: replace Impl* usage with interface usage */ | |
| if (!((IWineD3DSurfaceImpl *)pRenderTarget)->resource.usage & D3DUSAGE_RENDERTARGET) { | |
| FIXME("(%p)Trying to set the render target to a surface(%p) that wasn't created with a usage of D3DUSAGE_RENDERTARGET\n",This ,pRenderTarget); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| /** TODO: check that the depth stencil format matches the render target, this is only done in debug | |
| * builds, but I think wine counts as a 'debug' build for now. | |
| ******************************/ | |
| /* If we are trying to set what we already have, don't bother */ | |
| if (pRenderTarget == This->renderTarget) { | |
| TRACE("Trying to do a NOP SetRenderTarget operation\n"); | |
| } else { | |
| /* Otherwise, set the render target up */ | |
| if (FALSE == This->sceneEnded) { | |
| IWineD3DDevice_EndScene(iface); | |
| } | |
| TRACE("clearing renderer\n"); | |
| /* IWineD3DDeviceImpl_CleanRender(iface); */ | |
| /* OpenGL doesn't support 'sharing' of the stencilBuffer so we may incure an extra memory overhead | |
| depending on the renter target implementation being used. | |
| A shared context implementation will share all buffers between all rendertargets (including swapchains), | |
| implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the | |
| stencil buffer and incure an extra memory overhead */ | |
| hr = IWineD3DDeviceImpl_ActiveRender(iface, pRenderTarget); | |
| } | |
| if (SUCCEEDED(hr)) { | |
| /* Finally, reset the viewport as the MSDN states. */ | |
| /* TODO: Replace impl usage */ | |
| viewport.Height = ((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height; | |
| viewport.Width = ((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Width; | |
| viewport.X = 0; | |
| viewport.Y = 0; | |
| viewport.MaxZ = 1.0f; | |
| viewport.MinZ = 0.0f; | |
| IWineD3DDeviceImpl_SetViewport(iface, &viewport); | |
| } else { | |
| FIXME("Unknown error setting the render target\n"); | |
| } | |
| This->sceneEnded = FALSE; | |
| return hr; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetDepthStencilSurface(IWineD3DDevice *iface, IWineD3DSurface *pNewZStencil) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| HRESULT hr = D3D_OK; | |
| IWineD3DSurface *tmp; | |
| TRACE("(%p) Swapping z-buffer\n",This); | |
| if (pNewZStencil == This->stencilBufferTarget) { | |
| TRACE("Trying to do a NOP SetRenderTarget operation\n"); | |
| } else { | |
| /** OpenGL doesn't support 'sharing' of the stencilBuffer so we may incure an extra memory overhead | |
| * depending on the renter target implementation being used. | |
| * A shared context implementation will share all buffers between all rendertargets (including swapchains), | |
| * implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the | |
| * stencil buffer and incure an extra memory overhead | |
| ******************************************************/ | |
| tmp = This->stencilBufferTarget; | |
| This->stencilBufferTarget = pNewZStencil; | |
| /* should we be calling the parent or the wined3d surface? */ | |
| if (NULL != This->stencilBufferTarget) IWineD3DSurface_AddRef(This->stencilBufferTarget); | |
| if (NULL != tmp) IWineD3DSurface_Release(tmp); | |
| hr = D3D_OK; | |
| /** TODO: glEnable/glDisable on depth/stencil depending on | |
| * pNewZStencil is NULL and the depth/stencil is enabled in d3d | |
| **********************************************************/ | |
| } | |
| return hr; | |
| } | |
| /* Internal functions not in DirectX */ | |
| /** TODO: move this off to the opengl context manager | |
| *(the swapchain doesn't need to know anything about offscreen rendering!) | |
| ****************************************************/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_CleanRender(IWineD3DDevice* iface, IWineD3DSwapChainImpl *swapchain) | |
| { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| TRACE("(%p), %p\n", This, swapchain); | |
| if (swapchain->win != swapchain->drawable) { | |
| /* Set everything back the way it ws */ | |
| swapchain->render_ctx = swapchain->glCtx; | |
| swapchain->drawable = swapchain->win; | |
| } | |
| return D3D_OK; | |
| } | |
| /* TODO: move this off into a context manager so that GLX_ATI_render_texture and other types of surface can be used. */ | |
| HRESULT WINAPI IWineD3DDeviceImpl_FindGLContext(IWineD3DDevice *iface, IWineD3DSurface *pSurface, glContext **context) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| int i; | |
| int width; | |
| int height; | |
| WINED3DFORMAT format; | |
| WINED3DSURFACE_DESC surfaceDesc; | |
| memset(&surfaceDesc, 0, sizeof(surfaceDesc)); | |
| surfaceDesc.Width = &width; | |
| surfaceDesc.Height = &height; | |
| surfaceDesc.Format = &format; | |
| IWineD3DSurface_GetDesc(pSurface, &surfaceDesc); | |
| *context = NULL; | |
| /* I need a get width/height function (and should do something with the format) */ | |
| for (i = 0; i < CONTEXT_CACHE; ++i) { | |
| /** NOTE: the contextCache[i].pSurface == pSurface check ceates onepbuffer per surface | |
| ATI cards don't destroy pbuffers, but as soon as resource releasing callbacks are inplace | |
| the pSurface can be set to 0 allowing it to be reused from cache **/ | |
| if (This->contextCache[i].Width == width && This->contextCache[i].Height == height | |
| && (pbuffer_per_surface == FALSE || This->contextCache[i].pSurface == pSurface || This->contextCache[i].pSurface == NULL)) { | |
| *context = &This->contextCache[i]; | |
| break; | |
| } | |
| if (This->contextCache[i].Width == 0) { | |
| This->contextCache[i].pSurface = pSurface; | |
| This->contextCache[i].Width = width; | |
| This->contextCache[i].Height = height; | |
| *context = &This->contextCache[i]; | |
| break; | |
| } | |
| } | |
| if (i == CONTEXT_CACHE) { | |
| int minUsage = 0x7FFFFFFF; /* MAX_INT */ | |
| glContext *dropContext = 0; | |
| for (i = 0; i < CONTEXT_CACHE; i++) { | |
| if (This->contextCache[i].usedcount < minUsage) { | |
| dropContext = &This->contextCache[i]; | |
| minUsage = This->contextCache[i].usedcount; | |
| } | |
| } | |
| /* clean up the context (this doesn't work for ATI at the moment */ | |
| #if 0 | |
| glXDestroyContext(swapchain->display, dropContext->context); | |
| glXDestroyPbuffer(swapchain->display, dropContext->drawable); | |
| #endif | |
| FIXME("Leak\n"); | |
| dropContext->Width = 0; | |
| dropContext->pSurface = pSurface; | |
| *context = dropContext; | |
| } else { | |
| if (++This->contextCache[i].usedcount == 0x7FFFFFFF /* MAX_INT */ - 1 ) { | |
| for (i = 0; i < CONTEXT_CACHE; i++) { | |
| This->contextCache[i].usedcount = max(0, This->contextCache[i].usedcount - (0x7FFFFFFF /* MAX_INT */ >> 1)); | |
| } | |
| } | |
| } | |
| if (*context != NULL) | |
| return D3D_OK; | |
| else | |
| return E_OUTOFMEMORY; | |
| } | |
| /** FIXME: This is currently used called whenever SetRenderTarget or SetStencilBuffer are called | |
| * the functionality needs splitting up so that we don't do more than we should do. | |
| * this only seems to impact performance a little. | |
| ******************************/ | |
| HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface, | |
| IWineD3DSurface *RenderSurface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| IWineD3DSurface *StencilSurface = This->stencilBufferTarget; | |
| HRESULT ret = D3DERR_INVALIDCALL; | |
| IWineD3DSurface *tmp; | |
| /** | |
| * Currently only active for GLX >= 1.3 | |
| * for others versions we'll have to use GLXPixmaps | |
| * | |
| * normally we must test GLX_VERSION_1_3 but nvidia headers are not correct | |
| * as they implement GLX 1.3 but only define GLX_VERSION_1_2 | |
| * so only check OpenGL version | |
| * .......................... | |
| * I don't believe that it is a problem with NVidia headers, | |
| * XFree only supports GLX1.2, nVidia (and ATI to some extent) provide 1.3 functions | |
| * in GLX 1.2, there is no mention of the correct way to tell if the extensions are provided. | |
| * ATI Note: | |
| * Your application will report GLX version 1.2 on glXQueryVersion. | |
| * However, it is safe to call the GLX 1.3 functions as described below. | |
| */ | |
| #if defined(GL_VERSION_1_3) | |
| /** TODO: we only need to look up the configuration !IF! we are setting the target to a texture **/ | |
| GLXFBConfig* cfgs = NULL; | |
| int nCfgs = 0; | |
| int attribs[256]; | |
| int nAttribs = 0; | |
| IWineD3DSwapChain *currentSwapchain; | |
| IWineD3DSwapChainImpl *swapchain; | |
| /** TODO: get rid of Impl usage we should always create a zbuffer/stencil with our contexts if possible, | |
| * but switch them off if the StencilSurface is set to NULL | |
| ** *********************************************************/ | |
| D3DFORMAT BackBufferFormat = ((IWineD3DSurfaceImpl *) RenderSurface)->resource.format; | |
| D3DFORMAT StencilBufferFormat = (NULL != StencilSurface) ? ((IWineD3DSurfaceImpl *) StencilSurface)->resource.format : 0; | |
| /**TODO: | |
| if StencilSurface == NULL && zBufferTarget != NULL then switch the zbuffer off, | |
| it StencilSurface != NULL && zBufferTarget == NULL switch it on | |
| */ | |
| #define PUSH1(att) attribs[nAttribs++] = (att); | |
| #define PUSH2(att,value) attribs[nAttribs++] = (att); attribs[nAttribs++] = (value); | |
| /* PUSH2(GLX_BIND_TO_TEXTURE_RGBA_ATI, True); examples of this are few and far between (but I've got a nice working one!)*/ | |
| /** TODO: remove the reff to Impl (context manager should fix this!) **/ | |
| IWineD3DSwapChainImpl *impSwapChain; | |
| IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **)&impSwapChain); | |
| if (NULL == impSwapChain) { /* NOTE: This should NEVER fail */ | |
| ERR("(%p) Failed to get a the implicit swapchain\n", iface); | |
| } | |
| ENTER_GL(); | |
| PUSH2(GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT); | |
| PUSH2(GLX_X_RENDERABLE, TRUE); | |
| PUSH2(GLX_DOUBLEBUFFER, TRUE); | |
| TRACE("calling makeglcfg\n"); | |
| D3DFmtMakeGlCfg(BackBufferFormat, StencilBufferFormat, attribs, &nAttribs, FALSE /* alternate */); | |
| PUSH1(None); | |
| TRACE("calling chooseFGConfig\n"); | |
| cfgs = glXChooseFBConfig(impSwapChain->display, DefaultScreen(impSwapChain->display), | |
| attribs, &nCfgs); | |
| if (!cfgs) { /* OK we didn't find the exact config, so use any reasonable match */ | |
| /* TODO: fill in the 'requested' and 'current' depths, also make sure that's | |
| why we failed and only show this message once! */ | |
| 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"); /**/ | |
| nAttribs = 0; | |
| PUSH2(GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT); | |
| /* PUSH2(GLX_X_RENDERABLE, TRUE); */ | |
| PUSH2(GLX_RENDER_TYPE, GLX_RGBA_BIT); | |
| PUSH2(GLX_DOUBLEBUFFER, FALSE); | |
| TRACE("calling makeglcfg\n"); | |
| D3DFmtMakeGlCfg(BackBufferFormat, StencilBufferFormat, attribs, &nAttribs, TRUE /* alternate */); | |
| PUSH1(None); | |
| cfgs = glXChooseFBConfig(impSwapChain->display, DefaultScreen(impSwapChain->display), | |
| attribs, &nCfgs); | |
| } | |
| if (NULL != cfgs) { | |
| #ifdef EXTRA_TRACES | |
| int i; | |
| for (i = 0; i < nCfgs; ++i) { | |
| TRACE("for (%u,%s)/(%u,%s) found config[%d]@%p\n", BackBufferFormat, | |
| debug_d3dformat(BackBufferFormat), StencilBufferFormat, | |
| debug_d3dformat(StencilBufferFormat), i, cfgs[i]); | |
| } | |
| if (NULL != This->renderTarget) { | |
| glFlush(); | |
| vcheckGLcall("glFlush"); | |
| /** This is only useful if the old render target was a swapchain, | |
| * we need to supercede this with a function that displays | |
| * the current buffer on the screen. This is easy to do in glx1.3 but | |
| * we need to do copy-write pixels in glx 1.2. | |
| ************************************************/ | |
| glXSwapBuffers(impSwapChain->display, impSwapChain->drawable); | |
| printf("Hit Enter to get next frame ...\n"); | |
| getchar(); | |
| } | |
| #endif | |
| } | |
| if (IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DSwapChain, (void **)¤tSwapchain) != D3D_OK) { | |
| /* the selected render target doesn't belong to a swapchain, so use the devices implicit swapchain */ | |
| IWineD3DDevice_GetSwapChain(iface, 0, ¤tSwapchain); | |
| } | |
| /** | |
| * TODO: remove the use of IWineD3DSwapChainImpl, a context manager will help since it will replace the | |
| * renderTarget = swapchain->backBuffer bit and anything to do with *glContexts | |
| **********************************************************************/ | |
| if (IWineD3DSurface_GetContainer(RenderSurface, &IID_IWineD3DSwapChain, (void **)&swapchain) == D3D_OK) { | |
| /* We also need to make sure that the lights &co are also in the context of the swapchains */ | |
| /* FIXME: If the render target gets sent to the frontBuffer should be be presenting it raw? */ | |
| TRACE("making swapchain active\n"); | |
| if (RenderSurface != This->renderTarget) { | |
| if (RenderSurface == swapchain->backBuffer) { | |
| } else { | |
| /* This could be flagged so that some operations work directly with the front buffer */ | |
| FIXME("Attempting to set the renderTarget to the frontBuffer\n"); | |
| } | |
| if (glXMakeCurrent(swapchain->display, swapchain->win, swapchain->glCtx) | |
| == False) { | |
| TRACE("Error in setting current context: context %p drawable %ld !\n", | |
| impSwapChain->glCtx, impSwapChain->win); | |
| } | |
| IWineD3DDeviceImpl_CleanRender(iface, (IWineD3DSwapChainImpl *)currentSwapchain); | |
| } | |
| checkGLcall("glXMakeContextCurrent"); | |
| IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain); | |
| } | |
| else if (pbuffer_support == TRUE && cfgs != NULL /* && some test to make sure that opengl supports pbuffers */) { | |
| /** ******************************************************************** | |
| * This is a quickly hacked out implementation of offscreen textures. | |
| * It will work in most cases but there may be problems if the client | |
| * modifies the texture directly, or expects the contents of the rendertarget | |
| * to be persistent. | |
| * | |
| * There are some real speed vs compatibility issues here: | |
| * we should really use a new context for every texture, but that eats ram. | |
| * we should also be restoring the texture to the pbuffer but that eats CPU | |
| * we can also 'reuse' the current pbuffer if the size is larger than the requested buffer, | |
| * but if this means reusing the display backbuffer then we need to make sure that | |
| * states are correctly preserved. | |
| * In many cases I would expect that we can 'skip' some functions, such as preserving states, | |
| * and gain a good performance increase at the cost of compatibility. | |
| * I would suggest that, when this is the case, a user configurable flag be made | |
| * available, allowing the user to choose the best emmulated experience for them. | |
| *********************************************************************/ | |
| XVisualInfo *visinfo; | |
| glContext *newContext; | |
| /* Here were using a shared context model */ | |
| if (D3D_OK != IWineD3DDeviceImpl_FindGLContext(iface, RenderSurface, &newContext)) { | |
| FIXME("(%p) : Failed to find a context for surface %p\n", iface, RenderSurface); | |
| } | |
| /* If the context doesn't exist then create a new one */ | |
| /* TODO: This should really be part of findGlContext */ | |
| if (NULL == newContext->context) { | |
| TRACE("making new buffer\n"); | |
| nAttribs = 0; | |
| PUSH2(GLX_PBUFFER_WIDTH, newContext->Width); | |
| PUSH2(GLX_PBUFFER_HEIGHT, newContext->Height); | |
| PUSH1(None); | |
| newContext->drawable = glXCreatePbuffer(impSwapChain->display, cfgs[0], attribs); | |
| /** **************************************** | |
| *GLX1.3 isn't supported by XFree 'yet' untill that point ATI emulates pBuffers | |
| *they note: | |
| * In future releases, we may provide the calls glXCreateNewContext, | |
| * glXQueryDrawable and glXMakeContextCurrent. | |
| * so until then we have to use glXGetVisualFromFBConfig &co.. | |
| ********************************************/ | |
| visinfo = glXGetVisualFromFBConfig(impSwapChain->display, cfgs[0]); | |
| if (!visinfo) { | |
| ERR("Error: couldn't get an RGBA, double-buffered visual\n"); | |
| } else { | |
| newContext->context = glXCreateContext(impSwapChain->display, visinfo, impSwapChain->glCtx, GL_TRUE); | |
| XFree(visinfo); | |
| } | |
| } | |
| if (NULL == newContext || NULL == newContext->context) { | |
| ERR("(%p) : Failed to find a context for surface %p\n", iface, RenderSurface); | |
| } else { | |
| /* Debug logging, (this function leaks), change to a TRACE when the leak is plugged */ | |
| if (glXMakeCurrent(impSwapChain->display, newContext->drawable, newContext->context) == False) { | |
| TRACE("Error in setting current context: context %p drawable %ld\n", newContext->context, newContext->drawable); | |
| } | |
| /* Clean up the old context */ | |
| IWineD3DDeviceImpl_CleanRender(iface, (IWineD3DSwapChainImpl *)currentSwapchain); | |
| /* Set the current context of the swapchain to the new context */ | |
| impSwapChain->drawable = newContext->drawable; | |
| impSwapChain->render_ctx = newContext->context; | |
| } | |
| } | |
| #if 0 /* Apply the stateblock to the new context | |
| FIXME: This is a bit of a hack, each context should know it's own state, | |
| the directX current directX state should then be applied to the context */ | |
| BOOL oldRecording; | |
| IWineD3DStateBlockImpl *oldUpdateStateBlock; | |
| oldUpdateStateBlock = This->updateStateBlock; | |
| oldRecording= This->isRecordingState; | |
| This->isRecordingState = FALSE; | |
| This->updateStateBlock = This->stateBlock; | |
| IWineD3DStateBlock_Apply((IWineD3DStateBlock *)This->stateBlock); | |
| This->isRecordingState = oldRecording; | |
| This->updateStateBlock = oldUpdateStateBlock; | |
| #endif | |
| /* clean up the current rendertargets swapchain (if it belonged to one) */ | |
| if (currentSwapchain != NULL) { | |
| IWineD3DSwapChain_Release((IWineD3DSwapChain *)currentSwapchain); | |
| } | |
| /* Were done with the opengl context management, setup the rendertargets */ | |
| tmp = This->renderTarget; | |
| This->renderTarget = RenderSurface; | |
| IWineD3DSurface_AddRef(This->renderTarget); | |
| IWineD3DSurface_Release(tmp); | |
| { | |
| DWORD value; | |
| /* The surface must be rendered upside down to cancel the flip produce by glCopyTexImage */ | |
| /* Check that the container is not a swapchain member */ | |
| IWineD3DSwapChain *tmpSwapChain; | |
| if (D3D_OK != IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DSwapChain, (void **)&tmpSwapChain)) { | |
| This->renderUpsideDown = TRUE; | |
| }else{ | |
| This->renderUpsideDown = FALSE; | |
| IWineD3DSwapChain_Release(tmpSwapChain); | |
| } | |
| /* Force updating the cull mode */ | |
| TRACE("setting render state\n"); | |
| IWineD3DDevice_GetRenderState(iface, WINED3DRS_CULLMODE, &value); | |
| IWineD3DDevice_SetRenderState(iface, WINED3DRS_CULLMODE, value); | |
| /* Force updating projection matrix */ | |
| This->last_was_rhw = FALSE; | |
| This->proj_valid = FALSE; | |
| } | |
| ret = D3D_OK; | |
| if (cfgs != NULL) { | |
| XFree(cfgs); | |
| } else { | |
| ERR("cannot get valides GLXFBConfig for (%u,%s)/(%u,%s)\n", BackBufferFormat, | |
| debug_d3dformat(BackBufferFormat), StencilBufferFormat, debug_d3dformat(StencilBufferFormat)); | |
| } | |
| #undef PUSH1 | |
| #undef PUSH2 | |
| if ( NULL != impSwapChain) { | |
| IWineD3DSwapChain_Release((IWineD3DSwapChain *)impSwapChain); | |
| } | |
| LEAVE_GL(); | |
| #endif | |
| return ret; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice* iface, UINT XHotSpot, | |
| UINT YHotSpot, IWineD3DSurface *pCursorBitmap) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| /* TODO: the use of Impl is deprecated. */ | |
| /* some basic validation checks */ | |
| IWineD3DSurfaceImpl * pSur = (IWineD3DSurfaceImpl *) pCursorBitmap; | |
| TRACE("(%p) : Spot Pos(%u,%u)\n", This, XHotSpot, YHotSpot); | |
| if (WINED3DFMT_A8R8G8B8 != pSur->resource.format) { | |
| ERR("(%p) : surface(%p) has an invalid format\n", This, pCursorBitmap); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| if (32 != pSur->currentDesc.Height || 32 != pSur->currentDesc.Width) { | |
| ERR("(%p) : surface(%p) has an invalid size\n", This, pCursorBitmap); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| /* TODO: make the cursor 'real' */ | |
| This->xHotSpot = XHotSpot; | |
| This->yHotSpot = YHotSpot; | |
| return D3D_OK; | |
| } | |
| void WINAPI IWineD3DDeviceImpl_SetCursorPosition(IWineD3DDevice* iface, int XScreenSpace, int YScreenSpace, DWORD Flags) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| TRACE("(%p) : SetPos to (%u,%u)\n", This, XScreenSpace, YScreenSpace); | |
| This->xScreenSpace = XScreenSpace; | |
| This->yScreenSpace = YScreenSpace; | |
| return; | |
| } | |
| BOOL WINAPI IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOOL bShow) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| TRACE("(%p) : visible(%d)\n", This, bShow); | |
| This->bCursorVisible = bShow; | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_TestCooperativeLevel(IWineD3DDevice* iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| FIXME("(%p) : stub\n", This); /* No way of notifying yet! */ | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_EvictManagedResources(IWineD3DDevice* iface) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| /** FIXME: Resource tracking needs to be done, | |
| * The closes we can do to this is set the priorities of all managed textures low | |
| * and then reset them. | |
| ***********************************************************/ | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_Rest(IWineD3DDevice* iface, D3DPRESENT_PARAMETERS* pPresentationParameters) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| /** FIXME: Resource trascking needs to be done. | |
| * in effect this pulls all non only default | |
| * textures out of video memory and deletes all glTextures (glDeleteTextures) | |
| * and should clear down the context and set it up according to pPresentationParameters | |
| ***********************************************************/ | |
| FIXME("(%p) : stub\n", This); | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_SetDialogBoxMode(IWineD3DDevice *iface, BOOL bEnableDialogs) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; | |
| /** FIXME: always true at the moment **/ | |
| if(bEnableDialogs == FALSE) { | |
| FIXME("(%p) Dialogs cannot be disabled yet\n", This); | |
| } | |
| return D3D_OK; | |
| } | |
| HRESULT WINAPI IWineD3DDeviceImpl_GetCreationParameters(IWineD3DDevice *iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) { | |
| IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; | |
| FIXME("(%p) : stub\n", This); | |
| /* Setup some reasonable defaults */ | |
| pParameters->AdapterOrdinal = 0; /* always for now */ | |
| pParameters->DeviceType = D3DDEVTYPE_HAL; /* always for now */ | |
| pParameters->hFocusWindow = 0; | |
| pParameters->BehaviorFlags =0; | |
| return D3D_OK; | |
| } | |
| void WINAPI IWineD3DDeviceImpl_SetGammaRamp(IWineD3DDevice * iface, UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp) { | |
| IWineD3DSwapChain *swapchain; | |
| HRESULT hrc = D3D_OK; | |
| TRACE("Relaying to swapchain\n"); | |
| if ((hrc = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain)) == D3D_OK) { | |
| IWineD3DSwapChain_SetGammaRamp(swapchain, Flags, (D3DGAMMARAMP *)pRamp); | |
| IWineD3DSwapChain_Release(swapchain); | |
| } | |
| return; | |
| } | |
| void WINAPI IWineD3DDeviceImpl_GetGammaRamp(IWineD3DDevice *iface, UINT iSwapChain, D3DGAMMARAMP* pRamp) { | |
| IWineD3DSwapChain *swapchain; | |
| HRESULT hrc = D3D_OK; | |
| TRACE("Relaying to swapchain\n"); | |
| if ((hrc = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain)) == D3D_OK) { | |
| hrc =IWineD3DSwapChain_GetGammaRamp(swapchain, pRamp); | |
| IWineD3DSwapChain_Release(swapchain); | |
| } | |
| return; | |
| } | |
| /********************************************************** | |
| * IWineD3DDevice VTbl follows | |
| **********************************************************/ | |
| const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl = | |
| { | |
| /*** IUnknown methods ***/ | |
| IWineD3DDeviceImpl_QueryInterface, | |
| IWineD3DDeviceImpl_AddRef, | |
| IWineD3DDeviceImpl_Release, | |
| /*** IWineD3DDevice methods ***/ | |
| IWineD3DDeviceImpl_GetParent, | |
| /*** Creation methods**/ | |
| IWineD3DDeviceImpl_CreateVertexBuffer, | |
| IWineD3DDeviceImpl_CreateIndexBuffer, | |
| IWineD3DDeviceImpl_CreateStateBlock, | |
| IWineD3DDeviceImpl_CreateSurface, | |
| IWineD3DDeviceImpl_CreateTexture, | |
| IWineD3DDeviceImpl_CreateVolumeTexture, | |
| IWineD3DDeviceImpl_CreateVolume, | |
| IWineD3DDeviceImpl_CreateCubeTexture, | |
| IWineD3DDeviceImpl_CreateQuery, | |
| IWineD3DDeviceImpl_CreateAdditionalSwapChain, | |
| IWineD3DDeviceImpl_CreateVertexDeclaration, | |
| IWineD3DDeviceImpl_CreateVertexShader, | |
| IWineD3DDeviceImpl_CreatePixelShader, | |
| /*** Odd functions **/ | |
| IWineD3DDeviceImpl_EvictManagedResources, | |
| IWineD3DDeviceImpl_GetAvailableTextureMem, | |
| IWineD3DDeviceImpl_GetBackBuffer, | |
| IWineD3DDeviceImpl_GetCreationParameters, | |
| IWineD3DDeviceImpl_GetDeviceCaps, | |
| IWineD3DDeviceImpl_GetDirect3D, | |
| IWineD3DDeviceImpl_GetDisplayMode, | |
| IWineD3DDeviceImpl_GetNumberOfSwapChains, | |
| IWineD3DDeviceImpl_GetRasterStatus, | |
| IWineD3DDeviceImpl_GetSwapChain, | |
| IWineD3DDeviceImpl_Reset, | |
| IWineD3DDeviceImpl_SetDialogBoxMode, | |
| IWineD3DDeviceImpl_SetCursorProperties, | |
| IWineD3DDeviceImpl_SetCursorPosition, | |
| IWineD3DDeviceImpl_ShowCursor, | |
| IWineD3DDeviceImpl_TestCooperativeLevel, | |
| /*** Getters and setters **/ | |
| IWineD3DDeviceImpl_SetClipPlane, | |
| IWineD3DDeviceImpl_GetClipPlane, | |
| IWineD3DDeviceImpl_SetClipStatus, | |
| IWineD3DDeviceImpl_GetClipStatus, | |
| IWineD3DDeviceImpl_SetCurrentTexturePalette, | |
| IWineD3DDeviceImpl_GetCurrentTexturePalette, | |
| IWineD3DDeviceImpl_SetDepthStencilSurface, | |
| IWineD3DDeviceImpl_GetDepthStencilSurface, | |
| IWineD3DDeviceImpl_SetFVF, | |
| IWineD3DDeviceImpl_GetFVF, | |
| IWineD3DDeviceImpl_SetGammaRamp, | |
| IWineD3DDeviceImpl_GetGammaRamp, | |
| IWineD3DDeviceImpl_SetIndices, | |
| IWineD3DDeviceImpl_GetIndices, | |
| IWineD3DDeviceImpl_SetLight, | |
| IWineD3DDeviceImpl_GetLight, | |
| IWineD3DDeviceImpl_SetLightEnable, | |
| IWineD3DDeviceImpl_GetLightEnable, | |
| IWineD3DDeviceImpl_SetMaterial, | |
| IWineD3DDeviceImpl_GetMaterial, | |
| IWineD3DDeviceImpl_SetNPatchMode, | |
| IWineD3DDeviceImpl_GetNPatchMode, | |
| IWineD3DDeviceImpl_SetPaletteEntries, | |
| IWineD3DDeviceImpl_GetPaletteEntries, | |
| IWineD3DDeviceImpl_SetPixelShader, | |
| IWineD3DDeviceImpl_GetPixelShader, | |
| IWineD3DDeviceImpl_SetPixelShaderConstantB, | |
| IWineD3DDeviceImpl_GetPixelShaderConstantB, | |
| IWineD3DDeviceImpl_SetPixelShaderConstantI, | |
| IWineD3DDeviceImpl_GetPixelShaderConstantI, | |
| IWineD3DDeviceImpl_SetPixelShaderConstantF, | |
| IWineD3DDeviceImpl_GetPixelShaderConstantF, | |
| IWineD3DDeviceImpl_SetRenderState, | |
| IWineD3DDeviceImpl_GetRenderState, | |
| IWineD3DDeviceImpl_SetRenderTarget, | |
| IWineD3DDeviceImpl_GetRenderTarget, | |
| IWineD3DDeviceImpl_SetSamplerState, | |
| IWineD3DDeviceImpl_GetSamplerState, | |
| IWineD3DDeviceImpl_SetScissorRect, | |
| IWineD3DDeviceImpl_GetScissorRect, | |
| IWineD3DDeviceImpl_SetSoftwareVertexProcessing, | |
| IWineD3DDeviceImpl_GetSoftwareVertexProcessing, | |
| IWineD3DDeviceImpl_SetStreamSource, | |
| IWineD3DDeviceImpl_GetStreamSource, | |
| IWineD3DDeviceImpl_SetStreamSourceFreq, | |
| IWineD3DDeviceImpl_GetStreamSourceFreq, | |
| IWineD3DDeviceImpl_SetTexture, | |
| IWineD3DDeviceImpl_GetTexture, | |
| IWineD3DDeviceImpl_SetTextureStageState, | |
| IWineD3DDeviceImpl_GetTextureStageState, | |
| IWineD3DDeviceImpl_SetTransform, | |
| IWineD3DDeviceImpl_GetTransform, | |
| IWineD3DDeviceImpl_SetVertexDeclaration, | |
| IWineD3DDeviceImpl_GetVertexDeclaration, | |
| IWineD3DDeviceImpl_SetVertexShader, | |
| IWineD3DDeviceImpl_GetVertexShader, | |
| IWineD3DDeviceImpl_SetVertexShaderConstantB, | |
| IWineD3DDeviceImpl_GetVertexShaderConstantB, | |
| IWineD3DDeviceImpl_SetVertexShaderConstantI, | |
| IWineD3DDeviceImpl_GetVertexShaderConstantI, | |
| IWineD3DDeviceImpl_SetVertexShaderConstantF, | |
| IWineD3DDeviceImpl_GetVertexShaderConstantF, | |
| IWineD3DDeviceImpl_SetViewport, | |
| IWineD3DDeviceImpl_GetViewport, | |
| IWineD3DDeviceImpl_MultiplyTransform, | |
| IWineD3DDeviceImpl_ValidateDevice, | |
| IWineD3DDeviceImpl_ProcessVertices, | |
| /*** State block ***/ | |
| IWineD3DDeviceImpl_BeginStateBlock, | |
| IWineD3DDeviceImpl_EndStateBlock, | |
| /*** Scene management ***/ | |
| IWineD3DDeviceImpl_BeginScene, | |
| IWineD3DDeviceImpl_EndScene, | |
| IWineD3DDeviceImpl_Present, | |
| IWineD3DDeviceImpl_Clear, | |
| /*** Drawing ***/ | |
| IWineD3DDeviceImpl_DrawPrimitive, | |
| IWineD3DDeviceImpl_DrawIndexedPrimitive, | |
| IWineD3DDeviceImpl_DrawPrimitiveUP, | |
| IWineD3DDeviceImpl_DrawIndexedPrimitiveUP, | |
| IWineD3DDeviceImpl_DrawRectPatch, | |
| IWineD3DDeviceImpl_DrawTriPatch, | |
| IWineD3DDeviceImpl_DeletePatch, | |
| IWineD3DDeviceImpl_ColorFill, | |
| IWineD3DDeviceImpl_UpdateTexture, | |
| IWineD3DDeviceImpl_UpdateSurface, | |
| IWineD3DDeviceImpl_StretchRect, | |
| IWineD3DDeviceImpl_GetRenderTargetData, | |
| IWineD3DDeviceImpl_GetFrontBufferData, | |
| /*** Internal use IWineD3DDevice methods ***/ | |
| IWineD3DDeviceImpl_SetupTextureStates | |
| }; | |
| const DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R] = { | |
| WINED3DRS_ALPHABLENDENABLE , | |
| WINED3DRS_ALPHAFUNC , | |
| WINED3DRS_ALPHAREF , | |
| WINED3DRS_ALPHATESTENABLE , | |
| WINED3DRS_BLENDOP , | |
| WINED3DRS_COLORWRITEENABLE , | |
| WINED3DRS_DESTBLEND , | |
| WINED3DRS_DITHERENABLE , | |
| WINED3DRS_FILLMODE , | |
| WINED3DRS_FOGDENSITY , | |
| WINED3DRS_FOGEND , | |
| WINED3DRS_FOGSTART , | |
| WINED3DRS_LASTPIXEL , | |
| WINED3DRS_SHADEMODE , | |
| WINED3DRS_SRCBLEND , | |
| WINED3DRS_STENCILENABLE , | |
| WINED3DRS_STENCILFAIL , | |
| WINED3DRS_STENCILFUNC , | |
| WINED3DRS_STENCILMASK , | |
| WINED3DRS_STENCILPASS , | |
| WINED3DRS_STENCILREF , | |
| WINED3DRS_STENCILWRITEMASK , | |
| WINED3DRS_STENCILZFAIL , | |
| WINED3DRS_TEXTUREFACTOR , | |
| WINED3DRS_WRAP0 , | |
| WINED3DRS_WRAP1 , | |
| WINED3DRS_WRAP2 , | |
| WINED3DRS_WRAP3 , | |
| WINED3DRS_WRAP4 , | |
| WINED3DRS_WRAP5 , | |
| WINED3DRS_WRAP6 , | |
| WINED3DRS_WRAP7 , | |
| WINED3DRS_ZENABLE , | |
| WINED3DRS_ZFUNC , | |
| WINED3DRS_ZWRITEENABLE | |
| }; | |
| const DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T] = { | |
| WINED3DTSS_ADDRESSW , | |
| WINED3DTSS_ALPHAARG0 , | |
| WINED3DTSS_ALPHAARG1 , | |
| WINED3DTSS_ALPHAARG2 , | |
| WINED3DTSS_ALPHAOP , | |
| WINED3DTSS_BUMPENVLOFFSET , | |
| WINED3DTSS_BUMPENVLSCALE , | |
| WINED3DTSS_BUMPENVMAT00 , | |
| WINED3DTSS_BUMPENVMAT01 , | |
| WINED3DTSS_BUMPENVMAT10 , | |
| WINED3DTSS_BUMPENVMAT11 , | |
| WINED3DTSS_COLORARG0 , | |
| WINED3DTSS_COLORARG1 , | |
| WINED3DTSS_COLORARG2 , | |
| WINED3DTSS_COLOROP , | |
| WINED3DTSS_RESULTARG , | |
| WINED3DTSS_TEXCOORDINDEX , | |
| WINED3DTSS_TEXTURETRANSFORMFLAGS | |
| }; | |
| const DWORD SavedPixelStates_S[NUM_SAVEDPIXELSTATES_S] = { | |
| WINED3DSAMP_ADDRESSU , | |
| WINED3DSAMP_ADDRESSV , | |
| WINED3DSAMP_ADDRESSW , | |
| WINED3DSAMP_BORDERCOLOR , | |
| WINED3DSAMP_MAGFILTER , | |
| WINED3DSAMP_MINFILTER , | |
| WINED3DSAMP_MIPFILTER , | |
| WINED3DSAMP_MIPMAPLODBIAS , | |
| WINED3DSAMP_MAXMIPLEVEL , | |
| WINED3DSAMP_MAXANISOTROPY , | |
| WINED3DSAMP_SRGBTEXTURE , | |
| WINED3DSAMP_ELEMENTINDEX | |
| }; | |
| const DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R] = { | |
| WINED3DRS_AMBIENT , | |
| WINED3DRS_AMBIENTMATERIALSOURCE , | |
| WINED3DRS_CLIPPING , | |
| WINED3DRS_CLIPPLANEENABLE , | |
| WINED3DRS_COLORVERTEX , | |
| WINED3DRS_DIFFUSEMATERIALSOURCE , | |
| WINED3DRS_EMISSIVEMATERIALSOURCE , | |
| WINED3DRS_FOGDENSITY , | |
| WINED3DRS_FOGEND , | |
| WINED3DRS_FOGSTART , | |
| WINED3DRS_FOGTABLEMODE , | |
| WINED3DRS_FOGVERTEXMODE , | |
| WINED3DRS_INDEXEDVERTEXBLENDENABLE , | |
| WINED3DRS_LIGHTING , | |
| WINED3DRS_LOCALVIEWER , | |
| WINED3DRS_MULTISAMPLEANTIALIAS , | |
| WINED3DRS_MULTISAMPLEMASK , | |
| WINED3DRS_NORMALIZENORMALS , | |
| WINED3DRS_PATCHEDGESTYLE , | |
| WINED3DRS_POINTSCALE_A , | |
| WINED3DRS_POINTSCALE_B , | |
| WINED3DRS_POINTSCALE_C , | |
| WINED3DRS_POINTSCALEENABLE , | |
| WINED3DRS_POINTSIZE , | |
| WINED3DRS_POINTSIZE_MAX , | |
| WINED3DRS_POINTSIZE_MIN , | |
| WINED3DRS_POINTSPRITEENABLE , | |
| WINED3DRS_RANGEFOGENABLE , | |
| WINED3DRS_SPECULARMATERIALSOURCE , | |
| WINED3DRS_TWEENFACTOR , | |
| WINED3DRS_VERTEXBLEND | |
| }; | |
| const DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T] = { | |
| WINED3DTSS_TEXCOORDINDEX , | |
| WINED3DTSS_TEXTURETRANSFORMFLAGS | |
| }; | |
| const DWORD SavedVertexStates_S[NUM_SAVEDVERTEXSTATES_S] = { | |
| WINED3DSAMP_DMAPOFFSET | |
| }; |