#include "dxstdafx.h"
#include ".\OceanRenderer.h"
#include "GameManager.h"

OceanRenderer::OceanRenderer(void) : Renderer()
{ 
	this->setRenderPriority(20);
	this->rendererType |= Renderer::RENDERER_OCEAN;
}

OceanRenderer::~OceanRenderer(void)
{
	this->myScene->manager->releaseEffect(this->OceanEffect);
	this->OceanEffect = NULL;
}

void OceanRenderer::init() 
{
 
}

void OceanRenderer::setEffect(ID3DXEffect* effect) {
	this->OceanEffect = effect;

	//set technique handles:
	ShaderTechHandle = OceanEffect->GetTechniqueByName("PS20");
	ShaderTechHandleDepth = OceanEffect->GetTechniqueByName("PS20_Depth");

	//matrix handles:
	WorldViewProjectionHandle = OceanEffect->GetParameterByName(0, "wvpMatrix");
	WorldHandle = OceanEffect->GetParameterByName(0, "worldMatrix");
	WorldViewHandle = OceanEffect->GetParameterByName(0, "worldViewMatrix");
	ViewInverseHandle = OceanEffect->GetParameterByName(0, "viewInverseMatrix");

	//float handles:
	TimeHandle = OceanEffect->GetParameterByName(0, "time");
	RayHandle = OceanEffect->GetParameterByName(0, "forRaytracer");

	float nearPlane = this->myScene->getActiveCamera()->getNearClipping();
	float farPlane = this->myScene->getActiveCamera()->getFarClipping();
	FarPlaneMinusNearPlaneHandle = OceanEffect->GetParameterByName(0, "FarPlaneMinusNearPlane");
	OceanEffect->SetFloat(FarPlaneMinusNearPlaneHandle, farPlane - nearPlane);

	this->angle = 0;
}

