// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
|
#include "Direct3DDevice9.hpp"
|
|
#include "Direct3D9.hpp"
|
#include "Direct3DSurface9.hpp"
|
#include "Direct3DIndexBuffer9.hpp"
|
#include "Direct3DVertexBuffer9.hpp"
|
#include "Direct3DTexture9.hpp"
|
#include "Direct3DVolumeTexture9.hpp"
|
#include "Direct3DCubeTexture9.hpp"
|
#include "Direct3DVertexDeclaration9.hpp"
|
#include "Direct3DSwapChain9.hpp"
|
#include "Direct3DPixelShader9.hpp"
|
#include "Direct3DVertexShader9.hpp"
|
#include "Direct3DStateBlock9.hpp"
|
#include "Direct3DQuery9.hpp"
|
#include "Direct3DVolume9.hpp"
|
|
#include "Debug.hpp"
|
#include "Capabilities.hpp"
|
#include "Math.hpp"
|
#include "Renderer.hpp"
|
#include "Config.hpp"
|
#include "FrameBuffer.hpp"
|
#include "Clipper.hpp"
|
#include "Configurator.hpp"
|
#include "Timer.hpp"
|
#include "Resource.hpp"
|
|
#include <assert.h>
|
|
bool localShaderConstants = true;
|
|
namespace D3D9
|
{
|
inline unsigned long FtoDW(float f)
|
{
|
return (unsigned long&)f;
|
}
|
|
Direct3DDevice9::Direct3DDevice9(const HINSTANCE instance, Direct3D9 *d3d9, unsigned int adapter, D3DDEVTYPE deviceType, HWND focusWindow, unsigned long behaviourFlags, D3DPRESENT_PARAMETERS *presentParameters) : instance(instance), adapter(adapter), d3d9(d3d9), deviceType(deviceType), focusWindow(focusWindow), behaviourFlags(behaviourFlags)
|
{
|
InitializeCriticalSection(&criticalSection);
|
|
init = true;
|
stateRecorder = 0;
|
|
d3d9->AddRef();
|
|
context = new sw::Context();
|
renderer = new sw::Renderer(context, sw::Direct3D, false);
|
|
swapChain = 0;
|
depthStencil = 0;
|
autoDepthStencil = 0;
|
renderTarget[0] = 0;
|
renderTarget[1] = 0;
|
renderTarget[2] = 0;
|
renderTarget[3] = 0;
|
|
for(int i = 0; i < 16 + 4; i++)
|
{
|
texture[i] = 0;
|
}
|
|
cursor = 0;
|
|
Reset(presentParameters);
|
|
pixelShader = 0;
|
vertexShader = 0;
|
|
lightsDirty = true;
|
pixelShaderDirty = true;
|
pixelShaderConstantsBDirty = 0;
|
pixelShaderConstantsFDirty = 0;
|
pixelShaderConstantsIDirty = 0;
|
vertexShaderDirty = true;
|
vertexShaderConstantsBDirty = 0;
|
vertexShaderConstantsFDirty = 0;
|
vertexShaderConstantsIDirty = 0;
|
|
for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
|
{
|
dataStream[i] = 0;
|
streamStride[i] = 0;
|
streamOffset[i] = 0;
|
|
streamSourceFreq[i] = 1;
|
}
|
|
indexData = 0;
|
vertexDeclaration = 0;
|
|
D3DMATERIAL9 material;
|
|
material.Diffuse.r = 1.0f;
|
material.Diffuse.g = 1.0f;
|
material.Diffuse.b = 1.0f;
|
material.Diffuse.a = 0.0f;
|
material.Ambient.r = 0.0f;
|
material.Ambient.g = 0.0f;
|
material.Ambient.b = 0.0f;
|
material.Ambient.a = 0.0f;
|
material.Emissive.r = 0.0f;
|
material.Emissive.g = 0.0f;
|
material.Emissive.b = 0.0f;
|
material.Emissive.a = 0.0f;
|
material.Specular.r = 0.0f;
|
material.Specular.g = 0.0f;
|
material.Specular.b = 0.0f;
|
material.Specular.a = 0.0f;
|
material.Power = 0.0f;
|
|
SetMaterial(&material);
|
|
D3DMATRIX identity = {1, 0, 0, 0,
|
0, 1, 0, 0,
|
0, 0, 1, 0,
|
0, 0, 0, 1};
|
|
SetTransform(D3DTS_VIEW, &identity);
|
SetTransform(D3DTS_PROJECTION, &identity);
|
SetTransform(D3DTS_TEXTURE0, &identity);
|
SetTransform(D3DTS_TEXTURE1, &identity);
|
SetTransform(D3DTS_TEXTURE2, &identity);
|
SetTransform(D3DTS_TEXTURE3, &identity);
|
SetTransform(D3DTS_TEXTURE4, &identity);
|
SetTransform(D3DTS_TEXTURE5, &identity);
|
SetTransform(D3DTS_TEXTURE6, &identity);
|
SetTransform(D3DTS_TEXTURE7, &identity);
|
|
for(int i = 0; i < 12; i++)
|
{
|
SetTransform(D3DTS_WORLDMATRIX(i), &identity);
|
}
|
|
for(int i = 0; i < MAX_PIXEL_SHADER_CONST; i++)
|
{
|
float zero[4] = {0, 0, 0, 0};
|
|
SetPixelShaderConstantF(i, zero, 1);
|
}
|
|
for(int i = 0; i < MAX_VERTEX_SHADER_CONST; i++)
|
{
|
float zero[4] = {0, 0, 0, 0};
|
|
SetVertexShaderConstantF(i, zero, 1);
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
int zero[4] = {0, 0, 0, 0};
|
|
SetPixelShaderConstantI(i, zero, 1);
|
SetVertexShaderConstantI(i, zero, 1);
|
SetPixelShaderConstantB(i, &zero[0], 1);
|
SetVertexShaderConstantB(i, &zero[0], 1);
|
}
|
|
init = false;
|
|
if(!(behaviourFlags & D3DCREATE_FPU_PRESERVE))
|
{
|
configureFPU();
|
}
|
|
instancingEnabled = pixelShaderVersionX >= D3DPS_VERSION(3, 0);
|
}
|
|
Direct3DDevice9::~Direct3DDevice9()
|
{
|
delete renderer;
|
renderer = 0;
|
delete context;
|
context = 0;
|
|
d3d9->Release();
|
d3d9 = 0;
|
|
swapChain->unbind();
|
swapChain = 0;
|
|
if(depthStencil)
|
{
|
depthStencil->unbind();
|
depthStencil = 0;
|
}
|
|
if(autoDepthStencil)
|
{
|
autoDepthStencil->unbind();
|
autoDepthStencil = 0;
|
}
|
|
for(int index = 0; index < 4; index++)
|
{
|
if(renderTarget[index])
|
{
|
renderTarget[index]->unbind();
|
renderTarget[index] = 0;
|
}
|
}
|
|
if(vertexDeclaration)
|
{
|
vertexDeclaration->unbind();
|
vertexDeclaration = 0;
|
}
|
|
for(int i = 0; i < 16 + 4; i++)
|
{
|
if(texture[i])
|
{
|
texture[i]->unbind();
|
texture[i] = 0;
|
}
|
}
|
|
for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
|
{
|
if(dataStream[i])
|
{
|
dataStream[i]->unbind();
|
dataStream[i] = 0;
|
}
|
}
|
|
if(indexData)
|
{
|
indexData->unbind();
|
indexData = 0;
|
}
|
|
if(pixelShader)
|
{
|
pixelShader->unbind();
|
pixelShader = 0;
|
}
|
|
if(vertexShader)
|
{
|
vertexShader->unbind();
|
vertexShader = 0;
|
}
|
|
if(stateRecorder)
|
{
|
stateRecorder->unbind();
|
stateRecorder = 0;
|
}
|
|
palette.clear();
|
|
delete cursor;
|
|
DeleteCriticalSection(&criticalSection);
|
}
|
|
long Direct3DDevice9::QueryInterface(const IID &iid, void **object)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const IID &iid = 0x%0.8p, void **object = 0x%0.8p", iid, object);
|
|
if(iid == IID_IDirect3DDevice9 ||
|
iid == IID_IUnknown)
|
{
|
AddRef();
|
*object = this;
|
|
return S_OK;
|
}
|
|
*object = 0;
|
|
return NOINTERFACE(iid);
|
}
|
|
unsigned long Direct3DDevice9::AddRef()
|
{
|
TRACE("void");
|
|
return Unknown::AddRef();
|
}
|
|
unsigned long Direct3DDevice9::Release()
|
{
|
TRACE("void");
|
|
return Unknown::Release();
|
}
|
|
long Direct3DDevice9::BeginScene()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::BeginStateBlock()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
if(stateRecorder)
|
{
|
return INVALIDCALL();
|
}
|
|
stateRecorder = new Direct3DStateBlock9(this, (D3DSTATEBLOCKTYPE)0);
|
|
if(!stateRecorder)
|
{
|
return OUTOFMEMORY();
|
}
|
|
stateRecorder->bind();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::Clear(unsigned long count, const D3DRECT *rects, unsigned long flags, unsigned long color, float z, unsigned long stencil)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long count = %d, const D3DRECT *rects = 0x%0.8p, unsigned long flags = 0x%0.8X, unsigned long color = 0x%0.8X, float z = %f, unsigned long stencil = %d", count, rects, flags, color, z, stencil);
|
|
if(!rects && count != 0)
|
{
|
return INVALIDCALL();
|
}
|
|
if(flags & (D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL) && !depthStencil)
|
{
|
return INVALIDCALL();
|
}
|
|
if(flags & D3DCLEAR_STENCIL) // Check for stencil component
|
{
|
D3DSURFACE_DESC description;
|
depthStencil->GetDesc(&description);
|
|
switch(description.Format)
|
{
|
case D3DFMT_D15S1:
|
case D3DFMT_D24S8:
|
case D3DFMT_D24X8:
|
case D3DFMT_D24X4S4:
|
case D3DFMT_D24FS8:
|
case D3DFMT_S8_LOCKABLE: // FIXME: INVALIDCALL when trying to clear depth?
|
case D3DFMT_DF24:
|
case D3DFMT_DF16:
|
case D3DFMT_INTZ:
|
break;
|
case D3DFMT_D16_LOCKABLE:
|
case D3DFMT_D32:
|
case D3DFMT_D16:
|
case D3DFMT_D32F_LOCKABLE:
|
case D3DFMT_D32_LOCKABLE:
|
return INVALIDCALL();
|
default:
|
ASSERT(false);
|
}
|
}
|
|
if(!rects)
|
{
|
count = 1;
|
|
D3DRECT rect;
|
rect.x1 = viewport.X;
|
rect.x2 = viewport.X + viewport.Width;
|
rect.y1 = viewport.Y;
|
rect.y2 = viewport.Y + viewport.Height;
|
|
rects = ▭
|
}
|
|
for(unsigned int i = 0; i < count; i++)
|
{
|
sw::Rect clearRect(rects[i].x1, rects[i].y1, rects[i].x2, rects[i].y2);
|
|
clearRect.clip(viewport.X, viewport.Y, viewport.X + viewport.Width, viewport.Y + viewport.Height);
|
|
if(scissorEnable)
|
{
|
clearRect.clip(scissorRect.left, scissorRect.top, scissorRect.right, scissorRect.bottom);
|
}
|
|
if(flags & D3DCLEAR_TARGET)
|
{
|
for(int index = 0; index < 4; index++)
|
{
|
if(renderTarget[index])
|
{
|
D3DSURFACE_DESC description;
|
renderTarget[index]->GetDesc(&description);
|
|
float rgba[4];
|
rgba[0] = (float)(color & 0x00FF0000) / 0x00FF0000;
|
rgba[1] = (float)(color & 0x0000FF00) / 0x0000FF00;
|
rgba[2] = (float)(color & 0x000000FF) / 0x000000FF;
|
rgba[3] = (float)(color & 0xFF000000) / 0xFF000000;
|
|
if(renderState[D3DRS_SRGBWRITEENABLE] != FALSE && index == 0 && Capabilities::isSRGBwritable(description.Format))
|
{
|
rgba[0] = sw::linearToSRGB(rgba[0]);
|
rgba[1] = sw::linearToSRGB(rgba[1]);
|
rgba[2] = sw::linearToSRGB(rgba[2]);
|
}
|
|
renderer->clear(rgba, sw::FORMAT_A32B32G32R32F, renderTarget[index], clearRect, 0xF);
|
}
|
}
|
}
|
|
if(flags & D3DCLEAR_ZBUFFER)
|
{
|
z = sw::clamp01(z);
|
depthStencil->clearDepth(z, clearRect.x0, clearRect.y0, clearRect.width(), clearRect.height());
|
}
|
|
if(flags & D3DCLEAR_STENCIL)
|
{
|
depthStencil->clearStencil(stencil, 0xFF, clearRect.x0, clearRect.y0, clearRect.width(), clearRect.height());
|
}
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::ColorFill(IDirect3DSurface9 *surface, const RECT *rect, D3DCOLOR color)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DSurface9 *surface = 0x%0.8p, const RECT *rect = 0x%0.8p, D3DCOLOR color = 0x%0.8X", surface, rect, color);
|
|
if(!surface)
|
{
|
return INVALIDCALL();
|
}
|
|
D3DSURFACE_DESC description;
|
|
surface->GetDesc(&description);
|
|
if(description.Pool != D3DPOOL_DEFAULT)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!rect)
|
{
|
RECT lock;
|
|
lock.left = 0;
|
lock.top = 0;
|
lock.right = description.Width;
|
lock.bottom = description.Height;
|
|
rect = &lock;
|
}
|
|
static_cast<Direct3DSurface9*>(surface)->fill(color, rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS *presentParameters, IDirect3DSwapChain9 **swapChain)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DPRESENT_PARAMETERS *presentParameters = 0x%0.8p, IDirect3DSwapChain9 **swapChain = 0x%0.8p", presentParameters, swapChain);
|
|
if(!swapChain)
|
{
|
return INVALIDCALL();
|
}
|
|
*swapChain = 0;
|
|
if(!presentParameters)
|
{
|
return INVALIDCALL();
|
}
|
|
if(presentParameters->BackBufferCount > 3)
|
{
|
return INVALIDCALL(); // Maximum of three back buffers
|
}
|
|
*swapChain = new Direct3DSwapChain9(this, presentParameters);
|
|
if(!*swapChain)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *swapChain;
|
*swapChain = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*swapChain)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateCubeTexture(unsigned int edgeLength, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DCubeTexture9 **cubeTexture, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int edgeLength = %d, unsigned int levels = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DCubeTexture9 **cubeTexture = 0x%0.8p, void **sharedHandle = 0x%0.8p", edgeLength, levels, usage, format, pool, cubeTexture, sharedHandle);
|
|
*cubeTexture = 0;
|
|
if(edgeLength == 0 || (usage & D3DUSAGE_AUTOGENMIPMAP && levels > 1) || d3d9->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, usage, D3DRTYPE_CUBETEXTURE, format) != D3D_OK)
|
{
|
return INVALIDCALL();
|
}
|
|
*cubeTexture = new Direct3DCubeTexture9(this, edgeLength, levels, usage, format, pool);
|
|
if(!*cubeTexture)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *cubeTexture;
|
*cubeTexture = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*cubeTexture)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateDepthStencilSurface(unsigned int width, unsigned int height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multiSample, unsigned long multiSampleQuality, int discard, IDirect3DSurface9 **surface, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int width = %d, unsigned int height = %d, D3DFORMAT format = %d, D3DMULTISAMPLE_TYPE multiSample = %d, unsigned long multiSampleQuality = %d, int discard = %d, IDirect3DSurface9 **surface = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, format, multiSample, multiSampleQuality, discard, surface, sharedHandle);
|
|
*surface = 0;
|
|
if(width == 0 || height == 0 || d3d9->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, format) != D3D_OK || height > sw::OUTLINE_RESOLUTION)
|
{
|
return INVALIDCALL();
|
}
|
|
bool lockable = false;
|
|
switch(format)
|
{
|
case D3DFMT_D15S1:
|
case D3DFMT_D24S8:
|
case D3DFMT_D24X8:
|
case D3DFMT_D24X4S4:
|
case D3DFMT_D24FS8:
|
case D3DFMT_D32:
|
case D3DFMT_D16:
|
case D3DFMT_DF24:
|
case D3DFMT_DF16:
|
case D3DFMT_INTZ:
|
lockable = false;
|
break;
|
case D3DFMT_S8_LOCKABLE:
|
case D3DFMT_D16_LOCKABLE:
|
case D3DFMT_D32F_LOCKABLE:
|
case D3DFMT_D32_LOCKABLE:
|
lockable = true;
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
*surface = new Direct3DSurface9(this, this, width, height, format, D3DPOOL_DEFAULT, multiSample, multiSampleQuality, lockable, D3DUSAGE_DEPTHSTENCIL);
|
|
if(!*surface)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *surface;
|
*surface = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*surface)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateIndexBuffer(unsigned int length, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer9 **indexBuffer, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int length = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DIndexBuffer9 **indexBuffer = 0x%0.8p, void **sharedHandle = 0x%0.8p", length, usage, format, pool, indexBuffer, sharedHandle);
|
|
*indexBuffer = new Direct3DIndexBuffer9(this, length, usage, format, pool);
|
|
if(!*indexBuffer)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *indexBuffer;
|
*indexBuffer = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*indexBuffer)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateOffscreenPlainSurface(unsigned int width, unsigned int height, D3DFORMAT format, D3DPOOL pool, IDirect3DSurface9 **surface, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int width = %d, unsigned int height = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DSurface9 **surface = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, format, pool, surface, sharedHandle);
|
|
*surface = 0;
|
|
if(width == 0 || height == 0 || d3d9->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, 0, D3DRTYPE_SURFACE, format) != D3D_OK) // FIXME: Allow all formats supported by runtime/REF
|
{
|
return INVALIDCALL();
|
}
|
|
if(pool == D3DPOOL_MANAGED)
|
{
|
return INVALIDCALL();
|
}
|
|
*surface = new Direct3DSurface9(this, this, width, height, format, pool, D3DMULTISAMPLE_NONE, 0, true, 0);
|
|
if(!*surface)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *surface;
|
*surface = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*surface)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreatePixelShader(const unsigned long *function, IDirect3DPixelShader9 **shader)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const unsigned long *function = 0x%0.8p, IDirect3DPixelShader9 **shader = 0x%0.8p", function, shader);
|
|
if(!shader)
|
{
|
return INVALIDCALL();
|
}
|
|
*shader = 0;
|
|
if(!sw::PixelShader::validate(function) || function[0] > pixelShaderVersionX)
|
{
|
return INVALIDCALL(); // Shader contains unsupported operations
|
}
|
|
*shader = new Direct3DPixelShader9(this, function);
|
|
if(!*shader)
|
{
|
return OUTOFMEMORY();
|
}
|
|
(*shader)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateQuery(D3DQUERYTYPE type, IDirect3DQuery9 **query)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DQUERYTYPE type = %d, IDirect3DQuery9 **query = 0x%0.8p", type, query);
|
|
if(query == 0) // Support checked
|
{
|
switch(type)
|
{
|
case D3DQUERYTYPE_VCACHE: return D3D_OK;
|
case D3DQUERYTYPE_RESOURCEMANAGER: return NOTAVAILABLE();
|
case D3DQUERYTYPE_VERTEXSTATS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_EVENT: return D3D_OK;
|
case D3DQUERYTYPE_OCCLUSION: return D3D_OK;
|
case D3DQUERYTYPE_TIMESTAMP: return D3D_OK;
|
case D3DQUERYTYPE_TIMESTAMPDISJOINT: return D3D_OK;
|
case D3DQUERYTYPE_TIMESTAMPFREQ: return D3D_OK;
|
case D3DQUERYTYPE_PIPELINETIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_INTERFACETIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_VERTEXTIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_PIXELTIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_BANDWIDTHTIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_CACHEUTILIZATION: return NOTAVAILABLE();
|
default: ASSERT(false); return NOTAVAILABLE();
|
}
|
}
|
else
|
{
|
switch(type)
|
{
|
case D3DQUERYTYPE_VCACHE: break;
|
case D3DQUERYTYPE_RESOURCEMANAGER: return NOTAVAILABLE();
|
case D3DQUERYTYPE_VERTEXSTATS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_EVENT: break;
|
case D3DQUERYTYPE_OCCLUSION: break;
|
case D3DQUERYTYPE_TIMESTAMP: break;
|
case D3DQUERYTYPE_TIMESTAMPDISJOINT: break;
|
case D3DQUERYTYPE_TIMESTAMPFREQ: break;
|
case D3DQUERYTYPE_PIPELINETIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_INTERFACETIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_VERTEXTIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_PIXELTIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_BANDWIDTHTIMINGS: return NOTAVAILABLE();
|
case D3DQUERYTYPE_CACHEUTILIZATION: return NOTAVAILABLE();
|
default: ASSERT(false); return NOTAVAILABLE();
|
}
|
|
*query = new Direct3DQuery9(this, type);
|
|
if(!*query)
|
{
|
return OUTOFMEMORY();
|
}
|
|
(*query)->AddRef();
|
|
return D3D_OK;
|
}
|
}
|
|
long Direct3DDevice9::CreateRenderTarget(unsigned int width, unsigned int height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multiSample, unsigned long multiSampleQuality, int lockable, IDirect3DSurface9 **surface, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int width = %d, unsigned int height = %d, D3DFORMAT format = %d, D3DMULTISAMPLE_TYPE multiSample = %d, unsigned long multiSampleQuality = %d, int lockable = %d, IDirect3DSurface9 **surface = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, format, multiSample, multiSampleQuality, lockable, surface, sharedHandle);
|
|
*surface = 0;
|
|
if(width == 0 || height == 0 || d3d9->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, format) != D3D_OK || height > sw::OUTLINE_RESOLUTION)
|
{
|
return INVALIDCALL();
|
}
|
|
*surface = new Direct3DSurface9(this, this, width, height, format, D3DPOOL_DEFAULT, multiSample, multiSampleQuality, lockable != FALSE, D3DUSAGE_RENDERTARGET);
|
|
if(!*surface)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *surface;
|
*surface = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*surface)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateStateBlock(D3DSTATEBLOCKTYPE type, IDirect3DStateBlock9 **stateBlock)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DSTATEBLOCKTYPE type = %d, IDirect3DStateBlock9 **stateBlock = 0x%0.8p", type, stateBlock);
|
|
*stateBlock = new Direct3DStateBlock9(this, type);
|
|
if(!*stateBlock)
|
{
|
return OUTOFMEMORY();
|
}
|
|
(*stateBlock)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateTexture(unsigned int width, unsigned int height, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DTexture9 **texture, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int width = %d, unsigned int height = %d, unsigned int levels = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DTexture9 **texture = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, levels, usage, format, pool, texture, sharedHandle);
|
|
*texture = 0;
|
|
if(width == 0 || height == 0 || (usage & D3DUSAGE_AUTOGENMIPMAP && levels > 1) || d3d9->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, usage, D3DRTYPE_TEXTURE, format) != D3D_OK)
|
{
|
return INVALIDCALL();
|
}
|
|
*texture = new Direct3DTexture9(this, width, height, levels, usage, format, pool);
|
|
if(!*texture)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *texture;
|
*texture = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*texture)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateVertexBuffer(unsigned int length, unsigned long usage, unsigned long FVF, D3DPOOL pool, IDirect3DVertexBuffer9 **vertexBuffer, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int length = %d, unsigned long usage = %d, unsigned long FVF = 0x%0.8X, D3DPOOL pool = %d, IDirect3DVertexBuffer9 **vertexBuffer = 0x%0.8p, void **sharedHandle = 0x%0.8p", length, usage, FVF, pool, vertexBuffer, sharedHandle);
|
|
*vertexBuffer = new Direct3DVertexBuffer9(this, length, usage, FVF, pool);
|
|
if(!*vertexBuffer)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *vertexBuffer;
|
*vertexBuffer = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*vertexBuffer)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateVertexDeclaration(const D3DVERTEXELEMENT9 *vertexElements, IDirect3DVertexDeclaration9 **declaration)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const D3DVERTEXELEMENT9 *vertexElements = 0x%0.8p, IDirect3DVertexDeclaration9 **declaration = 0x%0.8p", vertexElements, declaration);
|
|
if(!declaration)
|
{
|
return INVALIDCALL();
|
}
|
|
const D3DVERTEXELEMENT9 *element = vertexElements;
|
|
while(element->Stream != 0xFF)
|
{
|
if(element->Type > D3DDECLTYPE_UNUSED) // FIXME: Check other fields too
|
{
|
return FAIL();
|
}
|
|
element++;
|
}
|
|
*declaration = new Direct3DVertexDeclaration9(this, vertexElements);
|
|
if(!*declaration)
|
{
|
return OUTOFMEMORY();
|
}
|
|
(*declaration)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateVertexShader(const unsigned long *function, IDirect3DVertexShader9 **shader)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const unsigned long *function = 0x%0.8p, IDirect3DVertexShader9 **shader = 0x%0.8p", function, shader);
|
|
if(!shader)
|
{
|
return INVALIDCALL();
|
}
|
|
*shader = 0;
|
|
if(!sw::VertexShader::validate(function) || function[0] > vertexShaderVersionX)
|
{
|
return INVALIDCALL(); // Shader contains unsupported operations
|
}
|
|
*shader = new Direct3DVertexShader9(this, function);
|
|
if(!*shader)
|
{
|
return OUTOFMEMORY();
|
}
|
|
(*shader)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::CreateVolumeTexture(unsigned int width, unsigned int height, unsigned int depth, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DVolumeTexture9 **volumeTexture, void **sharedHandle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int width = %d, unsigned int height = %d, unsigned int depth = %d, unsigned int levels = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DVolumeTexture9 **volumeTexture = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, depth, levels, usage, format, pool, volumeTexture, sharedHandle);
|
|
*volumeTexture = 0;
|
|
if(width == 0 || height == 0 || depth == 0 || (usage & D3DUSAGE_AUTOGENMIPMAP && levels > 1) || d3d9->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, usage, D3DRTYPE_VOLUMETEXTURE, format) != D3D_OK)
|
{
|
return INVALIDCALL();
|
}
|
|
*volumeTexture = new Direct3DVolumeTexture9(this, width, height, depth, levels, usage, format, pool);
|
|
if(!*volumeTexture)
|
{
|
return OUTOFMEMORY();
|
}
|
|
if(GetAvailableTextureMem() == 0)
|
{
|
delete *volumeTexture;
|
*volumeTexture = 0;
|
|
return OUTOFVIDEOMEMORY();
|
}
|
|
(*volumeTexture)->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::DeletePatch(unsigned int handle)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int handle = %d", handle);
|
|
UNIMPLEMENTED();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::DrawIndexedPrimitive(D3DPRIMITIVETYPE type, int baseVertexIndex, unsigned int minIndex, unsigned int numVertices, unsigned int startIndex, unsigned int primitiveCount)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DPRIMITIVETYPE type = %d, int baseVertexIndex = %d, unsigned int minIndex = %d, unsigned int numVertices = %d, unsigned int startIndex = %d, unsigned int primitiveCount = %d", type, baseVertexIndex, minIndex, numVertices, startIndex, primitiveCount);
|
|
if(!indexData)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!bindResources(indexData) || !primitiveCount)
|
{
|
return D3D_OK;
|
}
|
|
unsigned int indexOffset = startIndex * (indexData->is32Bit() ? 4 : 2); // FIXME: Doesn't take stream frequencies into account
|
|
sw::DrawType drawType;
|
|
if(indexData->is32Bit())
|
{
|
switch(type)
|
{
|
case D3DPT_POINTLIST: drawType = sw::DRAW_INDEXEDPOINTLIST32; break;
|
case D3DPT_LINELIST: drawType = sw::DRAW_INDEXEDLINELIST32; break;
|
case D3DPT_LINESTRIP: drawType = sw::DRAW_INDEXEDLINESTRIP32; break;
|
case D3DPT_TRIANGLELIST: drawType = sw::DRAW_INDEXEDTRIANGLELIST32; break;
|
case D3DPT_TRIANGLESTRIP: drawType = sw::DRAW_INDEXEDTRIANGLESTRIP32; break;
|
case D3DPT_TRIANGLEFAN: drawType = sw::DRAW_INDEXEDTRIANGLEFAN32; break;
|
default:
|
ASSERT(false);
|
}
|
}
|
else
|
{
|
switch(type)
|
{
|
case D3DPT_POINTLIST: drawType = sw::DRAW_INDEXEDPOINTLIST16; break;
|
case D3DPT_LINELIST: drawType = sw::DRAW_INDEXEDLINELIST16; break;
|
case D3DPT_LINESTRIP: drawType = sw::DRAW_INDEXEDLINESTRIP16; break;
|
case D3DPT_TRIANGLELIST: drawType = sw::DRAW_INDEXEDTRIANGLELIST16; break;
|
case D3DPT_TRIANGLESTRIP: drawType = sw::DRAW_INDEXEDTRIANGLESTRIP16; break;
|
case D3DPT_TRIANGLEFAN: drawType = sw::DRAW_INDEXEDTRIANGLEFAN16; break;
|
default:
|
ASSERT(false);
|
}
|
}
|
|
if((streamSourceFreq[0] & D3DSTREAMSOURCE_INDEXEDDATA) && instanceData())
|
{
|
int instanceCount = (streamSourceFreq[0] & ~D3DSTREAMSOURCE_INDEXEDDATA);
|
|
for(int instance = 0; instance < instanceCount; instance++)
|
{
|
bindVertexStreams(baseVertexIndex, true, instance);
|
renderer->draw(drawType, indexOffset, primitiveCount, instance == 0);
|
}
|
}
|
else
|
{
|
bindVertexStreams(baseVertexIndex, false, 0);
|
renderer->draw(drawType, indexOffset, primitiveCount);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE type, unsigned int minIndex, unsigned int numVertices, unsigned int primitiveCount, const void *indexData, D3DFORMAT indexDataFormat, const void *vertexStreamZeroData, unsigned int vertexStreamZeroStride)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DPRIMITIVETYPE type = %d, unsigned int minIndex = %d, unsigned int numVertices = %d, unsigned int primitiveCount = %d, const void *indexData = 0x%0.8p, D3DFORMAT indexDataFormat = %d, const void *vertexStreamZeroData = 0x%0.8p, unsigned int vertexStreamZeroStride = %d", type, minIndex, numVertices, primitiveCount, indexData, indexDataFormat, vertexStreamZeroData, vertexStreamZeroStride);
|
|
if(!vertexStreamZeroData || !indexData)
|
{
|
return INVALIDCALL();
|
}
|
|
int length = (minIndex + numVertices) * vertexStreamZeroStride;
|
|
Direct3DVertexBuffer9 *vertexBuffer = new Direct3DVertexBuffer9(this, length, 0, 0, D3DPOOL_DEFAULT);
|
|
void *data;
|
vertexBuffer->Lock(0, 0, &data, 0);
|
memcpy(data, vertexStreamZeroData, length);
|
vertexBuffer->Unlock();
|
|
SetStreamSource(0, vertexBuffer, 0, vertexStreamZeroStride);
|
|
switch(type)
|
{
|
case D3DPT_POINTLIST: length = primitiveCount; break;
|
case D3DPT_LINELIST: length = primitiveCount * 2; break;
|
case D3DPT_LINESTRIP: length = primitiveCount + 1; break;
|
case D3DPT_TRIANGLELIST: length = primitiveCount * 3; break;
|
case D3DPT_TRIANGLESTRIP: length = primitiveCount + 2; break;
|
case D3DPT_TRIANGLEFAN: length = primitiveCount + 2; break;
|
default:
|
ASSERT(false);
|
}
|
|
length *= indexDataFormat == D3DFMT_INDEX32 ? 4 : 2;
|
|
Direct3DIndexBuffer9 *indexBuffer = new Direct3DIndexBuffer9(this, length, 0, indexDataFormat, D3DPOOL_DEFAULT);
|
|
indexBuffer->Lock(0, 0, &data, 0);
|
memcpy(data, indexData, length);
|
indexBuffer->Unlock();
|
|
SetIndices(indexBuffer);
|
|
if(!bindResources(indexBuffer) || !primitiveCount)
|
{
|
vertexBuffer->Release();
|
|
return D3D_OK;
|
}
|
|
sw::DrawType drawType;
|
|
if(indexDataFormat == D3DFMT_INDEX32)
|
{
|
switch(type)
|
{
|
case D3DPT_POINTLIST: drawType = sw::DRAW_INDEXEDPOINTLIST32; break;
|
case D3DPT_LINELIST: drawType = sw::DRAW_INDEXEDLINELIST32; break;
|
case D3DPT_LINESTRIP: drawType = sw::DRAW_INDEXEDLINESTRIP32; break;
|
case D3DPT_TRIANGLELIST: drawType = sw::DRAW_INDEXEDTRIANGLELIST32; break;
|
case D3DPT_TRIANGLESTRIP: drawType = sw::DRAW_INDEXEDTRIANGLESTRIP32; break;
|
case D3DPT_TRIANGLEFAN: drawType = sw::DRAW_INDEXEDTRIANGLEFAN32; break;
|
default:
|
ASSERT(false);
|
}
|
}
|
else
|
{
|
switch(type)
|
{
|
case D3DPT_POINTLIST: drawType = sw::DRAW_INDEXEDPOINTLIST16; break;
|
case D3DPT_LINELIST: drawType = sw::DRAW_INDEXEDLINELIST16; break;
|
case D3DPT_LINESTRIP: drawType = sw::DRAW_INDEXEDLINESTRIP16; break;
|
case D3DPT_TRIANGLELIST: drawType = sw::DRAW_INDEXEDTRIANGLELIST16; break;
|
case D3DPT_TRIANGLESTRIP: drawType = sw::DRAW_INDEXEDTRIANGLESTRIP16; break;
|
case D3DPT_TRIANGLEFAN: drawType = sw::DRAW_INDEXEDTRIANGLEFAN16; break;
|
default:
|
ASSERT(false);
|
}
|
}
|
|
bindVertexStreams(0, false, 0);
|
renderer->draw(drawType, 0, primitiveCount);
|
|
SetStreamSource(0, 0, 0, 0);
|
SetIndices(0);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::DrawPrimitive(D3DPRIMITIVETYPE primitiveType, unsigned int startVertex, unsigned int primitiveCount)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DPRIMITIVETYPE primitiveType = %d, unsigned int startVertex = %d, unsigned int primitiveCount = %d", primitiveType, startVertex, primitiveCount);
|
|
if(!bindResources(0) || !primitiveCount)
|
{
|
return D3D_OK;
|
}
|
|
sw::DrawType drawType;
|
|
switch(primitiveType)
|
{
|
case D3DPT_POINTLIST: drawType = sw::DRAW_POINTLIST; break;
|
case D3DPT_LINELIST: drawType = sw::DRAW_LINELIST; break;
|
case D3DPT_LINESTRIP: drawType = sw::DRAW_LINESTRIP; break;
|
case D3DPT_TRIANGLELIST: drawType = sw::DRAW_TRIANGLELIST; break;
|
case D3DPT_TRIANGLESTRIP: drawType = sw::DRAW_TRIANGLESTRIP; break;
|
case D3DPT_TRIANGLEFAN: drawType = sw::DRAW_TRIANGLEFAN; break;
|
default:
|
ASSERT(false);
|
}
|
|
bindVertexStreams(startVertex, false, 0);
|
renderer->draw(drawType, 0, primitiveCount);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::DrawPrimitiveUP(D3DPRIMITIVETYPE primitiveType, unsigned int primitiveCount, const void *vertexStreamZeroData, unsigned int vertexStreamZeroStride)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DPRIMITIVETYPE primitiveType = %d, unsigned int primitiveCount = %d, const void *vertexStreamZeroData = 0x%0.8p, unsigned int vertexStreamZeroStride = %d", primitiveType, primitiveCount, vertexStreamZeroData, vertexStreamZeroStride);
|
|
if(!vertexStreamZeroData)
|
{
|
return INVALIDCALL();
|
}
|
|
IDirect3DVertexBuffer9 *vertexBuffer = 0;
|
int length = 0;
|
|
switch(primitiveType)
|
{
|
case D3DPT_POINTLIST: length = primitiveCount; break;
|
case D3DPT_LINELIST: length = primitiveCount * 2; break;
|
case D3DPT_LINESTRIP: length = primitiveCount + 1; break;
|
case D3DPT_TRIANGLELIST: length = primitiveCount * 3; break;
|
case D3DPT_TRIANGLESTRIP: length = primitiveCount + 2; break;
|
case D3DPT_TRIANGLEFAN: length = primitiveCount + 2; break;
|
default:
|
ASSERT(false);
|
}
|
|
length *= vertexStreamZeroStride;
|
|
CreateVertexBuffer(length, 0, 0, D3DPOOL_DEFAULT, &vertexBuffer, 0);
|
|
void *data;
|
vertexBuffer->Lock(0, 0, &data, 0);
|
memcpy(data, vertexStreamZeroData, length);
|
vertexBuffer->Unlock();
|
|
SetStreamSource(0, vertexBuffer, 0, vertexStreamZeroStride);
|
|
if(!bindResources(0) || !primitiveCount)
|
{
|
vertexBuffer->Release();
|
|
return D3D_OK;
|
}
|
|
sw::DrawType drawType;
|
|
switch(primitiveType)
|
{
|
case D3DPT_POINTLIST: drawType = sw::DRAW_POINTLIST; break;
|
case D3DPT_LINELIST: drawType = sw::DRAW_LINELIST; break;
|
case D3DPT_LINESTRIP: drawType = sw::DRAW_LINESTRIP; break;
|
case D3DPT_TRIANGLELIST: drawType = sw::DRAW_TRIANGLELIST; break;
|
case D3DPT_TRIANGLESTRIP: drawType = sw::DRAW_TRIANGLESTRIP; break;
|
case D3DPT_TRIANGLEFAN: drawType = sw::DRAW_TRIANGLEFAN; break;
|
default:
|
ASSERT(false);
|
}
|
|
bindVertexStreams(0, false, 0);
|
renderer->draw(drawType, 0, primitiveCount);
|
|
SetStreamSource(0, 0, 0, 0);
|
vertexBuffer->Release();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::DrawRectPatch(unsigned int handle, const float *numSegs, const D3DRECTPATCH_INFO *rectPatchInfo)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int handle = %d, const float *numSegs = 0x%0.8p, const D3DRECTPATCH_INFO *rectPatchInfo = 0x%0.8p", handle, numSegs, rectPatchInfo);
|
|
if(!numSegs || !rectPatchInfo)
|
{
|
return INVALIDCALL();
|
}
|
|
UNIMPLEMENTED();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::DrawTriPatch(unsigned int handle, const float *numSegs, const D3DTRIPATCH_INFO *triPatchInfo)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int handle = %d, const float *numSegs = 0x%0.8p, const D3DTRIPATCH_INFO *triPatchInfo = 0x%0.8p", handle, numSegs, triPatchInfo);
|
|
if(!numSegs || !triPatchInfo)
|
{
|
return INVALIDCALL();
|
}
|
|
UNIMPLEMENTED();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::EndScene()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::EndStateBlock(IDirect3DStateBlock9 **stateBlock)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DStateBlock9 **stateBlock = 0x%0.8p", stateBlock);
|
|
if(!stateBlock)
|
{
|
return INVALIDCALL();
|
}
|
|
*stateBlock = 0;
|
|
if(!stateRecorder)
|
{
|
return INVALIDCALL();
|
}
|
|
*stateBlock = stateRecorder;
|
stateRecorder->AddRef();
|
stateRecorder->unbind();
|
stateRecorder = 0; // Stop recording
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::EvictManagedResources()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
// UNIMPLEMENTED(); // FIXME
|
|
return D3D_OK;
|
}
|
|
unsigned int Direct3DDevice9::GetAvailableTextureMem()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
int availableMemory = textureMemory - Direct3DResource9::getMemoryUsage();
|
if(availableMemory < 0) availableMemory = 0;
|
|
// Round to nearest MB
|
return (availableMemory + 0x80000) & 0xFFF00000;
|
}
|
|
long Direct3DDevice9::GetBackBuffer(unsigned int swapChainIndex, unsigned int backBufferIndex, D3DBACKBUFFER_TYPE type, IDirect3DSurface9 **backBuffer)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int swapChainIndex = %d, unsigned int backBufferIndex = %d, D3DBACKBUFFER_TYPE type = %d, IDirect3DSurface9 **backBuffer = 0x%0.8p", swapChainIndex, backBufferIndex, type, backBuffer);
|
|
if(swapChainIndex >= GetNumberOfSwapChains())
|
{
|
return INVALIDCALL();
|
}
|
|
return swapChain->GetBackBuffer(backBufferIndex, type, backBuffer);
|
}
|
|
long Direct3DDevice9::GetClipPlane(unsigned long index, float *plane)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, float *plane = 0x%0.8p", index, plane);
|
|
if(!plane || index >= 6)
|
{
|
return INVALIDCALL();
|
}
|
|
plane[0] = this->plane[index][0];
|
plane[1] = this->plane[index][1];
|
plane[2] = this->plane[index][2];
|
plane[3] = this->plane[index][3];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetClipStatus(D3DCLIPSTATUS9 *clipStatus)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DCLIPSTATUS9 *clipStatus = 0x%0.8p", clipStatus);
|
|
if(!clipStatus)
|
{
|
return INVALIDCALL();
|
}
|
|
*clipStatus = this->clipStatus;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *parameters)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DDEVICE_CREATION_PARAMETERS *parameters = 0x%0.8p", parameters);
|
|
if(!parameters)
|
{
|
return INVALIDCALL();
|
}
|
|
parameters->AdapterOrdinal = adapter;
|
parameters->BehaviorFlags = behaviourFlags;
|
parameters->DeviceType = deviceType;
|
parameters->hFocusWindow = focusWindow;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetCurrentTexturePalette(unsigned int *paletteNumber)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int *paletteNumber = 0x%0.8p", paletteNumber);
|
|
if(!paletteNumber)
|
{
|
return INVALIDCALL();
|
}
|
|
*paletteNumber = currentPalette;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetDepthStencilSurface(IDirect3DSurface9 **depthStencilSurface)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DSurface9 **depthStencilSurface = 0x%0.8p", depthStencilSurface);
|
|
if(!depthStencilSurface)
|
{
|
return INVALIDCALL();
|
}
|
|
*depthStencilSurface = depthStencil;
|
|
if(depthStencil)
|
{
|
depthStencil->AddRef();
|
}
|
else
|
{
|
return NOTFOUND();
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetDeviceCaps(D3DCAPS9 *caps)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DCAPS9 *caps = 0x%0.8p", caps);
|
|
return d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, caps);
|
}
|
|
long Direct3DDevice9::GetDirect3D(IDirect3D9 **d3d9)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3D9 **d3d9 = 0x%0.8p", d3d9);
|
|
if(!d3d9)
|
{
|
return INVALIDCALL();
|
}
|
|
*d3d9 = this->d3d9;
|
this->d3d9->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetDisplayMode(unsigned int index, D3DDISPLAYMODE *mode)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int index = %d, D3DDISPLAYMODE *mode = 0x%0.8p", index, mode);
|
|
if(index >= GetNumberOfSwapChains())
|
{
|
return INVALIDCALL();
|
}
|
|
return swapChain->GetDisplayMode(mode);
|
}
|
|
long Direct3DDevice9::GetFrontBufferData(unsigned int index, IDirect3DSurface9 *destSurface)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int index = %d, IDirect3DSurface9 *destSurface = %p", index, destSurface);
|
|
if(index >= GetNumberOfSwapChains())
|
{
|
return INVALIDCALL();
|
}
|
|
return swapChain->GetFrontBufferData(destSurface);
|
}
|
|
long Direct3DDevice9::GetFVF(unsigned long *FVF)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long *FVF = 0x%0.8p", FVF);
|
|
if(!FVF)
|
{
|
return INVALIDCALL();
|
}
|
|
if(vertexDeclaration)
|
{
|
*FVF = vertexDeclaration->getFVF();
|
}
|
else
|
{
|
*FVF = 0;
|
}
|
|
return D3D_OK;
|
}
|
|
void Direct3DDevice9::GetGammaRamp(unsigned int index, D3DGAMMARAMP *ramp)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int index = %d, D3DGAMMARAMP *ramp = 0x%0.8p", index, ramp);
|
|
if(!ramp || index >= GetNumberOfSwapChains())
|
{
|
return;
|
}
|
|
swapChain->getGammaRamp((sw::GammaRamp*)ramp);
|
}
|
|
long Direct3DDevice9::GetIndices(IDirect3DIndexBuffer9 **indexData)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DIndexBuffer9 **indexData = 0x%0.8p", indexData);
|
|
if(!indexData)
|
{
|
return INVALIDCALL();
|
}
|
|
*indexData = this->indexData;
|
|
if(this->indexData)
|
{
|
this->indexData->AddRef();
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetLight(unsigned long index, D3DLIGHT9 *light)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, D3DLIGHT9 *light = 0x%0.8p", index, light);
|
|
if(!light)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!this->light.exists(index))
|
{
|
return INVALIDCALL();
|
}
|
|
*light = this->light[index];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetLightEnable(unsigned long index, int *enable)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, int *enable = 0x%0.8p", index, enable);
|
|
if(!enable)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!light.exists(index))
|
{
|
return INVALIDCALL();
|
}
|
|
*enable = light[index].enable ? 128 : 0;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetMaterial(D3DMATERIAL9 *material)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DMATERIAL9 *material = 0x%0.8p", material);
|
|
if(!material)
|
{
|
return INVALIDCALL();
|
}
|
|
*material = this->material;
|
|
return D3D_OK;
|
}
|
|
float Direct3DDevice9::GetNPatchMode()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
return 0.0f; // FIXME: Unimplemented
|
}
|
|
unsigned int Direct3DDevice9::GetNumberOfSwapChains()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
return 1;
|
}
|
|
long Direct3DDevice9::GetPaletteEntries(unsigned int paletteNumber, PALETTEENTRY *entries)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int paletteNumber = %d, PALETTEENTRY *entries = 0x%0.8p", paletteNumber, entries);
|
|
if(paletteNumber > 0xFFFF || !entries)
|
{
|
return INVALIDCALL();
|
}
|
|
for(int i = 0; i < 256; i++)
|
{
|
entries[i] = palette[paletteNumber].entry[i];
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetPixelShader(IDirect3DPixelShader9 **shader)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DPixelShader9 **shader = 0x%0.8p", shader);
|
|
if(!shader)
|
{
|
return INVALIDCALL();
|
}
|
|
if(pixelShader)
|
{
|
pixelShader->AddRef();
|
}
|
|
*shader = pixelShader;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetPixelShaderConstantB(unsigned int startRegister, int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
for(unsigned int i = 0; i < count; i++)
|
{
|
constantData[i] = pixelShaderConstantB[startRegister + i];
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetPixelShaderConstantF(unsigned int startRegister, float *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
for(unsigned int i = 0; i < count; i++)
|
{
|
constantData[i * 4 + 0] = pixelShaderConstantF[startRegister + i][0];
|
constantData[i * 4 + 1] = pixelShaderConstantF[startRegister + i][1];
|
constantData[i * 4 + 2] = pixelShaderConstantF[startRegister + i][2];
|
constantData[i * 4 + 3] = pixelShaderConstantF[startRegister + i][3];
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetPixelShaderConstantI(unsigned int startRegister, int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
for(unsigned int i = 0; i < count; i++)
|
{
|
constantData[i * 4 + 0] = pixelShaderConstantI[startRegister + i][0];
|
constantData[i * 4 + 1] = pixelShaderConstantI[startRegister + i][1];
|
constantData[i * 4 + 2] = pixelShaderConstantI[startRegister + i][2];
|
constantData[i * 4 + 3] = pixelShaderConstantI[startRegister + i][3];
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetRasterStatus(unsigned int index, D3DRASTER_STATUS *rasterStatus)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int swapChain = %d, D3DRASTER_STATUS *rasterStatus = 0x%0.8p", index, rasterStatus);
|
|
if(index >= GetNumberOfSwapChains())
|
{
|
return INVALIDCALL();
|
}
|
|
return swapChain->GetRasterStatus(rasterStatus);
|
}
|
|
long Direct3DDevice9::GetRenderState(D3DRENDERSTATETYPE state, unsigned long *value)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DRENDERSTATETYPE state = %d, unsigned long *value = 0x%0.8p", state, value);
|
|
if(!value)
|
{
|
return INVALIDCALL();
|
}
|
|
*value = renderState[state];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetRenderTarget(unsigned long index, IDirect3DSurface9 **renderTarget)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, IDirect3DSurface9 **renderTarget = 0x%0.8p", index, renderTarget);
|
|
if(index >= 4 || !renderTarget)
|
{
|
return INVALIDCALL();
|
}
|
|
*renderTarget = 0;
|
|
if(!this->renderTarget[index])
|
{
|
return NOTFOUND();
|
}
|
|
*renderTarget = this->renderTarget[index];
|
this->renderTarget[index]->AddRef();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetRenderTargetData(IDirect3DSurface9 *renderTarget, IDirect3DSurface9 *destSurface)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DSurface9 *renderTarget = 0x%0.8p, IDirect3DSurface9 *destSurface = 0x%0.8p", renderTarget, destSurface);
|
|
if(!renderTarget || !destSurface)
|
{
|
return INVALIDCALL();
|
}
|
|
D3DSURFACE_DESC sourceDescription;
|
D3DSURFACE_DESC destinationDescription;
|
|
renderTarget->GetDesc(&sourceDescription);
|
destSurface->GetDesc(&destinationDescription);
|
|
if(sourceDescription.Width != destinationDescription.Width ||
|
sourceDescription.Height != destinationDescription.Height ||
|
sourceDescription.Format != destinationDescription.Format ||
|
sourceDescription.MultiSampleType != D3DMULTISAMPLE_NONE)
|
{
|
return INVALIDCALL();
|
}
|
|
if(sourceDescription.Format == D3DFMT_A8R8G8B8 ||
|
sourceDescription.Format == D3DFMT_X8R8G8B8)
|
{
|
sw::Surface *source = static_cast<Direct3DSurface9*>(renderTarget);
|
sw::Surface *dest = static_cast<Direct3DSurface9*>(destSurface);
|
|
void *sourceBuffer = source->lockExternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
|
void *destBuffer = dest->lockExternal(0, 0, 0, sw::LOCK_WRITEONLY, sw::PUBLIC);
|
|
static void (__cdecl *blitFunction)(void *dst, void *src);
|
static sw::Routine *blitRoutine;
|
static sw::BlitState blitState = {};
|
|
sw::BlitState update;
|
update.width = sourceDescription.Width;
|
update.height = sourceDescription.Height;
|
update.sourceFormat = sw::FORMAT_A8R8G8B8;
|
update.sourceStride = source->getExternalPitchB();
|
update.destFormat = sw::FORMAT_A8R8G8B8;
|
update.destStride = dest->getExternalPitchB();
|
update.cursorHeight = 0;
|
update.cursorWidth = 0;
|
|
if(memcmp(&blitState, &update, sizeof(sw::BlitState)) != 0)
|
{
|
blitState = update;
|
delete blitRoutine;
|
|
blitRoutine = sw::FrameBuffer::copyRoutine(blitState);
|
blitFunction = (void(__cdecl*)(void*, void*))blitRoutine->getEntry();
|
}
|
|
blitFunction(destBuffer, sourceBuffer);
|
|
dest->unlockExternal();
|
source->unlockExternal();
|
}
|
else
|
{
|
return UpdateSurface(renderTarget, 0, destSurface, 0);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetSamplerState(unsigned long sampler, D3DSAMPLERSTATETYPE state, unsigned long *value)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long sampler = %d, D3DSAMPLERSTATETYPE type = %d, unsigned long *value = 0x%0.8p", sampler, state, value);
|
|
if(!value || state < D3DSAMP_ADDRESSU || state > D3DSAMP_DMAPOFFSET) // FIXME: Set *value to 0?
|
{
|
return INVALIDCALL();
|
}
|
|
if((sampler >= 16 && sampler <= D3DDMAPSAMPLER) || sampler > D3DVERTEXTEXTURESAMPLER3)
|
{
|
return INVALIDCALL();
|
}
|
|
if(sampler >= D3DVERTEXTEXTURESAMPLER0)
|
{
|
sampler = 16 + (sampler - D3DVERTEXTEXTURESAMPLER0);
|
}
|
|
*value = samplerState[sampler][state];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetScissorRect(RECT *rect)
|
{
|
CriticalSection cs(this);
|
|
TRACE("RECT *rect = 0x%0.8p", rect);
|
|
if(!rect)
|
{
|
return INVALIDCALL();
|
}
|
|
*rect = scissorRect;
|
|
return D3D_OK;
|
}
|
|
int Direct3DDevice9::GetSoftwareVertexProcessing()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
return softwareVertexProcessing ? TRUE : FALSE;
|
}
|
|
long Direct3DDevice9::GetStreamSource(unsigned int streamNumber, IDirect3DVertexBuffer9 **streamData, unsigned int *offset, unsigned int *stride)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int streamNumber = %d, IDirect3DVertexBuffer9 **streamData = 0x%0.8p, unsigned int *offset = 0x%0.8p, unsigned int *stride = 0x%0.8p", streamNumber, streamData, offset, stride);
|
|
if(streamNumber >= 16 || !streamData || !offset || !stride)
|
{
|
return INVALIDCALL();
|
}
|
|
*streamData = dataStream[streamNumber];
|
|
if(dataStream[streamNumber])
|
{
|
dataStream[streamNumber]->AddRef();
|
}
|
|
*offset = streamOffset[streamNumber];
|
*stride = streamStride[streamNumber];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetStreamSourceFreq(unsigned int streamNumber, unsigned int *divider)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int streamNumber = %d, unsigned int *divider = 0x%0.8p", streamNumber, divider);
|
|
if(streamNumber >= 16 || !divider)
|
{
|
return INVALIDCALL();
|
}
|
|
*divider = streamSourceFreq[streamNumber];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetSwapChain(unsigned int index, IDirect3DSwapChain9 **swapChain)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int index = %d, IDirect3DSwapChain9 **swapChain = 0x%0.8p", index, swapChain);
|
|
if(!swapChain || index >= GetNumberOfSwapChains())
|
{
|
return INVALIDCALL();
|
}
|
|
*swapChain = this->swapChain;
|
|
if(*swapChain)
|
{
|
(*swapChain)->AddRef();
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetTexture(unsigned long sampler, IDirect3DBaseTexture9 **texture)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long sampler = %d, IDirect3DBaseTexture9 **texture = 0x%0.8p", sampler, texture);
|
|
if(!texture)
|
{
|
return INVALIDCALL();
|
}
|
|
*texture = 0;
|
|
if((sampler >= 16 && sampler <= D3DDMAPSAMPLER) || sampler > D3DVERTEXTEXTURESAMPLER3)
|
{
|
return INVALIDCALL();
|
}
|
|
*texture = this->texture[sampler];
|
|
if(this->texture[sampler])
|
{
|
this->texture[sampler]->AddRef();
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long *value)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long stage = %d, D3DTEXTURESTAGESTATETYPE type = %d, unsigned long *value = 0x%0.8p", stage, type, value);
|
|
if(!value)
|
{
|
return INVALIDCALL();
|
}
|
|
*value = textureStageState[stage][type];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetTransform(D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DTRANSFORMSTATETYPE state = %d, D3DMATRIX *matrix = 0x%0.8p", state, matrix);
|
|
if(!matrix || state < 0 || state > 511)
|
{
|
return INVALIDCALL();
|
}
|
|
*matrix = this->matrix[state];
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetVertexDeclaration(IDirect3DVertexDeclaration9 **declaration)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DVertexDeclaration9 **declaration = 0x%0.8p", declaration);
|
|
if(!declaration)
|
{
|
return INVALIDCALL();
|
}
|
|
*declaration = vertexDeclaration;
|
|
if(vertexDeclaration)
|
{
|
vertexDeclaration->AddRef();
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetVertexShader(IDirect3DVertexShader9 **shader)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DVertexShader9 **shader = 0x%0.8p", shader);
|
|
if(!shader)
|
{
|
return INVALIDCALL();
|
}
|
|
*shader = vertexShader;
|
|
if(vertexShader)
|
{
|
vertexShader->AddRef();
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetVertexShaderConstantB(unsigned int startRegister, int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
for(unsigned int i = 0; i < count; i++)
|
{
|
constantData[i] = vertexShaderConstantB[startRegister + i];
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetVertexShaderConstantF(unsigned int startRegister, float *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
for(unsigned int i = 0; i < count; i++)
|
{
|
constantData[i * 4 + 0] = vertexShaderConstantF[startRegister + i][0];
|
constantData[i * 4 + 1] = vertexShaderConstantF[startRegister + i][1];
|
constantData[i * 4 + 2] = vertexShaderConstantF[startRegister + i][2];
|
constantData[i * 4 + 3] = vertexShaderConstantF[startRegister + i][3];
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetVertexShaderConstantI(unsigned int startRegister, int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
for(unsigned int i = 0; i < count; i++)
|
{
|
constantData[i * 4 + 0] = vertexShaderConstantI[startRegister + i][0];
|
constantData[i * 4 + 1] = vertexShaderConstantI[startRegister + i][1];
|
constantData[i * 4 + 2] = vertexShaderConstantI[startRegister + i][2];
|
constantData[i * 4 + 3] = vertexShaderConstantI[startRegister + i][3];
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::GetViewport(D3DVIEWPORT9 *viewport)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DVIEWPORT9 *viewport = 0x%0.8p", viewport);
|
|
if(!viewport)
|
{
|
return INVALIDCALL();
|
}
|
|
*viewport = this->viewport;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::LightEnable(unsigned long index, int enable)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, int enable = %d", index, enable);
|
|
if(!light.exists(index)) // Insert default light
|
{
|
D3DLIGHT9 light;
|
|
light.Type = D3DLIGHT_DIRECTIONAL;
|
light.Diffuse.r = 1;
|
light.Diffuse.g = 1;
|
light.Diffuse.b = 1;
|
light.Diffuse.a = 0;
|
light.Specular.r = 0;
|
light.Specular.g = 0;
|
light.Specular.b = 0;
|
light.Specular.a = 0;
|
light.Ambient.r = 0;
|
light.Ambient.g = 0;
|
light.Ambient.b = 0;
|
light.Ambient.a = 0;
|
light.Position.x = 0;
|
light.Position.y = 0;
|
light.Position.z = 0;
|
light.Direction.x = 0;
|
light.Direction.y = 0;
|
light.Direction.z = 1;
|
light.Range = 0;
|
light.Falloff = 0;
|
light.Attenuation0 = 0;
|
light.Attenuation1 = 0;
|
light.Attenuation2 = 0;
|
light.Theta = 0;
|
light.Phi = 0;
|
|
this->light[index] = light;
|
this->light[index].enable = false;
|
}
|
|
if(!stateRecorder)
|
{
|
light[index].enable = (enable != FALSE);
|
|
lightsDirty = true;
|
}
|
else
|
{
|
stateRecorder->lightEnable(index, enable);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::MultiplyTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DTRANSFORMSTATETYPE state = %d, const D3DMATRIX *matrix = 0x%0.8p", state, matrix);
|
|
if(!matrix)
|
{
|
return INVALIDCALL();
|
}
|
|
D3DMATRIX *current = &this->matrix[state];
|
|
sw::Matrix C(current->_11, current->_21, current->_31, current->_41,
|
current->_12, current->_22, current->_32, current->_42,
|
current->_13, current->_23, current->_33, current->_43,
|
current->_14, current->_24, current->_34, current->_44);
|
|
sw::Matrix M(matrix->_11, matrix->_21, matrix->_31, matrix->_41,
|
matrix->_12, matrix->_22, matrix->_32, matrix->_42,
|
matrix->_13, matrix->_23, matrix->_33, matrix->_43,
|
matrix->_14, matrix->_24, matrix->_34, matrix->_44);
|
|
switch(state)
|
{
|
case D3DTS_WORLD:
|
renderer->setModelMatrix(C * M);
|
break;
|
case D3DTS_VIEW:
|
renderer->setViewMatrix(C * M);
|
break;
|
case D3DTS_PROJECTION:
|
renderer->setProjectionMatrix(C * M);
|
break;
|
case D3DTS_TEXTURE0:
|
renderer->setTextureMatrix(0, C * M);
|
break;
|
case D3DTS_TEXTURE1:
|
renderer->setTextureMatrix(1, C * M);
|
break;
|
case D3DTS_TEXTURE2:
|
renderer->setTextureMatrix(2, C * M);
|
break;
|
case D3DTS_TEXTURE3:
|
renderer->setTextureMatrix(3, C * M);
|
break;
|
case D3DTS_TEXTURE4:
|
renderer->setTextureMatrix(4, C * M);
|
break;
|
case D3DTS_TEXTURE5:
|
renderer->setTextureMatrix(5, C * M);
|
break;
|
case D3DTS_TEXTURE6:
|
renderer->setTextureMatrix(6, C * M);
|
break;
|
case D3DTS_TEXTURE7:
|
renderer->setTextureMatrix(7, C * M);
|
break;
|
default:
|
if(state > 256 && state < 512)
|
{
|
renderer->setModelMatrix(C * M, state - 256);
|
}
|
else ASSERT(false);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::Present(const RECT *sourceRect, const RECT *destRect, HWND destWindowOverride, const RGNDATA *dirtyRegion)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const RECT *sourceRect = 0x%0.8p, const RECT *destRect = 0x%0.8p, HWND destWindowOverride = %d, const RGNDATA *dirtyRegion = 0x%0.8p", sourceRect, destRect, destWindowOverride, dirtyRegion);
|
|
return swapChain->Present(sourceRect, destRect, destWindowOverride, dirtyRegion, 0);
|
}
|
|
long Direct3DDevice9::ProcessVertices(unsigned int srcStartIndex, unsigned int destIndex, unsigned int vertexCount, IDirect3DVertexBuffer9 *destBuffer, IDirect3DVertexDeclaration9 *vertexDeclaration, unsigned long flags)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int srcStartIndex = %d, unsigned int destIndex = %d, unsigned int vertexCount = %d, IDirect3DVertexBuffer9 *destBuffer = 0x%0.8p, IDirect3DVertexDeclaration9 *vertexDeclaration = 0x%0.8p, unsigned long flags = %d", srcStartIndex, destIndex, vertexCount, destBuffer, vertexDeclaration, flags);
|
|
if(!destBuffer)
|
{
|
return INVALIDCALL();
|
}
|
|
UNIMPLEMENTED();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::Reset(D3DPRESENT_PARAMETERS *presentParameters)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DPRESENT_PARAMETERS *presentParameters = 0x%0.8p", presentParameters);
|
|
if(!presentParameters)
|
{
|
return INVALIDCALL();
|
}
|
|
deviceWindow = presentParameters->hDeviceWindow;
|
|
if(depthStencil)
|
{
|
depthStencil->unbind();
|
depthStencil = 0;
|
}
|
|
if(autoDepthStencil)
|
{
|
autoDepthStencil->unbind();
|
autoDepthStencil = 0;
|
}
|
|
for(int index = 0; index < 4; index++)
|
{
|
if(renderTarget[index])
|
{
|
renderTarget[index]->unbind();
|
renderTarget[index] = 0;
|
}
|
}
|
|
if(!swapChain)
|
{
|
swapChain = new Direct3DSwapChain9(this, presentParameters);
|
swapChain->bind();
|
}
|
else
|
{
|
swapChain->reset(presentParameters);
|
}
|
|
if(presentParameters->EnableAutoDepthStencil != FALSE)
|
{
|
bool lockable = false;
|
|
switch(presentParameters->AutoDepthStencilFormat)
|
{
|
case D3DFMT_D15S1:
|
case D3DFMT_D24S8:
|
case D3DFMT_D24X8:
|
case D3DFMT_D24X4S4:
|
case D3DFMT_D24FS8:
|
case D3DFMT_D32:
|
case D3DFMT_D16:
|
case D3DFMT_DF24:
|
case D3DFMT_DF16:
|
case D3DFMT_INTZ:
|
lockable = false;
|
break;
|
case D3DFMT_S8_LOCKABLE:
|
case D3DFMT_D16_LOCKABLE:
|
case D3DFMT_D32F_LOCKABLE:
|
case D3DFMT_D32_LOCKABLE:
|
lockable = true;
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
autoDepthStencil = new Direct3DSurface9(this, this, presentParameters->BackBufferWidth, presentParameters->BackBufferHeight, presentParameters->AutoDepthStencilFormat, D3DPOOL_DEFAULT, presentParameters->MultiSampleType, presentParameters->MultiSampleQuality, lockable, D3DUSAGE_DEPTHSTENCIL);
|
autoDepthStencil->bind();
|
|
SetDepthStencilSurface(autoDepthStencil);
|
}
|
|
IDirect3DSurface9 *renderTarget;
|
swapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &renderTarget);
|
SetRenderTarget(0, renderTarget);
|
renderTarget->Release();
|
|
SetRenderTarget(1, 0);
|
SetRenderTarget(2, 0);
|
SetRenderTarget(3, 0);
|
|
softwareVertexProcessing = (behaviourFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING) == D3DCREATE_SOFTWARE_VERTEXPROCESSING;
|
|
SetRenderState(D3DRS_ZENABLE, presentParameters->EnableAutoDepthStencil != FALSE ? D3DZB_TRUE : D3DZB_FALSE);
|
SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
|
SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
|
SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
|
SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
|
SetRenderState(D3DRS_LASTPIXEL, TRUE);
|
SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
|
SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);
|
SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
|
SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
|
SetRenderState(D3DRS_ALPHAREF, 0);
|
SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_ALWAYS);
|
SetRenderState(D3DRS_DITHERENABLE, FALSE);
|
SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
|
SetRenderState(D3DRS_FOGENABLE, FALSE);
|
SetRenderState(D3DRS_SPECULARENABLE, FALSE);
|
// SetRenderState(D3DRS_ZVISIBLE, 0);
|
SetRenderState(D3DRS_FOGCOLOR, 0);
|
SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE);
|
SetRenderState(D3DRS_FOGSTART, FtoDW(0.0f));
|
SetRenderState(D3DRS_FOGEND, FtoDW(1.0f));
|
SetRenderState(D3DRS_FOGDENSITY, FtoDW(1.0f));
|
SetRenderState(D3DRS_RANGEFOGENABLE, FALSE);
|
SetRenderState(D3DRS_STENCILENABLE, FALSE);
|
SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
|
SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
|
SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
|
SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
|
SetRenderState(D3DRS_STENCILREF, 0);
|
SetRenderState(D3DRS_STENCILMASK, 0xFFFFFFFF);
|
SetRenderState(D3DRS_STENCILWRITEMASK, 0xFFFFFFFF);
|
SetRenderState(D3DRS_TEXTUREFACTOR, 0xFFFFFFFF);
|
SetRenderState(D3DRS_WRAP0, 0);
|
SetRenderState(D3DRS_WRAP1, 0);
|
SetRenderState(D3DRS_WRAP2, 0);
|
SetRenderState(D3DRS_WRAP3, 0);
|
SetRenderState(D3DRS_WRAP4, 0);
|
SetRenderState(D3DRS_WRAP5, 0);
|
SetRenderState(D3DRS_WRAP6, 0);
|
SetRenderState(D3DRS_WRAP7, 0);
|
SetRenderState(D3DRS_CLIPPING, TRUE);
|
SetRenderState(D3DRS_LIGHTING, TRUE);
|
SetRenderState(D3DRS_AMBIENT, 0);
|
SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
|
SetRenderState(D3DRS_COLORVERTEX, TRUE);
|
SetRenderState(D3DRS_LOCALVIEWER, TRUE);
|
SetRenderState(D3DRS_NORMALIZENORMALS, FALSE);
|
SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
|
SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2);
|
SetRenderState(D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
|
SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
|
SetRenderState(D3DRS_VERTEXBLEND, D3DVBF_DISABLE);
|
SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
|
SetRenderState(D3DRS_POINTSIZE, FtoDW(1.0f));
|
SetRenderState(D3DRS_POINTSIZE_MIN, FtoDW(1.0f));
|
SetRenderState(D3DRS_POINTSPRITEENABLE, FALSE);
|
SetRenderState(D3DRS_POINTSCALEENABLE, FALSE);
|
SetRenderState(D3DRS_POINTSCALE_A, FtoDW(1.0f));
|
SetRenderState(D3DRS_POINTSCALE_B, FtoDW(0.0f));
|
SetRenderState(D3DRS_POINTSCALE_C, FtoDW(0.0f));
|
SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, TRUE);
|
SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
|
SetRenderState(D3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_DISCRETE);
|
SetRenderState(D3DRS_DEBUGMONITORTOKEN, D3DDMT_ENABLE);
|
SetRenderState(D3DRS_POINTSIZE_MAX, FtoDW(64.0f));
|
SetRenderState(D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE);
|
SetRenderState(D3DRS_COLORWRITEENABLE, 0x0000000F);
|
SetRenderState(D3DRS_TWEENFACTOR, FtoDW(0.0f));
|
SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
|
SetRenderState(D3DRS_POSITIONDEGREE, D3DDEGREE_CUBIC);
|
SetRenderState(D3DRS_NORMALDEGREE, D3DDEGREE_LINEAR);
|
SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
|
SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, FtoDW(0.0f));
|
SetRenderState(D3DRS_ANTIALIASEDLINEENABLE, FALSE);
|
SetRenderState(D3DRS_MINTESSELLATIONLEVEL, FtoDW(1.0f));
|
SetRenderState(D3DRS_MAXTESSELLATIONLEVEL, FtoDW(1.0f));
|
SetRenderState(D3DRS_ADAPTIVETESS_X, FtoDW(0.0f));
|
SetRenderState(D3DRS_ADAPTIVETESS_Y, FtoDW(0.0f));
|
SetRenderState(D3DRS_ADAPTIVETESS_Z, FtoDW(1.0f));
|
SetRenderState(D3DRS_ADAPTIVETESS_W, FtoDW(0.0f));
|
SetRenderState(D3DRS_ENABLEADAPTIVETESSELLATION, FALSE);
|
SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE);
|
SetRenderState(D3DRS_CCW_STENCILFAIL, D3DSTENCILOP_KEEP);
|
SetRenderState(D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_KEEP);
|
SetRenderState(D3DRS_CCW_STENCILPASS, D3DSTENCILOP_KEEP);
|
SetRenderState(D3DRS_CCW_STENCILFUNC, D3DCMP_ALWAYS);
|
SetRenderState(D3DRS_COLORWRITEENABLE1, 0x0000000F);
|
SetRenderState(D3DRS_COLORWRITEENABLE2, 0x0000000F);
|
SetRenderState(D3DRS_COLORWRITEENABLE3, 0x0000000F);
|
SetRenderState(D3DRS_BLENDFACTOR, 0xFFFFFFFF);
|
SetRenderState(D3DRS_SRGBWRITEENABLE, 0);
|
SetRenderState(D3DRS_DEPTHBIAS, FtoDW(0.0f));
|
SetRenderState(D3DRS_WRAP8, 0);
|
SetRenderState(D3DRS_WRAP9, 0);
|
SetRenderState(D3DRS_WRAP10, 0);
|
SetRenderState(D3DRS_WRAP11, 0);
|
SetRenderState(D3DRS_WRAP12, 0);
|
SetRenderState(D3DRS_WRAP13, 0);
|
SetRenderState(D3DRS_WRAP14, 0);
|
SetRenderState(D3DRS_WRAP15, 0);
|
SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
|
SetRenderState(D3DRS_SRCBLENDALPHA, D3DBLEND_ONE);
|
SetRenderState(D3DRS_DESTBLENDALPHA, D3DBLEND_ZERO);
|
SetRenderState(D3DRS_BLENDOPALPHA, D3DBLENDOP_ADD);
|
|
for(int i = 0; i < 8; i++)
|
{
|
SetTextureStageState(i, D3DTSS_COLOROP, i == 0 ? D3DTOP_MODULATE : D3DTOP_DISABLE);
|
SetTextureStageState(i, D3DTSS_COLORARG1, D3DTA_TEXTURE);
|
SetTextureStageState(i, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
SetTextureStageState(i, D3DTSS_ALPHAOP, i == 0 ? D3DTOP_SELECTARG1 : D3DTOP_DISABLE);
|
SetTextureStageState(i, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
|
SetTextureStageState(i, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
|
SetTextureStageState(i, D3DTSS_BUMPENVMAT00, FtoDW(0.0f));
|
SetTextureStageState(i, D3DTSS_BUMPENVMAT01, FtoDW(0.0f));
|
SetTextureStageState(i, D3DTSS_BUMPENVMAT10, FtoDW(0.0f));
|
SetTextureStageState(i, D3DTSS_BUMPENVMAT11, FtoDW(0.0f));
|
SetTextureStageState(i, D3DTSS_TEXCOORDINDEX, i);
|
SetTextureStageState(i, D3DTSS_BUMPENVLSCALE, FtoDW(0.0f));
|
SetTextureStageState(i, D3DTSS_BUMPENVLOFFSET, FtoDW(0.0f));
|
SetTextureStageState(i, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
SetTextureStageState(i, D3DTSS_COLORARG0, D3DTA_CURRENT);
|
SetTextureStageState(i, D3DTSS_ALPHAARG0, D3DTA_CURRENT);
|
SetTextureStageState(i, D3DTSS_RESULTARG, D3DTA_CURRENT);
|
SetTextureStageState(i, D3DTSS_CONSTANT, 0x00000000);
|
}
|
|
for(int i = 0; i <= D3DVERTEXTEXTURESAMPLER3; i = (i != 15) ? (i + 1) : D3DVERTEXTEXTURESAMPLER0)
|
{
|
SetTexture(i, 0);
|
|
SetSamplerState(i, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
|
SetSamplerState(i, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
|
SetSamplerState(i, D3DSAMP_ADDRESSW, D3DTADDRESS_WRAP);
|
SetSamplerState(i, D3DSAMP_BORDERCOLOR, 0x00000000);
|
SetSamplerState(i, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
|
SetSamplerState(i, D3DSAMP_MINFILTER, D3DTEXF_POINT);
|
SetSamplerState(i, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
|
SetSamplerState(i, D3DSAMP_MIPMAPLODBIAS, 0);
|
SetSamplerState(i, D3DSAMP_MAXMIPLEVEL, 0);
|
SetSamplerState(i, D3DSAMP_MAXANISOTROPY, 1);
|
SetSamplerState(i, D3DSAMP_SRGBTEXTURE, 0);
|
SetSamplerState(i, D3DSAMP_ELEMENTINDEX, 0);
|
SetSamplerState(i, D3DSAMP_DMAPOFFSET, 0);
|
}
|
|
for(int i = 0; i < 6; i++)
|
{
|
float plane[4] = {0, 0, 0, 0};
|
|
SetClipPlane(i, plane);
|
}
|
|
currentPalette = 0xFFFF;
|
|
ShowCursor(FALSE);
|
delete cursor;
|
cursor = 0;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetClipPlane(unsigned long index, const float *plane)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, const float *plane = 0x%0.8p", index, plane);
|
|
if(!plane || index >= 6)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
this->plane[index][0] = plane[0];
|
this->plane[index][1] = plane[1];
|
this->plane[index][2] = plane[2];
|
this->plane[index][3] = plane[3];
|
|
renderer->setClipPlane(index, plane);
|
}
|
else
|
{
|
stateRecorder->setClipPlane(index, plane);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetClipStatus(const D3DCLIPSTATUS9 *clipStatus)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const D3DCLIPSTATUS9 *clipStatus = 0x%0.8p", clipStatus);
|
|
if(!clipStatus)
|
{
|
return INVALIDCALL();
|
}
|
|
this->clipStatus = *clipStatus;
|
|
UNIMPLEMENTED();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetCurrentTexturePalette(unsigned int paletteNumber)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int paletteNumber = %d", paletteNumber);
|
|
if(paletteNumber > 0xFFFF || palette.find(paletteNumber) == palette.end())
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
currentPalette = paletteNumber;
|
|
sw::Surface::setTexturePalette((unsigned int*)&palette[currentPalette]);
|
}
|
else
|
{
|
stateRecorder->setCurrentTexturePalette(paletteNumber);
|
}
|
|
return D3D_OK;
|
}
|
|
void Direct3DDevice9::SetCursorPosition(int x, int y, unsigned long flags)
|
{
|
CriticalSection cs(this);
|
|
TRACE("int x = %d, int y = %d, unsigned long flags = 0x%0.8X", x, y, flags);
|
|
POINT point = {x, y};
|
HWND window = deviceWindow ? deviceWindow : focusWindow;
|
ScreenToClient(window, &point);
|
|
sw::FrameBuffer::setCursorPosition(point.x, point.y);
|
}
|
|
long Direct3DDevice9::SetCursorProperties(unsigned int x0, unsigned int y0, IDirect3DSurface9 *cursorBitmap)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int x0 = %d, unsigned int y0 = %d, IDirect3DSurface9 *cursorBitmap = 0x%0.8p", x0, y0, cursorBitmap);
|
|
if(!cursorBitmap)
|
{
|
return INVALIDCALL();
|
}
|
|
sw::Surface *cursorSurface = static_cast<Direct3DSurface9*>(cursorBitmap);
|
|
int width = cursorSurface->getWidth();
|
int height = cursorSurface->getHeight();
|
void *bitmap = cursorSurface->lockExternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
|
|
delete cursor;
|
cursor = sw::Surface::create(nullptr, width, height, 1, 0, 1, sw::FORMAT_A8R8G8B8, false, false);
|
|
void *buffer = cursor->lockExternal(0, 0, 0, sw::LOCK_DISCARD, sw::PUBLIC);
|
memcpy(buffer, bitmap, width * height * sizeof(unsigned int));
|
cursor->unlockExternal();
|
|
cursorSurface->unlockExternal();
|
|
if(showCursor)
|
{
|
sw::FrameBuffer::setCursorImage(cursor);
|
}
|
else
|
{
|
sw::FrameBuffer::setCursorImage(nullptr);
|
}
|
|
sw::FrameBuffer::setCursorOrigin(x0, y0);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetDepthStencilSurface(IDirect3DSurface9 *iDepthStencil)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DSurface9 *newDepthStencil = 0x%0.8p", iDepthStencil);
|
|
Direct3DSurface9 *depthStencil = static_cast<Direct3DSurface9*>(iDepthStencil);
|
|
if(this->depthStencil == depthStencil)
|
{
|
return D3D_OK;
|
}
|
|
if(depthStencil)
|
{
|
depthStencil->bind();
|
}
|
|
if(this->depthStencil)
|
{
|
this->depthStencil->unbind();
|
}
|
|
this->depthStencil = depthStencil;
|
|
renderer->setDepthBuffer(depthStencil);
|
renderer->setStencilBuffer(depthStencil);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetDialogBoxMode(int enableDialogs)
|
{
|
CriticalSection cs(this);
|
|
TRACE("int enableDialogs = %d", enableDialogs);
|
|
UNIMPLEMENTED();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetFVF(unsigned long FVF)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long FVF = 0x%0.8X", FVF);
|
|
if(!stateRecorder)
|
{
|
if(FVF != 0 || !this->vertexDeclaration)
|
{
|
Direct3DVertexDeclaration9 *vertexDeclaration = new Direct3DVertexDeclaration9(this, FVF);
|
vertexDeclaration->bind();
|
|
if(this->vertexDeclaration)
|
{
|
this->vertexDeclaration->unbind();
|
}
|
|
this->vertexDeclaration = vertexDeclaration;
|
}
|
}
|
else
|
{
|
stateRecorder->setFVF(FVF);
|
}
|
|
return D3D_OK;
|
}
|
|
void Direct3DDevice9::SetGammaRamp(unsigned int index, unsigned long flags, const D3DGAMMARAMP *ramp)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int index = %d, unsigned long flags = 0x%0.8X, const D3DGAMMARAMP *ramp = 0x%0.8p", index, flags, ramp);
|
|
if(!ramp || index >= GetNumberOfSwapChains())
|
{
|
return;
|
}
|
|
swapChain->setGammaRamp((sw::GammaRamp*)ramp, flags & D3DSGR_CALIBRATE);
|
}
|
|
long Direct3DDevice9::SetIndices(IDirect3DIndexBuffer9* iIndexBuffer)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DIndexBuffer9* indexData = 0x%0.8p", iIndexBuffer);
|
|
Direct3DIndexBuffer9 *indexBuffer = static_cast<Direct3DIndexBuffer9*>(iIndexBuffer);
|
|
if(!stateRecorder)
|
{
|
if(this->indexData == indexBuffer)
|
{
|
return D3D_OK;
|
}
|
|
if(indexBuffer)
|
{
|
indexBuffer->bind();
|
}
|
|
if(this->indexData)
|
{
|
this->indexData->unbind();
|
}
|
|
this->indexData = indexBuffer;
|
}
|
else
|
{
|
stateRecorder->setIndices(indexBuffer);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetLight(unsigned long index, const D3DLIGHT9 *light)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, const D3DLIGHT9 *light = 0x%0.8p", index, light);
|
|
if(!light)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
this->light[index] = *light;
|
|
lightsDirty = true;
|
}
|
else
|
{
|
stateRecorder->setLight(index, light);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetMaterial(const D3DMATERIAL9 *material)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const D3DMATERIAL9 *material = 0x%0.8p", material);
|
|
if(!material)
|
{
|
return INVALIDCALL(); // FIXME: Correct behaviour?
|
}
|
|
if(!stateRecorder)
|
{
|
this->material = *material;
|
|
renderer->setMaterialAmbient(sw::Color<float>(material->Ambient.r, material->Ambient.g, material->Ambient.b, material->Ambient.a));
|
renderer->setMaterialDiffuse(sw::Color<float>(material->Diffuse.r, material->Diffuse.g, material->Diffuse.b, material->Diffuse.a));
|
renderer->setMaterialEmission(sw::Color<float>(material->Emissive.r, material->Emissive.g, material->Emissive.b, material->Emissive.a));
|
renderer->setMaterialShininess(material->Power);
|
renderer->setMaterialSpecular(sw::Color<float>(material->Specular.r, material->Specular.g, material->Specular.b, material->Specular.a));
|
}
|
else
|
{
|
stateRecorder->setMaterial(material);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetNPatchMode(float segments)
|
{
|
CriticalSection cs(this);
|
|
TRACE("float segments = %f", segments);
|
|
if(!stateRecorder)
|
{
|
if(segments < 1)
|
{
|
// NOTE: Disable
|
}
|
else
|
{
|
UNIMPLEMENTED();
|
}
|
}
|
else
|
{
|
stateRecorder->setNPatchMode(segments);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetPaletteEntries(unsigned int paletteNumber, const PALETTEENTRY *entries)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int paletteNumber = %d, const PALETTEENTRY *entries = 0x%0.8p", paletteNumber, entries);
|
|
if(paletteNumber > 0xFFFF || !entries)
|
{
|
return INVALIDCALL();
|
}
|
|
for(int i = 0; i < 256; i++)
|
{
|
palette[paletteNumber].entry[i] = entries[i];
|
}
|
|
if(paletteNumber == currentPalette)
|
{
|
sw::Surface::setTexturePalette((unsigned int*)&palette[currentPalette]);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetPixelShader(IDirect3DPixelShader9 *iPixelShader)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DPixelShader9 *shader = 0x%0.8p", iPixelShader);
|
|
Direct3DPixelShader9 *pixelShader = static_cast<Direct3DPixelShader9*>(iPixelShader);
|
|
if(!stateRecorder)
|
{
|
if(this->pixelShader == pixelShader)
|
{
|
return D3D_OK;
|
}
|
|
if(pixelShader)
|
{
|
pixelShader->bind();
|
}
|
|
if(this->pixelShader)
|
{
|
this->pixelShader->unbind();
|
}
|
|
this->pixelShader = pixelShader;
|
pixelShaderDirty = true;
|
}
|
else
|
{
|
stateRecorder->setPixelShader(pixelShader);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetPixelShaderConstantB(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!stateRecorder)
|
{
|
for(unsigned int i = 0; i < count && startRegister + i < 16; i++)
|
{
|
pixelShaderConstantB[startRegister + i] = constantData[i];
|
}
|
|
pixelShaderConstantsBDirty = sw::max(startRegister + count, pixelShaderConstantsBDirty);
|
pixelShaderDirty = true; // Reload DEF constants
|
}
|
else
|
{
|
stateRecorder->setPixelShaderConstantB(startRegister, constantData, count);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!stateRecorder)
|
{
|
for(unsigned int i = 0; i < count && startRegister + i < MAX_PIXEL_SHADER_CONST; i++)
|
{
|
pixelShaderConstantF[startRegister + i][0] = constantData[i * 4 + 0];
|
pixelShaderConstantF[startRegister + i][1] = constantData[i * 4 + 1];
|
pixelShaderConstantF[startRegister + i][2] = constantData[i * 4 + 2];
|
pixelShaderConstantF[startRegister + i][3] = constantData[i * 4 + 3];
|
}
|
|
pixelShaderConstantsFDirty = sw::max(startRegister + count, pixelShaderConstantsFDirty);
|
pixelShaderDirty = true; // Reload DEF constants
|
}
|
else
|
{
|
stateRecorder->setPixelShaderConstantF(startRegister, constantData, count);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetPixelShaderConstantI(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!stateRecorder)
|
{
|
for(unsigned int i = 0; i < count && startRegister + i < 16; i++)
|
{
|
pixelShaderConstantI[startRegister + i][0] = constantData[i * 4 + 0];
|
pixelShaderConstantI[startRegister + i][1] = constantData[i * 4 + 1];
|
pixelShaderConstantI[startRegister + i][2] = constantData[i * 4 + 2];
|
pixelShaderConstantI[startRegister + i][3] = constantData[i * 4 + 3];
|
}
|
|
pixelShaderConstantsIDirty = sw::max(startRegister + count, pixelShaderConstantsIDirty);
|
pixelShaderDirty = true; // Reload DEF constants
|
}
|
else
|
{
|
stateRecorder->setPixelShaderConstantI(startRegister, constantData, count);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetRenderState(D3DRENDERSTATETYPE state, unsigned long value)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DRENDERSTATETYPE state = %d, unsigned long value = %d", state, value);
|
|
if(state < D3DRS_ZENABLE || state > D3DRS_BLENDOPALPHA)
|
{
|
return D3D_OK; // FIXME: Warning
|
}
|
|
if(!stateRecorder)
|
{
|
if(!init && renderState[state] == value)
|
{
|
return D3D_OK;
|
}
|
|
renderState[state] = value;
|
|
switch(state)
|
{
|
case D3DRS_ZENABLE:
|
switch(value)
|
{
|
case D3DZB_TRUE:
|
case D3DZB_USEW:
|
renderer->setDepthBufferEnable(true);
|
break;
|
case D3DZB_FALSE:
|
renderer->setDepthBufferEnable(false);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_FILLMODE:
|
switch(value)
|
{
|
case D3DFILL_POINT:
|
renderer->setFillMode(sw::FILL_VERTEX);
|
break;
|
case D3DFILL_WIREFRAME:
|
renderer->setFillMode(sw::FILL_WIREFRAME);
|
break;
|
case D3DFILL_SOLID:
|
renderer->setFillMode(sw::FILL_SOLID);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_SHADEMODE:
|
switch(value)
|
{
|
case D3DSHADE_FLAT:
|
renderer->setShadingMode(sw::SHADING_FLAT);
|
break;
|
case D3DSHADE_GOURAUD:
|
renderer->setShadingMode(sw::SHADING_GOURAUD);
|
break;
|
case D3DSHADE_PHONG:
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_ZWRITEENABLE:
|
renderer->setDepthWriteEnable(value != FALSE);
|
break;
|
case D3DRS_ALPHATESTENABLE:
|
renderer->setAlphaTestEnable(value != FALSE);
|
break;
|
case D3DRS_LASTPIXEL:
|
// if(!init) UNIMPLEMENTED(); // FIXME
|
break;
|
case D3DRS_SRCBLEND:
|
switch(value)
|
{
|
case D3DBLEND_ZERO:
|
renderer->setSourceBlendFactor(sw::BLEND_ZERO);
|
break;
|
case D3DBLEND_ONE:
|
renderer->setSourceBlendFactor(sw::BLEND_ONE);
|
break;
|
case D3DBLEND_SRCCOLOR:
|
renderer->setSourceBlendFactor(sw::BLEND_SOURCE);
|
break;
|
case D3DBLEND_INVSRCCOLOR:
|
renderer->setSourceBlendFactor(sw::BLEND_INVSOURCE);
|
break;
|
case D3DBLEND_SRCALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_INVSRCALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_DESTALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_DESTALPHA);
|
break;
|
case D3DBLEND_INVDESTALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_INVDESTALPHA);
|
break;
|
case D3DBLEND_DESTCOLOR:
|
renderer->setSourceBlendFactor(sw::BLEND_DEST);
|
break;
|
case D3DBLEND_INVDESTCOLOR:
|
renderer->setSourceBlendFactor(sw::BLEND_INVDEST);
|
break;
|
case D3DBLEND_SRCALPHASAT:
|
renderer->setSourceBlendFactor(sw::BLEND_SRCALPHASAT);
|
break;
|
case D3DBLEND_BOTHSRCALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_SOURCEALPHA);
|
renderer->setDestBlendFactor(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_BOTHINVSRCALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_INVSOURCEALPHA);
|
renderer->setDestBlendFactor(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_BLENDFACTOR:
|
renderer->setSourceBlendFactor(sw::BLEND_CONSTANT);
|
break;
|
case D3DBLEND_INVBLENDFACTOR:
|
renderer->setSourceBlendFactor(sw::BLEND_INVCONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_DESTBLEND:
|
switch(value)
|
{
|
case D3DBLEND_ZERO:
|
renderer->setDestBlendFactor(sw::BLEND_ZERO);
|
break;
|
case D3DBLEND_ONE:
|
renderer->setDestBlendFactor(sw::BLEND_ONE);
|
break;
|
case D3DBLEND_SRCCOLOR:
|
renderer->setDestBlendFactor(sw::BLEND_SOURCE);
|
break;
|
case D3DBLEND_INVSRCCOLOR:
|
renderer->setDestBlendFactor(sw::BLEND_INVSOURCE);
|
break;
|
case D3DBLEND_SRCALPHA:
|
renderer->setDestBlendFactor(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_INVSRCALPHA:
|
renderer->setDestBlendFactor(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_DESTALPHA:
|
renderer->setDestBlendFactor(sw::BLEND_DESTALPHA);
|
break;
|
case D3DBLEND_INVDESTALPHA:
|
renderer->setDestBlendFactor(sw::BLEND_INVDESTALPHA);
|
break;
|
case D3DBLEND_DESTCOLOR:
|
renderer->setDestBlendFactor(sw::BLEND_DEST);
|
break;
|
case D3DBLEND_INVDESTCOLOR:
|
renderer->setDestBlendFactor(sw::BLEND_INVDEST);
|
break;
|
case D3DBLEND_SRCALPHASAT:
|
renderer->setDestBlendFactor(sw::BLEND_SRCALPHASAT);
|
break;
|
case D3DBLEND_BOTHSRCALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_SOURCEALPHA);
|
renderer->setDestBlendFactor(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_BOTHINVSRCALPHA:
|
renderer->setSourceBlendFactor(sw::BLEND_INVSOURCEALPHA);
|
renderer->setDestBlendFactor(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_BLENDFACTOR:
|
renderer->setDestBlendFactor(sw::BLEND_CONSTANT);
|
break;
|
case D3DBLEND_INVBLENDFACTOR:
|
renderer->setDestBlendFactor(sw::BLEND_INVCONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_CULLMODE:
|
switch(value)
|
{
|
case D3DCULL_NONE:
|
renderer->setCullMode(sw::CULL_NONE, true);
|
break;
|
case D3DCULL_CCW:
|
renderer->setCullMode(sw::CULL_COUNTERCLOCKWISE, true);
|
break;
|
case D3DCULL_CW:
|
renderer->setCullMode(sw::CULL_CLOCKWISE, true);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_ZFUNC:
|
switch(value)
|
{
|
case D3DCMP_NEVER:
|
renderer->setDepthCompare(sw::DEPTH_NEVER);
|
break;
|
case D3DCMP_LESS:
|
renderer->setDepthCompare(sw::DEPTH_LESS);
|
break;
|
case D3DCMP_EQUAL:
|
renderer->setDepthCompare(sw::DEPTH_EQUAL);
|
break;
|
case D3DCMP_LESSEQUAL:
|
renderer->setDepthCompare(sw::DEPTH_LESSEQUAL);
|
break;
|
case D3DCMP_GREATER:
|
renderer->setDepthCompare(sw::DEPTH_GREATER);
|
break;
|
case D3DCMP_NOTEQUAL:
|
renderer->setDepthCompare(sw::DEPTH_NOTEQUAL);
|
break;
|
case D3DCMP_GREATEREQUAL:
|
renderer->setDepthCompare(sw::DEPTH_GREATEREQUAL);
|
break;
|
case D3DCMP_ALWAYS:
|
renderer->setDepthCompare(sw::DEPTH_ALWAYS);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_ALPHAREF:
|
renderer->setAlphaReference(value & 0x000000FF);
|
break;
|
case D3DRS_ALPHAFUNC:
|
switch(value)
|
{
|
case D3DCMP_NEVER:
|
renderer->setAlphaCompare(sw::ALPHA_NEVER);
|
break;
|
case D3DCMP_LESS:
|
renderer->setAlphaCompare(sw::ALPHA_LESS);
|
break;
|
case D3DCMP_EQUAL:
|
renderer->setAlphaCompare(sw::ALPHA_EQUAL);
|
break;
|
case D3DCMP_LESSEQUAL:
|
renderer->setAlphaCompare(sw::ALPHA_LESSEQUAL);
|
break;
|
case D3DCMP_GREATER:
|
renderer->setAlphaCompare(sw::ALPHA_GREATER);
|
break;
|
case D3DCMP_NOTEQUAL:
|
renderer->setAlphaCompare(sw::ALPHA_NOTEQUAL);
|
break;
|
case D3DCMP_GREATEREQUAL:
|
renderer->setAlphaCompare(sw::ALPHA_GREATEREQUAL);
|
break;
|
case D3DCMP_ALWAYS:
|
renderer->setAlphaCompare(sw::ALPHA_ALWAYS);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_DITHERENABLE:
|
// if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_ALPHABLENDENABLE:
|
renderer->setAlphaBlendEnable(value != FALSE);
|
break;
|
case D3DRS_FOGENABLE:
|
renderer->setFogEnable(value != FALSE);
|
break;
|
case D3DRS_FOGCOLOR:
|
renderer->setFogColor(value);
|
break;
|
case D3DRS_FOGTABLEMODE:
|
switch(value)
|
{
|
case D3DFOG_NONE:
|
renderer->setPixelFogMode(sw::FOG_NONE);
|
break;
|
case D3DFOG_LINEAR:
|
renderer->setPixelFogMode(sw::FOG_LINEAR);
|
break;
|
case D3DFOG_EXP:
|
renderer->setPixelFogMode(sw::FOG_EXP);
|
break;
|
case D3DFOG_EXP2:
|
renderer->setPixelFogMode(sw::FOG_EXP2);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_FOGSTART:
|
renderer->setFogStart((float&)value);
|
break;
|
case D3DRS_FOGEND:
|
renderer->setFogEnd((float&)value);
|
break;
|
case D3DRS_FOGDENSITY:
|
renderer->setFogDensity((float&)value);
|
break;
|
case D3DRS_RANGEFOGENABLE:
|
renderer->setRangeFogEnable(value != FALSE);
|
break;
|
case D3DRS_SPECULARENABLE:
|
renderer->setSpecularEnable(value != FALSE);
|
break;
|
case D3DRS_STENCILENABLE:
|
renderer->setStencilEnable(value != FALSE);
|
break;
|
case D3DRS_STENCILFAIL:
|
switch(value)
|
{
|
case D3DSTENCILOP_KEEP:
|
renderer->setStencilFailOperation(sw::OPERATION_KEEP);
|
break;
|
case D3DSTENCILOP_ZERO:
|
renderer->setStencilFailOperation(sw::OPERATION_ZERO);
|
break;
|
case D3DSTENCILOP_REPLACE:
|
renderer->setStencilFailOperation(sw::OPERATION_REPLACE);
|
break;
|
case D3DSTENCILOP_INCRSAT:
|
renderer->setStencilFailOperation(sw::OPERATION_INCRSAT);
|
break;
|
case D3DSTENCILOP_DECRSAT:
|
renderer->setStencilFailOperation(sw::OPERATION_DECRSAT);
|
break;
|
case D3DSTENCILOP_INVERT:
|
renderer->setStencilFailOperation(sw::OPERATION_INVERT);
|
break;
|
case D3DSTENCILOP_INCR:
|
renderer->setStencilFailOperation(sw::OPERATION_INCR);
|
break;
|
case D3DSTENCILOP_DECR:
|
renderer->setStencilFailOperation(sw::OPERATION_DECR);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_STENCILZFAIL:
|
switch(value)
|
{
|
case D3DSTENCILOP_KEEP:
|
renderer->setStencilZFailOperation(sw::OPERATION_KEEP);
|
break;
|
case D3DSTENCILOP_ZERO:
|
renderer->setStencilZFailOperation(sw::OPERATION_ZERO);
|
break;
|
case D3DSTENCILOP_REPLACE:
|
renderer->setStencilZFailOperation(sw::OPERATION_REPLACE);
|
break;
|
case D3DSTENCILOP_INCRSAT:
|
renderer->setStencilZFailOperation(sw::OPERATION_INCRSAT);
|
break;
|
case D3DSTENCILOP_DECRSAT:
|
renderer->setStencilZFailOperation(sw::OPERATION_DECRSAT);
|
break;
|
case D3DSTENCILOP_INVERT:
|
renderer->setStencilZFailOperation(sw::OPERATION_INVERT);
|
break;
|
case D3DSTENCILOP_INCR:
|
renderer->setStencilZFailOperation(sw::OPERATION_INCR);
|
break;
|
case D3DSTENCILOP_DECR:
|
renderer->setStencilZFailOperation(sw::OPERATION_DECR);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_STENCILPASS:
|
switch(value)
|
{
|
case D3DSTENCILOP_KEEP:
|
renderer->setStencilPassOperation(sw::OPERATION_KEEP);
|
break;
|
case D3DSTENCILOP_ZERO:
|
renderer->setStencilPassOperation(sw::OPERATION_ZERO);
|
break;
|
case D3DSTENCILOP_REPLACE:
|
renderer->setStencilPassOperation(sw::OPERATION_REPLACE);
|
break;
|
case D3DSTENCILOP_INCRSAT:
|
renderer->setStencilPassOperation(sw::OPERATION_INCRSAT);
|
break;
|
case D3DSTENCILOP_DECRSAT:
|
renderer->setStencilPassOperation(sw::OPERATION_DECRSAT);
|
break;
|
case D3DSTENCILOP_INVERT:
|
renderer->setStencilPassOperation(sw::OPERATION_INVERT);
|
break;
|
case D3DSTENCILOP_INCR:
|
renderer->setStencilPassOperation(sw::OPERATION_INCR);
|
break;
|
case D3DSTENCILOP_DECR:
|
renderer->setStencilPassOperation(sw::OPERATION_DECR);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_STENCILFUNC:
|
switch(value)
|
{
|
case D3DCMP_NEVER:
|
renderer->setStencilCompare(sw::STENCIL_NEVER);
|
break;
|
case D3DCMP_LESS:
|
renderer->setStencilCompare(sw::STENCIL_LESS);
|
break;
|
case D3DCMP_EQUAL:
|
renderer->setStencilCompare(sw::STENCIL_EQUAL);
|
break;
|
case D3DCMP_LESSEQUAL:
|
renderer->setStencilCompare(sw::STENCIL_LESSEQUAL);
|
break;
|
case D3DCMP_GREATER:
|
renderer->setStencilCompare(sw::STENCIL_GREATER);
|
break;
|
case D3DCMP_NOTEQUAL:
|
renderer->setStencilCompare(sw::STENCIL_NOTEQUAL);
|
break;
|
case D3DCMP_GREATEREQUAL:
|
renderer->setStencilCompare(sw::STENCIL_GREATEREQUAL);
|
break;
|
case D3DCMP_ALWAYS:
|
renderer->setStencilCompare(sw::STENCIL_ALWAYS);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_STENCILREF:
|
renderer->setStencilReference(value);
|
renderer->setStencilReferenceCCW(value);
|
break;
|
case D3DRS_STENCILMASK:
|
renderer->setStencilMask(value);
|
renderer->setStencilMaskCCW(value);
|
break;
|
case D3DRS_STENCILWRITEMASK:
|
renderer->setStencilWriteMask(value);
|
renderer->setStencilWriteMaskCCW(value);
|
break;
|
case D3DRS_TEXTUREFACTOR:
|
renderer->setTextureFactor(value);
|
break;
|
case D3DRS_WRAP0:
|
renderer->setTextureWrap(0, value);
|
break;
|
case D3DRS_WRAP1:
|
renderer->setTextureWrap(1, value);
|
break;
|
case D3DRS_WRAP2:
|
renderer->setTextureWrap(2, value);
|
break;
|
case D3DRS_WRAP3:
|
renderer->setTextureWrap(3, value);
|
break;
|
case D3DRS_WRAP4:
|
renderer->setTextureWrap(4, value);
|
break;
|
case D3DRS_WRAP5:
|
renderer->setTextureWrap(5, value);
|
break;
|
case D3DRS_WRAP6:
|
renderer->setTextureWrap(6, value);
|
break;
|
case D3DRS_WRAP7:
|
renderer->setTextureWrap(7, value);
|
break;
|
case D3DRS_CLIPPING:
|
// Ignored, clipping is always performed
|
break;
|
case D3DRS_LIGHTING:
|
renderer->setLightingEnable(value != FALSE);
|
break;
|
case D3DRS_AMBIENT:
|
renderer->setGlobalAmbient(value);
|
break;
|
case D3DRS_FOGVERTEXMODE:
|
switch(value)
|
{
|
case D3DFOG_NONE:
|
renderer->setVertexFogMode(sw::FOG_NONE);
|
break;
|
case D3DFOG_LINEAR:
|
renderer->setVertexFogMode(sw::FOG_LINEAR);
|
break;
|
case D3DFOG_EXP:
|
renderer->setVertexFogMode(sw::FOG_EXP);
|
break;
|
case D3DFOG_EXP2:
|
renderer->setVertexFogMode(sw::FOG_EXP2);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_COLORVERTEX:
|
renderer->setColorVertexEnable(value != FALSE);
|
break;
|
case D3DRS_LOCALVIEWER:
|
renderer->setLocalViewer(value != FALSE);
|
break;
|
case D3DRS_NORMALIZENORMALS:
|
renderer->setNormalizeNormals(value != FALSE);
|
break;
|
case D3DRS_DIFFUSEMATERIALSOURCE:
|
switch(value)
|
{
|
case D3DMCS_MATERIAL:
|
renderer->setDiffuseMaterialSource(sw::MATERIAL_MATERIAL);
|
break;
|
case D3DMCS_COLOR1:
|
renderer->setDiffuseMaterialSource(sw::MATERIAL_COLOR1);
|
break;
|
case D3DMCS_COLOR2:
|
renderer->setDiffuseMaterialSource(sw::MATERIAL_COLOR2);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_SPECULARMATERIALSOURCE:
|
switch(value)
|
{
|
case D3DMCS_MATERIAL:
|
renderer->setSpecularMaterialSource(sw::MATERIAL_MATERIAL);
|
break;
|
case D3DMCS_COLOR1:
|
renderer->setSpecularMaterialSource(sw::MATERIAL_COLOR1);
|
break;
|
case D3DMCS_COLOR2:
|
renderer->setSpecularMaterialSource(sw::MATERIAL_COLOR2);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_AMBIENTMATERIALSOURCE:
|
switch(value)
|
{
|
case D3DMCS_MATERIAL:
|
renderer->setAmbientMaterialSource(sw::MATERIAL_MATERIAL);
|
break;
|
case D3DMCS_COLOR1:
|
renderer->setAmbientMaterialSource(sw::MATERIAL_COLOR1);
|
break;
|
case D3DMCS_COLOR2:
|
renderer->setAmbientMaterialSource(sw::MATERIAL_COLOR2);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_EMISSIVEMATERIALSOURCE:
|
switch(value)
|
{
|
case D3DMCS_MATERIAL:
|
renderer->setEmissiveMaterialSource(sw::MATERIAL_MATERIAL);
|
break;
|
case D3DMCS_COLOR1:
|
renderer->setEmissiveMaterialSource(sw::MATERIAL_COLOR1);
|
break;
|
case D3DMCS_COLOR2:
|
renderer->setEmissiveMaterialSource(sw::MATERIAL_COLOR2);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_VERTEXBLEND:
|
switch(value)
|
{
|
case D3DVBF_DISABLE:
|
renderer->setVertexBlendMatrixCount(0);
|
break;
|
case D3DVBF_1WEIGHTS:
|
renderer->setVertexBlendMatrixCount(2);
|
break;
|
case D3DVBF_2WEIGHTS:
|
renderer->setVertexBlendMatrixCount(3);
|
break;
|
case D3DVBF_3WEIGHTS:
|
renderer->setVertexBlendMatrixCount(4);
|
break;
|
case D3DVBF_TWEENING:
|
UNIMPLEMENTED();
|
break;
|
case D3DVBF_0WEIGHTS:
|
renderer->setVertexBlendMatrixCount(1);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_CLIPPLANEENABLE:
|
renderer->setClipFlags(value);
|
break;
|
case D3DRS_POINTSIZE:
|
if(value == D3DFMT_INST && pixelShaderVersionX >= D3DPS_VERSION(2, 0)) // ATI hack to enable instancing on SM 2.0 hardware
|
{
|
instancingEnabled = true;
|
}
|
else if(value == D3DFMT_A2M1) // ATI hack to enable transparency anti-aliasing
|
{
|
renderer->setTransparencyAntialiasing(sw::TRANSPARENCY_ALPHA_TO_COVERAGE);
|
renderer->setAlphaTestEnable(true);
|
}
|
else if(value == D3DFMT_A2M0) // ATI hack to disable transparency anti-aliasing
|
{
|
renderer->setTransparencyAntialiasing(sw::TRANSPARENCY_NONE);
|
renderer->setAlphaTestEnable(false);
|
}
|
else
|
{
|
renderer->setPointSize((float&)value);
|
}
|
break;
|
case D3DRS_POINTSIZE_MIN:
|
renderer->setPointSizeMin((float&)value);
|
break;
|
case D3DRS_POINTSPRITEENABLE:
|
renderer->setPointSpriteEnable(value != FALSE);
|
break;
|
case D3DRS_POINTSCALEENABLE:
|
renderer->setPointScaleEnable(value != FALSE);
|
break;
|
case D3DRS_POINTSCALE_A:
|
renderer->setPointScaleA((float&)value);
|
break;
|
case D3DRS_POINTSCALE_B:
|
renderer->setPointScaleB((float&)value);
|
break;
|
case D3DRS_POINTSCALE_C:
|
renderer->setPointScaleC((float&)value);
|
break;
|
case D3DRS_MULTISAMPLEANTIALIAS:
|
// if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_MULTISAMPLEMASK:
|
SetRenderTarget(0, renderTarget[0]); // Sets the multi-sample mask, if maskable
|
break;
|
case D3DRS_PATCHEDGESTYLE:
|
if(!init) if(value != D3DPATCHEDGE_DISCRETE) UNIMPLEMENTED();
|
break;
|
case D3DRS_DEBUGMONITORTOKEN:
|
if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_POINTSIZE_MAX:
|
renderer->setPointSizeMax((float&)value);
|
break;
|
case D3DRS_INDEXEDVERTEXBLENDENABLE:
|
renderer->setIndexedVertexBlendEnable(value != FALSE);
|
break;
|
case D3DRS_COLORWRITEENABLE:
|
renderer->setColorWriteMask(0, value & 0x0000000F);
|
break;
|
case D3DRS_TWEENFACTOR:
|
if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_BLENDOP:
|
switch(value)
|
{
|
case D3DBLENDOP_ADD:
|
renderer->setBlendOperation(sw::BLENDOP_ADD);
|
break;
|
case D3DBLENDOP_SUBTRACT:
|
renderer->setBlendOperation(sw::BLENDOP_SUB);
|
break;
|
case D3DBLENDOP_REVSUBTRACT:
|
renderer->setBlendOperation(sw::BLENDOP_INVSUB);
|
break;
|
case D3DBLENDOP_MIN:
|
renderer->setBlendOperation(sw::BLENDOP_MIN);
|
break;
|
case D3DBLENDOP_MAX:
|
renderer->setBlendOperation(sw::BLENDOP_MAX);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_POSITIONDEGREE:
|
if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_NORMALDEGREE:
|
if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_SCISSORTESTENABLE:
|
scissorEnable = (value != FALSE);
|
break;
|
case D3DRS_SLOPESCALEDEPTHBIAS:
|
renderer->setSlopeDepthBias((float&)value);
|
break;
|
case D3DRS_ANTIALIASEDLINEENABLE:
|
if(!init) if(value != FALSE) UNIMPLEMENTED();
|
break;
|
case D3DRS_MINTESSELLATIONLEVEL:
|
if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_MAXTESSELLATIONLEVEL:
|
if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_ADAPTIVETESS_X:
|
if(!init) if((float&)value != 0.0f) UNIMPLEMENTED();
|
break;
|
case D3DRS_ADAPTIVETESS_Y:
|
if(value == D3DFMT_ATOC) // NVIDIA hack to enable transparency anti-aliasing
|
{
|
renderer->setTransparencyAntialiasing(sw::TRANSPARENCY_ALPHA_TO_COVERAGE);
|
}
|
else if(value == D3DFMT_UNKNOWN) // NVIDIA hack to disable transparency anti-aliasing
|
{
|
renderer->setTransparencyAntialiasing(sw::TRANSPARENCY_NONE);
|
}
|
else
|
{
|
if(!init) if((float&)value != 0.0f) UNIMPLEMENTED();
|
}
|
break;
|
case D3DRS_ADAPTIVETESS_Z:
|
if(!init) if((float&)value != 1.0f) UNIMPLEMENTED();
|
break;
|
case D3DRS_ADAPTIVETESS_W:
|
if(!init) if((float&)value != 0.0f) UNIMPLEMENTED();
|
break;
|
case D3DRS_ENABLEADAPTIVETESSELLATION:
|
if(!init) UNIMPLEMENTED();
|
break;
|
case D3DRS_TWOSIDEDSTENCILMODE:
|
renderer->setTwoSidedStencil(value != FALSE);
|
break;
|
case D3DRS_CCW_STENCILFAIL:
|
switch(value)
|
{
|
case D3DSTENCILOP_KEEP:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_KEEP);
|
break;
|
case D3DSTENCILOP_ZERO:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_ZERO);
|
break;
|
case D3DSTENCILOP_REPLACE:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_REPLACE);
|
break;
|
case D3DSTENCILOP_INCRSAT:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_INCRSAT);
|
break;
|
case D3DSTENCILOP_DECRSAT:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_DECRSAT);
|
break;
|
case D3DSTENCILOP_INVERT:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_INVERT);
|
break;
|
case D3DSTENCILOP_INCR:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_INCR);
|
break;
|
case D3DSTENCILOP_DECR:
|
renderer->setStencilFailOperationCCW(sw::OPERATION_DECR);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_CCW_STENCILZFAIL:
|
switch(value)
|
{
|
case D3DSTENCILOP_KEEP:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_KEEP);
|
break;
|
case D3DSTENCILOP_ZERO:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_ZERO);
|
break;
|
case D3DSTENCILOP_REPLACE:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_REPLACE);
|
break;
|
case D3DSTENCILOP_INCRSAT:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_INCRSAT);
|
break;
|
case D3DSTENCILOP_DECRSAT:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_DECRSAT);
|
break;
|
case D3DSTENCILOP_INVERT:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_INVERT);
|
break;
|
case D3DSTENCILOP_INCR:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_INCR);
|
break;
|
case D3DSTENCILOP_DECR:
|
renderer->setStencilZFailOperationCCW(sw::OPERATION_DECR);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_CCW_STENCILPASS:
|
switch(value)
|
{
|
case D3DSTENCILOP_KEEP:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_KEEP);
|
break;
|
case D3DSTENCILOP_ZERO:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_ZERO);
|
break;
|
case D3DSTENCILOP_REPLACE:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_REPLACE);
|
break;
|
case D3DSTENCILOP_INCRSAT:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_INCRSAT);
|
break;
|
case D3DSTENCILOP_DECRSAT:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_DECRSAT);
|
break;
|
case D3DSTENCILOP_INVERT:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_INVERT);
|
break;
|
case D3DSTENCILOP_INCR:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_INCR);
|
break;
|
case D3DSTENCILOP_DECR:
|
renderer->setStencilPassOperationCCW(sw::OPERATION_DECR);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_CCW_STENCILFUNC:
|
switch(value)
|
{
|
case D3DCMP_NEVER:
|
renderer->setStencilCompareCCW(sw::STENCIL_NEVER);
|
break;
|
case D3DCMP_LESS:
|
renderer->setStencilCompareCCW(sw::STENCIL_LESS);
|
break;
|
case D3DCMP_EQUAL:
|
renderer->setStencilCompareCCW(sw::STENCIL_EQUAL);
|
break;
|
case D3DCMP_LESSEQUAL:
|
renderer->setStencilCompareCCW(sw::STENCIL_LESSEQUAL);
|
break;
|
case D3DCMP_GREATER:
|
renderer->setStencilCompareCCW(sw::STENCIL_GREATER);
|
break;
|
case D3DCMP_NOTEQUAL:
|
renderer->setStencilCompareCCW(sw::STENCIL_NOTEQUAL);
|
break;
|
case D3DCMP_GREATEREQUAL:
|
renderer->setStencilCompareCCW(sw::STENCIL_GREATEREQUAL);
|
break;
|
case D3DCMP_ALWAYS:
|
renderer->setStencilCompareCCW(sw::STENCIL_ALWAYS);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_COLORWRITEENABLE1:
|
renderer->setColorWriteMask(1, value);
|
break;
|
case D3DRS_COLORWRITEENABLE2:
|
renderer->setColorWriteMask(2, value);
|
break;
|
case D3DRS_COLORWRITEENABLE3:
|
renderer->setColorWriteMask(3, value);
|
break;
|
case D3DRS_BLENDFACTOR:
|
renderer->setBlendConstant(sw::Color<float>(value));
|
break;
|
case D3DRS_SRGBWRITEENABLE:
|
renderer->setWriteSRGB(value != FALSE);
|
break;
|
case D3DRS_DEPTHBIAS:
|
renderer->setDepthBias((float&)value);
|
break;
|
case D3DRS_WRAP8:
|
renderer->setTextureWrap(8, value);
|
break;
|
case D3DRS_WRAP9:
|
renderer->setTextureWrap(9, value);
|
break;
|
case D3DRS_WRAP10:
|
renderer->setTextureWrap(10, value);
|
break;
|
case D3DRS_WRAP11:
|
renderer->setTextureWrap(11, value);
|
break;
|
case D3DRS_WRAP12:
|
renderer->setTextureWrap(12, value);
|
break;
|
case D3DRS_WRAP13:
|
renderer->setTextureWrap(13, value);
|
break;
|
case D3DRS_WRAP14:
|
renderer->setTextureWrap(14, value);
|
break;
|
case D3DRS_WRAP15:
|
renderer->setTextureWrap(15, value);
|
break;
|
case D3DRS_SEPARATEALPHABLENDENABLE:
|
renderer->setSeparateAlphaBlendEnable(value != FALSE);
|
break;
|
case D3DRS_SRCBLENDALPHA:
|
switch(value)
|
{
|
case D3DBLEND_ZERO:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_ZERO);
|
break;
|
case D3DBLEND_ONE:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_ONE);
|
break;
|
case D3DBLEND_SRCCOLOR:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_SOURCE);
|
break;
|
case D3DBLEND_INVSRCCOLOR:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_INVSOURCE);
|
break;
|
case D3DBLEND_SRCALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_INVSRCALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_DESTALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_DESTALPHA);
|
break;
|
case D3DBLEND_INVDESTALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_INVDESTALPHA);
|
break;
|
case D3DBLEND_DESTCOLOR:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_DEST);
|
break;
|
case D3DBLEND_INVDESTCOLOR:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_INVDEST);
|
break;
|
case D3DBLEND_SRCALPHASAT:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_SRCALPHASAT);
|
break;
|
case D3DBLEND_BOTHSRCALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_SOURCEALPHA);
|
renderer->setDestBlendFactorAlpha(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_BOTHINVSRCALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_INVSOURCEALPHA);
|
renderer->setDestBlendFactorAlpha(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_BLENDFACTOR:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_CONSTANT);
|
break;
|
case D3DBLEND_INVBLENDFACTOR:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_INVCONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_DESTBLENDALPHA:
|
switch(value)
|
{
|
case D3DBLEND_ZERO:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_ZERO);
|
break;
|
case D3DBLEND_ONE:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_ONE);
|
break;
|
case D3DBLEND_SRCCOLOR:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_SOURCE);
|
break;
|
case D3DBLEND_INVSRCCOLOR:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_INVSOURCE);
|
break;
|
case D3DBLEND_SRCALPHA:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_INVSRCALPHA:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_DESTALPHA:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_DESTALPHA);
|
break;
|
case D3DBLEND_INVDESTALPHA:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_INVDESTALPHA);
|
break;
|
case D3DBLEND_DESTCOLOR:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_DEST);
|
break;
|
case D3DBLEND_INVDESTCOLOR:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_INVDEST);
|
break;
|
case D3DBLEND_SRCALPHASAT:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_SRCALPHASAT);
|
break;
|
case D3DBLEND_BOTHSRCALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_SOURCEALPHA);
|
renderer->setDestBlendFactorAlpha(sw::BLEND_INVSOURCEALPHA);
|
break;
|
case D3DBLEND_BOTHINVSRCALPHA:
|
renderer->setSourceBlendFactorAlpha(sw::BLEND_INVSOURCEALPHA);
|
renderer->setDestBlendFactorAlpha(sw::BLEND_SOURCEALPHA);
|
break;
|
case D3DBLEND_BLENDFACTOR:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_CONSTANT);
|
break;
|
case D3DBLEND_INVBLENDFACTOR:
|
renderer->setDestBlendFactorAlpha(sw::BLEND_INVCONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DRS_BLENDOPALPHA:
|
switch(value)
|
{
|
case D3DBLENDOP_ADD:
|
renderer->setBlendOperationAlpha(sw::BLENDOP_ADD);
|
break;
|
case D3DBLENDOP_SUBTRACT:
|
renderer->setBlendOperationAlpha(sw::BLENDOP_SUB);
|
break;
|
case D3DBLENDOP_REVSUBTRACT:
|
renderer->setBlendOperationAlpha(sw::BLENDOP_INVSUB);
|
break;
|
case D3DBLENDOP_MIN:
|
renderer->setBlendOperationAlpha(sw::BLENDOP_MIN);
|
break;
|
case D3DBLENDOP_MAX:
|
renderer->setBlendOperationAlpha(sw::BLENDOP_MAX);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
default:
|
ASSERT(false);
|
}
|
}
|
else // stateRecorder
|
{
|
stateRecorder->setRenderState(state, value);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetRenderTarget(unsigned long index, IDirect3DSurface9 *iRenderTarget)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long index = %d, IDirect3DSurface9 *newRenderTarget = 0x%0.8p", index, iRenderTarget);
|
|
// FIXME: Check for D3DUSAGE_RENDERTARGET
|
|
if(index >= 4 || (index == 0 && !iRenderTarget))
|
{
|
return INVALIDCALL();
|
}
|
|
Direct3DSurface9 *renderTarget = static_cast<Direct3DSurface9*>(iRenderTarget);
|
|
if(renderTarget)
|
{
|
renderTarget->bind();
|
}
|
|
if(this->renderTarget[index])
|
{
|
this->renderTarget[index]->unbind();
|
}
|
|
this->renderTarget[index] = renderTarget;
|
|
if(renderTarget && index == 0)
|
{
|
D3DSURFACE_DESC renderTargetDesc;
|
renderTarget->GetDesc(&renderTargetDesc);
|
|
// Reset viewport to size of current render target
|
viewport.X = 0;
|
viewport.Y = 0;
|
viewport.Width = renderTargetDesc.Width;
|
viewport.Height = renderTargetDesc.Height;
|
viewport.MinZ = 0;
|
viewport.MaxZ = 1;
|
|
// Reset scissor rectangle to size of current render target
|
scissorRect.left = 0;
|
scissorRect.top = 0;
|
scissorRect.right = renderTargetDesc.Width;
|
scissorRect.bottom = renderTargetDesc.Height;
|
|
// Set the multi-sample mask, if maskable
|
if(renderTargetDesc.MultiSampleType != D3DMULTISAMPLE_NONE &&
|
renderTargetDesc.MultiSampleType != D3DMULTISAMPLE_NONMASKABLE)
|
{
|
renderer->setMultiSampleMask(renderState[D3DRS_MULTISAMPLEMASK]);
|
}
|
else
|
{
|
renderer->setMultiSampleMask(0xFFFFFFFF);
|
}
|
}
|
|
renderer->setRenderTarget(index, renderTarget);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetSamplerState(unsigned long sampler, D3DSAMPLERSTATETYPE state, unsigned long value)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long sampler = %d, D3DSAMPLERSTATETYPE state = %d, unsigned long value = %d", sampler, state, value);
|
|
if(state < D3DSAMP_ADDRESSU || state > D3DSAMP_DMAPOFFSET)
|
{
|
return INVALIDCALL();
|
}
|
|
if((sampler >= 16 && sampler <= D3DDMAPSAMPLER) || sampler > D3DVERTEXTEXTURESAMPLER3)
|
{
|
return INVALIDCALL();
|
}
|
|
if(sampler >= D3DVERTEXTEXTURESAMPLER0)
|
{
|
sampler = 16 + (sampler - D3DVERTEXTEXTURESAMPLER0);
|
}
|
|
if(!stateRecorder)
|
{
|
if(!init && samplerState[sampler][state] == value)
|
{
|
return D3D_OK;
|
}
|
|
samplerState[sampler][state] = value;
|
|
sw::SamplerType type = sampler < 16 ? sw::SAMPLER_PIXEL : sw::SAMPLER_VERTEX;
|
int index = sampler < 16 ? sampler : sampler - 16; // Sampler index within type group
|
|
switch(state)
|
{
|
case D3DSAMP_ADDRESSU:
|
switch(value)
|
{
|
case D3DTADDRESS_WRAP:
|
renderer->setAddressingModeU(type, index, sw::ADDRESSING_WRAP);
|
break;
|
case D3DTADDRESS_MIRROR:
|
renderer->setAddressingModeU(type, index, sw::ADDRESSING_MIRROR);
|
break;
|
case D3DTADDRESS_CLAMP:
|
renderer->setAddressingModeU(type, index, sw::ADDRESSING_CLAMP);
|
break;
|
case D3DTADDRESS_BORDER:
|
renderer->setAddressingModeU(type, index, sw::ADDRESSING_BORDER);
|
break;
|
case D3DTADDRESS_MIRRORONCE:
|
renderer->setAddressingModeU(type, index, sw::ADDRESSING_MIRRORONCE);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DSAMP_ADDRESSV:
|
switch(value)
|
{
|
case D3DTADDRESS_WRAP:
|
renderer->setAddressingModeV(type, index, sw::ADDRESSING_WRAP);
|
break;
|
case D3DTADDRESS_MIRROR:
|
renderer->setAddressingModeV(type, index, sw::ADDRESSING_MIRROR);
|
break;
|
case D3DTADDRESS_CLAMP:
|
renderer->setAddressingModeV(type, index, sw::ADDRESSING_CLAMP);
|
break;
|
case D3DTADDRESS_BORDER:
|
renderer->setAddressingModeV(type, index, sw::ADDRESSING_BORDER);
|
break;
|
case D3DTADDRESS_MIRRORONCE:
|
renderer->setAddressingModeV(type, index, sw::ADDRESSING_MIRRORONCE);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DSAMP_ADDRESSW:
|
switch(value)
|
{
|
case D3DTADDRESS_WRAP:
|
renderer->setAddressingModeW(type, index, sw::ADDRESSING_WRAP);
|
break;
|
case D3DTADDRESS_MIRROR:
|
renderer->setAddressingModeW(type, index, sw::ADDRESSING_MIRROR);
|
break;
|
case D3DTADDRESS_CLAMP:
|
renderer->setAddressingModeW(type, index, sw::ADDRESSING_CLAMP);
|
break;
|
case D3DTADDRESS_BORDER:
|
renderer->setAddressingModeW(type, index, sw::ADDRESSING_BORDER);
|
break;
|
case D3DTADDRESS_MIRRORONCE:
|
renderer->setAddressingModeW(type, index, sw::ADDRESSING_MIRRORONCE);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DSAMP_BORDERCOLOR:
|
renderer->setBorderColor(type, index, value);
|
break;
|
case D3DSAMP_MAGFILTER:
|
// NOTE: SwiftShader does not differentiate between minification and magnification filter
|
switch(value)
|
{
|
case D3DTEXF_NONE:
|
renderer->setTextureFilter(type, index, sw::FILTER_POINT); // FIXME: Only for mipmap filter
|
break;
|
case D3DTEXF_POINT:
|
renderer->setTextureFilter(type, index, sw::FILTER_POINT);
|
break;
|
case D3DTEXF_LINEAR:
|
renderer->setTextureFilter(type, index, sw::FILTER_LINEAR);
|
break;
|
case D3DTEXF_ANISOTROPIC:
|
renderer->setTextureFilter(type, index, sw::FILTER_ANISOTROPIC);
|
break;
|
case D3DTEXF_PYRAMIDALQUAD:
|
renderer->setTextureFilter(type, index, sw::FILTER_LINEAR); // FIXME: Unimplemented, fail silently
|
break;
|
case D3DTEXF_GAUSSIANQUAD:
|
renderer->setTextureFilter(type, index, sw::FILTER_LINEAR); // FIXME: Unimplemented, fail silently
|
break;
|
default:
|
return INVALIDCALL();
|
};
|
break;
|
case D3DSAMP_MINFILTER:
|
// NOTE: SwiftShader does not differentiate between minification and magnification filter
|
switch(value)
|
{
|
case D3DTEXF_NONE:
|
renderer->setTextureFilter(type, index, sw::FILTER_POINT); // FIXME: Only for mipmap filter
|
break;
|
case D3DTEXF_POINT:
|
renderer->setTextureFilter(type, index, sw::FILTER_POINT);
|
break;
|
case D3DTEXF_LINEAR:
|
renderer->setTextureFilter(type, index, sw::FILTER_LINEAR);
|
break;
|
case D3DTEXF_ANISOTROPIC:
|
renderer->setTextureFilter(type, index, sw::FILTER_ANISOTROPIC);
|
break;
|
case D3DTEXF_PYRAMIDALQUAD:
|
renderer->setTextureFilter(type, index, sw::FILTER_LINEAR); // FIXME: Unimplemented, fail silently
|
break;
|
case D3DTEXF_GAUSSIANQUAD:
|
renderer->setTextureFilter(type, index, sw::FILTER_LINEAR); // FIXME: Unimplemented, fail silently
|
break;
|
default:
|
return INVALIDCALL();
|
};
|
break;
|
case D3DSAMP_MIPFILTER:
|
switch(value)
|
{
|
case D3DTEXF_NONE:
|
renderer->setMipmapFilter(type, index, sw::MIPMAP_NONE);
|
break;
|
case D3DTEXF_POINT:
|
renderer->setMipmapFilter(type, index, sw::MIPMAP_POINT);
|
break;
|
case D3DTEXF_LINEAR:
|
renderer->setMipmapFilter(type, index, sw::MIPMAP_LINEAR);
|
break;
|
case D3DTEXF_ANISOTROPIC:
|
renderer->setMipmapFilter(type, index, sw::MIPMAP_LINEAR); // FIXME: Only for texture filter
|
break;
|
case D3DTEXF_PYRAMIDALQUAD:
|
renderer->setMipmapFilter(type, index, sw::MIPMAP_LINEAR); // FIXME: Only for texture filter
|
break;
|
case D3DTEXF_GAUSSIANQUAD:
|
renderer->setMipmapFilter(type, index, sw::MIPMAP_LINEAR); // FIXME: Only for texture filter
|
break;
|
default:
|
return INVALIDCALL();
|
};
|
break;
|
case D3DSAMP_MIPMAPLODBIAS:
|
if(value == D3DFMT_GET4) // ATI hack to enable Fetch4
|
{
|
renderer->setGatherEnable(type, index, true);
|
}
|
else if(value == D3DFMT_GET1) // ATI hack to disable Fetch4
|
{
|
renderer->setGatherEnable(type, index, false);
|
}
|
else
|
{
|
float LOD = (float&)value - sw::log2((float)context->renderTarget[0]->getSuperSampleCount()); // FIXME: Update when render target changes
|
renderer->setMipmapLOD(type, index, LOD);
|
}
|
break;
|
case D3DSAMP_MAXMIPLEVEL:
|
break;
|
case D3DSAMP_MAXANISOTROPY:
|
renderer->setMaxAnisotropy(type, index, sw::clamp((unsigned int)value, (unsigned int)1, maxAnisotropy));
|
break;
|
case D3DSAMP_SRGBTEXTURE:
|
renderer->setReadSRGB(type, index, value != FALSE);
|
break;
|
case D3DSAMP_ELEMENTINDEX:
|
if(!init) UNIMPLEMENTED(); // Multi-element textures deprecated in favor of multiple render targets
|
break;
|
case D3DSAMP_DMAPOFFSET:
|
// if(!init) UNIMPLEMENTED();
|
break;
|
default:
|
ASSERT(false);
|
}
|
}
|
else // stateRecorder
|
{
|
stateRecorder->setSamplerState(sampler, state, value);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetScissorRect(const RECT *rect)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const RECT *rect = 0x%0.8p", rect);
|
|
if(!rect)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
scissorRect = *rect;
|
}
|
else
|
{
|
stateRecorder->setScissorRect(rect);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetSoftwareVertexProcessing(int software)
|
{
|
CriticalSection cs(this);
|
|
TRACE("int software = %d", software);
|
|
if(behaviourFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING && software == FALSE)
|
{
|
return INVALIDCALL();
|
}
|
|
if(behaviourFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING && software == TRUE)
|
{
|
return INVALIDCALL();
|
}
|
|
softwareVertexProcessing = (software != FALSE);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetStreamSource(unsigned int stream, IDirect3DVertexBuffer9 *iVertexBuffer, unsigned int offset, unsigned int stride)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int stream = %d, IDirect3DVertexBuffer9 *data = 0x%0.8p, unsigned int offset = %d, unsigned int stride = %d", stream, iVertexBuffer, offset, stride);
|
|
Direct3DVertexBuffer9 *vertexBuffer = static_cast<Direct3DVertexBuffer9*>(iVertexBuffer);
|
|
if(!stateRecorder)
|
{
|
if(dataStream[stream] == vertexBuffer && streamOffset[stream] == offset && streamStride[stream] == stride)
|
{
|
return D3D_OK;
|
}
|
|
if(vertexBuffer)
|
{
|
vertexBuffer->bind();
|
}
|
|
if(dataStream[stream])
|
{
|
dataStream[stream]->unbind();
|
}
|
|
dataStream[stream] = vertexBuffer;
|
streamOffset[stream] = offset;
|
streamStride[stream] = stride;
|
}
|
else
|
{
|
stateRecorder->setStreamSource(stream, vertexBuffer, offset, stride);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetStreamSourceFreq(unsigned int streamNumber, unsigned int divider)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int streamNumber = %d, unsigned int divider = %d", streamNumber, divider);
|
|
if(!instancingEnabled)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
streamSourceFreq[streamNumber] = divider;
|
}
|
else
|
{
|
stateRecorder->setStreamSourceFreq(streamNumber, divider);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetTexture(unsigned long sampler, IDirect3DBaseTexture9 *iBaseTexture)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long sampler = %d, IDirect3DBaseTexture9 *texture = 0x%0.8p", sampler, iBaseTexture);
|
|
if((sampler >= 16 && sampler <= D3DDMAPSAMPLER) || sampler > D3DVERTEXTEXTURESAMPLER3)
|
{
|
return INVALIDCALL();
|
}
|
|
if(sampler >= D3DVERTEXTEXTURESAMPLER0)
|
{
|
sampler = 16 + (sampler - D3DVERTEXTEXTURESAMPLER0);
|
}
|
|
Direct3DBaseTexture9 *baseTexture = dynamic_cast<Direct3DBaseTexture9*>(iBaseTexture);
|
|
if(!stateRecorder)
|
{
|
if(texture[sampler] == baseTexture)
|
{
|
return D3D_OK;
|
}
|
|
if(baseTexture)
|
{
|
baseTexture->bind(); // FIXME: Bind individual sub-surfaces?
|
}
|
|
if(texture[sampler])
|
{
|
texture[sampler]->unbind();
|
}
|
|
texture[sampler] = baseTexture;
|
}
|
else
|
{
|
stateRecorder->setTexture(sampler, baseTexture);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long value)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long stage = %d, D3DTEXTURESTAGESTATETYPE type = %d, unsigned long value = %d", stage, type, value);
|
|
if(stage < 0 || stage >= 8 || type < D3DTSS_COLOROP || type > D3DTSS_CONSTANT)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
if(!init && textureStageState[stage][type] == value)
|
{
|
return D3D_OK;
|
}
|
|
textureStageState[stage][type] = value;
|
|
switch(type)
|
{
|
case D3DTSS_COLOROP:
|
switch(value)
|
{
|
case D3DTOP_DISABLE:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_DISABLE);
|
break;
|
case D3DTOP_SELECTARG1:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_SELECTARG1);
|
break;
|
case D3DTOP_SELECTARG2:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_SELECTARG2);
|
break;
|
case D3DTOP_MODULATE:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MODULATE);
|
break;
|
case D3DTOP_MODULATE2X:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MODULATE2X);
|
break;
|
case D3DTOP_MODULATE4X:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MODULATE4X);
|
break;
|
case D3DTOP_ADD:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_ADD);
|
break;
|
case D3DTOP_ADDSIGNED:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_ADDSIGNED);
|
break;
|
case D3DTOP_ADDSIGNED2X:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_ADDSIGNED2X);
|
break;
|
case D3DTOP_SUBTRACT:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_SUBTRACT);
|
break;
|
case D3DTOP_ADDSMOOTH:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_ADDSMOOTH);
|
break;
|
case D3DTOP_BLENDDIFFUSEALPHA:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_BLENDDIFFUSEALPHA);
|
break;
|
case D3DTOP_BLENDTEXTUREALPHA:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_BLENDTEXTUREALPHA);
|
break;
|
case D3DTOP_BLENDFACTORALPHA:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_BLENDFACTORALPHA);
|
break;
|
case D3DTOP_BLENDTEXTUREALPHAPM:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_BLENDTEXTUREALPHAPM);
|
break;
|
case D3DTOP_BLENDCURRENTALPHA:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_BLENDCURRENTALPHA);
|
break;
|
case D3DTOP_PREMODULATE:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_PREMODULATE);
|
break;
|
case D3DTOP_MODULATEALPHA_ADDCOLOR:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MODULATEALPHA_ADDCOLOR);
|
break;
|
case D3DTOP_MODULATECOLOR_ADDALPHA:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MODULATECOLOR_ADDALPHA);
|
break;
|
case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR);
|
break;
|
case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA);
|
break;
|
case D3DTOP_BUMPENVMAP:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_BUMPENVMAP);
|
break;
|
case D3DTOP_BUMPENVMAPLUMINANCE:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_BUMPENVMAPLUMINANCE);
|
break;
|
case D3DTOP_DOTPRODUCT3:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_DOT3);
|
break;
|
case D3DTOP_MULTIPLYADD:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_MULTIPLYADD);
|
break;
|
case D3DTOP_LERP:
|
renderer->setStageOperation(stage, sw::TextureStage::STAGE_LERP);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_COLORARG1:
|
switch(value & D3DTA_SELECTMASK)
|
{
|
case D3DTA_DIFFUSE:
|
renderer->setFirstArgument(stage, sw::TextureStage::SOURCE_DIFFUSE);
|
break;
|
case D3DTA_CURRENT:
|
renderer->setFirstArgument(stage, sw::TextureStage::SOURCE_CURRENT);
|
break;
|
case D3DTA_TEXTURE:
|
renderer->setFirstArgument(stage, sw::TextureStage::SOURCE_TEXTURE);
|
break;
|
case D3DTA_TFACTOR:
|
renderer->setFirstArgument(stage, sw::TextureStage::SOURCE_TFACTOR);
|
break;
|
case D3DTA_SPECULAR:
|
renderer->setFirstArgument(stage, sw::TextureStage::SOURCE_SPECULAR);
|
break;
|
case D3DTA_TEMP:
|
renderer->setFirstArgument(stage, sw::TextureStage::SOURCE_TEMP);
|
break;
|
case D3DTA_CONSTANT:
|
renderer->setFirstArgument(stage, sw::TextureStage::SOURCE_CONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
switch(value & ~D3DTA_SELECTMASK)
|
{
|
case 0:
|
renderer->setFirstModifier(stage, sw::TextureStage::MODIFIER_COLOR);
|
break;
|
case D3DTA_COMPLEMENT:
|
renderer->setFirstModifier(stage, sw::TextureStage::MODIFIER_INVCOLOR);
|
break;
|
case D3DTA_ALPHAREPLICATE:
|
renderer->setFirstModifier(stage, sw::TextureStage::MODIFIER_ALPHA);
|
break;
|
case D3DTA_COMPLEMENT | D3DTA_ALPHAREPLICATE:
|
renderer->setFirstModifier(stage, sw::TextureStage::MODIFIER_INVALPHA);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_COLORARG2:
|
switch(value & D3DTA_SELECTMASK)
|
{
|
case D3DTA_DIFFUSE:
|
renderer->setSecondArgument(stage, sw::TextureStage::SOURCE_DIFFUSE);
|
break;
|
case D3DTA_CURRENT:
|
renderer->setSecondArgument(stage, sw::TextureStage::SOURCE_CURRENT);
|
break;
|
case D3DTA_TEXTURE:
|
renderer->setSecondArgument(stage, sw::TextureStage::SOURCE_TEXTURE);
|
break;
|
case D3DTA_TFACTOR:
|
renderer->setSecondArgument(stage, sw::TextureStage::SOURCE_TFACTOR);
|
break;
|
case D3DTA_SPECULAR:
|
renderer->setSecondArgument(stage, sw::TextureStage::SOURCE_SPECULAR);
|
break;
|
case D3DTA_TEMP:
|
renderer->setSecondArgument(stage, sw::TextureStage::SOURCE_TEMP);
|
break;
|
case D3DTA_CONSTANT:
|
renderer->setSecondArgument(stage, sw::TextureStage::SOURCE_CONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
switch(value & ~D3DTA_SELECTMASK)
|
{
|
case 0:
|
renderer->setSecondModifier(stage, sw::TextureStage::MODIFIER_COLOR);
|
break;
|
case D3DTA_COMPLEMENT:
|
renderer->setSecondModifier(stage, sw::TextureStage::MODIFIER_INVCOLOR);
|
break;
|
case D3DTA_ALPHAREPLICATE:
|
renderer->setSecondModifier(stage, sw::TextureStage::MODIFIER_ALPHA);
|
break;
|
case D3DTA_COMPLEMENT | D3DTA_ALPHAREPLICATE:
|
renderer->setSecondModifier(stage, sw::TextureStage::MODIFIER_INVALPHA);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_ALPHAOP:
|
switch(value)
|
{
|
case D3DTOP_DISABLE:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_DISABLE);
|
break;
|
case D3DTOP_SELECTARG1:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_SELECTARG1);
|
break;
|
case D3DTOP_SELECTARG2:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_SELECTARG2);
|
break;
|
case D3DTOP_MODULATE:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MODULATE);
|
break;
|
case D3DTOP_MODULATE2X:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MODULATE2X);
|
break;
|
case D3DTOP_MODULATE4X:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MODULATE4X);
|
break;
|
case D3DTOP_ADD:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_ADD);
|
break;
|
case D3DTOP_ADDSIGNED:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_ADDSIGNED);
|
break;
|
case D3DTOP_ADDSIGNED2X:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_ADDSIGNED2X);
|
break;
|
case D3DTOP_SUBTRACT:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_SUBTRACT);
|
break;
|
case D3DTOP_ADDSMOOTH:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_ADDSMOOTH);
|
break;
|
case D3DTOP_BLENDDIFFUSEALPHA:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_BLENDDIFFUSEALPHA);
|
break;
|
case D3DTOP_BLENDTEXTUREALPHA:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_BLENDTEXTUREALPHA);
|
break;
|
case D3DTOP_BLENDFACTORALPHA:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_BLENDFACTORALPHA);
|
break;
|
case D3DTOP_BLENDTEXTUREALPHAPM:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_BLENDTEXTUREALPHAPM);
|
break;
|
case D3DTOP_BLENDCURRENTALPHA:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_BLENDCURRENTALPHA);
|
break;
|
case D3DTOP_PREMODULATE:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_PREMODULATE);
|
break;
|
case D3DTOP_MODULATEALPHA_ADDCOLOR:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MODULATEALPHA_ADDCOLOR);
|
break;
|
case D3DTOP_MODULATECOLOR_ADDALPHA:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MODULATECOLOR_ADDALPHA);
|
break;
|
case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR);
|
break;
|
case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA);
|
break;
|
case D3DTOP_BUMPENVMAP:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_BUMPENVMAP);
|
break;
|
case D3DTOP_BUMPENVMAPLUMINANCE:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_BUMPENVMAPLUMINANCE);
|
break;
|
case D3DTOP_DOTPRODUCT3:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_DOT3);
|
break;
|
case D3DTOP_MULTIPLYADD:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_MULTIPLYADD);
|
break;
|
case D3DTOP_LERP:
|
renderer->setStageOperationAlpha(stage, sw::TextureStage::STAGE_LERP);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_ALPHAARG1:
|
switch(value & D3DTA_SELECTMASK)
|
{
|
case D3DTA_DIFFUSE:
|
renderer->setFirstArgumentAlpha(stage, sw::TextureStage::SOURCE_DIFFUSE);
|
break;
|
case D3DTA_CURRENT:
|
renderer->setFirstArgumentAlpha(stage, sw::TextureStage::SOURCE_CURRENT);
|
break;
|
case D3DTA_TEXTURE:
|
renderer->setFirstArgumentAlpha(stage, sw::TextureStage::SOURCE_TEXTURE);
|
break;
|
case D3DTA_TFACTOR:
|
renderer->setFirstArgumentAlpha(stage, sw::TextureStage::SOURCE_TFACTOR);
|
break;
|
case D3DTA_SPECULAR:
|
renderer->setFirstArgumentAlpha(stage, sw::TextureStage::SOURCE_SPECULAR);
|
break;
|
case D3DTA_TEMP:
|
renderer->setFirstArgumentAlpha(stage, sw::TextureStage::SOURCE_TEMP);
|
break;
|
case D3DTA_CONSTANT:
|
renderer->setFirstArgumentAlpha(stage, sw::TextureStage::SOURCE_CONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
switch(value & ~D3DTA_SELECTMASK)
|
{
|
case 0:
|
renderer->setFirstModifierAlpha(stage, sw::TextureStage::MODIFIER_COLOR);
|
break;
|
case D3DTA_COMPLEMENT:
|
renderer->setFirstModifierAlpha(stage, sw::TextureStage::MODIFIER_INVCOLOR);
|
break;
|
case D3DTA_ALPHAREPLICATE:
|
renderer->setFirstModifierAlpha(stage, sw::TextureStage::MODIFIER_ALPHA);
|
break;
|
case D3DTA_COMPLEMENT | D3DTA_ALPHAREPLICATE:
|
renderer->setSecondModifier(stage, sw::TextureStage::MODIFIER_INVALPHA);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_ALPHAARG2:
|
switch(value & D3DTA_SELECTMASK)
|
{
|
case D3DTA_DIFFUSE:
|
renderer->setSecondArgumentAlpha(stage, sw::TextureStage::SOURCE_DIFFUSE);
|
break;
|
case D3DTA_CURRENT:
|
renderer->setSecondArgumentAlpha(stage, sw::TextureStage::SOURCE_CURRENT);
|
break;
|
case D3DTA_TEXTURE:
|
renderer->setSecondArgumentAlpha(stage, sw::TextureStage::SOURCE_TEXTURE);
|
break;
|
case D3DTA_TFACTOR:
|
renderer->setSecondArgumentAlpha(stage, sw::TextureStage::SOURCE_TFACTOR);
|
break;
|
case D3DTA_SPECULAR:
|
renderer->setSecondArgumentAlpha(stage, sw::TextureStage::SOURCE_SPECULAR);
|
break;
|
case D3DTA_TEMP:
|
renderer->setSecondArgumentAlpha(stage, sw::TextureStage::SOURCE_TEMP);
|
break;
|
case D3DTA_CONSTANT:
|
renderer->setSecondArgumentAlpha(stage, sw::TextureStage::SOURCE_CONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
switch(value & ~D3DTA_SELECTMASK)
|
{
|
case 0:
|
renderer->setSecondModifierAlpha(stage, sw::TextureStage::MODIFIER_COLOR);
|
break;
|
case D3DTA_COMPLEMENT:
|
renderer->setSecondModifierAlpha(stage, sw::TextureStage::MODIFIER_INVCOLOR);
|
break;
|
case D3DTA_ALPHAREPLICATE:
|
renderer->setSecondModifierAlpha(stage, sw::TextureStage::MODIFIER_ALPHA);
|
break;
|
case D3DTA_COMPLEMENT | D3DTA_ALPHAREPLICATE:
|
renderer->setSecondModifierAlpha(stage, sw::TextureStage::MODIFIER_INVALPHA);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_BUMPENVMAT00:
|
renderer->setBumpmapMatrix(stage, 0, (float&)value);
|
break;
|
case D3DTSS_BUMPENVMAT01:
|
renderer->setBumpmapMatrix(stage, 1, (float&)value);
|
break;
|
case D3DTSS_BUMPENVMAT10:
|
renderer->setBumpmapMatrix(stage, 2, (float&)value);
|
break;
|
case D3DTSS_BUMPENVMAT11:
|
renderer->setBumpmapMatrix(stage, 3, (float&)value);
|
break;
|
case D3DTSS_TEXCOORDINDEX:
|
renderer->setTexCoordIndex(stage, value & 0x0000FFFF);
|
|
switch(value & 0xFFFF0000)
|
{
|
case D3DTSS_TCI_PASSTHRU:
|
renderer->setTexGen(stage, sw::TEXGEN_PASSTHRU);
|
break;
|
case D3DTSS_TCI_CAMERASPACENORMAL:
|
renderer->setTexCoordIndex(stage, stage);
|
renderer->setTexGen(stage, sw::TEXGEN_NORMAL);
|
break;
|
case D3DTSS_TCI_CAMERASPACEPOSITION:
|
renderer->setTexCoordIndex(stage, stage);
|
renderer->setTexGen(stage, sw::TEXGEN_POSITION);
|
break;
|
case D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
|
renderer->setTexCoordIndex(stage, stage);
|
renderer->setTexGen(stage, sw::TEXGEN_REFLECTION);
|
break;
|
case D3DTSS_TCI_SPHEREMAP:
|
renderer->setTexCoordIndex(stage, stage);
|
renderer->setTexGen(stage, sw::TEXGEN_SPHEREMAP);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_BUMPENVLSCALE:
|
renderer->setLuminanceScale(stage, (float&)value);
|
break;
|
case D3DTSS_BUMPENVLOFFSET:
|
renderer->setLuminanceOffset(stage, (float&)value);
|
break;
|
case D3DTSS_TEXTURETRANSFORMFLAGS:
|
switch(value & ~D3DTTFF_PROJECTED)
|
{
|
case D3DTTFF_DISABLE:
|
renderer->setTextureTransform(stage, 0, (value & D3DTTFF_PROJECTED) == D3DTTFF_PROJECTED);
|
break;
|
case D3DTTFF_COUNT1:
|
renderer->setTextureTransform(stage, 1, (value & D3DTTFF_PROJECTED) == D3DTTFF_PROJECTED);
|
break;
|
case D3DTTFF_COUNT2:
|
renderer->setTextureTransform(stage, 2, (value & D3DTTFF_PROJECTED) == D3DTTFF_PROJECTED);
|
break;
|
case D3DTTFF_COUNT3:
|
renderer->setTextureTransform(stage, 3, (value & D3DTTFF_PROJECTED) == D3DTTFF_PROJECTED);
|
break;
|
case D3DTTFF_COUNT4:
|
renderer->setTextureTransform(stage, 4, (value & D3DTTFF_PROJECTED) == D3DTTFF_PROJECTED);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_COLORARG0:
|
switch(value & D3DTA_SELECTMASK)
|
{
|
case D3DTA_CURRENT:
|
renderer->setThirdArgument(stage, sw::TextureStage::SOURCE_CURRENT);
|
break;
|
case D3DTA_DIFFUSE:
|
renderer->setThirdArgument(stage, sw::TextureStage::SOURCE_DIFFUSE);
|
break;
|
case D3DTA_SPECULAR:
|
renderer->setThirdArgument(stage, sw::TextureStage::SOURCE_SPECULAR);
|
break;
|
case D3DTA_TEMP:
|
renderer->setThirdArgument(stage, sw::TextureStage::SOURCE_TEMP);
|
break;
|
case D3DTA_TEXTURE:
|
renderer->setThirdArgument(stage, sw::TextureStage::SOURCE_TEXTURE);
|
break;
|
case D3DTA_TFACTOR:
|
renderer->setThirdArgument(stage, sw::TextureStage::SOURCE_TFACTOR);
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
switch(value & ~D3DTA_SELECTMASK)
|
{
|
case 0:
|
renderer->setThirdModifier(stage, sw::TextureStage::MODIFIER_COLOR);
|
break;
|
case D3DTA_COMPLEMENT:
|
renderer->setThirdModifier(stage, sw::TextureStage::MODIFIER_INVCOLOR);
|
break;
|
case D3DTA_ALPHAREPLICATE:
|
renderer->setThirdModifier(stage, sw::TextureStage::MODIFIER_ALPHA);
|
break;
|
case D3DTA_COMPLEMENT | D3DTA_ALPHAREPLICATE:
|
renderer->setThirdModifier(stage, sw::TextureStage::MODIFIER_INVALPHA);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_ALPHAARG0:
|
switch(value & D3DTA_SELECTMASK)
|
{
|
case D3DTA_DIFFUSE:
|
renderer->setThirdArgumentAlpha(stage, sw::TextureStage::SOURCE_DIFFUSE);
|
break;
|
case D3DTA_CURRENT:
|
renderer->setThirdArgumentAlpha(stage, sw::TextureStage::SOURCE_CURRENT);
|
break;
|
case D3DTA_TEXTURE:
|
renderer->setThirdArgumentAlpha(stage, sw::TextureStage::SOURCE_TEXTURE);
|
break;
|
case D3DTA_TFACTOR:
|
renderer->setThirdArgumentAlpha(stage, sw::TextureStage::SOURCE_TFACTOR);
|
break;
|
case D3DTA_SPECULAR:
|
renderer->setThirdArgumentAlpha(stage, sw::TextureStage::SOURCE_SPECULAR);
|
break;
|
case D3DTA_TEMP:
|
renderer->setThirdArgumentAlpha(stage, sw::TextureStage::SOURCE_TEMP);
|
break;
|
case D3DTA_CONSTANT:
|
renderer->setThirdArgumentAlpha(stage, sw::TextureStage::SOURCE_CONSTANT);
|
break;
|
default:
|
ASSERT(false);
|
}
|
|
switch(value & ~D3DTA_SELECTMASK)
|
{
|
case 0:
|
renderer->setThirdModifierAlpha(stage, sw::TextureStage::MODIFIER_COLOR);
|
break;
|
case D3DTA_COMPLEMENT:
|
renderer->setThirdModifierAlpha(stage, sw::TextureStage::MODIFIER_INVCOLOR);
|
break;
|
case D3DTA_ALPHAREPLICATE:
|
renderer->setThirdModifierAlpha(stage, sw::TextureStage::MODIFIER_ALPHA);
|
break;
|
case D3DTA_COMPLEMENT | D3DTA_ALPHAREPLICATE:
|
renderer->setThirdModifierAlpha(stage, sw::TextureStage::MODIFIER_INVALPHA);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_RESULTARG:
|
switch(value & D3DTA_SELECTMASK)
|
{
|
case D3DTA_CURRENT:
|
renderer->setDestinationArgument(stage, sw::TextureStage::DESTINATION_CURRENT);
|
break;
|
case D3DTA_TEMP:
|
renderer->setDestinationArgument(stage, sw::TextureStage::DESTINATION_TEMP);
|
break;
|
default:
|
ASSERT(false);
|
}
|
break;
|
case D3DTSS_CONSTANT:
|
renderer->setConstantColor(stage, value);
|
break;
|
default:
|
ASSERT(false);
|
}
|
}
|
else // stateRecorder
|
{
|
stateRecorder->setTextureStageState(stage, type, value);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
|
{
|
CriticalSection cs(this);
|
|
TRACE("D3DTRANSFORMSTATETYPE state = %d, const D3DMATRIX *matrix = 0x%0.8p", state, matrix);
|
|
if(!matrix)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
this->matrix[state] = *matrix;
|
|
sw::Matrix M(matrix->_11, matrix->_21, matrix->_31, matrix->_41,
|
matrix->_12, matrix->_22, matrix->_32, matrix->_42,
|
matrix->_13, matrix->_23, matrix->_33, matrix->_43,
|
matrix->_14, matrix->_24, matrix->_34, matrix->_44);
|
|
switch(state)
|
{
|
case D3DTS_WORLD:
|
renderer->setModelMatrix(M);
|
break;
|
case D3DTS_VIEW:
|
renderer->setViewMatrix(M);
|
break;
|
case D3DTS_PROJECTION:
|
renderer->setProjectionMatrix(M);
|
break;
|
case D3DTS_TEXTURE0:
|
renderer->setTextureMatrix(0, M);
|
break;
|
case D3DTS_TEXTURE1:
|
renderer->setTextureMatrix(1, M);
|
break;
|
case D3DTS_TEXTURE2:
|
renderer->setTextureMatrix(2, M);
|
break;
|
case D3DTS_TEXTURE3:
|
renderer->setTextureMatrix(3, M);
|
break;
|
case D3DTS_TEXTURE4:
|
renderer->setTextureMatrix(4, M);
|
break;
|
case D3DTS_TEXTURE5:
|
renderer->setTextureMatrix(5, M);
|
break;
|
case D3DTS_TEXTURE6:
|
renderer->setTextureMatrix(6, M);
|
break;
|
case D3DTS_TEXTURE7:
|
renderer->setTextureMatrix(7, M);
|
break;
|
default:
|
if(state > 256 && state < 512)
|
{
|
renderer->setModelMatrix(M, state - 256);
|
}
|
else ASSERT(false);
|
}
|
}
|
else // stateRecorder
|
{
|
stateRecorder->setTransform(state, matrix);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetVertexDeclaration(IDirect3DVertexDeclaration9 *iVertexDeclaration)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DVertexDeclaration9 *declaration = 0x%0.8p", iVertexDeclaration);
|
|
Direct3DVertexDeclaration9 *vertexDeclaration = static_cast<Direct3DVertexDeclaration9*>(iVertexDeclaration);
|
|
if(!stateRecorder)
|
{
|
if(this->vertexDeclaration == vertexDeclaration)
|
{
|
return D3D_OK;
|
}
|
|
if(vertexDeclaration)
|
{
|
vertexDeclaration->bind();
|
}
|
|
if(this->vertexDeclaration)
|
{
|
this->vertexDeclaration->unbind();
|
}
|
|
this->vertexDeclaration = vertexDeclaration;
|
}
|
else
|
{
|
stateRecorder->setVertexDeclaration(vertexDeclaration);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetVertexShader(IDirect3DVertexShader9 *iVertexShader)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DVertexShader9 *shader = 0x%0.8p", iVertexShader);
|
|
Direct3DVertexShader9 *vertexShader = static_cast<Direct3DVertexShader9*>(iVertexShader);
|
|
if(!stateRecorder)
|
{
|
if(this->vertexShader == vertexShader)
|
{
|
return D3D_OK;
|
}
|
|
if(vertexShader)
|
{
|
vertexShader->bind();
|
}
|
|
if(this->vertexShader)
|
{
|
this->vertexShader->unbind();
|
}
|
|
this->vertexShader = vertexShader;
|
vertexShaderDirty = true;
|
}
|
else
|
{
|
stateRecorder->setVertexShader(vertexShader);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetVertexShaderConstantB(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
for(unsigned int i = 0; i < count && startRegister + i < 16; i++)
|
{
|
vertexShaderConstantB[startRegister + i] = constantData[i];
|
}
|
|
vertexShaderConstantsBDirty = sw::max(startRegister + count, vertexShaderConstantsBDirty);
|
vertexShaderDirty = true; // Reload DEF constants
|
}
|
else
|
{
|
stateRecorder->setVertexShaderConstantB(startRegister, constantData, count);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetVertexShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
for(unsigned int i = 0; i < count && startRegister + i < MAX_VERTEX_SHADER_CONST; i++)
|
{
|
vertexShaderConstantF[startRegister + i][0] = constantData[i * 4 + 0];
|
vertexShaderConstantF[startRegister + i][1] = constantData[i * 4 + 1];
|
vertexShaderConstantF[startRegister + i][2] = constantData[i * 4 + 2];
|
vertexShaderConstantF[startRegister + i][3] = constantData[i * 4 + 3];
|
}
|
|
vertexShaderConstantsFDirty = sw::max(startRegister + count, vertexShaderConstantsFDirty);
|
vertexShaderDirty = true; // Reload DEF constants
|
}
|
else
|
{
|
stateRecorder->setVertexShaderConstantF(startRegister, constantData, count);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetVertexShaderConstantI(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);
|
|
if(!constantData)
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
for(unsigned int i = 0; i < count && startRegister + i < 16; i++)
|
{
|
vertexShaderConstantI[startRegister + i][0] = constantData[i * 4 + 0];
|
vertexShaderConstantI[startRegister + i][1] = constantData[i * 4 + 1];
|
vertexShaderConstantI[startRegister + i][2] = constantData[i * 4 + 2];
|
vertexShaderConstantI[startRegister + i][3] = constantData[i * 4 + 3];
|
}
|
|
vertexShaderConstantsIDirty = sw::max(startRegister + count, vertexShaderConstantsIDirty);
|
vertexShaderDirty = true; // Reload DEF constants
|
}
|
else
|
{
|
stateRecorder->setVertexShaderConstantI(startRegister, constantData, count);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::SetViewport(const D3DVIEWPORT9 *viewport)
|
{
|
CriticalSection cs(this);
|
|
TRACE("const D3DVIEWPORT9 *viewport = 0x%0.8p", viewport);
|
|
if(!viewport) // FIXME: Check if valid
|
{
|
return INVALIDCALL();
|
}
|
|
if(!stateRecorder)
|
{
|
this->viewport = *viewport;
|
}
|
else
|
{
|
stateRecorder->setViewport(viewport);
|
}
|
|
return D3D_OK;
|
}
|
|
int Direct3DDevice9::ShowCursor(int show)
|
{
|
CriticalSection cs(this);
|
|
TRACE("int show = %d", show);
|
|
int oldValue = showCursor ? TRUE : FALSE;
|
showCursor = show != FALSE;
|
|
if(showCursor)
|
{
|
sw::FrameBuffer::setCursorImage(cursor);
|
}
|
else
|
{
|
sw::FrameBuffer::setCursorImage(0);
|
}
|
|
return oldValue;
|
}
|
|
long Direct3DDevice9::StretchRect(IDirect3DSurface9 *sourceSurface, const RECT *sourceRect, IDirect3DSurface9 *destSurface, const RECT *destRect, D3DTEXTUREFILTERTYPE filter)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DSurface9 *sourceSurface = 0x%0.8p, const RECT *sourceRect = 0x%0.8p, IDirect3DSurface9 *destSurface = 0x%0.8p, const RECT *destRect = 0x%0.8p, D3DTEXTUREFILTERTYPE filter = %d", sourceSurface, sourceRect, destSurface, destRect, filter);
|
|
if(!sourceSurface || !destSurface || !validRectangle(sourceRect, sourceSurface) || !validRectangle(destRect, destSurface))
|
{
|
return INVALIDCALL();
|
}
|
|
D3DSURFACE_DESC sourceDescription;
|
D3DSURFACE_DESC destDescription;
|
|
sourceSurface->GetDesc(&sourceDescription);
|
destSurface->GetDesc(&destDescription);
|
|
if(sourceDescription.Pool != D3DPOOL_DEFAULT || destDescription.Pool != D3DPOOL_DEFAULT)
|
{
|
return INVALIDCALL();
|
}
|
|
Direct3DSurface9 *source = static_cast<Direct3DSurface9*>(sourceSurface);
|
Direct3DSurface9 *dest = static_cast<Direct3DSurface9*>(destSurface);
|
|
stretchRect(source, sourceRect, dest, destRect, filter);
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::TestCooperativeLevel()
|
{
|
CriticalSection cs(this);
|
|
TRACE("void");
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::UpdateSurface(IDirect3DSurface9 *sourceSurface, const RECT *sourceRect, IDirect3DSurface9 *destinationSurface, const POINT *destPoint)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DSurface9 *sourceSurface = 0x%0.8p, const RECT *sourceRect = 0x%0.8p, IDirect3DSurface9 *destinationSurface = 0x%0.8p, const POINT *destPoint = 0x%0.8p", sourceSurface, sourceRect, destinationSurface, destPoint);
|
|
if(!sourceSurface || !destinationSurface)
|
{
|
return INVALIDCALL();
|
}
|
|
D3DSURFACE_DESC sourceDescription;
|
D3DSURFACE_DESC destinationDescription;
|
|
sourceSurface->GetDesc(&sourceDescription);
|
destinationSurface->GetDesc(&destinationDescription);
|
|
RECT sRect;
|
RECT dRect;
|
|
if(sourceRect)
|
{
|
sRect.left = sourceRect->left;
|
sRect.top = sourceRect->top;
|
sRect.right = sourceRect->right;
|
sRect.bottom = sourceRect->bottom;
|
}
|
else
|
{
|
sRect.left = 0;
|
sRect.top = 0;
|
sRect.right = sourceDescription.Width;
|
sRect.bottom = sourceDescription.Height;
|
}
|
|
if(destPoint)
|
{
|
dRect.left = destPoint->x;
|
dRect.top = destPoint->y;
|
dRect.right = destPoint->x + sRect.right - sRect.left;
|
dRect.bottom = destPoint->y + sRect.bottom - sRect.top;
|
}
|
else
|
{
|
dRect.left = 0;
|
dRect.top = 0;
|
dRect.right = sRect.right - sRect.left;
|
dRect.bottom = sRect.bottom - sRect.top;
|
}
|
|
if(!validRectangle(&sRect, sourceSurface) || !validRectangle(&dRect, destinationSurface))
|
{
|
return INVALIDCALL();
|
}
|
|
int sWidth = sRect.right - sRect.left;
|
int sHeight = sRect.bottom - sRect.top;
|
|
int dWidth = dRect.right - dRect.left;
|
int dHeight = dRect.bottom - dRect.top;
|
|
if(sourceDescription.MultiSampleType != D3DMULTISAMPLE_NONE ||
|
destinationDescription.MultiSampleType != D3DMULTISAMPLE_NONE ||
|
// sourceDescription.Pool != D3DPOOL_SYSTEMMEM || // FIXME: Check back buffer and depth buffer memory pool flags
|
// destinationDescription.Pool != D3DPOOL_DEFAULT ||
|
sourceDescription.Format != destinationDescription.Format)
|
{
|
return INVALIDCALL();
|
}
|
|
sw::Surface *source = static_cast<Direct3DSurface9*>(sourceSurface);
|
sw::Surface *dest = static_cast<Direct3DSurface9*>(destinationSurface);
|
|
unsigned char *sBuffer = (unsigned char*)source->lockExternal(sRect.left, sRect.top, 0, sw::LOCK_READONLY, sw::PUBLIC);
|
unsigned char *dBuffer = (unsigned char*)dest->lockExternal(dRect.left, dRect.top, 0, sw::LOCK_WRITEONLY, sw::PUBLIC);
|
int sPitch = source->getExternalPitchB();
|
int dPitch = dest->getExternalPitchB();
|
|
unsigned int width;
|
unsigned int height;
|
unsigned int bytes;
|
|
switch(sourceDescription.Format)
|
{
|
case D3DFMT_DXT1:
|
case D3DFMT_ATI1:
|
width = (dWidth + 3) / 4;
|
height = (dHeight + 3) / 4;
|
bytes = width * 8; // 64 bit per 4x4 block
|
break;
|
case D3DFMT_DXT2:
|
case D3DFMT_DXT3:
|
case D3DFMT_DXT4:
|
case D3DFMT_DXT5:
|
case D3DFMT_ATI2:
|
width = (dWidth + 3) / 4;
|
height = (dHeight + 3) / 4;
|
bytes = width * 16; // 128 bit per 4x4 block
|
break;
|
default:
|
width = dWidth;
|
height = dHeight;
|
bytes = width * Direct3DSurface9::bytes(sourceDescription.Format);
|
}
|
|
if(sourceDescription.Format == D3DFMT_ATI1 || sourceDescription.Format == D3DFMT_ATI2)
|
{
|
// Make the pitch correspond to 4 rows
|
sPitch *= 4;
|
dPitch *= 4;
|
}
|
|
for(unsigned int y = 0; y < height; y++)
|
{
|
memcpy(dBuffer, sBuffer, bytes);
|
|
sBuffer += sPitch;
|
dBuffer += dPitch;
|
}
|
|
source->unlockExternal();
|
dest->unlockExternal();
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::UpdateTexture(IDirect3DBaseTexture9 *sourceTexture, IDirect3DBaseTexture9 *destinationTexture)
|
{
|
CriticalSection cs(this);
|
|
TRACE("IDirect3DBaseTexture9 *sourceTexture = 0x%0.8p, IDirect3DBaseTexture9 *destinationTexture = 0x%0.8p", sourceTexture, destinationTexture);
|
|
if(!sourceTexture || !destinationTexture)
|
{
|
return INVALIDCALL();
|
}
|
|
// FIXME: Check memory pools
|
|
D3DRESOURCETYPE type = sourceTexture->GetType();
|
|
if(type != destinationTexture->GetType())
|
{
|
return INVALIDCALL();
|
}
|
|
switch(type)
|
{
|
case D3DRTYPE_TEXTURE:
|
{
|
IDirect3DTexture9 *source;
|
IDirect3DTexture9 *dest;
|
|
sourceTexture->QueryInterface(IID_IDirect3DTexture9, (void**)&source);
|
destinationTexture->QueryInterface(IID_IDirect3DTexture9, (void**)&dest);
|
|
ASSERT(source && dest);
|
|
for(unsigned int level = 0; level < source->GetLevelCount() && level < dest->GetLevelCount(); level++) // FIXME: Fail when source texture has fewer levels than the destination
|
{
|
IDirect3DSurface9 *sourceSurface;
|
IDirect3DSurface9 *destinationSurface;
|
|
source->GetSurfaceLevel(level, &sourceSurface);
|
dest->GetSurfaceLevel(level, &destinationSurface);
|
|
UpdateSurface(sourceSurface, 0, destinationSurface, 0);
|
|
sourceSurface->Release();
|
destinationSurface->Release();
|
}
|
|
source->Release();
|
dest->Release();
|
}
|
break;
|
case D3DRTYPE_VOLUMETEXTURE:
|
{
|
IDirect3DVolumeTexture9 *source;
|
IDirect3DVolumeTexture9 *dest;
|
|
sourceTexture->QueryInterface(IID_IDirect3DVolumeTexture9, (void**)&source);
|
destinationTexture->QueryInterface(IID_IDirect3DVolumeTexture9, (void**)&dest);
|
|
ASSERT(source && dest);
|
|
for(unsigned int level = 0; level < source->GetLevelCount() && level < dest->GetLevelCount(); level++) // FIXME: Fail when source texture has fewer levels than the destination
|
{
|
IDirect3DVolume9 *sourceVolume;
|
IDirect3DVolume9 *destinationVolume;
|
|
source->GetVolumeLevel(level, &sourceVolume);
|
dest->GetVolumeLevel(level, &destinationVolume);
|
|
updateVolume(sourceVolume, destinationVolume);
|
|
sourceVolume->Release();
|
destinationVolume->Release();
|
}
|
|
source->Release();
|
dest->Release();
|
}
|
break;
|
case D3DRTYPE_CUBETEXTURE:
|
{
|
IDirect3DCubeTexture9 *source;
|
IDirect3DCubeTexture9 *dest;
|
|
sourceTexture->QueryInterface(IID_IDirect3DCubeTexture9, (void**)&source);
|
destinationTexture->QueryInterface(IID_IDirect3DCubeTexture9, (void**)&dest);
|
|
ASSERT(source && dest);
|
|
for(int face = 0; face < 6; face++)
|
{
|
for(unsigned int level = 0; level < source->GetLevelCount() && level < dest->GetLevelCount(); level++) // FIXME: Fail when source texture has fewer levels than the destination
|
{
|
IDirect3DSurface9 *sourceSurface;
|
IDirect3DSurface9 *destinationSurface;
|
|
source->GetCubeMapSurface((D3DCUBEMAP_FACES)face, level, &sourceSurface);
|
dest->GetCubeMapSurface((D3DCUBEMAP_FACES)face, level, &destinationSurface);
|
|
UpdateSurface(sourceSurface, 0, destinationSurface, 0);
|
|
sourceSurface->Release();
|
destinationSurface->Release();
|
}
|
}
|
|
source->Release();
|
dest->Release();
|
}
|
break;
|
default:
|
UNIMPLEMENTED();
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::ValidateDevice(unsigned long *numPasses)
|
{
|
CriticalSection cs(this);
|
|
TRACE("unsigned long *numPasses = 0x%0.8p", numPasses);
|
|
if(!numPasses)
|
{
|
return INVALIDCALL();
|
}
|
|
*numPasses = 1;
|
|
return D3D_OK;
|
}
|
|
long Direct3DDevice9::getAdapterDisplayMode(unsigned int adapter, D3DDISPLAYMODE *mode)
|
{
|
return d3d9->GetAdapterDisplayMode(adapter, mode);
|
}
|
|
int Direct3DDevice9::typeStride(unsigned char streamType)
|
{
|
static int LUT[] =
|
{
|
4, // D3DDECLTYPE_FLOAT1 = 0, // 1D float expanded to (value, 0., 0., 1.)
|
8, // D3DDECLTYPE_FLOAT2 = 1, // 2D float expanded to (value, value, 0., 1.)
|
12, // D3DDECLTYPE_FLOAT3 = 2, // 3D float expanded to (value, value, value, 1.)
|
16, // D3DDECLTYPE_FLOAT4 = 3, // 4D float
|
4, // D3DDECLTYPE_D3DCOLOR = 4, // 4D packed unsigned bytes mapped to 0. to 1. range. Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
|
4, // D3DDECLTYPE_UBYTE4 = 5, // 4D unsigned byte
|
4, // D3DDECLTYPE_SHORT2 = 6, // 2D signed short expanded to (value, value, 0., 1.)
|
8, // D3DDECLTYPE_SHORT4 = 7, // 4D signed short
|
4, // D3DDECLTYPE_UBYTE4N = 8, // Each of 4 bytes is normalized by dividing to 255.0
|
4, // D3DDECLTYPE_SHORT2N = 9, // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
|
8, // D3DDECLTYPE_SHORT4N = 10, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
|
4, // D3DDECLTYPE_USHORT2N = 11, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
|
8, // D3DDECLTYPE_USHORT4N = 12, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
|
4, // D3DDECLTYPE_UDEC3 = 13, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
|
4, // D3DDECLTYPE_DEC3N = 14, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
|
4, // D3DDECLTYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded to (value, value, 0, 1)
|
8, // D3DDECLTYPE_FLOAT16_4 = 16, // Four 16-bit floating point values
|
0, // D3DDECLTYPE_UNUSED = 17, // When the type field in a decl is unused.
|
};
|
|
return LUT[streamType];
|
}
|
|
bool Direct3DDevice9::instanceData()
|
{
|
ASSERT(vertexDeclaration);
|
|
D3DVERTEXELEMENT9 vertexElement[MAXD3DDECLLENGTH + 1];
|
unsigned int numElements;
|
vertexDeclaration->GetDeclaration(vertexElement, &numElements);
|
|
bool instanceData = false;
|
|
for(unsigned int i = 0; i < numElements - 1; i++)
|
{
|
unsigned short stream = vertexElement[i].Stream;
|
|
if(stream != 0)
|
{
|
instanceData = instanceData || (streamSourceFreq[stream] & D3DSTREAMSOURCE_INSTANCEDATA) != 0;
|
}
|
}
|
|
return instanceData;
|
}
|
|
bool Direct3DDevice9::bindResources(Direct3DIndexBuffer9 *indexBuffer)
|
{
|
if(!bindViewport())
|
{
|
return false; // Zero-area target region
|
}
|
|
bindTextures();
|
bindIndexBuffer(indexBuffer);
|
bindShaderConstants();
|
bindLights();
|
|
return true;
|
}
|
|
void Direct3DDevice9::bindVertexStreams(int base, bool instancing, int instance)
|
{
|
ASSERT(vertexDeclaration);
|
|
renderer->resetInputStreams(vertexDeclaration->isPreTransformed());
|
|
D3DVERTEXELEMENT9 vertexElement[MAXD3DDECLLENGTH + 1];
|
unsigned int numElements;
|
vertexDeclaration->GetDeclaration(vertexElement, &numElements);
|
|
// Bind vertex data streams
|
for(unsigned int i = 0; i < numElements - 1; i++)
|
{
|
unsigned short stream = vertexElement[i].Stream;
|
unsigned short offset = vertexElement[i].Offset;
|
unsigned char type = vertexElement[i].Type;
|
unsigned char method = vertexElement[i].Method;
|
unsigned char usage = vertexElement[i].Usage;
|
unsigned char index = vertexElement[i].UsageIndex;
|
|
ASSERT(method == D3DDECLMETHOD_DEFAULT); // FIXME: Unimplemented
|
|
if(!dataStream[stream])
|
{
|
continue;
|
}
|
|
Direct3DVertexBuffer9 *streamBuffer = dataStream[stream];
|
sw::Resource *resource = streamBuffer->getResource();
|
const void *buffer = ((char*)resource->data() + streamOffset[stream]) + offset;
|
|
int stride = streamStride[stream];
|
|
if(instancing && streamSourceFreq[stream] & D3DSTREAMSOURCE_INSTANCEDATA)
|
{
|
int instanceFrequency = streamSourceFreq[stream] & ~D3DSTREAMSOURCE_INSTANCEDATA;
|
buffer = (char*)buffer + stride * (instance / instanceFrequency);
|
|
stride = 0;
|
}
|
else
|
{
|
buffer = (char*)buffer + stride * base;
|
}
|
|
sw::Stream attribute(resource, buffer, stride);
|
|
switch(type)
|
{
|
case D3DDECLTYPE_FLOAT1: attribute.define(sw::STREAMTYPE_FLOAT, 1, false); break;
|
case D3DDECLTYPE_FLOAT2: attribute.define(sw::STREAMTYPE_FLOAT, 2, false); break;
|
case D3DDECLTYPE_FLOAT3: attribute.define(sw::STREAMTYPE_FLOAT, 3, false); break;
|
case D3DDECLTYPE_FLOAT4: attribute.define(sw::STREAMTYPE_FLOAT, 4, false); break;
|
case D3DDECLTYPE_D3DCOLOR: attribute.define(sw::STREAMTYPE_COLOR, 4, false); break;
|
case D3DDECLTYPE_UBYTE4: attribute.define(sw::STREAMTYPE_BYTE, 4, false); break;
|
case D3DDECLTYPE_SHORT2: attribute.define(sw::STREAMTYPE_SHORT, 2, false); break;
|
case D3DDECLTYPE_SHORT4: attribute.define(sw::STREAMTYPE_SHORT, 4, false); break;
|
case D3DDECLTYPE_UBYTE4N: attribute.define(sw::STREAMTYPE_BYTE, 4, true); break;
|
case D3DDECLTYPE_SHORT2N: attribute.define(sw::STREAMTYPE_SHORT, 2, true); break;
|
case D3DDECLTYPE_SHORT4N: attribute.define(sw::STREAMTYPE_SHORT, 4, true); break;
|
case D3DDECLTYPE_USHORT2N: attribute.define(sw::STREAMTYPE_USHORT, 2, true); break;
|
case D3DDECLTYPE_USHORT4N: attribute.define(sw::STREAMTYPE_USHORT, 4, true); break;
|
case D3DDECLTYPE_UDEC3: attribute.define(sw::STREAMTYPE_UDEC3, 3, false); break;
|
case D3DDECLTYPE_DEC3N: attribute.define(sw::STREAMTYPE_DEC3N, 3, true); break;
|
case D3DDECLTYPE_FLOAT16_2: attribute.define(sw::STREAMTYPE_HALF, 2, false); break;
|
case D3DDECLTYPE_FLOAT16_4: attribute.define(sw::STREAMTYPE_HALF, 4, false); break;
|
case D3DDECLTYPE_UNUSED: attribute.defaults(); break;
|
default:
|
ASSERT(false);
|
}
|
|
if(vertexShader)
|
{
|
const sw::VertexShader *shader = vertexShader->getVertexShader();
|
|
if(!vertexDeclaration->isPreTransformed())
|
{
|
for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
|
{
|
const sw::Shader::Semantic& input = shader->getInput(i);
|
if((usage == input.usage) && (index == input.index))
|
{
|
renderer->setInputStream(i, attribute);
|
|
break;
|
}
|
}
|
}
|
else // Bind directly to the output
|
{
|
for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
|
{
|
const sw::Shader::Semantic& output = shader->getOutput(i, 0);
|
if(((usage == output.usage) || (usage == D3DDECLUSAGE_POSITIONT && output.usage == D3DDECLUSAGE_POSITION)) &&
|
(index == output.index))
|
{
|
renderer->setInputStream(i, attribute);
|
|
break;
|
}
|
}
|
}
|
}
|
else
|
{
|
switch(usage)
|
{
|
case D3DDECLUSAGE_POSITION: renderer->setInputStream(sw::Position, attribute); break;
|
case D3DDECLUSAGE_BLENDWEIGHT: renderer->setInputStream(sw::BlendWeight, attribute); break;
|
case D3DDECLUSAGE_BLENDINDICES: renderer->setInputStream(sw::BlendIndices, attribute.define(sw::STREAMTYPE_INDICES, 1)); break;
|
case D3DDECLUSAGE_NORMAL: renderer->setInputStream(sw::Normal, attribute.define(sw::STREAMTYPE_FLOAT, 3)); break;
|
case D3DDECLUSAGE_PSIZE: renderer->setInputStream(sw::PointSize, attribute.define(sw::STREAMTYPE_FLOAT, 1)); break;
|
case D3DDECLUSAGE_TEXCOORD: renderer->setInputStream(sw::TexCoord0 + index, attribute); break;
|
case D3DDECLUSAGE_TANGENT: /* Ignored */ break;
|
case D3DDECLUSAGE_BINORMAL: /* Ignored */ break;
|
case D3DDECLUSAGE_TESSFACTOR: UNIMPLEMENTED(); break;
|
case D3DDECLUSAGE_POSITIONT: renderer->setInputStream(sw::PositionT, attribute.define(sw::STREAMTYPE_FLOAT, 4)); break;
|
case D3DDECLUSAGE_COLOR: renderer->setInputStream(sw::Color0 + index, attribute.define(sw::STREAMTYPE_COLOR, 4)); break;
|
case D3DDECLUSAGE_FOG: /* Ignored */ break;
|
case D3DDECLUSAGE_DEPTH: /* Ignored */ break;
|
case D3DDECLUSAGE_SAMPLE: UNIMPLEMENTED(); break;
|
default:
|
ASSERT(false);
|
}
|
}
|
}
|
}
|
|
void Direct3DDevice9::bindIndexBuffer(Direct3DIndexBuffer9 *indexBuffer)
|
{
|
sw::Resource *resource = 0;
|
|
if(indexBuffer)
|
{
|
resource = indexBuffer->getResource();
|
}
|
|
renderer->setIndexBuffer(resource);
|
}
|
|
void Direct3DDevice9::bindShaderConstants()
|
{
|
if(pixelShaderDirty)
|
{
|
if(pixelShader)
|
{
|
if(pixelShaderConstantsBDirty)
|
{
|
renderer->setPixelShaderConstantB(0, pixelShaderConstantB, pixelShaderConstantsBDirty);
|
}
|
|
if(pixelShaderConstantsFDirty)
|
{
|
renderer->setPixelShaderConstantF(0, pixelShaderConstantF[0], pixelShaderConstantsFDirty);
|
}
|
|
if(pixelShaderConstantsIDirty)
|
{
|
renderer->setPixelShaderConstantI(0, pixelShaderConstantI[0], pixelShaderConstantsIDirty);
|
}
|
|
renderer->setPixelShader(pixelShader->getPixelShader()); // Loads shader constants set with DEF
|
pixelShaderConstantsBDirty = pixelShader->getPixelShader()->dirtyConstantsB; // Shader DEF'ed constants are dirty
|
pixelShaderConstantsFDirty = pixelShader->getPixelShader()->dirtyConstantsF; // Shader DEF'ed constants are dirty
|
pixelShaderConstantsIDirty = pixelShader->getPixelShader()->dirtyConstantsI; // Shader DEF'ed constants are dirty
|
}
|
else
|
{
|
renderer->setPixelShader(0);
|
}
|
|
pixelShaderDirty = false;
|
}
|
|
if(vertexShaderDirty)
|
{
|
if(vertexShader)
|
{
|
if(vertexShaderConstantsBDirty)
|
{
|
renderer->setVertexShaderConstantB(0, vertexShaderConstantB, vertexShaderConstantsBDirty);
|
}
|
|
if(vertexShaderConstantsFDirty)
|
{
|
renderer->setVertexShaderConstantF(0, vertexShaderConstantF[0], vertexShaderConstantsFDirty);
|
}
|
|
if(vertexShaderConstantsIDirty)
|
{
|
renderer->setVertexShaderConstantI(0, vertexShaderConstantI[0], vertexShaderConstantsIDirty);
|
}
|
|
renderer->setVertexShader(vertexShader->getVertexShader()); // Loads shader constants set with DEF
|
vertexShaderConstantsBDirty = vertexShader->getVertexShader()->dirtyConstantsB; // Shader DEF'ed constants are dirty
|
vertexShaderConstantsFDirty = vertexShader->getVertexShader()->dirtyConstantsF; // Shader DEF'ed constants are dirty
|
vertexShaderConstantsIDirty = vertexShader->getVertexShader()->dirtyConstantsI; // Shader DEF'ed constants are dirty
|
}
|
else
|
{
|
renderer->setVertexShader(0);
|
}
|
|
vertexShaderDirty = false;
|
}
|
}
|
|
void Direct3DDevice9::bindLights()
|
{
|
if(!lightsDirty) return;
|
|
Lights::iterator i = light.begin();
|
int active = 0;
|
|
// Set and enable renderer lights
|
while(active < 8)
|
{
|
while(i != light.end() && !i->second.enable)
|
{
|
i++;
|
}
|
|
if(i == light.end())
|
{
|
break;
|
}
|
|
const Light &l = i->second;
|
|
sw::Point position(l.Position.x, l.Position.y, l.Position.z);
|
sw::Color<float> diffuse(l.Diffuse.r, l.Diffuse.g, l.Diffuse.b, l.Diffuse.a);
|
sw::Color<float> specular(l.Specular.r, l.Specular.g, l.Specular.b, l.Specular.a);
|
sw::Color<float> ambient(l.Ambient.r, l.Ambient.g, l.Ambient.b, l.Ambient.a);
|
sw::Vector direction(l.Direction.x, l.Direction.y, l.Direction.z);
|
|
renderer->setLightDiffuse(active, diffuse);
|
renderer->setLightSpecular(active, specular);
|
renderer->setLightAmbient(active, ambient);
|
|
if(l.Type == D3DLIGHT_DIRECTIONAL)
|
{
|
// FIXME: Unsupported, make it a positional light far away without falloff
|
renderer->setLightPosition(active, -1e10f * direction);
|
renderer->setLightRange(active, l.Range);
|
renderer->setLightAttenuation(active, 1, 0, 0);
|
}
|
else if(l.Type == D3DLIGHT_SPOT)
|
{
|
// FIXME: Unsupported, make it a positional light
|
renderer->setLightPosition(active, position);
|
renderer->setLightRange(active, l.Range);
|
renderer->setLightAttenuation(active, l.Attenuation0, l.Attenuation1, l.Attenuation2);
|
}
|
else
|
{
|
renderer->setLightPosition(active, position);
|
renderer->setLightRange(active, l.Range);
|
renderer->setLightAttenuation(active, l.Attenuation0, l.Attenuation1, l.Attenuation2);
|
}
|
|
renderer->setLightEnable(active, true);
|
|
active++;
|
i++;
|
}
|
|
// Remaining lights are disabled
|
while(active < 8)
|
{
|
renderer->setLightEnable(active, false);
|
|
active++;
|
}
|
|
lightsDirty = false;
|
}
|
|
bool Direct3DDevice9::bindViewport()
|
{
|
if(viewport.Width <= 0 || viewport.Height <= 0)
|
{
|
return false;
|
}
|
|
if(scissorEnable)
|
{
|
if(scissorRect.left >= scissorRect.right || scissorRect.top >= scissorRect.bottom)
|
{
|
return false;
|
}
|
|
sw::Rect scissor;
|
scissor.x0 = scissorRect.left;
|
scissor.x1 = scissorRect.right;
|
scissor.y0 = scissorRect.top;
|
scissor.y1 = scissorRect.bottom;
|
|
renderer->setScissor(scissor);
|
}
|
else
|
{
|
sw::Rect scissor;
|
scissor.x0 = viewport.X;
|
scissor.x1 = viewport.X + viewport.Width;
|
scissor.y0 = viewport.Y;
|
scissor.y1 = viewport.Y + viewport.Height;
|
|
renderer->setScissor(scissor);
|
}
|
|
sw::Viewport view;
|
view.x0 = (float)viewport.X;
|
view.y0 = (float)viewport.Y + viewport.Height;
|
view.width = (float)viewport.Width;
|
view.height = -(float)viewport.Height;
|
view.minZ = viewport.MinZ;
|
view.maxZ = viewport.MaxZ;
|
|
renderer->setViewport(view);
|
|
return true;
|
}
|
|
void Direct3DDevice9::bindTextures()
|
{
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
Direct3DBaseTexture9 *baseTexture = texture[sampler];
|
|
sw::SamplerType type = sampler < 16 ? sw::SAMPLER_PIXEL : sw::SAMPLER_VERTEX;
|
int index = sampler < 16 ? sampler : sampler - 16; // Sampler index within type group
|
|
bool textureUsed = false;
|
|
if(type == sw::SAMPLER_PIXEL && pixelShader)
|
{
|
textureUsed = pixelShader->getPixelShader()->usesSampler(index);
|
}
|
else if(type == sw::SAMPLER_VERTEX && vertexShader)
|
{
|
textureUsed = vertexShader->getVertexShader()->usesSampler(index);
|
}
|
else
|
{
|
textureUsed = true; // FIXME: Check fixed-function use?
|
}
|
|
sw::Resource *resource = 0;
|
|
if(baseTexture && textureUsed)
|
{
|
resource = baseTexture->getResource();
|
}
|
|
renderer->setTextureResource(sampler, resource);
|
|
if(baseTexture && textureUsed)
|
{
|
baseTexture->GenerateMipSubLevels();
|
}
|
|
if(baseTexture && textureUsed)
|
{
|
int levelCount = baseTexture->getInternalLevelCount();
|
|
int textureLOD = baseTexture->GetLOD();
|
int samplerLOD = samplerState[sampler][D3DSAMP_MAXMIPLEVEL];
|
int LOD = textureLOD > samplerLOD ? textureLOD : samplerLOD;
|
|
if(samplerState[sampler][D3DSAMP_MIPFILTER] == D3DTEXF_NONE)
|
{
|
LOD = 0;
|
}
|
|
switch(baseTexture->GetType())
|
{
|
case D3DRTYPE_TEXTURE:
|
{
|
Direct3DTexture9 *texture = dynamic_cast<Direct3DTexture9*>(baseTexture);
|
Direct3DSurface9 *surface;
|
|
for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
|
{
|
int surfaceLevel = mipmapLevel;
|
|
if(surfaceLevel < LOD)
|
{
|
surfaceLevel = LOD;
|
}
|
|
if(surfaceLevel < 0)
|
{
|
surfaceLevel = 0;
|
}
|
else if(surfaceLevel >= levelCount)
|
{
|
surfaceLevel = levelCount - 1;
|
}
|
|
surface = texture->getInternalSurfaceLevel(surfaceLevel);
|
renderer->setTextureLevel(sampler, 0, mipmapLevel, surface, sw::TEXTURE_2D);
|
}
|
}
|
break;
|
case D3DRTYPE_CUBETEXTURE:
|
for(int face = 0; face < 6; face++)
|
{
|
Direct3DCubeTexture9 *cubeTexture = dynamic_cast<Direct3DCubeTexture9*>(baseTexture);
|
Direct3DSurface9 *surface;
|
|
for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
|
{
|
int surfaceLevel = mipmapLevel;
|
|
if(surfaceLevel < LOD)
|
{
|
surfaceLevel = LOD;
|
}
|
|
if(surfaceLevel < 0)
|
{
|
surfaceLevel = 0;
|
}
|
else if(surfaceLevel >= levelCount)
|
{
|
surfaceLevel = levelCount - 1;
|
}
|
|
surface = cubeTexture->getInternalCubeMapSurface((D3DCUBEMAP_FACES)face, surfaceLevel);
|
renderer->setTextureLevel(sampler, face, mipmapLevel, surface, sw::TEXTURE_CUBE);
|
}
|
}
|
break;
|
case D3DRTYPE_VOLUMETEXTURE:
|
{
|
Direct3DVolumeTexture9 *volumeTexture = dynamic_cast<Direct3DVolumeTexture9*>(baseTexture);
|
Direct3DVolume9 *volume;
|
|
for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
|
{
|
int surfaceLevel = mipmapLevel;
|
|
if(surfaceLevel < LOD)
|
{
|
surfaceLevel = LOD;
|
}
|
|
if(surfaceLevel < 0)
|
{
|
surfaceLevel = 0;
|
}
|
else if(surfaceLevel >= levelCount)
|
{
|
surfaceLevel = levelCount - 1;
|
}
|
|
volume = volumeTexture->getInternalVolumeLevel(surfaceLevel);
|
renderer->setTextureLevel(sampler, 0, mipmapLevel, volume, sw::TEXTURE_3D);
|
}
|
}
|
break;
|
default:
|
UNIMPLEMENTED();
|
}
|
}
|
else
|
{
|
renderer->setTextureLevel(sampler, 0, 0, 0, sw::TEXTURE_NULL);
|
}
|
}
|
}
|
|
bool Direct3DDevice9::isRecording() const
|
{
|
return stateRecorder != 0;
|
}
|
|
void Direct3DDevice9::setOcclusionEnabled(bool enable)
|
{
|
renderer->setOcclusionEnabled(enable);
|
}
|
|
void Direct3DDevice9::removeQuery(sw::Query *query)
|
{
|
renderer->removeQuery(query);
|
}
|
|
void Direct3DDevice9::addQuery(sw::Query *query)
|
{
|
renderer->addQuery(query);
|
}
|
|
void Direct3DDevice9::stretchRect(Direct3DSurface9 *source, const RECT *sourceRect, Direct3DSurface9 *dest, const RECT *destRect, D3DTEXTUREFILTERTYPE filter)
|
{
|
D3DSURFACE_DESC sourceDescription;
|
D3DSURFACE_DESC destDescription;
|
|
source->GetDesc(&sourceDescription);
|
dest->GetDesc(&destDescription);
|
|
int sWidth = source->getWidth();
|
int sHeight = source->getHeight();
|
int dWidth = dest->getWidth();
|
int dHeight = dest->getHeight();
|
|
sw::Rect sRect(0, 0, sWidth, sHeight);
|
sw::Rect dRect(0, 0, dWidth, dHeight);
|
|
if(sourceRect)
|
{
|
sRect.x0 = sourceRect->left;
|
sRect.y0 = sourceRect->top;
|
sRect.x1 = sourceRect->right;
|
sRect.y1 = sourceRect->bottom;
|
}
|
|
if(destRect)
|
{
|
dRect.x0 = destRect->left;
|
dRect.y0 = destRect->top;
|
dRect.x1 = destRect->right;
|
dRect.y1 = destRect->bottom;
|
}
|
|
bool scaling = (sRect.x1 - sRect.x0 != dRect.x1 - dRect.x0) || (sRect.y1 - sRect.y0 != dRect.y1 - dRect.y0);
|
bool equalFormats = source->getInternalFormat() == dest->getInternalFormat();
|
bool depthStencil = (sourceDescription.Usage & D3DUSAGE_DEPTHSTENCIL) == D3DUSAGE_DEPTHSTENCIL;
|
bool alpha0xFF = false;
|
|
if((sourceDescription.Format == D3DFMT_A8R8G8B8 && destDescription.Format == D3DFMT_X8R8G8B8) ||
|
(sourceDescription.Format == D3DFMT_X8R8G8B8 && destDescription.Format == D3DFMT_A8R8G8B8))
|
{
|
equalFormats = true;
|
alpha0xFF = true;
|
}
|
|
if(depthStencil) // Copy entirely, internally // FIXME: Check
|
{
|
if(source->hasDepth())
|
{
|
byte *sourceBuffer = (byte*)source->lockInternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
|
byte *destBuffer = (byte*)dest->lockInternal(0, 0, 0, sw::LOCK_DISCARD, sw::PUBLIC);
|
|
unsigned int width = source->getWidth();
|
unsigned int height = source->getHeight();
|
unsigned int pitch = source->getInternalPitchB();
|
|
for(unsigned int y = 0; y < height; y++)
|
{
|
memcpy(destBuffer, sourceBuffer, pitch); // FIXME: Only copy width * bytes
|
|
sourceBuffer += pitch;
|
destBuffer += pitch;
|
}
|
|
source->unlockInternal();
|
dest->unlockInternal();
|
}
|
|
if(source->hasStencil())
|
{
|
byte *sourceBuffer = (byte*)source->lockStencil(0, 0, 0, sw::PUBLIC);
|
byte *destBuffer = (byte*)dest->lockStencil(0, 0, 0, sw::PUBLIC);
|
|
unsigned int width = source->getWidth();
|
unsigned int height = source->getHeight();
|
unsigned int pitch = source->getStencilPitchB();
|
|
for(unsigned int y = 0; y < height; y++)
|
{
|
memcpy(destBuffer, sourceBuffer, pitch); // FIXME: Only copy width * bytes
|
|
sourceBuffer += pitch;
|
destBuffer += pitch;
|
}
|
|
source->unlockStencil();
|
dest->unlockStencil();
|
}
|
}
|
else if(!scaling && equalFormats)
|
{
|
unsigned char *sourceBytes = (unsigned char*)source->lockInternal(sRect.x0, sRect.y0, 0, sw::LOCK_READONLY, sw::PUBLIC);
|
unsigned char *destBytes = (unsigned char*)dest->lockInternal(dRect.x0, dRect.y0, 0, sw::LOCK_READWRITE, sw::PUBLIC);
|
unsigned int sourcePitch = source->getInternalPitchB();
|
unsigned int destPitch = dest->getInternalPitchB();
|
|
unsigned int width = dRect.x1 - dRect.x0;
|
unsigned int height = dRect.y1 - dRect.y0;
|
unsigned int bytes = width * sw::Surface::bytes(source->getInternalFormat());
|
|
for(unsigned int y = 0; y < height; y++)
|
{
|
memcpy(destBytes, sourceBytes, bytes);
|
|
if(alpha0xFF)
|
{
|
for(unsigned int x = 0; x < width; x++)
|
{
|
destBytes[4 * x + 3] = 0xFF;
|
}
|
}
|
|
sourceBytes += sourcePitch;
|
destBytes += destPitch;
|
}
|
|
source->unlockInternal();
|
dest->unlockInternal();
|
}
|
else
|
{
|
sw::SliceRectF sRectF((float)sRect.x0, (float)sRect.y0, (float)sRect.x1, (float)sRect.y1, 0);
|
renderer->blit(source, sRectF, dest, dRect, filter >= D3DTEXF_LINEAR);
|
}
|
}
|
|
long Direct3DDevice9::updateVolume(IDirect3DVolume9 *sourceVolume, IDirect3DVolume9 *destinationVolume)
|
{
|
TRACE("IDirect3DVolume9 *sourceVolume = 0x%0.8p, IDirect3DVolume9 *destinationVolume = 0x%0.8p", sourceVolume, destinationVolume);
|
|
if(!sourceVolume || !destinationVolume)
|
{
|
return INVALIDCALL();
|
}
|
|
D3DVOLUME_DESC sourceDescription;
|
D3DVOLUME_DESC destinationDescription;
|
|
sourceVolume->GetDesc(&sourceDescription);
|
destinationVolume->GetDesc(&destinationDescription);
|
|
if(sourceDescription.Pool != D3DPOOL_SYSTEMMEM ||
|
destinationDescription.Pool != D3DPOOL_DEFAULT ||
|
sourceDescription.Format != destinationDescription.Format ||
|
sourceDescription.Width != destinationDescription.Width ||
|
sourceDescription.Height != destinationDescription.Height ||
|
sourceDescription.Depth != destinationDescription.Depth)
|
{
|
return INVALIDCALL();
|
}
|
|
sw::Surface *source = static_cast<Direct3DVolume9*>(sourceVolume);
|
sw::Surface *dest = static_cast<Direct3DVolume9*>(destinationVolume);
|
|
if(source->getExternalPitchB() != dest->getExternalPitchB() ||
|
source->getExternalSliceB() != dest->getExternalSliceB())
|
{
|
UNIMPLEMENTED();
|
}
|
|
void *sBuffer = source->lockExternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
|
void *dBuffer = dest->lockExternal(0, 0, 0, sw::LOCK_WRITEONLY, sw::PUBLIC);
|
|
memcpy(dBuffer, sBuffer, source->getExternalSliceB() * sourceDescription.Depth);
|
|
source->unlockExternal();
|
dest->unlockExternal();
|
|
return D3D_OK;
|
}
|
|
bool Direct3DDevice9::validRectangle(const RECT *rect, IDirect3DSurface9 *surface)
|
{
|
if(!rect)
|
{
|
return true;
|
}
|
|
if(rect->right <= rect->left || rect->bottom <= rect->top)
|
{
|
return false;
|
}
|
|
if(rect->left < 0 || rect->top < 0)
|
{
|
return false;
|
}
|
|
D3DSURFACE_DESC description;
|
surface->GetDesc(&description);
|
|
if(rect->right > (int)description.Width || rect->bottom > (int)description.Height)
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
void Direct3DDevice9::configureFPU()
|
{
|
// _controlfp(_PC_24, _MCW_PC); // Single-precision
|
_controlfp(_MCW_EM, _MCW_EM); // Mask all exceptions
|
_controlfp(_RC_NEAR, _MCW_RC); // Round to nearest
|
}
|
}
|
