#include "Ogre.h"
#include <vector>
#include <cmath> 
#include "OgreEffectWrapper.h"
#include "ManagedOgreRenderTexturePass.h"


const char* ManagedOgreRenderTexturePass::noRenderTargetName="NO_RENDER_TEXTURE";
MovablePlane* ManagedOgreRenderTexturePass::fullScreenQuad=NULL;
Entity* ManagedOgreRenderTexturePass::fullScreenQuadEntity=NULL;
SceneNode* ManagedOgreRenderTexturePass::fullScreenQuadSceneNode=NULL;

ManagedOgreRenderTexturePass::ManagedOgreRenderTexturePass(
			
			Root* mRoot, const String& renderTextureName,unsigned int width,unsigned int height,
		 	TextureType texType , PixelFormat internalFormat, 
			const NameValuePairList *miscParams,bool fullScreenQuadRenderer
			
			){
	
	this->mRoot=mRoot;
	renderSystem=mRoot->getRenderSystem();
	mSceneMgr=mRoot->getSceneManager(ST_GENERIC);
	if(renderTextureName!=noRenderTargetName){
		renderTexture=renderSystem->createRenderTexture(renderTextureName,width,height,texType,internalFormat,miscParams);
		this->addRenderTarget(renderTexture);
	}
	if(!fullScreenQuad){
		createFullScreenQuad();
	}
	this->fullScreenQuadRenderer=fullScreenQuadRenderer;
	effectWrapper=new EffectWrapper();
}

void ManagedOgreRenderTexturePass::createFullScreenQuad(){
	fullScreenQuad=new MovablePlane(Vector3::UNIT_Y,0.0f);
	MeshManager::getSingleton().createPlane("FullScreenQuad", 
        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
        *fullScreenQuad, 1, 1, 
        1, 1, true, 1, 1, 1, Vector3::UNIT_Z);
	this->fullScreenQuadEntity=mSceneMgr->createEntity("FullScreenQuad","FullScreenQuadEntity");
	SceneNode* rootNode = mSceneMgr->getRootSceneNode();
	fullScreenQuadSceneNode=rootNode->createChildSceneNode();
	mPlaneNode->attachObject(fullScreenQuadEntity);
    mPlaneNode->attachObject(fullScreenQuad);
	//camera setup.
}

void ManagedOgreRenderTexturePass::entityMaterialSetup(){
	SceneManager::EntityIterator entityIterator=mSceneMgr->getEntityIterator();
	while(entityIterator.hasMoreElements()){
		Entity* entity=entityIterator.getNext();
		entity->setMaterialName(this->effectWrapper->getMaterial()->getName());
		if(fullScreenQuadRenderer){
			entityVisibilityList.push_back(entity->isVisible());
			entity->setVisible(false);
		}
	}
	if(fullScreenQuadRenderer){
		this->fullScreenQuadSceneNode->setVisible(true);
	}
}

void ManagedOgreRenderTexturePass::entityMaterialCleanup(){
	if(fullScreenQuadRenderer){
		SceneManager::EntityIterator entityIterator=mSceneMgr->getEntityIterator();
		int elementNumber=0;
		while(entityIterator.hasMoreElements()){
			Entity* entity=entityIterator.getNext();
			entity->setVisible(entityVisibilityList.at(elementNumber));
			elementNumber++;
		}
		entityVisibilityList.clear();
		this->fullScreenQuadSceneNode->setVisible(false);
	}
}

void ManagedOgreRenderTexturePass::update(NameValuePairList* startParams,NameValuePairList* endParams){
	onRenderStart(startParams);
	entityMaterialSetup();
	RenderTarget* rt=renderTargets.at(0);
	Matrix4* worldMatrices=new Matrix4[rt->getViewport(0)->getCamera()->getNumWorldTransforms()];
	rt->getViewport(0)->getCamera()->getWorldTransforms(worldMatrices);
	Matrix4 viewMatrix=renderTexture->getViewport(0)->getCamera()->getViewMatrix();
	Matrix4 projMatrix=renderTexture->getViewport(0)->getCamera()->getProjectionMatrix();
	std::vector<Viewport*> viewports;
	std::vector<RenderTarget*>::iterator rtIterator;
	for(rtIterator=renderTargets.begin();rtIterator!=renderTargets.end();rtIterator++){
		viewports.push_back((*rtIterator)->getViewport(0));
	}
	Matrix4 worldMatrix = Matrix4::IDENTITY;
	for(int i=0;i<rt->getViewport(0)->getCamera()->getNumWorldTransforms();i++){
		worldMatrix = worldMatrix * worldMatrices[i];
	}
	delete[] worldMatrices;
	mRoot->getSceneManager(ST_GENERIC)->manualRender(effectWrapper->getMaterial()->getTechnique(0)->getPass(0),viewports,this->cubeMapFaces,worldMatrix,viewMatrix,projMatrix,true);
	entityMaterialCleanup();
	onRenderEnd(endParams);
}

bool ManagedOgreRenderTexturePass::changeTexture(const String& textureName, unsigned short textureUnit){
	this->effectWrapper->SetTexture(textureUnit,textureName);
	return false;
}

bool ManagedOgreRenderTexturePass::changeMaterial(String& materialName, StringVector& newTextureNames,bool useOldTextureNames){
	effectWrapper->createMaterial(materialName);
	this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
	std::vector<TextureUnitState*>::iterator iter;
	for(iter=usedTextureUnitStates.begin();iter<usedTextureUnitStates.end();iter++){
		usedTextureUnitStates.erase(iter);
	}
	if(!useOldTextureNames){
		textureNames=newTextureNames;
	}
	std::vector<String>::iterator iter2;
	int i=0;
	for(iter2=textureNames.begin();iter2<textureNames.end();iter2++){
		TextureUnitState* t = this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->createTextureUnitState((*iter2),i);
		i++;
		usedTextureUnitStates.push_back(t);
	}
	return true;
}

void ManagedOgreRenderTexturePass::oneTimeRenderToTextureSetup(String& materialName,StringVector& textureNames){
	std::vector<String>::iterator iter;
	this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
	int i=0;
	for(iter=textureNames.begin();iter<textureNames.end();iter++){
		TextureUnitState* t = this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->createTextureUnitState((*iter),i);
		i++;
		usedTextureUnitStates.push_back(t);
	}
	effectWrapper->createMaterial(materialName);
}