void OceanRenderer::render() 
{
	this->device->BeginScene();
	SPTR<Node> node = this->myNode.lock();
	Object3d *obj = (Object3d *) (node.get());
    if(obj!=NULL && obj->isModelLoaded()) {
		//if(this->myScene->getActiveRenderPass() == NULL) {
		UINT numPasses = 0;
		switch(this->myScene->getActivePassId()) {
			case Scene::PASS_NORMAL:
				// set the technique to use
				OceanEffect->SetTechnique( ShaderTechHandle );
				
				D3DXMatrixMultiply(&this->worldViewMat, &this->myScene->getWorldMatrix(), &this->myScene->getViewMatrix());
				D3DXMatrixMultiply(&this->worldViewProjMat, &this->worldViewMat, &this->myScene->getProjectionMatrix());
				D3DXMatrixInverse(&viewInverseMatrix, 0, &this->myScene->getViewMatrix());

				OceanEffect->SetMatrix(WorldViewHandle, &this->worldViewMat);
				OceanEffect->SetMatrix(WorldViewProjectionHandle, &this->worldViewProjMat);
				OceanEffect->SetMatrix(WorldHandle, &this->myScene->getWorldMatrix());
				OceanEffect->SetMatrix(ViewInverseHandle, &this->viewInverseMatrix);
				
				//this->angle += 0.01f;
				//OceanEffect->SetFloat(TimeHandle, angle);
				//textur-wellen:
				this->angle += 0.05f;
				OceanEffect->SetFloat(TimeHandle, (float)sin(angle / 4.0f));
				
				OceanEffect->SetBool(RayHandle, false);
				
				OceanEffect->Begin(&numPasses, 0);
				for(UINT j = 0; j < numPasses; j++)
				{		
					this->device->SetTexture(0, obj->Textures[0]);
					// begin effect render pass
					OceanEffect->BeginPass(j);
					
					this->device->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
					this->device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);

					this->device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
					this->device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
										
					if(obj->isPMesh()) {
						(*obj->getProgressiveMesh())->DrawSubset(0);	
					} else {
						(*obj->getMesh())->DrawSubset(0);
					}
					
					this->device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);

					// end effect render pass
					OceanEffect->EndPass();
				}

				this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);

				OceanEffect->End();
				break;
			case Scene::PASS_RAYTRACE:
				// set the technique to use
				//this->device->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED );
				OceanEffect->SetTechnique( ShaderTechHandle );
				
				D3DXMatrixMultiply(&this->worldViewMat, &this->myScene->getWorldMatrix(), &this->myScene->getViewMatrix());
				D3DXMatrixMultiply(&this->worldViewProjMat, &this->worldViewMat, &this->myScene->getProjectionMatrix());
				D3DXMatrixInverse(&viewInverseMatrix, 0, &this->myScene->getViewMatrix());

				OceanEffect->SetMatrix(WorldViewHandle, &this->worldViewMat);
				OceanEffect->SetMatrix(WorldViewProjectionHandle, &this->worldViewProjMat);
				OceanEffect->SetMatrix(WorldHandle, &this->myScene->getWorldMatrix());
				OceanEffect->SetMatrix(ViewInverseHandle, &this->viewInverseMatrix);
				
				//this->angle += 0.01f;
				//OceanEffect->SetFloat(TimeHandle, (float)sin(angle / 4.0f));
				//OceanEffect->SetFloat(TimeHandle, angle);
				OceanEffect->SetBool(RayHandle, true);
				OceanEffect->CommitChanges();
				
				OceanEffect->Begin(&numPasses, 0);
				for(UINT j = 0; j < numPasses; j++)
				{		
					this->device->SetTexture(0, obj->Textures[0]);
					// begin effect render pass
					OceanEffect->BeginPass(j);
					
					this->device->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
					
					if(obj->isPMesh()) {
						(*obj->getProgressiveMesh())->DrawSubset(0);	
					} else {
						(*obj->getMesh())->DrawSubset(0);
					}
					
					// end effect render pass
					OceanEffect->EndPass();
				}

				this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);

				OceanEffect->End();
				//this->device->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED );
				break;
			case Scene::PASS_DEPTH:
				// set the technique to use
				OceanEffect->SetTechnique( ShaderTechHandleDepth );
				this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);
				D3DXMatrixMultiply(&this->worldViewMat, &this->myScene->getWorldMatrix(), &this->myScene->getViewMatrix());
				D3DXMatrixMultiply(&this->worldViewProjMat, &this->worldViewMat, &this->myScene->getProjectionMatrix());
				
				OceanEffect->SetMatrix(WorldViewProjectionHandle, &this->worldViewProjMat);

				D3DXMATRIX worldMat;
				D3DXMatrixIdentity(&worldMat);
				this->device->SetTransform( D3DTS_WORLD, &worldMat);
				this->device->SetTransform( D3DTS_PROJECTION, this->myScene->getActiveCamera()->getProjectionMatrix());
				this->device->SetTransform( D3DTS_VIEW, this->myScene->getActiveCamera()->getViewMatrix());
				
				//this->angle += 0.01f;
				//OceanEffect->SetFloat(TimeHandle, (float)sin(angle / 4.0f));
				//OceanEffect->SetFloat(TimeHandle, angle);
				OceanEffect->SetBool(RayHandle, false);
				OceanEffect->CommitChanges();
				
				OceanEffect->Begin(&numPasses, 0);
				for(UINT j = 0; j < numPasses; j++)
				{		
					this->device->SetTexture(0, obj->Textures[0]);
					// begin effect render pass
					OceanEffect->BeginPass(j);
					
					this->device->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
					
					if(obj->isPMesh()) {
						(*obj->getProgressiveMesh())->DrawSubset(0);	
					} else {
						(*obj->getMesh())->DrawSubset(0);
					}
					
					// end effect render pass
					OceanEffect->EndPass();
				}

				this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);

				OceanEffect->End();
				break;
		}
	}
	this->device->EndScene();
}

void OceanRenderer::OnLostDevice( void* pUserContext )
{
	HRESULT hr;
	this->myScene->manager->printToConsole(" OnLostDevice OceanRenderer");
	V( this->OceanEffect->OnLostDevice() );
}

void OceanRenderer::OnDestroyDevice( void* pUserContext )
{
	this->myScene->manager->printToConsole(" OnDestroyDevice OceanRenderer");
	this->myScene->manager->releaseEffect(this->OceanEffect);
	this->OceanEffect = NULL;
}

HRESULT OceanRenderer::OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
	this->device = pd3dDevice;
	this->OceanEffect = this->myScene->manager->getEffect(GameManager::EFFECT_OCEAN);
	if(!this->OceanEffect) {
		this->OceanEffect = this->myScene->manager->loadEffect(GameManager::EFFECT_OCEAN, L"shaders/Ocean.obj");
	}
	this->setEffect(this->OceanEffect);
	return S_OK;
}

bool OceanRenderer::isLowerThan(Renderer* renderer)
{
	return this->getRenderPriority() < renderer->getRenderPriority();
}