コード例 #1
0
ファイル: GBuffer.cpp プロジェクト: Solidstatewater/Engine
ABOOL GBufferOne::VInitialize()
{
	//==
	//Define properties for textures
	//==
	Texture2DParams * pParams = new Texture2DParams();
	pParams->Init(SCREEN_WIDTH, SCREEN_HEIGHT, 1, TEX_R32G32B32A32_FLOAT, true, false, 
		true, false, 1, 0, 1, true, false, false);
		//==
	//Create textures
	//==
	Texture2D pTex = *m_pPosTex;
	pTex.Create(pParams);
	m_pPosTex->Create(pParams);
	m_pNormalTex->Create(pParams);
	m_pDepthTex->Create(pParams);
	m_pDiffuseTex->Create(pParams);
	m_pSpecularTex->Create(pParams);


	//Define properties for shader resource views
	ShaderResourceViewParams * pSRVParams = new ShaderResourceViewParams();
	pSRVParams->InitForTexture2D(pParams->Format, 1, 0);

	//==
	//Create Shader Resource Views
	//==
	m_pPosTex->CreateShaderResourceView(m_SRVList.GetView(0), pSRVParams);
	m_pNormalTex->CreateShaderResourceView(m_SRVList.GetView(1), pSRVParams);
	m_pDepthTex->CreateShaderResourceView(m_SRVList.GetView(2), pSRVParams);
	m_pDiffuseTex->CreateShaderResourceView(m_SRVList.GetView(3), pSRVParams);
	m_pSpecularTex->CreateShaderResourceView(m_SRVList.GetView(4), pSRVParams);

	//Define properties for shader resource views
	RenderTargetViewParams * pRTVParams = new RenderTargetViewParams();
	pRTVParams->InitForTexture2D(pParams->Format, 0);

	//==
	//Create Render Target Views
	//==
	m_pPosTex->CreateRenderTargetView(m_RTVList.GetView(0), pRTVParams);
	m_pNormalTex->CreateRenderTargetView(m_RTVList.GetView(1), pRTVParams);
	m_pDepthTex->CreateRenderTargetView(m_RTVList.GetView(2), pRTVParams);
	m_pDiffuseTex->CreateRenderTargetView(m_RTVList.GetView(3), pRTVParams);
	m_pSpecularTex->CreateRenderTargetView(m_RTVList.GetView(4), pRTVParams);

	return 1;
}
コード例 #2
0
ABOOL Light::VInitialize(INPUT_LAYOUT * pLayout)
{
	//Initialize default light shaders
	m_pShaders = new ShaderBunch();
	m_pShaders->VSetVertexShader(m_vertexShaderFile,	DEFAULT_VERTEX_SHADER_NAME, pLayout, 2, TOPOLOGY_TRIANGLELIST);
	m_pShaders->VSetPixelShader(m_pixelShaderFile,	DEFAULT_PIXEL_SHADER_NAME);

	//Initialize textures for shadow mapping
	Texture2DParams tex2DParams;
	tex2DParams.Init(SCREEN_WIDTH, SCREEN_HEIGHT, 1, DXGI_FORMAT_R32_TYPELESS, true, false, false, true, 1, 0,
		1, true, false, false);
	m_pShadowMapTex->Create(&tex2DParams);

	//create shader resource and render target view for the texture
	ShaderResourceViewParams srvParams;
	srvParams.InitForTexture2D(DXGI_FORMAT_R32_FLOAT, 0, 0);
	m_pShadowMapTex->CreateShaderResourceView(&m_pShadowMapSRV->m_pView, &srvParams);

	DepthStencilViewParams dsvParams;
	dsvParams.InitForTexture2D(DXGI_FORMAT_D32_FLOAT, 0);
	if (!m_pShadowMapTex->CreateDepthStencilView(&m_pShadowMapDSV->m_pView, &dsvParams))	return false;

	/*** Initialize texture for varianbce shadow mapping ***/
	tex2DParams.Init(SCREEN_WIDTH, SCREEN_HEIGHT, 1, DXGI_FORMAT_R32G32B32A32_FLOAT, true, true, true, false,
		1, 0, 8, true, false, false, true);
	m_pVarianceShadowTex->Create(&tex2DParams);
	m_pTempTexture->Create(&tex2DParams);

	//create shadow resource view
	srvParams.InitForTexture2D(DXGI_FORMAT_R32G32B32A32_FLOAT, 8, 0);
	m_pVarianceShadowTex->CreateShaderResourceView(&m_pVarianceShadowSRV->m_pView, &srvParams);
	m_pTempTexture->CreateShaderResourceView(&m_pTempSRV->m_pView, &srvParams);

	RenderTargetViewParams rtvParams;
	rtvParams.InitForTexture2D(DXGI_FORMAT_R32G32B32A32_FLOAT, 0);
	m_pVarianceShadowTex->CreateRenderTargetView(&m_pVarianceShadowRTV->m_pView, &rtvParams);

	UnorderedAccessViewParams uavParams;
	uavParams.InitForTexture2D(DXGI_FORMAT_R32G32B32A32_FLOAT, 0);
	m_pVarianceShadowTex->CreateUnorderedAccessView(&m_pVarianceShadowUAV->m_pView, &uavParams);
	m_pTempTexture->CreateUnorderedAccessView(&m_pTempUAV->m_pView, &uavParams);

	m_bInitialized = true;

	return true;
}
コード例 #3
0
ABOOL DeferredRenderer::VInitialize(HWND hWnd, AUINT32 width, AUINT32 height)
{
	if (!Renderer::VInitialize(hWnd, width, height))
	{
		assert(0 && "Some problem initializing Renderer occured");
	}

	//initialize gbuffer
	m_gbuffer.VInitialize();

	//initialize data for light pass
	BufferParams matBufferParams;
	matBufferParams.FillConstantBufferParams(sizeof(Mat4x4), true, false, false);
	m_pMatrixBuffer->Create(&matBufferParams, NULL);

	//initialize data for light rendering
	BufferParams params;
	params.FillVertexBufferParams(sizeof(float3), 6, true, false, false, false);

	//position data
	SubresourceData data;

	AREAL32 left = (AREAL32)(SCREEN_WIDTH / 2 * -1);
	AREAL32 right = left + SCREEN_WIDTH;
	AREAL32 top = (AREAL32)(SCREEN_HEIGHT / 2);
	AREAL32 bottom = top - SCREEN_HEIGHT;

	float3 pos [] = 
	{
		float3(left,	top,	0.0f), //left top
		float3(right,	top,	0.0f), //right top
		float3(left,	bottom, 0.0f), //left bottom
		float3(left,	bottom, 0.0f), //left bottom
		float3(right,	top,	0.0f), //right top
		float3(right,	bottom, 0.0f), //right bottom
	};

	data.SetData(pos);
	if (!m_pVertices->Create(&params, &data, 6, sizeof(float3)))
	{
		assert(0 && "Error creating vertex buffer in Deferred Renderer initialization!");
	}

	//texture coordinates
	params.SetSize(sizeof(float2) * 6);

	float2 texCoords [] =
	{
		float2(0.0f, 0.0f), //left top
		float2(1.0f, 0.0f), //right top
		float2(0.0f, 1.0f), //left bottom
		float2(0.0f, 1.0f), //left bottom
		float2(1.0f, 0.0f), //right top
		float2(1.0f, 1.0f), //right bottom
	};

	data.SetData(texCoords);
	if (!m_pTexCoords->Create(&params, &data, 6, sizeof(float2)))
	{
		assert(0 && "Error creating vertex buffer with texture coordinates in Deferred Renderer initialization!");
	}

	//initialize input layout 
	m_pDefaultLayout = new INPUT_LAYOUT[5];

	m_pDefaultLayout[0].SemanticName			= "POSITION";			m_pDefaultLayout[1].SemanticName			= "TEXCOORDS";
	m_pDefaultLayout[0].SemanticIndex			= 0;					m_pDefaultLayout[1].SemanticIndex			= 0;
	m_pDefaultLayout[0].Format					= TEX_R32G32B32_FLOAT;	m_pDefaultLayout[1].Format					= TEX_R32G32_FLOAT;
	m_pDefaultLayout[0].InputSlot				= 0;					m_pDefaultLayout[1].InputSlot				= 1;
	m_pDefaultLayout[0].AlignedByteOffset		= 0;					m_pDefaultLayout[1].AlignedByteOffset		= 0;
	m_pDefaultLayout[0].InputSlotClass			= IA_PER_VERTEX_DATA;	m_pDefaultLayout[1].InputSlotClass			= IA_PER_VERTEX_DATA;
	m_pDefaultLayout[0].InstanceDataStepRate	= 0;					m_pDefaultLayout[1].InstanceDataStepRate	= 0;

	m_pDefaultLayout[2].SemanticName			= "NORMAL";				m_pDefaultLayout[3].SemanticName			= "TANGENT";
	m_pDefaultLayout[2].SemanticIndex			= 0;					m_pDefaultLayout[3].SemanticIndex			= 0;
	m_pDefaultLayout[2].Format					= TEX_R32G32B32_FLOAT;	m_pDefaultLayout[3].Format					= TEX_R32G32B32_FLOAT;
	m_pDefaultLayout[2].InputSlot				= 2;					m_pDefaultLayout[3].InputSlot				= 2;
	m_pDefaultLayout[2].AlignedByteOffset		= 0;					m_pDefaultLayout[3].AlignedByteOffset		= 12;
	m_pDefaultLayout[2].InputSlotClass			= IA_PER_VERTEX_DATA;	m_pDefaultLayout[3].InputSlotClass			= IA_PER_VERTEX_DATA;
	m_pDefaultLayout[2].InstanceDataStepRate	= 0;					m_pDefaultLayout[3].InstanceDataStepRate	= 0;

	m_pDefaultLayout[4].SemanticName			= "BINORMAL";			
	m_pDefaultLayout[4].SemanticIndex			= 0;					
	m_pDefaultLayout[4].Format					= TEX_R32G32B32_FLOAT;	
	m_pDefaultLayout[4].InputSlot				= 2;					
	m_pDefaultLayout[4].AlignedByteOffset		= 24;					
	m_pDefaultLayout[4].InputSlotClass			= IA_PER_VERTEX_DATA;	
	m_pDefaultLayout[4].InstanceDataStepRate	= 0;					

	//Initialize shaders
	m_pDefaultGBufferShaders->VSetVertexShader(L"GBufferShader.hlsl", "VS", m_pDefaultLayout, 5, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pDefaultGBufferShaders->VSetPixelShader(L"GBufferShader.hlsl", "PS", "ps_5_0");

	//input layout
	m_pLayout = new INPUT_LAYOUT[2];
	m_pLayout[0].SemanticName			= "POSITION";			m_pLayout[1].SemanticName			= "TEXCOORDS";
	m_pLayout[0].SemanticIndex			= 0;					m_pLayout[1].SemanticIndex			= 0;
	m_pLayout[0].Format					= TEX_R32G32B32_FLOAT;	m_pLayout[1].Format					= TEX_R32G32_FLOAT;
	m_pLayout[0].InputSlot				= 0;					m_pLayout[1].InputSlot				= 1;
	m_pLayout[0].AlignedByteOffset		= 0;					m_pLayout[1].AlignedByteOffset		= 0;
	m_pLayout[0].InputSlotClass			= IA_PER_VERTEX_DATA;	m_pLayout[1].InputSlotClass			= IA_PER_VERTEX_DATA;
	m_pLayout[0].InstanceDataStepRate	= 0;					m_pLayout[1].InstanceDataStepRate	= 0;

	////////////////////////////////////////////////////////
	//Shadow mapping
	m_pShadowsLayout = new INPUT_LAYOUT();
	m_pShadowsLayout->SemanticName	=	"POSITION";
	m_pShadowsLayout->SemanticIndex	=	0;
	m_pShadowsLayout->Format		=	TEX_R32G32B32_FLOAT;
	m_pShadowsLayout->InputSlot		=	0;
	m_pShadowsLayout->AlignedByteOffset =	0;
	m_pShadowsLayout->InputSlotClass	=	IA_PER_VERTEX_DATA;
	m_pShadowsLayout->InstanceDataStepRate =	0;

	m_pShadowsShaders->VSetVertexShader(L"Resources\\Shaders\\Shadows\\ShadowMap_VS.hlsl", "Shadows_VS", m_pShadowsLayout, 1, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pShadowsShaders->VSetPixelShader(L"Resources\\Shaders\\Shadows\\ShadowMap_PS.hlsl", "Shadows_PS", "ps_5_0");

	m_pShadowCubeShaders->VSetVertexShader(L"Shaders\\CubeShadowMap_VS.hlsl", "CubeShadowMap_VS", m_pShadowsLayout, 1, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pShadowCubeShaders->VSetGeometryShader(L"Shaders\\CubeShadowMap_GS.hlsl", "CubeShadowMap_GS", "gs_5_0");
	m_pShadowCubeShaders->VSetPixelShader(L"Shaders\\CubeShadowMap_PS.hlsl", "CubeShadowMap_PS", "gs_5_0");
	
	m_pVarianceShadowsShaders->VSetVertexShader(L"Resources\\Shaders\\Shadows\\VarianceShadows_DepthVS.hlsl", "VarianceShadows_DepthVS", m_pShadowsLayout, 1, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pVarianceShadowsShaders->VSetPixelShader(L"Resources\\Shaders\\Shadows\\VarianceShadows_DepthPS.hlsl", "VarianceShadows_DepthPS", "ps_5_0");

	////////////////////////////////////////////////////////
	//Motion Blur
	m_pMotionBlurLayout = new INPUT_LAYOUT[2];
	m_pMotionBlurLayout[0].SemanticName = "POSITION";				m_pMotionBlurLayout[1].SemanticName = "TEXCOORD";
	m_pMotionBlurLayout[0].SemanticIndex = 0;						m_pMotionBlurLayout[1].SemanticIndex = 0;
	m_pMotionBlurLayout[0].Format = TEX_R32G32B32_FLOAT;			m_pMotionBlurLayout[1].Format = TEX_R32G32_FLOAT;
	m_pMotionBlurLayout[0].InputSlot = 0;							m_pMotionBlurLayout[1].InputSlot = 1;
	m_pMotionBlurLayout[0].AlignedByteOffset = 0;					m_pMotionBlurLayout[1].AlignedByteOffset = 0;
	m_pMotionBlurLayout[0].InputSlotClass = IA_PER_VERTEX_DATA;		m_pMotionBlurLayout[1].InputSlotClass = IA_PER_VERTEX_DATA;
	m_pMotionBlurLayout[0].InstanceDataStepRate = 0;				m_pMotionBlurLayout[1].InstanceDataStepRate = 0;

	m_pVelocityMapShaders->VSetVertexShader(L"Resources\\Shaders\\PostProcessing\\VelocityMap_VS.hlsl", "GenerateVelocityMap_VS", m_pMotionBlurLayout, 2, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pVelocityMapShaders->VSetPixelShader(L"Resources\\Shaders\\PostProcessing\\VelocityMap_PS.hlsl", "GenerateVelocityMap_PS", "ps_5_0");

	m_pMotionBlurShaders->VSetVertexShader(L"Resources\\Shaders\\PostProcessing\\MotionBlur_VS.hlsl", "MotionBlur_VS", m_pMotionBlurLayout, 2, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pMotionBlurShaders->VSetPixelShader(L"Resources\\Shaders\\PostProcessing\\MotionBlur_PS.hlsl", "MotionBlur_PS", "ps_5_0");

	////////////////////////////////////////////////////////
	//resourece copying
	m_pSRVtoRTVLayout = new INPUT_LAYOUT();
	m_pSRVtoRTVLayout->SemanticName		=	"POSITION";
	m_pSRVtoRTVLayout->SemanticIndex	=	0;
	m_pSRVtoRTVLayout->Format			=	TEX_R32G32B32_FLOAT;
	m_pSRVtoRTVLayout->InputSlot		=	0;
	m_pSRVtoRTVLayout->AlignedByteOffset =	0;
	m_pSRVtoRTVLayout->InputSlotClass	=	IA_PER_VERTEX_DATA;
	m_pSRVtoRTVLayout->InstanceDataStepRate =	0;

	m_pSRVtoRTVShaders->VSetVertexShader(L"Resources\\Shaders\\Other\\FromSRVtoRTV_VS.hlsl", "SRVtoRTV_VS", m_pSRVtoRTVLayout, 1, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pSRVtoRTVShaders->VSetPixelShader(L"Resources\\Shaders\\Other\\FromSRVtoRTV_PS.hlsl", "SRVtoRTV_PS", "ps_5_0");

	////////////////////////////////////////////////////////
	//Ambient occlusion
	m_pSSAOLayout = new INPUT_LAYOUT();
	m_pSSAOLayout->SemanticName		=	"POSITION";
	m_pSSAOLayout->SemanticIndex	=	0;
	m_pSSAOLayout->Format			=	TEX_R32G32B32_FLOAT;
	m_pSSAOLayout->InputSlot		=	0;
	m_pSSAOLayout->AlignedByteOffset =	0;
	m_pSSAOLayout->InputSlotClass	=	IA_PER_VERTEX_DATA;
	m_pSSAOLayout->InstanceDataStepRate =	0;

	m_pSSAOShaders->VSetVertexShader(L"SSAO_Vertex.hlsl", "SSAO_VS", m_pSSAOLayout, 1, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pSSAOShaders->VSetPixelShader(L"SSAO_Pixel.hlsl", "SSAO_PS", "ps_5_0");

	Texture2DParams tex2DParams;
	tex2DParams.Init(SCREEN_WIDTH, SCREEN_HEIGHT, 1, TEX_R32G32B32A32_FLOAT, true, true, true, false, 1, 0,
		1, true, false, false);
	m_pSSAOTexture->Create(&tex2DParams);

	//create shader resource and render target view for the texture
	ShaderResourceViewParams srvSSAOParams;
	srvSSAOParams.InitForTexture2D(tex2DParams.Format, 0, 0, false);
	m_pSSAOTexture->CreateShaderResourceView(&m_pSSAOSRV->m_pView, &srvSSAOParams);

	UnorderedAccessViewParams uavSSAOParams;
	uavSSAOParams.InitForTexture2D(tex2DParams.Format, 0);
	m_pSSAOTexture->CreateUnorderedAccessView(&m_pSSAOUAV->m_pView, &uavSSAOParams);

	RenderTargetViewParams rtvSSAOParams;
	rtvSSAOParams.InitForTexture2D(tex2DParams.Format, 0, false);
	m_pSSAOTexture->CreateRenderTargetView(&m_pSSAORTV->m_pView, &rtvSSAOParams);

	///////////////////////////////////////////////
	//Initialize sky resources
	///////////////////////////////////////////////
	tex2DParams.InitCubeTexture(1024, 1024, 1, TEX_R8G8B8A8_UNORM, true, false, false, false, 1, 0,
		1, true, false, false);
	//m_pSkyTexture->CreateFromFile(L"church_cubemap.dds");
	m_pSkyTexture->CreateFromFile(L"space_cubemap.dds");

	ShaderResourceViewParams srvSkyParams;
	srvSkyParams.InitForCubeTexture(TEX_R8G8B8A8_UNORM, 1, 0);
	m_pSkyTexture->CreateShaderResourceView(&m_pSkySRV->m_pView, &srvSkyParams);

	m_pSkyLayout = new INPUT_LAYOUT();
	//m_pSkyLayout[0].SemanticName = "POSITION";					//m_pSkyLayout[1].SemanticName = "TEXCOORD";
	//m_pSkyLayout[0].SemanticIndex = 0;							//m_pSkyLayout[1].SemanticIndex = 0;
	//m_pSkyLayout[0].Format = TEX_R32G32B32_FLOAT;				//m_pSkyLayout[1].Format = TEX_R32G32_FLOAT;
	//m_pSkyLayout[0].InputSlot = 0;								//m_pSkyLayout[1].InputSlot = 1;
	//m_pSkyLayout[0].AlignedByteOffset = 0;						//m_pSkyLayout[1].AlignedByteOffset = 0;
	//m_pSkyLayout[0].InputSlotClass = IA_PER_VERTEX_DATA;		//m_pSkyLayout[1].InputSlotClass = IA_PER_VERTEX_DATA;
	//m_pSkyLayout[0].InstanceDataStepRate = 0;					//m_pSkyLayout[1].InstanceDataStepRate = 0;
	m_pSkyLayout->SemanticName		=	"POSITION";
	m_pSkyLayout->SemanticIndex	=	0;
	m_pSkyLayout->Format			=	TEX_R32G32B32_FLOAT;
	m_pSkyLayout->InputSlot		=	0;
	m_pSkyLayout->AlignedByteOffset =	0;
	m_pSkyLayout->InputSlotClass	=	IA_PER_VERTEX_DATA;
	m_pSkyLayout->InstanceDataStepRate =	0;

	m_pSkyShaders->VSetVertexShader(L"Source\\Shaders\\SkyBox.hlsl", "SkyBox_VS", m_pSkyLayout, 1, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	m_pSkyShaders->VSetPixelShader(L"Source\\Shaders\\SkyBox.hlsl", "SkyBox_PS", "ps_5_0");

	//m_pAtmoShaders->VSetVertexShader(L"Shaders\\Atmosphere\\SkyFromAtmosphere_vs.hlsl", "SkyFromAtmosphere_vs", m_pSkyLayout, 1, TOPOLOGY_TRIANGLELIST, "vs_5_0");
	//m_pAtmoShaders->VSetPixelShader(L"Shaders\\Atmosphere\\SkyFromAtmosphere_ps.hlsl", "SkyFromAtmosphere_ps", "ps_5_0");

	Resource meshResource("sphere.obj");
	shared_ptr<ResHandle> pMeshes = Anubis::SafeGetHandle(&meshResource);
	std::shared_ptr<MeshResourceExtraData> pData = static_pointer_cast<MeshResourceExtraData>(pMeshes->GetExtra());

	m_pSphereMesh = pData->m_pMeshes[0];

	///////////////////////////////////////////////
	//Antialiasing
	///////////////////////////////////////////////
	m_pNullLayout = nullptr;

	struct EmptyVertex {};
	EmptyVertex verts [] =
	{
		EmptyVertex(),
		EmptyVertex(),
		EmptyVertex(),
	};
	params.FillVertexBufferParams(0, 3, true, false, false, false);
	SubresourceData emptydata;
	data.SetData(verts);
//	m_pFullscreenEmpty->Create(&params, &emptydata, 3, 0);

	//m_pFXAAShaders->VSetVertexShader(L"Shaders\\FXAA.hlsl", "FXAA_VS", m_pLayout, 0, TOPOLOGY_TRIANGLELIST);
	//m_pFXAAShaders->VSetPixelShader(L"Shaders\\FXAA.hlsl", "FXAA_PS");
	m_pFXAAShaders->VSetVertexShader(L"Shaders\\FXAA_orig.hlsl", "FxaaVS", m_pLayout, 0, TOPOLOGY_TRIANGLESTRIP, "vs_5_0");
	m_pFXAAShaders->VSetPixelShader(L"Shaders\\FXAA_orig.hlsl", "FxaaPS", "ps_5_0");

	///////////////////////////////////////////////
	//Initialize data for blurring
	///////////////////////////////////////////////
	tex2DParams.Init(SCREEN_WIDTH, SCREEN_HEIGHT, 1, TEX_R32G32B32A32_FLOAT, true, true, false, false, 1, 0,
		1, true, false, false);
	m_pSSAOBlurredTexture->Create(&tex2DParams);

	srvSSAOParams.InitForTexture2D(tex2DParams.Format, 0, 0, false);
	m_pSSAOBlurredTexture->CreateShaderResourceView(&m_pSSAOBlurredSRV->m_pView, &srvSSAOParams);
	
	uavSSAOParams.InitForTexture2D(tex2DParams.Format, 0);
	m_pSSAOBlurredTexture->CreateUnorderedAccessView(&m_pSSAOBlurredUAV->m_pView, &uavSSAOParams);

	return true;
}