ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

d3d: De-pointerize the WINED3DCAPS structure.

This commit is contained in:
Stefan Dösinger 2008-03-18 19:26:00 +01:00 committed by Alexandre Julliard
parent 6d5f562dcf
commit 8869c0f147
9 changed files with 594 additions and 656 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
dlls/d3d8/d3d8_private.h
View File

@ -45,60 +45,60 @@
Macros
=========================================================================== */
/* Not nice, but it lets wined3d support different versions of directx */
#define D3D8CAPSTOWINECAPS(_pD3D8Caps, _pWineCaps) \
_pWineCaps->DeviceType = (WINED3DDEVTYPE *) &_pD3D8Caps->DeviceType; \
_pWineCaps->AdapterOrdinal = &_pD3D8Caps->AdapterOrdinal; \
_pWineCaps->Caps = &_pD3D8Caps->Caps; \
_pWineCaps->Caps2 = &_pD3D8Caps->Caps2; \
_pWineCaps->Caps3 = &_pD3D8Caps->Caps3; \
_pWineCaps->PresentationIntervals = &_pD3D8Caps->PresentationIntervals; \
_pWineCaps->CursorCaps = &_pD3D8Caps->CursorCaps; \
_pWineCaps->DevCaps = &_pD3D8Caps->DevCaps; \
_pWineCaps->PrimitiveMiscCaps = &_pD3D8Caps->PrimitiveMiscCaps; \
_pWineCaps->RasterCaps = &_pD3D8Caps->RasterCaps; \
_pWineCaps->ZCmpCaps = &_pD3D8Caps->ZCmpCaps; \
_pWineCaps->SrcBlendCaps = &_pD3D8Caps->SrcBlendCaps; \
_pWineCaps->DestBlendCaps = &_pD3D8Caps->DestBlendCaps; \
_pWineCaps->AlphaCmpCaps = &_pD3D8Caps->AlphaCmpCaps; \
_pWineCaps->ShadeCaps = &_pD3D8Caps->ShadeCaps; \
_pWineCaps->TextureCaps = &_pD3D8Caps->TextureCaps; \
_pWineCaps->TextureFilterCaps = &_pD3D8Caps->TextureFilterCaps; \
_pWineCaps->CubeTextureFilterCaps = &_pD3D8Caps->CubeTextureFilterCaps; \
_pWineCaps->VolumeTextureFilterCaps = &_pD3D8Caps->VolumeTextureFilterCaps; \
_pWineCaps->TextureAddressCaps = &_pD3D8Caps->TextureAddressCaps; \
_pWineCaps->VolumeTextureAddressCaps = &_pD3D8Caps->VolumeTextureAddressCaps; \
_pWineCaps->LineCaps = &_pD3D8Caps->LineCaps; \
_pWineCaps->MaxTextureWidth = &_pD3D8Caps->MaxTextureWidth; \
_pWineCaps->MaxTextureHeight = &_pD3D8Caps->MaxTextureHeight; \
_pWineCaps->MaxVolumeExtent = &_pD3D8Caps->MaxVolumeExtent; \
_pWineCaps->MaxTextureRepeat = &_pD3D8Caps->MaxTextureRepeat; \
_pWineCaps->MaxTextureAspectRatio = &_pD3D8Caps->MaxTextureAspectRatio; \
_pWineCaps->MaxAnisotropy = &_pD3D8Caps->MaxAnisotropy; \
_pWineCaps->MaxVertexW = &_pD3D8Caps->MaxVertexW; \
_pWineCaps->GuardBandLeft = &_pD3D8Caps->GuardBandLeft; \
_pWineCaps->GuardBandTop = &_pD3D8Caps->GuardBandTop; \
_pWineCaps->GuardBandRight = &_pD3D8Caps->GuardBandRight; \
_pWineCaps->GuardBandBottom = &_pD3D8Caps->GuardBandBottom; \
_pWineCaps->ExtentsAdjust = &_pD3D8Caps->ExtentsAdjust; \
_pWineCaps->StencilCaps = &_pD3D8Caps->StencilCaps; \
_pWineCaps->FVFCaps = &_pD3D8Caps->FVFCaps; \
_pWineCaps->TextureOpCaps = &_pD3D8Caps->TextureOpCaps; \
_pWineCaps->MaxTextureBlendStages = &_pD3D8Caps->MaxTextureBlendStages; \
_pWineCaps->MaxSimultaneousTextures = &_pD3D8Caps->MaxSimultaneousTextures; \
_pWineCaps->VertexProcessingCaps = &_pD3D8Caps->VertexProcessingCaps; \
_pWineCaps->MaxActiveLights = &_pD3D8Caps->MaxActiveLights; \
_pWineCaps->MaxUserClipPlanes = &_pD3D8Caps->MaxUserClipPlanes; \
_pWineCaps->MaxVertexBlendMatrices = &_pD3D8Caps->MaxVertexBlendMatrices; \
_pWineCaps->MaxVertexBlendMatrixIndex = &_pD3D8Caps->MaxVertexBlendMatrixIndex; \
_pWineCaps->MaxPointSize = &_pD3D8Caps->MaxPointSize; \
_pWineCaps->MaxPrimitiveCount = &_pD3D8Caps->MaxPrimitiveCount; \
_pWineCaps->MaxVertexIndex = &_pD3D8Caps->MaxVertexIndex; \
_pWineCaps->MaxStreams = &_pD3D8Caps->MaxStreams; \
_pWineCaps->MaxStreamStride = &_pD3D8Caps->MaxStreamStride; \
_pWineCaps->VertexShaderVersion = &_pD3D8Caps->VertexShaderVersion; \
_pWineCaps->MaxVertexShaderConst = &_pD3D8Caps->MaxVertexShaderConst; \
_pWineCaps->PixelShaderVersion = &_pD3D8Caps->PixelShaderVersion; \
_pWineCaps->PixelShader1xMaxValue = &_pD3D8Caps->MaxPixelShaderValue;
#define WINECAPSTOD3D8CAPS(_pD3D8Caps, _pWineCaps) \
_pD3D8Caps->DeviceType = (D3DDEVTYPE) _pWineCaps->DeviceType; \
_pD3D8Caps->AdapterOrdinal = _pWineCaps->AdapterOrdinal; \
_pD3D8Caps->Caps = _pWineCaps->Caps; \
_pD3D8Caps->Caps2 = _pWineCaps->Caps2; \
_pD3D8Caps->Caps3 = _pWineCaps->Caps3; \
_pD3D8Caps->PresentationIntervals = _pWineCaps->PresentationIntervals; \
_pD3D8Caps->CursorCaps = _pWineCaps->CursorCaps; \
_pD3D8Caps->DevCaps = _pWineCaps->DevCaps; \
_pD3D8Caps->PrimitiveMiscCaps = _pWineCaps->PrimitiveMiscCaps; \
_pD3D8Caps->RasterCaps = _pWineCaps->RasterCaps; \
_pD3D8Caps->ZCmpCaps = _pWineCaps->ZCmpCaps; \
_pD3D8Caps->SrcBlendCaps = _pWineCaps->SrcBlendCaps; \
_pD3D8Caps->DestBlendCaps = _pWineCaps->DestBlendCaps; \
_pD3D8Caps->AlphaCmpCaps = _pWineCaps->AlphaCmpCaps; \
_pD3D8Caps->ShadeCaps = _pWineCaps->ShadeCaps; \
_pD3D8Caps->TextureCaps = _pWineCaps->TextureCaps; \
_pD3D8Caps->TextureFilterCaps = _pWineCaps->TextureFilterCaps; \
_pD3D8Caps->CubeTextureFilterCaps = _pWineCaps->CubeTextureFilterCaps; \
_pD3D8Caps->VolumeTextureFilterCaps = _pWineCaps->VolumeTextureFilterCaps; \
_pD3D8Caps->TextureAddressCaps = _pWineCaps->TextureAddressCaps; \
_pD3D8Caps->VolumeTextureAddressCaps = _pWineCaps->VolumeTextureAddressCaps; \
_pD3D8Caps->LineCaps = _pWineCaps->LineCaps; \
_pD3D8Caps->MaxTextureWidth = _pWineCaps->MaxTextureWidth; \
_pD3D8Caps->MaxTextureHeight = _pWineCaps->MaxTextureHeight; \
_pD3D8Caps->MaxVolumeExtent = _pWineCaps->MaxVolumeExtent; \
_pD3D8Caps->MaxTextureRepeat = _pWineCaps->MaxTextureRepeat; \
_pD3D8Caps->MaxTextureAspectRatio = _pWineCaps->MaxTextureAspectRatio; \
_pD3D8Caps->MaxAnisotropy = _pWineCaps->MaxAnisotropy; \
_pD3D8Caps->MaxVertexW = _pWineCaps->MaxVertexW; \
_pD3D8Caps->GuardBandLeft = _pWineCaps->GuardBandLeft; \
_pD3D8Caps->GuardBandTop = _pWineCaps->GuardBandTop; \
_pD3D8Caps->GuardBandRight = _pWineCaps->GuardBandRight; \
_pD3D8Caps->GuardBandBottom = _pWineCaps->GuardBandBottom; \
_pD3D8Caps->ExtentsAdjust = _pWineCaps->ExtentsAdjust; \
_pD3D8Caps->StencilCaps = _pWineCaps->StencilCaps; \
_pD3D8Caps->FVFCaps = _pWineCaps->FVFCaps; \
_pD3D8Caps->TextureOpCaps = _pWineCaps->TextureOpCaps; \
_pD3D8Caps->MaxTextureBlendStages = _pWineCaps->MaxTextureBlendStages; \
_pD3D8Caps->MaxSimultaneousTextures = _pWineCaps->MaxSimultaneousTextures; \
_pD3D8Caps->VertexProcessingCaps = _pWineCaps->VertexProcessingCaps; \
_pD3D8Caps->MaxActiveLights = _pWineCaps->MaxActiveLights; \
_pD3D8Caps->MaxUserClipPlanes = _pWineCaps->MaxUserClipPlanes; \
_pD3D8Caps->MaxVertexBlendMatrices = _pWineCaps->MaxVertexBlendMatrices; \
_pD3D8Caps->MaxVertexBlendMatrixIndex = _pWineCaps->MaxVertexBlendMatrixIndex; \
_pD3D8Caps->MaxPointSize = _pWineCaps->MaxPointSize; \
_pD3D8Caps->MaxPrimitiveCount = _pWineCaps->MaxPrimitiveCount; \
_pD3D8Caps->MaxVertexIndex = _pWineCaps->MaxVertexIndex; \
_pD3D8Caps->MaxStreams = _pWineCaps->MaxStreams; \
_pD3D8Caps->MaxStreamStride = _pWineCaps->MaxStreamStride; \
_pD3D8Caps->VertexShaderVersion = _pWineCaps->VertexShaderVersion; \
_pD3D8Caps->MaxVertexShaderConst = _pWineCaps->MaxVertexShaderConst; \
_pD3D8Caps->PixelShaderVersion = _pWineCaps->PixelShaderVersion; \
_pD3D8Caps->MaxPixelShaderValue = _pWineCaps->PixelShader1xMaxValue;
/* Direct3D8 Interfaces: */
typedef struct IDirect3DBaseTexture8Impl IDirect3DBaseTexture8Impl;

