src/D3D9/Direct3DDevice9Ex.cpp

// 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 "Direct3DDevice9Ex.hpp"

#include "Direct3D9Ex.hpp"
#include "Direct3DSurface9.hpp"
#include "Direct3DIndexBuffer9.hpp"
#include "Direct3DVertexBuffer9.hpp"
#include "Direct3DTexture9.hpp"
#include "Direct3DVolumeTexture9.hpp"
#include "Direct3DCubeTexture9.hpp"
#include "Direct3DVertexDeclaration9.hpp"
#include "Direct3DSwapChain9.hpp"
#include "Direct3DPixelShader9.hpp"
#include "Direct3DVertexShader9.hpp"
#include "Direct3DStateBlock9.hpp"
#include "Direct3DQuery9.hpp"
#include "Direct3DVolume9.hpp"

#include "Debug.hpp"
#include "Renderer.hpp"
#include "FrameBuffer.hpp"
#include "Clipper.hpp"
#include "Configurator.hpp"
#include "Timer.hpp"

#include <assert.h>

namespace D3D9
{
	inline unsigned long FtoDW(float f)
	{
		return (unsigned long&)f;
	}

	inline float DWtoF(unsigned long dw)
	{
		return (float&)dw;
	}

	Direct3DDevice9Ex::Direct3DDevice9Ex(const HINSTANCE instance, Direct3D9Ex *d3d9ex, unsigned int adapter, D3DDEVTYPE deviceType, HWND focusWindow, unsigned long behaviourFlags, D3DPRESENT_PARAMETERS *presentParameters) : Direct3DDevice9(instance, d3d9ex, adapter, deviceType, focusWindow, behaviourFlags, presentParameters), d3d9ex(d3d9ex)
	{
	}

	Direct3DDevice9Ex::~Direct3DDevice9Ex()
	{
	}

	long Direct3DDevice9Ex::QueryInterface(const IID &iid, void **object)
	{
		CriticalSection cs(this);

		TRACE("const IID &iid = 0x%0.8p, void **object = 0x%0.8p", iid, object);

		if(iid == IID_IDirect3DDevice9Ex ||
		   iid == IID_IDirect3DDevice9 ||
		   iid == IID_IUnknown)
		{
			AddRef();
			*object = this;

			return S_OK;
		}

		*object = 0;

		return NOINTERFACE(iid);
	}

	unsigned long Direct3DDevice9Ex::AddRef()
	{
		TRACE("void");

		return Direct3DDevice9::AddRef();
	}

	unsigned long Direct3DDevice9Ex::Release()
	{
		TRACE("void");

		return Direct3DDevice9::Release();
	}

	long Direct3DDevice9Ex::BeginScene()
	{
		TRACE("void");

		return Direct3DDevice9::BeginScene();
	}

	long Direct3DDevice9Ex::BeginStateBlock()
	{
		TRACE("void");

		return Direct3DDevice9::BeginStateBlock();
	}

