blob: 7f6e7691d77e00a31c9655b23203c257b29068f7 [file] [log] [blame]
// 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 "Direct3DDevice8.hpp"
#include "Direct3D8.hpp"
#include "Direct3DSurface8.hpp"
#include "Direct3DIndexBuffer8.hpp"
#include "Direct3DVertexBuffer8.hpp"
#include "Direct3DTexture8.hpp"
#include "Direct3DVolumeTexture8.hpp"
#include "Direct3DCubeTexture8.hpp"
#include "Direct3DSwapChain8.hpp"
#include "Direct3DPixelShader8.hpp"
#include "Direct3DVertexShader8.hpp"
#include "Direct3DVolume8.hpp"
#include "Debug.hpp"
#include "Capabilities.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 = false;
namespace D3D8
{
inline unsigned long FtoDW(float f) // FIXME: Deprecate
{
return (unsigned long&)f;
}
Direct3DDevice8::Direct3DDevice8(const HINSTANCE instance, Direct3D8 *d3d8, unsigned int adapter, D3DDEVTYPE deviceType, HWND focusWindow, unsigned long behaviourFlags, D3DPRESENT_PARAMETERS *presentParameters) : instance(instance), d3d8(d3d8), adapter(adapter), deviceType(deviceType), focusWindow(focusWindow), behaviourFlags(behaviourFlags), presentParameters(*presentParameters)
{
init = true;
recordState = false;
d3d8->AddRef();
context = new sw::Context();
renderer = new sw::Renderer(context, sw::Direct3D, false);
swapChain.push_back(0);
depthStencil = 0;
renderTarget = 0;
for(int i = 0; i < 8; i++)
{
texture[i] = 0;
}
cursor = 0;
unsigned char one[32 * 32 / sizeof(unsigned char)];
memset(one, 0xFFFFFFFF, sizeof(one));
unsigned char zero[32 * 32 / sizeof(unsigned char)] = {0};
nullCursor = CreateCursor(instance, 0, 0, 32, 32, one, zero);
win32Cursor = GetCursor();
Reset(presentParameters);
pixelShader.push_back(0); // pixelShader[0] = 0
vertexShader.push_back(0); // vertexShader[0] = 0
vertexShaderHandle = 0;
pixelShaderHandle = 0;
lightsDirty = true;
for(int i = 0; i < 16; i++)
{
dataStream[i] = 0;
streamStride[i] = 0;
}
indexData = 0;
baseVertexIndex = 0;
declaration = 0;
FVF = 0;
D3DMATERIAL8 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 < 8; i++)
{
float zero[4] = {0, 0, 0, 0};
SetPixelShaderConstant(i, zero, 1);
}
for(int i = 0; i < 256; i++)
{
float zero[4] = {0, 0, 0, 0};
SetVertexShaderConstant(i, zero, 1);
}
init = false;
if(!(behaviourFlags & D3DCREATE_FPU_PRESERVE))
{
configureFPU();
}
}
Direct3DDevice8::~Direct3DDevice8()
{
delete renderer;
renderer = 0;
delete context;
context = 0;
d3d8->Release();
d3d8 = 0;
for(unsigned int i = 0; i < swapChain.size(); i++)
{
if(swapChain[i])
{
swapChain[i]->unbind();
swapChain[i] = 0;
}
}
if(depthStencil)
{
depthStencil->unbind();
depthStencil = 0;
}
if(renderTarget)
{
renderTarget->unbind();
renderTarget = 0;
}
for(int i = 0; i < 8; i++)
{
if(texture[i])
{
texture[i]->unbind();
texture[i] = 0;
}
}
for(int i = 0; i < 16; i++)
{
if(dataStream[i])
{
dataStream[i]->unbind();
dataStream[i] = 0;
}
}
if(indexData)
{
indexData->unbind();
indexData = 0;
}
for(unsigned int i = 0; i < pixelShader.size(); i++)
{
if(pixelShader[i])
{
pixelShader[i]->unbind();
pixelShader[i] = 0;
}
}
for(unsigned int i = 0; i < vertexShader.size(); i++)
{
if(vertexShader[i])
{
vertexShader[i]->unbind();
vertexShader[i] = 0;
}
}
for(unsigned int i = 0; i < stateRecorder.size(); i++)
{
if(stateRecorder[i])
{
stateRecorder[i]->unbind();
stateRecorder[i] = 0;
}
}
palette.clear();
delete cursor;
DestroyCursor(nullCursor);
}
long Direct3DDevice8::QueryInterface(const IID &iid, void **object)
{
TRACE("");
if(iid == IID_IDirect3DDevice8 ||
iid == IID_IUnknown)
{
AddRef();
*object = this;
return S_OK;
}
*object = 0;
return NOINTERFACE(iid);
}
unsigned long Direct3DDevice8::AddRef()
{
TRACE("");
return Unknown::AddRef();
}
unsigned long Direct3DDevice8::Release()
{
TRACE("");
return Unknown::Release();
}
long Direct3DDevice8::ApplyStateBlock(unsigned long token)
{
TRACE("");
stateRecorder[token]->Apply();
return D3D_OK;
}
long Direct3DDevice8::BeginScene()
{
TRACE("");
return D3D_OK;
}
long Direct3DDevice8::BeginStateBlock()
{
TRACE("");
recordState = true;
Direct3DStateBlock8 *stateBlock = new Direct3DStateBlock8(this, (D3DSTATEBLOCKTYPE)0);
stateBlock->bind();
stateRecorder.push_back(stateBlock);
return D3D_OK;
}
long Direct3DDevice8::CaptureStateBlock(unsigned long token)
{
TRACE("");
stateRecorder[token]->Capture();
return D3D_OK;
}
long Direct3DDevice8::Clear(unsigned long count, const D3DRECT *rects, unsigned long flags, unsigned long color, float z, unsigned long stencil)
{
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:
break;
case D3DFMT_D16_LOCKABLE:
case D3DFMT_D32:
case D3DFMT_D16:
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 = &rect;
}
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(flags & D3DCLEAR_TARGET)
{
if(renderTarget)
{
D3DSURFACE_DESC description;
renderTarget->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;
renderer->clear(rgba, sw::FORMAT_A32B32G32R32F, renderTarget, 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 Direct3DDevice8::CopyRects(IDirect3DSurface8 *sourceSurface, const RECT *sourceRectsArray, unsigned int rects, IDirect3DSurface8 *destinationSurface, const POINT *destPointsArray)
{
TRACE("");
if(!sourceSurface || !destinationSurface)
{
return INVALIDCALL();
}
if(sourceRectsArray && rects == 0 || !sourceRectsArray && rects > 0)
{
return INVALIDCALL(); // FIXME: Verify REF behaviour
}
D3DSURFACE_DESC sourceDescription;
D3DSURFACE_DESC destDescription;
sourceSurface->GetDesc(&sourceDescription);
destinationSurface->GetDesc(&destDescription);
if(sourceDescription.Format != destDescription.Format)
{
return INVALIDCALL();
}
int sWidth = sourceDescription.Width;
int sHeight = sourceDescription.Height;
int dWidth = destDescription.Width;
int dHeight = destDescription.Height;
RECT sRect = {0, 0, sWidth, sHeight};
POINT dPoint = {0, 0};
if(!sourceRectsArray || !destPointsArray)
{
sourceRectsArray = &sRect;
destPointsArray = &dPoint;
rects = 1;
}
int bpp = 8 * Direct3DSurface8::bytes(sourceDescription.Format);
for(unsigned int i = 0; i < rects; i++)
{
const RECT &sRect = sourceRectsArray[i];
const POINT &dPoint = destPointsArray[i];
int rWidth = sRect.right - sRect.left;
int rHeight = sRect.bottom - sRect.top;
RECT dRect;
dRect.top = dPoint.y;
dRect.left = dPoint.x;
dRect.bottom = dPoint.y + rHeight;
dRect.right = dPoint.x + rWidth;
D3DLOCKED_RECT sourceLock;
D3DLOCKED_RECT destLock;
sourceSurface->LockRect(&sourceLock, &sRect, D3DLOCK_READONLY);
destinationSurface->LockRect(&destLock, &dRect, D3DLOCK_DISCARD);
for(int y = 0; y < rHeight; y++)
{
switch(sourceDescription.Format)
{
case D3DFMT_DXT1:
case D3DFMT_DXT2:
case D3DFMT_DXT3:
case D3DFMT_DXT4:
case D3DFMT_DXT5:
memcpy(destLock.pBits, sourceLock.pBits, rWidth * bpp / 8);
y += 3; // Advance four lines at once
break;
default:
memcpy(destLock.pBits, sourceLock.pBits, rWidth * bpp / 8);
}
(char*&)sourceLock.pBits += sourceLock.Pitch;
(char*&)destLock.pBits += destLock.Pitch;
}
sourceSurface->UnlockRect();
destinationSurface->UnlockRect();
}
return D3D_OK;
}
long Direct3DDevice8::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS *presentParameters, IDirect3DSwapChain8 **swapChain)
{
TRACE("");
*swapChain = 0;
if(!presentParameters || !swapChain)
{
return INVALIDCALL();
}
if(presentParameters->BackBufferCount > 3)
{
return INVALIDCALL(); // Maximum of three back buffers
}
if(presentParameters->BackBufferCount == 0)
{
presentParameters->BackBufferCount = 1;
}
D3DPRESENT_PARAMETERS present = *presentParameters;
*swapChain = new Direct3DSwapChain8(this, &present);
if(!*swapChain)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *swapChain;
return OUTOFVIDEOMEMORY();
}
this->swapChain.push_back(static_cast<Direct3DSwapChain8*>(*swapChain));
(*swapChain)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreateCubeTexture(unsigned int edgeLength, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DCubeTexture8 **cubeTexture)
{
TRACE("");
*cubeTexture = 0;
if(edgeLength == 0 || d3d8->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, usage, D3DRTYPE_CUBETEXTURE, format) != D3D_OK)
{
return INVALIDCALL();
}
*cubeTexture = new Direct3DCubeTexture8(this, edgeLength, levels, usage, format, pool);
if(!*cubeTexture)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *cubeTexture;
return OUTOFVIDEOMEMORY();
}
(*cubeTexture)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreateDepthStencilSurface(unsigned int width, unsigned int height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multiSample, IDirect3DSurface8 **surface)
{
TRACE("");
*surface = 0;
if(width == 0 || height == 0 || d3d8->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, format) != D3D_OK || height > sw::OUTLINE_RESOLUTION)
{
return INVALIDCALL();
}
*surface = new Direct3DSurface8(this, this, width, height, format, D3DPOOL_DEFAULT, multiSample, format == D3DFMT_D16_LOCKABLE, D3DUSAGE_DEPTHSTENCIL);
if(!*surface)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *surface;
return OUTOFVIDEOMEMORY();
}
(*surface)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreateImageSurface(unsigned int width, unsigned int height, D3DFORMAT format, IDirect3DSurface8 **surface)
{
TRACE("");
*surface = 0;
if(width == 0 || height == 0 || d3d8->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, 0, D3DRTYPE_SURFACE, format) != D3D_OK)
{
return INVALIDCALL();
}
*surface = new Direct3DSurface8(this, this, width, height, format, D3DPOOL_SYSTEMMEM, D3DMULTISAMPLE_NONE, true, 0);
if(!*surface)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *surface;
return OUTOFVIDEOMEMORY();
}
(*surface)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreateIndexBuffer(unsigned int length, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer8 **indexBuffer)
{
TRACE("");
*indexBuffer = new Direct3DIndexBuffer8(this, length, usage, format, pool);
if(!*indexBuffer)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *indexBuffer;
return OUTOFVIDEOMEMORY();
}
(*indexBuffer)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreatePixelShader(const unsigned long *function, unsigned long *handle)
{
TRACE("");
if(!function || !handle || function[0] > pixelShaderVersion)
{
return INVALIDCALL();
}
unsigned int index;
for(index = 1; index < pixelShader.size(); index++) // Skip NULL handle
{
if(pixelShader[index] == 0)
{
pixelShader[index] = new Direct3DPixelShader8(this, function); // FIXME: Check for null
break;
}
}
if(index == pixelShader.size())
{
pixelShader.push_back(new Direct3DPixelShader8(this, function));
}
pixelShader[index]->AddRef();
*handle = index;
return D3D_OK;
}
long Direct3DDevice8::CreateRenderTarget(unsigned int width, unsigned int height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multiSample, int lockable, IDirect3DSurface8 **surface)
{
TRACE("");
*surface = 0;
if(width == 0 || height == 0 || d3d8->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, format) != D3D_OK || height > sw::OUTLINE_RESOLUTION)
{
return INVALIDCALL();
}
*surface = new Direct3DSurface8(this, this, width, height, format, D3DPOOL_DEFAULT, multiSample, lockable != FALSE, D3DUSAGE_RENDERTARGET);
if(!*surface)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *surface;
return OUTOFVIDEOMEMORY();
}
(*surface)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreateStateBlock(D3DSTATEBLOCKTYPE type, unsigned long *token)
{
TRACE("");
if(!token)
{
return INVALIDCALL();
}
Direct3DStateBlock8 *stateBlock = new Direct3DStateBlock8(this, type);
stateBlock->bind();
stateRecorder.push_back(stateBlock);
*token = (unsigned long)(stateRecorder.size() - 1);
return D3D_OK;
}
long Direct3DDevice8::CreateTexture(unsigned int width, unsigned int height, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DTexture8 **texture)
{
TRACE("");
*texture = 0;
if(width == 0 || height == 0 || d3d8->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, usage, D3DRTYPE_TEXTURE, format) != D3D_OK)
{
return INVALIDCALL();
}
*texture = new Direct3DTexture8(this, width, height, levels, usage, format, pool);
if(!*texture)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *texture;
return OUTOFVIDEOMEMORY();
}
(*texture)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreateVertexBuffer(unsigned int length, unsigned long usage, unsigned long FVF, D3DPOOL pool, IDirect3DVertexBuffer8 **vertexBuffer)
{
TRACE("");
*vertexBuffer = new Direct3DVertexBuffer8(this, length, usage, FVF, pool);
if(!*vertexBuffer)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *vertexBuffer;
return OUTOFVIDEOMEMORY();
}
(*vertexBuffer)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::CreateVertexShader(const unsigned long *declaration, const unsigned long *function, unsigned long *handle, unsigned long usage)
{
TRACE("const unsigned long *declaration = 0x%0.8p, const unsigned long *function = 0x%0.8p, unsigned long *handle = 0x%0.8p, unsigned long usage = %d", declaration, function, handle, usage);
if(!declaration || !handle || (function && function[0] > vertexShaderVersion))
{
return INVALIDCALL();
}
unsigned int index;
for(index = 1; index < vertexShader.size(); index++) // NOTE: skip NULL handle
{
if(vertexShader[index] == 0)
{
vertexShader[index] = new Direct3DVertexShader8(this, declaration, function); // FIXME: Check for null
break;
}
}
if(index == vertexShader.size())
{
vertexShader.push_back(new Direct3DVertexShader8(this, declaration, function));
}
vertexShader[index]->AddRef();
*handle = (index << 16) + 1;
return D3D_OK;
}
long Direct3DDevice8::CreateVolumeTexture(unsigned int width, unsigned int height, unsigned int depth, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DVolumeTexture8 **volumeTexture)
{
TRACE("");
*volumeTexture = 0;
if(width == 0 || height == 0 || depth == 0 || d3d8->CheckDeviceFormat(adapter, deviceType, D3DFMT_X8R8G8B8, usage, D3DRTYPE_VOLUMETEXTURE, format) != D3D_OK)
{
return INVALIDCALL();
}
*volumeTexture = new Direct3DVolumeTexture8(this, width, height, depth, levels, usage, format, pool);
if(!*volumeTexture)
{
return OUTOFMEMORY();
}
if(GetAvailableTextureMem() == 0)
{
delete *volumeTexture;
return OUTOFVIDEOMEMORY();
}
(*volumeTexture)->AddRef();
return D3D_OK;
}
long Direct3DDevice8::DeletePatch(unsigned int handle)
{
TRACE("");
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::DeleteStateBlock(unsigned long token)
{
TRACE("");
if(token >= stateRecorder.size() || !stateRecorder[token])
{
return INVALIDCALL();
}
stateRecorder[token]->unbind();
stateRecorder[token] = 0;
return D3D_OK;
}
long Direct3DDevice8::DeleteVertexShader(unsigned long handle)
{
TRACE("");
unsigned int index = handle >> 16;
if(index >= vertexShader.size() || !vertexShader[index])
{
return INVALIDCALL();
}
vertexShader[index]->Release();
vertexShader[index] = 0;
return D3D_OK;
}
long Direct3DDevice8::DrawIndexedPrimitive(D3DPRIMITIVETYPE type, unsigned int minIndex, unsigned int numVertices, unsigned int startIndex, unsigned int primitiveCount)
{
TRACE("");
if(!indexData)
{
return INVALIDCALL();
}
if(!bindData(indexData, baseVertexIndex) || !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);
}
}
bindData(indexData, baseVertexIndex);
renderer->draw(drawType, indexOffset, primitiveCount);
return D3D_OK;
}
long Direct3DDevice8::DeletePixelShader(unsigned long handle)
{
TRACE("");
if(handle >= pixelShader.size() || !pixelShader[handle])
{
return INVALIDCALL();
}
pixelShader[handle]->Release();
pixelShader[handle] = 0;
return D3D_OK;
}
long Direct3DDevice8::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE type, unsigned int minIndex, unsigned int numVertices, unsigned int primitiveCount, const void *indexData, D3DFORMAT indexDataFormat, const void *vertexStreamZeroData, unsigned int vertexStreamZeroStride)
{
TRACE("");
if(!vertexStreamZeroData || !indexData)
{
return INVALIDCALL();
}
int length = (minIndex + numVertices) * vertexStreamZeroStride;
Direct3DVertexBuffer8 *vertexBuffer = new Direct3DVertexBuffer8(this, length, 0, 0, D3DPOOL_DEFAULT);
unsigned char *data;
vertexBuffer->Lock(0, 0, &data, 0);
memcpy(data, vertexStreamZeroData, length);
vertexBuffer->Unlock();
SetStreamSource(0, vertexBuffer, 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;
Direct3DIndexBuffer8 *indexBuffer = new Direct3DIndexBuffer8(this, length, 0, indexDataFormat, D3DPOOL_DEFAULT);
indexBuffer->Lock(0, 0, &data, 0);
memcpy(data, indexData, length);
indexBuffer->Unlock();
SetIndices(indexBuffer, 0);
if(!bindData(indexBuffer, 0) || !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);
}
}
renderer->draw(drawType, 0, primitiveCount);
SetStreamSource(0, 0, 0);
SetIndices(0, 0);
return D3D_OK;
}
long Direct3DDevice8::DrawPrimitive(D3DPRIMITIVETYPE primitiveType, unsigned int startVertex, unsigned int primitiveCount)
{
TRACE("");
if(!bindData(0, startVertex) || !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);
}
renderer->draw(drawType, 0, primitiveCount);
return D3D_OK;
}
long Direct3DDevice8::DrawPrimitiveUP(D3DPRIMITIVETYPE primitiveType, unsigned int primitiveCount, const void *vertexStreamZeroData, unsigned int vertexStreamZeroStride)
{
TRACE("");
if(!vertexStreamZeroData)
{
return INVALIDCALL();
}
IDirect3DVertexBuffer8 *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);
unsigned char *data;
vertexBuffer->Lock(0, 0, &data, 0);
memcpy(data, vertexStreamZeroData, length);
vertexBuffer->Unlock();
SetStreamSource(0, vertexBuffer, vertexStreamZeroStride);
if(!bindData(0, 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);
}
renderer->draw(drawType, 0, primitiveCount);
SetStreamSource(0, 0, 0);
vertexBuffer->Release();
return D3D_OK;
}
long Direct3DDevice8::DrawRectPatch(unsigned int handle, const float *numSegs, const D3DRECTPATCH_INFO *rectPatchInfo)
{
TRACE("");
if(!numSegs || !rectPatchInfo)
{
return INVALIDCALL();
}
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::DrawTriPatch(unsigned int handle, const float *numSegs, const D3DTRIPATCH_INFO *triPatchInfo)
{
TRACE("");
if(!numSegs || !triPatchInfo)
{
return INVALIDCALL();
}
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::EndScene()
{
TRACE("");
return D3D_OK;
}
long Direct3DDevice8::EndStateBlock(unsigned long *token)
{
TRACE("");
if(!token)
{
return INVALIDCALL();
}
recordState = false;
*token = (unsigned long)(stateRecorder.size() - 1);
return D3D_OK;
}
unsigned int Direct3DDevice8::GetAvailableTextureMem()
{
TRACE("");
int availableMemory = textureMemory - Direct3DResource8::getMemoryUsage();
if(availableMemory < 0) availableMemory = 0;
// Round to nearest MB
return (availableMemory + 0x80000) & 0xFFF00000;
}
long Direct3DDevice8::GetBackBuffer(unsigned int index, D3DBACKBUFFER_TYPE type, IDirect3DSurface8 **backBuffer)
{
TRACE("");
if(!backBuffer/* || type != D3DBACKBUFFER_TYPE_MONO*/)
{
return INVALIDCALL();
}
swapChain[index]->GetBackBuffer(index, type, backBuffer);
return D3D_OK;
}
long Direct3DDevice8::GetClipPlane(unsigned long index, float *plane)
{
TRACE("");
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 Direct3DDevice8::GetClipStatus(D3DCLIPSTATUS8 *clipStatus)
{
TRACE("");
if(!clipStatus)
{
return INVALIDCALL();
}
*clipStatus = this->clipStatus;
return D3D_OK;
}
long Direct3DDevice8::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *parameters)
{
TRACE("");
if(!parameters)
{
return INVALIDCALL();
}
parameters->AdapterOrdinal = adapter;
parameters->BehaviorFlags = behaviourFlags;
parameters->DeviceType = deviceType;
parameters->hFocusWindow = focusWindow;
return D3D_OK;
}
long Direct3DDevice8::GetCurrentTexturePalette(unsigned int *paletteNumber)
{
TRACE("");
if(!paletteNumber)
{
return INVALIDCALL();
}
*paletteNumber = currentPalette;
return D3D_OK;
}
long Direct3DDevice8::GetDepthStencilSurface(IDirect3DSurface8 **depthStencilSurface)
{
TRACE("");
if(!depthStencilSurface)
{
return INVALIDCALL();
}
*depthStencilSurface = depthStencil;
if(depthStencil)
{
depthStencil->AddRef();
}
return D3D_OK; // FIXME: Return NOTFOUND() when no depthStencil?
}
long Direct3DDevice8::GetDeviceCaps(D3DCAPS8 *caps)
{
TRACE("");
return d3d8->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, caps);
}
long Direct3DDevice8::GetDirect3D(IDirect3D8 **d3d8)
{
TRACE("");
if(!d3d8)
{
return INVALIDCALL();
}
ASSERT(this->d3d8);
*d3d8 = this->d3d8;
this->d3d8->AddRef();
return D3D_OK;
}
long Direct3DDevice8::GetDisplayMode(D3DDISPLAYMODE *mode)
{
TRACE("");
if(!mode)
{
return INVALIDCALL();
}
d3d8->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, mode);
return D3D_OK;
}
long Direct3DDevice8::GetFrontBuffer(IDirect3DSurface8 *destSurface)
{
TRACE("");
if(!destSurface)
{
return INVALIDCALL();
}
D3DLOCKED_RECT description;
destSurface->LockRect(&description, 0, 0);
swapChain[0]->screenshot(description.pBits);
destSurface->UnlockRect();
return D3D_OK;
}
void Direct3DDevice8::GetGammaRamp(D3DGAMMARAMP *ramp)
{
TRACE("");
if(!ramp)
{
return;
}
swapChain[0]->getGammaRamp((sw::GammaRamp*)ramp);
}
long Direct3DDevice8::GetIndices(IDirect3DIndexBuffer8 **indexData, unsigned int *baseVertexIndex)
{
TRACE("");
if(!indexData || !baseVertexIndex)
{
return INVALIDCALL();
}
*indexData = this->indexData;
if(this->indexData)
{
this->indexData->AddRef();
}
*baseVertexIndex = this->baseVertexIndex;
return D3D_OK;
}
long Direct3DDevice8::GetInfo(unsigned long devInfoID, void *devInfoStruct, unsigned long devInfoStructSize)
{
TRACE("");
if(!devInfoStruct || devInfoStructSize == 0)
{
return INVALIDCALL();
}
switch(devInfoID)
{
case 0: return E_FAIL;
case 1: return E_FAIL;
case 2: return E_FAIL;
case 3: return E_FAIL;
case 4: return S_FALSE;
case 5: UNIMPLEMENTED(); // FIXME: D3DDEVINFOID_RESOURCEMANAGER
case 6: UNIMPLEMENTED(); // FIXME: D3DDEVINFOID_D3DVERTEXSTATS
case 7: return E_FAIL;
}
return D3D_OK;
}
long Direct3DDevice8::GetLight(unsigned long index, D3DLIGHT8 *light)
{
TRACE("");
if(!light)
{
return INVALIDCALL();
}
if(!this->light.exists(index))
{
return INVALIDCALL();
}
*light = this->light[index];
return D3D_OK;
}
long Direct3DDevice8::GetLightEnable(unsigned long index , int *enable)
{
TRACE("");
if(!enable)
{
return INVALIDCALL();
}
if(!light.exists(index))
{
return INVALIDCALL();
}
*enable = light[index].enable;
return D3D_OK;
}
long Direct3DDevice8::GetMaterial(D3DMATERIAL8 *material)
{
TRACE("");
if(!material)
{
return INVALIDCALL();
}
*material = this->material;
return D3D_OK;
}
long Direct3DDevice8::GetPaletteEntries(unsigned int paletteNumber, PALETTEENTRY *entries)
{
TRACE("");
if(paletteNumber > 0xFFFF || !entries)
{
return INVALIDCALL();
}
for(int i = 0; i < 256; i++)
{
entries[i] = palette[paletteNumber].entry[i];
}
return D3D_OK;
}
long Direct3DDevice8::GetPixelShader(unsigned long *handle)
{
TRACE("");
if(!handle)
{
return INVALIDCALL();
}
*handle = pixelShaderHandle;
return D3D_OK;
}
long Direct3DDevice8::GetPixelShaderFunction(unsigned long handle, void *data, unsigned long *size)
{
TRACE("");
if(!data)
{
return INVALIDCALL();
}
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::GetPixelShaderConstant(unsigned long startRegister, void *constantData, unsigned long count)
{
TRACE("");
if(!constantData)
{
return INVALIDCALL();
}
for(unsigned int i = 0; i < count; i++)
{
((float*)constantData)[i * 4 + 0] = pixelShaderConstant[startRegister + i][0];
((float*)constantData)[i * 4 + 1] = pixelShaderConstant[startRegister + i][1];
((float*)constantData)[i * 4 + 2] = pixelShaderConstant[startRegister + i][2];
((float*)constantData)[i * 4 + 3] = pixelShaderConstant[startRegister + i][3];
}
return D3D_OK;
}
long Direct3DDevice8::GetRasterStatus(D3DRASTER_STATUS *rasterStatus)
{
TRACE("");
if(!rasterStatus)
{
return INVALIDCALL();
}
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::GetRenderState(D3DRENDERSTATETYPE state, unsigned long *value)
{
TRACE("");
if(!value)
{
return INVALIDCALL();
}
*value = renderState[state];
return D3D_OK;
}
long Direct3DDevice8::GetRenderTarget(IDirect3DSurface8 **renderTarget)
{
TRACE("");
if(!renderTarget)
{
return INVALIDCALL();
}
*renderTarget = this->renderTarget;
this->renderTarget->AddRef();
return D3D_OK;
}
long Direct3DDevice8::GetStreamSource(unsigned int streamNumber, IDirect3DVertexBuffer8 **streamData, unsigned int *stride)
{
TRACE("");
if(streamNumber >= 16 || !streamData || !stride)
{
return INVALIDCALL();
}
*streamData = dataStream[streamNumber];
if(dataStream[streamNumber])
{
dataStream[streamNumber]->AddRef();
}
*stride = 0; // NOTE: Unimplemented
return D3D_OK;
}
long Direct3DDevice8::GetTexture(unsigned long stage, IDirect3DBaseTexture8 **texture)
{
TRACE("");
if(!texture || stage >= 8)
{
return INVALIDCALL();
}
*texture = this->texture[stage];
if(this->texture[stage])
{
this->texture[stage]->AddRef();
}
return D3D_OK;
}
long Direct3DDevice8::GetTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE state, unsigned long *value)
{
TRACE("");
if(!value || stage < 0 || stage >= 8 || state < 0 || state > D3DTSS_RESULTARG) // FIXME: Set *value to 0?
{
return INVALIDCALL();
}
*value = textureStageState[stage][state];
return D3D_OK;
}
long Direct3DDevice8::GetTransform(D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
{
TRACE("");
if(!matrix || state < 0 || state > 511)
{
return INVALIDCALL();
}
*matrix = this->matrix[state];
return D3D_OK;
}
long Direct3DDevice8::GetVertexShader(unsigned long *handle)
{
TRACE("");
if(!handle)
{
return INVALIDCALL();
}
*handle = vertexShaderHandle;
return D3D_OK;
}
long Direct3DDevice8::GetVertexShaderConstant(unsigned long startRegister, void *constantData, unsigned long count)
{
TRACE("");
if(!constantData)
{
return INVALIDCALL();
}
for(unsigned int i = 0; i < count; i++)
{
((float*)constantData)[i * 4 + 0] = vertexShaderConstant[startRegister + i][0];
((float*)constantData)[i * 4 + 1] = vertexShaderConstant[startRegister + i][1];
((float*)constantData)[i * 4 + 2] = vertexShaderConstant[startRegister + i][2];
((float*)constantData)[i * 4 + 3] = vertexShaderConstant[startRegister + i][3];
}
return D3D_OK;
}
long Direct3DDevice8::GetVertexShaderDeclaration(unsigned long handle, void *data, unsigned long *size)
{
TRACE("");
if(!data || !size)
{
return INVALIDCALL();
}
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::GetVertexShaderFunction(unsigned long handle, void *data, unsigned long *size)
{
TRACE("");
if(!data || !size)
{
return INVALIDCALL();
}
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::GetViewport(D3DVIEWPORT8 *viewport)
{
TRACE("");
if(!viewport)
{
return INVALIDCALL();
}
*viewport = this->viewport;
return D3D_OK;
}
long Direct3DDevice8::LightEnable(unsigned long index, int enable)
{
TRACE("");
if(!recordState)
{
if(!light.exists(index)) // Insert default light
{
D3DLIGHT8 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;
SetLight(index, &light);
}
light[index].enable = (enable != FALSE);
lightsDirty = true;
}
else
{
stateRecorder.back()->lightEnable(index, enable);
}
return D3D_OK;
}
long Direct3DDevice8::MultiplyTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
{
TRACE("");
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 Direct3DDevice8::Present(const RECT *sourceRect, const RECT *destRect, HWND destWindowOverride, const RGNDATA *dirtyRegion)
{
TRACE("");
// NOTE: sourceRect and destRect can be null, dirtyRegion has to be null
HWND windowHandle = presentParameters.hDeviceWindow ? presentParameters.hDeviceWindow : focusWindow;
if(destWindowOverride && destWindowOverride != windowHandle)
{
UNIMPLEMENTED();
}
if(dirtyRegion)
{
return INVALIDCALL();
}
swapChain[0]->Present(sourceRect, destRect, destWindowOverride, dirtyRegion);
return D3D_OK;
}
long Direct3DDevice8::ProcessVertices(unsigned int srcStartIndex, unsigned int destIndex, unsigned int vertexCount, IDirect3DVertexBuffer8 *destBuffer, unsigned long flags)
{
TRACE("");
if(!destBuffer)
{
return INVALIDCALL();
}
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::Reset(D3DPRESENT_PARAMETERS *presentParameters)
{
TRACE("");
if(!presentParameters)
{
return INVALIDCALL();
}
if(swapChain[0])
{
swapChain[0]->unbind();
swapChain[0] = 0;
}
if(depthStencil)
{
depthStencil->unbind();
depthStencil = 0;
}
if(renderTarget)
{
renderTarget->unbind();
renderTarget = 0;
}
D3DPRESENT_PARAMETERS present = *presentParameters;
if(!swapChain[0])
{
swapChain[0] = new Direct3DSwapChain8(this, &present);
swapChain[0]->bind();
}
else
{
swapChain[0]->reset(&present);
}
HWND windowHandle = presentParameters->hDeviceWindow ? presentParameters->hDeviceWindow : focusWindow;
int width = 0;
int height = 0;
if(presentParameters->Windowed && (presentParameters->BackBufferHeight == 0 || presentParameters->BackBufferWidth == 0))
{
RECT rectangle;
GetClientRect(windowHandle, &rectangle);
width = rectangle.right - rectangle.left;
height = rectangle.bottom - rectangle.top;
}
else
{
width = presentParameters->BackBufferWidth;
height = presentParameters->BackBufferHeight;
}
if(presentParameters->EnableAutoDepthStencil != FALSE)
{
depthStencil = new Direct3DSurface8(this, this, width, height, presentParameters->AutoDepthStencilFormat, D3DPOOL_DEFAULT, presentParameters->MultiSampleType, presentParameters->AutoDepthStencilFormat == D3DFMT_D16_LOCKABLE, D3DUSAGE_DEPTHSTENCIL);
depthStencil->bind();
}
IDirect3DSurface8 *renderTarget;
swapChain[0]->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &renderTarget);
SetRenderTarget(renderTarget, depthStencil);
renderTarget->Release();
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_EDGEANTIALIAS, FALSE);
SetRenderState(D3DRS_RANGEFOGENABLE, FALSE);
SetRenderState(D3DRS_ZBIAS, 0);
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_SOFTWAREVERTEXPROCESSING, FALSE);
SetRenderState(D3DRS_POINTSIZE, FtoDW(1.0f));
SetRenderState(D3DRS_POINTSIZE_MIN, FtoDW(0.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_POSITIONORDER, D3DORDER_CUBIC);
SetRenderState(D3DRS_NORMALORDER, D3DORDER_LINEAR);
for(int i = 0; i < 8; i++)
{
SetTexture(i, 0);
SetTextureStageState(i, D3DTSS_COLOROP, i == 0 ? D3DTOP_MODULATE : D3DTOP_DISABLE);
SetTextureStageState(i, D3DTSS_COLORARG1, D3DTA_TEXTURE); // TODO: D3DTA_DIFFUSE when no texture assigned
SetTextureStageState(i, D3DTSS_COLORARG2, D3DTA_CURRENT);
SetTextureStageState(i, D3DTSS_ALPHAOP, i == 0 ? D3DTOP_SELECTARG1 : D3DTOP_DISABLE);
SetTextureStageState(i, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); // TODO: D3DTA_DIFFUSE when no texture assigned
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_ADDRESSU, D3DTADDRESS_WRAP);
SetTextureStageState(i, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
SetTextureStageState(i, D3DTSS_ADDRESSW, D3DTADDRESS_WRAP);
SetTextureStageState(i, D3DTSS_BORDERCOLOR, 0x00000000);
SetTextureStageState(i, D3DTSS_MAGFILTER, D3DTEXF_POINT);
SetTextureStageState(i, D3DTSS_MINFILTER, D3DTEXF_POINT);
SetTextureStageState(i, D3DTSS_MIPFILTER, D3DTEXF_NONE);
SetTextureStageState(i, D3DTSS_MIPMAPLODBIAS, 0);
SetTextureStageState(i, D3DTSS_MAXMIPLEVEL, 0);
SetTextureStageState(i, D3DTSS_MAXANISOTROPY, 1);
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);
}
currentPalette = 0xFFFF;
delete cursor;
showCursor = false;
return D3D_OK;
}
long Direct3DDevice8::ResourceManagerDiscardBytes(unsigned long bytes)
{
TRACE("");
return D3D_OK;
}
long Direct3DDevice8::SetClipPlane(unsigned long index, const float *plane)
{
TRACE("");
if(!plane || index > 6)
{
return INVALIDCALL();
}
if(!recordState)
{
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.back()->setClipPlane(index, plane);
}
return D3D_OK;
}
long Direct3DDevice8::SetClipStatus(const D3DCLIPSTATUS8 *clipStatus)
{
TRACE("");
if(!clipStatus)
{
return INVALIDCALL();
}
this->clipStatus = *clipStatus;
UNIMPLEMENTED();
return D3D_OK;
}
long Direct3DDevice8::SetCurrentTexturePalette(unsigned int paletteNumber)
{
TRACE("");
if(paletteNumber > 0xFFFF || palette.find(paletteNumber) == palette.end())
{
return INVALIDCALL();
}
if(!recordState)
{
currentPalette = paletteNumber;
sw::Surface::setTexturePalette((unsigned int*)&palette[currentPalette]);
}
else
{
stateRecorder.back()->setCurrentTexturePalette(paletteNumber);
}
return D3D_OK;
}
void Direct3DDevice8::SetCursorPosition(int x, int y, unsigned long flags)
{
TRACE("");
POINT point = {x, y};
HWND window = focusWindow ? focusWindow : presentParameters.hDeviceWindow;
ScreenToClient(window, &point);
sw::FrameBuffer::setCursorPosition(point.x, point.y);
}
long Direct3DDevice8::SetCursorProperties(unsigned int x0, unsigned int y0, IDirect3DSurface8 *cursorBitmap)
{
TRACE("");
if(!cursorBitmap)
{
return INVALIDCALL();
}
D3DSURFACE_DESC desc;
D3DLOCKED_RECT lock;
cursorBitmap->GetDesc(&desc);
cursorBitmap->LockRect(&lock, 0, 0);
delete cursor;
cursor = sw::Surface::create(0, desc.Width, desc.Height, 1, sw::FORMAT_A8R8G8B8, false, false);
void *buffer = cursor->lockExternal(0, 0, 0, sw::LOCK_DISCARD, sw::PUBLIC);
memcpy(buffer, lock.pBits, desc.Width * desc.Height * sizeof(unsigned int));
cursor->unlockExternal();
cursorBitmap->UnlockRect();
sw::FrameBuffer::setCursorOrigin(x0, y0);
bindCursor();
return D3D_OK;
}
void Direct3DDevice8::SetGammaRamp(unsigned long flags, const D3DGAMMARAMP *ramp)
{
TRACE("");
if(!ramp)
{
return;
}
swapChain[0]->setGammaRamp((sw::GammaRamp*)ramp, flags & D3DSGR_CALIBRATE);
return;
}
long Direct3DDevice8::SetLight(unsigned long index, const D3DLIGHT8 *light)
{
TRACE("");
if(!light)
{
return INVALIDCALL();
}
if(!recordState)
{
this->light[index] = *light;
lightsDirty = true;
}
else
{
stateRecorder.back()->setLight(index, light);
}
return D3D_OK;
}
long Direct3DDevice8::SetMaterial(const D3DMATERIAL8 *material)
{
TRACE("");
if(!material)
{
return INVALIDCALL(); // FIXME: Correct behaviour?
}
if(!recordState)
{
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.back()->setMaterial(material);
}
return D3D_OK;
}
long Direct3DDevice8::SetPaletteEntries(unsigned int paletteNumber, const PALETTEENTRY *entries)
{
TRACE("");
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 Direct3DDevice8::SetPixelShader(unsigned long handle)
{
TRACE("");
if(!recordState)
{
if(pixelShader[handle])
{
pixelShader[handle]->bind();
}
if(pixelShader[pixelShaderHandle])
{
pixelShader[pixelShaderHandle]->unbind();
}
pixelShaderHandle = handle;
if(handle != 0)
{
renderer->setPixelShader(pixelShader[handle]->getPixelShader());
}
else
{
renderer->setPixelShader(0);
}
}
else
{
stateRecorder.back()->setPixelShader(handle);
}
return D3D_OK;
}
long Direct3DDevice8::SetPixelShaderConstant(unsigned long startRegister, const void *constantData, unsigned long count)
{
TRACE("");
if(!recordState)
{
for(unsigned int i = 0; i < count; i++)
{
pixelShaderConstant[startRegister + i][0] = ((float*)constantData)[i * 4 + 0];
pixelShaderConstant[startRegister + i][1] = ((float*)constantData)[i * 4 + 1];
pixelShaderConstant[startRegister + i][2] = ((float*)constantData)[i * 4 + 2];
pixelShaderConstant[startRegister + i][3] = ((float*)constantData)[i * 4 + 3];
}
renderer->setPixelShaderConstantF(startRegister, (const float*)constantData, count);
}
else
{
stateRecorder.back()->setPixelShaderConstant(startRegister, constantData, count);
}
return D3D_OK;
}
long Direct3DDevice8::SetRenderState(D3DRENDERSTATETYPE state, unsigned long value)
{
TRACE("D3DRENDERSTATETYPE state = %d, unsigned long value = %d", state, value);
if(state < D3DRS_ZENABLE || state > D3DRS_NORMALORDER)
{
return D3D_OK; // FIXME: Warning
}
if(!recordState)
{
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:
// FIXME: Unimplemented (should set gouraud)?
break;
default:
ASSERT(false);
}
break;
case D3DRS_LINEPATTERN:
if(!init) UNIMPLEMENTED();
break;
case D3DRS_ZWRITEENABLE:
renderer->setDepthWriteEnable(value != FALSE);
break;
case D3DRS_ALPHATESTENABLE:
renderer->setAlphaTestEnable(value != FALSE);
break;
case D3DRS_LASTPIXEL:
if(!init) UNIMPLEMENTED();
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;
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;
default:
ASSERT(false);
}
break;
case D3DRS_CULLMODE:
switch(value)
{
case D3DCULL_NONE:
renderer->setCullMode(sw::CULL_NONE);
break;
case D3DCULL_CCW:
renderer->setCullMode(sw::CULL_COUNTERCLOCKWISE);
break;
case D3DCULL_CW:
renderer->setCullMode(sw::CULL_CLOCKWISE);
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 && value == 1) UNIMPLEMENTED(); // FIXME: Unimplemented
break;
case D3DRS_ALPHABLENDENABLE:
renderer->setAlphaBlendEnable(value != FALSE);
break;
case D3DRS_FOGENABLE:
renderer->setFogEnable(value != FALSE);
break;
case D3DRS_ZVISIBLE:
break; // Not supported
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_EDGEANTIALIAS:
if(!init) if(value != FALSE) UNIMPLEMENTED();
break;
case D3DRS_ZBIAS:
renderer->setDepthBias(-2.0e-6f * value);
renderer->setSlopeDepthBias(0.0f);
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_SOFTWAREVERTEXPROCESSING:
break;
case D3DRS_POINTSIZE:
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(renderTarget, depthStencil); // Sets the multi-sample mask, if maskable
break;
case D3DRS_PATCHEDGESTYLE:
// if(!init) UNIMPLEMENTED();
break;
case D3DRS_PATCHSEGMENTS:
// UNIMPLEMENTED(); // FIXME
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);
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_POSITIONORDER:
if(!init) UNIMPLEMENTED();
break;
case D3DRS_NORMALORDER:
if(!init) UNIMPLEMENTED();
break;
default:
ASSERT(false);
}
}
else // stateRecorder
{
stateRecorder.back()->setRenderState(state, value);
}
return D3D_OK;
}
long Direct3DDevice8::SetRenderTarget(IDirect3DSurface8 *newRenderTarget, IDirect3DSurface8 *newDepthStencil)
{
TRACE("");
Direct3DSurface8 *renderTarget = static_cast<Direct3DSurface8*>(newRenderTarget);
if(renderTarget) // FIXME: Check for D3DUSAGE_RENDERTARGET
{
renderTarget->bind();
}
if(this->renderTarget)
{
this->renderTarget->unbind();
}
this->renderTarget = renderTarget;
Direct3DSurface8 *depthStencil = static_cast<Direct3DSurface8*>(newDepthStencil);
if(depthStencil) // FIXME: Check for D3DUSAGE_DEPTHSTENCIL and D3DPOOL_DEFAULT
{
depthStencil->bind();
}
if(this->depthStencil)
{
this->depthStencil->unbind();
}
this->depthStencil = depthStencil;
// Reset viewport to size of current render target
D3DSURFACE_DESC renderTargetDesc;
renderTarget->GetDesc(&renderTargetDesc);
D3DVIEWPORT8 viewport;
viewport.X = 0;
viewport.Y = 0;
viewport.Width = renderTargetDesc.Width;
viewport.Height = renderTargetDesc.Height;
viewport.MinZ = 0;
viewport.MaxZ = 1;
SetViewport(&viewport);
// Set the multi-sample mask, if maskable
if(renderTargetDesc.MultiSampleType != D3DMULTISAMPLE_NONE)
{
renderer->setMultiSampleMask(renderState[D3DRS_MULTISAMPLEMASK]);
}
else
{
renderer->setMultiSampleMask(0xFFFFFFFF);
}
renderer->setRenderTarget(0, renderTarget);
renderer->setDepthBuffer(depthStencil);
renderer->setStencilBuffer(depthStencil);
return D3D_OK;
}
long Direct3DDevice8::SetStreamSource(unsigned int stream, IDirect3DVertexBuffer8 *iVertexBuffer, unsigned int stride)
{
TRACE("");
Direct3DVertexBuffer8 *vertexBuffer = static_cast<Direct3DVertexBuffer8*>(iVertexBuffer);
if(!recordState)
{
if(vertexBuffer)
{
vertexBuffer->bind();
}
if(dataStream[stream])
{
dataStream[stream]->unbind();
streamStride[stream] = 0;
}
dataStream[stream] = vertexBuffer;
streamStride[stream] = stride;
}
else
{
stateRecorder.back()->setStreamSource(stream, vertexBuffer, stride);
}
return D3D_OK;
}
long Direct3DDevice8::SetTexture(unsigned long stage, IDirect3DBaseTexture8 *iBaseTexture)
{
TRACE("");
if(stage >= 8)
{
return INVALIDCALL();
}
Direct3DBaseTexture8 *baseTexture = dynamic_cast<Direct3DBaseTexture8*>(iBaseTexture);
if(!recordState)
{
if(texture[stage] == baseTexture)
{
return D3D_OK;
}
if(baseTexture)
{
baseTexture->bind();
}
if(texture[stage])
{
texture[stage]->unbind();
}
texture[stage] = baseTexture;
}
else
{
stateRecorder.back()->setTexture(stage, baseTexture);
}
return D3D_OK;
}
long Direct3DDevice8::SetTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long value)
{
TRACE("unsigned long stage = %d, D3DTEXTURESTAGESTATETYPE type = %d, unsigned long value = %d", stage, type, value);
if(stage >= 8 || type < 0 || type > D3DTSS_RESULTARG)
{
return INVALIDCALL();
}
if(!recordState)
{
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;
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;
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;
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;
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 & 0xFFFF);
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;
default:
ASSERT(false);
}
break;
case D3DTSS_ADDRESSU:
switch(value)
{
case D3DTADDRESS_WRAP:
renderer->setAddressingModeU(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_WRAP);
break;
case D3DTADDRESS_MIRROR:
renderer->setAddressingModeU(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_MIRROR);
break;
case D3DTADDRESS_CLAMP:
renderer->setAddressingModeU(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_CLAMP);
break;
case D3DTADDRESS_BORDER:
renderer->setAddressingModeU(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_BORDER);
break;
case D3DTADDRESS_MIRRORONCE:
renderer->setAddressingModeU(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_MIRRORONCE);
break;
default:
ASSERT(false);
}
break;
case D3DTSS_ADDRESSV:
switch(value)
{
case D3DTADDRESS_WRAP:
renderer->setAddressingModeV(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_WRAP);
break;
case D3DTADDRESS_MIRROR:
renderer->setAddressingModeV(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_MIRROR);
break;
case D3DTADDRESS_CLAMP:
renderer->setAddressingModeV(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_CLAMP);
break;
case D3DTADDRESS_BORDER:
renderer->setAddressingModeV(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_BORDER);
break;
case D3DTADDRESS_MIRRORONCE:
renderer->setAddressingModeV(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_MIRRORONCE);
break;
default:
ASSERT(false);
}
break;
case D3DTSS_BORDERCOLOR:
renderer->setBorderColor(sw::SAMPLER_PIXEL, stage, value);
break;
case D3DTSS_MAGFILTER:
// NOTE: SwiftShader does not differentiate between minification and magnification filter
switch(value)
{
case D3DTEXF_NONE:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_POINT);
break;
case D3DTEXF_POINT:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_POINT);
break;
case D3DTEXF_LINEAR:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_LINEAR);
break;
case D3DTEXF_ANISOTROPIC:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_ANISOTROPIC);
break;
case D3DTEXF_FLATCUBIC:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_LINEAR); // NOTE: Unimplemented, fail silently
break;
case D3DTEXF_GAUSSIANCUBIC:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_LINEAR); // NOTE: Unimplemented, fail silently
break;
default:
return INVALIDCALL();
};
break;
case D3DTSS_MINFILTER:
// NOTE: SwiftShader does not differentiate between minification and magnification filter
switch(value)
{
case D3DTEXF_NONE:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_POINT);
break;
case D3DTEXF_POINT:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_POINT);
break;
case D3DTEXF_LINEAR:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_LINEAR);
break;
case D3DTEXF_ANISOTROPIC:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_ANISOTROPIC);
break;
case D3DTEXF_FLATCUBIC:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_LINEAR); // NOTE: Unimplemented, fail silently
break;
case D3DTEXF_GAUSSIANCUBIC:
renderer->setTextureFilter(sw::SAMPLER_PIXEL, stage, sw::FILTER_LINEAR); // NOTE: Unimplemented, fail silently
break;
default:
return INVALIDCALL();
};
break;
case D3DTSS_MIPFILTER:
switch(value)
{
case D3DTEXF_NONE:
renderer->setMipmapFilter(sw::SAMPLER_PIXEL, stage, sw::MIPMAP_NONE);
break;
case D3DTEXF_POINT:
renderer->setMipmapFilter(sw::SAMPLER_PIXEL, stage, sw::MIPMAP_POINT);
break;
case D3DTEXF_LINEAR:
renderer->setMipmapFilter(sw::SAMPLER_PIXEL, stage, sw::MIPMAP_LINEAR);
break;
case D3DTEXF_ANISOTROPIC:
renderer->setMipmapFilter(sw::SAMPLER_PIXEL, stage, sw::MIPMAP_LINEAR); // NOTE: Unimplemented, fail silently
break;
case D3DTEXF_FLATCUBIC:
renderer->setMipmapFilter(sw::SAMPLER_PIXEL, stage, sw::MIPMAP_LINEAR); // NOTE: Unimplemented, fail silently
break;
case D3DTEXF_GAUSSIANCUBIC:
renderer->setMipmapFilter(sw::SAMPLER_PIXEL, stage, sw::MIPMAP_LINEAR); // NOTE: Unimplemented, fail silently
break;
default:
return INVALIDCALL();
};
break;
case D3DTSS_MIPMAPLODBIAS:
{
float LOD = (float&)value - sw::log2((float)context->renderTarget[0]->getSuperSampleCount()); // FIXME: Update when render target changes
renderer->setMipmapLOD(sw::SAMPLER_PIXEL, stage, LOD);
}
break;
case D3DTSS_MAXMIPLEVEL:
break;
case D3DTSS_MAXANISOTROPY:
renderer->setMaxAnisotropy(sw::SAMPLER_PIXEL, stage, sw::clamp((unsigned int)value, (unsigned int)1, maxAnisotropy));
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_ADDRESSW:
switch(value)
{
case D3DTADDRESS_WRAP:
renderer->setAddressingModeW(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_WRAP);
break;
case D3DTADDRESS_MIRROR:
renderer->setAddressingModeW(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_MIRROR);
break;
case D3DTADDRESS_CLAMP:
renderer->setAddressingModeW(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_CLAMP);
break;
case D3DTADDRESS_BORDER:
renderer->setAddressingModeW(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_BORDER);
break;
case D3DTADDRESS_MIRRORONCE:
renderer->setAddressingModeW(sw::SAMPLER_PIXEL, stage, sw::ADDRESSING_MIRRORONCE);
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;
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;
default:
ASSERT(false);
}
}
else // stateRecorder
{
stateRecorder.back()->setTextureStageState(stage, type, value);
}
return D3D_OK;
}
long Direct3DDevice8::SetTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
{
TRACE("");
if(!matrix || state < 0 || state > 511)
{
return INVALIDCALL();
}
if(!recordState)
{
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.back()->setTransform(state, matrix);
}
return D3D_OK;
}
long Direct3DDevice8::SetVertexShader(unsigned long handle)
{
TRACE("");
if(!recordState)
{
if(handle & 0x00000001)
{
unsigned int index = handle >> 16;
if(vertexShader[index])
{
vertexShader[index]->bind();
}
if(vertexShader[vertexShaderHandle >> 16])
{
vertexShader[vertexShaderHandle >> 16]->unbind();
}
vertexShaderHandle = handle;
Direct3DVertexShader8 *shader = vertexShader[index];
renderer->setVertexShader(shader->getVertexShader());
declaration = shader->getDeclaration();
FVF = 0;
}
else
{
renderer->setVertexShader(0);
declaration = 0;
FVF = handle;
}
}
else
{
stateRecorder.back()->setVertexShader(handle);
}
return D3D_OK;
}
long Direct3DDevice8::SetVertexShaderConstant(unsigned long startRegister, const void *constantData, unsigned long count)
{
TRACE("");
if(!constantData)
{
return INVALIDCALL();
}
if(!recordState)
{
for(unsigned int i = 0; i < count; i++)
{
vertexShaderConstant[startRegister + i][0] = ((float*)constantData)[i * 4 + 0];
vertexShaderConstant[startRegister + i][1] = ((float*)constantData)[i * 4 + 1];
vertexShaderConstant[startRegister + i][2] = ((float*)constantData)[i * 4 + 2];
vertexShaderConstant[startRegister + i][3] = ((float*)constantData)[i * 4 + 3];
}
renderer->setVertexShaderConstantF(startRegister, (const float*)constantData, count);
}
else
{
stateRecorder.back()->setVertexShaderConstant(startRegister, constantData, count);
}
return D3D_OK;
}
long Direct3DDevice8::SetViewport(const D3DVIEWPORT8 *viewport)
{
TRACE("");
if(!viewport)
{
return INVALIDCALL();
}
if(!recordState)
{
this->viewport = *viewport;
}
else
{
stateRecorder.back()->setViewport(viewport);
}
return D3D_OK;
}
int Direct3DDevice8::ShowCursor(int show)
{
TRACE("");
int oldValue = showCursor ? TRUE : FALSE;
showCursor = show != FALSE && cursor;
bindCursor();
return oldValue;
}
long Direct3DDevice8::TestCooperativeLevel()
{
TRACE("");
return D3D_OK;
}
long Direct3DDevice8::UpdateTexture(IDirect3DBaseTexture8 *sourceTexture, IDirect3DBaseTexture8 *destinationTexture)
{
TRACE("");
if(!sourceTexture || !destinationTexture)
{
return INVALIDCALL();
}
D3DRESOURCETYPE type = sourceTexture->GetType();
if(type != destinationTexture->GetType())
{
return INVALIDCALL();
}
switch(type)
{
case D3DRTYPE_TEXTURE:
{
IDirect3DTexture8 *source;
IDirect3DTexture8 *dest;
sourceTexture->QueryInterface(IID_IDirect3DTexture8, (void**)&source);
destinationTexture->QueryInterface(IID_IDirect3DTexture8, (void**)&dest);
ASSERT(source && dest);
for(unsigned int level = 0; level < source->GetLevelCount() && level < dest->GetLevelCount(); level++)
{
IDirect3DSurface8 *sourceSurface;
IDirect3DSurface8 *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:
{
IDirect3DVolumeTexture8 *source;
IDirect3DVolumeTexture8 *dest;
sourceTexture->QueryInterface(IID_IDirect3DVolumeTexture8, (void**)&source);
destinationTexture->QueryInterface(IID_IDirect3DVolumeTexture8, (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
{
IDirect3DVolume8 *sourceVolume;
IDirect3DVolume8 *destinationVolume;
source->GetVolumeLevel(level, &sourceVolume);
dest->GetVolumeLevel(level, &destinationVolume);
updateVolume(sourceVolume, destinationVolume);
sourceVolume->Release();
destinationVolume->Release();
}
source->Release();
dest->Release();
}
break;
case D3DRTYPE_CUBETEXTURE:
{
IDirect3DCubeTexture8 *source;
IDirect3DCubeTexture8 *dest;
sourceTexture->QueryInterface(IID_IDirect3DCubeTexture8, (void**)&source);
destinationTexture->QueryInterface(IID_IDirect3DCubeTexture8, (void**)&dest);
ASSERT(source && dest);
for(int face = 0; face < 6; face++)
{
for(unsigned int level = 0; level < source->GetLevelCount() && level < dest->GetLevelCount(); level++)
{
IDirect3DSurface8 *sourceSurface;
IDirect3DSurface8 *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:
ASSERT(false);
}
return D3D_OK;
}
long Direct3DDevice8::ValidateDevice(unsigned long *numPasses)
{
TRACE("");
if(!numPasses)
{
return INVALIDCALL();
}
*numPasses = 1;
return D3D_OK;
}
long Direct3DDevice8::updateSurface(IDirect3DSurface8 *sourceSurface, const RECT *sourceRect, IDirect3DSurface8 *destinationSurface, const POINT *destPoint)
{
TRACE("IDirect3DSurface8 *sourceSurface = 0x%0.8p, const RECT *sourceRect = 0x%0.8p, IDirect3DSurface8 *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 && destPoint)
{
sRect.left = sourceRect->left;
sRect.top = sourceRect->top;
sRect.right = sourceRect->right;
sRect.bottom = sourceRect->bottom;
dRect.left = destPoint->x;
dRect.top = destPoint->y;
dRect.right = destPoint->x + sourceRect->right - sourceRect->left;
dRect.bottom = destPoint->y + sourceRect->bottom - sourceRect->top;
}
else
{
sRect.left = 0;
sRect.top = 0;
sRect.right = sourceDescription.Width;
sRect.bottom = sourceDescription.Height;
dRect.left = 0;
dRect.top = 0;
dRect.right = destinationDescription.Width;
dRect.bottom = destinationDescription.Height;
}
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 ||
sWidth != dWidth ||
sHeight != dHeight)
{
return INVALIDCALL();
}
D3DLOCKED_RECT sourceLock;
D3DLOCKED_RECT destinationLock;
sourceSurface->LockRect(&sourceLock, &sRect, D3DLOCK_READONLY);
destinationSurface->LockRect(&destinationLock, &dRect, 0);
unsigned int width;
unsigned int height;
unsigned int bytes;
switch(sourceDescription.Format)
{
case D3DFMT_DXT1:
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:
width = (dWidth + 3) / 4;
height = (dHeight + 3) / 4;
bytes = width * 16; // 128 bit per 4x4 block
break;
default:
width = dWidth;
height = dHeight;
bytes = width * Direct3DSurface8::bytes(sourceDescription.Format);
}
for(unsigned int y = 0; y < height; y++)
{
memcpy(destinationLock.pBits, sourceLock.pBits, bytes);
(byte*&)sourceLock.pBits += sourceLock.Pitch;
(byte*&)destinationLock.pBits += destinationLock.Pitch;
}
sourceSurface->UnlockRect();
destinationSurface->UnlockRect();
return D3D_OK;
}
long Direct3DDevice8::SetIndices(IDirect3DIndexBuffer8 *iIndexBuffer, unsigned int baseVertexIndex)
{
TRACE("");
Direct3DIndexBuffer8 *indexBuffer = static_cast<Direct3DIndexBuffer8*>(iIndexBuffer);
if(!recordState)
{
if(indexBuffer)
{
indexBuffer->bind();
}
if(this->indexData)
{
this->indexData->unbind();
}
this->indexData = indexBuffer;
this->baseVertexIndex = baseVertexIndex;
}
else
{
stateRecorder.back()->setIndices(indexBuffer, baseVertexIndex);
}
return D3D_OK;
}
int Direct3DDevice8::FVFStride(unsigned long FVF)
{
int stride = 0;
switch(FVF & D3DFVF_POSITION_MASK)
{
case D3DFVF_XYZ: stride += 12; break;
case D3DFVF_XYZRHW: stride += 16; break;
case D3DFVF_XYZB1: stride += 16; break;
case D3DFVF_XYZB2: stride += 20; break;
case D3DFVF_XYZB3: stride += 24; break;
case D3DFVF_XYZB4: stride += 28; break;
case D3DFVF_XYZB5: stride += 32; break;
}
if(FVF & D3DFVF_NORMAL) stride += 12;
if(FVF & D3DFVF_PSIZE) stride += 4;
if(FVF & D3DFVF_DIFFUSE) stride += 4;
if(FVF & D3DFVF_SPECULAR) stride += 4;
switch((FVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT)
{
case 8: stride += 4 + 4 * ((1 + (FVF >> 30)) % 4);
case 7: stride += 4 + 4 * ((1 + (FVF >> 28)) % 4);
case 6: stride += 4 + 4 * ((1 + (FVF >> 26)) % 4);
case 5: stride += 4 + 4 * ((1 + (FVF >> 24)) % 4);
case 4: stride += 4 + 4 * ((1 + (FVF >> 22)) % 4);
case 3: stride += 4 + 4 * ((1 + (FVF >> 20)) % 4);
case 2: stride += 4 + 4 * ((1 + (FVF >> 18)) % 4);
case 1: stride += 4 + 4 * ((1 + (FVF >> 16)) % 4);
case 0: break;
default:
ASSERT(false);
}
return stride;
}
int Direct3DDevice8::typeStride(unsigned char type)
{
static const 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
};
if(type <= 7)
{
return LUT[type];
}
else ASSERT(false);
return 0;
}
bool Direct3DDevice8::bindData(Direct3DIndexBuffer8 *indexBuffer, int base)
{
if(!bindViewport())
{
return false; // Zero-area target region
}
bindTextures();
bindStreams(base);
bindIndexBuffer(indexBuffer);
bindLights();
return true;
}
void Direct3DDevice8::bindStreams(int base)
{
renderer->resetInputStreams((FVF & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW);
int stride;
if(!declaration) // Fixed-function vertex pipeline
{
const void *buffer = 0;
ASSERT(dataStream[0]);
Direct3DVertexBuffer8 *stream = dataStream[0];
sw::Resource *resource = stream->getResource();
buffer = (char*)resource->data();
stride = FVFStride(FVF);
ASSERT(stride == streamStride[0]); // FIXME
ASSERT(buffer && stride);
(char*&)buffer += stride * base;
sw::Stream attribute(resource, buffer, stride);
switch(FVF & D3DFVF_POSITION_MASK)
{
case D3DFVF_XYZ:
renderer->setInputStream(sw::Position, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3));
(char*&)buffer += 12;
break;
case D3DFVF_XYZRHW:
renderer->setInputStream(sw::PositionT, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 4));
(char*&)buffer += 16;
break;
case D3DFVF_XYZB1:
renderer->setInputStream(sw::Position, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3));
(char*&)buffer += 12;
renderer->setInputStream(sw::BlendWeight, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 1)); // FIXME: Stream type depends on indexed blending active?
(char*&)buffer += 4;
break;
case D3DFVF_XYZB2:
renderer->setInputStream(sw::Position, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3));
(char*&)buffer += 12;
renderer->setInputStream(sw::BlendWeight, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 1)); // FIXME: Stream type depends on indexed blending active?
(char*&)buffer += 8;
break;
case D3DFVF_XYZB3:
renderer->setInputStream(sw::Position, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3));
(char*&)buffer += 12;
renderer->setInputStream(sw::BlendWeight, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 2)); // FIXME: Stream type depends on indexed blending active?
(char*&)buffer += 12;
break;
case D3DFVF_XYZB4:
renderer->setInputStream(sw::Position, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3));
(char*&)buffer += 12;
renderer->setInputStream(sw::BlendWeight, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3)); // FIXME: Stream type depends on indexed blending active?
(char*&)buffer += 16;
break;
case D3DFVF_XYZB5:
renderer->setInputStream(sw::Position, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3));
(char*&)buffer += 12;
renderer->setInputStream(sw::BlendWeight, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 4)); // FIXME: Stream type depends on indexed blending active?
(char*&)buffer += 20;
break;
}
if(FVF & D3DFVF_LASTBETA_UBYTE4)
{
renderer->setInputStream(sw::BlendIndices, attribute.define((char*&)buffer - 4, sw::STREAMTYPE_INDICES, 1));
}
if(FVF & D3DFVF_NORMAL)
{
renderer->setInputStream(sw::Normal, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 3));
(char*&)buffer += 12;
}
if(FVF & D3DFVF_PSIZE)
{
renderer->setInputStream(sw::PointSize, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 1));
(char*&)buffer += 4;
}
if(FVF & D3DFVF_DIFFUSE)
{
renderer->setInputStream(sw::Color0, attribute.define(buffer, sw::STREAMTYPE_COLOR, 4));
(char*&)buffer += 4;
}
if(FVF & D3DFVF_SPECULAR)
{
renderer->setInputStream(sw::Color1, attribute.define(buffer, sw::STREAMTYPE_COLOR, 4));
(char*&)buffer += 4;
}
for(unsigned int i = 0; i < 8; i++)
{
if((FVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT >= i + 1)
{
renderer->setInputStream(sw::TexCoord0 + i, attribute.define(buffer, sw::STREAMTYPE_FLOAT, 1 + (1 + (FVF >> (16 + i * 2))) % 4));
(char*&)buffer += 4 + 4 * ((1 + (FVF >> (16 + i * 2))) % 4);
}
}
}
else
{
const unsigned long *element = declaration;
int stream = 0;
sw::Resource *resource;
const void *buffer = 0;
while(*element != 0xFFFFFFFF)
{
switch((*element & 0xE0000000) >> 29)
{
case 0: // NOP
if(*element != 0x00000000)
{
ASSERT(false);
}
break;
case 1: // Stream selector
stream = *element & 0x0000000F;
{
ASSERT(dataStream[stream]); // Expected a stream
Direct3DVertexBuffer8 *streamBuffer = (Direct3DVertexBuffer8*)dataStream[stream];
resource = streamBuffer->getResource();
buffer = (char*)resource->data();
const unsigned long *streamElement = element + 1;
stride = 0;
while((*streamElement & 0xE0000000) >> 29 == 2) // Data definition
{
if(*streamElement & 0x10000000) // Data skip
{
int skip = (*streamElement & 0x000F0000) >> 16;
stride += 4 * skip;
}
else
{
stride += typeStride((unsigned char)((*streamElement & 0x000F0000) >> 16));
}
streamElement++;
}
// ASSERT(stride == streamStride[stream]); // FIXME: Probably just ignore
(char*&)buffer += stride * base;
}
break;
case 2: // Data definition
if(*element & 0x10000000) // Data skip
{
int skip = (*element & 0x000F0000) >> 16;
(char*&)buffer += 4 * skip;
}
else
{
int type = (*element & 0x000F0000) >> 16;
int index = (*element & 0x0000000F) >> 0;
sw::Stream attribute(resource, buffer, stride);
switch(type)
{
case D3DVSDT_FLOAT1: attribute.define(sw::STREAMTYPE_FLOAT, 1); break;
case D3DVSDT_FLOAT2: attribute.define(sw::STREAMTYPE_FLOAT, 2); break;
case D3DVSDT_FLOAT3: attribute.define(sw::STREAMTYPE_FLOAT, 3); break;
case D3DVSDT_FLOAT4: attribute.define(sw::STREAMTYPE_FLOAT, 4); break;
case D3DVSDT_D3DCOLOR: attribute.define(sw::STREAMTYPE_COLOR, 4); break;
case D3DVSDT_UBYTE4: attribute.define(sw::STREAMTYPE_BYTE, 4); break;
case D3DVSDT_SHORT2: attribute.define(sw::STREAMTYPE_SHORT, 2); break;
case D3DVSDT_SHORT4: attribute.define(sw::STREAMTYPE_SHORT, 4); break;
default: attribute.define(sw::STREAMTYPE_FLOAT, 0); ASSERT(false);
}
switch(index)
{
case D3DVSDE_POSITION: renderer->setInputStream(sw::Position, attribute); break;
case D3DVSDE_BLENDWEIGHT: renderer->setInputStream(sw::BlendWeight, attribute); break;
case D3DVSDE_BLENDINDICES: renderer->setInputStream(sw::BlendIndices, attribute); break;
case D3DVSDE_NORMAL: renderer->setInputStream(sw::Normal, attribute); break;
case D3DVSDE_PSIZE: renderer->setInputStream(sw::PointSize, attribute); break;
case D3DVSDE_DIFFUSE: renderer->setInputStream(sw::Color0, attribute); break;
case D3DVSDE_SPECULAR: renderer->setInputStream(sw::Color1, attribute); break;
case D3DVSDE_TEXCOORD0: renderer->setInputStream(sw::TexCoord0, attribute); break;
case D3DVSDE_TEXCOORD1: renderer->setInputStream(sw::TexCoord1, attribute); break;
case D3DVSDE_TEXCOORD2: renderer->setInputStream(sw::TexCoord2, attribute); break;
case D3DVSDE_TEXCOORD3: renderer->setInputStream(sw::TexCoord3, attribute); break;
case D3DVSDE_TEXCOORD4: renderer->setInputStream(sw::TexCoord4, attribute); break;
case D3DVSDE_TEXCOORD5: renderer->setInputStream(sw::TexCoord5, attribute); break;
case D3DVSDE_TEXCOORD6: renderer->setInputStream(sw::TexCoord6, attribute); break;
case D3DVSDE_TEXCOORD7: renderer->setInputStream(sw::TexCoord7, attribute); break;
// case D3DVSDE_POSITION2: renderer->setInputStream(sw::Position1, attribute); break;
// case D3DVSDE_NORMAL2: renderer->setInputStream(sw::Normal1, attribute); break;
default:
ASSERT(false);
}
(char*&)buffer += typeStride(type);
}
break;
case 3: // Tesselator data
UNIMPLEMENTED();
break;
case 4: // Constant data
{
int count = (*element & 0x1E000000) >> 25;
int index = (*element & 0x0000007F) >> 0;
SetVertexShaderConstant(index, element + 1, count);
element += 4 * count;
}
break;
case 5: // Extension
UNIMPLEMENTED();
break;
default:
ASSERT(false);
}
element++;
}
}
}
void Direct3DDevice8::bindIndexBuffer(Direct3DIndexBuffer8 *indexBuffer)
{
sw::Resource *resource = 0;
if(indexBuffer)
{
resource = indexBuffer->getResource();
}
renderer->setIndexBuffer(resource);
}
void Direct3DDevice8::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)
{
// goto next; // FIXME
// FIXME: Unsupported, make it a positional light far away without falloff
renderer->setLightPosition(active, -1000 * direction);
renderer->setLightRange(active, l.Range);
renderer->setLightAttenuation(active, 1, 0, 0);
}
else if(l.Type == D3DLIGHT_SPOT)
{
// goto next; // FIXME
// 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++;
// next: // FIXME
i++;
}
// Remaining lights are disabled
while(active < 8)
{
renderer->setLightEnable(active, false);
active++;
}
lightsDirty= false;
}
bool Direct3DDevice8::bindViewport()
{
if(viewport.Width == 0 || viewport.Height == 0)
{
return false;
}
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);
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);
return true;
}
void Direct3DDevice8::bindTextures()
{
for(int stage = 0; stage < 8; stage++)
{
Direct3DBaseTexture8 *baseTexture = texture[stage];
sw::Resource *resource = 0;
bool textureUsed = false;
if(pixelShader[pixelShaderHandle])
{
textureUsed = pixelShader[pixelShaderHandle]->getPixelShader()->usesSampler(stage);
}
else
{
textureUsed = true; // FIXME: Check fixed-function use?
}
if(baseTexture && textureUsed)
{
resource = baseTexture->getResource();
}
renderer->setTextureResource(stage, resource);
if(baseTexture && textureUsed)
{
int levelCount = baseTexture->getInternalLevelCount();
int textureLOD = baseTexture->GetLOD();
int stageLOD = textureStageState[stage][D3DTSS_MAXMIPLEVEL];
int LOD = textureLOD > stageLOD ? textureLOD : stageLOD;
if(textureStageState[stage][D3DTSS_MIPFILTER] == D3DTEXF_NONE)
{
LOD = 0;
}
switch(baseTexture->GetType())
{
case D3DRTYPE_TEXTURE:
{
Direct3DTexture8 *texture = dynamic_cast<Direct3DTexture8*>(baseTexture);
Direct3DSurface8 *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(stage, 0, mipmapLevel, surface, sw::TEXTURE_2D);
}
}
break;
case D3DRTYPE_CUBETEXTURE:
for(int face = 0; face < 6; face++)
{
Direct3DCubeTexture8 *cubeTexture = dynamic_cast<Direct3DCubeTexture8*>(baseTexture);
Direct3DSurface8 *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(stage, face, mipmapLevel, surface, sw::TEXTURE_CUBE);
}
}
break;
case D3DRTYPE_VOLUMETEXTURE:
{
Direct3DVolumeTexture8 *volumeTexture = dynamic_cast<Direct3DVolumeTexture8*>(baseTexture);
Direct3DVolume8 *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(stage, 0, mipmapLevel, volume, sw::TEXTURE_3D);
}
}
break;
default:
UNIMPLEMENTED();
}
}
else
{
renderer->setTextureLevel(stage, 0, 0, 0, sw::TEXTURE_NULL);
}
}
}
void Direct3DDevice8::bindCursor()
{
if(showCursor)
{
sw::FrameBuffer::setCursorImage(cursor);
HCURSOR oldCursor = SetCursor(nullCursor);
if(oldCursor != nullCursor)
{
win32Cursor = oldCursor;
}
}
else
{
sw::FrameBuffer::setCursorImage(0);
if(GetCursor() == nullCursor)
{
SetCursor(win32Cursor);
}
}
}
long Direct3DDevice8::updateVolume(IDirect3DVolume8 *sourceVolume, IDirect3DVolume8 *destinationVolume)
{
TRACE("IDirect3DVolume8 *sourceVolume = 0x%0.8p, IDirect3DVolume8 *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)
{
return INVALIDCALL();
}
D3DLOCKED_BOX sourceLock;
D3DLOCKED_BOX destinationLock;
sourceVolume->LockBox(&sourceLock, 0, 0);
destinationVolume->LockBox(&destinationLock, 0, 0);
if(sourceLock.RowPitch != destinationLock.RowPitch ||
sourceLock.SlicePitch != destinationLock.SlicePitch)
{
UNIMPLEMENTED();
}
memcpy(destinationLock.pBits, sourceLock.pBits, sourceLock.SlicePitch * sourceDescription.Depth);
sourceVolume->UnlockBox();
destinationVolume->UnlockBox();
return D3D_OK;
}
void Direct3DDevice8::configureFPU()
{
unsigned short cw;
__asm
{
fstcw cw
and cw, 0xFCFC // Single-precision
or cw, 0x003F // Mask all exceptions
and cw, 0xF3FF // Round to nearest
fldcw cw
}
}
}