/* Parent reference */
LPDIRECT3DDEVICE8 parentDevice;
+
+ DWORD fvf;
};
/* --------------------- */
LONG ref;
/* IDirect3DResource8 fields */
- IWineD3DIndexBuffer *wineD3DIndexBuffer;
+ IWineD3DBuffer *wineD3DIndexBuffer;
/* Parent reference */
LPDIRECT3DDEVICE8 parentDevice;
+
+ WINED3DFORMAT format;
};
/* --------------------- */
object->lpVtbl = &Direct3DVertexBuffer8_Vtbl;
object->ref = 1;
EnterCriticalSection(&d3d8_cs);
- hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage & WINED3DUSAGE_MASK, FVF, (WINED3DPOOL) Pool, &(object->wineD3DVertexBuffer), NULL, (IUnknown *)object);
+ hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage & WINED3DUSAGE_MASK,
+ 0 /* fvf for ddraw only */, (WINED3DPOOL) Pool, &(object->wineD3DVertexBuffer), NULL,
+ (IUnknown *)object);
LeaveCriticalSection(&d3d8_cs);
+ object->fvf = FVF;
if (D3D_OK != hrc) {
object->lpVtbl = &Direct3DIndexBuffer8_Vtbl;
object->ref = 1;
+ object->format = wined3dformat_from_d3dformat(Format);
TRACE("Calling wined3d create index buffer\n");
EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_CreateIndexBuffer(This->WineD3DDevice, Length, Usage & WINED3DUSAGE_MASK,
- wined3dformat_from_d3dformat(Format), (WINED3DPOOL) Pool, &object->wineD3DIndexBuffer,
+ (WINED3DPOOL) Pool, &object->wineD3DIndexBuffer,
NULL, (IUnknown *)object);
LeaveCriticalSection(&d3d8_cs);
static HRESULT WINAPI IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface, UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags) {
IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
HRESULT hr;
+ IDirect3DVertexBuffer8Impl *dest = (IDirect3DVertexBuffer8Impl *) pDestBuffer;
TRACE("(%p) Relay\n" , This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, ((IDirect3DVertexBuffer8Impl *)pDestBuffer)->wineD3DVertexBuffer, NULL, Flags);
+ hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, dest->wineD3DVertexBuffer, NULL, Flags, dest->fvf);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
static HRESULT WINAPI IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8* pIndexData, UINT baseVertexIndex) {
IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
HRESULT hr;
+ IDirect3DIndexBuffer8Impl *ib = (IDirect3DIndexBuffer8Impl *)pIndexData;
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
*/
IWineD3DDevice_SetBaseVertexIndex(This->WineD3DDevice, baseVertexIndex);
hr = IWineD3DDevice_SetIndices(This->WineD3DDevice,
- pIndexData ? ((IDirect3DIndexBuffer8Impl *)pIndexData)->wineD3DIndexBuffer : NULL);
+ ib ? ib->wineD3DIndexBuffer : NULL,
+ ib ? ib->format : WINED3DFMT_UNKNOWN);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
static HRESULT WINAPI IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex) {
IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
- IWineD3DIndexBuffer *retIndexData = NULL;
+ IWineD3DBuffer *retIndexData = NULL;
HRESULT rc = D3D_OK;
TRACE("(%p) Relay\n", This);
IWineD3DDevice_GetBaseVertexIndex(This->WineD3DDevice, (INT *) pBaseVertexIndex);
rc = IWineD3DDevice_GetIndices(This->WineD3DDevice, &retIndexData);
if (SUCCEEDED(rc) && retIndexData) {
- IWineD3DIndexBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
- IWineD3DIndexBuffer_Release(retIndexData);
+ IWineD3DBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
+ IWineD3DBuffer_Release(retIndexData);
} else {
if (FAILED(rc)) FIXME("Call to GetIndices failed\n");
*ppIndexData = NULL;
DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) {
IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
HRESULT hr;
+ WINED3DRESOURCETYPE WineD3DRType;
TRACE("(%p)->(%d, %d, %d, %08x, %d, %d)\n", This, Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat);
+ switch(RType) {
+ case D3DRTYPE_VERTEXBUFFER:
+ case D3DRTYPE_INDEXBUFFER:
+ WineD3DRType = WINED3DRTYPE_BUFFER;
+ break;
+
+ default:
+ WineD3DRType = RType;
+ break;
+ }
+
EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_CheckDeviceFormat(This->WineD3D, Adapter, DeviceType, wined3dformat_from_d3dformat(AdapterFormat),
- Usage, RType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL);
+ Usage, WineD3DRType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
if (ref == 0) {
EnterCriticalSection(&d3d8_cs);
- IWineD3DIndexBuffer_Release(This->wineD3DIndexBuffer);
+ IWineD3DBuffer_Release(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d8_cs);
IUnknown_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DIndexBuffer_GetDevice(This->wineD3DIndexBuffer, &wined3d_device);
+ hr = IWineD3DBuffer_GetDevice(This->wineD3DIndexBuffer, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DIndexBuffer_SetPrivateData(This->wineD3DIndexBuffer, refguid, pData, SizeOfData, Flags);
+ hr = IWineD3DBuffer_SetPrivateData(This->wineD3DIndexBuffer, refguid, pData, SizeOfData, Flags);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DIndexBuffer_GetPrivateData(This->wineD3DIndexBuffer, refguid, pData, pSizeOfData);
+ hr = IWineD3DBuffer_GetPrivateData(This->wineD3DIndexBuffer, refguid, pData, pSizeOfData);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DIndexBuffer_FreePrivateData(This->wineD3DIndexBuffer, refguid);
+ hr = IWineD3DBuffer_FreePrivateData(This->wineD3DIndexBuffer, refguid);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- ret = IWineD3DIndexBuffer_SetPriority(This->wineD3DIndexBuffer, PriorityNew);
+ ret = IWineD3DBuffer_SetPriority(This->wineD3DIndexBuffer, PriorityNew);
LeaveCriticalSection(&d3d8_cs);
return ret;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- ret = IWineD3DIndexBuffer_GetPriority(This->wineD3DIndexBuffer);
+ ret = IWineD3DBuffer_GetPriority(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d8_cs);
return ret;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- IWineD3DIndexBuffer_PreLoad(This->wineD3DIndexBuffer);
+ IWineD3DBuffer_PreLoad(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d8_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer8Impl_GetType(LPDIRECT3DINDEXBUFFER8 iface) {
IDirect3DIndexBuffer8Impl *This = (IDirect3DIndexBuffer8Impl *)iface;
- D3DRESOURCETYPE type;
- TRACE("(%p) Relay\n", This);
+ TRACE("(%p)\n", This);
- EnterCriticalSection(&d3d8_cs);
- type = IWineD3DIndexBuffer_GetType(This->wineD3DIndexBuffer);
- LeaveCriticalSection(&d3d8_cs);
- return type;
+ return D3DRTYPE_INDEXBUFFER;
}
/* IDirect3DIndexBuffer8 Interface follow: */
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DIndexBuffer_Lock(This->wineD3DIndexBuffer, OffsetToLock, SizeToLock, ppbData, Flags);
+ hr = IWineD3DBuffer_Map(This->wineD3DIndexBuffer, OffsetToLock, SizeToLock, ppbData, Flags);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DIndexBuffer_Unlock(This->wineD3DIndexBuffer);
+ hr = IWineD3DBuffer_Unmap(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d8_cs);
return hr;
}
static HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetDesc(LPDIRECT3DINDEXBUFFER8 iface, D3DINDEXBUFFER_DESC *pDesc) {
IDirect3DIndexBuffer8Impl *This = (IDirect3DIndexBuffer8Impl *)iface;
HRESULT hr;
+ WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DIndexBuffer_GetDesc(This->wineD3DIndexBuffer, (WINED3DINDEXBUFFER_DESC *) pDesc);
+ hr = IWineD3DBuffer_GetDesc(This->wineD3DIndexBuffer, &desc);
LeaveCriticalSection(&d3d8_cs);
- if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
+ if (SUCCEEDED(hr)) {
+ pDesc->Format = d3dformat_from_wined3dformat(This->format);
+ pDesc->Type = D3DRTYPE_INDEXBUFFER;
+ pDesc->Usage = desc.Usage;
+ pDesc->Pool = desc.Pool;
+ pDesc->Size = desc.Size;
+ }
return hr;
}
static D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer8Impl_GetType(LPDIRECT3DVERTEXBUFFER8 iface) {
IDirect3DVertexBuffer8Impl *This = (IDirect3DVertexBuffer8Impl *)iface;
- D3DRESOURCETYPE type;
- TRACE("(%p) Relay\n", This);
+ TRACE("(%p)\n", This);
- EnterCriticalSection(&d3d8_cs);
- type = IWineD3DBuffer_GetType(This->wineD3DVertexBuffer);
- LeaveCriticalSection(&d3d8_cs);
- return type;
+ return D3DRTYPE_VERTEXBUFFER;
}
/* IDirect3DVertexBuffer8 Interface follow: */
static HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetDesc(LPDIRECT3DVERTEXBUFFER8 iface, D3DVERTEXBUFFER_DESC *pDesc) {
IDirect3DVertexBuffer8Impl *This = (IDirect3DVertexBuffer8Impl *)iface;
HRESULT hr;
+ WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d8_cs);
- hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, (WINED3DVERTEXBUFFER_DESC *)pDesc);
+ hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &desc);
LeaveCriticalSection(&d3d8_cs);
- if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
+ if (SUCCEEDED(hr)) {
+ pDesc->Type = D3DRTYPE_VERTEXBUFFER;
+ pDesc->Usage = desc.Usage;
+ pDesc->Pool = desc.Pool;
+ pDesc->Size = desc.Size;
+ pDesc->FVF = This->fvf;
+ pDesc->Format = D3DFMT_VERTEXDATA;
+ }
return hr;
}
+++ /dev/null
-TOPSRCDIR = @top_srcdir@
-TOPOBJDIR = ../..
-SRCDIR = @srcdir@
-VPATH = @srcdir@
-MODULE = d3d9.dll
-IMPORTLIB = d3d9
-IMPORTS = dxguid uuid wined3d kernel32
-
-C_SRCS = \
- basetexture.c \
- cubetexture.c \
- d3d9_main.c \
- device.c \
- directx.c \
- indexbuffer.c \
- pixelshader.c \
- query.c \
- resource.c \
- stateblock.c \
- surface.c \
- swapchain.c \
- texture.c \
- vertexbuffer.c \
- vertexdeclaration.c \
- vertexshader.c \
- volume.c \
- volumetexture.c
-
-RC_SRCS = version.rc
-
-@MAKE_DLL_RULES@
-
-@DEPENDENCIES@ # everything below this line is overwritten by make depend
/* Parent reference */
LPDIRECT3DDEVICE9EX parentDevice;
+
+ DWORD fvf;
} IDirect3DVertexBuffer9Impl;
/* --------------------- */
LONG ref;
/* IDirect3DResource9 fields */
- IWineD3DIndexBuffer *wineD3DIndexBuffer;
+ IWineD3DBuffer *wineD3DIndexBuffer;
/* Parent reference */
LPDIRECT3DDEVICE9EX parentDevice;
+ WINED3DFORMAT format;
} IDirect3DIndexBuffer9Impl;
/* --------------------- */
HRESULT ret = S_OK;
WINED3DSURFACE_DESC surface_desc;
WINED3DVOLUME_DESC volume_desc;
- WINED3DINDEXBUFFER_DESC index_desc;
- WINED3DVERTEXBUFFER_DESC vertex_desc;
+ D3DINDEXBUFFER_DESC index_desc;
+ D3DVERTEXBUFFER_DESC vertex_desc;
WINED3DFORMAT dummy_format;
WINED3DMULTISAMPLE_TYPE dummy_multisampletype;
DWORD dummy_dword;
WINED3DPOOL pool = WINED3DPOOL_SCRATCH; /* a harmless pool */
- IUnknown *parent;
+ IDirect3DResource9 *parent;
- type = IWineD3DResource_GetType(resource);
+ IWineD3DResource_GetParent(resource, (IUnknown **) &parent);
+ type = IDirect3DResource9_GetType(parent);
switch(type) {
- case WINED3DRTYPE_SURFACE:
+ case D3DRTYPE_SURFACE:
surface_desc.Format = &dummy_format;
surface_desc.Type = &type;
surface_desc.Usage = &dummy_dword;
IWineD3DSurface_GetDesc((IWineD3DSurface *) resource, &surface_desc);
break;
- case WINED3DRTYPE_VOLUME:
+ case D3DRTYPE_VOLUME:
volume_desc.Format = &dummy_format;
volume_desc.Type = &type;
volume_desc.Usage = &dummy_dword;
IWineD3DVolume_GetDesc((IWineD3DVolume *) resource, &volume_desc);
break;
- case WINED3DRTYPE_INDEXBUFFER:
- IWineD3DIndexBuffer_GetDesc((IWineD3DIndexBuffer *) resource, &index_desc);
+ case D3DRTYPE_INDEXBUFFER:
+ IDirect3DIndexBuffer9_GetDesc((IDirect3DIndexBuffer9 *) parent, &index_desc);
pool = index_desc.Pool;
break;
- case WINED3DRTYPE_VERTEXBUFFER:
- IWineD3DBuffer_GetDesc((IWineD3DBuffer *)resource, &vertex_desc);
+ case D3DRTYPE_VERTEXBUFFER:
+ IDirect3DVertexBuffer9_GetDesc((IDirect3DVertexBuffer9 *)parent, &vertex_desc);
pool = vertex_desc.Pool;
break;
}
if(pool == WINED3DPOOL_DEFAULT) {
- IWineD3DResource_GetParent(resource, &parent);
if(IUnknown_Release(parent) == 0) {
TRACE("Parent %p is an implicit resource with ref 0\n", parent);
} else {
ret = S_FALSE;
*resources_ok = FALSE;
}
+ } else {
+ IUnknown_Release(parent);
}
IWineD3DResource_Release(resource);
* below fails, the device is considered "lost", and _Reset and _Release are the only allowed calls
*/
EnterCriticalSection(&d3d9_cs);
-
- IWineD3DDevice_SetIndices(This->WineD3DDevice, NULL);
+ IWineD3DDevice_SetIndices(This->WineD3DDevice, NULL, WINED3DFMT_UNKNOWN);
for(i = 0; i < 16; i++) {
IWineD3DDevice_SetStreamSource(This->WineD3DDevice, i, NULL, 0, 0);
}
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
IDirect3DVertexDeclaration9Impl *Decl = (IDirect3DVertexDeclaration9Impl *) pVertexDecl;
HRESULT hr;
+ IDirect3DVertexBuffer9Impl *dest = (IDirect3DVertexBuffer9Impl *) pDestBuffer;
TRACE("(%p) Relay\n" , This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, ((IDirect3DVertexBuffer9Impl *)pDestBuffer)->wineD3DVertexBuffer, Decl ? Decl->wineD3DVertexDeclaration : NULL, Flags);
+ hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, dest->wineD3DVertexBuffer, Decl ? Decl->wineD3DVertexDeclaration : NULL, Flags, dest->fvf);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
static HRESULT WINAPI IDirect3DDevice9Impl_SetIndices(LPDIRECT3DDEVICE9EX iface, IDirect3DIndexBuffer9* pIndexData) {
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
+ IDirect3DIndexBuffer9Impl *ib = (IDirect3DIndexBuffer9Impl *) pIndexData;
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetIndices(This->WineD3DDevice,
- pIndexData ? ((IDirect3DIndexBuffer9Impl *)pIndexData)->wineD3DIndexBuffer : NULL);
+ ib ? ib->wineD3DIndexBuffer : NULL,
+ ib ? ib->format : WINED3DFMT_UNKNOWN);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
static HRESULT WINAPI IDirect3DDevice9Impl_GetIndices(LPDIRECT3DDEVICE9EX iface, IDirect3DIndexBuffer9 **ppIndexData) {
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
- IWineD3DIndexBuffer *retIndexData = NULL;
+ IWineD3DBuffer *retIndexData = NULL;
HRESULT rc = D3D_OK;
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
rc = IWineD3DDevice_GetIndices(This->WineD3DDevice, &retIndexData);
if (SUCCEEDED(rc) && retIndexData) {
- IWineD3DIndexBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
- IWineD3DIndexBuffer_Release(retIndexData);
+ IWineD3DBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
+ IWineD3DBuffer_Release(retIndexData);
} else {
if (FAILED(rc)) FIXME("Call to GetIndices failed\n");
*ppIndexData = NULL;
DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) {
IDirect3D9Impl *This = (IDirect3D9Impl *)iface;
HRESULT hr;
+ WINED3DRESOURCETYPE WineD3DRType;
TRACE("%p\n", This);
+ switch(RType) {
+ case D3DRTYPE_VERTEXBUFFER:
+ case D3DRTYPE_INDEXBUFFER:
+ WineD3DRType = WINED3DRTYPE_BUFFER;
+ break;
+
+ default:
+ WineD3DRType = RType;
+ break;
+ }
+
EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_CheckDeviceFormat(This->WineD3D, Adapter, DeviceType, wined3dformat_from_d3dformat(AdapterFormat),
- Usage, RType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL);
+ Usage, WineD3DRType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
if (ref == 0) {
EnterCriticalSection(&d3d9_cs);
- IWineD3DIndexBuffer_Release(This->wineD3DIndexBuffer);
+ IWineD3DBuffer_Release(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DIndexBuffer_GetDevice(This->wineD3DIndexBuffer, &wined3d_device);
+ hr = IWineD3DBuffer_GetDevice(This->wineD3DIndexBuffer, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DIndexBuffer_SetPrivateData(This->wineD3DIndexBuffer, refguid, pData, SizeOfData, Flags);
+ hr = IWineD3DBuffer_SetPrivateData(This->wineD3DIndexBuffer, refguid, pData, SizeOfData, Flags);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DIndexBuffer_GetPrivateData(This->wineD3DIndexBuffer, refguid, pData, pSizeOfData);
+ hr = IWineD3DBuffer_GetPrivateData(This->wineD3DIndexBuffer, refguid, pData, pSizeOfData);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DIndexBuffer_FreePrivateData(This->wineD3DIndexBuffer, refguid);
+ hr = IWineD3DBuffer_FreePrivateData(This->wineD3DIndexBuffer, refguid);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- ret = IWineD3DIndexBuffer_SetPriority(This->wineD3DIndexBuffer, PriorityNew);
+ ret = IWineD3DBuffer_SetPriority(This->wineD3DIndexBuffer, PriorityNew);
LeaveCriticalSection(&d3d9_cs);
return ret;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- ret = IWineD3DIndexBuffer_GetPriority(This->wineD3DIndexBuffer);
+ ret = IWineD3DBuffer_GetPriority(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d9_cs);
return ret;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- IWineD3DIndexBuffer_PreLoad(This->wineD3DIndexBuffer);
+ IWineD3DBuffer_PreLoad(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d9_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer9Impl_GetType(LPDIRECT3DINDEXBUFFER9 iface) {
IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface;
- D3DRESOURCETYPE ret;
- TRACE("(%p) Relay\n", This);
+ TRACE("(%p)\n", This);
- EnterCriticalSection(&d3d9_cs);
- ret = IWineD3DIndexBuffer_GetType(This->wineD3DIndexBuffer);
- LeaveCriticalSection(&d3d9_cs);
- return ret;
+ return D3DRTYPE_INDEXBUFFER;
}
/* IDirect3DIndexBuffer9 Interface follow: */
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DIndexBuffer_Lock(This->wineD3DIndexBuffer, OffsetToLock, SizeToLock, (BYTE **)ppbData, Flags);
+ hr = IWineD3DBuffer_Map(This->wineD3DIndexBuffer, OffsetToLock, SizeToLock, (BYTE **)ppbData, Flags);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DIndexBuffer_Unlock(This->wineD3DIndexBuffer);
+ hr = IWineD3DBuffer_Unmap(This->wineD3DIndexBuffer);
LeaveCriticalSection(&d3d9_cs);
return hr;
}
static HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetDesc(LPDIRECT3DINDEXBUFFER9 iface, D3DINDEXBUFFER_DESC *pDesc) {
IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface;
HRESULT hr;
+ WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DIndexBuffer_GetDesc(This->wineD3DIndexBuffer, (WINED3DINDEXBUFFER_DESC *) pDesc);
+ hr = IWineD3DBuffer_GetDesc(This->wineD3DIndexBuffer, &desc);
LeaveCriticalSection(&d3d9_cs);
- if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
+ if (SUCCEEDED(hr)) {
+ pDesc->Format = d3dformat_from_wined3dformat(This->format);
+ pDesc->Usage = desc.Usage;
+ pDesc->Pool = desc.Pool;
+ pDesc->Size = desc.Size;
+ pDesc->Type = D3DRTYPE_INDEXBUFFER;
+ }
return hr;
}
object->lpVtbl = &Direct3DIndexBuffer9_Vtbl;
object->ref = 1;
+ object->format = wined3dformat_from_d3dformat(Format);
TRACE("Calling wined3d create index buffer\n");
EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreateIndexBuffer(This->WineD3DDevice, Length, Usage & WINED3DUSAGE_MASK,
- wined3dformat_from_d3dformat(Format), (WINED3DPOOL)Pool, &object->wineD3DIndexBuffer,
+ (WINED3DPOOL)Pool, &object->wineD3DIndexBuffer,
pSharedHandle, (IUnknown *)object);
LeaveCriticalSection(&d3d9_cs);
if (hrc != D3D_OK) {
static D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer9Impl_GetType(LPDIRECT3DVERTEXBUFFER9 iface) {
IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface;
- D3DRESOURCETYPE ret;
- TRACE("(%p) Relay\n", This);
+ TRACE("(%p)\n", This);
- EnterCriticalSection(&d3d9_cs);
- ret = IWineD3DBuffer_GetType(This->wineD3DVertexBuffer);
- LeaveCriticalSection(&d3d9_cs);
- return ret;
+ return D3DRTYPE_VERTEXBUFFER;
}
/* IDirect3DVertexBuffer9 Interface follow: */
static HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetDesc(LPDIRECT3DVERTEXBUFFER9 iface, D3DVERTEXBUFFER_DESC* pDesc) {
IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface;
HRESULT hr;
+ WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
EnterCriticalSection(&d3d9_cs);
- hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, (WINED3DVERTEXBUFFER_DESC *)pDesc);
+ hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &desc);
LeaveCriticalSection(&d3d9_cs);
- if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
+ if (SUCCEEDED(hr)) {
+ pDesc->Format = D3DFMT_VERTEXDATA;
+ pDesc->Usage = desc.Usage;
+ pDesc->Pool = desc.Pool;
+ pDesc->Size = desc.Size;
+ pDesc->Type = D3DRTYPE_VERTEXBUFFER;
+ pDesc->FVF = This->fvf;
+ }
+
return hr;
}
object->lpVtbl = &Direct3DVertexBuffer9_Vtbl;
object->ref = 1;
+ object->fvf = FVF;
EnterCriticalSection(&d3d9_cs);
- hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage & WINED3DUSAGE_MASK, FVF, (WINED3DPOOL) Pool, &(object->wineD3DVertexBuffer), pSharedHandle, (IUnknown *)object);
+ hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage & WINED3DUSAGE_MASK,
+ 0 /* fvf for ddraw only */, (WINED3DPOOL) Pool, &(object->wineD3DVertexBuffer),
+ pSharedHandle, (IUnknown *)object);
LeaveCriticalSection(&d3d9_cs);
if (hrc != D3D_OK) {
/* Other object connections */
IWineD3DDevice *wineD3DDevice;
IDirectDrawImpl *ddraw;
- IWineD3DIndexBuffer *indexbuffer;
+ IWineD3DBuffer *indexbuffer;
IDirectDrawSurfaceImpl *target;
BOOL OffScreenTarget;
/*** Storage for D3D7 specific things ***/
DWORD Caps;
+ DWORD fvf;
};
/* The Vtables */
EnterCriticalSection(&ddraw_cs);
/* Free the index buffer. */
- IWineD3DDevice_SetIndices(This->wineD3DDevice, NULL);
- IWineD3DIndexBuffer_GetParent(This->indexbuffer,
- (IUnknown **) &IndexBufferParent);
+ IWineD3DDevice_SetIndices(This->wineD3DDevice, NULL, WINED3DFMT_UNKNOWN);
+ IWineD3DBuffer_GetParent(This->indexbuffer,
+ (IUnknown **) &IndexBufferParent);
IParent_Release(IndexBufferParent); /* Once for the getParent */
if( IParent_Release(IndexBufferParent) != 0) /* And now to destroy it */
{
IDirect3DVertexBufferImpl *vb = (IDirect3DVertexBufferImpl *)D3DVertexBuf;
HRESULT hr;
DWORD stride;
- WINED3DVERTEXBUFFER_DESC Desc;
TRACE("(%p)->(%08x,%p,%08x,%08x,%08x)\n", This, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
ERR("(%p) No Vertex buffer specified\n", This);
return DDERR_INVALIDPARAMS;
}
+ stride = get_flexible_vertex_size(vb->fvf);
- /* Get the FVF of the vertex buffer, and its stride */
EnterCriticalSection(&ddraw_cs);
- hr = IWineD3DBuffer_GetDesc(vb->wineD3DVertexBuffer, &Desc);
- if(hr != D3D_OK)
- {
- ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr = %08x\n", This, hr);
- LeaveCriticalSection(&ddraw_cs);
- return hr;
- }
- stride = get_flexible_vertex_size(Desc.FVF);
-
hr = IWineD3DDevice_SetVertexDeclaration(This->wineD3DDevice,
vb->wineD3DVertexDeclaration);
if(FAILED(hr))
{
IDirect3DDeviceImpl *This = (IDirect3DDeviceImpl *)iface;
IDirect3DVertexBufferImpl *vb = (IDirect3DVertexBufferImpl *)D3DVertexBuf;
- DWORD stride;
+ DWORD stride = get_flexible_vertex_size(vb->fvf);
WORD *LockedIndices;
HRESULT hr;
- WINED3DVERTEXBUFFER_DESC Desc;
TRACE("(%p)->(%08x,%p,%d,%d,%p,%d,%08x)\n", This, PrimitiveType, vb, StartVertex, NumVertices, Indices, IndexCount, Flags);
/* Steps:
- * 1) Calculate some things: stride, ...
- * 2) Upload the Indices to the index buffer
- * 3) Set the index source
- * 4) Set the Vertex Buffer as the Stream source
- * 5) Call IWineD3DDevice::DrawIndexedPrimitive
+ * 1) Upload the Indices to the index buffer
+ * 2) Set the index source
+ * 3) Set the Vertex Buffer as the Stream source
+ * 4) Call IWineD3DDevice::DrawIndexedPrimitive
*/
EnterCriticalSection(&ddraw_cs);
- /* Get the FVF of the vertex buffer, and its stride */
- hr = IWineD3DBuffer_GetDesc(vb->wineD3DVertexBuffer, &Desc);
- if(hr != D3D_OK)
- {
- ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr = %08x\n", This, hr);
- LeaveCriticalSection(&ddraw_cs);
- return hr;
- }
- stride = get_flexible_vertex_size(Desc.FVF);
- TRACE("Vertex buffer FVF = %08x, stride=%d\n", Desc.FVF, stride);
hr = IWineD3DDevice_SetVertexDeclaration(This->wineD3DDevice,
vb->wineD3DVertexDeclaration);
* or a SetData-Method for the index buffer, which
* overrides the index buffer data with our pointer.
*/
- hr = IWineD3DIndexBuffer_Lock(This->indexbuffer,
- 0 /* OffSetToLock */,
- IndexCount * sizeof(WORD),
- (BYTE **) &LockedIndices,
- 0 /* Flags */);
+ hr = IWineD3DBuffer_Map(This->indexbuffer,
+ 0 /* OffSetToLock */,
+ IndexCount * sizeof(WORD),
+ (BYTE **) &LockedIndices,
+ 0 /* Flags */);
assert(IndexCount < 0x100000);
if(hr != D3D_OK)
{
- ERR("(%p) IWineD3DIndexBuffer::Lock failed with hr = %08x\n", This, hr);
+ ERR("(%p) IWineD3DBuffer::Map failed with hr = %08x\n", This, hr);
LeaveCriticalSection(&ddraw_cs);
return hr;
}
memcpy(LockedIndices, Indices, IndexCount * sizeof(WORD));
- hr = IWineD3DIndexBuffer_Unlock(This->indexbuffer);
+ hr = IWineD3DBuffer_Unmap(This->indexbuffer);
if(hr != D3D_OK)
{
- ERR("(%p) IWineD3DIndexBuffer::Unlock failed with hr = %08x\n", This, hr);
+ ERR("(%p) IWineD3DBuffer::Unmap failed with hr = %08x\n", This, hr);
LeaveCriticalSection(&ddraw_cs);
return hr;
}
/* Set the index stream */
IWineD3DDevice_SetBaseVertexIndex(This->wineD3DDevice, StartVertex);
- hr = IWineD3DDevice_SetIndices(This->wineD3DDevice, This->indexbuffer);
+ hr = IWineD3DDevice_SetIndices(This->wineD3DDevice, This->indexbuffer,
+ WINED3DFMT_R16_UINT);
/* Set the vertex stream source */
hr = IWineD3DDevice_SetStreamSource(This->wineD3DDevice,
/* Create an Index Buffer. WineD3D needs one for Drawing indexed primitives
* Create a (hopefully) long enough buffer, and copy the indices into it
- * Ideally, a IWineD3DIndexBuffer::SetData method could be created, which
+ * Ideally, a IWineD3DBuffer::SetData method could be created, which
* takes the pointer and avoids the memcpy
*/
hr = IWineD3DDevice_CreateIndexBuffer(This->wineD3DDevice, 0x40000 /* Length. Don't know how long it should be */,
- WINED3DUSAGE_DYNAMIC /* Usage */, WINED3DFMT_R16_UINT /* Format. D3D7 uses WORDS */, WINED3DPOOL_DEFAULT,
+ WINED3DUSAGE_DYNAMIC /* Usage */, WINED3DPOOL_DEFAULT,
&object->indexbuffer, 0 /* Handle */, (IUnknown *)IndexBufferParent);
if(FAILED(hr))
object->Caps = Desc->dwCaps;
object->ddraw = This;
+ object->fvf = Desc->dwFVF;
EnterCriticalSection(&ddraw_cs);
hr = IWineD3DDevice_CreateVertexBuffer(This->wineD3DDevice,
TRACE("(%p) Destroying the render target, uninitializing D3D\n", This);
/* Unset any index buffer, just to be sure */
- IWineD3DDevice_SetIndices(ddraw->wineD3DDevice, NULL);
+ IWineD3DDevice_SetIndices(ddraw->wineD3DDevice, NULL, WINED3DFMT_UNKNOWN);
IWineD3DDevice_SetDepthStencilSurface(ddraw->wineD3DDevice, NULL);
IWineD3DDevice_SetVertexDeclaration(ddraw->wineD3DDevice, NULL);
for(i = 0; i < ddraw->numConvertedDecls; i++)
DWORD *Size)
{
IDirect3DVertexBufferImpl *This = (IDirect3DVertexBufferImpl *)iface;
- WINED3DVERTEXBUFFER_DESC Desc;
+ WINED3DBUFFER_DESC Desc;
HRESULT hr;
TRACE("(%p)->(%08x,%p,%p)\n", This, Flags, Data, Size);
hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &Desc);
if(hr != D3D_OK)
{
- ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr=%08x\n", This, hr);
+ ERR("(%p) IWineD3DBuffer::GetDesc failed with hr=%08x\n", This, hr);
LeaveCriticalSection(&ddraw_cs);
return hr;
}
IDirect3DDeviceImpl *D3D = (IDirect3DDeviceImpl *)D3DDevice;
BOOL oldClip, doClip;
HRESULT hr;
- WINED3DVERTEXBUFFER_DESC Desc;
TRACE("(%p)->(%08x,%d,%d,%p,%d,%p,%08x)\n", This, VertexOp, DestIndex, Count, Src, SrcIndex, D3D, Flags);
doClip);
}
- IWineD3DBuffer_GetDesc(Src->wineD3DVertexBuffer, &Desc);
IWineD3DDevice_SetStreamSource(D3D->wineD3DDevice,
0, /* Stream No */
Src->wineD3DVertexBuffer,
0, /* Offset */
- get_flexible_vertex_size(Desc.FVF));
+ get_flexible_vertex_size(Src->fvf));
IWineD3DDevice_SetVertexDeclaration(D3D->wineD3DDevice,
Src->wineD3DVertexDeclaration);
hr = IWineD3DDevice_ProcessVertices(D3D->wineD3DDevice,
Count,
This->wineD3DVertexBuffer,
NULL /* Output vdecl */,
- Flags);
+ Flags,
+ This->fvf);
/* Restore the states if needed */
if(doClip != oldClip)
D3DVERTEXBUFFERDESC *Desc)
{
IDirect3DVertexBufferImpl *This = (IDirect3DVertexBufferImpl *)iface;
- WINED3DVERTEXBUFFER_DESC WDesc;
+ WINED3DBUFFER_DESC WDesc;
HRESULT hr;
TRACE("(%p)->(%p)\n", This, Desc);
hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &WDesc);
if(hr != D3D_OK)
{
- ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr=%08x\n", This, hr);
+ ERR("(%p) IWineD3DBuffer::GetDesc failed with hr=%08x\n", This, hr);
LeaveCriticalSection(&ddraw_cs);
return hr;
}
/* Now fill the Desc structure */
Desc->dwCaps = This->Caps;
- Desc->dwFVF = WDesc.FVF;
- Desc->dwNumVertices = WDesc.Size / get_flexible_vertex_size(WDesc.FVF);
+ Desc->dwFVF = This->fvf;
+ Desc->dwNumVertices = WDesc.Size / get_flexible_vertex_size(This->fvf);
LeaveCriticalSection(&ddraw_cs);
return D3D_OK;
#define GLINFO_LOCATION (*gl_info)
+/* We have to subtract any other PARAMs that we might use in our shader programs.
+ * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
+ * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
+#define ARB_SHADER_RESERVED_VS_CONSTS 3
+
+/* The arb shader only loads the bump mapping environment matrix into the shader if it finds
+ * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
+ */
+#define ARB_SHADER_RESERVED_PS_CONSTS 2
+
/* Internally used shader constants. Applications can use constants 0 to GL_LIMITS(vshader_constantsF) - 1,
* so upload them above that
*/
-#define ARB_SHADER_PRIVCONST_BASE GL_LIMITS(vshader_constantsF)
+#define ARB_SHADER_PRIVCONST_BASE (GL_LIMITS(vshader_constantsF) - ARB_SHADER_RESERVED_VS_CONSTS)
#define ARB_SHADER_PRIVCONST_POS ARB_SHADER_PRIVCONST_BASE + 0
/* ARB_program_shader private data */
}
}
+/**
+ * Loads the texture dimensions for NP2 fixup into the currently set ARB_[vertex/fragment]_programs.
+ */
+static void shader_arb_load_np2fixup_constants(
+ IWineD3DDevice* device,
+ char usePixelShader,
+ char useVertexShader) {
+ /* not implemented */
+}
+
/**
* Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
*
DWORD i, cur;
char pshader = shader_is_pshader_version(reg_maps->shader_version);
unsigned max_constantsF = min(This->baseShader.limits.constant_float,
- (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
+ (pshader ? GL_LIMITS(pshader_constantsF) - ARB_SHADER_RESERVED_PS_CONSTS :
+ GL_LIMITS(vshader_constantsF) - ARB_SHADER_RESERVED_VS_CONSTS));
UINT extra_constants_needed = 0;
const local_constant *lconst;
* the stateblock into the shader. If no constant is available don't load, texbem will then just sample the texture without applying
* bump mapping.
*/
- if(max_constantsF + extra_constants_needed < GL_LIMITS(pshader_constantsF)) {
+ if(max_constantsF + extra_constants_needed < GL_LIMITS(pshader_constantsF) - ARB_SHADER_RESERVED_PS_CONSTS) {
ps->bumpenvmatconst[cur].const_num = max_constantsF + extra_constants_needed;
shader_addline(buffer, "PARAM bumpenvmat%d = program.env[%d];\n",
i, ps->bumpenvmatconst[cur].const_num);
extra_constants_needed++;
- if(reg_maps->luminanceparams && max_constantsF + extra_constants_needed < GL_LIMITS(pshader_constantsF)) {
+ if(reg_maps->luminanceparams && max_constantsF + extra_constants_needed < GL_LIMITS(pshader_constantsF) - ARB_SHADER_RESERVED_PS_CONSTS) {
((IWineD3DPixelShaderImpl *)This)->luminanceconst[cur].const_num = max_constantsF + extra_constants_needed;
shader_addline(buffer, "PARAM luminance%d = program.env[%d];\n",
i, ps->luminanceconst[cur].const_num);
};
static void shader_arb_get_write_mask(const struct wined3d_shader_instruction *ins,
- const DWORD param, char *write_mask)
+ const struct wined3d_shader_dst_param *dst, char *write_mask)
{
char *ptr = write_mask;
char vshader = shader_is_vshader_version(ins->reg_maps->shader_version);
- if(vshader && shader_get_regtype(param) == WINED3DSPR_ADDR) {
+ if (vshader && dst->register_type == WINED3DSPR_ADDR)
+ {
*ptr++ = '.';
*ptr++ = 'x';
- } else if ((param & WINED3DSP_WRITEMASK_ALL) != WINED3DSP_WRITEMASK_ALL) {
+ }
+ else if (dst->write_mask != WINED3DSP_WRITEMASK_ALL)
+ {
*ptr++ = '.';
- if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
- if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
- if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
- if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
+ if (dst->write_mask & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
+ if (dst->write_mask & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
+ if (dst->write_mask & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
+ if (dst->write_mask & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
}
*ptr = '\0';
*ptr = '\0';
}
-static void pshader_get_register_name(IWineD3DBaseShader* iface,
- const DWORD param, char* regstr) {
+static void shader_arb_get_register_name(IWineD3DBaseShader *iface, WINED3DSHADER_PARAM_REGISTER_TYPE register_type,
+ UINT register_idx, BOOL rel_addr, char *register_name, BOOL *is_color)
+{
+ /* oPos, oFog and oPts in D3D */
+ static const char * const rastout_reg_names[] = {"TMP_OUT", "result.fogcoord", "result.pointsize"};
+ IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
+ DWORD shader_version = This->baseShader.reg_maps.shader_version;
+ BOOL pshader = shader_is_pshader_version(shader_version);
- DWORD reg = param & WINED3DSP_REGNUM_MASK;
- DWORD regtype = shader_get_regtype(param);
- IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) iface;
+ *is_color = FALSE;
- switch (regtype) {
- case WINED3DSPR_TEMP:
- sprintf(regstr, "R%u", reg);
- break;
- case WINED3DSPR_INPUT:
- if (reg==0) {
- strcpy(regstr, "fragment.color.primary");
- } else {
- strcpy(regstr, "fragment.color.secondary");
- }
- break;
- case WINED3DSPR_CONST:
- if(This->baseShader.load_local_constsF || list_empty(&This->baseShader.constantsF)) {
- sprintf(regstr, "C[%u]", reg);
- } else {
- sprintf(regstr, "C%u", reg);
- }
- break;
- case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
- sprintf(regstr,"T%u", reg);
- break;
- case WINED3DSPR_COLOROUT:
- if (reg == 0)
- sprintf(regstr, "TMP_COLOR");
- else {
- /* TODO: See GL_ARB_draw_buffers */
- FIXME("Unsupported write to render target %u\n", reg);
- sprintf(regstr, "unsupported_register");
- }
- break;
- case WINED3DSPR_DEPTHOUT:
- sprintf(regstr, "result.depth");
- break;
- case WINED3DSPR_ATTROUT:
- sprintf(regstr, "oD[%u]", reg);
- break;
- case WINED3DSPR_TEXCRDOUT:
- sprintf(regstr, "oT[%u]", reg);
- break;
- default:
- FIXME("Unhandled register name Type(%d)\n", regtype);
- sprintf(regstr, "unrecognized_register");
- break;
+ switch (register_type)
+ {
+ case WINED3DSPR_TEMP:
+ sprintf(register_name, "R%u", register_idx);
+ break;
+
+ case WINED3DSPR_INPUT:
+ if (pshader)
+ {
+ if (register_idx == 0) strcpy(register_name, "fragment.color.primary");
+ else strcpy(register_name, "fragment.color.secondary");
+ }
+ else
+ {
+ if (((IWineD3DVertexShaderImpl *)This)->cur_args->swizzle_map & (1 << register_idx)) *is_color = TRUE;
+ sprintf(register_name, "vertex.attrib[%u]", register_idx);
+ }
+ break;
+
+ case WINED3DSPR_CONST:
+ if (!pshader && rel_addr)
+ {
+ UINT rel_offset = ((IWineD3DVertexShaderImpl *)This)->rel_offset;
+ if (register_idx >= rel_offset)
+ sprintf(register_name, "C[A0.x + %u]", register_idx - rel_offset);
+ else
+ sprintf(register_name, "C[A0.x - %u]", -register_idx + rel_offset);
+ }
+ else
+ {
+ if (This->baseShader.load_local_constsF || list_empty(&This->baseShader.constantsF))
+ sprintf(register_name, "C[%u]", register_idx);
+ else
+ sprintf(register_name, "C%u", register_idx);
+ }
+ break;
+
+ case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
+ if (pshader) sprintf(register_name, "T%u", register_idx);
+ else sprintf(register_name, "A%u", register_idx);
+ break;
+
+ case WINED3DSPR_COLOROUT:
+ if (register_idx == 0)
+ {
+ strcpy(register_name, "TMP_COLOR");
+ }
+ else
+ {
+ /* TODO: See GL_ARB_draw_buffers */
+ FIXME("Unsupported write to render target %u\n", register_idx);
+ sprintf(register_name, "unsupported_register");
+ }
+ break;
+
+ case WINED3DSPR_RASTOUT:
+ sprintf(register_name, "%s", rastout_reg_names[register_idx]);
+ break;
+
+ case WINED3DSPR_DEPTHOUT:
+ strcpy(register_name, "result.depth");
+ break;
+
+ case WINED3DSPR_ATTROUT:
+ if (pshader) sprintf(register_name, "oD[%u]", register_idx);
+ else if (register_idx == 0) strcpy(register_name, "result.color.primary");
+ else strcpy(register_name, "result.color.secondary");
+ break;
+
+ case WINED3DSPR_TEXCRDOUT:
+ if (pshader) sprintf(register_name, "oT[%u]", register_idx);
+ else sprintf(register_name, "result.texcoord[%u]", register_idx);
+ break;
+
+ default:
+ FIXME("Unhandled register type %#x[%u]\n", register_type, register_idx);
+ sprintf(register_name, "unrecognized_register[%u]", register_idx);
+ break;
}
}
-/* TODO: merge with pixel shader */
-static void vshader_program_add_param(const struct wined3d_shader_instruction *ins,
- const DWORD param, BOOL is_input, char *hwLine)
+static void shader_arb_add_src_param(const struct wined3d_shader_instruction *ins,
+ DWORD param, char *str)
{
- IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)ins->shader;
+ char register_name[255];
+ char swizzle[6];
+ BOOL is_color;
- /* oPos, oFog and oPts in D3D */
- static const char * const hwrastout_reg_names[] = { "TMP_OUT", "result.fogcoord", "result.pointsize" };
+ if ((param & WINED3DSP_SRCMOD_MASK) == WINED3DSPSM_NEG) strcat(str, " -");
+ else strcat(str, " ");
- DWORD reg = param & WINED3DSP_REGNUM_MASK;
- DWORD regtype = shader_get_regtype(param);
- char tmpReg[255];
- BOOL is_color = FALSE;
+ shader_arb_get_register_name(ins->shader, shader_get_regtype(param), param & WINED3DSP_REGNUM_MASK,
+ param & WINED3DSHADER_ADDRMODE_RELATIVE, register_name, &is_color);
+ strcat(str, register_name);
- if ((param & WINED3DSP_SRCMOD_MASK) == WINED3DSPSM_NEG) {
- strcat(hwLine, " -");
- } else {
- strcat(hwLine, " ");
- }
-
- switch (regtype) {
- case WINED3DSPR_TEMP:
- sprintf(tmpReg, "R%u", reg);
- strcat(hwLine, tmpReg);
- break;
- case WINED3DSPR_INPUT:
-
- if (This->cur_args->swizzle_map & (1 << reg)) is_color = TRUE;
-
- sprintf(tmpReg, "vertex.attrib[%u]", reg);
- strcat(hwLine, tmpReg);
- break;
- case WINED3DSPR_CONST:
- if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
- if(reg >= This->rel_offset) {
- sprintf(tmpReg, "C[A0.x + %u]", reg - This->rel_offset);
- } else {
- sprintf(tmpReg, "C[A0.x - %u]", -reg + This->rel_offset);
- }
- } else {
- if(This->baseShader.load_local_constsF || list_empty(&This->baseShader.constantsF)) {
- sprintf(tmpReg, "C[%u]", reg);
- } else {
- sprintf(tmpReg, "C%u", reg);
- }
- }
- strcat(hwLine, tmpReg);
- break;
- case WINED3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
- sprintf(tmpReg, "A%u", reg);
- strcat(hwLine, tmpReg);
- break;
- case WINED3DSPR_RASTOUT:
- sprintf(tmpReg, "%s", hwrastout_reg_names[reg]);
- strcat(hwLine, tmpReg);
- break;
- case WINED3DSPR_ATTROUT:
- if (reg==0) {
- strcat(hwLine, "result.color.primary");
- } else {
- strcat(hwLine, "result.color.secondary");
- }
- break;
- case WINED3DSPR_TEXCRDOUT:
- sprintf(tmpReg, "result.texcoord[%u]", reg);
- strcat(hwLine, tmpReg);
- break;
- default:
- FIXME("Unknown reg type %d %d\n", regtype, reg);
- strcat(hwLine, "unrecognized_register");
- break;
- }
+ shader_arb_get_swizzle(param, is_color, swizzle);
+ strcat(str, swizzle);
+}
- if (!is_input) {
+static void shader_arb_add_dst_param(const struct wined3d_shader_instruction *ins,
+ const struct wined3d_shader_dst_param *wined3d_dst, char *str)
+{
+ char register_name[255];
char write_mask[6];
- shader_arb_get_write_mask(ins, param, write_mask);
- strcat(hwLine, write_mask);
- } else {
- char swizzle[6];
- shader_arb_get_swizzle(param, is_color, swizzle);
- strcat(hwLine, swizzle);
- }
+ BOOL is_color;
+
+ strcat(str, " ");
+
+ shader_arb_get_register_name(ins->shader, wined3d_dst->register_type,
+ wined3d_dst->register_idx, wined3d_dst->has_rel_addr, register_name, &is_color);
+ strcat(str, register_name);
+
+ shader_arb_get_write_mask(ins, wined3d_dst, write_mask);
+ strcat(str, write_mask);
}
static const char *shader_arb_get_fixup_swizzle(enum fixup_channel_source channel_source)
} else {
tex_type = "2D";
}
+ if(shader_is_pshader_version(ins->reg_maps->shader_version)) {
+ const IWineD3DPixelShaderImpl* const ps = (const IWineD3DPixelShaderImpl*)This;
+ if(ps->cur_args->np2_fixup & (1 << sampler_idx)) {
+ FIXME("NP2 texcoord fixup is currently not implemented in ARB mode (use GLSL instead).\n");
+ }
+ }
break;
case WINED3DSTT_VOLUME:
if (shader_is_pshader_version(ins->reg_maps->shader_version))
{
IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *)ins->shader;
- gen_color_correction(buffer, dst_str, ins->dst[0].token & WINED3DSP_WRITEMASK_ALL,
+ gen_color_correction(buffer, dst_str, ins->dst[0].write_mask,
"one", "coefmul.x", ps->cur_args->color_fixup[sampler_idx]);
}
}
char *outregstr) {
/* Generate a line that does the input modifier computation and return the input register to use */
+ BOOL is_color = FALSE;
char regstr[256];
char swzstr[20];
int insert_line;
insert_line = 1;
/* Get register name */
- pshader_get_register_name(iface, instr, regstr);
- shader_arb_get_swizzle(instr, FALSE, swzstr);
+ shader_arb_get_register_name(iface, shader_get_regtype(instr), instr & WINED3DSP_REGNUM_MASK,
+ instr & WINED3DSHADER_ADDRMODE_RELATIVE, regstr, &is_color);
+ shader_arb_get_swizzle(instr, is_color, swzstr);
switch (instr & WINED3DSP_SRCMOD_MASK) {
case WINED3DSPSM_NONE:
static void pshader_hw_bem(const struct wined3d_shader_instruction *ins)
{
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
char src_name[2][50];
char dst_wmask[20];
- DWORD sampler_code = ins->dst[0].register_idx;
+ DWORD sampler_code = dst->register_idx;
BOOL has_bumpmat = FALSE;
+ BOOL is_color;
int i;
for(i = 0; i < This->numbumpenvmatconsts; i++) {
}
}
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_name);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_wmask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_name, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_wmask);
strcat(dst_name, dst_wmask);
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
static void pshader_hw_cnd(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_wmask[20];
char dst_name[50];
char src_name[3][50];
- BOOL sat = (ins->dst[0].token & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
- DWORD shift = (ins->dst[0].token & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ BOOL sat = dst->modifiers & WINED3DSPDM_SATURATE;
+ DWORD shift = dst->shift;
+ BOOL is_color;
/* FIXME: support output modifiers */
/* Handle output register */
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_name);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_wmask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_name, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_wmask);
/* Generate input register names (with modifiers) */
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
static void pshader_hw_cmp(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_wmask[20];
char dst_name[50];
char src_name[3][50];
- DWORD shift = (ins->dst[0].token & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (ins->dst[0].token & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = dst->shift;
+ BOOL sat = dst->modifiers & WINED3DSPDM_SATURATE;
+ BOOL is_color;
/* FIXME: support output modifiers */
/* Handle output register */
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_name);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_wmask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_name, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_wmask);
/* Generate input register names (with modifiers) */
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
* dst = dot2(src0, src1) + src2 */
static void pshader_hw_dp2add(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_wmask[20];
char dst_name[50];
char src_name[3][50];
- DWORD shift = (ins->dst[0].token & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (ins->dst[0].token & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = dst->shift;
+ BOOL sat = dst->modifiers & WINED3DSPDM_SATURATE;
+ BOOL is_color;
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_name);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_wmask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_name, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_wmask);
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[1], 1, src_name[1]);
static void shader_hw_map2gl(const struct wined3d_shader_instruction *ins)
{
SHADER_BUFFER *buffer = ins->buffer;
- DWORD dst = ins->dst[0].token;
const DWORD *src = ins->src;
const char *instruction;
char arguments[256];
if (shader_is_pshader_version(ins->reg_maps->shader_version))
{
/* Output token related */
+ const struct wined3d_shader_dst_param *dst;
char output_rname[256];
char output_wmask[20];
char operands[4][100];
BOOL centroid = FALSE;
BOOL partialprecision = FALSE;
const char *modifier;
+ BOOL is_color;
DWORD shift;
if (!(ins->dst_count + ins->src_count))
ERR("Opcode \"%#x\" has no parameters\n", ins->handler_idx);
return;
}
+ dst = &ins->dst[0];
/* Process modifiers */
- if (dst & WINED3DSP_DSTMOD_MASK)
+ if (dst->modifiers)
{
- DWORD mask = dst & WINED3DSP_DSTMOD_MASK;
+ DWORD mask = dst->modifiers;
saturate = mask & WINED3DSPDM_SATURATE;
centroid = mask & WINED3DSPDM_MSAMPCENTROID;
if (centroid)
FIXME("Unhandled modifier(%#x)\n", mask >> WINED3DSP_DSTMOD_SHIFT);
}
- shift = (dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ shift = dst->shift;
modifier = (saturate && !shift) ? "_SAT" : "";
/* Generate input register names (with modifiers) */
}
/* Handle output register */
- pshader_get_register_name(ins->shader, dst, output_rname);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, output_rname, &is_color);
strcpy(operands[0], output_rname);
shader_arb_get_write_mask(ins, dst, output_wmask);
strcat(operands[0], output_wmask);
/* A shift requires another line. */
if (shift) pshader_gen_output_modifier_line(buffer, saturate, output_wmask, shift, output_rname);
} else {
- /* Note that vshader_program_add_param() adds spaces. */
+ /* Note that shader_arb_add_*_param() adds spaces. */
arguments[0] = '\0';
if (ins->dst_count)
{
- vshader_program_add_param(ins, dst, FALSE, arguments);
+ shader_arb_add_dst_param(ins, &ins->dst[0], arguments);
for (i = 0; i < ins->src_count; ++i)
{
strcat(arguments, ",");
- vshader_program_add_param(ins, src[i], TRUE, arguments);
+ shader_arb_add_src_param(ins, src[i], arguments);
}
}
shader_addline(buffer, "%s%s;\n", instruction, arguments);
if ((WINED3DSHADER_VERSION_MAJOR(ins->reg_maps->shader_version) == 1
&& !shader_is_pshader_version(ins->reg_maps->shader_version)
- && shader_get_regtype(ins->dst[0].token) == WINED3DSPR_ADDR)
+ && ins->dst[0].register_type == WINED3DSPR_ADDR)
|| ins->handler_idx == WINED3DSIH_MOVA)
{
SHADER_BUFFER *buffer = ins->buffer;
src0_param[0] = '\0';
if (((IWineD3DVertexShaderImpl *)shader)->rel_offset)
{
- vshader_program_add_param(ins, ins->src[0], TRUE, src0_param);
+ shader_arb_add_src_param(ins, ins->src[0], src0_param);
shader_addline(buffer, "ADD TMP.x, %s, helper_const.z;\n", src0_param);
shader_addline(buffer, "ARL A0.x, TMP.x;\n");
}
parm |= WINED3DVS_X_Y | WINED3DVS_Y_Y | WINED3DVS_Z_Y | WINED3DVS_W_Y;
else if((ins->src[0] & WINED3DVS_X_X) == WINED3DVS_X_X)
parm |= WINED3DVS_X_X | WINED3DVS_Y_X | WINED3DVS_Z_X | WINED3DVS_W_X;
- vshader_program_add_param(ins, parm, TRUE, src0_param);
+ shader_arb_add_src_param(ins, parm, src0_param);
shader_addline(buffer, "ARL A0.x, %s;\n", src0_param);
}
}
static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
DWORD shader_version = ins->reg_maps->shader_version;
SHADER_BUFFER *buffer = ins->buffer;
char reg_dest[40];
+ BOOL is_color;
/* No swizzles are allowed in d3d's texkill. PS 1.x ignores the 4th component as documented,
* but >= 2.0 honors it(undocumented, but tested by the d3d9 testsuit)
*/
- pshader_get_register_name(ins->shader, ins->dst[0].token, reg_dest);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, reg_dest, &is_color);
if (shader_version >= WINED3DPS_VERSION(2,0))
{
{
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
+ BOOL is_color;
- DWORD dst = ins->dst[0].token;
const DWORD *src = ins->src;
SHADER_BUFFER* buffer = ins->buffer;
DWORD shader_version = ins->reg_maps->shader_version;
char reg_dest[40];
char reg_coord[40];
- DWORD reg_dest_code;
DWORD reg_sampler_code;
/* All versions have a destination register */
- reg_dest_code = ins->dst[0].register_idx;
- pshader_get_register_name(ins->shader, dst, reg_dest);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, reg_dest, &is_color);
/* 1.0-1.3: Use destination register as coordinate source.
1.4+: Use provided coordinate source register. */
/* 1.0-1.4: Use destination register number as texture code.
2.0+: Use provided sampler number as texure code. */
if (shader_version < WINED3DPS_VERSION(2,0))
- reg_sampler_code = reg_dest_code;
+ reg_sampler_code = dst->register_idx;
else
reg_sampler_code = src[1] & WINED3DSP_REGNUM_MASK;
static void pshader_hw_texcoord(const struct wined3d_shader_instruction *ins)
{
- DWORD dst = ins->dst[0].token;
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char tmp[20];
shader_arb_get_write_mask(ins, dst, tmp);
if (ins->reg_maps->shader_version != WINED3DPS_VERSION(1,4))
{
- DWORD reg = ins->dst[0].register_idx;
+ DWORD reg = dst->register_idx;
shader_addline(buffer, "MOV_SAT T%u%s, fragment.texcoord[%u];\n", reg, tmp, reg);
} else {
- DWORD reg1 = ins->dst[0].register_idx;
char reg_src[40];
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, reg_src);
- shader_addline(buffer, "MOV R%u%s, %s;\n", reg1, tmp, reg_src);
+ shader_addline(buffer, "MOV R%u%s, %s;\n", dst->register_idx, tmp, reg_src);
}
}
static void pshader_hw_texbem(const struct wined3d_shader_instruction *ins)
{
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
BOOL has_bumpmat = FALSE;
BOOL has_luminance = FALSE;
+ BOOL is_color;
int i;
- DWORD dst = ins->dst[0].token;
DWORD src = ins->src[0] & WINED3DSP_REGNUM_MASK;
SHADER_BUFFER* buffer = ins->buffer;
DWORD reg_dest_code;
/* All versions have a destination register */
- reg_dest_code = ins->dst[0].register_idx;
+ reg_dest_code = dst->register_idx;
/* Can directly use the name because texbem is only valid for <= 1.3 shaders */
- pshader_get_register_name(ins->shader, dst, reg_coord);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, reg_coord, &is_color);
for(i = 0; i < This->numbumpenvmatconsts; i++) {
if (This->bumpenvmatconst[i].const_num != WINED3D_CONST_NUM_UNUSED
static void pshader_hw_texdepth(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
+ BOOL is_color;
/* texdepth has an implicit destination, the fragment depth value. It's only parameter,
* which is essentially an input, is the destination register because it is the first
* parameter. According to the msdn, this must be register r5, but let's keep it more flexible
* here
*/
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_name);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_name, &is_color);
/* According to the msdn, the source register(must be r5) is unusable after
* the texdepth instruction, so we're free to modify it
* Take a 3-component dot product of the TexCoord[dstreg] and src. */
static void pshader_hw_texdp3(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
char src0[50];
char dst_str[50];
char dst_mask[6];
- DWORD dstreg = ins->dst[0].register_idx;
SHADER_BUFFER *buffer = ins->buffer;
+ BOOL is_color;
/* Handle output register */
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_str);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_mask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_str, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_mask);
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0);
- shader_addline(buffer, "DP3 %s%s, T%u, %s;\n", dst_str, dst_mask, dstreg, src0);
+ shader_addline(buffer, "DP3 %s%s, T%u, %s;\n", dst_str, dst_mask, dst->register_idx, src0);
/* TODO: Handle output modifiers */
}
* Perform the 3rd row of a 3x3 matrix multiply */
static void pshader_hw_texm3x3(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_str[50];
char dst_mask[6];
char src0[50];
- DWORD dst_reg = ins->dst[0].register_idx;
+ BOOL is_color;
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_str);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_mask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_str, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_mask);
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0);
- shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", dst_reg, src0);
+ shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", dst->register_idx, src0);
shader_addline(buffer, "MOV %s%s, TMP;\n", dst_str, dst_mask);
/* TODO: Handle output modifiers */
break;
}
+ tmp_dst = ins->dst[0];
for (i = 0; i < nComponents; i++) {
- tmp_dst.register_idx = ins->dst[0].register_idx;
- tmp_dst.token = ((ins->dst[0].token) & ~WINED3DSP_WRITEMASK_ALL) | (WINED3DSP_WRITEMASK_0 << i);
+ tmp_dst.write_mask = WINED3DSP_WRITEMASK_0 << i;
tmp_ins.src[1] = ins->src[1]+i;
shader_hw_map2gl(&tmp_ins);
}
static void vshader_hw_rsq_rcp(const struct wined3d_shader_instruction *ins)
{
SHADER_BUFFER *buffer = ins->buffer;
- DWORD dst = ins->dst[0].token;
DWORD src = ins->src[0];
DWORD swizzle = (src & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
const char *instruction;
}
strcpy(tmpLine, instruction);
- vshader_program_add_param(ins, dst, FALSE, tmpLine); /* Destination */
+ shader_arb_add_dst_param(ins, &ins->dst[0], tmpLine); /* Destination */
strcat(tmpLine, ",");
- vshader_program_add_param(ins, src, TRUE, tmpLine);
+ shader_arb_add_src_param(ins, src, tmpLine);
if ((WINED3DSP_NOSWIZZLE >> WINED3DSP_SWIZZLE_SHIFT) == swizzle) {
/* Dx sdk says .x is used if no swizzle is given, but our test shows that
* .w is used
static void shader_hw_nrm(const struct wined3d_shader_instruction *ins)
{
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
char src_name[50];
char dst_wmask[20];
- DWORD shift = (ins->dst[0].token & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (ins->dst[0].token & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = dst->shift;
+ BOOL sat = dst->modifiers & WINED3DSPDM_SATURATE;
+ BOOL is_color;
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_name);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_wmask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_name, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_wmask);
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name);
shader_addline(buffer, "DP3 TMP, %s, %s;\n", src_name, src_name);
* must contain fixed constants. So we need a separate function to filter those constants and
* can't use map2gl
*/
+ const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
char src_name[50];
char dst_wmask[20];
- DWORD shift = (ins->dst[0].token & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (ins->dst[0].token & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = dst->shift;
+ BOOL sat = dst->modifiers & WINED3DSPDM_SATURATE;
+ BOOL is_color;
- pshader_get_register_name(ins->shader, ins->dst[0].token, dst_name);
- shader_arb_get_write_mask(ins, ins->dst[0].token, dst_wmask);
+ shader_arb_get_register_name(ins->shader, dst->register_type,
+ dst->register_idx, dst->has_rel_addr, dst_name, &is_color);
+ shader_arb_get_write_mask(ins, dst, dst_wmask);
pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name);
shader_addline(buffer, "SCS%s %s%s, %s;\n", sat ? "_SAT" : "", dst_name, dst_wmask,
if(GL_SUPPORT(ARB_VERTEX_PROGRAM)) {
pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
TRACE_(d3d_caps)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
- pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
+ pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF) - ARB_SHADER_RESERVED_VS_CONSTS;
}
if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
pCaps->PixelShaderVersion = WINED3DPS_VERSION(1,4);
pCaps->PixelShader1xMaxValue = 8.0;
TRACE_(d3d_caps)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
+ pCaps->MaxPixelShaderConst = GL_LIMITS(pshader_constantsF) - ARB_SHADER_RESERVED_PS_CONSTS;
}
}
shader_arb_update_float_vertex_constants,
shader_arb_update_float_pixel_constants,
shader_arb_load_constants,
+ shader_arb_load_np2fixup_constants,
shader_arb_destroy,
shader_arb_alloc,
shader_arb_free,
list_init(clist);
}
+static void shader_parse_dst_param(DWORD param, DWORD addr_param, struct wined3d_shader_dst_param *dst)
+{
+ dst->register_type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
+ | ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
+ dst->register_idx = param & WINED3DSP_REGNUM_MASK;
+ dst->write_mask = param & WINED3DSP_WRITEMASK_ALL;
+ dst->modifiers = param & WINED3DSP_DSTMOD_MASK;
+ dst->shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ dst->has_rel_addr = param & WINED3DSHADER_ADDRMODE_RELATIVE;
+ dst->addr_token = addr_param;
+}
+
/* Note that this does not count the loop register
* as an address register. */
HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, struct shader_reg_maps *reg_maps,
- struct semantic *semantics_in, struct semantic *semantics_out, const DWORD *byte_code)
+ struct wined3d_shader_semantic *semantics_in, struct wined3d_shader_semantic *semantics_out,
+ const DWORD *byte_code)
{
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
else
reg_maps->packed_input[regnum] = 1;
- semantics_in[regnum].usage = usage;
- semantics_in[regnum].reg = param;
+ semantics_in[regnum].usage = (usage & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
+ semantics_in[regnum].usage_idx =
+ (usage & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
+ shader_parse_dst_param(param, 0, &semantics_in[regnum].reg);
/* Vshader: mark 3.0 output registers used, save token */
} else if (WINED3DSPR_OUTPUT == regtype) {
reg_maps->packed_output[regnum] = 1;
- semantics_out[regnum].usage = usage;
- semantics_out[regnum].reg = param;
+ semantics_out[regnum].usage = (usage & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
+ semantics_out[regnum].usage_idx =
+ (usage & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
+ shader_parse_dst_param(param, 0, &semantics_out[regnum].reg);
+
if (usage & (WINED3DDECLUSAGE_FOG << WINED3DSP_DCL_USAGE_SHIFT))
reg_maps->fog = 1;
ins.dst_count = curOpcode->dst_token ? 1 : 0;
if (ins.dst_count)
{
- dst_param.addr_token = 0;
- pToken += shader_get_param(pToken, shader_version, &dst_param.token, &dst_param.addr_token);
- dst_param.register_idx = dst_param.token & WINED3DSP_REGNUM_MASK;
+ DWORD param, addr_param = 0;
+ pToken += shader_get_param(pToken, shader_version, ¶m, &addr_param);
+ shader_parse_dst_param(param, addr_param, &dst_param);
}
/* Predication token */
static void shader_none_update_float_vertex_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
static void shader_none_update_float_pixel_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
+static void shader_none_load_np2fixup_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
static void shader_none_destroy(IWineD3DBaseShader *iface) {}
static HRESULT shader_none_alloc(IWineD3DDevice *iface) {return WINED3D_OK;}
static void shader_none_free(IWineD3DDevice *iface) {}
shader_none_update_float_vertex_constants,
shader_none_update_float_pixel_constants,
shader_none_load_constants,
+ shader_none_load_np2fixup_constants,
shader_none_destroy,
shader_none_alloc,
shader_none_free,
while (glGetError() != GL_NO_ERROR);
/* Basically the FVF parameter passed to CreateVertexBuffer is no good
- * It is the FVF set with IWineD3DDevice::SetFVF or the Vertex Declaration set with
- * IWineD3DDevice::SetVertexDeclaration that decides how the vertices in the buffer
- * look like. This means that on each DrawPrimitive call the vertex buffer has to be verified
- * to check if the rhw and color values are in the correct format.
- */
+ * It is the FVF set with IWineD3DDevice::SetFVF or the Vertex Declaration set with
+ * IWineD3DDevice::SetVertexDeclaration that decides how the vertices in the buffer
+ * look like. This means that on each DrawPrimitive call the vertex buffer has to be verified
+ * to check if the rhw and color values are in the correct format.
+ */
GL_EXTCALL(glGenBuffersARB(1, &This->buffer_object));
error = glGetError();
goto fail;
}
- GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, This->buffer_object));
+ if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
+ {
+ IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
+ }
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
error = glGetError();
if (error != GL_NO_ERROR)
{
}
/* Reserve memory for the buffer. The amount of data won't change
- * so we are safe with calling glBufferData once with a NULL ptr and
- * calling glBufferSubData on updates
- */
- GL_EXTCALL(glBufferDataARB(GL_ARRAY_BUFFER_ARB, This->resource.size, NULL, gl_usage));
+ * so we are safe with calling glBufferData once and
+ * calling glBufferSubData on updates. Upload the actual data in case
+ * we're not double buffering, so we can release the heap mem afterwards
+ */
+ GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, This->resource.size, This->resource.allocatedMemory, gl_usage));
error = glGetError();
if (error != GL_NO_ERROR)
{
This->buffer_object_usage = gl_usage;
This->dirty_start = 0;
This->dirty_end = This->resource.size;
- This->flags |= WINED3D_BUFFER_DIRTY;
+
+ if(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)
+ {
+ This->flags |= WINED3D_BUFFER_DIRTY;
+ }
+ else
+ {
+ HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
+ This->resource.allocatedMemory = NULL;
+ This->resource.heapMemory = NULL;
+ This->flags &= ~WINED3D_BUFFER_DIRTY;
+ }
return;
unsigned int i;
/* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer.
- * Once we have our declaration there is no need to look it up again.
+ * Once we have our declaration there is no need to look it up again. Index buffers also never need
+ * conversion, so once the (empty) conversion structure is created don't bother checking again
*/
- if (((IWineD3DImpl *)device->wineD3D)->dxVersion == 7 && This->flags & WINED3D_BUFFER_HASDESC) return FALSE;
+ if (This->flags & WINED3D_BUFFER_HASDESC)
+ {
+ if(((IWineD3DImpl *)device->wineD3D)->dxVersion == 7 ||
+ This->resource.format_desc->format != WINED3DFMT_VERTEXDATA) return FALSE;
+ }
TRACE("Finding vertex buffer conversion information\n");
/* Certain declaration types need some fixups before we can pass them to
* processing, FLOAT4 POSITIONT with fixed function, and FLOAT16 if
* GL_NV_half_float is not supported.
*
+ * Note for d3d8 and d3d9:
* The vertex buffer FVF doesn't help with finding them, we have to use
* the decoded vertex declaration and pick the things that concern the
* current buffer. A problem with this is that this can change between
* draws, so we have to validate the information and reprocess the buffer
* if it changes, and avoid false positives for performance reasons.
+ * WineD3D doesn't even know the vertex buffer any more, it is managed
+ * by the client libraries and passed to SetStreamSource and ProcessVertices
+ * as needed.
*
* We have to distinguish between vertex shaders and fixed function to
* pick the way we access the strided vertex information.
if (This->buffer_object_size != size)
{
TRACE("Old size %u, creating new size %u\n", This->buffer_object_size, size);
+
+ if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
+ {
+ IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
+ }
+
+ /* Rescue the data before resizing the buffer object if we do not have our backup copy */
+ if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
+ {
+ buffer_get_sysmem(This);
+ }
+
ENTER_GL();
- GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, This->buffer_object));
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
checkGLcall("glBindBufferARB");
- GL_EXTCALL(glBufferDataARB(GL_ARRAY_BUFFER_ARB, size, NULL, This->buffer_object_usage));
+ GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, size, NULL, This->buffer_object_usage));
This->buffer_object_size = size;
checkGLcall("glBufferDataARB");
LEAVE_GL();
return refcount;
}
+const BYTE *buffer_get_sysmem(struct wined3d_buffer *This)
+{
+ if(This->flags & WINED3D_BUFFER_DOUBLEBUFFER) return This->resource.allocatedMemory;
+
+ This->resource.heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->resource.size + RESOURCE_ALIGNMENT);
+ This->resource.allocatedMemory = (BYTE *)(((ULONG_PTR)This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
+ ENTER_GL();
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
+ GL_EXTCALL(glGetBufferSubDataARB(This->buffer_type_hint, 0, This->resource.size, This->resource.allocatedMemory));
+ LEAVE_GL();
+ This->flags |= WINED3D_BUFFER_DOUBLEBUFFER;
+
+ return This->resource.allocatedMemory;
+}
+
static void STDMETHODCALLTYPE buffer_UnLoad(IWineD3DBuffer *iface)
{
struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
TRACE("iface %p\n", iface);
- /* This is easy: The whole content is shadowed in This->resource.allocatedMemory,
- * so we only have to destroy the vbo. Only do it if we have a vbo, which implies
- * that vbos are supported
- */
if (This->buffer_object)
{
IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
+
+ /* Download the buffer, but don't permanently enable double buffering */
+ if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
+ {
+ buffer_get_sysmem(This);
+ This->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER;
+ }
+
ENTER_GL();
GL_EXTCALL(glDeleteBuffersARB(1, &This->buffer_object));
checkGLcall("glDeleteBuffersARB");
This->dirty_start = 0;
This->dirty_end = 0;
+ if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
+ {
+ IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
+ }
+
if (!This->conversion_map)
{
/* That means that there is nothing to fixup. Just upload from This->resource.allocatedMemory
*/
TRACE("No conversion needed\n");
+ /* Nothing to do because we locked directly into the vbo */
+ if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)) return;
+
if (!device->isInDraw)
{
ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
}
ENTER_GL();
- GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, This->buffer_object));
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
checkGLcall("glBindBufferARB");
- GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, start, end-start, This->resource.allocatedMemory + start));
+ GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, start, end-start, This->resource.allocatedMemory + start));
checkGLcall("glBufferSubDataARB");
LEAVE_GL();
return;
}
+ if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
+ {
+ buffer_get_sysmem(This);
+ }
+
/* Now for each vertex in the buffer that needs conversion */
vertices = This->resource.size / This->stride;
}
ENTER_GL();
- GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, This->buffer_object));
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
checkGLcall("glBindBufferARB");
- GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, vertices * This->conversion_stride, data));
+ GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, 0, vertices * This->conversion_stride, data));
checkGLcall("glBufferSubDataARB");
LEAVE_GL();
}
}
ENTER_GL();
- GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, This->buffer_object));
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
checkGLcall("glBindBufferARB");
- GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, start, end - start, data + start));
+ GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, start, end - start, data + start));
checkGLcall("glBufferSubDataARB");
LEAVE_GL();
}
static HRESULT STDMETHODCALLTYPE buffer_Map(IWineD3DBuffer *iface, UINT offset, UINT size, BYTE **data, DWORD flags)
{
struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
+ LONG count;
TRACE("iface %p, offset %u, size %u, data %p, flags %#x\n", iface, offset, size, data, flags);
- InterlockedIncrement(&This->lock_count);
+ count = InterlockedIncrement(&This->lock_count);
if (This->flags & WINED3D_BUFFER_DIRTY)
{
else This->dirty_end = This->resource.size;
}
- This->flags |= WINED3D_BUFFER_DIRTY;
+ if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER) && This->buffer_object)
+ {
+ if(count == 1)
+ {
+ if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
+ {
+ IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
+ }
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
+ This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(This->buffer_type_hint, GL_READ_WRITE_ARB));
+ }
+ }
+ else
+ {
+ This->flags |= WINED3D_BUFFER_DIRTY;
+ }
*data = This->resource.allocatedMemory + offset;
return WINED3D_OK;
}
- if (This->flags & WINED3D_BUFFER_HASDESC)
+ if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER) && This->buffer_object)
+ {
+ if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
+ {
+ IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
+ }
+ GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
+ GL_EXTCALL(glUnmapBufferARB(This->buffer_type_hint));
+ This->resource.allocatedMemory = NULL;
+ }
+ else if (This->flags & WINED3D_BUFFER_HASDESC)
{
buffer_PreLoad(iface);
}
return WINED3D_OK;
}
-static HRESULT STDMETHODCALLTYPE buffer_GetDesc(IWineD3DBuffer *iface, WINED3DVERTEXBUFFER_DESC *desc)
+static HRESULT STDMETHODCALLTYPE buffer_GetDesc(IWineD3DBuffer *iface, WINED3DBUFFER_DESC *desc)
{
struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
TRACE("(%p)\n", This);
- desc->Format = This->resource.format_desc->format;
desc->Type = This->resource.resourceType;
desc->Usage = This->resource.usage;
desc->Pool = This->resource.pool;
desc->Size = This->resource.size;
- desc->FVF = This->fvf;
return WINED3D_OK;
}
buffer_Unmap,
buffer_GetDesc,
};
-
-/* IUnknown methods */
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_QueryInterface(IWineD3DIndexBuffer *iface,
- REFIID riid, void **object)
-{
- TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
-
- if (IsEqualGUID(riid, &IID_IWineD3DIndexBuffer)
- || IsEqualGUID(riid, &IID_IWineD3DResource)
- || IsEqualGUID(riid, &IID_IWineD3DBase)
- || IsEqualGUID(riid, &IID_IUnknown))
- {
- IUnknown_AddRef(iface);
- *object = iface;
- return S_OK;
- }
-
- WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
-
- *object = NULL;
-
- return E_NOINTERFACE;
-}
-
-static ULONG STDMETHODCALLTYPE IWineD3DIndexBufferImpl_AddRef(IWineD3DIndexBuffer *iface)
-{
- IWineD3DIndexBufferImpl *This = (IWineD3DIndexBufferImpl *)iface;
- ULONG refcount = InterlockedIncrement(&This->resource.ref);
-
- TRACE("%p increasing refcount to %u\n", This, refcount);
-
- return refcount;
-}
-
-static ULONG STDMETHODCALLTYPE IWineD3DIndexBufferImpl_Release(IWineD3DIndexBuffer *iface)
-{
- IWineD3DIndexBufferImpl *This = (IWineD3DIndexBufferImpl *)iface;
- ULONG refcount = InterlockedDecrement(&This->resource.ref);
-
- TRACE("%p decreasing refcount to %u\n", This, refcount);
-
- if (!refcount)
- {
- if (This->vbo)
- {
- IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
-
- ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
- ENTER_GL();
- /* No need to manually unset the buffer. glDeleteBuffers unsets it for the current context,
- * but not for other contexts. However, because the d3d buffer is destroyed the app has to
- * unset it before doing the next draw, thus dirtifying the index buffer state and forcing
- * binding a new buffer
- */
- GL_EXTCALL(glDeleteBuffersARB(1, &This->vbo));
- checkGLcall("glDeleteBuffersARB");
- LEAVE_GL();
- }
-
- resource_cleanup((IWineD3DResource *)iface);
- HeapFree(GetProcessHeap(), 0, This);
- }
-
- return refcount;
-}
-
-/* IWineD3DBase methods */
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_GetParent(IWineD3DIndexBuffer *iface, IUnknown **parent)
-{
- return resource_get_parent((IWineD3DResource *)iface, parent);
-}
-
-/* IWineD3DResource methods */
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_GetDevice(IWineD3DIndexBuffer *iface, IWineD3DDevice **device)
-{
- return resource_get_device((IWineD3DResource *)iface, device);
-}
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_SetPrivateData(IWineD3DIndexBuffer *iface,
- REFGUID guid, const void *data, DWORD data_size, DWORD flags)
-{
- return resource_set_private_data((IWineD3DResource *)iface, guid, data, data_size, flags);
-}
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_GetPrivateData(IWineD3DIndexBuffer *iface,
- REFGUID guid, void *data, DWORD *data_size)
-{
- return resource_get_private_data((IWineD3DResource *)iface, guid, data, data_size);
-}
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_FreePrivateData(IWineD3DIndexBuffer *iface, REFGUID guid)
-{
- return resource_free_private_data((IWineD3DResource *)iface, guid);
-}
-
-static DWORD STDMETHODCALLTYPE IWineD3DIndexBufferImpl_SetPriority(IWineD3DIndexBuffer *iface, DWORD priority)
-{
- return resource_set_priority((IWineD3DResource *)iface, priority);
-}
-
-static DWORD STDMETHODCALLTYPE IWineD3DIndexBufferImpl_GetPriority(IWineD3DIndexBuffer *iface)
-{
- return resource_get_priority((IWineD3DResource *)iface);
-}
-
-static void STDMETHODCALLTYPE IWineD3DIndexBufferImpl_PreLoad(IWineD3DIndexBuffer *iface)
-{
- TRACE("iface %p\n", iface);
-}
-
-static void STDMETHODCALLTYPE IWineD3DIndexBufferImpl_UnLoad(IWineD3DIndexBuffer *iface)
-{
- IWineD3DIndexBufferImpl *This = (IWineD3DIndexBufferImpl *) iface;
- IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
-
- TRACE("(%p)\n", This);
-
- /* This is easy: The whole content is shadowed in This->resource.allocatedMemory,
- * so we only have to destroy the vbo. Only do it if we have a vbo, which implies
- * that vbos are supported.
- * (TODO: Make a IWineD3DBuffer base class for index and vertex buffers and share
- * this code. Also needed for D3D10)
- */
- if (This->vbo)
- {
- ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
- ENTER_GL();
- GL_EXTCALL(glDeleteBuffersARB(1, &This->vbo));
- checkGLcall("glDeleteBuffersARB");
- LEAVE_GL();
- This->vbo = 0;
- }
-}
-
-static WINED3DRESOURCETYPE STDMETHODCALLTYPE IWineD3DIndexBufferImpl_GetType(IWineD3DIndexBuffer *iface)
-{
- return resource_get_type((IWineD3DResource *)iface);
-}
-
-/* IWineD3DIndexBuffer methods */
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_Lock(IWineD3DIndexBuffer *iface,
- UINT OffsetToLock, UINT SizeToLock, BYTE **ppbData, DWORD Flags)
-{
- IWineD3DIndexBufferImpl *This = (IWineD3DIndexBufferImpl *)iface;
-
- TRACE("(%p) : offset %d, size %d, Flags=%x\n", This, OffsetToLock, SizeToLock, Flags);
-
- InterlockedIncrement(&This->lockcount);
- *ppbData = This->resource.allocatedMemory + OffsetToLock;
-
- if (Flags & (WINED3DLOCK_READONLY | WINED3DLOCK_NO_DIRTY_UPDATE) || !This->vbo)
- {
- return WINED3D_OK;
- }
-
- if (This->dirtystart != This->dirtyend)
- {
- if (This->dirtystart > OffsetToLock) This->dirtystart = OffsetToLock;
- if (SizeToLock)
- {
- if (This->dirtyend < OffsetToLock + SizeToLock) This->dirtyend = OffsetToLock + SizeToLock;
- }
- else
- {
- This->dirtyend = This->resource.size;
- }
- }
- else
- {
- This->dirtystart = OffsetToLock;
- if (SizeToLock) This->dirtyend = OffsetToLock + SizeToLock;
- else This->dirtyend = This->resource.size;
- }
-
- return WINED3D_OK;
-}
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_Unlock(IWineD3DIndexBuffer *iface)
-{
- IWineD3DIndexBufferImpl *This = (IWineD3DIndexBufferImpl *)iface;
- ULONG locks = InterlockedDecrement(&This->lockcount);
-
- TRACE("(%p)\n", This);
-
- /* For now load in unlock */
- if (!locks && This->vbo && (This->dirtyend - This->dirtystart) > 0)
- {
- IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
-
- ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
-
- ENTER_GL();
- GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, This->vbo));
- checkGLcall("glBindBufferARB");
- GL_EXTCALL(glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, This->dirtystart,
- This->dirtyend - This->dirtystart, This->resource.allocatedMemory + This->dirtystart));
- checkGLcall("glBufferSubDataARB");
- LEAVE_GL();
- This->dirtystart = 0;
- This->dirtyend = 0;
- /* TODO: Move loading into preload when the buffer is used, that avoids dirtifying the state */
- IWineD3DDeviceImpl_MarkStateDirty(device, STATE_INDEXBUFFER);
- }
-
- return WINED3D_OK;
-}
-
-static HRESULT STDMETHODCALLTYPE IWineD3DIndexBufferImpl_GetDesc(IWineD3DIndexBuffer *iface,
- WINED3DINDEXBUFFER_DESC *pDesc)
-{
- IWineD3DIndexBufferImpl *This = (IWineD3DIndexBufferImpl *)iface;
-
- TRACE("(%p)\n", This);
-
- pDesc->Format = This->resource.format_desc->format;
- pDesc->Type = This->resource.resourceType;
- pDesc->Usage = This->resource.usage;
- pDesc->Pool = This->resource.pool;
- pDesc->Size = This->resource.size;
-
- return WINED3D_OK;
-}
-
-const IWineD3DIndexBufferVtbl IWineD3DIndexBuffer_Vtbl =
-{
- /* IUnknown methods */
- IWineD3DIndexBufferImpl_QueryInterface,
- IWineD3DIndexBufferImpl_AddRef,
- IWineD3DIndexBufferImpl_Release,
- /* IWineD3DBase methods */
- IWineD3DIndexBufferImpl_GetParent,
- /* IWineD3DResource methods */
- IWineD3DIndexBufferImpl_GetDevice,
- IWineD3DIndexBufferImpl_SetPrivateData,
- IWineD3DIndexBufferImpl_GetPrivateData,
- IWineD3DIndexBufferImpl_FreePrivateData,
- IWineD3DIndexBufferImpl_SetPriority,
- IWineD3DIndexBufferImpl_GetPriority,
- IWineD3DIndexBufferImpl_PreLoad,
- IWineD3DIndexBufferImpl_UnLoad,
- IWineD3DIndexBufferImpl_GetType,
- /* IWineD3DIndexBuffer methods */
- IWineD3DIndexBufferImpl_Lock,
- IWineD3DIndexBufferImpl_Unlock,
- IWineD3DIndexBufferImpl_GetDesc,
-};
for (i = 0; i < sizeof(stream_info->elements) / sizeof(*stream_info->elements); ++i)
{
+ if (!stream_info->elements[i].format_desc) continue;
+
if (!GL_SUPPORT(EXT_VERTEX_ARRAY_BGRA) && stream_info->elements[i].format_desc->format == WINED3DFMT_A8R8G8B8)
{
stream_info->swizzle_map |= 1 << i;
HeapFree(GetProcessHeap(), 0, object);
return hr;
}
+ object->buffer_type_hint = GL_ARRAY_BUFFER_ARB;
TRACE("Created resource %p\n", object);
}
object->vtbl = &wined3d_buffer_vtbl;
- hr = resource_init(&object->resource, WINED3DRTYPE_VERTEXBUFFER, This, Size, Usage, format_desc, Pool, parent);
+ hr = resource_init(&object->resource, WINED3DRTYPE_BUFFER, This, Size, Usage, format_desc, Pool, parent);
if (FAILED(hr))
{
WARN("Failed to initialize resource, returning %#x\n", hr);
*ppVertexBuffer = NULL;
return hr;
}
+ object->buffer_type_hint = GL_ARRAY_BUFFER_ARB;
TRACE("(%p) : Created resource %p\n", This, object);
TRACE("(%p) : Size=%d, Usage=0x%08x, FVF=%x, Pool=%d - Memory@%p, Iface@%p\n", This, Size, Usage, FVF, Pool, object->resource.allocatedMemory, object);
*ppVertexBuffer = (IWineD3DBuffer *)object;
- object->fvf = FVF;
-
/* Observations show that drawStridedSlow is faster on dynamic VBs than converting +
* drawStridedFast (half-life 2).
*
return WINED3D_OK;
}
-static void CreateIndexBufferVBO(IWineD3DDeviceImpl *This, IWineD3DIndexBufferImpl *object) {
- GLenum error, glUsage;
- TRACE("Creating VBO for Index Buffer %p\n", object);
-
- /* The following code will modify the ELEMENT_ARRAY_BUFFER binding, make sure it is
- * restored on the next draw
- */
- IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
-
- /* Make sure that a context is there. Needed in a multithreaded environment. Otherwise this call is a nop */
- ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
- ENTER_GL();
-
- while(glGetError());
-
- GL_EXTCALL(glGenBuffersARB(1, &object->vbo));
- error = glGetError();
- if(error != GL_NO_ERROR || object->vbo == 0) {
- ERR("Creating a vbo failed with error %s (%#x), continuing without vbo for this buffer\n", debug_glerror(error), error);
- goto out;
- }
-
- GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, object->vbo));
- error = glGetError();
- if(error != GL_NO_ERROR) {
- ERR("Failed to bind index buffer with error %s (%#x), continuing without vbo for this buffer\n", debug_glerror(error), error);
- goto out;
- }
-
- /* Use static write only usage for now. Dynamic index buffers stay in sysmem, and due to the sysmem
- * copy no readback will be needed
- */
- glUsage = GL_STATIC_DRAW_ARB;
- GL_EXTCALL(glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, object->resource.size, NULL, glUsage));
- error = glGetError();
- if(error != GL_NO_ERROR) {
- ERR("Failed to initialize the index buffer with error %s (%#x)\n", debug_glerror(error), error);
- goto out;
- }
- LEAVE_GL();
- TRACE("Successfully created vbo %d for index buffer %p\n", object->vbo, object);
- return;
-
-out:
- GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
- GL_EXTCALL(glDeleteBuffersARB(1, &object->vbo));
- LEAVE_GL();
- object->vbo = 0;
-}
-
-static HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage,
- WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DIndexBuffer** ppIndexBuffer,
+static HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage,
+ WINED3DPOOL Pool, IWineD3DBuffer** ppIndexBuffer,
HANDLE *sharedHandle, IUnknown *parent) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
- const struct GlPixelFormatDesc *format_desc = getFormatDescEntry(Format, &This->adapter->gl_info);
- IWineD3DIndexBufferImpl *object;
+ const struct GlPixelFormatDesc *format_desc = getFormatDescEntry(WINED3DFMT_UNKNOWN, &This->adapter->gl_info);
+ struct wined3d_buffer *object;
HRESULT hr;
TRACE("(%p) Creating index buffer\n", This);
return WINED3DERR_OUTOFVIDEOMEMORY;
}
- object->lpVtbl = &IWineD3DIndexBuffer_Vtbl;
- hr = resource_init(&object->resource, WINED3DRTYPE_INDEXBUFFER, This, Length, Usage, format_desc, Pool, parent);
+ object->vtbl = &wined3d_buffer_vtbl;
+ hr = resource_init(&object->resource, WINED3DRTYPE_BUFFER, This, Length, Usage, format_desc, Pool, parent);
if (FAILED(hr))
{
WARN("Failed to initialize resource, returning %#x\n", hr);
*ppIndexBuffer = NULL;
return hr;
}
+ object->buffer_type_hint = GL_ELEMENT_ARRAY_BUFFER_ARB;
TRACE("(%p) : Created resource %p\n", This, object);
IWineD3DDeviceImpl_AddResource(iface, (IWineD3DResource *)object);
if(Pool != WINED3DPOOL_SYSTEMMEM && !(Usage & WINED3DUSAGE_DYNAMIC) && GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
- CreateIndexBufferVBO(This, object);
+ object->flags |= WINED3D_BUFFER_CREATEBO;
}
- TRACE("(%p) : Len=%d, Use=%x, 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;
+ TRACE("(%p) : Len=%d, Use=%x, Pool=%d - Memory@%p, Iface@%p\n", This, Length, Usage,
+ Pool, object, object->resource.allocatedMemory);
+ *ppIndexBuffer = (IWineD3DBuffer *) object;
return WINED3D_OK;
}
}
}
if(object->pIndexData) {
- IWineD3DIndexBuffer_AddRef(object->pIndexData);
+ IWineD3DBuffer_AddRef(object->pIndexData);
}
if(object->vertexShader) {
IWineD3DVertexShader_AddRef(object->vertexShader);
/*****
* Get / Set Indices
*****/
-static HRESULT WINAPI IWineD3DDeviceImpl_SetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer* pIndexData) {
+static HRESULT WINAPI IWineD3DDeviceImpl_SetIndices(IWineD3DDevice *iface, IWineD3DBuffer* pIndexData, WINED3DFORMAT fmt) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
- IWineD3DIndexBuffer *oldIdxs;
+ IWineD3DBuffer *oldIdxs;
TRACE("(%p) : Setting to %p\n", This, pIndexData);
oldIdxs = This->updateStateBlock->pIndexData;
This->updateStateBlock->changed.indices = TRUE;
This->updateStateBlock->pIndexData = pIndexData;
+ This->updateStateBlock->IndexFmt = fmt;
/* Handle recording of state blocks */
if (This->isRecordingState) {
TRACE("Recording... not performing anything\n");
- if(pIndexData) IWineD3DIndexBuffer_AddRef(pIndexData);
- if(oldIdxs) IWineD3DIndexBuffer_Release(oldIdxs);
+ if(pIndexData) IWineD3DBuffer_AddRef(pIndexData);
+ if(oldIdxs) IWineD3DBuffer_Release(oldIdxs);
return WINED3D_OK;
}
if(oldIdxs != pIndexData) {
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
- if(pIndexData) IWineD3DIndexBuffer_AddRef(pIndexData);
- if(oldIdxs) IWineD3DIndexBuffer_Release(oldIdxs);
+ if(pIndexData) {
+ InterlockedIncrement(&((struct wined3d_buffer *)pIndexData)->bind_count);
+ IWineD3DBuffer_AddRef(pIndexData);
+ }
+ if(oldIdxs) {
+ InterlockedDecrement(&((struct wined3d_buffer *)oldIdxs)->bind_count);
+ IWineD3DBuffer_Release(oldIdxs);
+ }
}
+
return WINED3D_OK;
}
-static HRESULT WINAPI IWineD3DDeviceImpl_GetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer** ppIndexData) {
+static HRESULT WINAPI IWineD3DDeviceImpl_GetIndices(IWineD3DDevice *iface, IWineD3DBuffer** ppIndexData) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
*ppIndexData = This->stateBlock->pIndexData;
/* up ref count on ppindexdata */
if (*ppIndexData) {
- IWineD3DIndexBuffer_AddRef(*ppIndexData);
+ IWineD3DBuffer_AddRef(*ppIndexData);
TRACE("(%p) index data set to %p\n", This, ppIndexData);
}else{
TRACE("(%p) No index data set\n", This);
iface, srcData, start, count);
/* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
- if (srcData == NULL || start + count > GL_LIMITS(vshader_constantsF) || start > GL_LIMITS(vshader_constantsF))
+ if (srcData == NULL || start + count > This->d3d_vshader_constantF || start > This->d3d_vshader_constantF)
return WINED3DERR_INVALIDCALL;
memcpy(&This->updateStateBlock->vertexShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
- int cnt = min(count, GL_LIMITS(vshader_constantsF) - start);
+ int cnt = min(count, This->d3d_vshader_constantF - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
iface, srcData, start, count);
/* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
- if (srcData == NULL || start + count > GL_LIMITS(pshader_constantsF) || start > GL_LIMITS(pshader_constantsF))
+ if (srcData == NULL || start + count > This->d3d_pshader_constantF || start > This->d3d_pshader_constantF)
return WINED3DERR_INVALIDCALL;
memcpy(&This->updateStateBlock->pixelShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
UINT count) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
- int cnt = min(count, GL_LIMITS(pshader_constantsF) - start);
+ int cnt = min(count, This->d3d_pshader_constantF - start);
TRACE("(iface %p, dstData %p, start %d, count %d)\n",
iface, dstData, start, count);
#define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size)
static HRESULT process_vertices_strided(IWineD3DDeviceImpl *This, DWORD dwDestIndex, DWORD dwCount,
- const struct wined3d_stream_info *stream_info, struct wined3d_buffer *dest, DWORD dwFlags)
+ const struct wined3d_stream_info *stream_info, struct wined3d_buffer *dest, DWORD dwFlags,
+ DWORD DestFVF)
{
char *dest_ptr, *dest_conv = NULL, *dest_conv_addr = NULL;
unsigned int i;
- DWORD DestFVF = dest->fvf;
WINED3DVIEWPORT vp;
WINED3DMATRIX mat, proj_mat, view_mat, world_mat;
BOOL doClip;
FIXME("Clipping is broken and disabled for now\n");
}
} else doClip = FALSE;
- dest_ptr = ((char *) dest->resource.allocatedMemory) + dwDestIndex * get_flexible_vertex_size(DestFVF);
+ dest_ptr = ((char *) buffer_get_sysmem(dest)) + dwDestIndex * get_flexible_vertex_size(DestFVF);
IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
WINED3DTS_VIEW,
#undef copy_and_next
static HRESULT WINAPI IWineD3DDeviceImpl_ProcessVertices(IWineD3DDevice *iface, UINT SrcStartIndex, UINT DestIndex,
- UINT VertexCount, IWineD3DBuffer *pDestBuffer, IWineD3DVertexDeclaration *pVertexDecl, DWORD Flags)
+ UINT VertexCount, IWineD3DBuffer *pDestBuffer, IWineD3DVertexDeclaration *pVertexDecl, DWORD Flags,
+ DWORD DestFVF)
{
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
struct wined3d_stream_info stream_info;
{
struct wined3d_buffer *vb = (struct wined3d_buffer *)This->stateBlock->streamSource[e->stream_idx];
e->buffer_object = 0;
- e->data = (BYTE *)((unsigned long)e->data + (unsigned long)vb->resource.allocatedMemory);
+ e->data = (BYTE *)((unsigned long)e->data + (unsigned long)buffer_get_sysmem(vb));
ENTER_GL();
GL_EXTCALL(glDeleteBuffersARB(1, &vb->buffer_object));
vb->buffer_object = 0;
}
return process_vertices_strided(This, DestIndex, VertexCount, &stream_info,
- (struct wined3d_buffer *)pDestBuffer, Flags);
+ (struct wined3d_buffer *)pDestBuffer, Flags, DestFVF);
}
/*****
{
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
UINT idxStride = 2;
- IWineD3DIndexBuffer *pIB;
- WINED3DINDEXBUFFER_DESC IdxBufDsc;
+ IWineD3DBuffer *pIB;
GLuint vbo;
pIB = This->stateBlock->pIndexData;
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
This->stateBlock->streamIsUP = FALSE;
}
- vbo = ((IWineD3DIndexBufferImpl *) pIB)->vbo;
+ vbo = ((struct wined3d_buffer *) pIB)->buffer_object;
TRACE("(%p) : min %u, vertex count %u, startIdx %u, index count %u\n",
This, minIndex, NumVertices, startIndex, index_count);
- IWineD3DIndexBuffer_GetDesc(pIB, &IdxBufDsc);
- if (IdxBufDsc.Format == WINED3DFMT_R16_UINT) {
+ if (This->stateBlock->IndexFmt == WINED3DFMT_R16_UINT) {
idxStride = 2;
} else {
idxStride = 4;
}
drawPrimitive(iface, index_count, NumVertices, startIndex, idxStride,
- vbo ? NULL : ((IWineD3DIndexBufferImpl *) pIB)->resource.allocatedMemory, minIndex);
+ vbo ? NULL : ((struct wined3d_buffer *) pIB)->resource.allocatedMemory, minIndex);
return WINED3D_OK;
}
int idxStride;
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
IWineD3DBuffer *vb;
- IWineD3DIndexBuffer *ib;
+ IWineD3DBuffer *ib;
TRACE("(%p) : MinVtxIdx %u, NumVIdx %u, index count %u, pidxdata %p, IdxFmt %u, pVtxdata %p, stride=%u\n",
This, MinVertexIndex, NumVertices, index_count, pIndexData,
This->stateBlock->streamStride[0] = 0;
ib = This->stateBlock->pIndexData;
if(ib) {
- IWineD3DIndexBuffer_Release(ib);
+ IWineD3DBuffer_Release(ib);
This->stateBlock->pIndexData = NULL;
}
/* No need to mark the stream source state dirty here. Either the app calls UP drawing again, or it has to call
This->currentPatch = patch;
old_primitive_type = This->stateBlock->gl_primitive_type;
This->stateBlock->gl_primitive_type = GL_TRIANGLES;
- IWineD3DDevice_DrawPrimitiveStrided(iface, patch->numSegs[0] * patch->numSegs[1] * 2, &patch->strided);
+ IWineD3DDevice_DrawPrimitiveStrided(iface, patch->numSegs[0] * patch->numSegs[1] * 2 * 3, &patch->strided);
This->stateBlock->gl_primitive_type = old_primitive_type;
This->currentPatch = NULL;
case WINED3DRTYPE_VOLUME:
/* TODO: nothing really? */
break;
- case WINED3DRTYPE_VERTEXBUFFER:
+ case WINED3DRTYPE_BUFFER:
{
int streamNumber;
TRACE("Cleaning up stream pointers\n");
}
}
}
- }
- break;
- case WINED3DRTYPE_INDEXBUFFER:
- if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
- if (This->updateStateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
- This->updateStateBlock->pIndexData = NULL;
+
+ if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
+ if (This->updateStateBlock->pIndexData == (IWineD3DBuffer *)resource) {
+ This->updateStateBlock->pIndexData = NULL;
+ }
}
- }
- if (This->stateBlock != NULL ) { /* ==NULL when device is being destroyed */
- if (This->stateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
- This->stateBlock->pIndexData = NULL;
+ if (This->stateBlock != NULL ) { /* ==NULL when device is being destroyed */
+ if (This->stateBlock->pIndexData == (IWineD3DBuffer *)resource) {
+ This->stateBlock->pIndexData = NULL;
+ }
}
}
break;
- case WINED3DRTYPE_BUFFER:
- /* Nothing to do, yet.*/
- break;
-
default:
FIXME("(%p) unknown resource type %p %u\n", This, resource, IWineD3DResource_GetType(resource));
break;
switch (vs_selected_mode) {
case SHADER_GLSL:
- /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
- gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 1;
+ gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF;
break;
case SHADER_ARB:
- /* We have to subtract any other PARAMs that we might use in our shader programs.
- * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
- * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
- gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF - 3;
+ gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF;
break;
default:
gl_info->max_vshader_constantsF = 0;
switch (ps_selected_mode) {
case SHADER_GLSL:
- /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
- * In theory the texbem instruction may need one more shader constant too. But lets assume
- * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
- * and lets not take away a uniform needlessly from all other shaders.
- */
- gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 2;
+ gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF;
break;
case SHADER_ARB:
- /* The arb shader only loads the bump mapping environment matrix into the shader if it finds
- * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
- */
- gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF - 2;
+ gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF;
break;
default:
gl_info->max_pshader_constantsF = 0;
* shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
*/
if(WINE_D3D9_CAPABLE(gl_info) && (gl_info->vs_nv_version == VS_VERSION_30)) {
- /* Geforce GTX - highend */
- if(strstr(gl_info->gl_renderer, "GTX 280")) {
+ /* Geforce 200 - highend */
+ if(strstr(gl_info->gl_renderer, "GTX 280") ||
+ strstr(gl_info->gl_renderer, "GTX 285") ||
+ strstr(gl_info->gl_renderer, "GTX 295"))
+ {
gl_info->gl_card = CARD_NVIDIA_GEFORCE_GTX280;
vidmem = 1024;
}
- /* Geforce9 - highend */
- else if(strstr(gl_info->gl_renderer, "9800")) {
+ /* Geforce 200 - midend high */
+ if(strstr(gl_info->gl_renderer, "GTX 275")) {
+ gl_info->gl_card = CARD_NVIDIA_GEFORCE_GTX275;
+ vidmem = 896;
+ }
+ /* Geforce 200 - midend */
+ if(strstr(gl_info->gl_renderer, "GTX 260")) {
+ gl_info->gl_card = CARD_NVIDIA_GEFORCE_GTX260;
+ vidmem = 1024;
+ }
+ /* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
+ else if(strstr(gl_info->gl_renderer, "9800") ||
+ strstr(gl_info->gl_renderer, "GTS 150") ||
+ strstr(gl_info->gl_renderer, "GTS 250"))
+ {
gl_info->gl_card = CARD_NVIDIA_GEFORCE_9800GT;
vidmem = 512;
}
gl_info->gl_card = CARD_NVIDIA_GEFORCE_9600GT;
vidmem = 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
}
+ /* Geforce9 - midend low / Geforce 200 - low*/
+ else if(strstr(gl_info->gl_renderer, "9500") ||
+ strstr(gl_info->gl_renderer, "GT 120") ||
+ strstr(gl_info->gl_renderer, "GT 130"))
+ {
+ gl_info->gl_card = CARD_NVIDIA_GEFORCE_9500GT;
+ vidmem = 256; /* The 9500GT has 256-1024MB */
+ }
+ /* Geforce9 - lowend */
+ else if(strstr(gl_info->gl_renderer, "9400")) {
+ gl_info->gl_card = CARD_NVIDIA_GEFORCE_9400GT;
+ vidmem = 256; /* The 9400GT has 256-1024MB */
+ }
+ /* Geforce9 - lowend low */
+ else if(strstr(gl_info->gl_renderer, "9100") ||
+ strstr(gl_info->gl_renderer, "9200") ||
+ strstr(gl_info->gl_renderer, "9300") ||
+ strstr(gl_info->gl_renderer, "G 100"))
+ {
+ gl_info->gl_card = CARD_NVIDIA_GEFORCE_9200;
+ vidmem = 256; /* The 9100-9300 cards have 256MB */
+ }
/* Geforce8 - highend */
else if (strstr(gl_info->gl_renderer, "8800")) {
gl_info->gl_card = CARD_NVIDIA_GEFORCE_8800GTS;
/* Return the information requested */
TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
strcpy(pIdentifier->Driver, This->adapters[Adapter].driver);
- strcpy(pIdentifier->Description, This->adapters[Adapter].description);
+ if(This->adapters[Adapter].gl_info.driver_description)
+ strcpy(pIdentifier->Description, This->adapters[Adapter].gl_info.driver_description);
+ else /* Copy default description "Direct3D HAL" */
+ strcpy(pIdentifier->Description, This->adapters[Adapter].description);
/* Note dx8 doesn't supply a DeviceName */
if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
/* Do nothing, continue with checking the format below */
break;
}
- } else if((RType == WINED3DRTYPE_INDEXBUFFER) || (RType == WINED3DRTYPE_VERTEXBUFFER)){
+ } else if(RType == WINED3DRTYPE_BUFFER){
/* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
TRACE_(d3d_caps)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
return WINED3DERR_NOTAVAILABLE;
const struct fragment_pipeline *frag_pipeline = NULL;
int i;
struct fragment_caps ffp_caps;
+ struct shader_caps shader_caps;
HRESULT hr;
/* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
&object->ps_selected_mode, &object->vs_selected_mode);
object->shader_backend = select_shader_backend(adapter, DeviceType);
+ memset(&shader_caps, 0, sizeof(shader_caps));
+ object->shader_backend->shader_get_caps(DeviceType, &adapter->gl_info, &shader_caps);
+ object->d3d_vshader_constantF = shader_caps.MaxVertexShaderConst;
+ object->d3d_pshader_constantF = shader_caps.MaxPixelShaderConst;
+
memset(&ffp_caps, 0, sizeof(ffp_caps));
frag_pipeline = select_fragment_implementation(adapter, DeviceType);
object->frag_pipe = frag_pipeline;
struct driver_version_information {
WORD vendor; /* reported PCI card vendor ID */
WORD card; /* reported PCI card device ID */
+ const char *description; /* Description of the card e.g. NVIDIA RIVA TNT */
WORD hipart_hi, hipart_lo; /* driver hiword to report */
WORD lopart_hi, lopart_lo; /* driver loword to report */
};
static const struct driver_version_information driver_version_table[] = {
- /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (177.x)*/
- /* GeforceFX support is up to 173.x, Geforce2MX/3/4 up to 96.x, TNT/Geforce1/2 up to 71.x */
- /* Note that version numbers >100 lets say 123.45 use >= x.y.11.2345 and not x.y.10.12345 */
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, 7, 15, 11, 7341 },
- {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, 7, 15, 11, 7341 },
+ /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (180.x)
+ * GeforceFX support is up to 173.x, - driver uses numbering x.y.11.7341 for 173.41 where x is the windows revision (6=2000/xp, 7=vista), y is unknown
+ * Geforce2MX/3/4 up to 96.x - driver uses numbering 9.6.8.9 for 96.89
+ * TNT/Geforce1/2 up to 71.x - driver uses numbering 7.1.8.6 for 71.86
+ *
+ * All version numbers used below are from the Linux nvidia drivers.
+ */
+ {VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT, "NVIDIA RIVA TNT", 7, 1, 8, 6 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", 7, 1, 8, 6 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE, "NVIDIA GeForce 256", 7, 1, 8, 6 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", 9, 6, 4, 3 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", 7, 1, 8, 6 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE3, "NVIDIA GeForce3", 9, 6, 4, 3 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", 9, 6, 4, 3 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", 9, 6, 4, 3 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", 7, 15, 11, 7341 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", 7, 15, 11, 7341 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", 7, 15, 11, 7341 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", 7, 15, 11, 8044 },
+ {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", 7, 15, 11, 8044 },
/* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode */
- {VENDOR_ATI, CARD_ATI_RADEON_9500, 6, 14, 10, 6764 },
- {VENDOR_ATI, CARD_ATI_RADEON_X700, 6, 14, 10, 6764 },
- {VENDOR_ATI, CARD_ATI_RADEON_X1600, 6, 14, 10, 6764 },
- {VENDOR_ATI, CARD_ATI_RADEON_HD2300, 6, 14, 10, 6764 },
- {VENDOR_ATI, CARD_ATI_RADEON_HD2600, 6, 14, 10, 6764 },
- {VENDOR_ATI, CARD_ATI_RADEON_HD2900, 6, 14, 10, 6764 },
-
- /* TODO: Add information about legacy nvidia and ATI hardware, Intel and other cards */
+ {VENDOR_ATI, CARD_ATI_RADEON_9500, "ATI Radeon 9500", 6, 14, 10, 6764 },
+ {VENDOR_ATI, CARD_ATI_RADEON_X700, "ATI Radeon X700 SE", 6, 14, 10, 6764 },
+ {VENDOR_ATI, CARD_ATI_RADEON_X1600, "ATI Radeon X1600 Series", 6, 14, 10, 6764 },
+ {VENDOR_ATI, CARD_ATI_RADEON_HD2300, "ATI Mobility Radeon HD 2300", 6, 14, 10, 6764 },
+ {VENDOR_ATI, CARD_ATI_RADEON_HD2600, "ATI Mobility Radeon HD 2600", 6, 14, 10, 6764 },
+ {VENDOR_ATI, CARD_ATI_RADEON_HD2900, "ATI Radeon HD 2900 XT", 6, 14, 10, 6764 },
+
+ /* TODO: Add information about legacy ATI hardware, Intel and other cards */
};
static void fixup_extensions(WineD3D_GL_Info *gl_info) {
driver_version_table[i].lopart_lo);
gl_info->driver_version_hipart = MAKEDWORD_VERSION(driver_version_table[i].hipart_hi,
driver_version_table[i].hipart_lo);
+ strcpy(gl_info->driver_description, driver_version_table[i].description);
break;
}
}
* idxData will be != NULL
*/
if(idxData == NULL) {
- idxData = ((IWineD3DIndexBufferImpl *) This->stateBlock->pIndexData)->resource.allocatedMemory;
+ idxData = buffer_get_sysmem((struct wined3d_buffer *) This->stateBlock->pIndexData);
}
if (idxSize == 2) pIdxBufS = idxData;
* idxData will be != NULL
*/
if(idxData == NULL) {
- idxData = ((IWineD3DIndexBufferImpl *) stateblock->pIndexData)->resource.allocatedMemory;
+ idxData = buffer_get_sysmem((struct wined3d_buffer *) This->stateBlock->pIndexData);
}
if (idxSize == 2) pIdxBufS = idxData;
{
struct wined3d_buffer *vb =
(struct wined3d_buffer *)stateblock->streamSource[si->elements[instancedData[j]].stream_idx];
- ptr += (long) vb->resource.allocatedMemory;
+ ptr += (long) buffer_get_sysmem(vb);
}
send_attribute(This, si->elements[instancedData[j]].format_desc->format, instancedData[j], ptr);
{
struct wined3d_buffer *vb = (struct wined3d_buffer *)This->stateBlock->streamSource[e->stream_idx];
e->buffer_object = 0;
- e->data = (BYTE *)((unsigned long)e->data + (unsigned long)vb->resource.allocatedMemory);
+ e->data = (BYTE *)((unsigned long)e->data + (unsigned long)buffer_get_sysmem(vb));
}
}
}
{
struct wined3d_buffer *vb;
vb = (struct wined3d_buffer *)This->stateBlock->streamSource[e->stream_idx];
- e->data = (BYTE *)((unsigned long)e->data + (unsigned long)vb->resource.allocatedMemory);
+ e->data = (BYTE *)((unsigned long)e->data + (unsigned long)buffer_get_sysmem(vb));
}
vtxStride = e->stride;
data = e->data +
GLint vuniformI_locations[MAX_CONST_I];
GLint puniformI_locations[MAX_CONST_I];
GLint posFixup_location;
- GLint rectFixup_location[MAX_FRAGMENT_SAMPLERS];
+ GLint np2Fixup_location[MAX_FRAGMENT_SAMPLERS];
GLint bumpenvmat_location[MAX_TEXTURES];
GLint luminancescale_location[MAX_TEXTURES];
GLint luminanceoffset_location[MAX_TEXTURES];
entry->constant_version = 0;
}
+/**
+ * Loads the texture dimensions for NP2 fixup into the currently set GLSL program.
+ */
+static void shader_glsl_load_np2fixup_constants(
+ IWineD3DDevice* device,
+ char usePixelShader,
+ char useVertexShader) {
+
+ const IWineD3DDeviceImpl* deviceImpl = (const IWineD3DDeviceImpl*) device;
+ const struct glsl_shader_prog_link* prog = ((struct shader_glsl_priv *)(deviceImpl->shader_priv))->glsl_program;
+
+ if (!prog) {
+ /* No GLSL program set - nothing to do. */
+ return;
+ }
+
+ if (!usePixelShader) {
+ /* NP2 texcoord fixup is (currently) only done for pixelshaders. */
+ return;
+ }
+
+ if (prog->ps_args.np2_fixup) {
+ UINT i;
+ UINT fixup = prog->ps_args.np2_fixup;
+ const WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info;
+ const IWineD3DStateBlockImpl* stateBlock = (const IWineD3DStateBlockImpl*) deviceImpl->stateBlock;
+
+ for (i = 0; fixup; fixup >>= 1, ++i) {
+ if (-1 != prog->np2Fixup_location[i]) {
+ const IWineD3DBaseTextureImpl* const tex = (const IWineD3DBaseTextureImpl*) stateBlock->textures[i];
+ if (!tex) {
+ FIXME("Non-existant texture is flagged for NP2 texcoord fixup\n");
+ continue;
+ } else {
+ const float tex_dim[2] = {tex->baseTexture.pow2Matrix[0], tex->baseTexture.pow2Matrix[5]};
+ GL_EXTCALL(glUniform2fvARB(prog->np2Fixup_location[i], 1, tex_dim));
+ }
+ }
+ }
+ }
+}
+
/**
* Loads the app-supplied constants into the currently set GLSL program.
*/
}
GL_EXTCALL(glUniform4fvARB(prog->ycorrection_location, 1, correction_params));
}
-
- /* Constant loading for texture rect coord fixup. */
- if (prog->ps_args.texrect_fixup) {
- UINT fixup = prog->ps_args.texrect_fixup;
-
- for (i = 0; fixup; fixup >>= 1, ++i) {
- if (-1 != prog->rectFixup_location[i]) {
- const IWineD3DBaseTextureImpl* const tex = (const IWineD3DBaseTextureImpl*) stateBlock->textures[i];
- if (!tex) {
- FIXME("Non-existant texture is flagged for NP2 texcoord fixup\n");
- continue;
- } else {
- const float tex_dim[2] = {tex->baseTexture.pow2Matrix[0], tex->baseTexture.pow2Matrix[5]};
- GL_EXTCALL(glUniform2fvARB(prog->rectFixup_location[i], 1, tex_dim));
- }
- }
- }
- }
}
if (priv->next_constant_version == UINT_MAX)
/* Declare the constants (aka uniforms) */
if (This->baseShader.limits.constant_float > 0) {
- unsigned max_constantsF = min(This->baseShader.limits.constant_float,
- (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
+ unsigned max_constantsF;
+ if(pshader) {
+ max_constantsF = GL_LIMITS(pshader_constantsF) - (MAX_CONST_B / 4) - MAX_CONST_I - 2;
+ max_constantsF = min(This->baseShader.limits.constant_float, max_constantsF);
+ } else {
+ /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
+ max_constantsF = GL_LIMITS(vshader_constantsF) - (MAX_CONST_B / 4) - MAX_CONST_I - 1;
+ max_constantsF = min(This->baseShader.limits.constant_float, max_constantsF);
+ }
shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
}
shader_addline(buffer, "uniform sampler2D %csampler%u;\n", prefix, i);
}
- if(ps_args->texrect_fixup & (1 << i)) {
- /* RECT textures in OpenGL use texcoords in the range [0,width]x[0,height]
+ if(ps_args->np2_fixup & (1 << i)) {
+ /* NP2/RECT textures in OpenGL use texcoords in the range [0,width]x[0,height]
* while D3D has them in the (normalized) [0,1]x[0,1] range.
- * samplerRectFixup stores texture dimensions and is updated through
- * shader_glsl_load_constants when the sampler changes. */
- shader_addline(buffer, "uniform vec2 %csamplerRectFixup%u;\n", prefix, i);
+ * samplerNP2Fixup stores texture dimensions and is updated through
+ * shader_glsl_load_np2fixup_constants when the sampler changes. */
+ shader_addline(buffer, "uniform vec2 %csamplerNP2Fixup%u;\n", prefix, i);
}
break;
case WINED3DSTT_CUBE:
/** Writes the GLSL variable name that corresponds to the register that the
* DX opcode parameter is trying to access */
-static void shader_glsl_get_register_name(const DWORD param, const DWORD addr_token,
- char *regstr, BOOL *is_color, const struct wined3d_shader_instruction *ins)
+static void shader_glsl_get_register_name(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx,
+ BOOL rel_addr, const DWORD addr_token, char *register_name, BOOL *is_color,
+ const struct wined3d_shader_instruction *ins)
{
/* oPos, oFog and oPts in D3D */
static const char * const hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
- DWORD reg = param & WINED3DSP_REGNUM_MASK;
- DWORD regtype = shader_get_regtype(param);
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
const WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info;
DWORD shader_version = This->baseShader.reg_maps.shader_version;
char pshader = shader_is_pshader_version(shader_version);
- char tmpStr[150];
- *is_color = FALSE;
-
- switch (regtype) {
+ *is_color = FALSE;
+
+ switch (register_type)
+ {
case WINED3DSPR_TEMP:
- sprintf(tmpStr, "R%u", reg);
+ sprintf(register_name, "R%u", register_idx);
break;
case WINED3DSPR_INPUT:
if (pshader) {
{
DWORD in_count = GL_LIMITS(glsl_varyings) / 4;
- if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
+ if (rel_addr)
+ {
glsl_src_param_t rel_param;
shader_glsl_add_src_param(ins, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
/* Removing a + 0 would be an obvious optimization, but macos doesn't see the NOP
* operation there
*/
- if(((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg]) {
+ if (((IWineD3DPixelShaderImpl *)This)->input_reg_map[register_idx])
+ {
if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count) {
- sprintf(tmpStr, "((%s + %u) > %d ? (%s + %u) > %d ? gl_SecondaryColor : gl_Color : IN[%s + %u])",
- rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg], in_count - 1,
- rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg], in_count,
- rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg]);
+ sprintf(register_name, "((%s + %u) > %d ? (%s + %u) > %d ? gl_SecondaryColor : gl_Color : IN[%s + %u])",
+ rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[register_idx], in_count - 1,
+ rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[register_idx], in_count,
+ rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[register_idx]);
} else {
- sprintf(tmpStr, "IN[%s + %u]", rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg]);
+ sprintf(register_name, "IN[%s + %u]", rel_param.param_str,
+ ((IWineD3DPixelShaderImpl *)This)->input_reg_map[register_idx]);
}
} else {
if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count) {
- sprintf(tmpStr, "((%s) > %d ? (%s) > %d ? gl_SecondaryColor : gl_Color : IN[%s])",
+ sprintf(register_name, "((%s) > %d ? (%s) > %d ? gl_SecondaryColor : gl_Color : IN[%s])",
rel_param.param_str, in_count - 1,
rel_param.param_str, in_count,
rel_param.param_str);
} else {
- sprintf(tmpStr, "IN[%s]", rel_param.param_str);
+ sprintf(register_name, "IN[%s]", rel_param.param_str);
}
}
} else {
- DWORD idx = ((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg];
+ DWORD idx = ((IWineD3DPixelShaderImpl *) This)->input_reg_map[register_idx];
if (idx == in_count) {
- sprintf(tmpStr, "gl_Color");
+ sprintf(register_name, "gl_Color");
} else if (idx == in_count + 1) {
- sprintf(tmpStr, "gl_SecondaryColor");
+ sprintf(register_name, "gl_SecondaryColor");
} else {
- sprintf(tmpStr, "IN[%u]", idx);
+ sprintf(register_name, "IN[%u]", idx);
}
}
} else {
- if (reg==0)
- strcpy(tmpStr, "gl_Color");
+ if (register_idx == 0)
+ strcpy(register_name, "gl_Color");
else
- strcpy(tmpStr, "gl_SecondaryColor");
+ strcpy(register_name, "gl_SecondaryColor");
}
} else {
- if (((IWineD3DVertexShaderImpl *)This)->cur_args->swizzle_map & (1 << reg)) *is_color = TRUE;
- sprintf(tmpStr, "attrib%u", reg);
- }
+ if (((IWineD3DVertexShaderImpl *)This)->cur_args->swizzle_map & (1 << register_idx)) *is_color = TRUE;
+ sprintf(register_name, "attrib%u", register_idx);
+ }
break;
case WINED3DSPR_CONST:
{
const char prefix = pshader? 'P':'V';
/* Relative addressing */
- if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
-
+ if (rel_addr)
+ {
/* Relative addressing on shaders 2.0+ have a relative address token,
* prior to that, it was hard-coded as "A0.x" because there's only 1 register */
if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 2)
{
glsl_src_param_t rel_param;
shader_glsl_add_src_param(ins, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
- if(reg) {
- sprintf(tmpStr, "%cC[%s + %u]", prefix, rel_param.param_str, reg);
+ if (register_idx)
+ {
+ sprintf(register_name, "%cC[%s + %u]", prefix, rel_param.param_str, register_idx);
} else {
- sprintf(tmpStr, "%cC[%s]", prefix, rel_param.param_str);
+ sprintf(register_name, "%cC[%s]", prefix, rel_param.param_str);
}
} else {
- if(reg) {
- sprintf(tmpStr, "%cC[A0.x + %u]", prefix, reg);
+ if (register_idx)
+ {
+ sprintf(register_name, "%cC[A0.x + %u]", prefix, register_idx);
} else {
- sprintf(tmpStr, "%cC[A0.x]", prefix);
+ sprintf(register_name, "%cC[A0.x]", prefix);
}
}
} else {
- if(shader_constant_is_local(This, reg)) {
- sprintf(tmpStr, "%cLC%u", prefix, reg);
+ if (shader_constant_is_local(This, register_idx))
+ {
+ sprintf(register_name, "%cLC%u", prefix, register_idx);
} else {
- sprintf(tmpStr, "%cC[%u]", prefix, reg);
+ sprintf(register_name, "%cC[%u]", prefix, register_idx);
}
}
}
case WINED3DSPR_CONSTINT:
if (pshader)
- sprintf(tmpStr, "PI[%u]", reg);
+ sprintf(register_name, "PI[%u]", register_idx);
else
- sprintf(tmpStr, "VI[%u]", reg);
+ sprintf(register_name, "VI[%u]", register_idx);
break;
case WINED3DSPR_CONSTBOOL:
if (pshader)
- sprintf(tmpStr, "PB[%u]", reg);
+ sprintf(register_name, "PB[%u]", register_idx);
else
- sprintf(tmpStr, "VB[%u]", reg);
+ sprintf(register_name, "VB[%u]", register_idx);
break;
case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
if (pshader) {
- sprintf(tmpStr, "T%u", reg);
+ sprintf(register_name, "T%u", register_idx);
} else {
- sprintf(tmpStr, "A%u", reg);
+ sprintf(register_name, "A%u", register_idx);
}
break;
case WINED3DSPR_LOOP:
- sprintf(tmpStr, "aL%u", This->baseShader.cur_loop_regno - 1);
+ sprintf(register_name, "aL%u", This->baseShader.cur_loop_regno - 1);
break;
case WINED3DSPR_SAMPLER:
if (pshader)
- sprintf(tmpStr, "Psampler%u", reg);
+ sprintf(register_name, "Psampler%u", register_idx);
else
- sprintf(tmpStr, "Vsampler%u", reg);
+ sprintf(register_name, "Vsampler%u", register_idx);
break;
case WINED3DSPR_COLOROUT:
- if (reg >= GL_LIMITS(buffers)) {
- WARN("Write to render target %u, only %d supported\n", reg, 4);
- }
+ if (register_idx >= GL_LIMITS(buffers))
+ WARN("Write to render target %u, only %d supported\n", register_idx, 4);
+
if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
- sprintf(tmpStr, "gl_FragData[%u]", reg);
+ sprintf(register_name, "gl_FragData[%u]", register_idx);
} else { /* On older cards with GLSL support like the GeforceFX there's only one buffer. */
- sprintf(tmpStr, "gl_FragColor");
+ sprintf(register_name, "gl_FragColor");
}
break;
case WINED3DSPR_RASTOUT:
- sprintf(tmpStr, "%s", hwrastout_reg_names[reg]);
+ sprintf(register_name, "%s", hwrastout_reg_names[register_idx]);
break;
case WINED3DSPR_DEPTHOUT:
- sprintf(tmpStr, "gl_FragDepth");
+ sprintf(register_name, "gl_FragDepth");
break;
case WINED3DSPR_ATTROUT:
- if (reg == 0) {
- sprintf(tmpStr, "gl_FrontColor");
+ if (register_idx == 0)
+ {
+ sprintf(register_name, "gl_FrontColor");
} else {
- sprintf(tmpStr, "gl_FrontSecondaryColor");
+ sprintf(register_name, "gl_FrontSecondaryColor");
}
break;
case WINED3DSPR_TEXCRDOUT:
/* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
- if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 3) sprintf(tmpStr, "OUT[%u]", reg);
- else sprintf(tmpStr, "gl_TexCoord[%u]", reg);
+ if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 3) sprintf(register_name, "OUT[%u]", register_idx);
+ else sprintf(register_name, "gl_TexCoord[%u]", register_idx);
break;
case WINED3DSPR_MISCTYPE:
- if (reg == 0) {
+ if (register_idx == 0)
+ {
/* vPos */
- sprintf(tmpStr, "vpos");
- } else if (reg == 1){
+ sprintf(register_name, "vpos");
+ }
+ else if (register_idx == 1)
+ {
/* Note that gl_FrontFacing is a bool, while vFace is
* a float for which the sign determines front/back
*/
- sprintf(tmpStr, "(gl_FrontFacing ? 1.0 : -1.0)");
+ sprintf(register_name, "(gl_FrontFacing ? 1.0 : -1.0)");
} else {
- FIXME("Unhandled misctype register %d\n", reg);
- sprintf(tmpStr, "unrecognized_register");
+ FIXME("Unhandled misctype register %d\n", register_idx);
+ sprintf(register_name, "unrecognized_register");
}
break;
default:
- FIXME("Unhandled register name Type(%d)\n", regtype);
- sprintf(tmpStr, "unrecognized_register");
+ FIXME("Unhandled register name Type(%d)\n", register_type);
+ sprintf(register_name, "unrecognized_register");
break;
}
+}
- strcat(regstr, tmpStr);
+static void shader_glsl_write_mask_to_str(DWORD write_mask, char *str)
+{
+ *str++ = '.';
+ if (write_mask & WINED3DSP_WRITEMASK_0) *str++ = 'x';
+ if (write_mask & WINED3DSP_WRITEMASK_1) *str++ = 'y';
+ if (write_mask & WINED3DSP_WRITEMASK_2) *str++ = 'z';
+ if (write_mask & WINED3DSP_WRITEMASK_3) *str++ = 'w';
+ *str = '\0';
}
/* Get the GLSL write mask for the destination register */
-static DWORD shader_glsl_get_write_mask(const DWORD param, char *write_mask) {
- char *ptr = write_mask;
- DWORD mask = param & WINED3DSP_WRITEMASK_ALL;
+static DWORD shader_glsl_get_write_mask(const struct wined3d_shader_dst_param *param, char *write_mask)
+{
+ DWORD mask = param->write_mask;
- if (shader_is_scalar(param)) {
+ if (shader_is_scalar(param->register_type, param->register_idx))
+ {
mask = WINED3DSP_WRITEMASK_0;
- } else {
- *ptr++ = '.';
- if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
- if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
- if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
- if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
+ *write_mask = '\0';
+ }
+ else
+ {
+ shader_glsl_write_mask_to_str(mask, write_mask);
}
-
- *ptr = '\0';
return mask;
}
const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
char *ptr = swizzle_str;
- if (!shader_is_scalar(param)) {
+ if (!shader_is_scalar(shader_get_regtype(param), param & WINED3DSP_REGNUM_MASK))
+ {
*ptr++ = '.';
/* swizzle bits fields: wwzzyyxx */
if (mask & WINED3DSP_WRITEMASK_0) *ptr++ = swizzle_chars[swizzle & 0x03];
src_param->param_str[0] = '\0';
swizzle_str[0] = '\0';
- shader_glsl_get_register_name(param, addr_token, src_param->reg_name, &is_color, ins);
+ shader_glsl_get_register_name(shader_get_regtype(param), param & WINED3DSP_REGNUM_MASK,
+ param & WINED3DSHADER_ADDRMODE_RELATIVE, addr_token, src_param->reg_name, &is_color, ins);
shader_glsl_get_swizzle(param, is_color, mask, swizzle_str);
shader_glsl_gen_modifier(param, src_param->reg_name, swizzle_str, src_param->param_str);
* Also, return the actual register name and swizzle in case the
* caller needs this information as well. */
static DWORD shader_glsl_add_dst_param(const struct wined3d_shader_instruction *ins,
- const DWORD param, const DWORD addr_token, glsl_dst_param_t *dst_param)
+ const struct wined3d_shader_dst_param *wined3d_dst, glsl_dst_param_t *glsl_dst)
{
BOOL is_color = FALSE;
- dst_param->mask_str[0] = '\0';
- dst_param->reg_name[0] = '\0';
+ glsl_dst->mask_str[0] = '\0';
+ glsl_dst->reg_name[0] = '\0';
- shader_glsl_get_register_name(param, addr_token, dst_param->reg_name, &is_color, ins);
- return shader_glsl_get_write_mask(param, dst_param->mask_str);
+ shader_glsl_get_register_name(wined3d_dst->register_type, wined3d_dst->register_idx,
+ wined3d_dst->has_rel_addr, wined3d_dst->addr_token, glsl_dst->reg_name, &is_color, ins);
+ return shader_glsl_get_write_mask(wined3d_dst, glsl_dst->mask_str);
}
/* Append the destination part of the instruction to the buffer, return the effective write mask */
static DWORD shader_glsl_append_dst_ext(SHADER_BUFFER *buffer,
- const struct wined3d_shader_instruction *ins, const DWORD param)
+ const struct wined3d_shader_instruction *ins, const struct wined3d_shader_dst_param *dst)
{
- glsl_dst_param_t dst_param;
+ glsl_dst_param_t glsl_dst;
DWORD mask;
- int shift;
-
- mask = shader_glsl_add_dst_param(ins, param, ins->dst[0].addr_token, &dst_param);
- if(mask) {
- shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- shader_addline(buffer, "%s%s = %s(", dst_param.reg_name, dst_param.mask_str, shift_glsl_tab[shift]);
- }
+ mask = shader_glsl_add_dst_param(ins, dst, &glsl_dst);
+ if (mask) shader_addline(buffer, "%s%s = %s(", glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]);
return mask;
}
/* Append the destination part of the instruction to the buffer, return the effective write mask */
static DWORD shader_glsl_append_dst(SHADER_BUFFER *buffer, const struct wined3d_shader_instruction *ins)
{
- return shader_glsl_append_dst_ext(buffer, ins, ins->dst[0].token);
+ return shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0]);
}
/** Process GLSL instruction modifiers */
void shader_glsl_add_instruction_modifiers(const struct wined3d_shader_instruction *ins)
{
glsl_dst_param_t dst_param;
- DWORD mask;
+ DWORD modifiers;
if (!ins->dst_count) return;
- mask = ins->dst[0].token & WINED3DSP_DSTMOD_MASK;
- if (!mask) return;
+ modifiers = ins->dst[0].modifiers;
+ if (!modifiers) return;
- shader_glsl_add_dst_param(ins, ins->dst[0].token, 0, &dst_param);
+ shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
- if (mask & WINED3DSPDM_SATURATE)
+ if (modifiers & WINED3DSPDM_SATURATE)
{
/* _SAT means to clamp the value of the register to between 0 and 1 */
shader_addline(ins->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
dst_param.mask_str, dst_param.reg_name, dst_param.mask_str);
}
- if (mask & WINED3DSPDM_MSAMPCENTROID)
+ if (modifiers & WINED3DSPDM_MSAMPCENTROID)
{
FIXME("_centroid modifier not handled\n");
}
- if (mask & WINED3DSPDM_PARTIALPRECISION)
+ if (modifiers & WINED3DSPDM_PARTIALPRECISION)
{
/* MSDN says this modifier can be safely ignored, so that's what we'll do. */
}
static void shader_glsl_color_correction(const struct wined3d_shader_instruction *ins, struct color_fixup_desc fixup)
{
+ struct wined3d_shader_dst_param dst;
unsigned int mask_size, remaining;
glsl_dst_param_t dst_param;
char arguments[256];
DWORD mask;
- BOOL dummy;
mask = 0;
if (fixup.x_sign_fixup || fixup.x_source != CHANNEL_SOURCE_X) mask |= WINED3DSP_WRITEMASK_0;
if (fixup.y_sign_fixup || fixup.y_source != CHANNEL_SOURCE_Y) mask |= WINED3DSP_WRITEMASK_1;
if (fixup.z_sign_fixup || fixup.z_source != CHANNEL_SOURCE_Z) mask |= WINED3DSP_WRITEMASK_2;
if (fixup.w_sign_fixup || fixup.w_source != CHANNEL_SOURCE_W) mask |= WINED3DSP_WRITEMASK_3;
- mask &= ins->dst[0].token;
+ mask &= ins->dst[0].write_mask;
if (!mask) return; /* Nothing to do */
mask_size = shader_glsl_get_write_mask_size(mask);
- dst_param.mask_str[0] = '\0';
- shader_glsl_get_write_mask(mask, dst_param.mask_str);
-
- dst_param.reg_name[0] = '\0';
- shader_glsl_get_register_name(ins->dst[0].token, ins->dst[0].addr_token, dst_param.reg_name, &dummy, ins);
+ dst = ins->dst[0];
+ dst.write_mask = mask;
+ shader_glsl_add_dst_param(ins, &dst, &dst_param);
arguments[0] = '\0';
remaining = mask_size;
const char *sampler_base;
char dst_swizzle[6];
struct color_fixup_desc fixup;
- BOOL rect_fixup = FALSE;
+ BOOL np2_fixup = FALSE;
va_list args;
- shader_glsl_get_swizzle(swizzle, FALSE, ins->dst[0].token, dst_swizzle);
+ shader_glsl_get_swizzle(swizzle, FALSE, ins->dst[0].write_mask, dst_swizzle);
if (shader_is_pshader_version(ins->reg_maps->shader_version))
{
fixup = This->cur_args->color_fixup[sampler];
sampler_base = "Psampler";
- if(This->cur_args->texrect_fixup & (1 << sampler)) {
+ if(This->cur_args->np2_fixup & (1 << sampler)) {
if(bias) {
- FIXME("Biased sampling from RECT textures is unsupported\n");
+ FIXME("Biased sampling from NP2 textures is unsupported\n");
} else {
- rect_fixup = TRUE;
+ np2_fixup = TRUE;
}
}
} else {
if(bias) {
shader_addline(ins->buffer, ", %s)%s);\n", bias, dst_swizzle);
} else {
- if (rect_fixup) {
- shader_addline(ins->buffer, " * PsamplerRectFixup%u)%s);\n", sampler, dst_swizzle);
+ if (np2_fixup) {
+ shader_addline(ins->buffer, " * PsamplerNP2Fixup%u)%s);\n", sampler, dst_swizzle);
} else {
shader_addline(ins->buffer, ")%s);\n", dst_swizzle);
}
* shader versions WINED3DSIO_MOVA is used for this. */
if ((WINED3DSHADER_VERSION_MAJOR(ins->reg_maps->shader_version) == 1
&& !shader_is_pshader_version(ins->reg_maps->shader_version)
- && shader_get_regtype(ins->dst[0].token) == WINED3DSPR_ADDR))
+ && ins->dst[0].register_type == WINED3DSPR_ADDR))
{
/* This is a simple floor() */
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
glsl_src_param_t src1_param;
char dst_mask[6];
- shader_glsl_get_write_mask(ins->dst[0].token, dst_mask);
+ shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
shader_glsl_append_dst(ins->buffer, ins);
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], src_mask, &src1_param);
shader_addline(ins->buffer, "tmp0.w = 1.0;\n");
shader_glsl_append_dst(ins->buffer, ins);
- shader_glsl_get_write_mask(ins->dst[0].token, dst_mask);
+ shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
shader_addline(ins->buffer, "tmp0%s);\n", dst_mask);
} else {
DWORD write_mask;
char mask_char[6];
BOOL temp_destination = FALSE;
- if (shader_is_scalar(ins->src[0]))
+ if (shader_is_scalar(shader_get_regtype(ins->src[0]), ins->src[0] & WINED3DSP_REGNUM_MASK))
{
write_mask = shader_glsl_append_dst(ins->buffer, ins);
DWORD src1regtype = shader_get_regtype(ins->src[1]);
DWORD src2regtype = shader_get_regtype(ins->src[2]);
DWORD dstreg = ins->dst[0].register_idx;
- DWORD dstregtype = shader_get_regtype(ins->dst[0].token);
+ DWORD dstregtype = ins->dst[0].register_type;
+ DWORD dst_mask = ins->dst[0].write_mask;
+ struct wined3d_shader_dst_param dst = ins->dst[0];
/* Cycle through all source0 channels */
for (i=0; i<4; i++) {
cmp_channel = WINED3DSP_WRITEMASK_0 << j;
}
}
+ dst.write_mask = dst_mask & write_mask;
/* Splitting the cmp instruction up in multiple lines imposes a problem:
* The first lines may overwrite source parameters of the following lines.
* Deal with that by using a temporary destination register if needed
*/
- if((src0reg == dstreg && src0regtype == dstregtype) ||
- (src1reg == dstreg && src1regtype == dstregtype) ||
- (src2reg == dstreg && src2regtype == dstregtype)) {
-
- write_mask = shader_glsl_get_write_mask(ins->dst[0].token & (~WINED3DSP_SWIZZLE_MASK | write_mask),
- mask_char);
+ if ((src0reg == dstreg && src0regtype == dstregtype)
+ || (src1reg == dstreg && src1regtype == dstregtype)
+ || (src2reg == dstreg && src2regtype == dstregtype))
+ {
+ write_mask = shader_glsl_get_write_mask(&dst, mask_char);
if (!write_mask) continue;
shader_addline(ins->buffer, "tmp0%s = (", mask_char);
temp_destination = TRUE;
} else {
- write_mask = shader_glsl_append_dst_ext(ins->buffer, ins,
- ins->dst[0].token & (~WINED3DSP_SWIZZLE_MASK | write_mask));
+ write_mask = shader_glsl_append_dst_ext(ins->buffer, ins, &dst);
if (!write_mask) continue;
}
}
if(temp_destination) {
- shader_glsl_get_write_mask(ins->dst[0].token, mask_char);
- shader_glsl_append_dst_ext(ins->buffer, ins, ins->dst[0].token);
+ shader_glsl_get_write_mask(&ins->dst[0], mask_char);
+ shader_glsl_append_dst(ins->buffer, ins);
shader_addline(ins->buffer, "tmp0%s);\n", mask_char);
}
}
* the compare is done per component of src0. */
static void shader_glsl_cnd(const struct wined3d_shader_instruction *ins)
{
+ struct wined3d_shader_dst_param dst;
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
DWORD write_mask, cmp_channel = 0;
unsigned int i, j;
+ DWORD dst_mask;
if (ins->reg_maps->shader_version < WINED3DPS_VERSION(1, 4))
{
return;
}
/* Cycle through all source0 channels */
+ dst_mask = ins->dst[0].write_mask;
+ dst = ins->dst[0];
for (i=0; i<4; i++) {
write_mask = 0;
/* Find the destination channels which use the current source0 channel */
cmp_channel = WINED3DSP_WRITEMASK_0 << j;
}
}
- write_mask = shader_glsl_append_dst_ext(ins->buffer, ins,
- ins->dst[0].token & (~WINED3DSP_SWIZZLE_MASK | write_mask));
+
+ dst.write_mask = dst_mask & write_mask;
+ write_mask = shader_glsl_append_dst_ext(ins->buffer, ins, &dst);
if (!write_mask) continue;
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], cmp_channel, &src0_param);
break;
}
+ tmp_dst = ins->dst[0];
for (i = 0; i < nComponents; ++i)
{
- tmp_dst.register_idx = ins->dst[0].register_idx;
- tmp_dst.token = ((ins->dst[0].token) & ~WINED3DSP_WRITEMASK_ALL) | (WINED3DSP_WRITEMASK_0 << i);
+ tmp_dst.write_mask = WINED3DSP_WRITEMASK_0 << i;
tmp_ins.src[1] = ins->src[1] + i;
shader_glsl_dot(&tmp_ins);
}
char dst_mask[6];
shader_glsl_append_dst(ins->buffer, ins);
- shader_glsl_get_write_mask(ins->dst[0].token, dst_mask);
+ shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_1, &src1_param);
char dst_mask[6];
shader_glsl_append_dst(ins->buffer, ins);
- shader_glsl_get_write_mask(ins->dst[0].token, dst_mask);
+ shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_1, &src0y_param);
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_2, &src0z_param);
if (shader_version < WINED3DPS_VERSION(1,4))
{
char coord_mask[6];
- shader_glsl_get_write_mask(mask, coord_mask);
+ shader_glsl_write_mask_to_str(mask, coord_mask);
shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL,
"T%u%s", sampler_idx, coord_mask);
} else {
{
/* FIXME: Make this work for more than just 2D textures */
SHADER_BUFFER *buffer = ins->buffer;
- DWORD write_mask;
- char dst_mask[6];
-
- write_mask = shader_glsl_append_dst(ins->buffer, ins);
- shader_glsl_get_write_mask(write_mask, dst_mask);
+ DWORD write_mask = shader_glsl_append_dst(ins->buffer, ins);
if (ins->reg_maps->shader_version != WINED3DPS_VERSION(1,4))
{
- DWORD reg = ins->dst[0].register_idx;
- shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n", reg, dst_mask);
+ char dst_mask[6];
+
+ shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
+ shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n",
+ ins->dst[0].register_idx, dst_mask);
} else {
DWORD reg = ins->src[0] & WINED3DSP_REGNUM_MASK;
DWORD src_mod = ins->src[0] & WINED3DSP_SRCMOD_MASK;
{
glsl_dst_param_t dst_param;
- shader_glsl_add_dst_param(ins, ins->dst[0].token, 0, &dst_param);
+ shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
/* Tests show that texdepth never returns anything below 0.0, and that r5.y is clamped to 1.0.
* Negative input is accepted, -0.25 / -0.5 returns 0.5. GL should clamp gl_FragDepth to [0;1], but
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
shader_glsl_append_dst(ins->buffer, ins);
- shader_glsl_get_write_mask(ins->dst[0].token, dst_mask);
+ shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
shader_addline(ins->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
current_state->current_row = 0;
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
mask = sample_function.coord_mask;
- shader_glsl_get_write_mask(mask, coord_mask);
+ shader_glsl_write_mask_to_str(mask, coord_mask);
/* with projective textures, texbem only divides the static texture coord, not the displacement,
* so we can't let the GL handle this.
case WINED3DTTFF_COUNT4:
case WINED3DTTFF_DISABLE: div_mask = WINED3DSP_WRITEMASK_3; break;
}
- shader_glsl_get_write_mask(div_mask, coord_div_mask);
+ shader_glsl_write_mask_to_str(div_mask, coord_div_mask);
shader_addline(ins->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
}
glsl_dst_param_t dst_param;
shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_2, &luminance_param);
- shader_glsl_add_dst_param(ins, ins->dst[0].token, ins->dst[0].addr_token, &dst_param);
+ shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
shader_addline(ins->buffer, "%s%s *= (%s * luminancescale%d + luminanceoffset%d);\n",
dst_param.reg_name, dst_param.mask_str,
glsl_dst_param_t dst_param;
/* The argument is a destination parameter, and no writemasks are allowed */
- shader_glsl_add_dst_param(ins, ins->dst[0].token, 0, &dst_param);
+ shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
if ((ins->reg_maps->shader_version >= WINED3DPS_VERSION(2,0)))
{
/* 2.0 shaders compare all 4 components in texkill */
}
}
-static void pshader_glsl_input_pack(SHADER_BUFFER* buffer, const struct semantic* semantics_in,
- IWineD3DPixelShader *iface, enum vertexprocessing_mode vertexprocessing)
+static void pshader_glsl_input_pack(IWineD3DPixelShader *iface, SHADER_BUFFER *buffer,
+ const struct wined3d_shader_semantic *semantics_in, const struct shader_reg_maps *reg_maps,
+ enum vertexprocessing_mode vertexprocessing)
{
- unsigned int i;
- IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
+ unsigned int i;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
+
+ for (i = 0; i < MAX_REG_INPUT; ++i)
+ {
+ DWORD usage, usage_idx;
+ char reg_mask[6];
- for (i = 0; i < MAX_REG_INPUT; i++) {
+ /* Unused */
+ if (!reg_maps->packed_input[i]) continue;
- DWORD usage_token = semantics_in[i].usage;
- DWORD register_token = semantics_in[i].reg;
- DWORD usage, usage_idx;
- char reg_mask[6];
+ usage = semantics_in[i].usage;
+ usage_idx = semantics_in[i].usage_idx;
+ shader_glsl_get_write_mask(&semantics_in[i].reg, reg_mask);
- /* Uninitialized */
- if (!usage_token) continue;
- usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
- usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
- shader_glsl_get_write_mask(register_token, reg_mask);
+ switch (usage)
+ {
+ case WINED3DDECLUSAGE_TEXCOORD:
+ if (usage_idx < 8 && vertexprocessing == pretransformed)
+ shader_addline(buffer, "IN[%u]%s = gl_TexCoord[%u]%s;\n",
+ This->input_reg_map[i], reg_mask, usage_idx, reg_mask);
+ else
+ shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
+ This->input_reg_map[i], reg_mask, reg_mask);
+ break;
- switch(usage) {
+ case WINED3DDECLUSAGE_COLOR:
+ if (usage_idx == 0)
+ shader_addline(buffer, "IN[%u]%s = vec4(gl_Color)%s;\n",
+ This->input_reg_map[i], reg_mask, reg_mask);
+ else if (usage_idx == 1)
+ shader_addline(buffer, "IN[%u]%s = vec4(gl_SecondaryColor)%s;\n",
+ This->input_reg_map[i], reg_mask, reg_mask);
+ else
+ shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
+ This->input_reg_map[i], reg_mask, reg_mask);
+ break;
- case WINED3DDECLUSAGE_TEXCOORD:
- if(usage_idx < 8 && vertexprocessing == pretransformed) {
- shader_addline(buffer, "IN[%u]%s = gl_TexCoord[%u]%s;\n",
- This->input_reg_map[i], reg_mask, usage_idx, reg_mask);
- } else {
- shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
- This->input_reg_map[i], reg_mask, reg_mask);
- }
- break;
-
- case WINED3DDECLUSAGE_COLOR:
- if (usage_idx == 0)
- shader_addline(buffer, "IN[%u]%s = vec4(gl_Color)%s;\n",
- This->input_reg_map[i], reg_mask, reg_mask);
- else if (usage_idx == 1)
- shader_addline(buffer, "IN[%u]%s = vec4(gl_SecondaryColor)%s;\n",
- This->input_reg_map[i], reg_mask, reg_mask);
- else
- shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
- This->input_reg_map[i], reg_mask, reg_mask);
- break;
-
- default:
- shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
- This->input_reg_map[i], reg_mask, reg_mask);
+ default:
+ shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
+ This->input_reg_map[i], reg_mask, reg_mask);
+ break;
}
}
}
HeapFree(GetProcessHeap(), 0, entry);
}
-static void handle_ps3_input(SHADER_BUFFER *buffer, const struct semantic *semantics_in,
- const struct semantic *semantics_out, const WineD3D_GL_Info *gl_info, const DWORD *map)
+static void handle_ps3_input(SHADER_BUFFER *buffer, const WineD3D_GL_Info *gl_info, const DWORD *map,
+ const struct wined3d_shader_semantic *semantics_in, const struct shader_reg_maps *reg_maps_in,
+ const struct wined3d_shader_semantic *semantics_out, const struct shader_reg_maps *reg_maps_out)
{
unsigned int i, j;
- DWORD usage_token, usage_token_out;
- DWORD register_token, register_token_out;
DWORD usage, usage_idx, usage_out, usage_idx_out;
DWORD *set;
DWORD in_idx;
}
for(i = 0; i < MAX_REG_INPUT; i++) {
- usage_token = semantics_in[i].usage;
- if (!usage_token) continue;
+ if (!reg_maps_in->packed_input[i]) continue;
in_idx = map[i];
if (in_idx >= (in_count + 2)) {
sprintf(destination, "IN[%u]", in_idx);
}
- register_token = semantics_in[i].reg;
-
- usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
- usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
- set[map[i]] = shader_glsl_get_write_mask(register_token, reg_mask);
+ usage = semantics_in[i].usage;
+ usage_idx = semantics_in[i].usage_idx;
+ set[map[i]] = shader_glsl_get_write_mask(&semantics_in[i].reg, reg_mask);
if(!semantics_out) {
switch(usage) {
} else {
BOOL found = FALSE;
for(j = 0; j < MAX_REG_OUTPUT; j++) {
- usage_token_out = semantics_out[j].usage;
- if (!usage_token_out) continue;
- register_token_out = semantics_out[j].reg;
+ if (!reg_maps_out->packed_output[j]) continue;
- usage_out = (usage_token_out & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
- usage_idx_out = (usage_token_out & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
- shader_glsl_get_write_mask(register_token_out, reg_mask_out);
+ usage_out = semantics_out[j].usage;
+ usage_idx_out = semantics_out[j].usage_idx;
+ shader_glsl_get_write_mask(&semantics_out[j].reg, reg_mask_out);
if(usage == usage_out &&
usage_idx == usage_idx_out) {
DWORD ps_major = ps ? WINED3DSHADER_VERSION_MAJOR(ps->baseShader.reg_maps.shader_version) : 0;
unsigned int i;
SHADER_BUFFER buffer;
- DWORD usage_token;
- DWORD register_token;
DWORD usage, usage_idx, writemask;
char reg_mask[6];
- const struct semantic *semantics_out, *semantics_in;
+ const struct wined3d_shader_semantic *semantics_out;
shader_buffer_init(&buffer);
shader_addline(&buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
for(i = 0; i < MAX_REG_OUTPUT; i++) {
- usage_token = semantics_out[i].usage;
- if (!usage_token) continue;
- register_token = semantics_out[i].reg;
+ if (!vs->baseShader.reg_maps.packed_output[i]) continue;
- usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
- usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
- writemask = shader_glsl_get_write_mask(register_token, reg_mask);
+ usage = semantics_out[i].usage;
+ usage_idx = semantics_out[i].usage_idx;
+ writemask = shader_glsl_get_write_mask(&semantics_out[i].reg, reg_mask);
switch(usage) {
case WINED3DDECLUSAGE_COLOR:
} else if(ps_major >= 3 && vs_major >= 3) {
semantics_out = vs->semantics_out;
- semantics_in = ps->semantics_in;
/* This one is tricky: a 3.0 pixel shader reads from a 3.0 vertex shader */
shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
/* First, sort out position and point size. Those are not passed to the pixel shader */
for(i = 0; i < MAX_REG_OUTPUT; i++) {
- usage_token = semantics_out[i].usage;
- if (!usage_token) continue;
- register_token = semantics_out[i].reg;
+ if (!vs->baseShader.reg_maps.packed_output[i]) continue;
- usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
- usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
- shader_glsl_get_write_mask(register_token, reg_mask);
+ usage = semantics_out[i].usage;
+ usage_idx = semantics_out[i].usage_idx;
+ shader_glsl_get_write_mask(&semantics_out[i].reg, reg_mask);
switch(usage) {
case WINED3DDECLUSAGE_POSITION:
}
/* Then, fix the pixel shader input */
- handle_ps3_input(&buffer, semantics_in, semantics_out, gl_info, ps->input_reg_map);
+ handle_ps3_input(&buffer, gl_info, ps->input_reg_map,
+ ps->semantics_in, &ps->baseShader.reg_maps, semantics_out, &vs->baseShader.reg_maps);
shader_addline(&buffer, "}\n");
} else if(ps_major >= 3 && vs_major < 3) {
- semantics_in = ps->semantics_in;
-
shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
shader_addline(&buffer, "void order_ps_input() {\n");
/* The vertex shader wrote to the builtin varyings. There is no need to figure out position and
* point size, but we depend on the optimizers kindness to find out that the pixel shader doesn't
* read gl_TexCoord and gl_ColorX, otherwise we'll run out of varyings
*/
- handle_ps3_input(&buffer, semantics_in, NULL, gl_info, ps->input_reg_map);
+ handle_ps3_input(&buffer, gl_info, ps->input_reg_map, ps->semantics_in, &ps->baseShader.reg_maps, NULL, NULL);
shader_addline(&buffer, "}\n");
} else {
ERR("Unexpected vertex and pixel shader version condition: vs: %d, ps: %d\n", vs_major, ps_major);
}
}
- if (use_ps && ps_compile_args.texrect_fixup) {
+ if (use_ps && ps_compile_args.np2_fixup) {
char name[32];
for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
- if (ps_compile_args.texrect_fixup & (1 << i)) {
- sprintf(name, "PsamplerRectFixup%u", i);
- entry->rectFixup_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
+ if (ps_compile_args.np2_fixup & (1 << i)) {
+ sprintf(name, "PsamplerNP2Fixup%u", i);
+ entry->np2Fixup_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
} else {
- entry->rectFixup_location[i] = -1;
+ entry->np2Fixup_location[i] = -1;
}
}
}
if(pshader) {
ps = (IWineD3DPixelShaderImpl *) This;
if(ps->num_gl_shaders == 0) return;
+ if (priv->glsl_program && (IWineD3DBaseShader *)priv->glsl_program->pshader == iface)
+ shader_glsl_select(This->baseShader.device, FALSE, FALSE);
} else {
vs = (IWineD3DVertexShaderImpl *) This;
if(vs->num_gl_shaders == 0) return;
+ if (priv->glsl_program && (IWineD3DBaseShader *)priv->glsl_program->vshader == iface)
+ shader_glsl_select(This->baseShader.device, FALSE, FALSE);
}
linked_programs = &This->baseShader.linked_programs;
/* Pack 3.0 inputs */
if (reg_maps->shader_version >= WINED3DPS_VERSION(3,0) && args->vp_mode != vertexshader) {
- pshader_glsl_input_pack(buffer, This->semantics_in, iface, args->vp_mode);
+ pshader_glsl_input_pack(iface, buffer, This->semantics_in, reg_maps, args->vp_mode);
}
/* Base Shader Body */
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->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
+ /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
+ pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF) - (MAX_CONST_B / 4) - MAX_CONST_I - 1;
/* Older DX9-class videocards (GeforceFX / Radeon >9500/X*00) only support pixel shader 2.0/2.0a/2.0b.
* In OpenGL the extensions related to GLSL abstract lowlevel GL info away which is needed
else
pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
+ /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
+ * In theory the texbem instruction may need one more shader constant too. But lets assume
+ * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
+ * and lets not take away a uniform needlessly from all other shaders.
+ */
+ pCaps->MaxPixelShaderConst = GL_LIMITS(pshader_constantsF) - (MAX_CONST_B / 4) - MAX_CONST_I - 2;
+
/* FIXME: The following line is card dependent. -8.0 to 8.0 is the
* Direct3D minimum requirement.
*
shader_glsl_update_float_vertex_constants,
shader_glsl_update_float_pixel_constants,
shader_glsl_load_constants,
+ shader_glsl_load_np2fixup_constants,
shader_glsl_destroy,
shader_glsl_alloc,
shader_glsl_free,
memset(args, 0, sizeof(*args)); /* FIXME: Make sure all bits are set */
args->srgb_correction = stateblock->renderState[WINED3DRS_SRGBWRITEENABLE] ? 1 : 0;
- args->texrect_fixup = 0;
+ args->np2_fixup = 0;
for(i = 0; i < MAX_FRAGMENT_SAMPLERS; i++) {
if(shader->baseShader.reg_maps.samplers[i] == 0) continue;
/* Flag samplers that need NP2 texcoord fixup. */
if(!tex->baseTexture.pow2Matrix_identity) {
- args->texrect_fixup |= (1 << i);
+ args->np2_fixup |= (1 << i);
}
}
if (shader->baseShader.reg_maps.shader_version >= WINED3DPS_VERSION(3,0))
/* Trigger shader constant reloading (for NP2 texcoord fixup)
* Only do this if pshaders are used (note: fixup is currently only implemented in GLSL). */
- if (!tex_impl->baseTexture.pow2Matrix_identity && use_ps(stateblock)) {
+ if (!tex_impl->baseTexture.pow2Matrix_identity) {
IWineD3DDeviceImpl* d3ddevice = stateblock->wineD3DDevice;
- /* FIXME: add something like shader_load_rectfixup_consts to the backend to only reload the
- * constants that are used for the fixup (and not the other ones too) */
- d3ddevice->shader_backend->shader_load_constants((IWineD3DDevice*)d3ddevice, use_ps(stateblock), use_vs(stateblock));
+ d3ddevice->shader_backend->shader_load_np2fixup_constants(
+ (IWineD3DDevice*)d3ddevice, use_ps(stateblock), use_vs(stateblock));
}
} else if(mapped_stage < GL_LIMITS(textures)) {
if(sampler < stateblock->lowest_disabled_stage) {
if(stateblock->streamIsUP || stateblock->pIndexData == NULL ) {
GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
} else {
- IWineD3DIndexBufferImpl *ib = (IWineD3DIndexBufferImpl *) stateblock->pIndexData;
- GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib->vbo));
+ struct wined3d_buffer *ib = (struct wined3d_buffer *) stateblock->pIndexData;
+ GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib->buffer_object));
}
}
Dest->vertexShader = This->vertexShader;
Dest->streamIsUP = This->streamIsUP;
Dest->pIndexData = This->pIndexData;
+ Dest->IndexFmt = This->IndexFmt;
Dest->baseVertexIndex = This->baseVertexIndex;
/* Dest->lights = This->lights; */
Dest->clip_status = This->clip_status;
}
}
}
- if(This->pIndexData) IWineD3DIndexBuffer_Release(This->pIndexData);
+ if(This->pIndexData) IWineD3DBuffer_Release(This->pIndexData);
if(This->vertexShader) IWineD3DVertexShader_Release(This->vertexShader);
if(This->pixelShader) IWineD3DPixelShader_Release(This->pixelShader);
if (This->changed.primitive_type) This->gl_primitive_type = targetStateBlock->gl_primitive_type;
if (This->changed.indices && ((This->pIndexData != targetStateBlock->pIndexData)
- || (This->baseVertexIndex != targetStateBlock->baseVertexIndex))) {
+ || (This->baseVertexIndex != targetStateBlock->baseVertexIndex)
+ || (This->IndexFmt != targetStateBlock->IndexFmt))) {
TRACE("Updating pIndexData to %p, baseVertexIndex to %d\n",
targetStateBlock->pIndexData, targetStateBlock->baseVertexIndex);
- if(targetStateBlock->pIndexData) IWineD3DIndexBuffer_AddRef(targetStateBlock->pIndexData);
- if(This->pIndexData) IWineD3DIndexBuffer_Release(This->pIndexData);
+ if(targetStateBlock->pIndexData) IWineD3DBuffer_AddRef(targetStateBlock->pIndexData);
+ if(This->pIndexData) IWineD3DBuffer_Release(This->pIndexData);
This->pIndexData = targetStateBlock->pIndexData;
This->baseVertexIndex = targetStateBlock->baseVertexIndex;
+ This->IndexFmt = targetStateBlock->IndexFmt;
}
if(This->changed.vertexDecl && This->vertexDecl != targetStateBlock->vertexDecl){
memcpy(This->samplerState, targetStateBlock->samplerState, sizeof(This->samplerState));
This->scissorRect = targetStateBlock->scissorRect;
- if(targetStateBlock->pIndexData != This->pIndexData) {
- if (targetStateBlock->pIndexData) IWineD3DIndexBuffer_AddRef(targetStateBlock->pIndexData);
- if (This->pIndexData) IWineD3DIndexBuffer_Release(This->pIndexData);
+ if(targetStateBlock->pIndexData != This->pIndexData ||
+ targetStateBlock->IndexFmt != This->IndexFmt) {
+ if (targetStateBlock->pIndexData) IWineD3DBuffer_AddRef(targetStateBlock->pIndexData);
+ if (This->pIndexData) IWineD3DBuffer_Release(This->pIndexData);
This->pIndexData = targetStateBlock->pIndexData;
+ This->IndexFmt = targetStateBlock->IndexFmt;
}
for(i = 0; i < MAX_STREAMS; i++) {
if(targetStateBlock->streamSource[i] != This->streamSource[i]) {
}
if (This->changed.indices) {
- IWineD3DDevice_SetIndices(pDevice, This->pIndexData);
+ IWineD3DDevice_SetIndices(pDevice, This->pIndexData, This->IndexFmt);
IWineD3DDevice_SetBaseVertexIndex(pDevice, This->baseVertexIndex);
}
IWineD3DDevice_SetTransform(pDevice, i, &This->transforms[i]);
}
This->wineD3DDevice->updateStateBlock->gl_primitive_type = This->gl_primitive_type;
- IWineD3DDevice_SetIndices(pDevice, This->pIndexData);
+ IWineD3DDevice_SetIndices(pDevice, This->pIndexData, This->IndexFmt);
IWineD3DDevice_SetBaseVertexIndex(pDevice, This->baseVertexIndex);
IWineD3DDevice_SetVertexDeclaration(pDevice, This->vertexDecl);
IWineD3DDevice_SetMaterial(pDevice, &This->material);
RES_TO_STR(WINED3DRTYPE_TEXTURE);
RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
- RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
- RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
RES_TO_STR(WINED3DRTYPE_BUFFER);
#undef RES_TO_STR
default:
unsigned int regnum,
BYTE usage, BYTE usage_idx) {
- /* Fake usage: set reserved bit, usage, usage_idx */
- DWORD usage_token = (0x1 << 31) |
- (usage << WINED3DSP_DCL_USAGE_SHIFT) | (usage_idx << WINED3DSP_DCL_USAGEINDEX_SHIFT);
-
- /* Fake register; set reserved bit, regnum, type: input, wmask: all */
- DWORD reg_token = (0x1 << 31) |
- WINED3DSP_WRITEMASK_ALL | (WINED3DSPR_INPUT << WINED3DSP_REGTYPE_SHIFT) | regnum;
-
- This->semantics_in[regnum].usage = usage_token;
- This->semantics_in[regnum].reg = reg_token;
+ This->semantics_in[regnum].usage = usage;
+ This->semantics_in[regnum].usage_idx = usage_idx;
+ This->semantics_in[regnum].reg.register_type = WINED3DSPR_INPUT;
+ This->semantics_in[regnum].reg.register_idx = regnum;
+ This->semantics_in[regnum].reg.write_mask = WINED3DSP_WRITEMASK_ALL;
+ This->semantics_in[regnum].reg.modifiers = 0;
+ This->semantics_in[regnum].reg.shift = 0;
+ This->semantics_in[regnum].reg.has_rel_addr = FALSE;
+ This->semantics_in[regnum].reg.addr_token = 0;
}
static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2) {
int i;
for (i = 0; i < MAX_ATTRIBS; i++) {
- DWORD usage_token = This->semantics_in[i].usage;
- DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
- DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
+ if (!This->baseShader.reg_maps.attributes[i]) continue;
- if (usage_token && match_usage(usage, usage_idx, usage_req, usage_idx_req)) {
+ if (match_usage(This->semantics_in[i].usage,
+ This->semantics_in[i].usage_idx, usage_req, usage_idx_req))
+ {
*regnum = i;
return TRUE;
}
CARD_NVIDIA_GEFORCE_8600GT = 0x0402,
CARD_NVIDIA_GEFORCE_8600MGT = 0x0407,
CARD_NVIDIA_GEFORCE_8800GTS = 0x0193,
+ CARD_NVIDIA_GEFORCE_9200 = 0x086d,
+ CARD_NVIDIA_GEFORCE_9400GT = 0x042c,
+ CARD_NVIDIA_GEFORCE_9500GT = 0x0640,
CARD_NVIDIA_GEFORCE_9600GT = 0x0622,
CARD_NVIDIA_GEFORCE_9800GT = 0x0614,
+ CARD_NVIDIA_GEFORCE_GTX260 = 0x05e2,
+ CARD_NVIDIA_GEFORCE_GTX275 = 0x05e6,
CARD_NVIDIA_GEFORCE_GTX280 = 0x05e1,
CARD_INTEL_845G = 0x2562,
UINT vidmem;
DWORD driver_version;
DWORD driver_version_hipart;
+ CHAR driver_description[255];
CHAR gl_renderer[255];
/**
* CAPS Constants
WINED3DSIH_TABLE_SIZE
};
-typedef struct semantic
-{
- DWORD usage;
- DWORD reg;
-} semantic;
-
typedef struct shader_reg_maps
{
DWORD shader_version;
struct wined3d_shader_dst_param
{
+ WINED3DSHADER_PARAM_REGISTER_TYPE register_type;
UINT register_idx;
- DWORD token;
+ DWORD write_mask;
+ DWORD modifiers;
+ DWORD shift;
+ BOOL has_rel_addr;
DWORD addr_token;
};
UINT src_count;
};
+struct wined3d_shader_semantic
+{
+ WINED3DDECLUSAGE usage;
+ UINT usage_idx;
+ struct wined3d_shader_dst_param reg;
+};
+
typedef void (*SHADER_HANDLER)(const struct wined3d_shader_instruction *);
struct shader_caps {
DWORD PixelShaderVersion;
float PixelShader1xMaxValue;
+ DWORD MaxPixelShaderConst;
WINED3DVSHADERCAPS2_0 VS20Caps;
WINED3DPSHADERCAPS2_0 PS20Caps;
/* Projected textures(ps 1.0-1.3) */
/* Texture types(2D, Cube, 3D) in ps 1.x */
BOOL srgb_correction;
- WORD texrect_fixup;
- /* Bitmap for texture rect coord fixups (16 samplers max currently).
+ WORD np2_fixup;
+ /* Bitmap for NP2 texcoord fixups (16 samplers max currently).
D3D9 has a limit of 16 samplers and the fixup is superfluous
in D3D10 (unconditional NP2 support mandatory). */
};
void (*shader_update_float_vertex_constants)(IWineD3DDevice *iface, UINT start, UINT count);
void (*shader_update_float_pixel_constants)(IWineD3DDevice *iface, UINT start, UINT count);
void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
+ void (*shader_load_np2fixup_constants)(IWineD3DDevice *iface, char usePS, char useVS);
void (*shader_destroy)(IWineD3DBaseShader *iface);
HRESULT (*shader_alloc_private)(IWineD3DDevice *iface);
void (*shader_free_private)(IWineD3DDevice *iface);
const struct blit_shader *blitter;
unsigned int max_ffp_textures, max_ffp_texture_stages;
+ DWORD d3d_vshader_constantF, d3d_pshader_constantF; /* Advertised d3d caps, not GL ones */
WORD view_ident : 1; /* true iff view matrix is identity */
WORD untransformed : 1;
/* Tests show that the start address of resources is 32 byte aligned */
#define RESOURCE_ALIGNMENT 32
-/*****************************************************************************
- * IWineD3DIndexBuffer implementation structure (extends IWineD3DResourceImpl)
- */
-typedef struct IWineD3DIndexBufferImpl
-{
- /* IUnknown & WineD3DResource Information */
- const IWineD3DIndexBufferVtbl *lpVtbl;
- IWineD3DResourceClass resource;
-
- GLuint vbo;
- UINT dirtystart, dirtyend;
- LONG lockcount;
-
- /* WineD3DVertexBuffer specifics */
-} IWineD3DIndexBufferImpl;
-
-extern const IWineD3DIndexBufferVtbl IWineD3DIndexBuffer_Vtbl;
-
/*****************************************************************************
* IWineD3DBaseTexture D3D- > openGL state map lookups
*/
UINT streamFlags[MAX_STREAMS + 1]; /*0 | WINED3DSTREAMSOURCE_INSTANCEDATA | WINED3DSTREAMSOURCE_INDEXEDDATA */
/* Indices */
- IWineD3DIndexBuffer* pIndexData;
+ IWineD3DBuffer* pIndexData;
+ WINED3DFORMAT IndexFmt;
INT baseVertexIndex;
INT loadBaseVertexIndex; /* non-indexed drawing needs 0 here, indexed baseVertexIndex */
#define WINED3D_BUFFER_DIRTY 0x02 /* Buffer data has been modified */
#define WINED3D_BUFFER_HASDESC 0x04 /* A vertex description has been found */
#define WINED3D_BUFFER_CREATEBO 0x08 /* Attempt to create a buffer object next PreLoad */
+#define WINED3D_BUFFER_DOUBLEBUFFER 0x10 /* Use a vbo and local allocated memory */
struct wined3d_buffer
{
GLuint buffer_object;
GLenum buffer_object_usage;
+ GLenum buffer_type_hint;
UINT buffer_object_size;
LONG bind_count;
DWORD flags;
UINT dirty_end;
LONG lock_count;
- /* legacy vertex buffers */
- DWORD fvf;
-
/* conversion stuff */
UINT conversion_count;
UINT draw_count;
extern const IWineD3DBufferVtbl wined3d_buffer_vtbl;
const BYTE *buffer_get_memory(IWineD3DBuffer *iface, UINT offset, GLuint *buffer_object);
+const BYTE *buffer_get_sysmem(struct wined3d_buffer *This);
/* IWineD3DRendertargetView */
struct wined3d_rendertarget_view
void shader_buffer_free(struct SHADER_BUFFER *buffer);
void shader_cleanup(IWineD3DBaseShader *iface);
HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, struct shader_reg_maps *reg_maps,
- struct semantic *semantics_in, struct semantic *semantics_out, const DWORD *byte_code);
+ struct wined3d_shader_semantic *semantics_in, struct wined3d_shader_semantic *semantics_out,
+ const DWORD *byte_code);
void shader_init(struct IWineD3DBaseShaderClass *shader,
IWineD3DDevice *device, const SHADER_OPCODE *instruction_table);
void shader_trace_init(const DWORD *byte_code, const SHADER_OPCODE *opcode_table);
return WINED3DSIO_COMMENT == (token & WINED3DSI_OPCODE_MASK);
}
-static inline BOOL shader_is_scalar(DWORD param) {
- DWORD reg_type = shader_get_regtype(param);
- DWORD reg_num;
-
- switch (reg_type) {
+static inline BOOL shader_is_scalar(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx)
+{
+ switch (register_type)
+ {
case WINED3DSPR_RASTOUT:
- if ((param & WINED3DSP_REGNUM_MASK) != 0) {
- /* oFog & oPts */
- return TRUE;
- }
+ /* oFog & oPts */
+ if (register_idx != 0) return TRUE;
/* oPos */
return FALSE;
return TRUE;
case WINED3DSPR_MISCTYPE:
- reg_num = param & WINED3DSP_REGNUM_MASK;
- switch(reg_num) {
+ switch(register_idx)
+ {
case 0: /* vPos */
return FALSE;
case 1: /* vFace */
UINT num_gl_shaders, shader_array_size;
/* Vertex shader input and output semantics */
- semantic semantics_in [MAX_ATTRIBS];
- semantic semantics_out [MAX_REG_OUTPUT];
+ struct wined3d_shader_semantic semantics_in[MAX_ATTRIBS];
+ struct wined3d_shader_semantic semantics_out[MAX_REG_OUTPUT];
UINT min_rel_offset, max_rel_offset;
UINT rel_offset;
IUnknown *parent;
/* Pixel shader input semantics */
- semantic semantics_in [MAX_REG_INPUT];
+ struct wined3d_shader_semantic semantics_in[MAX_REG_INPUT];
DWORD input_reg_map[MAX_REG_INPUT];
BOOL input_reg_used[MAX_REG_INPUT];
int declared_in_count;
WINED3DRTYPE_TEXTURE = 3,
WINED3DRTYPE_VOLUMETEXTURE = 4,
WINED3DRTYPE_CUBETEXTURE = 5,
- WINED3DRTYPE_VERTEXBUFFER = 6,
- WINED3DRTYPE_INDEXBUFFER = 7,
- WINED3DRTYPE_BUFFER = 8,
+ WINED3DRTYPE_BUFFER = 6,
WINED3DRTYPE_FORCE_DWORD = 0x7fffffff
} WINED3DRESOURCETYPE;
-const UINT WINED3DRTYPECOUNT = WINED3DRTYPE_INDEXBUFFER + 1;
+const UINT WINED3DRTYPECOUNT = WINED3DRTYPE_BUFFER + 1;
typedef enum _WINED3DPOOL
{
non user modifiable (only valid if OptMethod==1) */
} WINED3DDEVINFO_VCACHE;
-typedef struct _WINED3DVERTEXBUFFER_DESC
+typedef struct _WINED3DBUFFER_DESC
{
- WINED3DFORMAT Format;
- WINED3DRESOURCETYPE Type;
- DWORD Usage;
- WINED3DPOOL Pool;
- UINT Size;
- DWORD FVF;
-} WINED3DVERTEXBUFFER_DESC;
-
-typedef struct _WINED3DINDEXBUFFER_DESC
-{
- WINED3DFORMAT Format;
WINED3DRESOURCETYPE Type;
DWORD Usage;
WINED3DPOOL Pool;
UINT Size;
-} WINED3DINDEXBUFFER_DESC;
+} WINED3DBUFFER_DESC;
typedef struct glDescriptor
{
);
}
-[
- object,
- local,
- uuid(3a02a54e-6f30-11d9-c687-00046142c14f)
-]
-interface IWineD3DIndexBuffer : IWineD3DResource
-{
- HRESULT Lock(
- [in] UINT offset,
- [in] UINT size,
- [out] BYTE **data,
- [in] DWORD flags
- );
- HRESULT Unlock(
- );
- HRESULT GetDesc(
- [out] WINED3DINDEXBUFFER_DESC *desc
- );
-}
-
[
object,
local,
HRESULT Unmap(
);
HRESULT GetDesc(
- [out] WINED3DVERTEXBUFFER_DESC *desc
+ [out] WINED3DBUFFER_DESC *desc
);
}
HRESULT CreateIndexBuffer(
[in] UINT length,
[in] DWORD usage,
- [in] WINED3DFORMAT format,
[in] WINED3DPOOL pool,
- [out] IWineD3DIndexBuffer **index_buffer,
+ [out] IWineD3DBuffer **index_buffer,
[in] HANDLE *shared_handle,
[in] IUnknown *parent
);
[out] WINED3DGAMMARAMP *ramp
);
HRESULT SetIndices(
- [in] IWineD3DIndexBuffer *index_buffer
+ [in] IWineD3DBuffer *index_buffer,
+ [in] WINED3DFORMAT format
);
HRESULT GetIndices(
- [out] IWineD3DIndexBuffer **index_buffer
+ [out] IWineD3DBuffer **index_buffer
);
HRESULT SetBaseVertexIndex(
[in] INT base_index
[in] UINT vertex_count,
[in] IWineD3DBuffer *dest_buffer,
[in] IWineD3DVertexDeclaration *declaration,
- [in] DWORD flags
+ [in] DWORD flags,
+ [in] DWORD DestFVF
);
HRESULT BeginStateBlock(
);
projects / reactos.git / commitdiff