2
dlls/d3d8/device.c
View File

@ -192,10 +192,10 @@ static HRESULT WINAPI IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface
return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */
}
D3D8CAPSTOWINECAPS(pCaps, pWineCaps)
EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps);
LeaveCriticalSection(&d3d8_cs);
WINECAPSTOD3D8CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
/* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */

2
dlls/d3d8/directx.c
View File

@ -231,10 +231,10 @@ static HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps(LPDIRECT3D8 iface, UINT Ada
if(pWineCaps == NULL){
return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/
}
D3D8CAPSTOWINECAPS(pCaps, pWineCaps)
EnterCriticalSection(&d3d8_cs);
hrc = IWineD3D_GetDeviceCaps(This->WineD3D, Adapter, DeviceType, pWineCaps);
LeaveCriticalSection(&d3d8_cs);
WINECAPSTOD3D8CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
/* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */

154
dlls/d3d9/d3d9_private.h
View File

@ -50,83 +50,83 @@ extern CRITICAL_SECTION d3d9_cs;
Macros
=========================================================================== */
/* Not nice, but it lets wined3d support different versions of directx */
#define D3D9CAPSTOWINECAPS(_pD3D9Caps, _pWineCaps) \
_pWineCaps->DeviceType = (WINED3DDEVTYPE *) &_pD3D9Caps->DeviceType; \
_pWineCaps->AdapterOrdinal = &_pD3D9Caps->AdapterOrdinal; \
_pWineCaps->Caps = &_pD3D9Caps->Caps; \
_pWineCaps->Caps2 = &_pD3D9Caps->Caps2; \
_pWineCaps->Caps3 = &_pD3D9Caps->Caps3; \
_pWineCaps->PresentationIntervals = &_pD3D9Caps->PresentationIntervals; \
_pWineCaps->CursorCaps = &_pD3D9Caps->CursorCaps; \
_pWineCaps->DevCaps = &_pD3D9Caps->DevCaps; \
_pWineCaps->PrimitiveMiscCaps = &_pD3D9Caps->PrimitiveMiscCaps; \
_pWineCaps->RasterCaps = &_pD3D9Caps->RasterCaps; \
_pWineCaps->ZCmpCaps = &_pD3D9Caps->ZCmpCaps; \
_pWineCaps->SrcBlendCaps = &_pD3D9Caps->SrcBlendCaps; \
_pWineCaps->DestBlendCaps = &_pD3D9Caps->DestBlendCaps; \
_pWineCaps->AlphaCmpCaps = &_pD3D9Caps->AlphaCmpCaps; \
_pWineCaps->ShadeCaps = &_pD3D9Caps->ShadeCaps; \
_pWineCaps->TextureCaps = &_pD3D9Caps->TextureCaps; \
_pWineCaps->TextureFilterCaps = &_pD3D9Caps->TextureFilterCaps; \
_pWineCaps->CubeTextureFilterCaps = &_pD3D9Caps->CubeTextureFilterCaps; \
_pWineCaps->VolumeTextureFilterCaps = &_pD3D9Caps->VolumeTextureFilterCaps; \
_pWineCaps->TextureAddressCaps = &_pD3D9Caps->TextureAddressCaps; \
_pWineCaps->VolumeTextureAddressCaps = &_pD3D9Caps->VolumeTextureAddressCaps; \
_pWineCaps->LineCaps = &_pD3D9Caps->LineCaps; \
_pWineCaps->MaxTextureWidth = &_pD3D9Caps->MaxTextureWidth; \
_pWineCaps->MaxTextureHeight = &_pD3D9Caps->MaxTextureHeight; \
_pWineCaps->MaxVolumeExtent = &_pD3D9Caps->MaxVolumeExtent; \
_pWineCaps->MaxTextureRepeat = &_pD3D9Caps->MaxTextureRepeat; \
_pWineCaps->MaxTextureAspectRatio = &_pD3D9Caps->MaxTextureAspectRatio; \
_pWineCaps->MaxAnisotropy = &_pD3D9Caps->MaxAnisotropy; \
_pWineCaps->MaxVertexW = &_pD3D9Caps->MaxVertexW; \
_pWineCaps->GuardBandLeft = &_pD3D9Caps->GuardBandLeft; \
_pWineCaps->GuardBandTop = &_pD3D9Caps->GuardBandTop; \
_pWineCaps->GuardBandRight = &_pD3D9Caps->GuardBandRight; \
_pWineCaps->GuardBandBottom = &_pD3D9Caps->GuardBandBottom; \
_pWineCaps->ExtentsAdjust = &_pD3D9Caps->ExtentsAdjust; \
_pWineCaps->StencilCaps = &_pD3D9Caps->StencilCaps; \
_pWineCaps->FVFCaps = &_pD3D9Caps->FVFCaps; \
_pWineCaps->TextureOpCaps = &_pD3D9Caps->TextureOpCaps; \
_pWineCaps->MaxTextureBlendStages = &_pD3D9Caps->MaxTextureBlendStages; \
_pWineCaps->MaxSimultaneousTextures = &_pD3D9Caps->MaxSimultaneousTextures; \
_pWineCaps->VertexProcessingCaps = &_pD3D9Caps->VertexProcessingCaps; \
_pWineCaps->MaxActiveLights = &_pD3D9Caps->MaxActiveLights; \
_pWineCaps->MaxUserClipPlanes = &_pD3D9Caps->MaxUserClipPlanes; \
_pWineCaps->MaxVertexBlendMatrices = &_pD3D9Caps->MaxVertexBlendMatrices; \
_pWineCaps->MaxVertexBlendMatrixIndex = &_pD3D9Caps->MaxVertexBlendMatrixIndex; \
_pWineCaps->MaxPointSize = &_pD3D9Caps->MaxPointSize; \
_pWineCaps->MaxPrimitiveCount = &_pD3D9Caps->MaxPrimitiveCount; \
_pWineCaps->MaxVertexIndex = &_pD3D9Caps->MaxVertexIndex; \
_pWineCaps->MaxStreams = &_pD3D9Caps->MaxStreams; \
_pWineCaps->MaxStreamStride = &_pD3D9Caps->MaxStreamStride; \
_pWineCaps->VertexShaderVersion = &_pD3D9Caps->VertexShaderVersion; \
_pWineCaps->MaxVertexShaderConst = &_pD3D9Caps->MaxVertexShaderConst; \
_pWineCaps->PixelShaderVersion = &_pD3D9Caps->PixelShaderVersion; \
_pWineCaps->PixelShader1xMaxValue = &_pD3D9Caps->PixelShader1xMaxValue; \
_pWineCaps->DevCaps2 = &_pD3D9Caps->DevCaps2; \
_pWineCaps->MaxNpatchTessellationLevel = &_pD3D9Caps->MaxNpatchTessellationLevel; \
_pWineCaps->MasterAdapterOrdinal = &_pD3D9Caps->MasterAdapterOrdinal; \
_pWineCaps->AdapterOrdinalInGroup = &_pD3D9Caps->AdapterOrdinalInGroup; \
_pWineCaps->NumberOfAdaptersInGroup = &_pD3D9Caps->NumberOfAdaptersInGroup; \
_pWineCaps->DeclTypes = &_pD3D9Caps->DeclTypes; \
_pWineCaps->NumSimultaneousRTs = &_pD3D9Caps->NumSimultaneousRTs; \
_pWineCaps->StretchRectFilterCaps = &_pD3D9Caps->StretchRectFilterCaps; \
_pWineCaps->VS20Caps.Caps = &_pD3D9Caps->VS20Caps.Caps; \
_pWineCaps->VS20Caps.DynamicFlowControlDepth = &_pD3D9Caps->VS20Caps.DynamicFlowControlDepth; \
_pWineCaps->VS20Caps.NumTemps = &_pD3D9Caps->VS20Caps.NumTemps; \
_pWineCaps->VS20Caps.NumTemps = &_pD3D9Caps->VS20Caps.NumTemps; \
_pWineCaps->VS20Caps.StaticFlowControlDepth = &_pD3D9Caps->VS20Caps.StaticFlowControlDepth; \
_pWineCaps->PS20Caps.Caps = &_pD3D9Caps->PS20Caps.Caps; \
_pWineCaps->PS20Caps.DynamicFlowControlDepth = &_pD3D9Caps->PS20Caps.DynamicFlowControlDepth; \
_pWineCaps->PS20Caps.NumTemps = &_pD3D9Caps->PS20Caps.NumTemps; \
_pWineCaps->PS20Caps.StaticFlowControlDepth = &_pD3D9Caps->PS20Caps.StaticFlowControlDepth; \
_pWineCaps->PS20Caps.NumInstructionSlots = &_pD3D9Caps->PS20Caps.NumInstructionSlots; \
_pWineCaps->VertexTextureFilterCaps = &_pD3D9Caps->VertexTextureFilterCaps; \
_pWineCaps->MaxVShaderInstructionsExecuted = &_pD3D9Caps->MaxVShaderInstructionsExecuted; \
_pWineCaps->MaxPShaderInstructionsExecuted = &_pD3D9Caps->MaxPShaderInstructionsExecuted; \
_pWineCaps->MaxVertexShader30InstructionSlots = &_pD3D9Caps->MaxVertexShader30InstructionSlots; \
_pWineCaps->MaxPixelShader30InstructionSlots = &_pD3D9Caps->MaxPixelShader30InstructionSlots;
#define WINECAPSTOD3D9CAPS(_pD3D9Caps, _pWineCaps) \
_pD3D9Caps->DeviceType = (D3DDEVTYPE) _pWineCaps->DeviceType; \
_pD3D9Caps->AdapterOrdinal = _pWineCaps->AdapterOrdinal; \
_pD3D9Caps->Caps = _pWineCaps->Caps; \
_pD3D9Caps->Caps2 = _pWineCaps->Caps2; \
_pD3D9Caps->Caps3 = _pWineCaps->Caps3; \
_pD3D9Caps->PresentationIntervals = _pWineCaps->PresentationIntervals; \
_pD3D9Caps->CursorCaps = _pWineCaps->CursorCaps; \
_pD3D9Caps->DevCaps = _pWineCaps->DevCaps; \
_pD3D9Caps->PrimitiveMiscCaps = _pWineCaps->PrimitiveMiscCaps; \
_pD3D9Caps->RasterCaps = _pWineCaps->RasterCaps; \
_pD3D9Caps->ZCmpCaps = _pWineCaps->ZCmpCaps; \
_pD3D9Caps->SrcBlendCaps = _pWineCaps->SrcBlendCaps; \
_pD3D9Caps->DestBlendCaps = _pWineCaps->DestBlendCaps; \
_pD3D9Caps->AlphaCmpCaps = _pWineCaps->AlphaCmpCaps; \
_pD3D9Caps->ShadeCaps = _pWineCaps->ShadeCaps; \
_pD3D9Caps->TextureCaps = _pWineCaps->TextureCaps; \
_pD3D9Caps->TextureFilterCaps = _pWineCaps->TextureFilterCaps; \
_pD3D9Caps->CubeTextureFilterCaps = _pWineCaps->CubeTextureFilterCaps; \
_pD3D9Caps->VolumeTextureFilterCaps = _pWineCaps->VolumeTextureFilterCaps; \
_pD3D9Caps->TextureAddressCaps = _pWineCaps->TextureAddressCaps; \
_pD3D9Caps->VolumeTextureAddressCaps = _pWineCaps->VolumeTextureAddressCaps; \
_pD3D9Caps->LineCaps = _pWineCaps->LineCaps; \
_pD3D9Caps->MaxTextureWidth = _pWineCaps->MaxTextureWidth; \
_pD3D9Caps->MaxTextureHeight = _pWineCaps->MaxTextureHeight; \
_pD3D9Caps->MaxVolumeExtent = _pWineCaps->MaxVolumeExtent; \
_pD3D9Caps->MaxTextureRepeat = _pWineCaps->MaxTextureRepeat; \
_pD3D9Caps->MaxTextureAspectRatio = _pWineCaps->MaxTextureAspectRatio; \
_pD3D9Caps->MaxAnisotropy = _pWineCaps->MaxAnisotropy; \
_pD3D9Caps->MaxVertexW = _pWineCaps->MaxVertexW; \
_pD3D9Caps->GuardBandLeft = _pWineCaps->GuardBandLeft; \
_pD3D9Caps->GuardBandTop = _pWineCaps->GuardBandTop; \
_pD3D9Caps->GuardBandRight = _pWineCaps->GuardBandRight; \
_pD3D9Caps->GuardBandBottom = _pWineCaps->GuardBandBottom; \
_pD3D9Caps->ExtentsAdjust = _pWineCaps->ExtentsAdjust; \
_pD3D9Caps->StencilCaps = _pWineCaps->StencilCaps; \
_pD3D9Caps->FVFCaps = _pWineCaps->FVFCaps; \
_pD3D9Caps->TextureOpCaps = _pWineCaps->TextureOpCaps; \
_pD3D9Caps->MaxTextureBlendStages = _pWineCaps->MaxTextureBlendStages; \
_pD3D9Caps->MaxSimultaneousTextures = _pWineCaps->MaxSimultaneousTextures; \
_pD3D9Caps->VertexProcessingCaps = _pWineCaps->VertexProcessingCaps; \
_pD3D9Caps->MaxActiveLights = _pWineCaps->MaxActiveLights; \
_pD3D9Caps->MaxUserClipPlanes = _pWineCaps->MaxUserClipPlanes; \
_pD3D9Caps->MaxVertexBlendMatrices = _pWineCaps->MaxVertexBlendMatrices; \
_pD3D9Caps->MaxVertexBlendMatrixIndex = _pWineCaps->MaxVertexBlendMatrixIndex; \
_pD3D9Caps->MaxPointSize = _pWineCaps->MaxPointSize; \
_pD3D9Caps->MaxPrimitiveCount = _pWineCaps->MaxPrimitiveCount; \
_pD3D9Caps->MaxVertexIndex = _pWineCaps->MaxVertexIndex; \
_pD3D9Caps->MaxStreams = _pWineCaps->MaxStreams; \
_pD3D9Caps->MaxStreamStride = _pWineCaps->MaxStreamStride; \
_pD3D9Caps->VertexShaderVersion = _pWineCaps->VertexShaderVersion; \
_pD3D9Caps->MaxVertexShaderConst = _pWineCaps->MaxVertexShaderConst; \
_pD3D9Caps->PixelShaderVersion = _pWineCaps->PixelShaderVersion; \
_pD3D9Caps->PixelShader1xMaxValue = _pWineCaps->PixelShader1xMaxValue; \
_pD3D9Caps->DevCaps2 = _pWineCaps->DevCaps2; \
_pD3D9Caps->MaxNpatchTessellationLevel = _pWineCaps->MaxNpatchTessellationLevel; \
_pD3D9Caps->MasterAdapterOrdinal = _pWineCaps->MasterAdapterOrdinal; \
_pD3D9Caps->AdapterOrdinalInGroup = _pWineCaps->AdapterOrdinalInGroup; \
_pD3D9Caps->NumberOfAdaptersInGroup = _pWineCaps->NumberOfAdaptersInGroup; \
_pD3D9Caps->DeclTypes = _pWineCaps->DeclTypes; \
_pD3D9Caps->NumSimultaneousRTs = _pWineCaps->NumSimultaneousRTs; \
_pD3D9Caps->StretchRectFilterCaps = _pWineCaps->StretchRectFilterCaps; \
_pD3D9Caps->VS20Caps.Caps = _pWineCaps->VS20Caps.Caps; \
_pD3D9Caps->VS20Caps.DynamicFlowControlDepth = _pWineCaps->VS20Caps.DynamicFlowControlDepth; \
_pD3D9Caps->VS20Caps.NumTemps = _pWineCaps->VS20Caps.NumTemps; \
_pD3D9Caps->VS20Caps.NumTemps = _pWineCaps->VS20Caps.NumTemps; \
_pD3D9Caps->VS20Caps.StaticFlowControlDepth = _pWineCaps->VS20Caps.StaticFlowControlDepth; \
_pD3D9Caps->PS20Caps.Caps = _pWineCaps->PS20Caps.Caps; \
_pD3D9Caps->PS20Caps.DynamicFlowControlDepth = _pWineCaps->PS20Caps.DynamicFlowControlDepth; \
_pD3D9Caps->PS20Caps.NumTemps = _pWineCaps->PS20Caps.NumTemps; \
_pD3D9Caps->PS20Caps.StaticFlowControlDepth = _pWineCaps->PS20Caps.StaticFlowControlDepth; \
_pD3D9Caps->PS20Caps.NumInstructionSlots = _pWineCaps->PS20Caps.NumInstructionSlots; \
_pD3D9Caps->VertexTextureFilterCaps = _pWineCaps->VertexTextureFilterCaps; \
_pD3D9Caps->MaxVShaderInstructionsExecuted = _pWineCaps->MaxVShaderInstructionsExecuted; \
_pD3D9Caps->MaxPShaderInstructionsExecuted = _pWineCaps->MaxPShaderInstructionsExecuted; \
_pD3D9Caps->MaxVertexShader30InstructionSlots = _pWineCaps->MaxVertexShader30InstructionSlots; \
_pD3D9Caps->MaxPixelShader30InstructionSlots = _pWineCaps->MaxPixelShader30InstructionSlots;
/* ===========================================================================
D3D9 interfactes

2
dlls/d3d9/device.c
View File

@ -183,10 +183,10 @@ static HRESULT WINAPI IDirect3DDevice9Impl_GetDeviceCaps(LPDIRECT3DDEVICE9EX i
}
memset(pCaps, 0, sizeof(*pCaps));
D3D9CAPSTOWINECAPS(pCaps, pWineCaps)
EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps);
LeaveCriticalSection(&d3d9_cs);
WINECAPSTOD3D9CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
/* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */

2
dlls/d3d9/directx.c
View File

@ -303,10 +303,10 @@ static HRESULT WINAPI IDirect3D9Impl_GetDeviceCaps(LPDIRECT3D9EX iface, UINT Ada
return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/
}
memset(pCaps, 0, sizeof(*pCaps));
D3D9CAPSTOWINECAPS(pCaps, pWineCaps)
EnterCriticalSection(&d3d9_cs);
hrc = IWineD3D_GetDeviceCaps(This->WineD3D, Adapter, DeviceType, pWineCaps);
LeaveCriticalSection(&d3d9_cs);
WINECAPSTOD3D9CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
/* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */

145
dlls/ddraw/direct3d.c
View File

@ -1260,102 +1260,9 @@ IDirect3DImpl_GetCaps(IWineD3D *WineD3D,
HRESULT hr;
/* Some Variables to asign to the pointers in WCaps */
WINED3DDEVTYPE DevType;
UINT dummy_uint;
float dummy_float;
DWORD dummy_dword, MaxTextureBlendStages, MaxSimultaneousTextures;
DWORD MaxUserClipPlanes, MaxVertexBlendMatrices;
TRACE("()->(%p,%p,%p\n", WineD3D, Desc123, Desc7);
/* Asign the pointers in WCaps */
WCaps.DeviceType = &DevType;
WCaps.AdapterOrdinal = &dummy_uint;
WCaps.Caps = &dummy_dword;
WCaps.Caps2 = &dummy_dword;
WCaps.Caps3 = &dummy_dword;
WCaps.PresentationIntervals = &dummy_dword;
WCaps.CursorCaps = &dummy_dword;
WCaps.DevCaps = &Desc7->dwDevCaps;
WCaps.PrimitiveMiscCaps = &dummy_dword;
WCaps.RasterCaps = &Desc7->dpcLineCaps.dwRasterCaps;
WCaps.ZCmpCaps = &Desc7->dpcLineCaps.dwZCmpCaps;
WCaps.SrcBlendCaps = &Desc7->dpcLineCaps.dwSrcBlendCaps;
WCaps.DestBlendCaps = &Desc7->dpcLineCaps.dwDestBlendCaps;
WCaps.AlphaCmpCaps = &Desc7->dpcLineCaps.dwAlphaCmpCaps;
WCaps.ShadeCaps = &Desc7->dpcLineCaps.dwShadeCaps;
WCaps.TextureCaps = &Desc7->dpcLineCaps.dwTextureCaps;
WCaps.TextureFilterCaps = &Desc7->dpcLineCaps.dwTextureFilterCaps;
WCaps.CubeTextureFilterCaps = &dummy_dword;
WCaps.VolumeTextureFilterCaps = &dummy_dword;
WCaps.TextureAddressCaps = &Desc7->dpcLineCaps.dwTextureAddressCaps;
WCaps.VolumeTextureAddressCaps = &dummy_dword;
WCaps.LineCaps = &dummy_dword;
WCaps.MaxTextureWidth = &Desc7->dwMaxTextureWidth;
WCaps.MaxTextureHeight = &Desc7->dwMaxTextureHeight;
WCaps.MaxVolumeExtent = &dummy_dword;
WCaps.MaxTextureRepeat = &Desc7->dwMaxTextureRepeat;
WCaps.MaxTextureAspectRatio = &Desc7->dwMaxTextureAspectRatio;
WCaps.MaxAnisotropy = &Desc7->dwMaxAnisotropy;
WCaps.MaxVertexW = &Desc7->dvMaxVertexW;
WCaps.GuardBandLeft = &Desc7->dvGuardBandLeft;
WCaps.GuardBandTop = &Desc7->dvGuardBandTop;
WCaps.GuardBandRight = &Desc7->dvGuardBandRight;
WCaps.GuardBandBottom = &Desc7->dvGuardBandBottom;
WCaps.ExtentsAdjust = &Desc7->dvExtentsAdjust;
WCaps.StencilCaps = &Desc7->dwStencilCaps;
WCaps.FVFCaps = &Desc7->dwFVFCaps;
WCaps.TextureOpCaps = &Desc7->dwTextureOpCaps;
WCaps.MaxTextureBlendStages = &MaxTextureBlendStages;
WCaps.MaxSimultaneousTextures = &MaxSimultaneousTextures;
WCaps.VertexProcessingCaps = &Desc7->dwVertexProcessingCaps;
WCaps.MaxActiveLights = &Desc7->dwMaxActiveLights;
WCaps.MaxUserClipPlanes = &MaxUserClipPlanes;
WCaps.MaxVertexBlendMatrices = &MaxVertexBlendMatrices;
WCaps.MaxVertexBlendMatrixIndex = &dummy_dword;
WCaps.MaxPointSize = &dummy_float;
WCaps.MaxPrimitiveCount = &dummy_dword;
WCaps.MaxVertexIndex = &dummy_dword;
WCaps.MaxStreams = &dummy_dword;
WCaps.MaxStreamStride = &dummy_dword;
WCaps.VertexShaderVersion = &dummy_dword;
WCaps.MaxVertexShaderConst = &dummy_dword;
WCaps.PixelShaderVersion = &dummy_dword;
WCaps.PixelShader1xMaxValue = &dummy_float;
/* These are dx9 only, set them to NULL */
WCaps.DevCaps2 = NULL;
WCaps.MaxNpatchTessellationLevel = NULL;
WCaps.Reserved5 = NULL;
WCaps.MasterAdapterOrdinal = NULL;
WCaps.AdapterOrdinalInGroup = NULL;
WCaps.NumberOfAdaptersInGroup = NULL;
WCaps.DeclTypes = NULL;
WCaps.NumSimultaneousRTs = NULL;
WCaps.StretchRectFilterCaps = NULL;
/* WCaps.VS20Caps = NULL; */
/* WCaps.PS20Caps = NULL; */
WCaps.VertexTextureFilterCaps = NULL;
WCaps.MaxVShaderInstructionsExecuted = NULL;
WCaps.MaxPShaderInstructionsExecuted = NULL;
WCaps.MaxVertexShader30InstructionSlots = NULL;
WCaps.MaxPixelShader30InstructionSlots = NULL;
WCaps.Reserved2 = NULL;
WCaps.Reserved3 = NULL;
/* Now get the caps */
memset(&WCaps, 0, sizeof(WCaps));
EnterCriticalSection(&ddraw_cs);
hr = IWineD3D_GetDeviceCaps(WineD3D, 0, WINED3DDEVTYPE_HAL, &WCaps);
LeaveCriticalSection(&ddraw_cs);
@ -1364,6 +1271,40 @@ IDirect3DImpl_GetCaps(IWineD3D *WineD3D,
return hr;
}
/* Copy the results into the d3d7 and d3d3 structures */
Desc7->dwDevCaps = WCaps.DevCaps;
Desc7->dpcLineCaps.dwRasterCaps = WCaps.RasterCaps;
Desc7->dpcLineCaps.dwZCmpCaps = WCaps.ZCmpCaps;
Desc7->dpcLineCaps.dwSrcBlendCaps = WCaps.SrcBlendCaps;
Desc7->dpcLineCaps.dwDestBlendCaps = WCaps.DestBlendCaps;
Desc7->dpcLineCaps.dwAlphaCmpCaps = WCaps.AlphaCmpCaps;
Desc7->dpcLineCaps.dwShadeCaps = WCaps.ShadeCaps;
Desc7->dpcLineCaps.dwTextureCaps = WCaps.TextureCaps;
Desc7->dpcLineCaps.dwTextureFilterCaps = WCaps.TextureFilterCaps;
Desc7->dpcLineCaps.dwTextureAddressCaps = WCaps.TextureAddressCaps;
Desc7->dwMaxTextureWidth = WCaps.MaxTextureWidth;
Desc7->dwMaxTextureHeight = WCaps.MaxTextureHeight;
Desc7->dwMaxTextureRepeat = WCaps.MaxTextureRepeat;
Desc7->dwMaxTextureAspectRatio = WCaps.MaxTextureAspectRatio;
Desc7->dwMaxAnisotropy = WCaps.MaxAnisotropy;
Desc7->dvMaxVertexW = WCaps.MaxVertexW;
Desc7->dvGuardBandLeft = WCaps.GuardBandLeft;
Desc7->dvGuardBandTop = WCaps.GuardBandTop;
Desc7->dvGuardBandRight = WCaps.GuardBandRight;
Desc7->dvGuardBandBottom = WCaps.GuardBandBottom;
Desc7->dvExtentsAdjust = WCaps.ExtentsAdjust;
Desc7->dwStencilCaps = WCaps.StencilCaps;
Desc7->dwFVFCaps = WCaps.FVFCaps;
Desc7->dwTextureOpCaps = WCaps.TextureOpCaps;
Desc7->dwVertexProcessingCaps = WCaps.VertexProcessingCaps;
Desc7->dwMaxActiveLights = WCaps.MaxActiveLights;
/* Remove all non-d3d7 caps */
Desc7->dwDevCaps &= (
D3DDEVCAPS_FLOATTLVERTEX | D3DDEVCAPS_SORTINCREASINGZ | D3DDEVCAPS_SORTDECREASINGZ |
@ -1489,15 +1430,15 @@ IDirect3DImpl_GetCaps(IWineD3D *WineD3D,
Desc7->dwMinTextureHeight = 1;
/* Convert DWORDs safely to WORDs */
if(MaxTextureBlendStages > 65535) Desc7->wMaxTextureBlendStages = 65535;
else Desc7->wMaxTextureBlendStages = (WORD) MaxTextureBlendStages;
if(MaxSimultaneousTextures > 65535) Desc7->wMaxSimultaneousTextures = 65535;
else Desc7->wMaxSimultaneousTextures = (WORD) MaxSimultaneousTextures;
if(WCaps.MaxTextureBlendStages > 65535) Desc7->wMaxTextureBlendStages = 65535;
else Desc7->wMaxTextureBlendStages = (WORD) WCaps.MaxTextureBlendStages;
if(WCaps.MaxSimultaneousTextures > 65535) Desc7->wMaxSimultaneousTextures = 65535;
else Desc7->wMaxSimultaneousTextures = (WORD) WCaps.MaxSimultaneousTextures;
if(MaxUserClipPlanes > 65535) Desc7->wMaxUserClipPlanes = 65535;
else Desc7->wMaxUserClipPlanes = (WORD) MaxUserClipPlanes;
if(MaxVertexBlendMatrices > 65535) Desc7->wMaxVertexBlendMatrices = 65535;
else Desc7->wMaxVertexBlendMatrices = (WORD) MaxVertexBlendMatrices;
if(WCaps.MaxUserClipPlanes > 65535) Desc7->wMaxUserClipPlanes = 65535;
else Desc7->wMaxUserClipPlanes = (WORD) WCaps.MaxUserClipPlanes;
if(WCaps.MaxVertexBlendMatrices > 65535) Desc7->wMaxVertexBlendMatrices = 65535;
else Desc7->wMaxVertexBlendMatrices = (WORD) WCaps.MaxVertexBlendMatrices;
Desc7->deviceGUID = IID_IDirect3DTnLHalDevice;

679
dlls/wined3d/directx.c
View File

@ -2678,47 +2678,47 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
/* ------------------------------------------------
The following fields apply to both d3d8 and d3d9
------------------------------------------------ */
*pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
*pCaps->AdapterOrdinal = Adapter;
pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
pCaps->AdapterOrdinal = Adapter;
*pCaps->Caps = 0;
*pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
WINED3DCAPS2_FULLSCREENGAMMA |
WINED3DCAPS2_DYNAMICTEXTURES;
pCaps->Caps = 0;
pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
WINED3DCAPS2_FULLSCREENGAMMA |
WINED3DCAPS2_DYNAMICTEXTURES;
if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
*pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
}
*pCaps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD;
*pCaps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE |
WINED3DPRESENT_INTERVAL_ONE;
pCaps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD;
pCaps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE |
WINED3DPRESENT_INTERVAL_ONE;
*pCaps->CursorCaps = WINED3DCURSORCAPS_COLOR |
WINED3DCURSORCAPS_LOWRES;
pCaps->CursorCaps = WINED3DCURSORCAPS_COLOR |
WINED3DCURSORCAPS_LOWRES;
*pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
WINED3DDEVCAPS_PUREDEVICE |
WINED3DDEVCAPS_HWRASTERIZATION |
WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
WINED3DDEVCAPS_CANRENDERAFTERFLIP |
WINED3DDEVCAPS_DRAWPRIMITIVES2 |
WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
WINED3DDEVCAPS_RTPATCHES;
pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
WINED3DDEVCAPS_PUREDEVICE |
WINED3DDEVCAPS_HWRASTERIZATION |
WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
WINED3DDEVCAPS_CANRENDERAFTERFLIP |
WINED3DDEVCAPS_DRAWPRIMITIVES2 |
WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
WINED3DDEVCAPS_RTPATCHES;
*pCaps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
WINED3DPMISCCAPS_CULLCCW |
WINED3DPMISCCAPS_CULLCW |
WINED3DPMISCCAPS_COLORWRITEENABLE |
WINED3DPMISCCAPS_CLIPTLVERTS |
WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
WINED3DPMISCCAPS_MASKZ |
WINED3DPMISCCAPS_BLENDOP;
pCaps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
WINED3DPMISCCAPS_CULLCCW |
WINED3DPMISCCAPS_CULLCW |
WINED3DPMISCCAPS_COLORWRITEENABLE |
WINED3DPMISCCAPS_CLIPTLVERTS |
WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
WINED3DPMISCCAPS_MASKZ |
WINED3DPMISCCAPS_BLENDOP;
/* TODO:
WINED3DPMISCCAPS_NULLREFERENCE
WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
@ -2728,36 +2728,36 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
if(GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE) && GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE))
*pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
/* The caps below can be supported but aren't handled yet in utils.c 'd3dta_to_combiner_input', disable them until support is fixed */
#if 0
if (GL_SUPPORT(NV_REGISTER_COMBINERS))
*pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_TSSARGTEMP;
pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_TSSARGTEMP;
if (GL_SUPPORT(NV_REGISTER_COMBINERS2))
*pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_PERSTAGECONSTANT;
pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_PERSTAGECONSTANT;
#endif
*pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
WINED3DPRASTERCAPS_PAT |
WINED3DPRASTERCAPS_WFOG |
WINED3DPRASTERCAPS_ZFOG |
WINED3DPRASTERCAPS_FOGVERTEX |
WINED3DPRASTERCAPS_FOGTABLE |
WINED3DPRASTERCAPS_STIPPLE |
WINED3DPRASTERCAPS_SUBPIXEL |
WINED3DPRASTERCAPS_ZTEST |
WINED3DPRASTERCAPS_SCISSORTEST |
WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
WINED3DPRASTERCAPS_DEPTHBIAS;
pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
WINED3DPRASTERCAPS_PAT |
WINED3DPRASTERCAPS_WFOG |
WINED3DPRASTERCAPS_ZFOG |
WINED3DPRASTERCAPS_FOGVERTEX |
WINED3DPRASTERCAPS_FOGTABLE |
WINED3DPRASTERCAPS_STIPPLE |
WINED3DPRASTERCAPS_SUBPIXEL |
WINED3DPRASTERCAPS_ZTEST |
WINED3DPRASTERCAPS_SCISSORTEST |
WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
WINED3DPRASTERCAPS_DEPTHBIAS;
if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
*pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
WINED3DPRASTERCAPS_ZBIAS |
WINED3DPRASTERCAPS_MIPMAPLODBIAS;
pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
WINED3DPRASTERCAPS_ZBIAS |
WINED3DPRASTERCAPS_MIPMAPLODBIAS;
}
if(GL_SUPPORT(NV_FOG_DISTANCE)) {
*pCaps->RasterCaps |= WINED3DPRASTERCAPS_FOGRANGE;
pCaps->RasterCaps |= WINED3DPRASTERCAPS_FOGRANGE;
}
/* FIXME Add:
WINED3DPRASTERCAPS_COLORPERSPECTIVE
@ -2766,39 +2766,39 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
WINED3DPRASTERCAPS_ZBUFFERLESSHSR
WINED3DPRASTERCAPS_WBUFFER */
*pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS |
WINED3DPCMPCAPS_EQUAL |
WINED3DPCMPCAPS_GREATER |
WINED3DPCMPCAPS_GREATEREQUAL |
WINED3DPCMPCAPS_LESS |
WINED3DPCMPCAPS_LESSEQUAL |
WINED3DPCMPCAPS_NEVER |
WINED3DPCMPCAPS_NOTEQUAL;
pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS |
WINED3DPCMPCAPS_EQUAL |
WINED3DPCMPCAPS_GREATER |
WINED3DPCMPCAPS_GREATEREQUAL |
WINED3DPCMPCAPS_LESS |
WINED3DPCMPCAPS_LESSEQUAL |
WINED3DPCMPCAPS_NEVER |
WINED3DPCMPCAPS_NOTEQUAL;
*pCaps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
WINED3DPBLENDCAPS_BOTHSRCALPHA |
WINED3DPBLENDCAPS_DESTALPHA |
WINED3DPBLENDCAPS_DESTCOLOR |
WINED3DPBLENDCAPS_INVDESTALPHA |
WINED3DPBLENDCAPS_INVDESTCOLOR |
WINED3DPBLENDCAPS_INVSRCALPHA |
WINED3DPBLENDCAPS_INVSRCCOLOR |
WINED3DPBLENDCAPS_ONE |
WINED3DPBLENDCAPS_SRCALPHA |
WINED3DPBLENDCAPS_SRCALPHASAT |
WINED3DPBLENDCAPS_SRCCOLOR |
WINED3DPBLENDCAPS_ZERO;
pCaps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
WINED3DPBLENDCAPS_BOTHSRCALPHA |
WINED3DPBLENDCAPS_DESTALPHA |
WINED3DPBLENDCAPS_DESTCOLOR |
WINED3DPBLENDCAPS_INVDESTALPHA |
WINED3DPBLENDCAPS_INVDESTCOLOR |
WINED3DPBLENDCAPS_INVSRCALPHA |
WINED3DPBLENDCAPS_INVSRCCOLOR |
WINED3DPBLENDCAPS_ONE |
WINED3DPBLENDCAPS_SRCALPHA |
WINED3DPBLENDCAPS_SRCALPHASAT |
WINED3DPBLENDCAPS_SRCCOLOR |
WINED3DPBLENDCAPS_ZERO;
*pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA |
WINED3DPBLENDCAPS_DESTCOLOR |
WINED3DPBLENDCAPS_INVDESTALPHA |
WINED3DPBLENDCAPS_INVDESTCOLOR |
WINED3DPBLENDCAPS_INVSRCALPHA |
WINED3DPBLENDCAPS_INVSRCCOLOR |
WINED3DPBLENDCAPS_ONE |
WINED3DPBLENDCAPS_SRCALPHA |
WINED3DPBLENDCAPS_SRCCOLOR |
WINED3DPBLENDCAPS_ZERO;
pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA |
WINED3DPBLENDCAPS_DESTCOLOR |
WINED3DPBLENDCAPS_INVDESTALPHA |
WINED3DPBLENDCAPS_INVDESTCOLOR |
WINED3DPBLENDCAPS_INVSRCALPHA |
WINED3DPBLENDCAPS_INVSRCCOLOR |
WINED3DPBLENDCAPS_ONE |
WINED3DPBLENDCAPS_SRCALPHA |
WINED3DPBLENDCAPS_SRCCOLOR |
WINED3DPBLENDCAPS_ZERO;
/* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
* according to the glBlendFunc manpage
*
@ -2807,197 +2807,197 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
*/
if( GL_SUPPORT(EXT_BLEND_COLOR)) {
*pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
*pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
}
*pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS |
WINED3DPCMPCAPS_EQUAL |
WINED3DPCMPCAPS_GREATER |
WINED3DPCMPCAPS_GREATEREQUAL |
WINED3DPCMPCAPS_LESS |
WINED3DPCMPCAPS_LESSEQUAL |
WINED3DPCMPCAPS_NEVER |
WINED3DPCMPCAPS_NOTEQUAL;
pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS |
WINED3DPCMPCAPS_EQUAL |
WINED3DPCMPCAPS_GREATER |
WINED3DPCMPCAPS_GREATEREQUAL |
WINED3DPCMPCAPS_LESS |
WINED3DPCMPCAPS_LESSEQUAL |
WINED3DPCMPCAPS_NEVER |
WINED3DPCMPCAPS_NOTEQUAL;
*pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
WINED3DPSHADECAPS_COLORGOURAUDRGB |
WINED3DPSHADECAPS_ALPHAFLATBLEND |
WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
WINED3DPSHADECAPS_COLORFLATRGB |
WINED3DPSHADECAPS_FOGFLAT |
WINED3DPSHADECAPS_FOGGOURAUD |
WINED3DPSHADECAPS_SPECULARFLATRGB;
pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
WINED3DPSHADECAPS_COLORGOURAUDRGB |
WINED3DPSHADECAPS_ALPHAFLATBLEND |
WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
WINED3DPSHADECAPS_COLORFLATRGB |
WINED3DPSHADECAPS_FOGFLAT |
WINED3DPSHADECAPS_FOGGOURAUD |
WINED3DPSHADECAPS_SPECULARFLATRGB;
*pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
WINED3DPTEXTURECAPS_ALPHAPALETTE |
WINED3DPTEXTURECAPS_BORDER |
WINED3DPTEXTURECAPS_MIPMAP |
WINED3DPTEXTURECAPS_PROJECTED |
WINED3DPTEXTURECAPS_PERSPECTIVE;
pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
WINED3DPTEXTURECAPS_ALPHAPALETTE |
WINED3DPTEXTURECAPS_BORDER |
WINED3DPTEXTURECAPS_MIPMAP |
WINED3DPTEXTURECAPS_PROJECTED |
WINED3DPTEXTURECAPS_PERSPECTIVE;
if( !GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
*pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
}
if( GL_SUPPORT(EXT_TEXTURE3D)) {
*pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
}
if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
*pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
WINED3DPTEXTURECAPS_MIPCUBEMAP |
WINED3DPTEXTURECAPS_CUBEMAP_POW2;
pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
WINED3DPTEXTURECAPS_MIPCUBEMAP |
WINED3DPTEXTURECAPS_CUBEMAP_POW2;
}
*pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MIPFLINEAR |
WINED3DPTFILTERCAPS_MIPFPOINT |
WINED3DPTFILTERCAPS_LINEAR |
WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
WINED3DPTFILTERCAPS_MIPLINEAR |
WINED3DPTFILTERCAPS_MIPNEAREST |
WINED3DPTFILTERCAPS_NEAREST;
pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MIPFLINEAR |
WINED3DPTFILTERCAPS_MIPFPOINT |
WINED3DPTFILTERCAPS_LINEAR |
WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
WINED3DPTFILTERCAPS_MIPLINEAR |
WINED3DPTFILTERCAPS_MIPNEAREST |
WINED3DPTFILTERCAPS_NEAREST;
if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
*pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
WINED3DPTFILTERCAPS_MINFANISOTROPIC;
pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
WINED3DPTFILTERCAPS_MINFANISOTROPIC;
}
if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
*pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MIPFLINEAR |
WINED3DPTFILTERCAPS_MIPFPOINT |
WINED3DPTFILTERCAPS_LINEAR |
WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
WINED3DPTFILTERCAPS_MIPLINEAR |
WINED3DPTFILTERCAPS_MIPNEAREST |
WINED3DPTFILTERCAPS_NEAREST;
pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MIPFLINEAR |
WINED3DPTFILTERCAPS_MIPFPOINT |
WINED3DPTFILTERCAPS_LINEAR |
WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
WINED3DPTFILTERCAPS_MIPLINEAR |
WINED3DPTFILTERCAPS_MIPNEAREST |
WINED3DPTFILTERCAPS_NEAREST;
if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
*pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
WINED3DPTFILTERCAPS_MINFANISOTROPIC;
}
} else
*pCaps->CubeTextureFilterCaps = 0;
pCaps->CubeTextureFilterCaps = 0;
if (GL_SUPPORT(EXT_TEXTURE3D)) {
*pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MIPFLINEAR |
WINED3DPTFILTERCAPS_MIPFPOINT |
WINED3DPTFILTERCAPS_LINEAR |
WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
WINED3DPTFILTERCAPS_MIPLINEAR |
WINED3DPTFILTERCAPS_MIPNEAREST |
WINED3DPTFILTERCAPS_NEAREST;
pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MIPFLINEAR |
WINED3DPTFILTERCAPS_MIPFPOINT |
WINED3DPTFILTERCAPS_LINEAR |
WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
WINED3DPTFILTERCAPS_MIPLINEAR |
WINED3DPTFILTERCAPS_MIPNEAREST |
WINED3DPTFILTERCAPS_NEAREST;
} else
*pCaps->VolumeTextureFilterCaps = 0;
pCaps->VolumeTextureFilterCaps = 0;
*pCaps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
WINED3DPTADDRESSCAPS_CLAMP |
WINED3DPTADDRESSCAPS_WRAP;
pCaps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
WINED3DPTADDRESSCAPS_CLAMP |
WINED3DPTADDRESSCAPS_WRAP;
if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
*pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
}
if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
*pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
}
if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
*pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
}
if (GL_SUPPORT(EXT_TEXTURE3D)) {
*pCaps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
WINED3DPTADDRESSCAPS_CLAMP |
WINED3DPTADDRESSCAPS_WRAP;
pCaps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
WINED3DPTADDRESSCAPS_CLAMP |
WINED3DPTADDRESSCAPS_WRAP;
if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
*pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
}
if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
*pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
}
if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
*pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
}
} else
*pCaps->VolumeTextureAddressCaps = 0;
pCaps->VolumeTextureAddressCaps = 0;
*pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
WINED3DLINECAPS_ZTEST;
pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
WINED3DLINECAPS_ZTEST;
/* FIXME: Add
WINED3DLINECAPS_BLEND
WINED3DLINECAPS_ALPHACMP
WINED3DLINECAPS_FOG */
*pCaps->MaxTextureWidth = GL_LIMITS(texture_size);
*pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
pCaps->MaxTextureWidth = GL_LIMITS(texture_size);
pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
if(GL_SUPPORT(EXT_TEXTURE3D))
*pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
else
*pCaps->MaxVolumeExtent = 0;
pCaps->MaxVolumeExtent = 0;
*pCaps->MaxTextureRepeat = 32768;
*pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
*pCaps->MaxVertexW = 1.0;
pCaps->MaxTextureRepeat = 32768;
pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
pCaps->MaxVertexW = 1.0;
*pCaps->GuardBandLeft = 0;
*pCaps->GuardBandTop = 0;
*pCaps->GuardBandRight = 0;
*pCaps->GuardBandBottom = 0;
pCaps->GuardBandLeft = 0;
pCaps->GuardBandTop = 0;
pCaps->GuardBandRight = 0;
pCaps->GuardBandBottom = 0;
*pCaps->ExtentsAdjust = 0;
pCaps->ExtentsAdjust = 0;
*pCaps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT |
WINED3DSTENCILCAPS_INCRSAT |
WINED3DSTENCILCAPS_INVERT |
WINED3DSTENCILCAPS_KEEP |
WINED3DSTENCILCAPS_REPLACE |
WINED3DSTENCILCAPS_ZERO;
pCaps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT |
WINED3DSTENCILCAPS_INCRSAT |
WINED3DSTENCILCAPS_INVERT |
WINED3DSTENCILCAPS_KEEP |
WINED3DSTENCILCAPS_REPLACE |
WINED3DSTENCILCAPS_ZERO;
if (GL_SUPPORT(EXT_STENCIL_WRAP)) {
*pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR |
WINED3DSTENCILCAPS_INCR;
pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR |
WINED3DSTENCILCAPS_INCR;
}
if ( This->dxVersion > 8 &&
( GL_SUPPORT(EXT_STENCIL_TWO_SIDE) ||
GL_SUPPORT(ATI_SEPARATE_STENCIL) ) ) {
*pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
}
*pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
*pCaps->TextureOpCaps = WINED3DTEXOPCAPS_ADD |
WINED3DTEXOPCAPS_ADDSIGNED |
WINED3DTEXOPCAPS_ADDSIGNED2X |
WINED3DTEXOPCAPS_MODULATE |
WINED3DTEXOPCAPS_MODULATE2X |
WINED3DTEXOPCAPS_MODULATE4X |
WINED3DTEXOPCAPS_SELECTARG1 |
WINED3DTEXOPCAPS_SELECTARG2 |
WINED3DTEXOPCAPS_DISABLE;
pCaps->TextureOpCaps = WINED3DTEXOPCAPS_ADD |
WINED3DTEXOPCAPS_ADDSIGNED |
WINED3DTEXOPCAPS_ADDSIGNED2X |
WINED3DTEXOPCAPS_MODULATE |
WINED3DTEXOPCAPS_MODULATE2X |
WINED3DTEXOPCAPS_MODULATE4X |
WINED3DTEXOPCAPS_SELECTARG1 |
WINED3DTEXOPCAPS_SELECTARG2 |
WINED3DTEXOPCAPS_DISABLE;
if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE) ||
GL_SUPPORT(EXT_TEXTURE_ENV_COMBINE) ||
GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
*pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA |
pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA |
WINED3DTEXOPCAPS_BLENDTEXTUREALPHA |
WINED3DTEXOPCAPS_BLENDFACTORALPHA |
WINED3DTEXOPCAPS_BLENDCURRENTALPHA |
@ -3006,62 +3006,62 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
}
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3) ||
GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
*pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_ADDSMOOTH |
pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_ADDSMOOTH |
WINED3DTEXOPCAPS_MULTIPLYADD |
WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM;
}
if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3))
*pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_DOTPRODUCT3;
pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_DOTPRODUCT3;
if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
*pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
}
if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
*pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
} else if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
/* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does
* not support 3D textures. This asks for trouble if an app uses both bump mapping
* and 3D textures. It also allows us to keep the code simpler by having texture
* shaders constantly enabled.
*/
*pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
/* TODO: Luminance bump map? */
}
#if 0
/* FIXME: Add
*pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
WINED3DTEXOPCAPS_PREMODULATE */
#endif
*pCaps->MaxTextureBlendStages = GL_LIMITS(texture_stages);
*pCaps->MaxSimultaneousTextures = GL_LIMITS(textures);
*pCaps->MaxUserClipPlanes = GL_LIMITS(clipplanes);
*pCaps->MaxActiveLights = GL_LIMITS(lights);
pCaps->MaxTextureBlendStages = GL_LIMITS(texture_stages);
pCaps->MaxSimultaneousTextures = GL_LIMITS(textures);
pCaps->MaxUserClipPlanes = GL_LIMITS(clipplanes);
pCaps->MaxActiveLights = GL_LIMITS(lights);
*pCaps->MaxVertexBlendMatrices = GL_LIMITS(blends);
*pCaps->MaxVertexBlendMatrixIndex = 0;
pCaps->MaxVertexBlendMatrices = GL_LIMITS(blends);
pCaps->MaxVertexBlendMatrixIndex = 0;
*pCaps->MaxAnisotropy = GL_LIMITS(anisotropy);
*pCaps->MaxPointSize = GL_LIMITS(pointsize);
pCaps->MaxAnisotropy = GL_LIMITS(anisotropy);
pCaps->MaxPointSize = GL_LIMITS(pointsize);
*pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
WINED3DVTXPCAPS_MATERIALSOURCE7 |
WINED3DVTXPCAPS_POSITIONALLIGHTS |
WINED3DVTXPCAPS_LOCALVIEWER |
WINED3DVTXPCAPS_VERTEXFOG |
WINED3DVTXPCAPS_TEXGEN;
pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
WINED3DVTXPCAPS_MATERIALSOURCE7 |
WINED3DVTXPCAPS_POSITIONALLIGHTS |
WINED3DVTXPCAPS_LOCALVIEWER |
WINED3DVTXPCAPS_VERTEXFOG |
WINED3DVTXPCAPS_TEXGEN;
/* FIXME: Add
D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
*pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
*pCaps->MaxVertexIndex = 0xFFFFF;
*pCaps->MaxStreams = MAX_STREAMS;
*pCaps->MaxStreamStride = 1024;
pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
pCaps->MaxVertexIndex = 0xFFFFF;
pCaps->MaxStreams = MAX_STREAMS;
pCaps->MaxStreamStride = 1024;
if (vs_selected_mode == SHADER_GLSL) {
/* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
@ -3072,19 +3072,19 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
* supports vertex shader 2.0 too and the way around. We can detect ps2.0 using the maximum number
* of native instructions, so use that here. For more info see the pixel shader versioning code below. */
if((GLINFO_LOCATION.vs_nv_version == VS_VERSION_20) || (GLINFO_LOCATION.ps_arb_max_instructions <= 512))
*pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
else
*pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
TRACE_(d3d_caps)("Hardware vertex shader version %d.%d enabled (GLSL)\n", (*pCaps->VertexShaderVersion >> 8) & 0xff, *pCaps->VertexShaderVersion & 0xff);
pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
TRACE_(d3d_caps)("Hardware vertex shader version %d.%d enabled (GLSL)\n", (pCaps->VertexShaderVersion >> 8) & 0xff, pCaps->VertexShaderVersion & 0xff);
} else if (vs_selected_mode == SHADER_ARB) {
*pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
TRACE_(d3d_caps)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
} else {
*pCaps->VertexShaderVersion = 0;
pCaps->VertexShaderVersion = 0;
TRACE_(d3d_caps)("Vertex shader functionality not available\n");
}
*pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
if (ps_selected_mode == SHADER_GLSL) {
/* Older DX9-class videocards (GeforceFX / Radeon >9500/X*00) only support pixel shader 2.0/2.0a/2.0b.
@ -3099,9 +3099,9 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
* NOTE: ps3.0 hardware requires 512 or more instructions but ati and nvidia offer 'enough' (1024 vs 4096) on their most basic ps3.0 hardware.
*/
if((GLINFO_LOCATION.ps_nv_version == PS_VERSION_20) || (GLINFO_LOCATION.ps_arb_max_instructions <= 512))
*pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
else
*pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
/* FIXME: The following line is card dependent. -8.0 to 8.0 is the
* Direct3D minimum requirement.
*
@ -3114,124 +3114,121 @@ static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter,
* the shader will generate incorrect results too. Unfortunately, GL deliberately doesn't
* offer a way to query this.
*/
*pCaps->PixelShader1xMaxValue = 8.0;
TRACE_(d3d_caps)("Hardware pixel shader version %d.%d enabled (GLSL)\n", (*pCaps->PixelShaderVersion >> 8) & 0xff, *pCaps->PixelShaderVersion & 0xff);
pCaps->PixelShader1xMaxValue = 8.0;
TRACE_(d3d_caps)("Hardware pixel shader version %d.%d enabled (GLSL)\n", (pCaps->PixelShaderVersion >> 8) & 0xff, pCaps->PixelShaderVersion & 0xff);
} else if (ps_selected_mode == SHADER_ARB) {
*pCaps->PixelShaderVersion = WINED3DPS_VERSION(1,4);
*pCaps->PixelShader1xMaxValue = 8.0;
pCaps->PixelShaderVersion = WINED3DPS_VERSION(1,4);
pCaps->PixelShader1xMaxValue = 8.0;
TRACE_(d3d_caps)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
} else {
*pCaps->PixelShaderVersion = 0;
*pCaps->PixelShader1xMaxValue = 0.0;
pCaps->PixelShaderVersion = 0;
pCaps->PixelShader1xMaxValue = 0.0;
TRACE_(d3d_caps)("Pixel shader functionality not available\n");
}
/* ------------------------------------------------
The following fields apply to d3d9 only
------------------------------------------------ */
if (This->dxVersion > 8) {
/* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
*pCaps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET;
/* TODO: VS3.0 needs at least D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET */
*pCaps->MaxNpatchTessellationLevel = 0;
*pCaps->MasterAdapterOrdinal = 0;
*pCaps->AdapterOrdinalInGroup = 0;
*pCaps->NumberOfAdaptersInGroup = 1;
/* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
pCaps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET;
/* TODO: VS3.0 needs at least D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET */
pCaps->MaxNpatchTessellationLevel = 0;
pCaps->MasterAdapterOrdinal = 0;
pCaps->AdapterOrdinalInGroup = 0;
pCaps->NumberOfAdaptersInGroup = 1;
if(*pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
/* OpenGL supports all the formats below, perhaps not always
* without conversion, but it supports them.
* Further GLSL doesn't seem to have an official unsigned type so
* don't advertise it yet as I'm not sure how we handle it.
* We might need to add some clamping in the shader engine to
* support it.
* TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
*pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4 |
WINED3DDTCAPS_UBYTE4N |
WINED3DDTCAPS_SHORT2N |
WINED3DDTCAPS_SHORT4N;
if (GL_SUPPORT(NV_HALF_FLOAT)) {
*pCaps->DeclTypes |=
WINED3DDTCAPS_FLOAT16_2 |
WINED3DDTCAPS_FLOAT16_4;
}
} else
*pCaps->DeclTypes = 0;
*pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
*pCaps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MAGFLINEAR;
*pCaps->VertexTextureFilterCaps = 0;
if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
/* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
*pCaps->VS20Caps.Caps = WINED3DVS20CAPS_PREDICATION;
*pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
*pCaps->VS20Caps.NumTemps = max(32, GLINFO_LOCATION.vs_arb_max_temps);
*pCaps->VS20Caps.StaticFlowControlDepth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
*pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
*pCaps->MaxVertexShader30InstructionSlots = max(512, GLINFO_LOCATION.vs_arb_max_instructions);
} else if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
*pCaps->VS20Caps.Caps = 0;
*pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
*pCaps->VS20Caps.NumTemps = max(12, GLINFO_LOCATION.vs_arb_max_temps);
*pCaps->VS20Caps.StaticFlowControlDepth = 1;
*pCaps->MaxVShaderInstructionsExecuted = 65535;
*pCaps->MaxVertexShader30InstructionSlots = 0;
} else { /* VS 1.x */
*pCaps->VS20Caps.Caps = 0;
*pCaps->VS20Caps.DynamicFlowControlDepth = 0;
*pCaps->VS20Caps.NumTemps = 0;
*pCaps->VS20Caps.StaticFlowControlDepth = 0;
*pCaps->MaxVShaderInstructionsExecuted = 0;
*pCaps->MaxVertexShader30InstructionSlots = 0;
if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
/* OpenGL supports all the formats below, perhaps not always
* without conversion, but it supports them.
* Further GLSL doesn't seem to have an official unsigned type so
* don't advertise it yet as I'm not sure how we handle it.
* We might need to add some clamping in the shader engine to
* support it.
* TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4 |
WINED3DDTCAPS_UBYTE4N |
WINED3DDTCAPS_SHORT2N |
WINED3DDTCAPS_SHORT4N;
if (GL_SUPPORT(NV_HALF_FLOAT)) {
pCaps->DeclTypes |=
WINED3DDTCAPS_FLOAT16_2 |
WINED3DDTCAPS_FLOAT16_4;
}
} else
pCaps->DeclTypes = 0;
if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
/* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
/* Caps is more or less undocumented on MSDN but it appears to be used for PS20Caps based on results from R9600/FX5900/Geforce6800 cards from Windows */
*pCaps->PS20Caps.Caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE |
WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
WINED3DPS20CAPS_PREDICATION |
WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
*pCaps->PS20Caps.DynamicFlowControlDepth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
*pCaps->PS20Caps.NumTemps = max(32, GLINFO_LOCATION.ps_arb_max_temps);
*pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
*pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
*pCaps->MaxPShaderInstructionsExecuted = 65535;
*pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS, GLINFO_LOCATION.ps_arb_max_instructions);
} else if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
/* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
*pCaps->PS20Caps.Caps = 0;
*pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
*pCaps->PS20Caps.NumTemps = max(12, GLINFO_LOCATION.ps_arb_max_temps);
*pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
*pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
pCaps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT |
WINED3DPTFILTERCAPS_MAGFPOINT |
WINED3DPTFILTERCAPS_MINFLINEAR |
WINED3DPTFILTERCAPS_MAGFLINEAR;
pCaps->VertexTextureFilterCaps = 0;
*pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
*pCaps->MaxPixelShader30InstructionSlots = 0;
} else { /* PS 1.x */
*pCaps->PS20Caps.Caps = 0;
*pCaps->PS20Caps.DynamicFlowControlDepth = 0;
*pCaps->PS20Caps.NumTemps = 0;
*pCaps->PS20Caps.StaticFlowControlDepth = 0;
*pCaps->PS20Caps.NumInstructionSlots = 0;
if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
/* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
pCaps->VS20Caps.Caps = WINED3DVS20CAPS_PREDICATION;
pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
pCaps->VS20Caps.NumTemps = max(32, GLINFO_LOCATION.vs_arb_max_temps);
pCaps->VS20Caps.StaticFlowControlDepth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
*pCaps->MaxPShaderInstructionsExecuted = 0;
*pCaps->MaxPixelShader30InstructionSlots = 0;
}
pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
pCaps->MaxVertexShader30InstructionSlots = max(512, GLINFO_LOCATION.vs_arb_max_instructions);
} else if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
pCaps->VS20Caps.Caps = 0;
pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
pCaps->VS20Caps.NumTemps = max(12, GLINFO_LOCATION.vs_arb_max_temps);
pCaps->VS20Caps.StaticFlowControlDepth = 1;
pCaps->MaxVShaderInstructionsExecuted = 65535;
pCaps->MaxVertexShader30InstructionSlots = 0;
} else { /* VS 1.x */
pCaps->VS20Caps.Caps = 0;
pCaps->VS20Caps.DynamicFlowControlDepth = 0;
pCaps->VS20Caps.NumTemps = 0;
pCaps->VS20Caps.StaticFlowControlDepth = 0;
pCaps->MaxVShaderInstructionsExecuted = 0;
pCaps->MaxVertexShader30InstructionSlots = 0;
}
if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
/* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
/* Caps is more or less undocumented on MSDN but it appears to be used for PS20Caps based on results from R9600/FX5900/Geforce6800 cards from Windows */
pCaps->PS20Caps.Caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE |
WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
WINED3DPS20CAPS_PREDICATION |
WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
pCaps->PS20Caps.DynamicFlowControlDepth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
pCaps->PS20Caps.NumTemps = max(32, GLINFO_LOCATION.ps_arb_max_temps);
pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
pCaps->MaxPShaderInstructionsExecuted = 65535;
pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS, GLINFO_LOCATION.ps_arb_max_instructions);
} else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
/* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
pCaps->PS20Caps.Caps = 0;
pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
pCaps->PS20Caps.NumTemps = max(12, GLINFO_LOCATION.ps_arb_max_temps);
pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
pCaps->MaxPixelShader30InstructionSlots = 0;
} else { /* PS 1.x */
pCaps->PS20Caps.Caps = 0;
pCaps->PS20Caps.DynamicFlowControlDepth = 0;
pCaps->PS20Caps.NumTemps = 0;
pCaps->PS20Caps.StaticFlowControlDepth = 0;
pCaps->PS20Caps.NumInstructionSlots = 0;
pCaps->MaxPShaderInstructionsExecuted = 0;
pCaps->MaxPixelShader30InstructionSlots = 0;
}
return WINED3D_OK;

