#include "renderpath/RenderPathOmniShadow.h"

#include "IScene.h"

namespace LifeGraphics { namespace RenderPath
{
	RenderPathOmniShadow::RenderPathOmniShadow(ShadowMapManager* sm)
		:IRenderPathShadow(sm)
	{
		pRenderer = CG::me()->GetRenderer();
		renderTarget = pRenderer->CreateRenderTargetCube(512, FORMAT_R32_FLOAT);

		depthTarget = pRenderer->CreateDepthTargetCube(512, FORMAT_D24_UNORM_S8_UINT);
		cbCamera = pRenderer->CreateConstantBuffer(sizeof(PER_CAMERA_CONSTANTS));

		//cbLight = pRenderer->CreateConstantBuffer(sizeof(POINT_LIGHT_DATA));
	}
	RenderPathOmniShadow::~RenderPathOmniShadow()
	{
	}
	void RenderPathOmniShadow::SetLight(const Light& _light)
	{
		light = _light;
	}
	void RenderPathOmniShadow::Render(IScene* pScene)
	{
		//top, bottom, left, right, front, back directions
		static LifeMath::float3 dir[6] =
		{
			LifeMath::float3( 1,  0,  0),
			LifeMath::float3(  -1,  0,  0),

			LifeMath::float3( 0,  1,  0),
			LifeMath::float3( 0, -1,  0),

			LifeMath::float3( 0,  0,  1),
			LifeMath::float3( 0,  0, -1),
		};

		LifeMath::float3 lightPos = light.getTransform()->GetPosition();

		//compute 6 cube face cameras
		for(int i = 0; i < 6; i++)
		{
			cam[i].setPosition(lightPos);
			cam[i].setDirection(dir[i] + lightPos);
			cam[i].setFov(3.1415f * 0.5f);
			cam[i].setAspect(1.0f);
			cam[i].setNear(0.1f);
			cam[i].setFar(light.getRange());
		}

		LifeMath::Rect2i vp(0,0,512,512);
		pRenderer->SetViewport(vp);

		//for render scene depth to 6 cube faces
		for(int i = 0; i < 6; i++)
		{
			//pRenderer->SetCubeTarget(NULL, depthTarget, i);
			//pRenderer->ClearRenderTarget()
			static LifeMath::float4 clearColor(0,0,0,0);
			pRenderer->ClearDepthStencil(depthTarget->getSurface(i), 1, 1.0f, 0);
			pRenderer->ClearRenderTarget(renderTarget->getSurface(i), &clearColor);
			pRenderer->SetTargets(renderTarget->getSurface(i), depthTarget->getSurface(i));

			frustumQuery.SetFrustum(*cam[i].getFrustum());
			frustumQuery.Filration = true;
			frustumQuery.filter = NT_MESH;
			//get all visible objects
			pScene->PerformQuery(&frustumQuery);

			int nc = frustumQuery.Size();

			PER_CAMERA_CONSTANTS pccs = {0};

			pccs.camNearFar = LifeMath::float4(cam[i].getNear(), cam[i].getFar(), 0.0f,0.0f);
			pccs.mView = cam[i].getView();
			pccs.mProj = cam[i].getProj();
			pccs.mInvVP = pccs.mView * pccs.mProj;
			LifeMath::float3 camPosl = cam[i].getPosition();
			LifeMath::float3 camDirl = cam[i].getDirection();
			pccs.camPos = camPosl;

			pccs.camDir = camDirl;

			cbCamera->Update(&pccs, sizeof(PER_CAMERA_CONSTANTS));
			pRenderer->SetVSConstantBuffer(cbCamera, 1);
			pRenderer->SetPSConstantBuffer(cbCamera, 1);

			pRenderer->SetDepthStencilState(pShadowManager->depthState);

			for(int j = 0; j < nc; j++)
			{
				IObject* mesh = static_cast<IObject*>(frustumQuery[j]);
				mesh->bind();

				for(int k = 0; k < mesh->getSumbeshCount(); k++)
				{
					IMaterialProxy* mat = mesh->getMaterial(k);
					mat->SelectTechnique(MT_RENDER_DEFERRED);
					mat->GetTechnique()->SelectPass(MP_DEPTH_SM);

					IMaterialPass* pass = mat->GetTechnique()->GetPass();
					pass->Apply();
					//pRenderer->SetVertexShader(mat->g_buffer_pass_vs);

					/*if(mat->diffuseMap.ptr())
					{
					pRenderer->SetPSTexture(mat->diffuseMap.ptr(), 0);
					}
					if(mat->AlphaTest || mat->AlphaBlendEnable)
					{
					pRenderer->SetPixelShader(pShadowManager->rtdCubePsAT);
					}
					else
					{
					pRenderer->SetPixelShader(pShadowManager->rtdCubePs);
					}*/
					mesh->render(k);
				}
			}
			frustumQuery.Flush();
			//IGraphicsNode* n = frustumQuery[0]->
		}

		//	renderTarget->ToFile("C:\\cube_shadow.dds");
	}
}}