void Render::Draw(IDirect3DSurface9* renderTarget, D3DXMATRIX* view, D3DXMATRIX* projection)
{
// Get or create device
LPDIRECT3DDEVICE9 device = GetDevice();
if (device == NULL) return;
// Load shaders if it is required
// if (!EnsureShaders()) return;
// Prepare depth surface
D3DSURFACE_DESC renderTargetDescription;
renderTarget->GetDesc(&renderTargetDescription);
D3DSURFACE_DESC depthSurfaceDescription;
if (depthSurface != NULL) depthSurface->GetDesc(&depthSurfaceDescription);
if (depthSurface == NULL || depthSurfaceDescription.Width != renderTargetDescription.Width || depthSurfaceDescription.Height != renderTargetDescription.Height)
{
if (depthSurface != NULL) depthSurface->Release();
device->CreateDepthStencilSurface(renderTargetDescription.Width, renderTargetDescription.Height, D3DFMT_D24X8, D3DMULTISAMPLE_NONE, 0, FALSE, &depthSurface, NULL);
if (depthSurface == NULL) return;
}
device->SetRenderTarget(0, renderTarget);
device->SetDepthStencilSurface(depthSurface);
device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
if (lowPolySphere == NULL)
{
// Create spheres
lowPolySphere = CreateSphere(2);
middlePolySphere = CreateSphere(3);
highPolySphere = CreateSphere(5);
// Create cylinders
lowPolyCylinder = CreateCylinder(3);
middlePolyCylinder = CreateCylinder(12);
highPolyCylinder = CreateCylinder(24);
}
// FIXME: light dir must be slightly different!
D3DVECTOR lightDirection;
lightDirection.x = view->_13;
lightDirection.y = view->_23;
lightDirection.z = view->_33;
D3DVECTOR viewDirection;
viewDirection.x = view->_13;
viewDirection.y = view->_23;
viewDirection.z = view->_33;
elementMaterials[0].SetViewLightDirection(&viewDirection, &lightDirection);
// Rendering
device->BeginScene();
DrawAtoms(view, projection);
DrawBonds(view, projection);
DrawResidues(view, projection);
device->EndScene();
}
void InitStateDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 使用trilinear
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
//
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
//
device->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, FALSE);
device->GetRenderTarget(0, &g_pMainFrameBuffer);
device->GetDepthStencilSurface(&g_pMainDepthBuffer);
int width, height;
GutGetWindowSize(width, height);
g_iFrameBufferWidth = width * 2;
g_iFrameBufferHeight = height * 2;
device->CreateTexture(g_iFrameBufferWidth, g_iFrameBufferHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_pTexture, NULL);
device->CreateDepthStencilSurface(g_iFrameBufferWidth, g_iFrameBufferHeight, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, FALSE, &g_pDepthStencil, NULL);
g_pTexture->GetSurfaceLevel(0, &g_pFrameBuffer);
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
g_projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFOV, 1.0f, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 改變三角形正面的面向
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
device->CreateTexture(512, 512, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_pTexture, NULL);
device->CreateDepthStencilSurface(512, 512, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, FALSE, &g_pDepthStencil, NULL);
CGutModel::SetTexturePath("../../textures/");
g_Model_DX9.ConvertToDX9Model(&g_Model);
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
device->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
device->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
return true;
}
HRESULT HookIDirect3DDevice9::CreateDepthStencilSurface(LPVOID _this,
UINT Width,
UINT Height,
D3DFORMAT Format,
D3DMULTISAMPLE_TYPE MultiSample,
DWORD MultisampleQuality,
BOOL Discard,
IDirect3DSurface9** ppSurface,
HANDLE* pSharedHandle)
{
LOG_API();
return pD3Dev->CreateDepthStencilSurface(Width, Height, Format, MultiSample, MultisampleQuality, Discard, ppSurface, pSharedHandle);
}
// レンダリングターゲット用テクスチャ作成
const LPDIRECT3DTEXTURE9 CTexture::CreateRenderTarget( LPDIRECT3DDEVICE9 lpdevice, UINT width, UINT height, D3DFORMAT format )
{
// 開放しておく
this->~CTexture();
// 指定されたサイズでテクスチャ作成
D3DXCreateTexture(
lpdevice,
width,
height,
1,
D3DUSAGE_RENDERTARGET,
format,
D3DPOOL_DEFAULT,
&m_lpTex );
// 深度バッファ作成
lpdevice->CreateDepthStencilSurface(
width,
height,
D3DFMT_D16,
D3DMULTISAMPLE_NONE,
0,
TRUE,
&m_lpZbuffer,
NULL );
if( m_lpTex )
{
// テクスチャからレンダリングターゲット用サーフェス作成
m_lpTex->GetSurfaceLevel( 0, &m_lpSurface );
m_lpTex->GetLevelDesc( 0, &m_Desc );
}else{
return NULL;
}
return m_lpTex;
}
bool InitialiseDirectX()
{
const D3DFORMAT backBufferFormat = D3DFMT_D16;
const D3DFORMAT textureFormat = D3DFMT_A8R8G8B8;
if(FAILED(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
{
ShowMessageBox("Direct3D interface creation has failed");
return false;
}
// Build present params
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
D3DMULTISAMPLE_TYPE antiAliasingLvl;
bool antiAliasing = false;
if(SUCCEEDED(d3d->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, textureFormat, true, D3DMULTISAMPLE_2_SAMPLES, nullptr)))
{
d3dpp.MultiSampleType = D3DMULTISAMPLE_2_SAMPLES;
antiAliasingLvl = D3DMULTISAMPLE_2_SAMPLES;
antiAliasing = true;
}
d3dpp.hDeviceWindow = hWnd;
d3dpp.Windowed = true;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = textureFormat;
d3dpp.BackBufferWidth = WINDOW_WIDTH;
d3dpp.BackBufferHeight = WINDOW_HEIGHT;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = backBufferFormat;
if(FAILED(d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &d3ddev)))
{
ShowMessageBox("Direct3D interface creation has failed");
return false;
}
// Create Z-buffer
if(FAILED(d3ddev->CreateDepthStencilSurface(WINDOW_WIDTH, WINDOW_HEIGHT, backBufferFormat,
antiAliasing ? antiAliasingLvl : D3DMULTISAMPLE_NONE, NULL, TRUE, &backBuffer, NULL)))
{
ShowMessageBox("Z-buffer creation has failed");
return false;
}
d3ddev->SetRenderTarget(0,backBuffer);
// Set render states
d3ddev->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, antiAliasing);
// Check shader capabilities
D3DCAPS9 caps;
d3ddev->GetDeviceCaps(&caps);
// Check for vertex shader version 2.0 support.
if(caps.VertexShaderVersion < D3DVS_VERSION(2, 0))
{
ShowMessageBox("Shader model 2.0 or higher is required");
return false;
}
return true;
}
void TextureGPU::createDrawableIntoColorTextureWithDepth(PrimitiveTypes::UInt32 w, PrimitiveTypes::UInt32 h, ESamplerState sampler, bool use32BitRedForDepth /* = false*/)
{
StringOps::writeToString("createDrawableIntoColorTextureWithDepth", m_name, 256);
m_samplerState = sampler;
# if APIABSTRACTION_D3D9
D3D9Renderer *pD3D9Renderer = static_cast<D3D9Renderer *>(m_pContext->getGPUScreen());
LPDIRECT3DDEVICE9 pDevice = pD3D9Renderer->m_pD3D9Device;
m_viewport.X = 0;
m_viewport.Y = 0;
m_viewport.Width = w;
m_viewport.Height = h;
m_viewport.MinZ = 0.0f;
m_viewport.MaxZ = 1.0f;
#if APIABSTRACTION_X360
HRESULT hr = D3DXCreateTexture(pDevice,
w,
h,
1,
D3DUSAGE_RENDERTARGET,
use32BitRedForDepth ? D3DFMT_R32F : D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&this->m_pTexture );
#else
HRESULT hr = pDevice->CreateTexture(
w,
h,
1,
D3DUSAGE_RENDERTARGET,
use32BitRedForDepth ? D3DFMT_R32F : D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&this->m_pTexture,
NULL);
#endif
D3DSURFACE_DESC desc;
m_pTexture->GetSurfaceLevel( 0, &m_pSurface );
m_pSurface->GetDesc( &desc );
#ifdef _XBOX
//create depth stencil surface to use with this texture
hr = pDevice->CreateDepthStencilSurface(
w,
h,
D3DFMT_D24S8,
D3DMULTISAMPLE_NONE,
0, // multi sample quality
TRUE, // Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
//If this flag is set, the contents of the depth stencil buffer will be invalid
// after calling either IDirect3DDevice9::Present or IDirect3DDevice9::SetDepthStencilSurface with a different depth surface.
&m_pEDRamDSRenderTargetSurface,
NULL);
assert(SUCCEEDED(hr));
hr = pDevice->CreateRenderTarget(
desc.Width, desc.Height,
( D3DFORMAT )MAKESRGBFMT( desc.Format ),
D3DMULTISAMPLE_NONE, 0, 0,
&m_pEDRamColorRenderTargetSurface, NULL );
#else
#if D3D9_USE_RENDER_TO_SURFACE
hr = D3DXCreateRenderToSurface(pDevice,
desc.Width,
desc.Height,
desc.Format,
TRUE,
D3DFMT_D16,
&m_pRenderToSurface );
#else
//create depth stencil surface to use with this texture
hr = pDevice->CreateDepthStencilSurface(
w,
h,
D3DFMT_D24S8,
D3DMULTISAMPLE_NONE,
0, // multi sample quality
TRUE, // Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
//If this flag is set, the contents of the depth stencil buffer will be invalid
// after calling either IDirect3DDevice9::Present or IDirect3DDevice9::SetDepthStencilSurface with a different depth surface.
&m_pDSSurface,
NULL);
#endif
#endif
assert(SUCCEEDED(hr));
#elif APIABSTRACTION_OGL
SamplerState &ss = SamplerStateManager::getInstance()->getSamplerState(m_samplerState);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
IRenderer::checkForErrors("glTexImage2D");
#if PE_PLAT_IS_IOS
PEWARN("We are creating depth texture as 32 bit, because I could not get 16 bit depth working. If you figure it out, change it to 16 bit for better perf (hopefully!)");
#endif
glTexImage2D(
GL_TEXTURE_2D, // Target
0, // Mip-level
#if PE_PLAT_IS_IOS
GL_DEPTH_COMPONENT, // InternalFormat
#else
GL_DEPTH_COMPONENT16,
#endif
w, // width size
h, // height size
0, // border
GL_DEPTH_COMPONENT, // input pixel format
#if PE_PLAT_IS_IOS
GL_UNSIGNED_INT, // input pixel type
#else
GL_UNSIGNED_SHORT,
#endif
NULL); // input pixels
IRenderer::checkForErrors("glTexImage2D");
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, ss.val_GL_TEXTURE_MIN_FILTER);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, ss.val_GL_TEXTURE_MAG_FILTER);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, ss.val_GL_TEXTURE_WRAP_S);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, ss.val_GL_TEXTURE_WRAP_T);
#if !APIABSTRACTION_IOS
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,0); //only one mip
// depth related comparison functions
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
#endif
glBindTexture(GL_TEXTURE_2D, 0);
#if APIABSTRACTION_PS3
glGenFramebuffersOES(1, &m_frameBufferObject);
#else
glGenFramebuffers(1, &m_frameBufferObject);
#endif
#if APIABSTRACTION_PS3
glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_frameBufferObject); //set framebuffer for reading and writing. could also use GL_READ_FRAMEBUFFER to set a buffer for reading vs writing.
#else
glBindFramebuffer(GL_FRAMEBUFFER, m_frameBufferObject); //set framebuffer for reading and writing. could also use GL_READ_FRAMEBUFFER to set a buffer for reading vs writing.
#endif
//glFramebufferParameteri(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, w); / no need for this, since it take size of the texture passed
#if APIABSTRACTION_PS3
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_TEXTURE_2D, texture, 0);
#else
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texture, 0);
#endif
m_viewport.x = 0;
m_viewport.y = 0;
m_viewport.w = w;
m_viewport.h = h;
m_viewport.minDepth = 0;
m_viewport.maxDepth = 1.0f;
// had to comment out this assert becasue apparently with newest hardware it is actually complete too
//assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE); // make sure API requires color texture too
// need to cerate color texture too, otherwise framebuffer object is incomplete
glGenTextures(1, &m_texture);
glBindTexture(GL_TEXTURE_2D, m_texture);
IRenderer::checkForErrors("glTexImage2D");
#if PE_PLAT_IS_IOS
if (use32BitRedForDepth)
PEWARN("We are creating depth+color and storing dpeth in color. for ios we store it as rgba, since we cant store it as 32bit red..");
#endif
glTexImage2D(
GL_TEXTURE_2D, // Target
0, // Mip-level
#if defined(SN_TARGET_PS3)
use32BitRedForDepth ? GL_LUMINANCE32F_ARB : GL_ARGB_SCE,
#else
#if APIABSTRACTION_IOS
use32BitRedForDepth ? GL_RGBA : GL_RGBA, // InternalFormat, for ps3 use GL_ARGB_SCE, why?
#else
use32BitRedForDepth ? GL_R32F : GL_RGBA, // InternalFormat, for ps3 use GL_ARGB_SCE, why?
#endif
#endif
w, // width size
h, // height size
0, // border
GL_RGBA, // input pixel format
GL_UNSIGNED_BYTE, // input pixel type
NULL); // input pixels
IRenderer::checkForErrors("glTexImage2D");
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, ss.val_GL_TEXTURE_MIN_FILTER);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, ss.val_GL_TEXTURE_MAG_FILTER);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, ss.val_GL_TEXTURE_WRAP_S);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, ss.val_GL_TEXTURE_WRAP_T);
#if !APIABSTRACTION_IOS
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,0); //only one mip
#endif
//depth related
//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_COMPARE_MODE_ARB,GL_COMPARE_R_TO_TEXTURE_ARB);
//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
glBindTexture(GL_TEXTURE_2D, 0);
#if APIABSTRACTION_PS3
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0);
#else
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0);
#endif
#if !APIABSTRACTION_IOS
#if APIABSTRACTION_PS3
assert(glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES) == GL_FRAMEBUFFER_COMPLETE_OES);
#else
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
#endif
#endif
IRenderer::checkRenderBufferComplete();
#if APIABSTRACTION_PS3
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0); // back to default
#else
glBindFramebuffer(GL_FRAMEBUFFER, 0); // back to default
#endif
#elif APIABSTRACTION_D3D11
m_viewport.TopLeftX = 0;
m_viewport.TopLeftY = 0;
m_viewport.Width = w;
m_viewport.Height = h;
m_viewport.MinDepth = 0.0f;
m_viewport.MaxDepth = 1.0f;
D3D11Renderer *pD3D11Renderer = static_cast<D3D11Renderer *>(m_pContext->getGPUScreen());
ID3D11Device *pDevice = pD3D11Renderer->m_pD3DDevice;
ID3D11DeviceContext *pDeviceContext = pD3D11Renderer->m_pD3DContext;
//ID3D11Texture2D *pColorMap = 0;
D3D11_TEXTURE2D_DESC texDesc;
texDesc.Width = w;
texDesc.Height = h;
texDesc.MipLevels = 1;
texDesc.ArraySize = 1;
texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
texDesc.SampleDesc.Count = 1;
texDesc.SampleDesc.Quality = 0;
texDesc.Usage = D3D11_USAGE_DEFAULT;
texDesc.BindFlags = D3D11_BIND_RENDER_TARGET |
D3D11_BIND_SHADER_RESOURCE;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = D3D11_RESOURCE_MISC_GENERATE_MIPS;
HRESULT hr = pDevice->CreateTexture2D(&texDesc, 0, &m_pTexture);
assert(SUCCEEDED(hr));
// Null description means to create a view to all mipmap levels
// using the format the texture was created with
hr = pDevice->CreateRenderTargetView(m_pTexture, 0, &m_pRenderTargetView);
assert(SUCCEEDED(hr));
hr = pDevice->CreateShaderResourceView(m_pTexture, 0, &m_pShaderResourceView);
assert(SUCCEEDED(hr));
// Now create depth part fo the texture
ID3D11Texture2D *pDepthMap = 0;
texDesc.Format = DXGI_FORMAT_R32_TYPELESS;
texDesc.Usage = D3D11_USAGE_DEFAULT;
texDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL |
D3D11_BIND_SHADER_RESOURCE;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;
hr = pDevice->CreateTexture2D(&texDesc, 0, &pDepthMap);
assert(SUCCEEDED(hr));
// setting up view for rendering into depth buffer/and reading (stenciling) from it (z-buffer algorithm red/write)
D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
dsvDesc.Format = DXGI_FORMAT_D32_FLOAT;
dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
dsvDesc.Texture2D.MipSlice = 0;
dsvDesc.Flags = 0;//D3D11_DSV_READ_ONLY_DEPTH;
hr = pDevice->CreateDepthStencilView(pDepthMap, &dsvDesc, &m_DepthStencilView);
assert(SUCCEEDED(hr));
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Format = DXGI_FORMAT_R32_FLOAT;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = texDesc.MipLevels;
srvDesc.Texture2D.MostDetailedMip = 0;
hr = pDevice->CreateShaderResourceView(pDepthMap, &srvDesc, &m_pDepthShaderResourceView);
assert(SUCCEEDED(hr));
pDepthMap->Release();
#endif
}
void TextureCacheEntry::restore()
{
// compute usage
DWORD usage = D3DUSAGE_AUTOGENMIPMAP;
D3DPOOL pool = D3DPOOL_MANAGED;
UINT levels = 0;
if (renderTarget)
{
usage = usage | D3DUSAGE_RENDERTARGET;
pool = D3DPOOL_DEFAULT;
levels = 1;
}
// Allocate D3D texture
HRESULT result = pD3DDevice->CreateTexture(
xSize, // width
ySize, // height
levels, // number of miplevels - zero for automatic mip-map generation
usage, // usage - autogen mipmaps and maybe rendertarget
D3DFMT_A8R8G8B8, // pixel format - we will only use 32-bit
pool, // memory pool - we'll let D3D manage the textures so we don't have to "restore."
&d3dTexture, // return pointer to texture interface object here
NULL // this parameter must be NULL
);
// Check for failure. We won't handle errors gracefully.
if (FAILED(result)) {
ABORT("Can't allocate %dx%d 32-bit texture", xSize, ySize);
}
// Create a depth stencil if requested
if (depthStencil)
{
// acceptable formats in order of preference
D3DFORMAT formats[] = {D3DFMT_D32, D3DFMT_D16};
for (int a = 0; a < 2; a++)
{
result =
pD3DDevice->CreateDepthStencilSurface(
xSize,
ySize,
formats[1],
D3DMULTISAMPLE_NONE,
NULL,
true,
&d3dDepthBuffer,
NULL
);
// leave if a buffer was successfully created
if (SUCCEEDED(result)) break;
}
if (FAILED(result)) // if a depth buffer could not be created
{
ABORT("Can't create a depth buffer", xSize, ySize);
}
}
}