156
include/wine/wined3d_types.h
View File

@ -1096,111 +1096,111 @@ typedef struct _WINED3DINDEXBUFFER_DESC {
*/
typedef struct _WINED3DVSHADERCAPS2_0 {
DWORD *Caps;
INT *DynamicFlowControlDepth;
INT *NumTemps;
INT *StaticFlowControlDepth;
DWORD Caps;
INT DynamicFlowControlDepth;
INT NumTemps;
INT StaticFlowControlDepth;
} WINED3DVSHADERCAPS2_0;
typedef struct _WINED3DPSHADERCAPS2_0 {
DWORD *Caps;
INT *DynamicFlowControlDepth;
INT *NumTemps;
INT *StaticFlowControlDepth;
INT *NumInstructionSlots;
DWORD Caps;
INT DynamicFlowControlDepth;
INT NumTemps;
INT StaticFlowControlDepth;
INT NumInstructionSlots;
} WINED3DPSHADERCAPS2_0;
typedef struct _WINED3DCAPS {
WINED3DDEVTYPE *DeviceType;
UINT *AdapterOrdinal;
WINED3DDEVTYPE DeviceType;
UINT AdapterOrdinal;
DWORD *Caps;
DWORD *Caps2;
DWORD *Caps3;
DWORD *PresentationIntervals;
DWORD Caps;
DWORD Caps2;
DWORD Caps3;
DWORD PresentationIntervals;
DWORD *CursorCaps;
DWORD CursorCaps;
DWORD *DevCaps;
DWORD DevCaps;
DWORD *PrimitiveMiscCaps;
DWORD *RasterCaps;
DWORD *ZCmpCaps;
DWORD *SrcBlendCaps;
DWORD *DestBlendCaps;
DWORD *AlphaCmpCaps;
DWORD *ShadeCaps;
DWORD *TextureCaps;
DWORD *TextureFilterCaps;
DWORD *CubeTextureFilterCaps;
DWORD *VolumeTextureFilterCaps;
DWORD *TextureAddressCaps;
DWORD *VolumeTextureAddressCaps;
DWORD PrimitiveMiscCaps;
DWORD RasterCaps;
DWORD ZCmpCaps;
DWORD SrcBlendCaps;
DWORD DestBlendCaps;
DWORD AlphaCmpCaps;
DWORD ShadeCaps;
DWORD TextureCaps;
DWORD TextureFilterCaps;
DWORD CubeTextureFilterCaps;
DWORD VolumeTextureFilterCaps;
DWORD TextureAddressCaps;
DWORD VolumeTextureAddressCaps;
DWORD *LineCaps;
DWORD LineCaps;
DWORD *MaxTextureWidth;
DWORD *MaxTextureHeight;
DWORD *MaxVolumeExtent;
DWORD MaxTextureWidth;
DWORD MaxTextureHeight;
DWORD MaxVolumeExtent;
DWORD *MaxTextureRepeat;
DWORD *MaxTextureAspectRatio;
DWORD *MaxAnisotropy;
float *MaxVertexW;
DWORD MaxTextureRepeat;
DWORD MaxTextureAspectRatio;
DWORD MaxAnisotropy;
float MaxVertexW;
float *GuardBandLeft;
float *GuardBandTop;
float *GuardBandRight;
float *GuardBandBottom;
float GuardBandLeft;
float GuardBandTop;
float GuardBandRight;
float GuardBandBottom;
float *ExtentsAdjust;
DWORD *StencilCaps;
float ExtentsAdjust;
DWORD StencilCaps;
DWORD *FVFCaps;
DWORD *TextureOpCaps;
DWORD *MaxTextureBlendStages;
DWORD *MaxSimultaneousTextures;
DWORD FVFCaps;
DWORD TextureOpCaps;
DWORD MaxTextureBlendStages;
DWORD MaxSimultaneousTextures;
DWORD *VertexProcessingCaps;
DWORD *MaxActiveLights;
DWORD *MaxUserClipPlanes;
DWORD *MaxVertexBlendMatrices;
DWORD *MaxVertexBlendMatrixIndex;
DWORD VertexProcessingCaps;
DWORD MaxActiveLights;
DWORD MaxUserClipPlanes;
DWORD MaxVertexBlendMatrices;
DWORD MaxVertexBlendMatrixIndex;
float *MaxPointSize;
float MaxPointSize;
DWORD *MaxPrimitiveCount;
DWORD *MaxVertexIndex;
DWORD *MaxStreams;
DWORD *MaxStreamStride;
DWORD MaxPrimitiveCount;
DWORD MaxVertexIndex;
DWORD MaxStreams;
DWORD MaxStreamStride;
DWORD *VertexShaderVersion;
DWORD *MaxVertexShaderConst;
DWORD VertexShaderVersion;
DWORD MaxVertexShaderConst;
DWORD *PixelShaderVersion;
float *PixelShader1xMaxValue;
DWORD PixelShaderVersion;
float PixelShader1xMaxValue;
/* DX 9 */
DWORD *DevCaps2;
DWORD DevCaps2;
float *MaxNpatchTessellationLevel;
DWORD *Reserved5; /*undocumented*/
float MaxNpatchTessellationLevel;
DWORD Reserved5; /*undocumented*/
UINT *MasterAdapterOrdinal;
UINT *AdapterOrdinalInGroup;
UINT *NumberOfAdaptersInGroup;
DWORD *DeclTypes;
DWORD *NumSimultaneousRTs;
DWORD *StretchRectFilterCaps;
UINT MasterAdapterOrdinal;
UINT AdapterOrdinalInGroup;
UINT NumberOfAdaptersInGroup;
DWORD DeclTypes;
DWORD NumSimultaneousRTs;
DWORD StretchRectFilterCaps;
WINED3DVSHADERCAPS2_0 VS20Caps;
WINED3DPSHADERCAPS2_0 PS20Caps;
DWORD *VertexTextureFilterCaps;
DWORD *MaxVShaderInstructionsExecuted;
DWORD *MaxPShaderInstructionsExecuted;
DWORD *MaxVertexShader30InstructionSlots;
DWORD *MaxPixelShader30InstructionSlots;
DWORD *Reserved2;/* Not in the microsoft headers but documented */
DWORD *Reserved3;
DWORD VertexTextureFilterCaps;
DWORD MaxVShaderInstructionsExecuted;
DWORD MaxPShaderInstructionsExecuted;
DWORD MaxVertexShader30InstructionSlots;
DWORD MaxPixelShader30InstructionSlots;
DWORD Reserved2;/* Not in the microsoft headers but documented */
DWORD Reserved3;
} WINED3DCAPS;