CD3D11Texture2D::~CD3D11Texture2D()
{
ReleaseCOM(md3dSRV);
ReleaseCOM(md3dUAV);
ReleaseReferenceCounted(mDepthStencilSurface);
ReleaseReferenceCounted(mRenderTarget);
ReleaseCOM(md3dTexture);
}
CD3D11Texture2DArray::~CD3D11Texture2DArray()
{
ReleaseCOM(md3dSRV);
ReleaseCOM(md3dUAV);
for (u32 i = 0; i < mRenderTargets.size(); i++)
ReleaseReferenceCounted(mRenderTargets[i]);
for (u32 i = 0; i < mDepthStencilSurfaces.size(); i++)
ReleaseReferenceCounted(mDepthStencilSurfaces[i]);
ReleaseCOM(md3dTexture);
}
void CD3D11Texture2DArray::clearDepthStencilSurfaces(std::vector<CD3D11DepthStencilSurface*> depthStencilSurfaces)
{
for (u32 i = 0; i < depthStencilSurfaces.size(); i++)
{
ReleaseReferenceCounted(depthStencilSurfaces[i]);
}
}
void CD3D11Texture2DArray::clearRenderTargets(std::vector<CD3D11RenderTarget*> renderTargets)
{
for (u32 i = 0; i < renderTargets.size(); i++)
{
ReleaseReferenceCounted(renderTargets[i]);
}
}
CWin32Device::~CWin32Device()
{
mSceneManager->destroy();
mSceneManager = nullptr;
//ReleaseReferenceCounted(mSceneManager);
ReleaseReferenceCounted(mVideoDriver);
}
CModelMeshNode::~CModelMeshNode()
{
IReflectionMediator* mediator = mSceneManager->getReflectionMediator();
mediator->removeMapping(this);
ReleaseReferenceCounted(mMesh);
ReleaseListElementCounted(mMaterials);
}
bool CModelMeshNode::setMaterial(u32 subset, IMaterial* material)
{
if (subset >= mMesh->getSubsetCount())
return false;
if (material != mMaterials[subset])
{
ReleaseReferenceCounted(mMaterials[subset]);
mMaterials[subset] = material;
AddReferenceCounted(material);
}
return true;
}
CD3D11Driver::~CD3D11Driver()
{
/* 释放的顺序
1, mesh
2, material
3, pipeline
4, texture
5, shader,
6, inputlayout
7, render-state
*/
mDefaultRenderTarget->drop();
ReleaseCOM(D3D11DriverState.ShadowMapRasterizerState);
for (u32 i = 0; i < EST_SHADER_COUNT; i++)
clearShader(E_SHADER_TYPE(i));
ReleaseReferenceCounted(mMeshManager);
ReleaseReferenceCounted(mMaterialManager);
ReleaseReferenceCounted(mPipeManager);
ReleaseReferenceCounted(mTextureManager);
ReleaseReferenceCounted(mShaderManager);
ReleaseReferenceCounted(mInputLayoutManager);
ReleaseReferenceCounted(mRenderStateManager);
ReleaseReferenceCounted(mResourceFactory);
ReleaseReferenceCounted(mGeometryCreator);
ReleaseCOM(md3dSwapChain);
ReleaseCOM(md3dDeviceContext);
ReleaseCOM(md3dDevice);
//md3dDebug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL);
ReleaseCOM(md3dDebug);
}
IBuffer* CD3D11ResourceFactory::createBuffer(const std::string& name,
u32 sortcode,
u32 elementNum,
u32 bindFlags,
E_GI_FORMAT format,
u32 elementSize,
void* rawData,
E_MEMORY_USAGE memoryUsage)
{
CD3D11Buffer* pd3dBuffer = new CD3D11Buffer(md3dDevice, md3dDeviceContext,
name, sortcode, md3dDriver);
if (!pd3dBuffer->create(elementNum, bindFlags, format, elementSize, rawData, memoryUsage))
{
ReleaseReferenceCounted(pd3dBuffer);
}
return pd3dBuffer;
}
CD3D11ResourceFactory::~CD3D11ResourceFactory()
{
ReleaseReferenceCounted(md3dRenderStateCache);
ReleaseReferenceCounted(md3dSamplerStateCache);
}
bool CD3D11Texture2D::create(u32 width, u32 height, u32 bindFlags,
void* rawData, u32 miplevel, E_GI_FORMAT format, u32 pitch,
E_MEMORY_USAGE memoryUsage)
{
HRESULT hr;
ID3D11Texture2D* pd3dTexture = NULL;
ID3D11ShaderResourceView* pd3dSRV = NULL;
ID3D11UnorderedAccessView* pd3dUAV = NULL;
CD3D11RenderTarget* pRenderTarget = nullptr;
D3D11_TEXTURE2D_DESC texDesc;
texDesc.Width = width;
texDesc.Height = height;
texDesc.MipLevels = miplevel;
texDesc.ArraySize = 1;
texDesc.Format = getDxgiFormat(format);
texDesc.SampleDesc.Count = 1;
texDesc.SampleDesc.Quality = 0;
texDesc.BindFlags = getD3dx11BindFlags(bindFlags);
texDesc.CPUAccessFlags = getD3dx11CpuAccessFlag(bindFlags);
texDesc.MiscFlags = 0;
texDesc.Usage = getD3d11Usage(memoryUsage);
if (memoryUsage == EMU_UNKNOWN)
{
if ((bindFlags & ETBT_CPU_ACCESS_READ)) {
texDesc.Usage = D3D11_USAGE_STAGING;
memoryUsage = EMU_STAGING;
}
else if (bindFlags & ETBT_CPU_ACCESS_WRITE) {
texDesc.Usage = D3D11_USAGE_DYNAMIC;
memoryUsage = EMU_DEFAULT;
}
else if (rawData) {
texDesc.Usage = D3D11_USAGE_IMMUTABLE;
memoryUsage = EMU_STATIC;
}
else if (!rawData) {
texDesc.Usage = D3D11_USAGE_DEFAULT;
memoryUsage = EMU_DEFAULT;
}
}
else
{
if (memoryUsage == EMU_DEFAULT || memoryUsage == EMU_STATIC)
{
if ((bindFlags & ETBT_CPU_ACCESS_READ) || (bindFlags & ETBT_CPU_ACCESS_WRITE))
{
GF_PRINT_CONSOLE_INFO("Static or Default Buffer cannot be accessed by CPU.\n");
return false;
}
}
else if (memoryUsage == EMU_DYNAMIC)
{
if (bindFlags & ETBT_CPU_ACCESS_READ)
{
GF_PRINT_CONSOLE_INFO("Dynamic Buffer cannot be read by CPU.\n");
return false;
}
}
}
if (memoryUsage == D3D11_USAGE_STAGING)
{
if ((bindFlags & ETBT_SHADER_RESOURCE) || (bindFlags & ETBT_UNORDERED_ACCESS)){
GF_PRINT_CONSOLE_INFO("Buffer with the memory usage 'STARING' cannot have SHADER_RESOURCE or UNORDERED_ACCESS.");
return false;
}
}
if (rawData)
{
D3D11_SUBRESOURCE_DATA texData;
texData.pSysMem = rawData;
if (pitch == 0)
pitch = getFormatOffset(format) * width;
texData.SysMemPitch = pitch;
texData.SysMemSlicePitch = 0;
hr = md3dDevice->CreateTexture2D(&texDesc, &texData, &pd3dTexture);
}
else
{
hr = md3dDevice->CreateTexture2D(&texDesc, NULL, &pd3dTexture);
}
if (FAILED(hr))
{
return false;
}
if (bindFlags & ETBT_SHADER_RESOURCE)
{
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Format = texDesc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = -1;
hr = md3dDevice->CreateShaderResourceView(pd3dTexture, &srvDesc, &pd3dSRV);
if (FAILED(hr))
{
ReleaseCOM(pd3dTexture);
return false;
}
}
if (bindFlags & ETBT_UNORDERED_ACCESS)
{
D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;
uavDesc.Format = texDesc.Format;
uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
uavDesc.Texture2D.MipSlice = 0;
hr = md3dDevice->CreateUnorderedAccessView(pd3dTexture, &uavDesc, &pd3dUAV);
if (FAILED(hr))
{
ReleaseCOM(pd3dTexture);
return false;
}
}
if (bindFlags & ETBT_RENDER_TARGET)
{
pRenderTarget = new CD3D11RenderTarget(md3dDevice, md3dDeviceContext);
if (!pRenderTarget->create(this, pd3dTexture, pd3dSRV, width, height, format))
{
ReleaseReferenceCounted(pRenderTarget);
ReleaseCOM(pd3dSRV);
ReleaseCOM(pd3dTexture);
return false;
}
}
ReleaseReferenceCounted(mRenderTarget);
ReleaseReferenceCounted(mDepthStencilSurface);
ReleaseCOM(md3dSRV);
ReleaseCOM(md3dUAV);
ReleaseCOM(md3dTexture);
md3dTexture = pd3dTexture;
md3dSRV = pd3dSRV;
md3dUAV = pd3dUAV;
mRenderTarget = pRenderTarget;
mTextureWidth = width;
mTextureHeight = height;
mFormat = format;
return true;
}
CResourceGroupManager::~CResourceGroupManager()
{
ReleaseReferenceCounted(mResourceLoader);
}
