/* CDirect3D::ResetDevice
resets the device
called if surface was lost or the settings/display size require a device reset
-----
returns true if successful, false otherwise
*/
bool CDirect3D::ResetDevice()
{
if(!init_done) return false;
HRESULT hr;
//release prior to reset
DestroyDrawSurface();
if(cgAvailable) {
cgShader->OnLostDevice();
cgD3D9SetDevice(NULL);
}
//zero or unknown values result in the current window size/display settings
dPresentParams.BackBufferWidth = 0;
dPresentParams.BackBufferHeight = 0;
dPresentParams.BackBufferCount = GUI.DoubleBuffered?2:1;
dPresentParams.BackBufferFormat = D3DFMT_UNKNOWN;
dPresentParams.FullScreen_RefreshRateInHz = 0;
dPresentParams.Windowed = true;
dPresentParams.PresentationInterval = GUI.Vsync?D3DPRESENT_INTERVAL_ONE:D3DPRESENT_INTERVAL_IMMEDIATE;
dPresentParams.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
if(fullscreen) {
dPresentParams.BackBufferWidth = GUI.FullscreenMode.width;
dPresentParams.BackBufferHeight = GUI.FullscreenMode.height;
dPresentParams.BackBufferCount = GUI.DoubleBuffered?2:1;
dPresentParams.Windowed = false;
if(GUI.FullscreenMode.depth == 32)
dPresentParams.BackBufferFormat = D3DFMT_X8R8G8B8;
else
dPresentParams.BackBufferFormat = D3DFMT_R5G6B5;
dPresentParams.FullScreen_RefreshRateInHz = GUI.FullscreenMode.rate;
}
if(FAILED(hr = pDevice->Reset(&dPresentParams))) {
DXTRACE_ERR(TEXT("Unable to reset device"), hr);
return false;
}
if(cgAvailable) {
cgD3D9SetDevice(pDevice);
cgShader->OnResetDevice();
}
pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
pDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
//recreate the surface
CreateDrawSurface();
SetViewport();
return true;
}
static bool d3d_init_shader(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
(void)d3d;
(void)data;
#if defined(HAVE_HLSL)
RARCH_LOG("D3D]: Using HLSL shader backend.\n");
const shader_backend_t *backend = &hlsl_backend;
const char *shader_path = g_settings.video.shader_path;
d3d->shader = backend;
if (!d3d->shader)
return false;
return d3d->shader->init(d3d, shader_path);
#elif defined(HAVE_CG)
d3d->cgCtx = cgCreateContext();
if (!d3d->cgCtx)
return false;
RARCH_LOG("[D3D]: Created shader context.\n");
HRESULT ret = cgD3D9SetDevice(d3d->dev);
if (FAILED(ret))
return false;
return true;
#elif defined(_XBOX1)
return false;
#endif
}
static void d3d9_cg_destroy_resources(void *data)
{
unsigned i;
cg_renderchain_t *cg_data = (cg_renderchain_t*)data;
for (i = 0; i < TEXTURES; i++)
{
if (cg_data->prev.tex[i])
d3d_texture_free(cg_data->prev.tex[i]);
if (cg_data->prev.vertex_buf[i])
d3d_vertex_buffer_free(cg_data->prev.vertex_buf[i], NULL);
}
d3d9_cg_deinit_progs(cg_data);
for (i = 0; i < cg_data->luts.size(); i++)
{
if (cg_data->luts[i].tex)
d3d_texture_free(cg_data->luts[i].tex);
}
cg_data->luts.clear();
if (cg_data->state_tracker)
{
state_tracker_free(cg_data->state_tracker);
cg_data->state_tracker = NULL;
}
cgD3D9UnloadAllPrograms();
cgD3D9SetDevice(NULL);
}
static HRESULT CALLBACK OnResetDevice(IDirect3DDevice9* pDev,
const D3DSURFACE_DESC* backBuf,
void* userContext)
{
cgD3D9SetDevice(pDev);
checkForCgError("setting Direct3D device");
static int firstTime = 1;
if (firstTime) {
/* Cg runtime resources such as CGprogram and CGparameter handles
survive a device reset so we just need to compile a Cg program
just once. We do however need to unload Cg programs with
cgD3DUnloadProgram upon when a Direct3D device is lost and load
Cg programs every Direct3D device reset with cgD3D9UnloadProgram. */
createCgPrograms();
firstTime = 0;
}
/* false below means "no parameter shadowing" */
cgD3D9LoadProgram(g_cgVertexProgram, false, 0);
checkForCgError("loading vertex program");
bool bRet;
bRet = init(pDev);
if (bRet)
return S_OK;
else
return S_FALSE;
}
static void cg_d3d9_renderchain_deinit_shader(cg_renderchain_t *chain)
{
if (!chain || !chain->cgCtx)
return;
cgD3D9UnloadAllPrograms();
cgD3D9SetDevice(NULL);
cgDestroyContext(chain->cgCtx);
chain->cgCtx = NULL;
}
void d3d_deinit_shader(void *data)
{
D3DVideo *d3d = reinterpret_cast<D3DVideo*>(data);
if (!d3d->cgCtx)
return;
cgD3D9UnloadAllPrograms();
cgD3D9SetDevice(NULL);
cgDestroyContext(d3d->cgCtx);
d3d->cgCtx = NULL;
}
bool d3d_init_shader(void *data)
{
D3DVideo *d3d = reinterpret_cast<D3DVideo*>(data);
d3d->cgCtx = cgCreateContext();
if (d3d->cgCtx == NULL)
return false;
RARCH_LOG("[D3D9 Cg]: Created context.\n");
HRESULT ret = cgD3D9SetDevice(d3d->dev);
if (FAILED(ret))
return false;
return true;
}
static void d3d_deinit_shader(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
(void)d3d;
(void)data;
#ifdef HAVE_CG
if (!d3d->cgCtx)
return;
cgD3D9UnloadAllPrograms();
cgD3D9SetDevice(NULL);
cgDestroyContext(d3d->cgCtx);
d3d->cgCtx = NULL;
#endif
}
void CDirect3D::DeInitialize()
{
DestroyDrawSurface();
SetShader(NULL);
if(cgShader) {
delete cgShader;
cgShader = NULL;
}
if(cgContext) {
cgDestroyContext(cgContext);
cgContext = NULL;
}
if(cgAvailable)
cgD3D9SetDevice(NULL);
if(vertexBuffer) {
vertexBuffer->Release();
vertexBuffer = NULL;
}
if(vertexDeclaration) {
vertexDeclaration->Release();
vertexDeclaration = NULL;
}
if( pDevice ) {
pDevice->Release();
pDevice = NULL;
}
if( pD3D ) {
pD3D->Release();
pD3D = NULL;
}
init_done = false;
afterRenderWidth = 0;
afterRenderHeight = 0;
quadTextureSize = 0;
fullscreen = false;
filterScale = 0;
if(cgAvailable)
unloadCgLibrary();
cgAvailable = false;
}
static bool d3d9_cg_renderchain_init_shader(d3d9_video_t *d3d,
cg_renderchain_t *renderchain)
{
CGcontext cgCtx = cgCreateContext();
if (!cgCtx)
{
RARCH_ERR("Failed to create Cg context.\n");
return false;
}
if (FAILED(cgD3D9SetDevice((IDirect3DDevice9*)d3d->dev)))
return false;
renderchain->cgCtx = cgCtx;
return true;
}
bool d3d_init_shader(void *data)
{
D3DVideo *d3d = reinterpret_cast<D3DVideo*>(data);
(void)d3d;
#ifdef HAVE_CG
d3d->cgCtx = cgCreateContext();
if (d3d->cgCtx == NULL)
return false;
#endif
RARCH_LOG("[D3D]: Created shader context.\n");
#ifdef HAVE_CG
HRESULT ret = cgD3D9SetDevice(d3d->dev);
if (FAILED(ret))
return false;
#endif
return true;
}
static bool cg_d3d9_renderchain_init_shader(void *data,
void *renderchain_data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
cg_renderchain_t *renderchain = (cg_renderchain_t*)renderchain_data;
if (!d3d || !renderchain)
return false;
renderchain->cgCtx = cgCreateContext();
if (!renderchain->cgCtx)
return false;
RARCH_LOG("[D3D]: Created shader context.\n");
HRESULT ret = cgD3D9SetDevice((IDirect3DDevice9*)d3d->dev);
if (FAILED(ret))
return false;
return true;
}
static void d3d9_cg_destroy_resources(cg_renderchain_t *chain)
{
unsigned i;
for (i = 0; i < TEXTURES; i++)
{
if (chain->chain.prev.tex[i])
d3d9_texture_free(chain->chain.prev.tex[i]);
if (chain->chain.prev.vertex_buf[i])
d3d9_vertex_buffer_free(chain->chain.prev.vertex_buf[i], NULL);
}
d3d9_cg_deinit_progs(chain);
for (i = 0; i < chain->chain.luts->count; i++)
{
if (chain->chain.luts->data[i].tex)
d3d9_texture_free(chain->chain.luts->data[i].tex);
}
cgD3D9UnloadAllPrograms();
cgD3D9SetDevice(NULL);
}
/* CDirect3D::Initialize
Initializes Direct3D (always in window mode)
IN:
hWnd - the HWND of the window in which we render/the focus window for fullscreen
-----
returns true if successful, false otherwise
*/
bool CDirect3D::Initialize(HWND hWnd)
{
if(init_done)
return true;
pD3D = Direct3DCreate9(D3D_SDK_VERSION);
if(pD3D == NULL) {
DXTRACE_ERR_MSGBOX(TEXT("Error creating initial D3D9 object"), 0);
return false;
}
memset(&dPresentParams, 0, sizeof(dPresentParams));
dPresentParams.hDeviceWindow = hWnd;
dPresentParams.Windowed = true;
dPresentParams.BackBufferCount = GUI.DoubleBuffered?2:1;
dPresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
dPresentParams.BackBufferFormat = D3DFMT_UNKNOWN;
HRESULT hr = pD3D->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hWnd,
D3DCREATE_MIXED_VERTEXPROCESSING,
&dPresentParams,
&pDevice);
if(FAILED(hr)) {
DXTRACE_ERR_MSGBOX(TEXT("Error creating D3D9 device"), hr);
return false;
}
hr = pDevice->CreateVertexBuffer(sizeof(vertexStream),D3DUSAGE_WRITEONLY,0,D3DPOOL_MANAGED,&vertexBuffer,NULL);
if(FAILED(hr)) {
DXTRACE_ERR_MSGBOX(TEXT("Error creating vertex buffer"), hr);
return false;
}
hr = pDevice->CreateVertexDeclaration(vertexElems,&vertexDeclaration);
if(FAILED(hr)) {
DXTRACE_ERR_MSGBOX(TEXT("Error creating vertex declaration"), hr);
return false;
}
cgAvailable = loadCgFunctions();
if(cgAvailable) {
cgContext = cgCreateContext();
hr = cgD3D9SetDevice(pDevice);
if(FAILED(hr)) {
DXTRACE_ERR_MSGBOX(TEXT("Error setting cg device"), hr);
}
cgShader = new CD3DCG(cgContext,pDevice);
}
pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
pDevice->SetRenderState( D3DRS_ZENABLE, FALSE);
pDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
pDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
Clear();
init_done = true;
ApplyDisplayChanges();
return true;
}
void D3D9Device::init(
const ion_uint32 width,const ion_uint32 height,
const base::String& title,const bool fullscreen,void* displayhandle,
const ion_uint32 adapter,
const video::Pixelformat colorbufferformat,
const video::Pixelformat depthstencilformat,const ion_uint32 Hz,const bool vsync)
{
if (!m_IsValid) {
base::log("D3D9Device::init()",base::Warning) <<
"Initializing an invalid device\n";
}
openWindow(width,height,title,fullscreen,displayhandle);
bool windowed=!m_Fullscreen;
D3DFORMAT adapterfmt;
if (windowed) {
D3DDISPLAYMODE d3ddm;
m_pD3D9->GetAdapterDisplayMode(adapter,&d3ddm);
adapterfmt=d3ddm.Format;
} else adapterfmt=d3dpixelformat(colorbufferformat);
if (adapterfmt==D3DFMT_UNKNOWN) {
base::log("D3D9Device::init()",base::Error) << "Unknown/unsupported color buffer format\n";
m_IsValid=false; return;
}
RECT r;
GetClientRect(m_hWindow,&r);
m_D3DPP.Windowed=windowed;
m_D3DPP.BackBufferWidth=r.right-r.left;
m_D3DPP.BackBufferHeight=r.bottom-r.top;
m_D3DPP.BackBufferCount=1;
m_D3DPP.BackBufferFormat=adapterfmt;
m_D3DPP.AutoDepthStencilFormat=d3dpixelformat(depthstencilformat);
m_D3DPP.EnableAutoDepthStencil=TRUE;
m_D3DPP.Flags=0;
m_D3DPP.PresentationInterval=vsync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE;
m_D3DPP.FullScreen_RefreshRateInHz=windowed ? 0 : Hz;
m_D3DPP.hDeviceWindow=m_hWindow;
m_D3DPP.MultiSampleQuality=0;
m_D3DPP.MultiSampleType=D3DMULTISAMPLE_NONE;
m_D3DPP.SwapEffect=D3DSWAPEFFECT_DISCARD;
m_D3DPP.Windowed=windowed;
// Getting caps
base::log("D3D9Device::init()",base::Message) << "Getting caps\n";
HRESULT hr=m_pD3D9->GetDeviceCaps(adapter,D3DDEVTYPE_HAL,&m_D3DCaps);
if (FAILED(hr)) {
base::log("D3D9Device::init()",base::Error) << "GetDeviceCaps() failed\n";
m_IsValid=false;
return;
}
// Caps structure is initialized here
{
base::log("D3D9Device::init()",base::Message) << "Analyzing caps\n";
m_Caps.m_NPOTTextures=!((m_D3DCaps.TextureCaps&D3DPTEXTURECAPS_POW2) ||
(m_D3DCaps.TextureCaps&D3DPTEXTURECAPS_NONPOW2CONDITIONAL));
m_Caps.m_RectangularTextures=(m_D3DCaps.TextureCaps&D3DPTEXTURECAPS_SQUAREONLY)==0;
m_Caps.m_Cubemaps=(m_D3DCaps.TextureCaps&D3DPTEXTURECAPS_CUBEMAP)!=0;
m_Caps.m_NPOTCubemaps=(m_D3DCaps.TextureCaps&D3DPTEXTURECAPS_CUBEMAP_POW2)==0;
m_Caps.m_ProjectedTextures=(m_D3DCaps.TextureCaps&D3DPTEXTURECAPS_PROJECTED)!=0;
m_Caps.m_DisplacementMaps=false;
m_Caps.m_CompressedTextures=false;
m_Caps.m_MaxTextureWidth=m_D3DCaps.MaxTextureWidth;
m_Caps.m_MaxTextureHeight=m_D3DCaps.MaxTextureHeight;
m_Caps.m_MaxTextureVolumeDepth=m_D3DCaps.MaxVolumeExtent;
m_Caps.m_MaxAnisotropy=m_D3DCaps.MaxAnisotropy;
m_Caps.m_MaxTextureBlendStages=m_D3DCaps.MaxTextureBlendStages;
m_Caps.m_MaxActiveFFLights=m_D3DCaps.MaxActiveLights;
m_Caps.m_MaxPointSize=m_D3DCaps.MaxPointSize;
m_Caps.m_MaxPrimitiveCount=m_D3DCaps.MaxPrimitiveCount;
m_Caps.m_MaxVertexIndex=m_D3DCaps.MaxVertexIndex;
}
// Probing formats
{
video::Caps::Texflags **pTexflags,
*pTexflagarrays[]={m_Caps.m_Valid2DTextureFormats,m_Caps.m_Valid3DTextureFormats,
m_Caps.m_ValidCubemapFormats,0};
const D3DRESOURCETYPE rtype[]={D3DRTYPE_TEXTURE,D3DRTYPE_VOLUMETEXTURE,D3DRTYPE_CUBETEXTURE};
pTexflags=pTexflagarrays;
unsigned int ii=0;
base::log("D3D9Device::init()",base::Message) << "Probing texture formats\n";
while (*pTexflags) {
video::Caps::Texflags *pTexflagarray=*pTexflags;
for (unsigned int i=0;i<video::Pixelformat_NumFormats;++i) {
D3DFORMAT fmt=d3dpixelformat((video::Pixelformat)i);
hr=0;
hr=m_pD3D9->CheckDeviceFormat(adapter,D3DDEVTYPE_HAL,adapterfmt,0,rtype[ii],fmt);
if (FAILED(hr)) { pTexflagarray[i].m_Supported=false; continue; }
else pTexflagarray[i].m_Supported=true;
if ((i==video::Pixelformat_RGB_DXT1)
|| (i==video::Pixelformat_RGBA_DXT1)
|| (i==video::Pixelformat_RGBA_DXT3)
|| (i==video::Pixelformat_RGBA_DXT5))
m_Caps.m_CompressedTextures=true;
// Volume textures are not supported as render targets
if (rtype[ii]!=D3DRTYPE_VOLUMETEXTURE) {
hr=m_pD3D9->CheckDeviceFormat(adapter,D3DDEVTYPE_HAL,adapterfmt,D3DUSAGE_RENDERTARGET,rtype[ii],fmt);
pTexflagarray[i].m_Rendertarget=(hr==D3D_OK);
m_Caps.m_Rendertargets=true;
} else pTexflagarray[i].m_Rendertarget=false;
hr=m_pD3D9->CheckDeviceFormat(adapter,D3DDEVTYPE_HAL,adapterfmt,D3DUSAGE_DYNAMIC,rtype[ii],fmt);
pTexflagarray[i].m_Dynamic=(hr==D3D_OK);
// For depth buffers, only depth formats are supported
// Volume textures are not supported
if (isDepthformat((video::Pixelformat)i) && (rtype[ii]!=D3DRTYPE_VOLUMETEXTURE)) {
hr=m_pD3D9->CheckDeviceFormat(adapter,D3DDEVTYPE_HAL,adapterfmt,D3DUSAGE_DEPTHSTENCIL,rtype[ii],fmt);
pTexflagarray[i].m_Depth=(hr==D3D_OK);
} else pTexflagarray[i].m_Depth=false;
if ((m_D3DCaps.DevCaps2&D3DDEVCAPS2_DMAPNPATCH)!=0) {
hr=m_pD3D9->CheckDeviceFormat(adapter,D3DDEVTYPE_HAL,adapterfmt,D3DUSAGE_DMAP,rtype[ii],fmt);
pTexflagarray[i].m_DisplacementMap=(hr==D3D_OK);
} else pTexflagarray[i].m_DisplacementMap=false;
}
++pTexflags;
++ii;
}
}
base::log("D3D9Device::init()",base::Message) << "Creating D3D device\n";
hr=m_pD3D9->CreateDevice(adapter,D3DDEVTYPE_HAL,m_hWindow,
D3DCREATE_HARDWARE_VERTEXPROCESSING,&m_D3DPP,&m_pD3DDev9);
if (FAILED(hr)) {
base::log("D3D9Device::init()",base::Error) << "CreateDevice() failed\n";
m_IsValid=false;
return;
}
D3DVIEWPORT9 viewport;
viewport.X=0;
viewport.Y=0;
viewport.Width=r.right-r.left;
viewport.Height=r.bottom-r.top;
viewport.MinZ=0;
viewport.MaxZ=1;
m_pD3DDev9->SetViewport(&viewport);
#ifdef D3D9DRV_USE_CG
base::log("D3D9Device::init()",base::Message) << "Initializing Cg\n";
{
m_CgContext=cgCreateContext();
cgD3D9SetDevice(m_pD3DDev9);
#ifdef D3D9DRV_CG_DEBUG_ERRORCALLBACK
errctx=m_CgContext;
cgSetErrorCallback(cgErrorCallback);
#endif
m_CgVertexProfile=cgD3D9GetLatestVertexProfile();
m_CgFragmentProfile=cgD3D9GetLatestPixelProfile();
m_CgOptimalVertexProfileOptions=cgD3D9GetOptimalOptions(m_CgVertexProfile);
m_CgOptimalFragmentProfileOptions=cgD3D9GetOptimalOptions(m_CgFragmentProfile);
}
#endif
base::log("D3D9Device::init()",base::Message) << "Probing queries\n";
{
IDirect3DQuery9* pQuery=0;
hr=m_pD3DDev9->CreateQuery(D3DQUERYTYPE_OCCLUSION,&pQuery);
m_Caps.m_HWOcclusionQueries=(hr==D3D_OK);
if (pQuery) pQuery->Release();
}
{
base::log("D3D9Device::init()",base::Message) << "Probing vertex program support\n";
// Supported vertex programs
{
unsigned int version=HIBYTE(LOWORD(m_D3DCaps.VertexShaderVersion));
unsigned int subversion=LOBYTE(LOWORD(m_D3DCaps.VertexShaderVersion));
if (version>=3) {
m_Caps.m_SupportedProgramFormats.addString("d3d_vs11");
m_Caps.m_SupportedProgramFormats.addString("d3d_vs20");
m_Caps.m_SupportedProgramFormats.addString("d3d_vs30");
} else if (version>=2) {
m_Caps.m_SupportedProgramFormats.addString("d3d_vs11");
if (subversion>=0) m_Caps.m_SupportedProgramFormats.addString("d3d_vs20");
} else if (version>=1) {
if (subversion>=1) m_Caps.m_SupportedProgramFormats.addString("d3d_vs11");
}
// HLSL support
LPCSTR vsprofile=D3DXGetVertexShaderProfile(m_pD3DDev9);
base::String hlslvsprofile;
if (vsprofile) hlslvsprofile=vsprofile;
if (hlslvsprofile.compare("vs_1_1",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs11");
} else if (hlslvsprofile.compare("vs_2_0",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs20");
} else if (hlslvsprofile.compare("vs_2_a",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs20");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs2a");
} else if (hlslvsprofile.compare("vs_3_0",true) || (version>=3)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs20");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs2a");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_vs30");
}
#ifdef D3D9DRV_USE_CG
m_Caps.m_SupportedProgramFormats.addString("cg_vprogram");
#endif
}
base::log("D3D9Device::init()",base::Message) << "Probing fragment program support\n";
// Supported fragment programs
{
unsigned int version=HIBYTE(LOWORD(m_D3DCaps.PixelShaderVersion));
unsigned int subversion=LOBYTE(LOWORD(m_D3DCaps.PixelShaderVersion));
if (version>=3) {
m_Caps.m_SupportedProgramFormats.addString("d3d_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_ps12");
m_Caps.m_SupportedProgramFormats.addString("d3d_ps13");
m_Caps.m_SupportedProgramFormats.addString("d3d_ps14");
m_Caps.m_SupportedProgramFormats.addString("d3d_ps20");
if (subversion>=0) m_Caps.m_SupportedProgramFormats.addString("d3d_ps30");
} else if (version>=2) {
m_Caps.m_SupportedProgramFormats.addString("d3d_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_ps12");
m_Caps.m_SupportedProgramFormats.addString("d3d_ps13");
m_Caps.m_SupportedProgramFormats.addString("d3d_ps14");
if (subversion>=0) m_Caps.m_SupportedProgramFormats.addString("d3d_ps20");
} else if (version>=1) {
if (subversion>=1) m_Caps.m_SupportedProgramFormats.addString("d3d_ps11");
if (subversion>=2) m_Caps.m_SupportedProgramFormats.addString("d3d_ps12");
if (subversion>=3) m_Caps.m_SupportedProgramFormats.addString("d3d_ps13");
if (subversion>=4) m_Caps.m_SupportedProgramFormats.addString("d3d_ps14");
}
// HLSL support
LPCSTR vsprofile=D3DXGetPixelShaderProfile(m_pD3DDev9);
base::String hlslpsprofile;
if (vsprofile) hlslpsprofile=vsprofile;
if (hlslpsprofile.compare("ps_1_1",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps11");
} else if (hlslpsprofile.compare("ps_1_2",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps12");
} else if (hlslpsprofile.compare("ps_1_3",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps12");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps13");
} else if (hlslpsprofile.compare("ps_1_4",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps12");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps13");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps14");
} else if (hlslpsprofile.compare("ps_2_0",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps12");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps13");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps14");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps20");
} else if (hlslpsprofile.compare("ps_2_a",true)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps12");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps13");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps14");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps20");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps2a");
} else if (hlslpsprofile.compare("ps_3_0",true) || (version>=3)) {
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps11");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps12");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps13");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps14");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps20");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps2a");
m_Caps.m_SupportedProgramFormats.addString("d3d_hlsl_ps30");
}
#ifdef D3D9DRV_USE_CG
m_Caps.m_SupportedProgramFormats.addString("cg_fprogram");
#endif
}
} // Caps end
m_Displaywidth=viewport.Width;
m_Displayheight=viewport.Height;
m_ColorbufferFormat=colorbufferformat;
m_DepthstencilbufferFormat=depthstencilformat;
m_pD3DDev9->SetRenderState(D3DRS_FOGVERTEXMODE,D3DFOG_LINEAR);
fixedLighting(false);
base::log("D3D9Device::init()",base::Message) << "Init complete\n";
}
static void CALLBACK OnLostDevice(void* userContext)
{
g_pMeshSphere->Release();
cgD3D9SetDevice(NULL);
}