	long Direct3DDevice9Ex::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);

		return Direct3DDevice9::Clear(count, rects, flags, color, z, stencil);
	}

	long Direct3DDevice9Ex::ColorFill(IDirect3DSurface9 *surface, const RECT *rect, D3DCOLOR color)
	{
		TRACE("IDirect3DSurface9 *surface = 0x%0.8p, const RECT *rect = 0x%0.8p, D3DCOLOR color = 0x%0.8X", surface, rect, color);

		return Direct3DDevice9::ColorFill(surface, rect, color);
	}

	long Direct3DDevice9Ex::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS *presentParameters, IDirect3DSwapChain9 **swapChain)
	{
		TRACE("D3DPRESENT_PARAMETERS *presentParameters = 0x%0.8p, IDirect3DSwapChain9 **swapChain = 0x%0.8p", presentParameters, swapChain);

		return Direct3DDevice9::CreateAdditionalSwapChain(presentParameters, swapChain);
	}

	long Direct3DDevice9Ex::CreateCubeTexture(unsigned int edgeLength, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DCubeTexture9 **cubeTexture, void **sharedHandle)
	{
		TRACE("unsigned int edgeLength = %d, unsigned int levels = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DCubeTexture9 **cubeTexture = 0x%0.8p, void **sharedHandle = 0x%0.8p", edgeLength, levels, usage, format, pool, cubeTexture, sharedHandle);

		return Direct3DDevice9::CreateCubeTexture(edgeLength, levels, usage, format, pool, cubeTexture, sharedHandle);
	}

	long Direct3DDevice9Ex::CreateDepthStencilSurface(unsigned int width, unsigned int height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multiSample, unsigned long multiSampleQuality, int discard, IDirect3DSurface9 **surface, void **sharedHandle)
	{
		TRACE("unsigned int width = %d, unsigned int height = %d, D3DFORMAT format = %d, D3DMULTISAMPLE_TYPE multiSample = %d, unsigned long multiSampleQuality = %d, int discard = %d, IDirect3DSurface9 **surface = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, format, multiSample, multiSampleQuality, discard, surface, sharedHandle);

		return Direct3DDevice9::CreateDepthStencilSurface(width, height, format, multiSample, multiSampleQuality, discard, surface, sharedHandle);
	}

	long Direct3DDevice9Ex::CreateIndexBuffer(unsigned int length, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer9 **indexBuffer, void **sharedHandle)
	{
		TRACE("unsigned int length = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DIndexBuffer9 **indexBuffer = 0x%0.8p, void **sharedHandle = 0x%0.8p", length, usage, format, pool, indexBuffer, sharedHandle);

		return Direct3DDevice9::CreateIndexBuffer(length, usage, format, pool, indexBuffer, sharedHandle);
	}

	long Direct3DDevice9Ex::CreateOffscreenPlainSurface(unsigned int width, unsigned int height, D3DFORMAT format, D3DPOOL pool, IDirect3DSurface9 **surface, void **sharedHandle)
	{
		TRACE("unsigned int width = %d, unsigned int height = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DSurface9 **surface = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, format, pool, surface, sharedHandle);

		return Direct3DDevice9::CreateOffscreenPlainSurface(width, height, format, pool, surface, sharedHandle);
	}

	long Direct3DDevice9Ex::CreatePixelShader(const unsigned long *function, IDirect3DPixelShader9 **shader)
	{
		TRACE("const unsigned long *function = 0x%0.8p, IDirect3DPixelShader9 **shader = 0x%0.8p", function, shader);

		return Direct3DDevice9::CreatePixelShader(function, shader);
	}

	long Direct3DDevice9Ex::CreateQuery(D3DQUERYTYPE type, IDirect3DQuery9 **query)
	{
		TRACE("D3DQUERYTYPE type = %d, IDirect3DQuery9 **query = 0x%0.8p", type, query);

		return Direct3DDevice9::CreateQuery(type, query);
	}

	long Direct3DDevice9Ex::CreateRenderTarget(unsigned int width, unsigned int height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multiSample, unsigned long multiSampleQuality, int lockable, IDirect3DSurface9 **surface, void **sharedHandle)
	{
		TRACE("unsigned int width = %d, unsigned int height = %d, D3DFORMAT format = %d, D3DMULTISAMPLE_TYPE multiSample = %d, unsigned long multiSampleQuality = %d, int lockable = %d, IDirect3DSurface9 **surface = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, format, multiSample, multiSampleQuality, lockable, surface, sharedHandle);

		return Direct3DDevice9::CreateRenderTarget(width, height, format, multiSample, multiSampleQuality, lockable, surface, sharedHandle);
	}

	long Direct3DDevice9Ex::CreateStateBlock(D3DSTATEBLOCKTYPE type, IDirect3DStateBlock9 **stateBlock)
	{
		TRACE("D3DSTATEBLOCKTYPE type = %d, IDirect3DStateBlock9 **stateBlock = 0x%0.8p", type, stateBlock);

		return Direct3DDevice9::CreateStateBlock(type, stateBlock);
	}

	long Direct3DDevice9Ex::CreateTexture(unsigned int width, unsigned int height, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DTexture9 **texture, void **sharedHandle)
	{
		TRACE("unsigned int width = %d, unsigned int height = %d, unsigned int levels = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DTexture9 **texture = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, levels, usage, format, pool, texture, sharedHandle);

		return Direct3DDevice9::CreateTexture(width, height, levels, usage, format, pool, texture, sharedHandle);
	}

	long Direct3DDevice9Ex::CreateVertexBuffer(unsigned int length, unsigned long usage, unsigned long FVF, D3DPOOL pool, IDirect3DVertexBuffer9 **vertexBuffer, void **sharedHandle)
	{
		TRACE("unsigned int length = %d, unsigned long usage = %d, unsigned long FVF = 0x%0.8X, D3DPOOL pool = %d, IDirect3DVertexBuffer9 **vertexBuffer = 0x%0.8p, void **sharedHandle = 0x%0.8p", length, usage, FVF, pool, vertexBuffer, sharedHandle);

		return Direct3DDevice9::CreateVertexBuffer(length, usage, FVF, pool, vertexBuffer, sharedHandle);
	}

	long Direct3DDevice9Ex::CreateVertexDeclaration(const D3DVERTEXELEMENT9 *vertexElements, IDirect3DVertexDeclaration9 **declaration)
	{
		TRACE("const D3DVERTEXELEMENT9 *vertexElements = 0x%0.8p, IDirect3DVertexDeclaration9 **declaration = 0x%0.8p", vertexElements, declaration);

		return Direct3DDevice9::CreateVertexDeclaration(vertexElements, declaration);
	}

	long Direct3DDevice9Ex::CreateVertexShader(const unsigned long *function, IDirect3DVertexShader9 **shader)
	{
		TRACE("const unsigned long *function = 0x%0.8p, IDirect3DVertexShader9 **shader = 0x%0.8p", function, shader);

		return Direct3DDevice9::CreateVertexShader(function, shader);
	}

	long Direct3DDevice9Ex::CreateVolumeTexture(unsigned int width, unsigned int height, unsigned int depth, unsigned int levels, unsigned long usage, D3DFORMAT format, D3DPOOL pool, IDirect3DVolumeTexture9 **volumeTexture, void **sharedHandle)
	{
		TRACE("unsigned int width = %d, unsigned int height = %d, unsigned int depth = %d, unsigned int levels = %d, unsigned long usage = %d, D3DFORMAT format = %d, D3DPOOL pool = %d, IDirect3DVolumeTexture9 **volumeTexture = 0x%0.8p, void **sharedHandle = 0x%0.8p", width, height, depth, levels, usage, format, pool, volumeTexture, sharedHandle);

		return Direct3DDevice9::CreateVolumeTexture(width, height, depth, levels, usage, format, pool, volumeTexture, sharedHandle);
	}

	long Direct3DDevice9Ex::DeletePatch(unsigned int handle)
	{
		TRACE("unsigned int handle = %d", handle);

		return Direct3DDevice9::DeletePatch(handle);
	}

	long Direct3DDevice9Ex::DrawIndexedPrimitive(D3DPRIMITIVETYPE type, int baseVertexIndex, unsigned int minIndex, unsigned int numVertices, unsigned int startIndex, unsigned int primitiveCount)
	{
		TRACE("D3DPRIMITIVETYPE type = %d, int baseVertexIndex = %d, unsigned int minIndex = %d, unsigned int numVertices = %d, unsigned int startIndex = %d, unsigned int primitiveCount = %d", type, baseVertexIndex, minIndex, numVertices, startIndex, primitiveCount);

		return Direct3DDevice9::DrawIndexedPrimitive(type, baseVertexIndex, minIndex, numVertices, startIndex, primitiveCount);
	}

	long Direct3DDevice9Ex::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE type, unsigned int minIndex, unsigned int numVertices, unsigned int primitiveCount, const void *indexData, D3DFORMAT indexDataFormat, const void *vertexStreamZeroData, unsigned int vertexStreamZeroStride)
	{
		TRACE("D3DPRIMITIVETYPE type = %d, unsigned int minIndex = %d, unsigned int numVertices = %d, unsigned int primitiveCount = %d, const void *indexData = 0x%0.8p, D3DFORMAT indexDataFormat = %d, const void *vertexStreamZeroData = 0x%0.8p, unsigned int vertexStreamZeroStride = %d", type, minIndex, numVertices, primitiveCount, indexData, indexDataFormat, vertexStreamZeroData, vertexStreamZeroStride);

		return Direct3DDevice9::DrawIndexedPrimitiveUP(type, minIndex, numVertices, primitiveCount, indexData, indexDataFormat, vertexStreamZeroData, vertexStreamZeroStride);
	}

	long Direct3DDevice9Ex::DrawPrimitive(D3DPRIMITIVETYPE primitiveType, unsigned int startVertex, unsigned int primitiveCount)
	{
		TRACE("D3DPRIMITIVETYPE primitiveType = %d, unsigned int startVertex = %d, unsigned int primitiveCount = %d", primitiveType, startVertex, primitiveCount);

		return Direct3DDevice9::DrawPrimitive(primitiveType, startVertex, primitiveCount);
	}

	long Direct3DDevice9Ex::DrawPrimitiveUP(D3DPRIMITIVETYPE primitiveType, unsigned int primitiveCount, const void *vertexStreamZeroData, unsigned int vertexStreamZeroStride)
	{
		TRACE("D3DPRIMITIVETYPE primitiveType = %d, unsigned int primitiveCount = %d, const void *vertexStreamZeroData = 0x%0.8p, unsigned int vertexStreamZeroStride = %d", primitiveType, primitiveCount, vertexStreamZeroData, vertexStreamZeroStride);

		return Direct3DDevice9::DrawPrimitiveUP(primitiveType, primitiveCount, vertexStreamZeroData, vertexStreamZeroStride);
	}

	long Direct3DDevice9Ex::DrawRectPatch(unsigned int handle, const float *numSegs, const D3DRECTPATCH_INFO *rectPatchInfo)
	{
		TRACE("unsigned int handle = %d, const float *numSegs = 0x%0.8p, const D3DRECTPATCH_INFO *rectPatchInfo = 0x%0.8p", handle, numSegs, rectPatchInfo);

		return Direct3DDevice9::DrawRectPatch(handle, numSegs, rectPatchInfo);
	}

	long Direct3DDevice9Ex::DrawTriPatch(unsigned int handle, const float *numSegs, const D3DTRIPATCH_INFO *triPatchInfo)
	{
		TRACE("unsigned int handle = %d, const float *numSegs = 0x%0.8p, const D3DTRIPATCH_INFO *triPatchInfo = 0x%0.8p", handle, numSegs, triPatchInfo);

		return Direct3DDevice9::DrawTriPatch(handle, numSegs, triPatchInfo);
	}

	long Direct3DDevice9Ex::EndScene()
	{
		TRACE("void");

		return Direct3DDevice9::EndScene();
	}

	long Direct3DDevice9Ex::EndStateBlock(IDirect3DStateBlock9 **stateBlock)
	{
		TRACE("IDirect3DStateBlock9 **stateBlock = 0x%0.8p", stateBlock);

		return Direct3DDevice9::EndStateBlock(stateBlock);
	}

	long Direct3DDevice9Ex::EvictManagedResources()
	{
		TRACE("void");

		return Direct3DDevice9::EvictManagedResources();
	}

	unsigned int Direct3DDevice9Ex::GetAvailableTextureMem()
	{
		TRACE("void");

		return Direct3DDevice9::GetAvailableTextureMem();
	}

	long Direct3DDevice9Ex::GetBackBuffer(unsigned int swapChainIndex, unsigned int backBufferIndex, D3DBACKBUFFER_TYPE type, IDirect3DSurface9 **backBuffer)
	{
		TRACE("unsigned int swapChainIndex = %d, unsigned int backBufferIndex = %d, D3DBACKBUFFER_TYPE type = %d, IDirect3DSurface9 **backBuffer = 0x%0.8p", swapChainIndex, backBufferIndex, type, backBuffer);

		return Direct3DDevice9::GetBackBuffer(swapChainIndex, backBufferIndex, type, backBuffer);
	}

	long Direct3DDevice9Ex::GetClipPlane(unsigned long index, float *plane)
	{
		TRACE("unsigned long index = %d, float *plane = 0x%0.8p", index, plane);

		return Direct3DDevice9::GetClipPlane(index, plane);
	}

	long Direct3DDevice9Ex::GetClipStatus(D3DCLIPSTATUS9 *clipStatus)
	{
		TRACE("D3DCLIPSTATUS9 *clipStatus = 0x%0.8p", clipStatus);

		return Direct3DDevice9::GetClipStatus(clipStatus);
	}

	long Direct3DDevice9Ex::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *parameters)
	{
		TRACE("D3DDEVICE_CREATION_PARAMETERS *parameters = 0x%0.8p", parameters);

		return Direct3DDevice9::GetCreationParameters(parameters);
	}

	long Direct3DDevice9Ex::GetCurrentTexturePalette(unsigned int *paletteNumber)
	{
		TRACE("unsigned int *paletteNumber = 0x%0.8p", paletteNumber);

		return Direct3DDevice9::GetCurrentTexturePalette(paletteNumber);
	}

	long Direct3DDevice9Ex::GetDepthStencilSurface(IDirect3DSurface9 **depthStencilSurface)
	{
		TRACE("IDirect3DSurface9 **depthStencilSurface = 0x%0.8p", depthStencilSurface);

		return Direct3DDevice9::GetDepthStencilSurface(depthStencilSurface);
	}

	long Direct3DDevice9Ex::GetDeviceCaps(D3DCAPS9 *caps)
	{
		TRACE("D3DCAPS9 *caps = 0x%0.8p", caps);

		return d3d9ex->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, caps);
	}

	long Direct3DDevice9Ex::GetDirect3D(IDirect3D9 **d3d9)
	{
		TRACE("IDirect3D9 **d3d9 = 0x%0.8p", d3d9);

		return Direct3DDevice9::GetDirect3D(d3d9);
	}

	long Direct3DDevice9Ex::GetDisplayMode(unsigned int index, D3DDISPLAYMODE *mode)
	{
		TRACE("unsigned int index = %d, D3DDISPLAYMODE *mode = 0x%0.8p", index, mode);

		return Direct3DDevice9::GetDisplayMode(index, mode);
	}

	long Direct3DDevice9Ex::GetFrontBufferData(unsigned int index, IDirect3DSurface9 *destSurface)
	{
		TRACE("unsigned int index = %d, IDirect3DSurface9 *destSurface = %p", index, destSurface);

		return Direct3DDevice9::GetFrontBufferData(index, destSurface);
	}

	long Direct3DDevice9Ex::GetFVF(unsigned long *FVF)
	{
		TRACE("unsigned long *FVF = 0x%0.8p", FVF);

		return Direct3DDevice9::GetFVF(FVF);
	}

	void Direct3DDevice9Ex::GetGammaRamp(unsigned int index, D3DGAMMARAMP *ramp)
	{
		TRACE("unsigned int index = %d, D3DGAMMARAMP *ramp = 0x%0.8p", index, ramp);

		return Direct3DDevice9::GetGammaRamp(index, ramp);
	}

	long Direct3DDevice9Ex::GetIndices(IDirect3DIndexBuffer9 **indexData)
	{
		TRACE("IDirect3DIndexBuffer9 **indexData = 0x%0.8p", indexData);

		return Direct3DDevice9::GetIndices(indexData);
	}

	long Direct3DDevice9Ex::GetLight(unsigned long index, D3DLIGHT9 *light)
	{
		TRACE("unsigned long index = %d, D3DLIGHT9 *light = 0x%0.8p", index, light);

		return Direct3DDevice9::GetLight(index, light);
	}

	long Direct3DDevice9Ex::GetLightEnable(unsigned long index, int *enable)
	{
		TRACE("unsigned long index = %d, int *enable = 0x%0.8p", index, enable);

		return Direct3DDevice9::GetLightEnable(index, enable);
	}

	long Direct3DDevice9Ex::GetMaterial(D3DMATERIAL9 *material)
	{
		TRACE("D3DMATERIAL9 *material = 0x%0.8p", material);

		return Direct3DDevice9::GetMaterial(material);
	}

	float Direct3DDevice9Ex::GetNPatchMode()
	{
		TRACE("void");

		return Direct3DDevice9::GetNPatchMode();
	}

	unsigned int Direct3DDevice9Ex::GetNumberOfSwapChains()
	{
		TRACE("void");

		return Direct3DDevice9::GetNumberOfSwapChains();
	}

	long Direct3DDevice9Ex::GetPaletteEntries(unsigned int paletteNumber, PALETTEENTRY *entries)
	{
		TRACE("unsigned int paletteNumber = %d, PALETTEENTRY *entries = 0x%0.8p", paletteNumber, entries);

		return Direct3DDevice9::GetPaletteEntries(paletteNumber, entries);
	}

	long Direct3DDevice9Ex::GetPixelShader(IDirect3DPixelShader9 **shader)
	{
		TRACE("IDirect3DPixelShader9 **shader = 0x%0.8p", shader);

		return Direct3DDevice9::GetPixelShader(shader);
	}

	long Direct3DDevice9Ex::GetPixelShaderConstantB(unsigned int startRegister, int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::GetPixelShaderConstantB(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::GetPixelShaderConstantF(unsigned int startRegister, float *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::GetPixelShaderConstantF(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::GetPixelShaderConstantI(unsigned int startRegister, int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::GetPixelShaderConstantI(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::GetRasterStatus(unsigned int swapChain, D3DRASTER_STATUS *rasterStatus)
	{
		TRACE("unsigned int swapChain = %d, D3DRASTER_STATUS *rasterStatus = 0x%0.8p", swapChain, rasterStatus);

		return Direct3DDevice9::GetRasterStatus(swapChain, rasterStatus);
	}

	long Direct3DDevice9Ex::GetRenderState(D3DRENDERSTATETYPE state, unsigned long *value)
	{
		TRACE("D3DRENDERSTATETYPE state = %d, unsigned long *value = 0x%0.8p", state, value);

		return Direct3DDevice9::GetRenderState(state, value);
	}

	long Direct3DDevice9Ex::GetRenderTarget(unsigned long index, IDirect3DSurface9 **renderTarget)
	{
		TRACE("unsigned long index = %d, IDirect3DSurface9 **renderTarget = 0x%0.8p", index, renderTarget);

		return Direct3DDevice9::GetRenderTarget(index, renderTarget);
	}

	long Direct3DDevice9Ex::GetRenderTargetData(IDirect3DSurface9 *renderTarget, IDirect3DSurface9 *destSurface)
	{
		TRACE("IDirect3DSurface9 *renderTarget = 0x%0.8p, IDirect3DSurface9 *destSurface = 0x%0.8p", renderTarget, destSurface);

		return Direct3DDevice9::GetRenderTargetData(renderTarget, destSurface);
	}

	long Direct3DDevice9Ex::GetSamplerState(unsigned long sampler, D3DSAMPLERSTATETYPE state, unsigned long *value)
	{
		TRACE("unsigned long sampler = %d, D3DSAMPLERSTATETYPE type = %d, unsigned long *value = 0x%0.8p", sampler, state, value);

		return Direct3DDevice9::GetSamplerState(sampler, state, value);
	}

	long Direct3DDevice9Ex::GetScissorRect(RECT *rect)
	{
		TRACE("RECT *rect = 0x%0.8p", rect);

		return Direct3DDevice9::GetScissorRect(rect);
	}

	int Direct3DDevice9Ex::GetSoftwareVertexProcessing()
	{
		TRACE("void");

		return Direct3DDevice9::GetSoftwareVertexProcessing();
	}

	long Direct3DDevice9Ex::GetStreamSource(unsigned int streamNumber, IDirect3DVertexBuffer9 **streamData, unsigned int *offset, unsigned int *stride)
	{
		TRACE("unsigned int streamNumber = %d, IDirect3DVertexBuffer9 **streamData = 0x%0.8p, unsigned int *offset = 0x%0.8p, unsigned int *stride = 0x%0.8p", streamNumber, streamData, offset, stride);

		return Direct3DDevice9::GetStreamSource(streamNumber, streamData, offset, stride);
	}

	long Direct3DDevice9Ex::GetStreamSourceFreq(unsigned int streamNumber, unsigned int *divider)
	{
		TRACE("unsigned int streamNumber = %d, unsigned int *divider = 0x%0.8p", streamNumber, divider);

		return Direct3DDevice9::GetStreamSourceFreq(streamNumber, divider);
	}

	long Direct3DDevice9Ex::GetSwapChain(unsigned int index, IDirect3DSwapChain9 **swapChain)
	{
		TRACE("unsigned int index = %d, IDirect3DSwapChain9 **swapChain = 0x%0.8p", index, swapChain);

		return Direct3DDevice9::GetSwapChain(index, swapChain);
	}

	long Direct3DDevice9Ex::GetTexture(unsigned long sampler, IDirect3DBaseTexture9 **texture)
	{
		TRACE("unsigned long sampler = %d, IDirect3DBaseTexture9 **texture = 0x%0.8p", sampler, texture);

		return Direct3DDevice9::GetTexture(sampler, texture);
	}

	long Direct3DDevice9Ex::GetTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long *value)
	{
		TRACE("unsigned long stage = %d, D3DTEXTURESTAGESTATETYPE type = %d, unsigned long *value = 0x%0.8p", stage, type, value);

		return Direct3DDevice9::GetTextureStageState(stage, type, value);
	}

	long Direct3DDevice9Ex::GetTransform(D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
	{
		TRACE("D3DTRANSFORMSTATETYPE state = %d, D3DMATRIX *matrix = 0x%0.8p", state, matrix);

		return Direct3DDevice9::GetTransform(state, matrix);
	}

	long Direct3DDevice9Ex::GetVertexDeclaration(IDirect3DVertexDeclaration9 **declaration)
	{
		TRACE("IDirect3DVertexDeclaration9 **declaration = 0x%0.8p", declaration);

		return Direct3DDevice9::GetVertexDeclaration(declaration);
	}

	long Direct3DDevice9Ex::GetVertexShader(IDirect3DVertexShader9 **shader)
	{
		TRACE("IDirect3DVertexShader9 **shader = 0x%0.8p", shader);

		return Direct3DDevice9::GetVertexShader(shader);
	}

	long Direct3DDevice9Ex::GetVertexShaderConstantB(unsigned int startRegister, int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::GetVertexShaderConstantB(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::GetVertexShaderConstantF(unsigned int startRegister, float *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::GetVertexShaderConstantF(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::GetVertexShaderConstantI(unsigned int startRegister, int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::GetVertexShaderConstantI(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::GetViewport(D3DVIEWPORT9 *viewport)
	{
		TRACE("D3DVIEWPORT9 *viewport = 0x%0.8p", viewport);

		return Direct3DDevice9::GetViewport(viewport);
	}

	long Direct3DDevice9Ex::LightEnable(unsigned long index, int enable)
	{
		TRACE("unsigned long index = %d, int enable = %d", index, enable);

		return Direct3DDevice9::LightEnable(index, enable);
	}

	long Direct3DDevice9Ex::MultiplyTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
	{
		TRACE("D3DTRANSFORMSTATETYPE state = %d, const D3DMATRIX *matrix = 0x%0.8p", state, matrix);

		return Direct3DDevice9::MultiplyTransform(state, matrix);
	}

	long Direct3DDevice9Ex::Present(const RECT *sourceRect, const RECT *destRect, HWND destWindowOverride, const RGNDATA *dirtyRegion)
	{
		TRACE("const RECT *sourceRect = 0x%0.8p, const RECT *destRect = 0x%0.8p, HWND destWindowOverride = %d, const RGNDATA *dirtyRegion = 0x%0.8p", sourceRect, destRect, destWindowOverride, dirtyRegion);

		return Direct3DDevice9::Present(sourceRect, destRect, destWindowOverride, dirtyRegion);
	}

	long Direct3DDevice9Ex::ProcessVertices(unsigned int srcStartIndex, unsigned int destIndex, unsigned int vertexCount, IDirect3DVertexBuffer9 *destBuffer, IDirect3DVertexDeclaration9 *vertexDeclaration, unsigned long flags)
	{
		TRACE("unsigned int srcStartIndex = %d, unsigned int destIndex = %d, unsigned int vertexCount = %d, IDirect3DVertexBuffer9 *destBuffer = 0x%0.8p, IDirect3DVertexDeclaration9 *vertexDeclaration = 0x%0.8p, unsigned long flags = %d", srcStartIndex, destIndex, vertexCount, destBuffer, vertexDeclaration, flags);

		return Direct3DDevice9::ProcessVertices(srcStartIndex, destIndex, vertexCount, destBuffer, vertexDeclaration, flags);
	}

	long Direct3DDevice9Ex::Reset(D3DPRESENT_PARAMETERS *presentParameters)
	{
		TRACE("D3DPRESENT_PARAMETERS *presentParameters = 0x%0.8p", presentParameters);

		return Direct3DDevice9::Reset(presentParameters);
	}

	long Direct3DDevice9Ex::SetClipPlane(unsigned long index, const float *plane)
	{
		TRACE("unsigned long index = %d, const float *plane = 0x%0.8p", index, plane);

		return Direct3DDevice9::SetClipPlane(index, plane);
	}

	long Direct3DDevice9Ex::SetClipStatus(const D3DCLIPSTATUS9 *clipStatus)
	{
		TRACE("const D3DCLIPSTATUS9 *clipStatus = 0x%0.8p", clipStatus);

		return Direct3DDevice9::SetClipStatus(clipStatus);
	}

	long Direct3DDevice9Ex::SetCurrentTexturePalette(unsigned int paletteNumber)
	{
		TRACE("unsigned int paletteNumber = %d", paletteNumber);

		return Direct3DDevice9::SetCurrentTexturePalette(paletteNumber);
	}

	void Direct3DDevice9Ex::SetCursorPosition(int x, int y, unsigned long flags)
	{
		TRACE("int x = %d, int y = %d, unsigned long flags = 0x%0.8X", x, y, flags);

		return Direct3DDevice9::SetCursorPosition(x, y, flags);
	}

	long Direct3DDevice9Ex::SetCursorProperties(unsigned int x, unsigned int y, IDirect3DSurface9 *cursorBitmap)
	{
		TRACE("unsigned int x = %d, unsigned int y = %d, IDirect3DSurface9 *cursorBitmap = 0x%0.8p", x, y, cursorBitmap);

		return Direct3DDevice9::SetCursorProperties(x, y, cursorBitmap);
	}

	long Direct3DDevice9Ex::SetDepthStencilSurface(IDirect3DSurface9 *iDepthStencil)
	{
		TRACE("IDirect3DSurface9 *newDepthStencil = 0x%0.8p", iDepthStencil);

		return Direct3DDevice9::SetDepthStencilSurface(iDepthStencil);
	}

	long Direct3DDevice9Ex::SetDialogBoxMode(int enableDialogs)
	{
		TRACE("int enableDialogs = %d", enableDialogs);

		return Direct3DDevice9::SetDialogBoxMode(enableDialogs);
	}

	long Direct3DDevice9Ex::SetFVF(unsigned long FVF)
	{
		TRACE("unsigned long FVF = 0x%0.8X", FVF);

		return Direct3DDevice9::SetFVF(FVF);
	}

	void Direct3DDevice9Ex::SetGammaRamp(unsigned int index, unsigned long flags, const D3DGAMMARAMP *ramp)
	{
		TRACE("unsigned int index = %d, unsigned long flags = 0x%0.8X, const D3DGAMMARAMP *ramp = 0x%0.8p", index, flags, ramp);

		return Direct3DDevice9::SetGammaRamp(index, flags, ramp);
	}

	long Direct3DDevice9Ex::SetIndices(IDirect3DIndexBuffer9* iIndexBuffer)
	{
		TRACE("IDirect3DIndexBuffer9* indexData = 0x%0.8p", iIndexBuffer);

		return Direct3DDevice9::SetIndices(iIndexBuffer);
	}

	long Direct3DDevice9Ex::SetLight(unsigned long index, const D3DLIGHT9 *light)
	{
		TRACE("unsigned long index = %d, const D3DLIGHT9 *light = 0x%0.8p", index, light);

		return Direct3DDevice9::SetLight(index, light);
	}

	long Direct3DDevice9Ex::SetMaterial(const D3DMATERIAL9 *material)
	{
		TRACE("const D3DMATERIAL9 *material = 0x%0.8p", material);

		return Direct3DDevice9::SetMaterial(material);
	}

	long Direct3DDevice9Ex::SetNPatchMode(float segments)
	{
		TRACE("float segments = %f", segments);

		return Direct3DDevice9::SetNPatchMode(segments);
	}

	long Direct3DDevice9Ex::SetPaletteEntries(unsigned int paletteNumber, const PALETTEENTRY *entries)
	{
		TRACE("unsigned int paletteNumber = %d, const PALETTEENTRY *entries = 0x%0.8p", paletteNumber, entries);

		return Direct3DDevice9::SetPaletteEntries(paletteNumber, entries);
	}

	long Direct3DDevice9Ex::SetPixelShader(IDirect3DPixelShader9 *iPixelShader)
	{
		TRACE("IDirect3DPixelShader9 *shader = 0x%0.8p", iPixelShader);

		return Direct3DDevice9::SetPixelShader(iPixelShader);
	}

	long Direct3DDevice9Ex::SetPixelShaderConstantB(unsigned int startRegister, const int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::SetPixelShaderConstantB(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::SetPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::SetPixelShaderConstantF(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::SetPixelShaderConstantI(unsigned int startRegister, const int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::SetPixelShaderConstantI(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::SetRenderState(D3DRENDERSTATETYPE state, unsigned long value)
	{
		TRACE("D3DRENDERSTATETYPE state = %d, unsigned long value = %d", state, value);

		return Direct3DDevice9::SetRenderState(state, value);
	}

	long Direct3DDevice9Ex::SetRenderTarget(unsigned long index, IDirect3DSurface9 *iRenderTarget)
	{
		TRACE("unsigned long index = %d, IDirect3DSurface9 *newRenderTarget = 0x%0.8p", index, iRenderTarget);

		return Direct3DDevice9::SetRenderTarget(index, iRenderTarget);
	}

	long Direct3DDevice9Ex::SetSamplerState(unsigned long sampler, D3DSAMPLERSTATETYPE state, unsigned long value)
	{
		TRACE("unsigned long sampler = %d, D3DSAMPLERSTATETYPE state = %d, unsigned long value = %d", sampler, state, value);

		return Direct3DDevice9::SetSamplerState(sampler, state, value);
	}

	long Direct3DDevice9Ex::SetScissorRect(const RECT *rect)
	{
		TRACE("const RECT *rect = 0x%0.8p", rect);

		return Direct3DDevice9::SetScissorRect(rect);
	}

	long Direct3DDevice9Ex::SetSoftwareVertexProcessing(int software)
	{
		TRACE("int software = %d", software);

		return Direct3DDevice9::SetSoftwareVertexProcessing(software);
	}

	long Direct3DDevice9Ex::SetStreamSource(unsigned int stream, IDirect3DVertexBuffer9 *iVertexBuffer, unsigned int offset, unsigned int stride)
	{
		TRACE("unsigned int stream = %d, IDirect3DVertexBuffer9 *data = 0x%0.8p, unsigned int offset = %d, unsigned int stride = %d", stream, iVertexBuffer, offset, stride);

		return Direct3DDevice9::SetStreamSource(stream, iVertexBuffer, offset, stride);
	}

	long Direct3DDevice9Ex::SetStreamSourceFreq(unsigned int streamNumber, unsigned int divider)
	{
		TRACE("unsigned int streamNumber = %d, unsigned int divider = %d", streamNumber, divider);

		return Direct3DDevice9::SetStreamSourceFreq(streamNumber, divider);
	}

	long Direct3DDevice9Ex::SetTexture(unsigned long sampler, IDirect3DBaseTexture9 *iBaseTexture)
	{
		TRACE("unsigned long sampler = %d, IDirect3DBaseTexture9 *texture = 0x%0.8p", sampler, iBaseTexture);

		return Direct3DDevice9::SetTexture(sampler, iBaseTexture);
	}

	long Direct3DDevice9Ex::SetTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long value)
	{
		TRACE("unsigned long stage = %d, D3DTEXTURESTAGESTATETYPE type = %d, unsigned long value = %d", stage, type, value);

		return Direct3DDevice9::SetTextureStageState(stage, type, value);
	}

	long Direct3DDevice9Ex::SetTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
	{
		TRACE("D3DTRANSFORMSTATETYPE state = %d, const D3DMATRIX *matrix = 0x%0.8p", state, matrix);

		return Direct3DDevice9::SetTransform(state, matrix);
	}

	long Direct3DDevice9Ex::SetVertexDeclaration(IDirect3DVertexDeclaration9 *iVertexDeclaration)
	{
		TRACE("IDirect3DVertexDeclaration9 *declaration = 0x%0.8p", iVertexDeclaration);

		return Direct3DDevice9::SetVertexDeclaration(iVertexDeclaration);
	}

	long Direct3DDevice9Ex::SetVertexShader(IDirect3DVertexShader9 *iVertexShader)
	{
		TRACE("IDirect3DVertexShader9 *shader = 0x%0.8p", iVertexShader);

		return Direct3DDevice9::SetVertexShader(iVertexShader);
	}

	long Direct3DDevice9Ex::SetVertexShaderConstantB(unsigned int startRegister, const int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::SetVertexShaderConstantB(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::SetVertexShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::SetVertexShaderConstantF(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::SetVertexShaderConstantI(unsigned int startRegister, const int *constantData, unsigned int count)
	{
		TRACE("unsigned int startRegister = %d, const int *constantData = 0x%0.8p, unsigned int count = %d", startRegister, constantData, count);

		return Direct3DDevice9::SetVertexShaderConstantI(startRegister, constantData, count);
	}

	long Direct3DDevice9Ex::SetViewport(const D3DVIEWPORT9 *viewport)
	{
		TRACE("const D3DVIEWPORT9 *viewport = 0x%0.8p", viewport);

		return Direct3DDevice9::SetViewport(viewport);
	}

	int Direct3DDevice9Ex::ShowCursor(int show)
	{
		TRACE("int show = %d", show);

		return Direct3DDevice9::ShowCursor(show);
	}

	long Direct3DDevice9Ex::StretchRect(IDirect3DSurface9 *sourceSurface, const RECT *sourceRect, IDirect3DSurface9 *destSurface, const RECT *destRect, D3DTEXTUREFILTERTYPE filter)
	{
		TRACE("IDirect3DSurface9 *sourceSurface = 0x%0.8p, const RECT *sourceRect = 0x%0.8p, IDirect3DSurface9 *destSurface = 0x%0.8p, const RECT *destRect = 0x%0.8p, D3DTEXTUREFILTERTYPE filter = %d", sourceSurface, sourceRect, destSurface, destRect, filter);

		return Direct3DDevice9::StretchRect(sourceSurface, sourceRect, destSurface, destRect, filter);
	}

	long Direct3DDevice9Ex::TestCooperativeLevel()
	{
		TRACE("void");

		return Direct3DDevice9::TestCooperativeLevel();
	}

	long Direct3DDevice9Ex::UpdateSurface(IDirect3DSurface9 *sourceSurface, const RECT *sourceRect, IDirect3DSurface9 *destinationSurface, const POINT *destPoint)
	{
		TRACE("IDirect3DSurface9 *sourceSurface = 0x%0.8p, const RECT *sourceRect = 0x%0.8p, IDirect3DSurface9 *destinationSurface = 0x%0.8p, const POINT *destPoint = 0x%0.8p", sourceSurface, sourceRect, destinationSurface, destPoint);

		return Direct3DDevice9::UpdateSurface(sourceSurface, sourceRect, destinationSurface, destPoint);
	}

	long Direct3DDevice9Ex::UpdateTexture(IDirect3DBaseTexture9 *sourceTexture, IDirect3DBaseTexture9 *destinationTexture)
	{
		TRACE("IDirect3DBaseTexture9 *sourceTexture = 0x%0.8p, IDirect3DBaseTexture9 *destinationTexture = 0x%0.8p", sourceTexture, destinationTexture);

		return Direct3DDevice9::UpdateTexture(sourceTexture, destinationTexture);
	}

	long Direct3DDevice9Ex::ValidateDevice(unsigned long *numPasses)
	{
		TRACE("unsigned long *numPasses = 0x%0.8p", numPasses);

		return Direct3DDevice9::ValidateDevice(numPasses);
	}

	HRESULT Direct3DDevice9Ex::SetConvolutionMonoKernel(UINT,UINT,float *,float *)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::ComposeRects(IDirect3DSurface9 *,IDirect3DSurface9 *,IDirect3DVertexBuffer9 *,UINT,IDirect3DVertexBuffer9 *,D3DCOMPOSERECTSOP,int,int)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::PresentEx(const RECT *,const RECT *,HWND,const RGNDATA *,DWORD)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::GetGPUThreadPriority(INT *)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::SetGPUThreadPriority(INT)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::WaitForVBlank(UINT)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::CheckResourceResidency(IDirect3DResource9 **,UINT32)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::SetMaximumFrameLatency(UINT)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::GetMaximumFrameLatency(UINT *)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::CheckDeviceState(HWND destinationWindow)
	{
		CriticalSection cs(this);

	//	UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::CreateRenderTargetEx(UINT,UINT,D3DFORMAT,D3DMULTISAMPLE_TYPE,DWORD,BOOL,IDirect3DSurface9 **,HANDLE *,DWORD)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::CreateOffscreenPlainSurfaceEx(UINT,UINT,D3DFORMAT,D3DPOOL,IDirect3DSurface9 **,HANDLE *,DWORD)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::CreateDepthStencilSurfaceEx(UINT,UINT,D3DFORMAT,D3DMULTISAMPLE_TYPE,DWORD,BOOL,IDirect3DSurface9 **,HANDLE *,DWORD)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::ResetEx(D3DPRESENT_PARAMETERS *,D3DDISPLAYMODEEX *)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}

	HRESULT Direct3DDevice9Ex::GetDisplayModeEx(UINT,D3DDISPLAYMODEEX *,D3DDISPLAYROTATION *)
	{
		CriticalSection cs(this);

		UNIMPLEMENTED();

		return D3D_OK;
	}
}