forked from Mirrorlandia_minetest/irrlicht
084e0e669a
The support for UINT shader constants added in this is just returning warnings in GLES drivers as this would need ES 3.0 git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/branches/ogl-es@6115 dfc29bdd-3216-0410-991c-e03cc46cb475
3827 lines
115 KiB
C++
3827 lines
115 KiB
C++
// Copyright (C) 2002-2012 Nikolaus Gebhardt
|
|
// This file is part of the "Irrlicht Engine".
|
|
// For conditions of distribution and use, see copyright notice in irrlicht.h
|
|
|
|
#define _IRR_DONT_DO_MEMORY_DEBUGGING_HERE
|
|
#include "CD3D9Driver.h"
|
|
|
|
#ifdef _IRR_COMPILE_WITH_DIRECT3D_9_
|
|
|
|
#include "os.h"
|
|
#include "S3DVertex.h"
|
|
#include "CD3D9Texture.h"
|
|
#include "CD3D9RenderTarget.h"
|
|
#include "CD3D9MaterialRenderer.h"
|
|
#include "CD3D9ShaderMaterialRenderer.h"
|
|
#include "CD3D9NormalMapRenderer.h"
|
|
#include "CD3D9ParallaxMapRenderer.h"
|
|
#include "CD3D9HLSLMaterialRenderer.h"
|
|
#include "SIrrCreationParameters.h"
|
|
|
|
namespace irr
|
|
{
|
|
namespace video
|
|
{
|
|
|
|
namespace
|
|
{
|
|
inline DWORD F2DW( FLOAT f ) { return *((DWORD*)&f); }
|
|
}
|
|
|
|
//! constructor
|
|
CD3D9Driver::CD3D9Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io)
|
|
: CNullDriver(io, params.WindowSize), BridgeCalls(0), CurrentRenderMode(ERM_NONE),
|
|
ResetRenderStates(true), Transformation3DChanged(false),
|
|
D3DLibrary(0), pID3D(0), pID3DDevice(0), BackBufferSurface(0),
|
|
DepthStencilSurface(0), WindowId(0), SceneSourceRect(0),
|
|
LastVertexType((video::E_VERTEX_TYPE)-1), VendorID(0),
|
|
MaxTextureUnits(0), MaxFixedPipelineTextureUnits(0), MaxUserClipPlanes(0),
|
|
MaxLightDistance(0.f), LastSetLight(-1),
|
|
ColorFormat(ECF_A8R8G8B8), DeviceLost(false),
|
|
DriverWasReset(true), OcclusionQuerySupport(false),
|
|
AlphaToCoverageSupport(false), Params(params)
|
|
{
|
|
#ifdef _DEBUG
|
|
setDebugName("CD3D9Driver");
|
|
#endif
|
|
|
|
printVersion();
|
|
|
|
for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
|
|
{
|
|
CurrentTexture[i] = 0;
|
|
LastTextureMipMapsAvailable[i] = false;
|
|
}
|
|
MaxLightDistance = sqrtf(FLT_MAX);
|
|
// create sphere map matrix
|
|
|
|
SphereMapMatrixD3D9._11 = 0.5f; SphereMapMatrixD3D9._12 = 0.0f;
|
|
SphereMapMatrixD3D9._13 = 0.0f; SphereMapMatrixD3D9._14 = 0.0f;
|
|
SphereMapMatrixD3D9._21 = 0.0f; SphereMapMatrixD3D9._22 =-0.5f;
|
|
SphereMapMatrixD3D9._23 = 0.0f; SphereMapMatrixD3D9._24 = 0.0f;
|
|
SphereMapMatrixD3D9._31 = 0.0f; SphereMapMatrixD3D9._32 = 0.0f;
|
|
SphereMapMatrixD3D9._33 = 1.0f; SphereMapMatrixD3D9._34 = 0.0f;
|
|
SphereMapMatrixD3D9._41 = 0.5f; SphereMapMatrixD3D9._42 = 0.5f;
|
|
SphereMapMatrixD3D9._43 = 0.0f; SphereMapMatrixD3D9._44 = 1.0f;
|
|
|
|
core::matrix4 mat;
|
|
UnitMatrixD3D9 = *(D3DMATRIX*)((void*)mat.pointer());
|
|
|
|
// init direct 3d is done in the factory function
|
|
}
|
|
|
|
|
|
//! destructor
|
|
CD3D9Driver::~CD3D9Driver()
|
|
{
|
|
deleteMaterialRenders();
|
|
deleteAllTextures();
|
|
removeAllOcclusionQueries();
|
|
removeAllHardwareBuffers();
|
|
|
|
if (DepthStencilSurface)
|
|
DepthStencilSurface->Release();
|
|
|
|
delete BridgeCalls;
|
|
|
|
// drop d3d9
|
|
|
|
if (pID3DDevice)
|
|
pID3DDevice->Release();
|
|
|
|
if (pID3D)
|
|
pID3D->Release();
|
|
}
|
|
|
|
|
|
void CD3D9Driver::createMaterialRenderers()
|
|
{
|
|
// create D3D9 material renderers
|
|
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_SOLID(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_SOLID_2_LAYER(pID3DDevice, this));
|
|
|
|
// add the same renderer for all lightmap types
|
|
|
|
CD3D9MaterialRenderer_LIGHTMAP* lmr = new CD3D9MaterialRenderer_LIGHTMAP(pID3DDevice, this);
|
|
addMaterialRenderer(lmr); // for EMT_LIGHTMAP:
|
|
addMaterialRenderer(lmr); // for EMT_LIGHTMAP_ADD:
|
|
addMaterialRenderer(lmr); // for EMT_LIGHTMAP_M2:
|
|
addMaterialRenderer(lmr); // for EMT_LIGHTMAP_M4:
|
|
addMaterialRenderer(lmr); // for EMT_LIGHTMAP_LIGHTING:
|
|
addMaterialRenderer(lmr); // for EMT_LIGHTMAP_LIGHTING_M2:
|
|
addMaterialRenderer(lmr); // for EMT_LIGHTMAP_LIGHTING_M4:
|
|
lmr->drop();
|
|
|
|
// add remaining fixed function pipeline material renderers
|
|
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_DETAIL_MAP(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_SPHERE_MAP(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_REFLECTION_2_LAYER(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_TRANSPARENT_ADD_COLOR(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_TRANSPARENT_ALPHA_CHANNEL(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_TRANSPARENT_ALPHA_CHANNEL_REF(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_TRANSPARENT_VERTEX_ALPHA(pID3DDevice, this));
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_TRANSPARENT_REFLECTION_2_LAYER(pID3DDevice, this));
|
|
|
|
// add normal map renderers
|
|
|
|
s32 tmp = 0;
|
|
video::IMaterialRenderer* renderer = 0;
|
|
|
|
renderer = new CD3D9NormalMapRenderer(pID3DDevice, this, tmp,
|
|
MaterialRenderers[EMT_SOLID].Renderer);
|
|
renderer->drop();
|
|
|
|
renderer = new CD3D9NormalMapRenderer(pID3DDevice, this, tmp,
|
|
MaterialRenderers[EMT_TRANSPARENT_ADD_COLOR].Renderer);
|
|
renderer->drop();
|
|
|
|
renderer = new CD3D9NormalMapRenderer(pID3DDevice, this, tmp,
|
|
MaterialRenderers[EMT_TRANSPARENT_VERTEX_ALPHA].Renderer);
|
|
renderer->drop();
|
|
|
|
// add parallax map renderers
|
|
|
|
renderer = new CD3D9ParallaxMapRenderer(pID3DDevice, this, tmp,
|
|
MaterialRenderers[EMT_SOLID].Renderer);
|
|
renderer->drop();
|
|
|
|
renderer = new CD3D9ParallaxMapRenderer(pID3DDevice, this, tmp,
|
|
MaterialRenderers[EMT_TRANSPARENT_ADD_COLOR].Renderer);
|
|
renderer->drop();
|
|
|
|
renderer = new CD3D9ParallaxMapRenderer(pID3DDevice, this, tmp,
|
|
MaterialRenderers[EMT_TRANSPARENT_VERTEX_ALPHA].Renderer);
|
|
renderer->drop();
|
|
|
|
// add basic 1 texture blending
|
|
addAndDropMaterialRenderer(new CD3D9MaterialRenderer_ONETEXTURE_BLEND(pID3DDevice, this));
|
|
}
|
|
|
|
|
|
//! initialises the Direct3D API
|
|
bool CD3D9Driver::initDriver(HWND hwnd, bool pureSoftware)
|
|
{
|
|
if (!pID3D)
|
|
{
|
|
D3DLibrary = LoadLibrary( __TEXT("d3d9.dll") );
|
|
|
|
if (!D3DLibrary)
|
|
{
|
|
os::Printer::log("Error, could not load d3d9.dll.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
typedef IDirect3D9 * (__stdcall *D3DCREATETYPE)(UINT);
|
|
D3DCREATETYPE d3dCreate = (D3DCREATETYPE) GetProcAddress(D3DLibrary, "Direct3DCreate9");
|
|
|
|
if (!d3dCreate)
|
|
{
|
|
os::Printer::log("Error, could not get proc adress of Direct3DCreate9.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
//just like pID3D = Direct3DCreate9(D3D_SDK_VERSION);
|
|
pID3D = (*d3dCreate)(D3D_SDK_VERSION);
|
|
|
|
if (!pID3D)
|
|
{
|
|
os::Printer::log("Error initializing D3D.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// print device information
|
|
D3DADAPTER_IDENTIFIER9 dai;
|
|
if (!FAILED(pID3D->GetAdapterIdentifier(Params.DisplayAdapter, 0, &dai)))
|
|
{
|
|
char tmp[512];
|
|
|
|
s32 Product = HIWORD(dai.DriverVersion.HighPart);
|
|
s32 Version = LOWORD(dai.DriverVersion.HighPart);
|
|
s32 SubVersion = HIWORD(dai.DriverVersion.LowPart);
|
|
s32 Build = LOWORD(dai.DriverVersion.LowPart);
|
|
|
|
sprintf(tmp, "%s %s %d.%d.%d.%d", dai.Description, dai.Driver, Product, Version,
|
|
SubVersion, Build);
|
|
os::Printer::log(tmp, ELL_INFORMATION);
|
|
|
|
// Assign vendor name based on vendor id.
|
|
VendorID= static_cast<u16>(dai.VendorId);
|
|
switch(dai.VendorId)
|
|
{
|
|
case 0x1002 : VendorName = "ATI Technologies Inc."; break;
|
|
case 0x10DE : VendorName = "NVIDIA Corporation"; break;
|
|
case 0x102B : VendorName = "Matrox Electronic Systems Ltd."; break;
|
|
case 0x121A : VendorName = "3dfx Interactive Inc"; break;
|
|
case 0x5333 : VendorName = "S3 Graphics Co., Ltd."; break;
|
|
case 0x8086 : VendorName = "Intel Corporation"; break;
|
|
default: VendorName = "Unknown VendorId: ";VendorName += (u32)dai.VendorId; break;
|
|
}
|
|
}
|
|
|
|
D3DDISPLAYMODE d3ddm;
|
|
if (FAILED(pID3D->GetAdapterDisplayMode(Params.DisplayAdapter, &d3ddm)))
|
|
{
|
|
os::Printer::log("Error: Could not get Adapter Display mode.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
ZeroMemory(&present, sizeof(present));
|
|
|
|
present.BackBufferCount = 1;
|
|
present.EnableAutoDepthStencil = TRUE;
|
|
if (Params.Vsync)
|
|
present.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
|
|
else
|
|
present.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
|
|
|
|
if (Params.Fullscreen)
|
|
{
|
|
present.BackBufferWidth = Params.WindowSize.Width;
|
|
present.BackBufferHeight = Params.WindowSize.Height;
|
|
// request 32bit mode if user specified 32 bit, added by Thomas Stuefe
|
|
if (Params.Bits == 32)
|
|
present.BackBufferFormat = D3DFMT_X8R8G8B8;
|
|
else
|
|
present.BackBufferFormat = D3DFMT_R5G6B5;
|
|
present.SwapEffect = D3DSWAPEFFECT_FLIP;
|
|
present.Windowed = FALSE;
|
|
present.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
|
|
}
|
|
else
|
|
{
|
|
present.BackBufferFormat = d3ddm.Format;
|
|
present.SwapEffect = D3DSWAPEFFECT_DISCARD;
|
|
present.Windowed = TRUE;
|
|
}
|
|
|
|
UINT adapter = Params.DisplayAdapter;
|
|
D3DDEVTYPE devtype = D3DDEVTYPE_HAL;
|
|
#ifndef _IRR_D3D_NO_SHADER_DEBUGGING
|
|
devtype = D3DDEVTYPE_REF;
|
|
#elif defined(_IRR_USE_NVIDIA_PERFHUD_)
|
|
for (UINT adapter_i = 0; adapter_i < pID3D->GetAdapterCount(); ++adapter_i)
|
|
{
|
|
D3DADAPTER_IDENTIFIER9 identifier;
|
|
pID3D->GetAdapterIdentifier(adapter_i,0,&identifier);
|
|
if (strstr(identifier.Description,"PerfHUD") != 0)
|
|
{
|
|
adapter = adapter_i;
|
|
devtype = D3DDEVTYPE_REF;
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// enable anti alias if possible and desired
|
|
if (Params.AntiAlias > 0)
|
|
{
|
|
if (Params.AntiAlias > 32)
|
|
Params.AntiAlias = 32;
|
|
|
|
DWORD qualityLevels = 0;
|
|
|
|
while(Params.AntiAlias > 0)
|
|
{
|
|
if(SUCCEEDED(pID3D->CheckDeviceMultiSampleType(adapter,
|
|
devtype, present.BackBufferFormat, !Params.Fullscreen,
|
|
(D3DMULTISAMPLE_TYPE)Params.AntiAlias, &qualityLevels)))
|
|
{
|
|
present.MultiSampleType = (D3DMULTISAMPLE_TYPE)Params.AntiAlias;
|
|
present.MultiSampleQuality = qualityLevels-1;
|
|
present.SwapEffect = D3DSWAPEFFECT_DISCARD;
|
|
break;
|
|
}
|
|
--Params.AntiAlias;
|
|
}
|
|
|
|
if (Params.AntiAlias==0)
|
|
{
|
|
os::Printer::log("Anti aliasing disabled because hardware/driver lacks necessary caps.", ELL_WARNING);
|
|
}
|
|
}
|
|
|
|
// check stencil buffer compatibility
|
|
if (Params.Stencilbuffer)
|
|
{
|
|
present.AutoDepthStencilFormat = D3DFMT_D24S8;
|
|
if(FAILED(pID3D->CheckDeviceFormat(adapter, devtype,
|
|
present.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
|
|
D3DRTYPE_SURFACE, present.AutoDepthStencilFormat)))
|
|
{
|
|
present.AutoDepthStencilFormat = D3DFMT_D24X4S4;
|
|
if(FAILED(pID3D->CheckDeviceFormat(adapter, devtype,
|
|
present.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
|
|
D3DRTYPE_SURFACE, present.AutoDepthStencilFormat)))
|
|
{
|
|
present.AutoDepthStencilFormat = D3DFMT_D15S1;
|
|
if(FAILED(pID3D->CheckDeviceFormat(adapter, devtype,
|
|
present.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
|
|
D3DRTYPE_SURFACE, present.AutoDepthStencilFormat)))
|
|
{
|
|
os::Printer::log("Device does not support stencilbuffer, disabling stencil buffer.", ELL_WARNING);
|
|
Params.Stencilbuffer = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if(FAILED(pID3D->CheckDepthStencilMatch(adapter, devtype,
|
|
present.BackBufferFormat, present.BackBufferFormat, present.AutoDepthStencilFormat)))
|
|
{
|
|
os::Printer::log("Depth-stencil format is not compatible with display format, disabling stencil buffer.", ELL_WARNING);
|
|
Params.Stencilbuffer = false;
|
|
}
|
|
}
|
|
// do not use else here to cope with flag change in previous block
|
|
if (!Params.Stencilbuffer)
|
|
{
|
|
present.AutoDepthStencilFormat = D3DFMT_D32;
|
|
if(FAILED(pID3D->CheckDeviceFormat(adapter, devtype,
|
|
present.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
|
|
D3DRTYPE_SURFACE, present.AutoDepthStencilFormat)))
|
|
{
|
|
present.AutoDepthStencilFormat = D3DFMT_D24X8;
|
|
if(FAILED(pID3D->CheckDeviceFormat(adapter, devtype,
|
|
present.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
|
|
D3DRTYPE_SURFACE, present.AutoDepthStencilFormat)))
|
|
{
|
|
present.AutoDepthStencilFormat = D3DFMT_D16;
|
|
if(FAILED(pID3D->CheckDeviceFormat(adapter, devtype,
|
|
present.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
|
|
D3DRTYPE_SURFACE, present.AutoDepthStencilFormat)))
|
|
{
|
|
os::Printer::log("Device does not support required depth buffer.", ELL_WARNING);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// create device
|
|
|
|
DWORD fpuPrecision = Params.HighPrecisionFPU ? D3DCREATE_FPU_PRESERVE : 0;
|
|
DWORD multithreaded = Params.DriverMultithreaded ? D3DCREATE_MULTITHREADED : 0;
|
|
if (pureSoftware)
|
|
{
|
|
if (FAILED(pID3D->CreateDevice(Params.DisplayAdapter, D3DDEVTYPE_REF, hwnd,
|
|
fpuPrecision | D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present, &pID3DDevice)))
|
|
os::Printer::log("Was not able to create Direct3D9 software device.", ELL_ERROR);
|
|
}
|
|
else
|
|
{
|
|
HRESULT hr = pID3D->CreateDevice(adapter, devtype, hwnd,
|
|
fpuPrecision | multithreaded | D3DCREATE_HARDWARE_VERTEXPROCESSING, &present, &pID3DDevice);
|
|
|
|
if(FAILED(hr))
|
|
hr = pID3D->CreateDevice(adapter, devtype, hwnd,
|
|
fpuPrecision | multithreaded | D3DCREATE_MIXED_VERTEXPROCESSING , &present, &pID3DDevice);
|
|
|
|
if(FAILED(hr))
|
|
hr = pID3D->CreateDevice(adapter, devtype, hwnd,
|
|
fpuPrecision | multithreaded | D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present, &pID3DDevice);
|
|
|
|
if (FAILED(hr))
|
|
os::Printer::log("Was not able to create Direct3D9 device.", ELL_ERROR);
|
|
}
|
|
|
|
if (!pID3DDevice)
|
|
{
|
|
os::Printer::log("Was not able to create DIRECT3D9 device.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
// get caps
|
|
pID3DDevice->GetDeviceCaps(&Caps);
|
|
|
|
os::Printer::log("Currently available Video Memory (kB)", core::stringc(pID3DDevice->GetAvailableTextureMem()/1024).c_str());
|
|
|
|
// disable stencilbuffer if necessary
|
|
if (Params.Stencilbuffer &&
|
|
(!(Caps.StencilCaps & D3DSTENCILCAPS_DECRSAT) ||
|
|
!(Caps.StencilCaps & D3DSTENCILCAPS_INCRSAT) ||
|
|
!(Caps.StencilCaps & D3DSTENCILCAPS_KEEP)))
|
|
{
|
|
os::Printer::log("Device not able to use stencil buffer, disabling stencil buffer.", ELL_WARNING);
|
|
Params.Stencilbuffer = false;
|
|
}
|
|
|
|
if (!BridgeCalls)
|
|
BridgeCalls = new CD3D9CallBridge(pID3DDevice, this);
|
|
|
|
// set default vertex shader
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
// set fog mode
|
|
setFog(FogColor, FogType, FogStart, FogEnd, FogDensity, PixelFog, RangeFog);
|
|
|
|
// set exposed data
|
|
ExposedData.D3D9.D3D9 = pID3D;
|
|
ExposedData.D3D9.D3DDev9 = pID3DDevice;
|
|
ExposedData.D3D9.HWnd = hwnd;
|
|
|
|
ResetRenderStates = true;
|
|
|
|
// create materials
|
|
createMaterialRenderers();
|
|
|
|
MaxFixedPipelineTextureUnits = (u32)Caps.MaxSimultaneousTextures;
|
|
DriverAttributes->setAttribute("MaxSupportedTextures", (s32)MaxFixedPipelineTextureUnits);
|
|
|
|
u32 maxTextureSamplers = (Caps.PixelShaderVersion >= D3DPS_VERSION(2, 0)) ? 16 : (Caps.PixelShaderVersion >= D3DPS_VERSION(1, 4)) ?
|
|
6 : (Caps.PixelShaderVersion >= D3DPS_VERSION(1, 0)) ? 4 : 0;
|
|
|
|
MaxTextureUnits = core::max_(MaxFixedPipelineTextureUnits, maxTextureSamplers);
|
|
MaxTextureUnits = core::min_(MaxTextureUnits, MATERIAL_MAX_TEXTURES);
|
|
MaxTextureUnits = core::min_(MaxTextureUnits, MATERIAL_MAX_TEXTURES_USED);
|
|
|
|
MaxUserClipPlanes = (u32)Caps.MaxUserClipPlanes;
|
|
OcclusionQuerySupport=(pID3DDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, NULL) == S_OK);
|
|
|
|
if (VendorID==0x10DE)//NVidia
|
|
AlphaToCoverageSupport = (pID3D->CheckDeviceFormat(adapter, D3DDEVTYPE_HAL,
|
|
D3DFMT_X8R8G8B8, 0,D3DRTYPE_SURFACE,
|
|
(D3DFORMAT)MAKEFOURCC('A', 'T', 'O', 'C')) == S_OK);
|
|
else if (VendorID==0x1002)//ATI
|
|
AlphaToCoverageSupport = true; // TODO: Check unknown
|
|
#if 0
|
|
AlphaToCoverageSupport = (pID3D->CheckDeviceFormat(adapter, D3DDEVTYPE_HAL,
|
|
D3DFMT_X8R8G8B8, 0,D3DRTYPE_SURFACE,
|
|
(D3DFORMAT)MAKEFOURCC('A','2','M','1')) == S_OK);
|
|
#endif
|
|
|
|
DriverAttributes->setAttribute("MaxTextures", (s32)MaxTextureUnits);
|
|
DriverAttributes->setAttribute("MaxLights", (s32)Caps.MaxActiveLights);
|
|
DriverAttributes->setAttribute("MaxAnisotropy", (s32)Caps.MaxAnisotropy);
|
|
DriverAttributes->setAttribute("MaxUserClipPlanes", (s32)Caps.MaxUserClipPlanes);
|
|
DriverAttributes->setAttribute("MaxMultipleRenderTargets", (s32)Caps.NumSimultaneousRTs);
|
|
DriverAttributes->setAttribute("MaxIndices", (s32)Caps.MaxVertexIndex);
|
|
DriverAttributes->setAttribute("MaxTextureSize", (s32)core::min_(Caps.MaxTextureHeight,Caps.MaxTextureWidth));
|
|
DriverAttributes->setAttribute("MaxTextureLODBias", 16);
|
|
DriverAttributes->setAttribute("Version", 901);
|
|
DriverAttributes->setAttribute("ShaderLanguageVersion", (s32)(((0x00ff00 & Caps.VertexShaderVersion)>>8)*100 + (Caps.VertexShaderVersion&0xff)));
|
|
DriverAttributes->setAttribute("AntiAlias", Params.AntiAlias);
|
|
|
|
// set the renderstates
|
|
setRenderStates3DMode();
|
|
|
|
// store the screen's depth buffer descriptor
|
|
if (!SUCCEEDED(pID3DDevice->GetDepthStencilSurface(&DepthStencilSurface)))
|
|
{
|
|
os::Printer::log("Was not able to get main depth buffer.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
D3DColorFormat = D3DFMT_A8R8G8B8;
|
|
IDirect3DSurface9* bb = 0;
|
|
if (SUCCEEDED(pID3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &bb)))
|
|
{
|
|
D3DSURFACE_DESC desc;
|
|
bb->GetDesc(&desc);
|
|
D3DColorFormat = desc.Format;
|
|
|
|
if (D3DColorFormat == D3DFMT_X8R8G8B8)
|
|
D3DColorFormat = D3DFMT_A8R8G8B8;
|
|
|
|
bb->Release();
|
|
}
|
|
ColorFormat = getColorFormatFromD3DFormat(D3DColorFormat);
|
|
|
|
ActiveRenderTarget.set_used((u32)Caps.NumSimultaneousRTs);
|
|
|
|
for (u32 i = 0; i < ActiveRenderTarget.size(); ++i)
|
|
ActiveRenderTarget[i] = false;
|
|
|
|
// so far so good.
|
|
return true;
|
|
}
|
|
|
|
bool CD3D9Driver::beginScene(u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil, const SExposedVideoData& videoData, core::rect<s32>* sourceRect)
|
|
{
|
|
CNullDriver::beginScene(clearFlag, clearColor, clearDepth, clearStencil, videoData, sourceRect);
|
|
WindowId = (HWND)videoData.D3D9.HWnd;
|
|
SceneSourceRect = sourceRect;
|
|
|
|
if (!pID3DDevice)
|
|
return false;
|
|
|
|
HRESULT hr;
|
|
if (DeviceLost)
|
|
{
|
|
if ( !retrieveDevice(1) )
|
|
return false;
|
|
}
|
|
|
|
clearBuffers(clearFlag, clearColor, clearDepth, clearStencil);
|
|
|
|
hr = pID3DDevice->BeginScene();
|
|
if (FAILED(hr))
|
|
{
|
|
os::Printer::log("DIRECT3D9 begin scene failed.", ELL_WARNING);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CD3D9Driver::endScene()
|
|
{
|
|
CNullDriver::endScene();
|
|
DriverWasReset=false;
|
|
|
|
HRESULT hr = pID3DDevice->EndScene();
|
|
if (FAILED(hr))
|
|
{
|
|
os::Printer::log("DIRECT3D9 end scene failed.", ELL_WARNING);
|
|
return false;
|
|
}
|
|
|
|
RECT* srcRct = 0;
|
|
RECT sourceRectData;
|
|
if ( SceneSourceRect )
|
|
{
|
|
srcRct = &sourceRectData;
|
|
sourceRectData.left = SceneSourceRect->UpperLeftCorner.X;
|
|
sourceRectData.top = SceneSourceRect->UpperLeftCorner.Y;
|
|
sourceRectData.right = SceneSourceRect->LowerRightCorner.X;
|
|
sourceRectData.bottom = SceneSourceRect->LowerRightCorner.Y;
|
|
}
|
|
|
|
IDirect3DSwapChain9* swChain;
|
|
hr = pID3DDevice->GetSwapChain(0, &swChain);
|
|
DWORD flags = (Params.HandleSRGB && (Caps.Caps3&D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION))?D3DPRESENT_LINEAR_CONTENT:0;
|
|
hr = swChain->Present(srcRct, NULL, WindowId, NULL, flags);
|
|
swChain->Release();
|
|
|
|
if (SUCCEEDED(hr))
|
|
return true;
|
|
|
|
if (hr == D3DERR_DEVICELOST)
|
|
{
|
|
DeviceLost = true;
|
|
os::Printer::log("Present failed", "DIRECT3D9 device lost.", ELL_WARNING);
|
|
}
|
|
#ifdef D3DERR_DEVICEREMOVED
|
|
else if (hr == D3DERR_DEVICEREMOVED)
|
|
{
|
|
os::Printer::log("Present failed", "Device removed.", ELL_WARNING);
|
|
}
|
|
#endif
|
|
else if (hr == D3DERR_INVALIDCALL)
|
|
{
|
|
os::Printer::log("Present failed", "Invalid Call", ELL_WARNING);
|
|
}
|
|
else
|
|
os::Printer::log("DIRECT3D9 present failed.", ELL_WARNING);
|
|
return false;
|
|
}
|
|
|
|
|
|
//! queries the features of the driver, returns true if feature is available
|
|
bool CD3D9Driver::queryFeature(E_VIDEO_DRIVER_FEATURE feature) const
|
|
{
|
|
if (!FeatureEnabled[feature])
|
|
return false;
|
|
|
|
switch (feature)
|
|
{
|
|
case EVDF_MULTITEXTURE:
|
|
case EVDF_BILINEAR_FILTER:
|
|
return true;
|
|
case EVDF_RENDER_TO_TARGET:
|
|
return Caps.NumSimultaneousRTs > 0;
|
|
case EVDF_HARDWARE_TL:
|
|
return (Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0;
|
|
case EVDF_MIP_MAP:
|
|
return (Caps.TextureCaps & D3DPTEXTURECAPS_MIPMAP) != 0;
|
|
case EVDF_MIP_MAP_AUTO_UPDATE:
|
|
return (Caps.Caps2 & D3DCAPS2_CANAUTOGENMIPMAP) != 0;
|
|
case EVDF_STENCIL_BUFFER:
|
|
return Params.Stencilbuffer && Caps.StencilCaps;
|
|
case EVDF_VERTEX_SHADER_1_1:
|
|
return Caps.VertexShaderVersion >= D3DVS_VERSION(1,1);
|
|
case EVDF_VERTEX_SHADER_2_0:
|
|
return Caps.VertexShaderVersion >= D3DVS_VERSION(2,0);
|
|
case EVDF_VERTEX_SHADER_3_0:
|
|
return Caps.VertexShaderVersion >= D3DVS_VERSION(3,0);
|
|
case EVDF_PIXEL_SHADER_1_1:
|
|
return Caps.PixelShaderVersion >= D3DPS_VERSION(1,1);
|
|
case EVDF_PIXEL_SHADER_1_2:
|
|
return Caps.PixelShaderVersion >= D3DPS_VERSION(1,2);
|
|
case EVDF_PIXEL_SHADER_1_3:
|
|
return Caps.PixelShaderVersion >= D3DPS_VERSION(1,3);
|
|
case EVDF_PIXEL_SHADER_1_4:
|
|
return Caps.PixelShaderVersion >= D3DPS_VERSION(1,4);
|
|
case EVDF_PIXEL_SHADER_2_0:
|
|
return Caps.PixelShaderVersion >= D3DPS_VERSION(2,0);
|
|
case EVDF_PIXEL_SHADER_3_0:
|
|
return Caps.PixelShaderVersion >= D3DPS_VERSION(3,0);
|
|
case EVDF_HLSL:
|
|
return Caps.VertexShaderVersion >= D3DVS_VERSION(1,1);
|
|
case EVDF_TEXTURE_NSQUARE:
|
|
return (Caps.TextureCaps & D3DPTEXTURECAPS_SQUAREONLY) == 0;
|
|
case EVDF_TEXTURE_NPOT:
|
|
return (Caps.TextureCaps & D3DPTEXTURECAPS_POW2) == 0;
|
|
case EVDF_COLOR_MASK:
|
|
return (Caps.PrimitiveMiscCaps & D3DPMISCCAPS_COLORWRITEENABLE) != 0;
|
|
case EVDF_MULTIPLE_RENDER_TARGETS:
|
|
return Caps.NumSimultaneousRTs > 1;
|
|
case EVDF_MRT_COLOR_MASK:
|
|
return (Caps.PrimitiveMiscCaps & D3DPMISCCAPS_INDEPENDENTWRITEMASKS) != 0;
|
|
case EVDF_MRT_BLEND:
|
|
return (Caps.PrimitiveMiscCaps & D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING) != 0;
|
|
case EVDF_OCCLUSION_QUERY:
|
|
return OcclusionQuerySupport;
|
|
case EVDF_POLYGON_OFFSET:
|
|
return (Caps.RasterCaps & (D3DPRASTERCAPS_DEPTHBIAS|D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS)) != 0;
|
|
case EVDF_BLEND_OPERATIONS:
|
|
return true;
|
|
case EVDF_BLEND_SEPARATE:
|
|
return (Caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) != 0;
|
|
case EVDF_TEXTURE_MATRIX:
|
|
return true;
|
|
case EVDF_TEXTURE_COMPRESSED_DXT:
|
|
return true;
|
|
case EVDF_TEXTURE_CUBEMAP:
|
|
return true;
|
|
default:
|
|
return false;
|
|
};
|
|
}
|
|
|
|
|
|
//! sets transformation
|
|
void CD3D9Driver::setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat)
|
|
{
|
|
Transformation3DChanged = true;
|
|
|
|
switch(state)
|
|
{
|
|
case ETS_VIEW:
|
|
pID3DDevice->SetTransform(D3DTS_VIEW, (D3DMATRIX*)((void*)mat.pointer()));
|
|
break;
|
|
case ETS_WORLD:
|
|
pID3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)((void*)mat.pointer()));
|
|
break;
|
|
case ETS_PROJECTION:
|
|
pID3DDevice->SetTransform( D3DTS_PROJECTION, (D3DMATRIX*)((void*)mat.pointer()));
|
|
break;
|
|
case ETS_COUNT:
|
|
return;
|
|
default:
|
|
{
|
|
const s32 stage = state - ETS_TEXTURE_0;
|
|
|
|
if ( stage < static_cast<s32>(MaxTextureUnits)
|
|
&& stage < static_cast<s32>(MaxFixedPipelineTextureUnits)) // texture transforms for shader pipeline have to be passed by user
|
|
{
|
|
if (mat.isIdentity())
|
|
pID3DDevice->SetTextureStageState(stage, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
|
else
|
|
{
|
|
pID3DDevice->SetTextureStageState(stage, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
|
|
pID3DDevice->SetTransform((D3DTRANSFORMSTATETYPE)(D3DTS_TEXTURE0 + stage), (D3DMATRIX*)((void*)mat.pointer()));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
Matrices[state] = mat;
|
|
}
|
|
|
|
|
|
//! sets the current Texture
|
|
bool CD3D9Driver::setActiveTexture(u32 stage, const video::ITexture* texture)
|
|
{
|
|
if (CurrentTexture[stage] == texture)
|
|
return true;
|
|
|
|
if (texture && texture->getDriverType() != EDT_DIRECT3D9)
|
|
{
|
|
os::Printer::log("Fatal Error: Tried to set a texture not owned by this driver.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
CurrentTexture[stage] = texture;
|
|
|
|
if (!texture)
|
|
{
|
|
pID3DDevice->SetTexture(stage, 0);
|
|
pID3DDevice->SetTextureStageState( stage, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetTexture(stage, ((const CD3D9Texture*)texture)->getDX9BaseTexture());
|
|
|
|
if (stage <= 4)
|
|
pID3DDevice->SetTexture(D3DVERTEXTEXTURESAMPLER0 + stage, ((const CD3D9Texture*)texture)->getDX9BaseTexture());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
//! sets a material
|
|
void CD3D9Driver::setMaterial(const SMaterial& material)
|
|
{
|
|
Material = material;
|
|
OverrideMaterial.apply(Material);
|
|
|
|
for (u32 i=0; i<MaxTextureUnits; ++i)
|
|
{
|
|
const ITexture* texture = Material.getTexture(i);
|
|
setActiveTexture(i, texture);
|
|
if ( texture )
|
|
{
|
|
setTransform((E_TRANSFORMATION_STATE) ( ETS_TEXTURE_0 + i ),
|
|
material.getTextureMatrix(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
ITexture* CD3D9Driver::createDeviceDependentTexture(const io::path& name, IImage* image)
|
|
{
|
|
core::array<IImage*> imageArray(1);
|
|
imageArray.push_back(image);
|
|
|
|
CD3D9Texture* texture = new CD3D9Texture(name, imageArray, ETT_2D, this);
|
|
if ( !texture->getDX9Texture() )
|
|
{
|
|
texture->drop();
|
|
return 0;
|
|
}
|
|
|
|
return texture;
|
|
}
|
|
|
|
ITexture* CD3D9Driver::createDeviceDependentTextureCubemap(const io::path& name, const core::array<IImage*>& image)
|
|
{
|
|
CD3D9Texture* texture = new CD3D9Texture(name, image, ETT_CUBEMAP, this);
|
|
|
|
if ( !texture->getDX9CubeTexture() )
|
|
{
|
|
texture->drop();
|
|
return 0;
|
|
}
|
|
|
|
return texture;
|
|
}
|
|
|
|
bool CD3D9Driver::setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil)
|
|
{
|
|
if (target && target->getDriverType() != EDT_DIRECT3D9)
|
|
{
|
|
os::Printer::log("Fatal Error: Tried to set a render target not owned by this driver.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
if (target)
|
|
{
|
|
// Store main render target.
|
|
|
|
if (!BackBufferSurface)
|
|
{
|
|
if (FAILED(pID3DDevice->GetRenderTarget(0, &BackBufferSurface)))
|
|
{
|
|
os::Printer::log("Could not get main render target.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Set new color textures.
|
|
|
|
CD3D9RenderTarget* renderTarget = static_cast<CD3D9RenderTarget*>(target);
|
|
|
|
const u32 surfaceSize = core::min_(renderTarget->getSurfaceCount(), ActiveRenderTarget.size());
|
|
|
|
for (u32 i = 0; i < surfaceSize; ++i)
|
|
{
|
|
ActiveRenderTarget[i] = true;
|
|
|
|
if (FAILED(pID3DDevice->SetRenderTarget(i, renderTarget->getSurface(i))))
|
|
{
|
|
ActiveRenderTarget[i] = false;
|
|
|
|
os::Printer::log("Error: Could not set render target.", ELL_ERROR);
|
|
}
|
|
}
|
|
|
|
// Reset other render target channels.
|
|
|
|
for (u32 i = surfaceSize; i < ActiveRenderTarget.size(); ++i)
|
|
{
|
|
if (ActiveRenderTarget[i])
|
|
{
|
|
pID3DDevice->SetRenderTarget(i, 0);
|
|
ActiveRenderTarget[i] = false;
|
|
}
|
|
}
|
|
|
|
// Set depth stencil buffer.
|
|
|
|
IDirect3DSurface9* depthStencilSurface = renderTarget->getDepthStencilSurface();
|
|
|
|
if (depthStencilSurface && FAILED(pID3DDevice->SetDepthStencilSurface(depthStencilSurface)))
|
|
{
|
|
os::Printer::log("Error: Could not set depth-stencil buffer.", ELL_ERROR);
|
|
}
|
|
|
|
// Set other settings.
|
|
|
|
CurrentRenderTargetSize = renderTarget->getSize();
|
|
Transformation3DChanged = true;
|
|
}
|
|
else if (CurrentRenderTarget != target)
|
|
{
|
|
// Set main render target.
|
|
|
|
if (BackBufferSurface)
|
|
{
|
|
ActiveRenderTarget[0] = true;
|
|
|
|
if (FAILED(pID3DDevice->SetRenderTarget(0, BackBufferSurface)))
|
|
{
|
|
os::Printer::log("Error: Could not set main render target.", ELL_ERROR);
|
|
ActiveRenderTarget[0] = false;
|
|
|
|
return false;
|
|
}
|
|
|
|
BackBufferSurface->Release();
|
|
BackBufferSurface = 0;
|
|
}
|
|
|
|
// Reset other render target channels.
|
|
|
|
for (u32 i = 1; i < ActiveRenderTarget.size(); ++i)
|
|
{
|
|
if (ActiveRenderTarget[i])
|
|
{
|
|
pID3DDevice->SetRenderTarget(i, 0);
|
|
ActiveRenderTarget[i] = false;
|
|
}
|
|
}
|
|
|
|
// Set main depth-stencil stencil buffer.
|
|
|
|
if (FAILED(pID3DDevice->SetDepthStencilSurface(DepthStencilSurface)))
|
|
{
|
|
os::Printer::log("Error: Could not set main depth-stencil buffer.", ELL_ERROR);
|
|
}
|
|
|
|
// Set other settings.
|
|
|
|
CurrentRenderTargetSize = core::dimension2d<u32>(0, 0);
|
|
Transformation3DChanged = true;
|
|
}
|
|
|
|
CurrentRenderTarget = target;
|
|
|
|
clearBuffers(clearFlag, clearColor, clearDepth, clearStencil);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//! sets a viewport
|
|
void CD3D9Driver::setViewPort(const core::rect<s32>& area)
|
|
{
|
|
core::rect<s32> vp = area;
|
|
core::rect<s32> rendert(0,0, getCurrentRenderTargetSize().Width, getCurrentRenderTargetSize().Height);
|
|
vp.clipAgainst(rendert);
|
|
if (vp.getHeight()>0 && vp.getWidth()>0)
|
|
{
|
|
D3DVIEWPORT9 viewPort;
|
|
viewPort.X = vp.UpperLeftCorner.X;
|
|
viewPort.Y = vp.UpperLeftCorner.Y;
|
|
viewPort.Width = vp.getWidth();
|
|
viewPort.Height = vp.getHeight();
|
|
viewPort.MinZ = 0.0f;
|
|
viewPort.MaxZ = 1.0f;
|
|
|
|
HRESULT hr = pID3DDevice->SetViewport(&viewPort);
|
|
if (FAILED(hr))
|
|
os::Printer::log("Failed setting the viewport.", ELL_WARNING);
|
|
else
|
|
ViewPort = vp;
|
|
}
|
|
}
|
|
|
|
|
|
//! gets the area of the current viewport
|
|
const core::rect<s32>& CD3D9Driver::getViewPort() const
|
|
{
|
|
return ViewPort;
|
|
}
|
|
|
|
|
|
bool CD3D9Driver::updateVertexHardwareBuffer(SHWBufferLink_d3d9 *hwBuffer)
|
|
{
|
|
if (!hwBuffer)
|
|
return false;
|
|
|
|
const scene::IMeshBuffer* mb = hwBuffer->MeshBuffer;
|
|
const void* vertices=mb->getVertices();
|
|
const u32 vertexCount=mb->getVertexCount();
|
|
const E_VERTEX_TYPE vType=mb->getVertexType();
|
|
const u32 vertexSize = getVertexPitchFromType(vType);
|
|
const u32 bufSize = vertexSize * vertexCount;
|
|
|
|
if (!hwBuffer->vertexBuffer || (bufSize > hwBuffer->vertexBufferSize))
|
|
{
|
|
if (hwBuffer->vertexBuffer)
|
|
{
|
|
hwBuffer->vertexBuffer->Release();
|
|
hwBuffer->vertexBuffer=0;
|
|
}
|
|
|
|
DWORD FVF;
|
|
// Get the vertex sizes and cvf
|
|
switch (vType)
|
|
{
|
|
case EVT_STANDARD:
|
|
FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX1;
|
|
break;
|
|
case EVT_2TCOORDS:
|
|
FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX2;
|
|
break;
|
|
case EVT_TANGENTS:
|
|
FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX3;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
DWORD flags = D3DUSAGE_WRITEONLY; // SIO2: Default to D3DUSAGE_WRITEONLY
|
|
if (hwBuffer->Mapped_Vertex != scene::EHM_STATIC)
|
|
flags |= D3DUSAGE_DYNAMIC;
|
|
|
|
if (FAILED(pID3DDevice->CreateVertexBuffer(bufSize, flags, FVF, D3DPOOL_DEFAULT, &hwBuffer->vertexBuffer, NULL)))
|
|
return false;
|
|
hwBuffer->vertexBufferSize = bufSize;
|
|
|
|
flags = 0; // SIO2: Reset flags before Lock
|
|
if (hwBuffer->Mapped_Vertex != scene::EHM_STATIC)
|
|
flags = D3DLOCK_DISCARD;
|
|
|
|
void* lockedBuffer = 0;
|
|
hwBuffer->vertexBuffer->Lock(0, bufSize, (void**)&lockedBuffer, flags);
|
|
memcpy(lockedBuffer, vertices, bufSize);
|
|
hwBuffer->vertexBuffer->Unlock();
|
|
}
|
|
else
|
|
{
|
|
void* lockedBuffer = 0;
|
|
hwBuffer->vertexBuffer->Lock(0, bufSize, (void**)&lockedBuffer, D3DLOCK_DISCARD);
|
|
memcpy(lockedBuffer, vertices, bufSize);
|
|
hwBuffer->vertexBuffer->Unlock();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CD3D9Driver::updateIndexHardwareBuffer(SHWBufferLink_d3d9 *hwBuffer)
|
|
{
|
|
if (!hwBuffer)
|
|
return false;
|
|
|
|
const scene::IMeshBuffer* mb = hwBuffer->MeshBuffer;
|
|
const u16* indices=mb->getIndices();
|
|
const u32 indexCount=mb->getIndexCount();
|
|
u32 indexSize = 2;
|
|
D3DFORMAT indexType=D3DFMT_UNKNOWN;
|
|
switch (mb->getIndexType())
|
|
{
|
|
case EIT_16BIT:
|
|
{
|
|
indexType=D3DFMT_INDEX16;
|
|
indexSize = 2;
|
|
break;
|
|
}
|
|
case EIT_32BIT:
|
|
{
|
|
indexType=D3DFMT_INDEX32;
|
|
indexSize = 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const u32 bufSize = indexSize * indexCount;
|
|
if (!hwBuffer->indexBuffer || (bufSize > hwBuffer->indexBufferSize))
|
|
{
|
|
if (hwBuffer->indexBuffer)
|
|
{
|
|
hwBuffer->indexBuffer->Release();
|
|
hwBuffer->indexBuffer=0;
|
|
}
|
|
|
|
DWORD flags = D3DUSAGE_WRITEONLY; // SIO2: Default to D3DUSAGE_WRITEONLY
|
|
if (hwBuffer->Mapped_Index != scene::EHM_STATIC)
|
|
flags |= D3DUSAGE_DYNAMIC; // SIO2: Add DYNAMIC flag for dynamic buffer data
|
|
|
|
if (FAILED(pID3DDevice->CreateIndexBuffer(bufSize, flags, indexType, D3DPOOL_DEFAULT, &hwBuffer->indexBuffer, NULL)))
|
|
return false;
|
|
|
|
flags = 0; // SIO2: Reset flags before Lock
|
|
if (hwBuffer->Mapped_Index != scene::EHM_STATIC)
|
|
flags = D3DLOCK_DISCARD;
|
|
|
|
void* lockedBuffer = 0;
|
|
if (FAILED(hwBuffer->indexBuffer->Lock( 0, 0, (void**)&lockedBuffer, flags)))
|
|
return false;
|
|
|
|
memcpy(lockedBuffer, indices, bufSize);
|
|
hwBuffer->indexBuffer->Unlock();
|
|
|
|
hwBuffer->indexBufferSize = bufSize;
|
|
}
|
|
else
|
|
{
|
|
void* lockedBuffer = 0;
|
|
if( SUCCEEDED(hwBuffer->indexBuffer->Lock( 0, 0, (void**)&lockedBuffer, D3DLOCK_DISCARD)))
|
|
{
|
|
memcpy(lockedBuffer, indices, bufSize);
|
|
hwBuffer->indexBuffer->Unlock();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//! updates hardware buffer if needed
|
|
bool CD3D9Driver::updateHardwareBuffer(SHWBufferLink *hwBuffer)
|
|
{
|
|
if (!hwBuffer)
|
|
return false;
|
|
|
|
if (hwBuffer->Mapped_Vertex!=scene::EHM_NEVER)
|
|
{
|
|
if (hwBuffer->ChangedID_Vertex != hwBuffer->MeshBuffer->getChangedID_Vertex()
|
|
|| !((SHWBufferLink_d3d9*)hwBuffer)->vertexBuffer)
|
|
{
|
|
hwBuffer->ChangedID_Vertex = hwBuffer->MeshBuffer->getChangedID_Vertex();
|
|
|
|
if (!updateVertexHardwareBuffer((SHWBufferLink_d3d9*)hwBuffer))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (hwBuffer->Mapped_Index!=scene::EHM_NEVER)
|
|
{
|
|
if (hwBuffer->ChangedID_Index != hwBuffer->MeshBuffer->getChangedID_Index()
|
|
|| !((SHWBufferLink_d3d9*)hwBuffer)->indexBuffer)
|
|
{
|
|
hwBuffer->ChangedID_Index = hwBuffer->MeshBuffer->getChangedID_Index();
|
|
|
|
if (!updateIndexHardwareBuffer((SHWBufferLink_d3d9*)hwBuffer))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//! Create hardware buffer from meshbuffer
|
|
CD3D9Driver::SHWBufferLink *CD3D9Driver::createHardwareBuffer(const scene::IMeshBuffer* mb)
|
|
{
|
|
// Looks like d3d does not support only partial buffering, so refuse
|
|
// in any case of NEVER
|
|
if (!mb || (mb->getHardwareMappingHint_Index()==scene::EHM_NEVER || mb->getHardwareMappingHint_Vertex()==scene::EHM_NEVER))
|
|
return 0;
|
|
|
|
SHWBufferLink_d3d9 *hwBuffer=new SHWBufferLink_d3d9(mb);
|
|
|
|
//add to map
|
|
HWBufferMap.insert(hwBuffer->MeshBuffer, hwBuffer);
|
|
|
|
hwBuffer->ChangedID_Vertex=hwBuffer->MeshBuffer->getChangedID_Vertex();
|
|
hwBuffer->ChangedID_Index=hwBuffer->MeshBuffer->getChangedID_Index();
|
|
hwBuffer->Mapped_Vertex=mb->getHardwareMappingHint_Vertex();
|
|
hwBuffer->Mapped_Index=mb->getHardwareMappingHint_Index();
|
|
hwBuffer->LastUsed=0;
|
|
hwBuffer->vertexBuffer=0;
|
|
hwBuffer->indexBuffer=0;
|
|
hwBuffer->vertexBufferSize=0;
|
|
hwBuffer->indexBufferSize=0;
|
|
|
|
if (!updateHardwareBuffer(hwBuffer))
|
|
{
|
|
deleteHardwareBuffer(hwBuffer);
|
|
return 0;
|
|
}
|
|
|
|
return hwBuffer;
|
|
}
|
|
|
|
|
|
void CD3D9Driver::deleteHardwareBuffer(SHWBufferLink *_HWBuffer)
|
|
{
|
|
if (!_HWBuffer)
|
|
return;
|
|
|
|
SHWBufferLink_d3d9 *HWBuffer=(SHWBufferLink_d3d9*)_HWBuffer;
|
|
if (HWBuffer->indexBuffer)
|
|
{
|
|
HWBuffer->indexBuffer->Release();
|
|
HWBuffer->indexBuffer = 0;
|
|
}
|
|
|
|
if (HWBuffer->vertexBuffer)
|
|
{
|
|
HWBuffer->vertexBuffer->Release();
|
|
HWBuffer->vertexBuffer = 0;
|
|
}
|
|
|
|
CNullDriver::deleteHardwareBuffer(_HWBuffer);
|
|
}
|
|
|
|
|
|
//! Draw hardware buffer
|
|
void CD3D9Driver::drawHardwareBuffer(SHWBufferLink *_HWBuffer)
|
|
{
|
|
if (!_HWBuffer)
|
|
return;
|
|
|
|
SHWBufferLink_d3d9 *HWBuffer=(SHWBufferLink_d3d9*)_HWBuffer;
|
|
|
|
updateHardwareBuffer(HWBuffer); //check if update is needed
|
|
|
|
HWBuffer->LastUsed=0;//reset count
|
|
|
|
const scene::IMeshBuffer* mb = HWBuffer->MeshBuffer;
|
|
const E_VERTEX_TYPE vType = mb->getVertexType();
|
|
const u32 stride = getVertexPitchFromType(vType);
|
|
const void* vPtr = mb->getVertices();
|
|
const void* iPtr = mb->getIndices();
|
|
if (HWBuffer->vertexBuffer)
|
|
{
|
|
pID3DDevice->SetStreamSource(0, HWBuffer->vertexBuffer, 0, stride);
|
|
vPtr=0;
|
|
}
|
|
if (HWBuffer->indexBuffer)
|
|
{
|
|
pID3DDevice->SetIndices(HWBuffer->indexBuffer);
|
|
iPtr=0;
|
|
}
|
|
|
|
drawVertexPrimitiveList(vPtr, mb->getVertexCount(), iPtr, mb->getPrimitiveCount(), mb->getVertexType(), mb->getPrimitiveType(), mb->getIndexType());
|
|
|
|
if (HWBuffer->vertexBuffer)
|
|
pID3DDevice->SetStreamSource(0, 0, 0, 0);
|
|
if (HWBuffer->indexBuffer)
|
|
pID3DDevice->SetIndices(0);
|
|
}
|
|
|
|
|
|
//! Create occlusion query.
|
|
/** Use node for identification and mesh for occlusion test. */
|
|
void CD3D9Driver::addOcclusionQuery(scene::ISceneNode* node,
|
|
const scene::IMesh* mesh)
|
|
{
|
|
if (!queryFeature(EVDF_OCCLUSION_QUERY))
|
|
return;
|
|
CNullDriver::addOcclusionQuery(node, mesh);
|
|
const s32 index = OcclusionQueries.linear_search(SOccQuery(node));
|
|
if ((index != -1) && (OcclusionQueries[index].PID == 0))
|
|
pID3DDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, reinterpret_cast<IDirect3DQuery9**>(&OcclusionQueries[index].PID));
|
|
}
|
|
|
|
|
|
//! Remove occlusion query.
|
|
void CD3D9Driver::removeOcclusionQuery(scene::ISceneNode* node)
|
|
{
|
|
const s32 index = OcclusionQueries.linear_search(SOccQuery(node));
|
|
if (index != -1)
|
|
{
|
|
if (OcclusionQueries[index].PID != 0)
|
|
reinterpret_cast<IDirect3DQuery9*>(OcclusionQueries[index].PID)->Release();
|
|
CNullDriver::removeOcclusionQuery(node);
|
|
}
|
|
}
|
|
|
|
|
|
//! Run occlusion query. Draws mesh stored in query.
|
|
/** If the mesh shall not be rendered visible, use
|
|
overrideMaterial to disable the color and depth buffer. */
|
|
void CD3D9Driver::runOcclusionQuery(scene::ISceneNode* node, bool visible)
|
|
{
|
|
if (!node)
|
|
return;
|
|
|
|
const s32 index = OcclusionQueries.linear_search(SOccQuery(node));
|
|
if (index != -1)
|
|
{
|
|
if (OcclusionQueries[index].PID)
|
|
reinterpret_cast<IDirect3DQuery9*>(OcclusionQueries[index].PID)->Issue(D3DISSUE_BEGIN);
|
|
CNullDriver::runOcclusionQuery(node,visible);
|
|
if (OcclusionQueries[index].PID)
|
|
reinterpret_cast<IDirect3DQuery9*>(OcclusionQueries[index].PID)->Issue(D3DISSUE_END);
|
|
}
|
|
}
|
|
|
|
|
|
//! Update occlusion query. Retrieves results from GPU.
|
|
/** If the query shall not block, set the flag to false.
|
|
Update might not occur in this case, though */
|
|
void CD3D9Driver::updateOcclusionQuery(scene::ISceneNode* node, bool block)
|
|
{
|
|
const s32 index = OcclusionQueries.linear_search(SOccQuery(node));
|
|
if (index != -1)
|
|
{
|
|
// not yet started
|
|
if (OcclusionQueries[index].Run==u32(~0))
|
|
return;
|
|
bool available = block?true:false;
|
|
int tmp=0;
|
|
if (!block)
|
|
available=(reinterpret_cast<IDirect3DQuery9*>(OcclusionQueries[index].PID)->GetData(&tmp, sizeof(DWORD), 0)==S_OK);
|
|
else
|
|
{
|
|
do
|
|
{
|
|
HRESULT hr = reinterpret_cast<IDirect3DQuery9*>(OcclusionQueries[index].PID)->GetData(&tmp, sizeof(DWORD), D3DGETDATA_FLUSH);
|
|
available = (hr == S_OK);
|
|
if (hr!=S_FALSE)
|
|
break;
|
|
} while (!available);
|
|
}
|
|
if (available)
|
|
OcclusionQueries[index].Result = tmp;
|
|
}
|
|
}
|
|
|
|
|
|
//! Return query result.
|
|
/** Return value is the number of visible pixels/fragments.
|
|
The value is a safe approximation, i.e. can be larger than the
|
|
actual value of pixels. */
|
|
u32 CD3D9Driver::getOcclusionQueryResult(scene::ISceneNode* node) const
|
|
{
|
|
const s32 index = OcclusionQueries.linear_search(SOccQuery(node));
|
|
if (index != -1)
|
|
return OcclusionQueries[index].Result;
|
|
else
|
|
return ~0;
|
|
}
|
|
|
|
|
|
//! Create render target.
|
|
IRenderTarget* CD3D9Driver::addRenderTarget()
|
|
{
|
|
CD3D9RenderTarget* renderTarget = new CD3D9RenderTarget(this);
|
|
RenderTargets.push_back(renderTarget);
|
|
|
|
return renderTarget;
|
|
}
|
|
|
|
|
|
//! draws a vertex primitive list
|
|
void CD3D9Driver::drawVertexPrimitiveList(const void* vertices,
|
|
u32 vertexCount, const void* indexList, u32 primitiveCount,
|
|
E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType,
|
|
E_INDEX_TYPE iType)
|
|
{
|
|
if (!checkPrimitiveCount(primitiveCount))
|
|
return;
|
|
|
|
CNullDriver::drawVertexPrimitiveList(vertices, vertexCount, indexList, primitiveCount, vType, pType,iType);
|
|
|
|
if (!vertexCount || !primitiveCount)
|
|
return;
|
|
|
|
draw2D3DVertexPrimitiveList(vertices, vertexCount, indexList, primitiveCount,
|
|
vType, pType, iType, true);
|
|
}
|
|
|
|
|
|
//! draws a vertex primitive list
|
|
void CD3D9Driver::draw2DVertexPrimitiveList(const void* vertices,
|
|
u32 vertexCount, const void* indexList, u32 primitiveCount,
|
|
E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType,
|
|
E_INDEX_TYPE iType)
|
|
{
|
|
if (!checkPrimitiveCount(primitiveCount))
|
|
return;
|
|
|
|
CNullDriver::draw2DVertexPrimitiveList(vertices, vertexCount, indexList, primitiveCount, vType, pType,iType);
|
|
|
|
if (!vertexCount || !primitiveCount)
|
|
return;
|
|
|
|
draw2D3DVertexPrimitiveList(vertices, vertexCount, indexList, primitiveCount,
|
|
vType, pType, iType, false);
|
|
}
|
|
|
|
|
|
void CD3D9Driver::draw2D3DVertexPrimitiveList(const void* vertices,
|
|
u32 vertexCount, const void* indexList, u32 primitiveCount,
|
|
E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType,
|
|
E_INDEX_TYPE iType, bool is3D)
|
|
{
|
|
setVertexShader(vType);
|
|
|
|
const u32 stride = getVertexPitchFromType(vType);
|
|
|
|
D3DFORMAT indexType=D3DFMT_UNKNOWN;
|
|
switch (iType)
|
|
{
|
|
case (EIT_16BIT):
|
|
{
|
|
indexType=D3DFMT_INDEX16;
|
|
break;
|
|
}
|
|
case (EIT_32BIT):
|
|
{
|
|
indexType=D3DFMT_INDEX32;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (is3D)
|
|
{
|
|
if (!setRenderStates3DMode())
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (Material.MaterialType==EMT_ONETEXTURE_BLEND)
|
|
{
|
|
E_BLEND_FACTOR srcFact;
|
|
E_BLEND_FACTOR dstFact;
|
|
E_MODULATE_FUNC modulo;
|
|
u32 alphaSource;
|
|
unpack_textureBlendFunc ( srcFact, dstFact, modulo, alphaSource, Material.MaterialTypeParam);
|
|
setRenderStates2DMode(alphaSource&video::EAS_VERTEX_COLOR, (Material.getTexture(0) != 0), (alphaSource&video::EAS_TEXTURE) != 0);
|
|
}
|
|
else
|
|
setRenderStates2DMode(Material.MaterialType==EMT_TRANSPARENT_VERTEX_ALPHA, (Material.getTexture(0) != 0), Material.MaterialType==EMT_TRANSPARENT_ALPHA_CHANNEL);
|
|
}
|
|
|
|
switch (pType)
|
|
{
|
|
case scene::EPT_POINT_SPRITES:
|
|
case scene::EPT_POINTS:
|
|
{
|
|
f32 tmp=Material.Thickness/getScreenSize().Height;
|
|
if (pType==scene::EPT_POINT_SPRITES)
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSIZE, F2DW(tmp));
|
|
tmp=1.0f;
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSCALE_A, F2DW(tmp));
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSCALE_B, F2DW(tmp));
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSIZE_MIN, F2DW(tmp));
|
|
tmp=0.0f;
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSCALE_C, F2DW(tmp));
|
|
|
|
if (!vertices)
|
|
{
|
|
pID3DDevice->DrawIndexedPrimitive(D3DPT_POINTLIST, 0, 0, vertexCount, 0, primitiveCount);
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_POINTLIST, 0, vertexCount,
|
|
primitiveCount, indexList, indexType, vertices, stride);
|
|
}
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSCALEENABLE, FALSE);
|
|
if (pType==scene::EPT_POINT_SPRITES)
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, FALSE);
|
|
}
|
|
break;
|
|
case scene::EPT_LINE_STRIP:
|
|
if(!vertices)
|
|
pID3DDevice->DrawIndexedPrimitive(D3DPT_LINESTRIP, 0, 0, vertexCount, 0, primitiveCount);
|
|
else
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_LINESTRIP, 0, vertexCount,
|
|
primitiveCount, indexList, indexType, vertices, stride);
|
|
break;
|
|
case scene::EPT_LINE_LOOP:
|
|
if(!vertices)
|
|
{
|
|
// TODO: Implement proper hardware support for this primitive type.
|
|
// (No looping occurs currently because this would require a way to
|
|
// draw the hardware buffer with a custom set of indices. We may even
|
|
// need to create a new mini index buffer specifically for this
|
|
// primitive type.)
|
|
pID3DDevice->DrawIndexedPrimitive(D3DPT_LINELIST, 0, 0, vertexCount, 0, primitiveCount);
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_LINESTRIP, 0, vertexCount,
|
|
primitiveCount - 1, indexList, indexType, vertices, stride);
|
|
|
|
u16 tmpIndices[] = {static_cast<u16>(primitiveCount - 1), 0};
|
|
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_LINELIST, 0, vertexCount,
|
|
1, tmpIndices, indexType, vertices, stride);
|
|
}
|
|
break;
|
|
case scene::EPT_LINES:
|
|
if(!vertices)
|
|
pID3DDevice->DrawIndexedPrimitive(D3DPT_LINELIST, 0, 0, vertexCount, 0, primitiveCount);
|
|
else
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_LINELIST, 0, vertexCount,
|
|
primitiveCount, indexList, indexType, vertices, stride);
|
|
break;
|
|
case scene::EPT_TRIANGLE_STRIP:
|
|
if(!vertices)
|
|
pID3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, vertexCount, 0, primitiveCount);
|
|
else
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLESTRIP, 0, vertexCount, primitiveCount,
|
|
indexList, indexType, vertices, stride);
|
|
break;
|
|
case scene::EPT_TRIANGLE_FAN:
|
|
if(!vertices)
|
|
pID3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLEFAN, 0, 0, vertexCount, 0, primitiveCount);
|
|
else
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLEFAN, 0, vertexCount, primitiveCount,
|
|
indexList, indexType, vertices, stride);
|
|
break;
|
|
case scene::EPT_TRIANGLES:
|
|
if(!vertices)
|
|
{
|
|
pID3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, vertexCount, 0, primitiveCount);
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, vertexCount,
|
|
primitiveCount, indexList, indexType, vertices, stride);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CD3D9Driver::draw2DImage(const video::ITexture* texture,
|
|
const core::rect<s32>& destRect,
|
|
const core::rect<s32>& sourceRect,
|
|
const core::rect<s32>* clipRect,
|
|
const video::SColor* const colors,
|
|
bool useAlphaChannelOfTexture)
|
|
{
|
|
if(!texture)
|
|
return;
|
|
|
|
const core::dimension2d<u32>& ss = texture->getOriginalSize();
|
|
core::rect<f32> tcoords;
|
|
tcoords.UpperLeftCorner.X = (f32)sourceRect.UpperLeftCorner.X / (f32)ss.Width;
|
|
tcoords.UpperLeftCorner.Y = (f32)sourceRect.UpperLeftCorner.Y / (f32)ss.Height;
|
|
tcoords.LowerRightCorner.X = (f32)sourceRect.LowerRightCorner.X / (f32)ss.Width;
|
|
tcoords.LowerRightCorner.Y = (f32)sourceRect.LowerRightCorner.Y / (f32)ss.Height;
|
|
|
|
const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
|
|
|
|
const video::SColor temp[4] =
|
|
{
|
|
0xFFFFFFFF,
|
|
0xFFFFFFFF,
|
|
0xFFFFFFFF,
|
|
0xFFFFFFFF
|
|
};
|
|
|
|
const video::SColor* const useColor = colors ? colors : temp;
|
|
|
|
S3DVertex vtx[4]; // clock wise
|
|
vtx[0] = S3DVertex((f32)destRect.UpperLeftCorner.X, (f32)destRect.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, useColor[0],
|
|
tcoords.UpperLeftCorner.X, tcoords.UpperLeftCorner.Y);
|
|
vtx[1] = S3DVertex((f32)destRect.LowerRightCorner.X, (f32)destRect.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, useColor[3],
|
|
tcoords.LowerRightCorner.X, tcoords.UpperLeftCorner.Y);
|
|
vtx[2] = S3DVertex((f32)destRect.LowerRightCorner.X, (f32)destRect.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, useColor[2],
|
|
tcoords.LowerRightCorner.X, tcoords.LowerRightCorner.Y);
|
|
vtx[3] = S3DVertex((f32)destRect.UpperLeftCorner.X, (f32)destRect.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, useColor[1],
|
|
tcoords.UpperLeftCorner.X, tcoords.LowerRightCorner.Y);
|
|
|
|
s16 indices[6] = {0,1,2,0,2,3};
|
|
|
|
setActiveTexture(0, texture);
|
|
|
|
setRenderStates2DMode(useColor[0].getAlpha()<255 || useColor[1].getAlpha()<255 ||
|
|
useColor[2].getAlpha()<255 || useColor[3].getAlpha()<255,
|
|
true, useAlphaChannelOfTexture);
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
if (clipRect)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
|
|
RECT scissor;
|
|
scissor.left = clipRect->UpperLeftCorner.X;
|
|
scissor.top = clipRect->UpperLeftCorner.Y;
|
|
scissor.right = clipRect->LowerRightCorner.X;
|
|
scissor.bottom = clipRect->LowerRightCorner.Y;
|
|
pID3DDevice->SetScissorRect(&scissor);
|
|
}
|
|
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 4, 2, &indices[0],
|
|
D3DFMT_INDEX16,&vtx[0], sizeof(S3DVertex));
|
|
|
|
if (clipRect)
|
|
pID3DDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
|
|
}
|
|
|
|
|
|
void CD3D9Driver::draw2DImageBatch(const video::ITexture* texture,
|
|
const core::array<core::position2d<s32> >& positions,
|
|
const core::array<core::rect<s32> >& sourceRects,
|
|
const core::rect<s32>* clipRect,
|
|
SColor color,
|
|
bool useAlphaChannelOfTexture)
|
|
{
|
|
if (!texture)
|
|
return;
|
|
|
|
if (!setActiveTexture(0, texture))
|
|
return;
|
|
|
|
setRenderStates2DMode(color.getAlpha()<255, true, useAlphaChannelOfTexture);
|
|
|
|
const irr::u32 drawCount = core::min_<u32>(positions.size(), sourceRects.size());
|
|
|
|
core::array<S3DVertex> vtx(drawCount * 4);
|
|
core::array<u16> indices(drawCount * 6);
|
|
|
|
for(u32 i = 0;i < drawCount;i++)
|
|
{
|
|
core::position2d<s32> targetPos = positions[i];
|
|
core::position2d<s32> sourcePos = sourceRects[i].UpperLeftCorner;
|
|
// This needs to be signed as it may go negative.
|
|
core::dimension2d<s32> sourceSize(sourceRects[i].getSize());
|
|
|
|
if (clipRect)
|
|
{
|
|
if (targetPos.X < clipRect->UpperLeftCorner.X)
|
|
{
|
|
sourceSize.Width += targetPos.X - clipRect->UpperLeftCorner.X;
|
|
if (sourceSize.Width <= 0)
|
|
continue;
|
|
|
|
sourcePos.X -= targetPos.X - clipRect->UpperLeftCorner.X;
|
|
targetPos.X = clipRect->UpperLeftCorner.X;
|
|
}
|
|
|
|
if (targetPos.X + (s32)sourceSize.Width > clipRect->LowerRightCorner.X)
|
|
{
|
|
sourceSize.Width -= (targetPos.X + sourceSize.Width) - clipRect->LowerRightCorner.X;
|
|
if (sourceSize.Width <= 0)
|
|
continue;
|
|
}
|
|
|
|
if (targetPos.Y < clipRect->UpperLeftCorner.Y)
|
|
{
|
|
sourceSize.Height += targetPos.Y - clipRect->UpperLeftCorner.Y;
|
|
if (sourceSize.Height <= 0)
|
|
continue;
|
|
|
|
sourcePos.Y -= targetPos.Y - clipRect->UpperLeftCorner.Y;
|
|
targetPos.Y = clipRect->UpperLeftCorner.Y;
|
|
}
|
|
|
|
if (targetPos.Y + (s32)sourceSize.Height > clipRect->LowerRightCorner.Y)
|
|
{
|
|
sourceSize.Height -= (targetPos.Y + sourceSize.Height) - clipRect->LowerRightCorner.Y;
|
|
if (sourceSize.Height <= 0)
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// clip these coordinates
|
|
|
|
if (targetPos.X<0)
|
|
{
|
|
sourceSize.Width += targetPos.X;
|
|
if (sourceSize.Width <= 0)
|
|
continue;
|
|
|
|
sourcePos.X -= targetPos.X;
|
|
targetPos.X = 0;
|
|
}
|
|
|
|
const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
|
|
|
|
if (targetPos.X + sourceSize.Width > (s32)renderTargetSize.Width)
|
|
{
|
|
sourceSize.Width -= (targetPos.X + sourceSize.Width) - renderTargetSize.Width;
|
|
if (sourceSize.Width <= 0)
|
|
continue;
|
|
}
|
|
|
|
if (targetPos.Y<0)
|
|
{
|
|
sourceSize.Height += targetPos.Y;
|
|
if (sourceSize.Height <= 0)
|
|
continue;
|
|
|
|
sourcePos.Y -= targetPos.Y;
|
|
targetPos.Y = 0;
|
|
}
|
|
|
|
if (targetPos.Y + sourceSize.Height > (s32)renderTargetSize.Height)
|
|
{
|
|
sourceSize.Height -= (targetPos.Y + sourceSize.Height) - renderTargetSize.Height;
|
|
if (sourceSize.Height <= 0)
|
|
continue;
|
|
}
|
|
|
|
// ok, we've clipped everything.
|
|
// now draw it.
|
|
|
|
core::rect<f32> tcoords;
|
|
tcoords.UpperLeftCorner.X = (((f32)sourcePos.X)) / texture->getOriginalSize().Width ;
|
|
tcoords.UpperLeftCorner.Y = (((f32)sourcePos.Y)) / texture->getOriginalSize().Height;
|
|
tcoords.LowerRightCorner.X = tcoords.UpperLeftCorner.X + ((f32)(sourceSize.Width) / texture->getOriginalSize().Width);
|
|
tcoords.LowerRightCorner.Y = tcoords.UpperLeftCorner.Y + ((f32)(sourceSize.Height) / texture->getOriginalSize().Height);
|
|
|
|
const core::rect<s32> poss(targetPos, sourceSize);
|
|
|
|
vtx.push_back(S3DVertex((f32)poss.UpperLeftCorner.X, (f32)poss.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.UpperLeftCorner.X, tcoords.UpperLeftCorner.Y));
|
|
vtx.push_back(S3DVertex((f32)poss.LowerRightCorner.X, (f32)poss.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.LowerRightCorner.X, tcoords.UpperLeftCorner.Y));
|
|
vtx.push_back(S3DVertex((f32)poss.LowerRightCorner.X, (f32)poss.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.LowerRightCorner.X, tcoords.LowerRightCorner.Y));
|
|
vtx.push_back(S3DVertex((f32)poss.UpperLeftCorner.X, (f32)poss.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.UpperLeftCorner.X, tcoords.LowerRightCorner.Y));
|
|
|
|
const u32 curPos = vtx.size()-4;
|
|
indices.push_back(0+curPos);
|
|
indices.push_back(1+curPos);
|
|
indices.push_back(2+curPos);
|
|
|
|
indices.push_back(0+curPos);
|
|
indices.push_back(2+curPos);
|
|
indices.push_back(3+curPos);
|
|
}
|
|
|
|
if (vtx.size())
|
|
{
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, vtx.size(), indices.size() / 3, indices.pointer(),
|
|
D3DFMT_INDEX16,vtx.pointer(), sizeof(S3DVertex));
|
|
}
|
|
}
|
|
|
|
|
|
//! draws a 2d image, using a color and the alpha channel of the texture if
|
|
//! desired. The image is drawn at pos and clipped against clipRect (if != 0).
|
|
void CD3D9Driver::draw2DImage(const video::ITexture* texture,
|
|
const core::position2d<s32>& pos,
|
|
const core::rect<s32>& sourceRect,
|
|
const core::rect<s32>* clipRect, SColor color,
|
|
bool useAlphaChannelOfTexture)
|
|
{
|
|
if (!texture)
|
|
return;
|
|
|
|
if (!sourceRect.isValid())
|
|
return;
|
|
|
|
if (!setActiveTexture(0, texture))
|
|
return;
|
|
|
|
core::position2d<s32> targetPos = pos;
|
|
core::position2d<s32> sourcePos = sourceRect.UpperLeftCorner;
|
|
// This needs to be signed as it may go negative.
|
|
core::dimension2d<s32> sourceSize(sourceRect.getSize());
|
|
|
|
if (clipRect)
|
|
{
|
|
if (targetPos.X < clipRect->UpperLeftCorner.X)
|
|
{
|
|
sourceSize.Width += targetPos.X - clipRect->UpperLeftCorner.X;
|
|
if (sourceSize.Width <= 0)
|
|
return;
|
|
|
|
sourcePos.X -= targetPos.X - clipRect->UpperLeftCorner.X;
|
|
targetPos.X = clipRect->UpperLeftCorner.X;
|
|
}
|
|
|
|
if (targetPos.X + (s32)sourceSize.Width > clipRect->LowerRightCorner.X)
|
|
{
|
|
sourceSize.Width -= (targetPos.X + sourceSize.Width) - clipRect->LowerRightCorner.X;
|
|
if (sourceSize.Width <= 0)
|
|
return;
|
|
}
|
|
|
|
if (targetPos.Y < clipRect->UpperLeftCorner.Y)
|
|
{
|
|
sourceSize.Height += targetPos.Y - clipRect->UpperLeftCorner.Y;
|
|
if (sourceSize.Height <= 0)
|
|
return;
|
|
|
|
sourcePos.Y -= targetPos.Y - clipRect->UpperLeftCorner.Y;
|
|
targetPos.Y = clipRect->UpperLeftCorner.Y;
|
|
}
|
|
|
|
if (targetPos.Y + (s32)sourceSize.Height > clipRect->LowerRightCorner.Y)
|
|
{
|
|
sourceSize.Height -= (targetPos.Y + sourceSize.Height) - clipRect->LowerRightCorner.Y;
|
|
if (sourceSize.Height <= 0)
|
|
return;
|
|
}
|
|
}
|
|
|
|
// clip these coordinates
|
|
|
|
if (targetPos.X<0)
|
|
{
|
|
sourceSize.Width += targetPos.X;
|
|
if (sourceSize.Width <= 0)
|
|
return;
|
|
|
|
sourcePos.X -= targetPos.X;
|
|
targetPos.X = 0;
|
|
}
|
|
|
|
const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
|
|
|
|
if (targetPos.X + sourceSize.Width > (s32)renderTargetSize.Width)
|
|
{
|
|
sourceSize.Width -= (targetPos.X + sourceSize.Width) - renderTargetSize.Width;
|
|
if (sourceSize.Width <= 0)
|
|
return;
|
|
}
|
|
|
|
if (targetPos.Y<0)
|
|
{
|
|
sourceSize.Height += targetPos.Y;
|
|
if (sourceSize.Height <= 0)
|
|
return;
|
|
|
|
sourcePos.Y -= targetPos.Y;
|
|
targetPos.Y = 0;
|
|
}
|
|
|
|
if (targetPos.Y + sourceSize.Height > (s32)renderTargetSize.Height)
|
|
{
|
|
sourceSize.Height -= (targetPos.Y + sourceSize.Height) - renderTargetSize.Height;
|
|
if (sourceSize.Height <= 0)
|
|
return;
|
|
}
|
|
|
|
// ok, we've clipped everything.
|
|
// now draw it.
|
|
|
|
core::rect<f32> tcoords;
|
|
tcoords.UpperLeftCorner.X = (((f32)sourcePos.X)) / texture->getOriginalSize().Width ;
|
|
tcoords.UpperLeftCorner.Y = (((f32)sourcePos.Y)) / texture->getOriginalSize().Height;
|
|
tcoords.LowerRightCorner.X = tcoords.UpperLeftCorner.X + ((f32)(sourceSize.Width) / texture->getOriginalSize().Width);
|
|
tcoords.LowerRightCorner.Y = tcoords.UpperLeftCorner.Y + ((f32)(sourceSize.Height) / texture->getOriginalSize().Height);
|
|
|
|
const core::rect<s32> poss(targetPos, sourceSize);
|
|
|
|
setRenderStates2DMode(color.getAlpha()<255, true, useAlphaChannelOfTexture);
|
|
|
|
S3DVertex vtx[4];
|
|
vtx[0] = S3DVertex((f32)poss.UpperLeftCorner.X, (f32)poss.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.UpperLeftCorner.X, tcoords.UpperLeftCorner.Y);
|
|
vtx[1] = S3DVertex((f32)poss.LowerRightCorner.X, (f32)poss.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.LowerRightCorner.X, tcoords.UpperLeftCorner.Y);
|
|
vtx[2] = S3DVertex((f32)poss.LowerRightCorner.X, (f32)poss.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.LowerRightCorner.X, tcoords.LowerRightCorner.Y);
|
|
vtx[3] = S3DVertex((f32)poss.UpperLeftCorner.X, (f32)poss.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, color,
|
|
tcoords.UpperLeftCorner.X, tcoords.LowerRightCorner.Y);
|
|
|
|
s16 indices[6] = {0,1,2,0,2,3};
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 4, 2, &indices[0],
|
|
D3DFMT_INDEX16,&vtx[0], sizeof(S3DVertex));
|
|
}
|
|
|
|
|
|
//!Draws a 2d rectangle with a gradient.
|
|
void CD3D9Driver::draw2DRectangle(const core::rect<s32>& position,
|
|
SColor colorLeftUp, SColor colorRightUp, SColor colorLeftDown, SColor colorRightDown,
|
|
const core::rect<s32>* clip)
|
|
{
|
|
core::rect<s32> pos(position);
|
|
|
|
if (clip)
|
|
pos.clipAgainst(*clip);
|
|
|
|
if (!pos.isValid())
|
|
return;
|
|
|
|
S3DVertex vtx[4];
|
|
vtx[0] = S3DVertex((f32)pos.UpperLeftCorner.X, (f32)pos.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, colorLeftUp, 0.0f, 0.0f);
|
|
vtx[1] = S3DVertex((f32)pos.LowerRightCorner.X, (f32)pos.UpperLeftCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, colorRightUp, 0.0f, 1.0f);
|
|
vtx[2] = S3DVertex((f32)pos.LowerRightCorner.X, (f32)pos.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, colorRightDown, 1.0f, 0.0f);
|
|
vtx[3] = S3DVertex((f32)pos.UpperLeftCorner.X, (f32)pos.LowerRightCorner.Y, 0.0f,
|
|
0.0f, 0.0f, 0.0f, colorLeftDown, 1.0f, 1.0f);
|
|
|
|
s16 indices[6] = {0,1,2,0,2,3};
|
|
|
|
setRenderStates2DMode(
|
|
colorLeftUp.getAlpha() < 255 ||
|
|
colorRightUp.getAlpha() < 255 ||
|
|
colorLeftDown.getAlpha() < 255 ||
|
|
colorRightDown.getAlpha() < 255, false, false);
|
|
|
|
setActiveTexture(0,0);
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 4, 2, &indices[0],
|
|
D3DFMT_INDEX16, &vtx[0], sizeof(S3DVertex));
|
|
}
|
|
|
|
|
|
//! Draws a 2d line.
|
|
void CD3D9Driver::draw2DLine(const core::position2d<s32>& start,
|
|
const core::position2d<s32>& end,
|
|
SColor color)
|
|
{
|
|
if (start==end)
|
|
drawPixel(start.X, start.Y, color);
|
|
else
|
|
{
|
|
// thanks to Vash TheStampede who sent in his implementation
|
|
S3DVertex vtx[2];
|
|
vtx[0] = S3DVertex((f32)start.X+0.375f, (f32)start.Y+0.375f, 0.0f,
|
|
0.0f, 0.0f, 0.0f, // normal
|
|
color, 0.0f, 0.0f); // texture
|
|
|
|
vtx[1] = S3DVertex((f32)end.X+0.375f, (f32)end.Y+0.375f, 0.0f,
|
|
0.0f, 0.0f, 0.0f,
|
|
color, 0.0f, 0.0f);
|
|
|
|
setRenderStates2DMode(color.getAlpha() < 255, false, false);
|
|
setActiveTexture(0,0);
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_LINELIST, 1,
|
|
&vtx[0], sizeof(S3DVertex) );
|
|
}
|
|
}
|
|
|
|
|
|
//! Draws a pixel
|
|
void CD3D9Driver::drawPixel(u32 x, u32 y, const SColor & color)
|
|
{
|
|
const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
|
|
if(x > (u32)renderTargetSize.Width || y > (u32)renderTargetSize.Height)
|
|
return;
|
|
|
|
setRenderStates2DMode(color.getAlpha() < 255, false, false);
|
|
setActiveTexture(0,0);
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
S3DVertex vertex((f32)x+0.375f, (f32)y+0.375f, 0.f, 0.f, 0.f, 0.f, color, 0.f, 0.f);
|
|
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_POINTLIST, 1, &vertex, sizeof(vertex));
|
|
}
|
|
|
|
|
|
//! sets right vertex shader
|
|
void CD3D9Driver::setVertexShader(E_VERTEX_TYPE newType)
|
|
{
|
|
if (newType != LastVertexType)
|
|
{
|
|
LastVertexType = newType;
|
|
HRESULT hr = 0;
|
|
|
|
switch(newType)
|
|
{
|
|
case EVT_STANDARD:
|
|
hr = pID3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX1);
|
|
break;
|
|
case EVT_2TCOORDS:
|
|
hr = pID3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX2);
|
|
break;
|
|
case EVT_TANGENTS:
|
|
hr = pID3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX3 |
|
|
D3DFVF_TEXCOORDSIZE2(0) | // real texture coord
|
|
D3DFVF_TEXCOORDSIZE3(1) | // misuse texture coord 2 for tangent
|
|
D3DFVF_TEXCOORDSIZE3(2) // misuse texture coord 3 for binormal
|
|
);
|
|
break;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
os::Printer::log("Could not set vertex Shader.", ELL_ERROR);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//! sets the needed renderstates
|
|
bool CD3D9Driver::setRenderStates3DMode()
|
|
{
|
|
if (!pID3DDevice)
|
|
return false;
|
|
|
|
if (CurrentRenderMode != ERM_3D)
|
|
{
|
|
// switch back the matrices
|
|
pID3DDevice->SetTransform(D3DTS_VIEW, (D3DMATRIX*)((void*)&Matrices[ETS_VIEW]));
|
|
pID3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)((void*)&Matrices[ETS_WORLD]));
|
|
pID3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)((void*)&Matrices[ETS_PROJECTION]));
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
|
|
pID3DDevice->SetRenderState(D3DRS_CLIPPING, TRUE);
|
|
|
|
ResetRenderStates = true;
|
|
}
|
|
|
|
if (ResetRenderStates || LastMaterial != Material)
|
|
{
|
|
// unset old material
|
|
|
|
if (CurrentRenderMode == ERM_3D &&
|
|
LastMaterial.MaterialType != Material.MaterialType &&
|
|
LastMaterial.MaterialType >= 0 && LastMaterial.MaterialType < (s32)MaterialRenderers.size())
|
|
MaterialRenderers[LastMaterial.MaterialType].Renderer->OnUnsetMaterial();
|
|
|
|
// set new material.
|
|
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
MaterialRenderers[Material.MaterialType].Renderer->OnSetMaterial(
|
|
Material, LastMaterial, ResetRenderStates, this);
|
|
}
|
|
|
|
bool shaderOK = true;
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
shaderOK = MaterialRenderers[Material.MaterialType].Renderer->OnRender(this, LastVertexType);
|
|
|
|
LastMaterial = Material;
|
|
|
|
ResetRenderStates = false;
|
|
|
|
CurrentRenderMode = ERM_3D;
|
|
|
|
return shaderOK;
|
|
}
|
|
|
|
|
|
//! Map Irrlicht texture wrap mode to native values
|
|
D3DTEXTUREADDRESS CD3D9Driver::getTextureWrapMode(const u8 clamp)
|
|
{
|
|
switch (clamp)
|
|
{
|
|
case ETC_REPEAT:
|
|
if (Caps.TextureAddressCaps & D3DPTADDRESSCAPS_WRAP)
|
|
return D3DTADDRESS_WRAP;
|
|
case ETC_CLAMP:
|
|
case ETC_CLAMP_TO_EDGE:
|
|
if (Caps.TextureAddressCaps & D3DPTADDRESSCAPS_CLAMP)
|
|
return D3DTADDRESS_CLAMP;
|
|
case ETC_MIRROR:
|
|
if (Caps.TextureAddressCaps & D3DPTADDRESSCAPS_MIRROR)
|
|
return D3DTADDRESS_MIRROR;
|
|
case ETC_CLAMP_TO_BORDER:
|
|
if (Caps.TextureAddressCaps & D3DPTADDRESSCAPS_BORDER)
|
|
return D3DTADDRESS_BORDER;
|
|
else
|
|
return D3DTADDRESS_CLAMP;
|
|
case ETC_MIRROR_CLAMP:
|
|
case ETC_MIRROR_CLAMP_TO_EDGE:
|
|
case ETC_MIRROR_CLAMP_TO_BORDER:
|
|
if (Caps.TextureAddressCaps & D3DPTADDRESSCAPS_MIRRORONCE)
|
|
return D3DTADDRESS_MIRRORONCE;
|
|
else
|
|
return D3DTADDRESS_CLAMP;
|
|
default:
|
|
return D3DTADDRESS_WRAP;
|
|
}
|
|
}
|
|
|
|
|
|
//! Can be called by an IMaterialRenderer to make its work easier.
|
|
void CD3D9Driver::setBasicRenderStates(const SMaterial& material, const SMaterial& lastmaterial,
|
|
bool resetAllRenderstates)
|
|
{
|
|
// This needs only to be updated onresets
|
|
if (Params.HandleSRGB && resetAllRenderstates)
|
|
pID3DDevice->SetRenderState(D3DRS_SRGBWRITEENABLE, TRUE);
|
|
|
|
if (resetAllRenderstates ||
|
|
lastmaterial.AmbientColor != material.AmbientColor ||
|
|
lastmaterial.DiffuseColor != material.DiffuseColor ||
|
|
lastmaterial.SpecularColor != material.SpecularColor ||
|
|
lastmaterial.EmissiveColor != material.EmissiveColor ||
|
|
lastmaterial.Shininess != material.Shininess)
|
|
{
|
|
D3DMATERIAL9 mat;
|
|
mat.Diffuse = colorToD3D(material.DiffuseColor);
|
|
mat.Ambient = colorToD3D(material.AmbientColor);
|
|
mat.Specular = colorToD3D(material.SpecularColor);
|
|
mat.Emissive = colorToD3D(material.EmissiveColor);
|
|
mat.Power = material.Shininess;
|
|
pID3DDevice->SetMaterial(&mat);
|
|
}
|
|
|
|
if (lastmaterial.ColorMaterial != material.ColorMaterial)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_COLORVERTEX, (material.ColorMaterial != ECM_NONE));
|
|
pID3DDevice->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE,
|
|
((material.ColorMaterial == ECM_DIFFUSE)||
|
|
(material.ColorMaterial == ECM_DIFFUSE_AND_AMBIENT))?D3DMCS_COLOR1:D3DMCS_MATERIAL);
|
|
pID3DDevice->SetRenderState(D3DRS_AMBIENTMATERIALSOURCE,
|
|
((material.ColorMaterial == ECM_AMBIENT)||
|
|
(material.ColorMaterial == ECM_DIFFUSE_AND_AMBIENT))?D3DMCS_COLOR1:D3DMCS_MATERIAL);
|
|
pID3DDevice->SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE,
|
|
(material.ColorMaterial == ECM_EMISSIVE)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
|
|
pID3DDevice->SetRenderState(D3DRS_SPECULARMATERIALSOURCE,
|
|
(material.ColorMaterial == ECM_SPECULAR)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
|
|
}
|
|
|
|
// fillmode
|
|
if (resetAllRenderstates || lastmaterial.Wireframe != material.Wireframe || lastmaterial.PointCloud != material.PointCloud)
|
|
{
|
|
if (material.Wireframe)
|
|
pID3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
|
|
else
|
|
if (material.PointCloud)
|
|
pID3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_POINT);
|
|
else
|
|
pID3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
|
|
}
|
|
|
|
// shademode
|
|
|
|
if (resetAllRenderstates || lastmaterial.GouraudShading != material.GouraudShading)
|
|
{
|
|
if (material.GouraudShading)
|
|
pID3DDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
|
|
else
|
|
pID3DDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);
|
|
}
|
|
|
|
// lighting
|
|
|
|
if (resetAllRenderstates || lastmaterial.Lighting != material.Lighting)
|
|
{
|
|
if (material.Lighting)
|
|
pID3DDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
|
|
else
|
|
pID3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
|
|
}
|
|
|
|
// zbuffer
|
|
|
|
if (resetAllRenderstates || lastmaterial.ZBuffer != material.ZBuffer)
|
|
{
|
|
switch (material.ZBuffer)
|
|
{
|
|
case ECFN_DISABLED:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
|
|
break;
|
|
case ECFN_LESSEQUAL:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
|
|
break;
|
|
case ECFN_EQUAL:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_EQUAL);
|
|
break;
|
|
case ECFN_LESS:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
|
|
break;
|
|
case ECFN_NOTEQUAL:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_NOTEQUAL);
|
|
break;
|
|
case ECFN_GREATEREQUAL:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_GREATEREQUAL);
|
|
break;
|
|
case ECFN_GREATER:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_GREATER);
|
|
break;
|
|
case ECFN_ALWAYS:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
|
|
break;
|
|
case ECFN_NEVER:
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_NEVER);
|
|
}
|
|
}
|
|
|
|
// zwrite
|
|
if (getWriteZBuffer(material))
|
|
{
|
|
pID3DDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE);
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
|
|
}
|
|
|
|
// back face culling
|
|
|
|
if (resetAllRenderstates || (lastmaterial.FrontfaceCulling != material.FrontfaceCulling) || (lastmaterial.BackfaceCulling != material.BackfaceCulling))
|
|
{
|
|
// if (material.FrontfaceCulling && material.BackfaceCulling)
|
|
// pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW|D3DCULL_CCW);
|
|
// else
|
|
if (material.FrontfaceCulling)
|
|
pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
|
|
else
|
|
if (material.BackfaceCulling)
|
|
pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
|
|
else
|
|
pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
|
|
}
|
|
|
|
// fog
|
|
if (resetAllRenderstates || lastmaterial.FogEnable != material.FogEnable)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_FOGENABLE, material.FogEnable);
|
|
}
|
|
|
|
// specular highlights
|
|
if (resetAllRenderstates || !core::equals(lastmaterial.Shininess,material.Shininess))
|
|
{
|
|
const bool enable = (material.Shininess!=0.0f);
|
|
pID3DDevice->SetRenderState(D3DRS_SPECULARENABLE, enable);
|
|
pID3DDevice->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
|
|
}
|
|
|
|
// normalization
|
|
if (resetAllRenderstates || lastmaterial.NormalizeNormals != material.NormalizeNormals)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_NORMALIZENORMALS, material.NormalizeNormals);
|
|
}
|
|
|
|
// Color Mask
|
|
if (queryFeature(EVDF_COLOR_MASK) &&
|
|
(resetAllRenderstates || lastmaterial.ColorMask != material.ColorMask))
|
|
{
|
|
const DWORD flag =
|
|
((material.ColorMask & ECP_RED)?D3DCOLORWRITEENABLE_RED:0) |
|
|
((material.ColorMask & ECP_GREEN)?D3DCOLORWRITEENABLE_GREEN:0) |
|
|
((material.ColorMask & ECP_BLUE)?D3DCOLORWRITEENABLE_BLUE:0) |
|
|
((material.ColorMask & ECP_ALPHA)?D3DCOLORWRITEENABLE_ALPHA:0);
|
|
pID3DDevice->SetRenderState(D3DRS_COLORWRITEENABLE, flag);
|
|
}
|
|
|
|
// Blend Operation
|
|
if (material.BlendOperation == EBO_NONE)
|
|
BridgeCalls->setBlend(false);
|
|
else
|
|
{
|
|
BridgeCalls->setBlend(true);
|
|
|
|
if (queryFeature(EVDF_BLEND_OPERATIONS))
|
|
{
|
|
switch (material.BlendOperation)
|
|
{
|
|
case EBO_MAX:
|
|
case EBO_MAX_FACTOR:
|
|
case EBO_MAX_ALPHA:
|
|
BridgeCalls->setBlendOperation(D3DBLENDOP_MAX);
|
|
break;
|
|
case EBO_MIN:
|
|
case EBO_MIN_FACTOR:
|
|
case EBO_MIN_ALPHA:
|
|
BridgeCalls->setBlendOperation(D3DBLENDOP_MIN);
|
|
break;
|
|
case EBO_SUBTRACT:
|
|
BridgeCalls->setBlendOperation(D3DBLENDOP_SUBTRACT);
|
|
break;
|
|
case EBO_REVSUBTRACT:
|
|
BridgeCalls->setBlendOperation(D3DBLENDOP_REVSUBTRACT);
|
|
break;
|
|
default:
|
|
BridgeCalls->setBlendOperation(D3DBLENDOP_ADD);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Blend Factor
|
|
if (IR(material.BlendFactor) & 0xFFFFFFFF // TODO: why the & 0xFFFFFFFF?
|
|
&& material.MaterialType != EMT_ONETEXTURE_BLEND
|
|
)
|
|
{
|
|
E_BLEND_FACTOR srcRGBFact = EBF_ZERO;
|
|
E_BLEND_FACTOR dstRGBFact = EBF_ZERO;
|
|
E_BLEND_FACTOR srcAlphaFact = EBF_ZERO;
|
|
E_BLEND_FACTOR dstAlphaFact = EBF_ZERO;
|
|
E_MODULATE_FUNC modulo = EMFN_MODULATE_1X;
|
|
u32 alphaSource = 0;
|
|
|
|
unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo, alphaSource, material.BlendFactor);
|
|
|
|
BridgeCalls->setBlendFuncSeparate(getD3DBlend(srcRGBFact), getD3DBlend(dstRGBFact),
|
|
getD3DBlend(srcAlphaFact), getD3DBlend(dstAlphaFact));
|
|
}
|
|
|
|
// Polygon offset
|
|
if (queryFeature(EVDF_POLYGON_OFFSET) && (resetAllRenderstates ||
|
|
lastmaterial.PolygonOffsetDirection != material.PolygonOffsetDirection ||
|
|
lastmaterial.PolygonOffsetFactor != material.PolygonOffsetFactor ||
|
|
lastmaterial.PolygonOffsetSlopeScale != material.PolygonOffsetSlopeScale ||
|
|
lastmaterial.PolygonOffsetDepthBias != material.PolygonOffsetDepthBias ))
|
|
{
|
|
if ( material.PolygonOffsetSlopeScale || material.PolygonOffsetDepthBias )
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, F2DW(material.PolygonOffsetSlopeScale));
|
|
pID3DDevice->SetRenderState(D3DRS_DEPTHBIAS, F2DW(material.PolygonOffsetDepthBias));
|
|
}
|
|
else if (material.PolygonOffsetFactor)
|
|
{
|
|
if (material.PolygonOffsetDirection==EPO_BACK)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, F2DW(1.f));
|
|
pID3DDevice->SetRenderState(D3DRS_DEPTHBIAS, F2DW((FLOAT)material.PolygonOffsetFactor));
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, F2DW(-1.f));
|
|
pID3DDevice->SetRenderState(D3DRS_DEPTHBIAS, F2DW((FLOAT)-material.PolygonOffsetFactor));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0);
|
|
pID3DDevice->SetRenderState(D3DRS_DEPTHBIAS, 0);
|
|
}
|
|
}
|
|
|
|
// Anti Aliasing
|
|
if (resetAllRenderstates || lastmaterial.AntiAliasing != material.AntiAliasing)
|
|
{
|
|
if (AlphaToCoverageSupport && (material.AntiAliasing & EAAM_ALPHA_TO_COVERAGE))
|
|
{
|
|
if (VendorID==0x10DE)//NVidia
|
|
pID3DDevice->SetRenderState(D3DRS_ADAPTIVETESS_Y, MAKEFOURCC('A','T','O','C'));
|
|
// SSAA could give better results on NVidia cards
|
|
else if (VendorID==0x1002)//ATI
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSIZE, MAKEFOURCC('A','2','M','1'));
|
|
}
|
|
else if (AlphaToCoverageSupport && (lastmaterial.AntiAliasing & EAAM_ALPHA_TO_COVERAGE))
|
|
{
|
|
if (VendorID==0x10DE)
|
|
pID3DDevice->SetRenderState(D3DRS_ADAPTIVETESS_Y, D3DFMT_UNKNOWN);
|
|
else if (VendorID==0x1002)
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSIZE, MAKEFOURCC('A','2','M','0'));
|
|
}
|
|
|
|
// enable antialiasing
|
|
if (Params.AntiAlias)
|
|
{
|
|
if (material.AntiAliasing & (EAAM_SIMPLE|EAAM_QUALITY))
|
|
pID3DDevice->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, TRUE);
|
|
else if (lastmaterial.AntiAliasing & (EAAM_SIMPLE|EAAM_QUALITY))
|
|
pID3DDevice->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, FALSE);
|
|
if (material.AntiAliasing & (EAAM_LINE_SMOOTH))
|
|
pID3DDevice->SetRenderState(D3DRS_ANTIALIASEDLINEENABLE, TRUE);
|
|
else if (lastmaterial.AntiAliasing & (EAAM_LINE_SMOOTH))
|
|
pID3DDevice->SetRenderState(D3DRS_ANTIALIASEDLINEENABLE, FALSE);
|
|
}
|
|
}
|
|
|
|
// thickness
|
|
if (resetAllRenderstates || lastmaterial.Thickness != material.Thickness)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_POINTSIZE, F2DW(material.Thickness));
|
|
}
|
|
|
|
// texture address mode
|
|
for (u32 st=0; st<MaxTextureUnits; ++st)
|
|
{
|
|
if (resetAllRenderstates && Params.HandleSRGB)
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_SRGBTEXTURE, TRUE);
|
|
|
|
if (resetAllRenderstates || lastmaterial.TextureLayer[st].LODBias != material.TextureLayer[st].LODBias)
|
|
{
|
|
const float tmp = material.TextureLayer[st].LODBias * 0.125f;
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MIPMAPLODBIAS, F2DW(tmp));
|
|
}
|
|
|
|
if (resetAllRenderstates || lastmaterial.TextureLayer[st].TextureWrapU != material.TextureLayer[st].TextureWrapU)
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_ADDRESSU, getTextureWrapMode(material.TextureLayer[st].TextureWrapU));
|
|
// If separate UV not supported reuse U for V
|
|
if (!(Caps.TextureAddressCaps & D3DPTADDRESSCAPS_INDEPENDENTUV))
|
|
{
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_ADDRESSV, getTextureWrapMode(material.TextureLayer[st].TextureWrapU));
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_ADDRESSW, getTextureWrapMode(material.TextureLayer[st].TextureWrapU));
|
|
}
|
|
else
|
|
{
|
|
if (resetAllRenderstates || lastmaterial.TextureLayer[st].TextureWrapV != material.TextureLayer[st].TextureWrapV)
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_ADDRESSV, getTextureWrapMode(material.TextureLayer[st].TextureWrapV));
|
|
|
|
if (resetAllRenderstates || lastmaterial.TextureLayer[st].TextureWrapW != material.TextureLayer[st].TextureWrapW)
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_ADDRESSW, getTextureWrapMode(material.TextureLayer[st].TextureWrapW));
|
|
}
|
|
|
|
// Bilinear, trilinear, and anisotropic filter
|
|
if (resetAllRenderstates ||
|
|
lastmaterial.TextureLayer[st].BilinearFilter != material.TextureLayer[st].BilinearFilter ||
|
|
lastmaterial.TextureLayer[st].TrilinearFilter != material.TextureLayer[st].TrilinearFilter ||
|
|
lastmaterial.TextureLayer[st].AnisotropicFilter != material.TextureLayer[st].AnisotropicFilter ||
|
|
lastmaterial.UseMipMaps != material.UseMipMaps)
|
|
{
|
|
if (material.TextureLayer[st].BilinearFilter || material.TextureLayer[st].TrilinearFilter || material.TextureLayer[st].AnisotropicFilter)
|
|
{
|
|
D3DTEXTUREFILTERTYPE tftMag = ((Caps.TextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC) &&
|
|
material.TextureLayer[st].AnisotropicFilter) ? D3DTEXF_ANISOTROPIC : D3DTEXF_LINEAR;
|
|
D3DTEXTUREFILTERTYPE tftMin = ((Caps.TextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC) &&
|
|
material.TextureLayer[st].AnisotropicFilter) ? D3DTEXF_ANISOTROPIC : D3DTEXF_LINEAR;
|
|
D3DTEXTUREFILTERTYPE tftMip = material.UseMipMaps? (material.TextureLayer[st].TrilinearFilter ? D3DTEXF_LINEAR : D3DTEXF_POINT) : D3DTEXF_NONE;
|
|
|
|
if (tftMag==D3DTEXF_ANISOTROPIC || tftMin == D3DTEXF_ANISOTROPIC)
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MAXANISOTROPY, core::min_((DWORD)material.TextureLayer[st].AnisotropicFilter, Caps.MaxAnisotropy));
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MAGFILTER, tftMag);
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MINFILTER, tftMin);
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MIPFILTER, tftMip);
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MINFILTER, D3DTEXF_POINT);
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
|
|
pID3DDevice->SetSamplerState(st, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//! sets the needed renderstates
|
|
void CD3D9Driver::setRenderStatesStencilShadowMode(bool zfail, u32 debugDataVisible)
|
|
{
|
|
if ((CurrentRenderMode != ERM_SHADOW_VOLUME_ZFAIL &&
|
|
CurrentRenderMode != ERM_SHADOW_VOLUME_ZPASS) ||
|
|
Transformation3DChanged)
|
|
{
|
|
// unset last 3d material
|
|
if (CurrentRenderMode == ERM_3D &&
|
|
static_cast<u32>(Material.MaterialType) < MaterialRenderers.size())
|
|
{
|
|
MaterialRenderers[Material.MaterialType].Renderer->OnUnsetMaterial();
|
|
ResetRenderStates = true;
|
|
}
|
|
// switch back the matrices
|
|
pID3DDevice->SetTransform(D3DTS_VIEW, (D3DMATRIX*)((void*)&Matrices[ETS_VIEW]));
|
|
pID3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)((void*)&Matrices[ETS_WORLD]));
|
|
pID3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)((void*)&Matrices[ETS_PROJECTION]));
|
|
|
|
Transformation3DChanged = false;
|
|
|
|
setActiveTexture(0,0);
|
|
setActiveTexture(1,0);
|
|
setActiveTexture(2,0);
|
|
setActiveTexture(3,0);
|
|
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
|
|
|
pID3DDevice->SetFVF(D3DFVF_XYZ);
|
|
LastVertexType = (video::E_VERTEX_TYPE)(-1);
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);
|
|
//pID3DDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
|
|
//pID3DDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILREF, 0x0);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILMASK, 0xffffffff);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xffffffff);
|
|
|
|
BridgeCalls->setBlend(true);
|
|
BridgeCalls->setBlendFunc(D3DBLEND_ZERO, D3DBLEND_ONE);
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
|
|
pID3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
|
|
|
|
//if (!(debugDataVisible & (scene::EDS_SKELETON|scene::EDS_MESH_WIRE_OVERLAY)))
|
|
// pID3DDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
|
|
if ((debugDataVisible & scene::EDS_MESH_WIRE_OVERLAY))
|
|
pID3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
|
|
}
|
|
|
|
if (CurrentRenderMode != ERM_SHADOW_VOLUME_ZPASS && !zfail)
|
|
{
|
|
// USE THE ZPASS METHOD
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
|
|
//pID3DDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_INCR); // does not matter, will be set later
|
|
}
|
|
else
|
|
if (CurrentRenderMode != ERM_SHADOW_VOLUME_ZFAIL && zfail)
|
|
{
|
|
// USE THE ZFAIL METHOD
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
|
|
//pID3DDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_INCR); // does not matter, will be set later
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
|
|
}
|
|
|
|
CurrentRenderMode = zfail ? ERM_SHADOW_VOLUME_ZFAIL : ERM_SHADOW_VOLUME_ZPASS;
|
|
}
|
|
|
|
|
|
//! sets the needed renderstates
|
|
void CD3D9Driver::setRenderStatesStencilFillMode(bool alpha)
|
|
{
|
|
if (CurrentRenderMode != ERM_STENCIL_FILL || Transformation3DChanged)
|
|
{
|
|
core::matrix4 mat;
|
|
pID3DDevice->SetTransform(D3DTS_VIEW, &UnitMatrixD3D9);
|
|
pID3DDevice->SetTransform(D3DTS_WORLD, &UnitMatrixD3D9);
|
|
pID3DDevice->SetTransform(D3DTS_PROJECTION, &UnitMatrixD3D9);
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
|
|
pID3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
|
|
pID3DDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
|
|
|
|
pID3DDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILREF, 0x1);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_LESSEQUAL);
|
|
//pID3DDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_GREATEREQUAL);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILMASK, 0xffffffff);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xffffffff);
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
|
|
|
|
Transformation3DChanged = false;
|
|
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
|
|
if (alpha)
|
|
{
|
|
BridgeCalls->setBlend(true);
|
|
BridgeCalls->setBlendFunc(D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA);
|
|
}
|
|
else
|
|
{
|
|
BridgeCalls->setBlend(false);
|
|
}
|
|
}
|
|
|
|
CurrentRenderMode = ERM_STENCIL_FILL;
|
|
}
|
|
|
|
|
|
//! Enable the 2d override material
|
|
void CD3D9Driver::enableMaterial2D(bool enable)
|
|
{
|
|
if (!enable)
|
|
CurrentRenderMode = ERM_NONE;
|
|
CNullDriver::enableMaterial2D(enable);
|
|
}
|
|
|
|
|
|
//! sets the needed renderstates
|
|
void CD3D9Driver::setRenderStates2DMode(bool alpha, bool texture, bool alphaChannel)
|
|
{
|
|
if (!pID3DDevice)
|
|
return;
|
|
|
|
if (CurrentRenderMode != ERM_2D || Transformation3DChanged)
|
|
{
|
|
// unset last 3d material
|
|
if (CurrentRenderMode == ERM_3D)
|
|
{
|
|
if (static_cast<u32>(LastMaterial.MaterialType) < MaterialRenderers.size())
|
|
MaterialRenderers[LastMaterial.MaterialType].Renderer->OnUnsetMaterial();
|
|
}
|
|
if (!OverrideMaterial2DEnabled)
|
|
{
|
|
setBasicRenderStates(InitMaterial2D, LastMaterial, true);
|
|
LastMaterial=InitMaterial2D;
|
|
|
|
// fix everything that is wrongly set by InitMaterial2D default
|
|
pID3DDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
|
|
}
|
|
core::matrix4 m;
|
|
// this fixes some problems with pixel exact rendering, but also breaks nice texturing
|
|
// moreover, it would have to be tested in each call, as the texture flag can change each time
|
|
// if (!texture)
|
|
// m.setTranslation(core::vector3df(0.5f,0.5f,0));
|
|
pID3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)((void*)m.pointer()));
|
|
|
|
// adjust the view such that pixel center aligns with texels
|
|
// Otherwise, subpixel artifacts will occur
|
|
m.setTranslation(core::vector3df(-0.5f,-0.5f,0));
|
|
pID3DDevice->SetTransform(D3DTS_VIEW, (D3DMATRIX*)((void*)m.pointer()));
|
|
|
|
const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
|
|
m.buildProjectionMatrixOrthoLH(f32(renderTargetSize.Width), f32(-(s32)(renderTargetSize.Height)), -1.0, 1.0);
|
|
m.setTranslation(core::vector3df(-1,1,0));
|
|
pID3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)((void*)m.pointer()));
|
|
|
|
// 2d elements are clipped in software
|
|
pID3DDevice->SetRenderState(D3DRS_CLIPPING, FALSE);
|
|
|
|
Transformation3DChanged = false;
|
|
}
|
|
if (OverrideMaterial2DEnabled)
|
|
{
|
|
OverrideMaterial2D.Lighting=false;
|
|
setBasicRenderStates(OverrideMaterial2D, LastMaterial, false);
|
|
LastMaterial = OverrideMaterial2D;
|
|
}
|
|
|
|
// no alphaChannel without texture
|
|
alphaChannel &= texture;
|
|
|
|
if (alpha || alphaChannel)
|
|
{
|
|
BridgeCalls->setBlend(true);
|
|
BridgeCalls->setBlendFunc(D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA);
|
|
}
|
|
else
|
|
BridgeCalls->setBlend(false);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
|
|
if (texture)
|
|
{
|
|
setTransform(ETS_TEXTURE_0, core::IdentityMatrix);
|
|
// Due to the transformation change, the previous line would call a reset each frame
|
|
// but we can safely reset the variable as it was false before
|
|
Transformation3DChanged=false;
|
|
}
|
|
if (alphaChannel)
|
|
{
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
|
|
|
|
if (alpha)
|
|
{
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
|
|
if (alpha)
|
|
{
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
|
|
}
|
|
else
|
|
{
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
|
|
pID3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
|
|
}
|
|
}
|
|
|
|
CurrentRenderMode = ERM_2D;
|
|
}
|
|
|
|
|
|
//! deletes all dynamic lights there are
|
|
void CD3D9Driver::deleteAllDynamicLights()
|
|
{
|
|
for (s32 i=0; i<LastSetLight+1; ++i)
|
|
pID3DDevice->LightEnable(i, false);
|
|
|
|
LastSetLight = -1;
|
|
|
|
CNullDriver::deleteAllDynamicLights();
|
|
}
|
|
|
|
|
|
//! adds a dynamic light
|
|
s32 CD3D9Driver::addDynamicLight(const SLight& dl)
|
|
{
|
|
CNullDriver::addDynamicLight(dl);
|
|
|
|
D3DLIGHT9 light;
|
|
|
|
switch (dl.Type)
|
|
{
|
|
case ELT_POINT:
|
|
light.Type = D3DLIGHT_POINT;
|
|
break;
|
|
case ELT_SPOT:
|
|
light.Type = D3DLIGHT_SPOT;
|
|
break;
|
|
case ELT_DIRECTIONAL:
|
|
light.Type = D3DLIGHT_DIRECTIONAL;
|
|
break;
|
|
}
|
|
|
|
light.Position = *(D3DVECTOR*)((void*)(&dl.Position));
|
|
light.Direction = *(D3DVECTOR*)((void*)(&dl.Direction));
|
|
|
|
light.Range = core::min_(dl.Radius, MaxLightDistance);
|
|
light.Falloff = dl.Falloff;
|
|
|
|
light.Diffuse = *(D3DCOLORVALUE*)((void*)(&dl.DiffuseColor));
|
|
light.Specular = *(D3DCOLORVALUE*)((void*)(&dl.SpecularColor));
|
|
light.Ambient = *(D3DCOLORVALUE*)((void*)(&dl.AmbientColor));
|
|
|
|
light.Attenuation0 = dl.Attenuation.X;
|
|
light.Attenuation1 = dl.Attenuation.Y;
|
|
light.Attenuation2 = dl.Attenuation.Z;
|
|
|
|
light.Theta = dl.InnerCone * 2.0f * core::DEGTORAD;
|
|
light.Phi = dl.OuterCone * 2.0f * core::DEGTORAD;
|
|
|
|
++LastSetLight;
|
|
|
|
if(D3D_OK == pID3DDevice->SetLight(LastSetLight, &light))
|
|
{
|
|
// I don't care if this succeeds
|
|
(void)pID3DDevice->LightEnable(LastSetLight, true);
|
|
return LastSetLight;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//! Turns a dynamic light on or off
|
|
//! \param lightIndex: the index returned by addDynamicLight
|
|
//! \param turnOn: true to turn the light on, false to turn it off
|
|
void CD3D9Driver::turnLightOn(s32 lightIndex, bool turnOn)
|
|
{
|
|
if(lightIndex < 0 || lightIndex > LastSetLight)
|
|
return;
|
|
|
|
(void)pID3DDevice->LightEnable(lightIndex, turnOn);
|
|
}
|
|
|
|
|
|
//! returns the maximal amount of dynamic lights the device can handle
|
|
u32 CD3D9Driver::getMaximalDynamicLightAmount() const
|
|
{
|
|
return Caps.MaxActiveLights;
|
|
}
|
|
|
|
|
|
//! Sets the dynamic ambient light color. The default color is
|
|
//! (0,0,0,0) which means it is dark.
|
|
//! \param color: New color of the ambient light.
|
|
void CD3D9Driver::setAmbientLight(const SColorf& color)
|
|
{
|
|
CNullDriver::setAmbientLight(color);
|
|
|
|
if (!pID3DDevice)
|
|
return;
|
|
|
|
D3DCOLOR col = color.toSColor().color;
|
|
pID3DDevice->SetRenderState(D3DRS_AMBIENT, col);
|
|
}
|
|
|
|
|
|
//! \return Returns the name of the video driver. Example: In case of the DIRECT3D9
|
|
//! driver, it would return "Direct3D9.0".
|
|
const wchar_t* CD3D9Driver::getName() const
|
|
{
|
|
return L"Direct3D 9.0";
|
|
}
|
|
|
|
|
|
//! Draws a shadow volume into the stencil buffer. To draw a stencil shadow, do
|
|
//! this: First, draw all geometry. Then use this method, to draw the shadow
|
|
//! volume. Then, use IVideoDriver::drawStencilShadow() to visualize the shadow.
|
|
void CD3D9Driver::drawStencilShadowVolume(const core::array<core::vector3df>& triangles, bool zfail, u32 debugDataVisible)
|
|
{
|
|
if (!Params.Stencilbuffer)
|
|
return;
|
|
|
|
setRenderStatesStencilShadowMode(zfail, debugDataVisible);
|
|
|
|
const u32 count = triangles.size();
|
|
if (!count)
|
|
return;
|
|
|
|
if (!zfail)
|
|
{
|
|
// ZPASS Method
|
|
|
|
// Draw front-side of shadow volume in stencil only
|
|
pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_INCR);
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles.const_pointer(), sizeof(core::vector3df));
|
|
|
|
// Now reverse cull order so front sides of shadow volume are written.
|
|
pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_DECR);
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles.const_pointer(), sizeof(core::vector3df));
|
|
}
|
|
else
|
|
{
|
|
// ZFAIL Method
|
|
|
|
// Draw front-side of shadow volume in stencil only
|
|
pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
|
|
pID3DDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_INCR);
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles.const_pointer(), sizeof(core::vector3df));
|
|
|
|
// Now reverse cull order so front sides of shadow volume are written.
|
|
pID3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW);
|
|
pID3DDevice->SetRenderState( D3DRS_STENCILZFAIL, D3DSTENCILOP_DECR);
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles.const_pointer(), sizeof(core::vector3df));
|
|
}
|
|
}
|
|
|
|
|
|
//! Fills the stencil shadow with color. After the shadow volume has been drawn
|
|
//! into the stencil buffer using IVideoDriver::drawStencilShadowVolume(), use this
|
|
//! to draw the color of the shadow.
|
|
void CD3D9Driver::drawStencilShadow(bool clearStencilBuffer, video::SColor leftUpEdge,
|
|
video::SColor rightUpEdge, video::SColor leftDownEdge, video::SColor rightDownEdge)
|
|
{
|
|
if (!Params.Stencilbuffer)
|
|
return;
|
|
|
|
S3DVertex vtx[4];
|
|
vtx[0] = S3DVertex(1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, leftUpEdge, 0.0f, 0.0f);
|
|
vtx[1] = S3DVertex(1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, rightUpEdge, 0.0f, 1.0f);
|
|
vtx[2] = S3DVertex(-1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, leftDownEdge, 1.0f, 0.0f);
|
|
vtx[3] = S3DVertex(-1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, rightDownEdge, 1.0f, 1.0f);
|
|
|
|
s16 indices[6] = {0,1,2,1,3,2};
|
|
|
|
setRenderStatesStencilFillMode(
|
|
leftUpEdge.getAlpha() < 255 ||
|
|
rightUpEdge.getAlpha() < 255 ||
|
|
leftDownEdge.getAlpha() < 255 ||
|
|
rightDownEdge.getAlpha() < 255);
|
|
|
|
setActiveTexture(0,0);
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
|
|
pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 4, 2, &indices[0],
|
|
D3DFMT_INDEX16, &vtx[0], sizeof(S3DVertex));
|
|
|
|
if (clearStencilBuffer)
|
|
pID3DDevice->Clear( 0, NULL, D3DCLEAR_STENCIL,0, 1.0, 0);
|
|
}
|
|
|
|
|
|
//! Returns the maximum amount of primitives (mostly vertices) which
|
|
//! the device is able to render with one drawIndexedTriangleList
|
|
//! call.
|
|
u32 CD3D9Driver::getMaximalPrimitiveCount() const
|
|
{
|
|
return Caps.MaxPrimitiveCount;
|
|
}
|
|
|
|
|
|
//! Sets the fog mode.
|
|
void CD3D9Driver::setFog(SColor color, E_FOG_TYPE fogType, f32 start,
|
|
f32 end, f32 density, bool pixelFog, bool rangeFog)
|
|
{
|
|
CNullDriver::setFog(color, fogType, start, end, density, pixelFog, rangeFog);
|
|
|
|
if (!pID3DDevice)
|
|
return;
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_FOGCOLOR, color.color);
|
|
|
|
pID3DDevice->SetRenderState(
|
|
pixelFog ? D3DRS_FOGTABLEMODE : D3DRS_FOGVERTEXMODE,
|
|
(fogType==EFT_FOG_LINEAR)? D3DFOG_LINEAR : (fogType==EFT_FOG_EXP)?D3DFOG_EXP:D3DFOG_EXP2);
|
|
|
|
if (fogType==EFT_FOG_LINEAR)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_FOGSTART, F2DW(start));
|
|
pID3DDevice->SetRenderState(D3DRS_FOGEND, F2DW(end));
|
|
}
|
|
else
|
|
pID3DDevice->SetRenderState(D3DRS_FOGDENSITY, F2DW(density));
|
|
|
|
if(!pixelFog)
|
|
pID3DDevice->SetRenderState(D3DRS_RANGEFOGENABLE, rangeFog);
|
|
}
|
|
|
|
|
|
//! Draws a 3d line.
|
|
void CD3D9Driver::draw3DLine(const core::vector3df& start,
|
|
const core::vector3df& end, SColor color)
|
|
{
|
|
setVertexShader(EVT_STANDARD);
|
|
setRenderStates3DMode();
|
|
video::S3DVertex v[2];
|
|
v[0].Color = color;
|
|
v[1].Color = color;
|
|
v[0].Pos = start;
|
|
v[1].Pos = end;
|
|
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_LINELIST, 1, v, sizeof(S3DVertex));
|
|
}
|
|
|
|
void CD3D9Driver::draw3DBox( const core::aabbox3d<f32>& box, SColor color)
|
|
{
|
|
core::vector3df edges[8];
|
|
box.getEdges(edges);
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
setRenderStates3DMode();
|
|
|
|
video::S3DVertex v[24];
|
|
|
|
for(u32 i = 0; i < 24; i++)
|
|
v[i].Color = color;
|
|
|
|
v[0].Pos = edges[5];
|
|
v[1].Pos = edges[1];
|
|
v[2].Pos = edges[1];
|
|
v[3].Pos = edges[3];
|
|
v[4].Pos = edges[3];
|
|
v[5].Pos = edges[7];
|
|
v[6].Pos = edges[7];
|
|
v[7].Pos = edges[5];
|
|
v[8].Pos = edges[0];
|
|
v[9].Pos = edges[2];
|
|
v[10].Pos = edges[2];
|
|
v[11].Pos = edges[6];
|
|
v[12].Pos = edges[6];
|
|
v[13].Pos = edges[4];
|
|
v[14].Pos = edges[4];
|
|
v[15].Pos = edges[0];
|
|
v[16].Pos = edges[1];
|
|
v[17].Pos = edges[0];
|
|
v[18].Pos = edges[3];
|
|
v[19].Pos = edges[2];
|
|
v[20].Pos = edges[7];
|
|
v[21].Pos = edges[6];
|
|
v[22].Pos = edges[5];
|
|
v[23].Pos = edges[4];
|
|
|
|
pID3DDevice->DrawPrimitiveUP(D3DPT_LINELIST, 12, v, sizeof(S3DVertex));
|
|
}
|
|
|
|
bool CD3D9Driver::retrieveDevice(int numTries, int msSleepBetweenTries)
|
|
{
|
|
while ( numTries > 0)
|
|
{
|
|
HRESULT hr;
|
|
if ( FAILED(hr = pID3DDevice->TestCooperativeLevel()) )
|
|
{
|
|
// hr can be: D3DERR_DEVICELOST, D3DERR_DEVICENOTRESET or D3DERR_DRIVERINTERNALERROR
|
|
switch ( hr )
|
|
{
|
|
case D3DERR_DEVICENOTRESET:
|
|
if ( reset() )
|
|
return true;
|
|
// when reset fails, just try again, maybe device got lost in between TestCooperativeLevel and reset calls?
|
|
break;
|
|
case D3DERR_DEVICELOST:
|
|
break;
|
|
case D3DERR_DRIVERINTERNALERROR:
|
|
return false;
|
|
}
|
|
|
|
Sleep(msSleepBetweenTries);
|
|
--numTries;
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//! resets the device
|
|
bool CD3D9Driver::reset()
|
|
{
|
|
os::Printer::log("Resetting D3D9 device.", ELL_INFORMATION);
|
|
|
|
for (u32 i = 0; i<RenderTargets.size(); ++i)
|
|
{
|
|
if (RenderTargets[i]->getDriverType() == EDT_DIRECT3D9)
|
|
{
|
|
static_cast<CD3D9RenderTarget*>(RenderTargets[i])->releaseSurfaces();
|
|
|
|
const core::array<ITexture*> texArray = RenderTargets[i]->getTexture();
|
|
|
|
for (u32 j = 0; j < texArray.size(); ++j)
|
|
{
|
|
CD3D9Texture* tex = static_cast<CD3D9Texture*>(texArray[j]);
|
|
|
|
if (tex)
|
|
tex->releaseTexture();
|
|
}
|
|
|
|
CD3D9Texture* tex = static_cast<CD3D9Texture*>(RenderTargets[i]->getDepthStencil());
|
|
|
|
if (tex)
|
|
tex->releaseTexture();
|
|
}
|
|
}
|
|
for (u32 i=0; i<Textures.size(); ++i)
|
|
{
|
|
if (Textures[i].Surface->isRenderTarget())
|
|
{
|
|
CD3D9Texture* tex = static_cast<CD3D9Texture*>(Textures[i].Surface);
|
|
|
|
if (tex)
|
|
tex->releaseTexture();
|
|
}
|
|
}
|
|
for (u32 i=0; i<OcclusionQueries.size(); ++i)
|
|
{
|
|
if (OcclusionQueries[i].PID)
|
|
{
|
|
reinterpret_cast<IDirect3DQuery9*>(OcclusionQueries[i].PID)->Release();
|
|
OcclusionQueries[i].PID=0;
|
|
}
|
|
}
|
|
// this does not require a restore in the reset method, it's updated
|
|
// automatically in the next render cycle.
|
|
removeAllHardwareBuffers();
|
|
|
|
// reset render target usage information.
|
|
for (u32 i = 0; i < ActiveRenderTarget.size(); ++i)
|
|
ActiveRenderTarget[i] = false;
|
|
|
|
if (DepthStencilSurface)
|
|
{
|
|
DepthStencilSurface->Release();
|
|
DepthStencilSurface = 0;
|
|
}
|
|
|
|
if (BackBufferSurface)
|
|
{
|
|
BackBufferSurface->Release();
|
|
BackBufferSurface = 0;
|
|
}
|
|
|
|
DriverWasReset=true;
|
|
|
|
HRESULT hr = pID3DDevice->Reset(&present);
|
|
if (FAILED(hr))
|
|
{
|
|
if (hr == D3DERR_DEVICELOST)
|
|
{
|
|
DeviceLost = true;
|
|
os::Printer::log("Resetting failed due to device lost.", ELL_WARNING);
|
|
}
|
|
#ifdef D3DERR_DEVICEREMOVED
|
|
else if (hr == D3DERR_DEVICEREMOVED)
|
|
{
|
|
os::Printer::log("Resetting failed due to device removed.", ELL_WARNING);
|
|
}
|
|
#endif
|
|
else if (hr == D3DERR_DRIVERINTERNALERROR)
|
|
{
|
|
os::Printer::log("Resetting failed due to internal error.", ELL_WARNING);
|
|
}
|
|
else if (hr == D3DERR_OUTOFVIDEOMEMORY)
|
|
{
|
|
os::Printer::log("Resetting failed due to out of memory.", ELL_WARNING);
|
|
}
|
|
else if (hr == D3DERR_DEVICENOTRESET)
|
|
{
|
|
os::Printer::log("Resetting failed due to not reset.", ELL_WARNING);
|
|
}
|
|
else if (hr == D3DERR_INVALIDCALL)
|
|
{
|
|
os::Printer::log("Resetting failed due to invalid call", "You need to release some more surfaces.", ELL_WARNING);
|
|
}
|
|
else
|
|
{
|
|
os::Printer::log("Resetting failed due to unknown reason.", core::stringc((int)hr).c_str(), ELL_WARNING);
|
|
}
|
|
return false;
|
|
}
|
|
DeviceLost = false;
|
|
|
|
// reset bridge calls.
|
|
if (BridgeCalls)
|
|
BridgeCalls->reset();
|
|
|
|
// restore screen depthbuffer descriptor
|
|
if (!SUCCEEDED(pID3DDevice->GetDepthStencilSurface(&DepthStencilSurface)))
|
|
{
|
|
os::Printer::log("Was not able to get main depth buffer.", ELL_ERROR);
|
|
return false;
|
|
}
|
|
|
|
// restore RTTs
|
|
for (u32 i=0; i<Textures.size(); ++i)
|
|
{
|
|
if (Textures[i].Surface->isRenderTarget())
|
|
((CD3D9Texture*)(Textures[i].Surface))->generateRenderTarget();
|
|
}
|
|
for (u32 i = 0; i<RenderTargets.size(); ++i)
|
|
{
|
|
if (RenderTargets[i]->getDriverType() == EDT_DIRECT3D9)
|
|
{
|
|
const core::array<ITexture*> texArray = RenderTargets[i]->getTexture();
|
|
|
|
for (u32 j = 0; j < texArray.size(); ++j)
|
|
{
|
|
CD3D9Texture* tex = static_cast<CD3D9Texture*>(texArray[j]);
|
|
|
|
if (tex)
|
|
tex->generateRenderTarget();
|
|
}
|
|
|
|
CD3D9Texture* tex = static_cast<CD3D9Texture*>(RenderTargets[i]->getDepthStencil());
|
|
|
|
if (tex)
|
|
tex->generateRenderTarget();
|
|
|
|
static_cast<CD3D9RenderTarget*>(RenderTargets[i])->generateSurfaces();
|
|
}
|
|
}
|
|
|
|
// restore occlusion queries
|
|
for (u32 i=0; i<OcclusionQueries.size(); ++i)
|
|
{
|
|
pID3DDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, reinterpret_cast<IDirect3DQuery9**>(&OcclusionQueries[i].PID));
|
|
}
|
|
|
|
ResetRenderStates = true;
|
|
LastVertexType = (E_VERTEX_TYPE)-1;
|
|
|
|
for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
|
|
CurrentTexture[i] = 0;
|
|
|
|
setVertexShader(EVT_STANDARD);
|
|
setRenderStates3DMode();
|
|
setFog(FogColor, FogType, FogStart, FogEnd, FogDensity, PixelFog, RangeFog);
|
|
setAmbientLight(getAmbientLight());
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void CD3D9Driver::OnResize(const core::dimension2d<u32>& size)
|
|
{
|
|
if (!pID3DDevice)
|
|
return;
|
|
|
|
CNullDriver::OnResize(size);
|
|
present.BackBufferWidth = size.Width;
|
|
present.BackBufferHeight = size.Height;
|
|
|
|
if ( !reset() )
|
|
{
|
|
if ( !retrieveDevice(20, 200) ) // retrying for 3 seconds, I hope that's long enough?
|
|
{
|
|
os::Printer::log("Failed to retrieve device in OnResize.", ELL_ERROR);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//! Returns type of video driver
|
|
E_DRIVER_TYPE CD3D9Driver::getDriverType() const
|
|
{
|
|
return EDT_DIRECT3D9;
|
|
}
|
|
|
|
|
|
//! Returns the transformation set by setTransform
|
|
const core::matrix4& CD3D9Driver::getTransform(E_TRANSFORMATION_STATE state) const
|
|
{
|
|
return Matrices[state];
|
|
}
|
|
|
|
|
|
//! Get a vertex shader constant index.
|
|
s32 CD3D9Driver::getVertexShaderConstantID(const c8* name)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->getVariableID(true, name);
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//! Get a pixel shader constant index.
|
|
s32 CD3D9Driver::getPixelShaderConstantID(const c8* name)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->getVariableID(false, name);
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
//! Sets a vertex shader constant.
|
|
void CD3D9Driver::setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)
|
|
{
|
|
if (data)
|
|
pID3DDevice->SetVertexShaderConstantF(startRegister, data, constantAmount);
|
|
}
|
|
|
|
|
|
//! Sets a pixel shader constant.
|
|
void CD3D9Driver::setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)
|
|
{
|
|
if (data)
|
|
pID3DDevice->SetPixelShaderConstantF(startRegister, data, constantAmount);
|
|
}
|
|
|
|
|
|
//! Sets a constant for the vertex shader based on an index.
|
|
bool CD3D9Driver::setVertexShaderConstant(s32 index, const f32* floats, int count)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->setVariable(true, index, floats, count);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//! Int interface for the above.
|
|
bool CD3D9Driver::setVertexShaderConstant(s32 index, const s32* ints, int count)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->setVariable(true, index, ints, count);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//! Uint interface for the above.
|
|
bool CD3D9Driver::setVertexShaderConstant(s32 index, const u32* ints, int count)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->setVariable(true, index, ints, count);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//! Sets a constant for the pixel shader based on an index.
|
|
bool CD3D9Driver::setPixelShaderConstant(s32 index, const f32* floats, int count)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->setVariable(false, index, floats, count);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//! Int interface for the above.
|
|
bool CD3D9Driver::setPixelShaderConstant(s32 index, const s32* ints, int count)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->setVariable(false, index, ints, count);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//! Uint interface for the above.
|
|
bool CD3D9Driver::setPixelShaderConstant(s32 index, const u32* ints, int count)
|
|
{
|
|
if (Material.MaterialType >= 0 && Material.MaterialType < (s32)MaterialRenderers.size())
|
|
{
|
|
CD3D9MaterialRenderer* r = (CD3D9MaterialRenderer*)MaterialRenderers[Material.MaterialType].Renderer;
|
|
return r->setVariable(false, index, ints, count);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
//! Adds a new material renderer to the VideoDriver, using pixel and/or
|
|
//! vertex shaders to render geometry.
|
|
s32 CD3D9Driver::addShaderMaterial(const c8* vertexShaderProgram,
|
|
const c8* pixelShaderProgram,
|
|
IShaderConstantSetCallBack* callback,
|
|
E_MATERIAL_TYPE baseMaterial, s32 userData)
|
|
{
|
|
s32 nr = -1;
|
|
CD3D9ShaderMaterialRenderer* r = new CD3D9ShaderMaterialRenderer(
|
|
pID3DDevice, this, nr, vertexShaderProgram, pixelShaderProgram,
|
|
callback, getMaterialRenderer(baseMaterial), userData);
|
|
|
|
r->drop();
|
|
return nr;
|
|
}
|
|
|
|
|
|
//! Adds a new material renderer to the VideoDriver, based on a high level shading
|
|
//! language.
|
|
s32 CD3D9Driver::addHighLevelShaderMaterial(
|
|
const c8* vertexShaderProgram,
|
|
const c8* vertexShaderEntryPointName,
|
|
E_VERTEX_SHADER_TYPE vsCompileTarget,
|
|
const c8* pixelShaderProgram,
|
|
const c8* pixelShaderEntryPointName,
|
|
E_PIXEL_SHADER_TYPE psCompileTarget,
|
|
const c8* geometryShaderProgram,
|
|
const c8* geometryShaderEntryPointName,
|
|
E_GEOMETRY_SHADER_TYPE gsCompileTarget,
|
|
scene::E_PRIMITIVE_TYPE inType, scene::E_PRIMITIVE_TYPE outType,
|
|
u32 verticesOut,
|
|
IShaderConstantSetCallBack* callback,
|
|
E_MATERIAL_TYPE baseMaterial, s32 userData)
|
|
{
|
|
s32 nr = -1;
|
|
|
|
CD3D9HLSLMaterialRenderer* r = new CD3D9HLSLMaterialRenderer(
|
|
pID3DDevice, this, nr,
|
|
vertexShaderProgram,
|
|
vertexShaderEntryPointName,
|
|
vsCompileTarget,
|
|
pixelShaderProgram,
|
|
pixelShaderEntryPointName,
|
|
psCompileTarget,
|
|
callback,
|
|
getMaterialRenderer(baseMaterial),
|
|
userData);
|
|
|
|
r->drop();
|
|
|
|
return nr;
|
|
}
|
|
|
|
|
|
//! Returns a pointer to the IVideoDriver interface. (Implementation for
|
|
//! IMaterialRendererServices)
|
|
IVideoDriver* CD3D9Driver::getVideoDriver()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
|
|
//! Creates a render target texture.
|
|
ITexture* CD3D9Driver::addRenderTargetTexture(const core::dimension2d<u32>& size,
|
|
const io::path& name,
|
|
const ECOLOR_FORMAT format)
|
|
{
|
|
if ( IImage::isCompressedFormat(format) )
|
|
return 0;
|
|
|
|
CD3D9Texture* tex = new CD3D9Texture(this, size, name, ETT_2D, format);
|
|
if (tex)
|
|
{
|
|
if (!tex->Texture)
|
|
{
|
|
tex->drop();
|
|
return 0;
|
|
}
|
|
|
|
addTexture(tex);
|
|
tex->drop();
|
|
}
|
|
return tex;
|
|
}
|
|
|
|
ITexture* CD3D9Driver::addRenderTargetTextureCubemap(const irr::u32 sideLen,
|
|
const io::path& name, const ECOLOR_FORMAT format)
|
|
{
|
|
if ( IImage::isCompressedFormat(format) )
|
|
return 0;
|
|
|
|
CD3D9Texture* tex = new CD3D9Texture(this, core::dimension2d<u32>(sideLen, sideLen), name, ETT_CUBEMAP, format);
|
|
if (tex)
|
|
{
|
|
if (!tex->CubeTexture)
|
|
{
|
|
tex->drop();
|
|
return 0;
|
|
}
|
|
|
|
addTexture(tex);
|
|
tex->drop();
|
|
}
|
|
return tex;
|
|
}
|
|
|
|
void CD3D9Driver::clearBuffers(u16 flag, SColor color, f32 depth, u8 stencil)
|
|
{
|
|
DWORD internalFlag = 0;
|
|
|
|
if (flag & ECBF_COLOR)
|
|
internalFlag |= D3DCLEAR_TARGET;
|
|
|
|
if (flag & ECBF_DEPTH)
|
|
internalFlag |= D3DCLEAR_ZBUFFER;
|
|
|
|
if (flag & ECBF_STENCIL)
|
|
internalFlag |= D3DCLEAR_STENCIL;
|
|
|
|
if (internalFlag)
|
|
{
|
|
HRESULT hr = pID3DDevice->Clear(0, NULL, internalFlag, color.color, depth, stencil);
|
|
|
|
if (FAILED(hr))
|
|
os::Printer::log("DIRECT3D9 clear failed.", ELL_WARNING);
|
|
}
|
|
}
|
|
|
|
|
|
//! Returns an image created from the last rendered frame.
|
|
IImage* CD3D9Driver::createScreenShot(video::ECOLOR_FORMAT format, video::E_RENDER_TARGET target)
|
|
{
|
|
if (target != video::ERT_FRAME_BUFFER)
|
|
return 0;
|
|
|
|
if (format==video::ECF_UNKNOWN)
|
|
format=getColorFormat();
|
|
|
|
// TODO: Maybe we could support more formats (floating point and some of those beyond ECF_R8), didn't really try yet
|
|
if (IImage::isCompressedFormat(format) || IImage::isDepthFormat(format) || IImage::isFloatingPointFormat(format) || format >= ECF_R8)
|
|
return 0;
|
|
|
|
// query the screen dimensions of the current adapter
|
|
D3DDISPLAYMODE displayMode;
|
|
pID3DDevice->GetDisplayMode(0, &displayMode);
|
|
|
|
// create the image surface to store the front buffer image [always A8R8G8B8]
|
|
HRESULT hr;
|
|
LPDIRECT3DSURFACE9 lpSurface;
|
|
if (FAILED(hr = pID3DDevice->CreateOffscreenPlainSurface(displayMode.Width, displayMode.Height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &lpSurface, 0)))
|
|
return 0;
|
|
|
|
// read the front buffer into the image surface
|
|
if (FAILED(hr = pID3DDevice->GetFrontBufferData(0, lpSurface)))
|
|
{
|
|
lpSurface->Release();
|
|
return 0;
|
|
}
|
|
|
|
RECT clientRect;
|
|
{
|
|
POINT clientPoint;
|
|
clientPoint.x = 0;
|
|
clientPoint.y = 0;
|
|
|
|
ClientToScreen((HWND)getExposedVideoData().D3D9.HWnd, &clientPoint);
|
|
|
|
clientRect.left = clientPoint.x;
|
|
clientRect.top = clientPoint.y;
|
|
clientRect.right = clientRect.left + ScreenSize.Width;
|
|
clientRect.bottom = clientRect.top + ScreenSize.Height;
|
|
|
|
// window can be off-screen partly, we can't take screenshots from that
|
|
clientRect.left = core::max_(clientRect.left, 0l);
|
|
clientRect.top = core::max_(clientRect.top, 0l);
|
|
clientRect.right = core::min_(clientRect.right, (long)displayMode.Width);
|
|
clientRect.bottom = core::min_(clientRect.bottom, (long)displayMode.Height );
|
|
}
|
|
|
|
// lock our area of the surface
|
|
D3DLOCKED_RECT lockedRect;
|
|
if (FAILED(lpSurface->LockRect(&lockedRect, &clientRect, D3DLOCK_READONLY)))
|
|
{
|
|
lpSurface->Release();
|
|
return 0;
|
|
}
|
|
|
|
irr::core::dimension2d<u32> shotSize;
|
|
shotSize.Width = core::min_( ScreenSize.Width, (u32)(clientRect.right-clientRect.left) );
|
|
shotSize.Height = core::min_( ScreenSize.Height, (u32)(clientRect.bottom-clientRect.top) );
|
|
|
|
// this could throw, but we aren't going to worry about that case very much
|
|
IImage* newImage = createImage(format, shotSize);
|
|
|
|
if (newImage)
|
|
{
|
|
// d3d pads the image, so we need to copy the correct number of bytes
|
|
u32* dP = (u32*)newImage->lock();
|
|
u8 * sP = (u8 *)lockedRect.pBits;
|
|
|
|
// If the display mode format doesn't promise anything about the Alpha value
|
|
// and it appears that it's not presenting 255, then we should manually
|
|
// set each pixel alpha value to 255.
|
|
if (D3DFMT_X8R8G8B8 == displayMode.Format && (0xFF000000 != (*dP & 0xFF000000)))
|
|
{
|
|
for (u32 y = 0; y < shotSize.Height; ++y)
|
|
{
|
|
for (u32 x = 0; x < shotSize.Width; ++x)
|
|
{
|
|
newImage->setPixel(x,y,*((u32*)sP) | 0xFF000000);
|
|
sP += 4;
|
|
}
|
|
|
|
sP += lockedRect.Pitch - (4 * shotSize.Width);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (u32 y = 0; y < shotSize.Height; ++y)
|
|
{
|
|
convertColor(sP, video::ECF_A8R8G8B8, shotSize.Width, dP, format);
|
|
sP += lockedRect.Pitch;
|
|
dP += shotSize.Width;
|
|
}
|
|
}
|
|
|
|
newImage->unlock();
|
|
}
|
|
|
|
// we can unlock and release the surface
|
|
lpSurface->UnlockRect();
|
|
|
|
// release the image surface
|
|
lpSurface->Release();
|
|
|
|
// return status of save operation to caller
|
|
return newImage;
|
|
}
|
|
|
|
|
|
//! returns color format
|
|
ECOLOR_FORMAT CD3D9Driver::getColorFormat() const
|
|
{
|
|
return ColorFormat;
|
|
}
|
|
|
|
|
|
//! returns color format
|
|
D3DFORMAT CD3D9Driver::getD3DColorFormat() const
|
|
{
|
|
return D3DColorFormat;
|
|
}
|
|
|
|
|
|
// Set/unset a clipping plane.
|
|
bool CD3D9Driver::setClipPlane(u32 index, const core::plane3df& plane, bool enable)
|
|
{
|
|
if (index >= MaxUserClipPlanes)
|
|
return false;
|
|
|
|
HRESULT ok = pID3DDevice->SetClipPlane(index, (const float*)&(plane.Normal.X));
|
|
if (D3D_OK == ok)
|
|
enableClipPlane(index, enable);
|
|
return true;
|
|
}
|
|
|
|
|
|
// Enable/disable a clipping plane.
|
|
void CD3D9Driver::enableClipPlane(u32 index, bool enable)
|
|
{
|
|
if (index >= MaxUserClipPlanes)
|
|
return;
|
|
DWORD renderstate;
|
|
HRESULT ok = pID3DDevice->GetRenderState(D3DRS_CLIPPLANEENABLE, &renderstate);
|
|
if (S_OK == ok)
|
|
{
|
|
if (enable)
|
|
renderstate |= (1 << index);
|
|
else
|
|
renderstate &= ~(1 << index);
|
|
ok = pID3DDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, renderstate);
|
|
}
|
|
}
|
|
|
|
|
|
D3DFORMAT CD3D9Driver::getD3DFormatFromColorFormat(ECOLOR_FORMAT format) const
|
|
{
|
|
switch(format)
|
|
{
|
|
case ECF_A1R5G5B5:
|
|
return D3DFMT_A1R5G5B5;
|
|
case ECF_R5G6B5:
|
|
return D3DFMT_R5G6B5;
|
|
case ECF_R8G8B8:
|
|
return D3DFMT_R8G8B8;
|
|
case ECF_A8R8G8B8:
|
|
return D3DFMT_A8R8G8B8;
|
|
|
|
case ECF_DXT1:
|
|
return D3DFMT_DXT1;
|
|
case ECF_DXT2:
|
|
return D3DFMT_DXT2;
|
|
case ECF_DXT3:
|
|
return D3DFMT_DXT3;
|
|
case ECF_DXT4:
|
|
return D3DFMT_DXT4;
|
|
case ECF_DXT5:
|
|
return D3DFMT_DXT5;
|
|
case ECF_R16F:
|
|
return D3DFMT_R16F;
|
|
case ECF_G16R16F:
|
|
return D3DFMT_G16R16F;
|
|
case ECF_A16B16G16R16F:
|
|
return D3DFMT_A16B16G16R16F;
|
|
case ECF_R32F:
|
|
return D3DFMT_R32F;
|
|
case ECF_G32R32F:
|
|
return D3DFMT_G32R32F;
|
|
case ECF_A32B32G32R32F:
|
|
return D3DFMT_A32B32G32R32F;
|
|
|
|
case ECF_R8:
|
|
return D3DFMT_A8; // not correct, but somewhat similar
|
|
case ECF_R8G8:
|
|
return D3DFMT_A8L8; // not correct, but somewhat similar
|
|
case ECF_R16:
|
|
return D3DFMT_L16; // not correct, but somewhat similar
|
|
case ECF_R16G16:
|
|
return D3DFMT_G16R16; // flipped :-(
|
|
|
|
case ECF_D16:
|
|
return D3DFMT_D16;
|
|
case ECF_D24S8:
|
|
return D3DFMT_D24S8;
|
|
case ECF_D32:
|
|
return D3DFMT_D32;
|
|
}
|
|
return D3DFMT_UNKNOWN;
|
|
}
|
|
|
|
|
|
ECOLOR_FORMAT CD3D9Driver::getColorFormatFromD3DFormat(D3DFORMAT format) const
|
|
{
|
|
switch(format)
|
|
{
|
|
case D3DFMT_X1R5G5B5:
|
|
case D3DFMT_A1R5G5B5:
|
|
return ECF_A1R5G5B5;
|
|
case D3DFMT_A8B8G8R8:
|
|
case D3DFMT_A8R8G8B8:
|
|
case D3DFMT_X8R8G8B8:
|
|
return ECF_A8R8G8B8;
|
|
case D3DFMT_R5G6B5:
|
|
return ECF_R5G6B5;
|
|
case D3DFMT_R8G8B8:
|
|
return ECF_R8G8B8;
|
|
|
|
// Floating Point formats. Thanks to Patryk "Nadro" Nadrowski.
|
|
case D3DFMT_R16F:
|
|
return ECF_R16F;
|
|
case D3DFMT_G16R16F:
|
|
return ECF_G16R16F;
|
|
case D3DFMT_A16B16G16R16F:
|
|
return ECF_A16B16G16R16F;
|
|
case D3DFMT_R32F:
|
|
return ECF_R32F;
|
|
case D3DFMT_G32R32F:
|
|
return ECF_G32R32F;
|
|
case D3DFMT_A32B32G32R32F:
|
|
return ECF_A32B32G32R32F;
|
|
default:
|
|
return (ECOLOR_FORMAT)0;
|
|
};
|
|
}
|
|
|
|
|
|
core::dimension2du CD3D9Driver::getMaxTextureSize() const
|
|
{
|
|
return core::dimension2du(Caps.MaxTextureWidth, Caps.MaxTextureHeight);
|
|
}
|
|
|
|
bool CD3D9Driver::queryTextureFormat(ECOLOR_FORMAT format) const
|
|
{
|
|
return getD3DFormatFromColorFormat(format) != D3DFMT_UNKNOWN;
|
|
}
|
|
|
|
bool CD3D9Driver::needsTransparentRenderPass(const irr::video::SMaterial& material) const
|
|
{
|
|
return CNullDriver::needsTransparentRenderPass(material) || material.isAlphaBlendOperation();
|
|
}
|
|
|
|
u32 CD3D9Driver::getD3DBlend(E_BLEND_FACTOR factor) const
|
|
{
|
|
u32 r = 0;
|
|
switch (factor)
|
|
{
|
|
case EBF_ZERO: r = D3DBLEND_ZERO; break;
|
|
case EBF_ONE: r = D3DBLEND_ONE; break;
|
|
case EBF_DST_COLOR: r = D3DBLEND_DESTCOLOR; break;
|
|
case EBF_ONE_MINUS_DST_COLOR: r = D3DBLEND_INVDESTCOLOR; break;
|
|
case EBF_SRC_COLOR: r = D3DBLEND_SRCCOLOR; break;
|
|
case EBF_ONE_MINUS_SRC_COLOR: r = D3DBLEND_INVSRCCOLOR; break;
|
|
case EBF_SRC_ALPHA: r = D3DBLEND_SRCALPHA; break;
|
|
case EBF_ONE_MINUS_SRC_ALPHA: r = D3DBLEND_INVSRCALPHA; break;
|
|
case EBF_DST_ALPHA: r = D3DBLEND_DESTALPHA; break;
|
|
case EBF_ONE_MINUS_DST_ALPHA: r = D3DBLEND_INVDESTALPHA; break;
|
|
case EBF_SRC_ALPHA_SATURATE: r = D3DBLEND_SRCALPHASAT; break;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
u32 CD3D9Driver::getD3DModulate(E_MODULATE_FUNC func) const
|
|
{
|
|
u32 r = D3DTOP_MODULATE;
|
|
switch (func)
|
|
{
|
|
case EMFN_MODULATE_1X: r = D3DTOP_MODULATE; break;
|
|
case EMFN_MODULATE_2X: r = D3DTOP_MODULATE2X; break;
|
|
case EMFN_MODULATE_4X: r = D3DTOP_MODULATE4X; break;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
CD3D9CallBridge* CD3D9Driver::getBridgeCalls() const
|
|
{
|
|
return BridgeCalls;
|
|
}
|
|
|
|
CD3D9CallBridge::CD3D9CallBridge(IDirect3DDevice9* p, CD3D9Driver* driver) : pID3DDevice(p),
|
|
BlendOperation(D3DBLENDOP_ADD), BlendSourceRGB(D3DBLEND_ONE), BlendDestinationRGB(D3DBLEND_ZERO),
|
|
BlendSourceAlpha(D3DBLEND_ONE), BlendDestinationAlpha(D3DBLEND_ZERO), Blend(false), BlendSeparate(false),
|
|
FeatureBlendSeparate(false)
|
|
{
|
|
FeatureBlendSeparate = driver->queryFeature(EVDF_BLEND_SEPARATE);
|
|
|
|
reset();
|
|
}
|
|
|
|
void CD3D9CallBridge::reset()
|
|
{
|
|
BlendOperation = D3DBLENDOP_ADD;
|
|
|
|
BlendSourceRGB = D3DBLEND_ONE;
|
|
BlendDestinationRGB = D3DBLEND_ZERO;
|
|
BlendSourceAlpha = D3DBLEND_ONE;
|
|
BlendDestinationAlpha = D3DBLEND_ZERO;
|
|
|
|
Blend = false;
|
|
BlendSeparate = false;
|
|
|
|
pID3DDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
|
|
pID3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
|
|
pID3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);
|
|
pID3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
|
|
|
|
if (FeatureBlendSeparate)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SRCBLENDALPHA, D3DBLEND_ONE);
|
|
pID3DDevice->SetRenderState(D3DRS_DESTBLENDALPHA, D3DBLEND_ZERO);
|
|
pID3DDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
|
|
}
|
|
}
|
|
|
|
void CD3D9CallBridge::setBlendOperation(DWORD mode)
|
|
{
|
|
if (BlendOperation != mode)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_BLENDOP, mode);
|
|
|
|
BlendOperation = mode;
|
|
}
|
|
}
|
|
|
|
void CD3D9CallBridge::setBlendFunc(DWORD source, DWORD destination)
|
|
{
|
|
if (BlendSourceRGB != source)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SRCBLEND, source);
|
|
|
|
BlendSourceRGB = source;
|
|
}
|
|
|
|
if (BlendDestinationRGB != destination)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_DESTBLEND, destination);
|
|
|
|
BlendDestinationRGB = destination;
|
|
}
|
|
|
|
if (FeatureBlendSeparate && BlendSeparate)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
|
|
|
|
BlendSeparate = false;
|
|
}
|
|
}
|
|
|
|
void CD3D9CallBridge::setBlendFuncSeparate(DWORD sourceRGB, DWORD destinationRGB, DWORD sourceAlpha, DWORD destinationAlpha)
|
|
{
|
|
if (BlendSourceRGB != sourceRGB)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SRCBLEND, sourceRGB);
|
|
|
|
BlendSourceRGB = sourceRGB;
|
|
}
|
|
|
|
if (BlendDestinationRGB != destinationRGB)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_DESTBLEND, destinationRGB);
|
|
|
|
BlendDestinationRGB = destinationRGB;
|
|
}
|
|
|
|
if (FeatureBlendSeparate)
|
|
{
|
|
if (sourceRGB != sourceAlpha || destinationRGB != destinationAlpha)
|
|
{
|
|
if (BlendSourceAlpha != sourceAlpha)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SRCBLENDALPHA, sourceAlpha);
|
|
|
|
BlendSourceAlpha = sourceAlpha;
|
|
}
|
|
|
|
if (BlendDestinationAlpha != destinationAlpha)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_DESTBLENDALPHA, destinationAlpha);
|
|
|
|
BlendDestinationAlpha = destinationAlpha;
|
|
}
|
|
|
|
if (!BlendSeparate)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
|
|
|
|
BlendSeparate = true;
|
|
}
|
|
}
|
|
else if (BlendSeparate)
|
|
{
|
|
pID3DDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
|
|
|
|
BlendSeparate = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CD3D9CallBridge::setBlend(bool enable)
|
|
{
|
|
if (Blend != enable)
|
|
{
|
|
if (enable)
|
|
pID3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
|
|
else
|
|
pID3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
|
|
|
|
Blend = enable;
|
|
}
|
|
}
|
|
|
|
} // end namespace video
|
|
} // end namespace irr
|
|
|
|
#endif // _IRR_COMPILE_WITH_DIRECT3D_9_
|
|
|
|
|
|
|
|
namespace irr
|
|
{
|
|
namespace video
|
|
{
|
|
|
|
#ifdef _IRR_COMPILE_WITH_DIRECT3D_9_
|
|
//! creates a video driver
|
|
IVideoDriver* createDirectX9Driver(const SIrrlichtCreationParameters& params,
|
|
io::IFileSystem* io, HWND window)
|
|
{
|
|
const bool pureSoftware = false;
|
|
CD3D9Driver* dx9 = new CD3D9Driver(params, io);
|
|
if (!dx9->initDriver(window, pureSoftware))
|
|
{
|
|
dx9->drop();
|
|
dx9 = 0;
|
|
}
|
|
|
|
return dx9;
|
|
}
|
|
#endif // _IRR_COMPILE_WITH_DIRECT3D_9_
|
|
|
|
} // end namespace video
|
|
} // end namespace irr
|
|
|