Exemple #1
0
	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]);
		}
	}
Exemple #5
0
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;
	}
Exemple #8
0
	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);
	}
Exemple #11
0
	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);
	}