#include "dxstdafx.h"
#include ".\scene.h"
#include "GameManager.h"
#include "Object3d.h"
#include "Box.h"
#include "Sprite.h"
#include "ParticleGroup.h"
#include "ParticleEmitter.h"
#include "SoundNode.h"
#include "SharedResourceTexture.h"
#include "fmod.h"

Scene::Scene(void)
{
	this->sceneAlpha = 1;
	this->root.setScene(*this);
	this->sceneLifeTime = 0;
	this->usePhysXDebugger = true;

	//Fade Stuff
	this->visible = true;
	this->fadeState = NOFADE;

	//Gravity
	this->pDefaultGravity.x = 0;
	this->pDefaultGravity.y = -9.8f;
	this->pDefaultGravity.z = 0;

	//Frustum Stuff
	this->enableFrustumCulling = true;
	this->drawBBoxes = true;
	this->boundingBox = NULL;
	this->quadTreeBuilt = false;

	//RenderChain Timing usw
	QueryPerformanceFrequency(&this->frequency);
	this->firstFrame = true;
	
	//PhysicStuff
	this->pScene = NULL;
	D3DXMatrixIdentity(&this->worldMatrix);
	D3DXMatrixIdentity(&this->identMatrix);
	
	this->root.myScene = this;
	this->contactReport = NULL;
	this->triggerReport = NULL;
	this->notifyReport = NULL;

	//Get the Device
	this->device = DXUTGetD3DDevice();
	this->physxRenderer.setDevice(*this->device);

	//Sun Stuff
	this->sunDirection.setXYZ(-1.0f, -2.0f, 1.0f);
	this->specialRenderer = NULL;

	//DefaultRenderPass konfigurieren
	this->activeRenderPass = NULL;

	//Particle Group Stuff
	this->particleGroupCounter = 0;

	this->finalImage = NULL;
	this->preDistortionFinal = NULL;
	this->distortionMap1 = NULL;
	this->distortionMap2 = NULL;
	this->screenDistortionMap = NULL;
	this->quadMesh = NULL;
	this->meshCreated = false;
	this->depthTextureResource = NULL;
	this->useDepthImposter = true;
	this->useRaytracer = true;

	this->muteMusic = false;
}

Scene::~Scene(void)
{
	SAFE_RELEASE(this->finalImage);
	SAFE_RELEASE(this->finalImageSurface);
	SAFE_RELEASE(this->quadMesh);
	SAFE_RELEASE(this->depthSurface);
	SAFE_RELEASE(this->preDistortionFinal);
	SAFE_RELEASE(this->preDistortionFinalSurface);
	SAFE_RELEASE(this->screenDistortionMapSurface);
}

void Scene::initScene(GameManager &_manager)
{
	HRESULT hr;
	
	this->manager = &_manager;
	
	//Textur für endgültiges Bild erzeugen
	if(!this->finalImage) {
		//Create Texture
		V( DXUTGetD3DDevice()->CreateTexture(this->manager->screenWidth, this->manager->screenHeight, 1, D3DUSAGE_RENDERTARGET, 
		D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &this->finalImage, NULL ) );

		//Get Surface for RenderTarget
		this->finalImage->GetSurfaceLevel(0, &this->finalImageSurface);
	}
	
	this->sceneLifeTime = 0;
	this->firstFrame = true;
	
	this->defaultParticleGroup = (ParticleGroup*) this->createNode(Scene::NODE_PARTICLEGROUP, false);
	this->initPhysic();
	this->boundingBox = (Box*) this->createNode(Scene::NODE_BOX);
	this->boundingBox->setVisible(false);
	this->boundingBox->setStandBy(true);
	
	//Camera Stuff
	this->defaultCamera = (Camera *) this->createNode(this->NODE_CAMERA);
	this->activeCamera = this->defaultCamera;

	//Default RenderPass
	this->defaultRenderPass.setSafeAndRestoreRenderTarget(false);
	this->defaultRenderPass.setScene(*this);
	this->defaultRenderPass.setRenderPassId(Scene::PASS_NORMAL);
	this->defaultRenderPass.setRenderTarget(this->finalImageSurface);
	this->defaultRenderPass.execute(RenderPass::CMD_CLEARRENDERTARGETANDZBUFFER);
	this->defaultRenderPass.execute(RenderPass::CMD_RENDERNODES);
	
	//Depth RenderPass
	this->depthTextureResource = (SharedResourceTexture*) this->getSharedResource(Scene::SR_TEXTURE_VIEWDEPTH);
	if(!this->depthTextureResource) {
		if(this->depthSurface){
			SAFE_RELEASE (this->depthSurface);
		}
		this->depthTextureResource = (SharedResourceTexture*) this->createSharedResource(Scene::SR_TEXTURE_VIEWDEPTH);
		this->depthTextureResource->getTexture()->GetSurfaceLevel(0, &this->depthSurface);
	}
	
	//Load DistortionMaps
	if(!this->distortionMap1)
		this->distortionMap1 = this->manager->resManager.loadTexture("./media/textures/heatnoise.tga");
	if(!this->distortionMap2) 
		this->distortionMap2 = this->manager->resManager.loadTexture("./media/textures/heatnoise2.tga");
	if(!this->screenDistortionMap) {
		SharedResourceTexture* distMap = (SharedResourceTexture*) this->createSharedResource(Scene::SR_TEXTURE_DISTORTION);
		this->screenDistortionMap = distMap->getTexture();
		this->screenDistortionMap->GetSurfaceLevel(0, &this->screenDistortionMapSurface);
	}

	if(!this->preDistortionFinal) {
		//Create Texture
		V( DXUTGetD3DDevice()->CreateTexture(this->manager->screenWidth, this->manager->screenHeight, 1, D3DUSAGE_RENDERTARGET, 
		D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &this->preDistortionFinal, NULL ) );

		//Get Surface for RenderTarget
		this->preDistortionFinal->GetSurfaceLevel(0, &this->preDistortionFinalSurface);
	}

	this->depthRenderPass.setSafeAndRestoreRenderTarget(false);
	this->depthRenderPass.setScene(*this);
	this->depthRenderPass.setRenderPassId(Scene::PASS_DEPTH);
	this->depthRenderPass.setRenderTarget(this->depthSurface);
	this->depthRenderPass.execute(RenderPass::CMD_CLEARRENDERTARGETANDZBUFFER);
	this->depthRenderPass.execute(RenderPass::CMD_RENDERNODES);
	this->depthRenderPass.useThisRendererList(this->defaultRenderPass.usedRendererList);

	//Raytrace RenderPass
	this->raytraceRenderPass.setSafeAndRestoreRenderTarget(false);
	this->raytraceRenderPass.setScene(*this);
	this->raytraceRenderPass.setRenderPassId(Scene::PASS_RAYTRACE);
	this->raytraceRenderPass.execute(RenderPass::CMD_CLEARRENDERTARGETANDZBUFFER);
	this->raytraceRenderPass.execute(RenderPass::CMD_DOFRUSTUMCULLING);
	this->raytraceRenderPass.execute(RenderPass::CMD_RENDERNODES);

}

float Scene::getSceneLiveTime()
{
	return this->sceneLifeTime;
}

void Scene::setVisible(bool _visible)
{
	this->visible = _visible;
}

bool Scene::isVisible() 
{
	return this->visible;
}
void Scene::fadeIn(float _duration)
{
	this->fadeDuration = _duration;
	this->fadeTimer = 0;
	this->fadeState = FADEIN;
	this->setVisible(true);
}
void Scene::fadeOut(float _duration)
{
	this->fadeDuration = _duration;
	this->fadeTimer = 0;
	this->fadeState = FADEOUT;
}

void Scene::setSceneAlpha(float _alpha) 
{
	if(_alpha>1) _alpha = 1;
	if(_alpha<0) _alpha = 0;
	this->sceneAlpha = _alpha;
}

Node* Scene::getRoot()
{
	return &this->root;
}

void Scene::clearScene() {
	this->root.removeAllChildren();
	this->cleanUpScene();
	
	this->nodeList.clear();
	this->particleList.clear();
	this->rendererList.clear();
	this->refObject3dList.clear();
	this->refCameraList.clear();
	this->refSoundList.clear();
	this->triggerList.clear();
	this->particleGroupVector.clear();
	this->clearSharedResources();
	this->sharedResourceVector.clear();
	this->visibleNodeList.clear();
	this->soundNodeList.clear();
	//this->usedRendererList.clear();
	this->zombieNodeList.clear();

	if(this->manager && this->manager->pPhysicsSDK) {
		this->manager->pPhysicsSDK->releaseScene(*this->pScene);
		this->pScene = NULL;
	}
}

void Scene::setWidth(float _w)
{
	this->width = _w;
}

void Scene::setHeight(float _h)
{
	this->height = _h;
}

void Scene::setDepth(float _d)
{
	this->depth = _d;
}

float Scene::getWidth()
{
	return this->width;
}

float Scene::getHeight()
{
	return this->height;
}

float Scene::getDepth() 
{
	return this->depth;
}

Camera* Scene::getActiveCamera()
{
	return this->activeCamera;
}

NxSceneDesc* Scene::getPhysicSceneDescriptor() 
{
	return &this->sceneDesc;
}

bool Scene::initPhysic()
{
    // Create the scene
	this->manager->pPhysicsSDK->setParameter(NX_SKIN_WIDTH, (NxReal)0.01);
    if(this->usePhysXDebugger) {
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZATION_SCALE, 5.0f);
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZE_COLLISION_SHAPES, 1);
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZE_ACTOR_AXES, 1);
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZE_JOINT_LOCAL_AXES, 1.0f);
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZE_JOINT_WORLD_AXES, 1);
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZE_JOINT_ERROR, 1);
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZE_JOINT_LIMITS, 1);
		this->manager->pPhysicsSDK->setParameter(NX_VISUALIZE_JOINT_FORCE, 1);
	}
	this->sceneDesc.gravity = pDefaultGravity;
    this->sceneDesc.collisionDetection = true;
	if(this->pScene!=NULL) {
		this->manager->pPhysicsSDK->releaseScene(*this->pScene);
	}
    this->pScene = this->manager->pPhysicsSDK->createScene(this->sceneDesc);
	if(this->contactReport) this->pScene->setUserContactReport(this->contactReport);
	if(this->triggerReport) this->pScene->setUserTriggerReport(this->triggerReport);
	if(this->notifyReport) this->pScene->setUserNotify(this->notifyReport);
	this->pScene->setTiming(1.0f/60.0f, 8, NX_TIMESTEP_FIXED);
	
	// Create the default material
    NxMaterial* defaultMaterial = this->pScene->getMaterialFromIndex(0); 
    defaultMaterial->setRestitution(0.5);
    defaultMaterial->setStaticFriction(0.5);
    defaultMaterial->setDynamicFriction(0.5);

	return true;
}

float Scene::getDeltaTime()
{
	return this->dt;
}

void Scene::buildQuadTree()
{
	this->fcQuad.setDimension(this->getWidth(), this->getWidth());
	this->fcQuad.setPosition(this->getWidth()/2, this->getWidth()/2);
	this->fcQuad.buildQuadTree(QUADLEVEL);
	this->quadTreeBuilt = true;
}

RenderPass* Scene::getActiveRenderPass()
{
	return this->activeRenderPass;
}

void Scene::renderScene(float fElapsedTime) 
{
	if(this->isVisible()) {
		if(this->device==0) {
			this->device = DXUTGetD3DDevice();
			this->physxRenderer.setDevice(*this->device);
		}
		this->device->SetRenderTarget(0, this->finalImageSurface);

		this->takeTime();
		//ClearScreen
		//this->clearRenderTargetAndZBuffer();
		//Clear SharedResources
		this->clearSharedResources();
		//Fetch Physic Results
		this->fetchPhysicResults();
		//Fading Stuff
		this->doFade();
		//Trigger updates
		this->updateTrigger();
		//Update Nodes
		this->updateNodes();
		//Calculate Transformations
		this->calculateTransformations();
		
		//startRenderPasses
		this->startRenderPasses();

		//Cleanup Memory
		this->cleanUpScene();
		//Start Physic
		this->startPhysic();

		this->firstFrame = false;
	}
}

void Scene::takeTime()
{
	//Take time
	if(this->firstFrame) {
		QueryPerformanceCounter(&this->currentFrame);
		this->lastFrame = this->currentFrame;
		return;
	} else {
		this->lastFrame = this->currentFrame;
		QueryPerformanceCounter(&this->currentFrame);
	}
	double tempdt;
	tempdt = (double)(this->currentFrame.QuadPart-this->lastFrame.QuadPart)/(double)this->frequency.QuadPart;
	this->dt = (float) tempdt;	
	this->dt = min(0.033f, this->dt);
}

void Scene::fetchPhysicResults()
{
	if(!this->firstFrame) {
		this->pScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
	}
}

void Scene::doFade()
{
	switch(this->fadeState) 
	{
		case FADEOUT:
			this->fadeTimer+=this->dt;
			this->sceneAlpha -= this->dt/this->fadeDuration;
			if(this->sceneAlpha<=0) {
				this->setVisible(false);
				this->fadeState = NOFADE;
				this->sceneAlpha = 0;
			}
			this->updateSoundNodeVolume();
			break;
		case FADEIN:
			if(!this->visible)
				this->setVisible(true);
			this->fadeTimer+=this->dt;
			this->sceneAlpha+=this->dt/this->fadeDuration;
			if(this->sceneAlpha>=1) {
				this->fadeState = NOFADE;
				this->sceneAlpha = 1;
			}
			this->updateSoundNodeVolume();
			break;
		default:
			break;
	}
}

void Scene::updateTrigger()
{
	this->sceneLifeTime+=this->getDeltaTime();
	std::vector<SPTR<Trigger> >::iterator it;
	for(it=this->triggerList.begin();it!=this->triggerList.end();it++) {
		if(this->sceneLifeTime>(*it)->getTime()) {
			this->executeTrigger(*it);
			this->triggerList.erase(it);
			it--;
		} else {
			return;
		}
	}

	for(UINT i=0;i<this->triggerList.size();i++) {
		if(this->sceneLifeTime>this->triggerList.at(i)->getTime()) {
			this->executeTrigger(this->triggerList.at(i));
			i--;
		} else {
			return;
		}
	}
}

void Scene::updateNodes() 
{
	this->root.update(this->dt);
}


void Scene::calculateTransformations() 
{
	//Object transformation
	this->root.calcWorldMatrix(this->worldMatrix);
	this->root.updateBBox();
}



void Scene::doFrustumCulling()
{
	Camera cam;
	cam.setViewMatrix(*this->activeRenderPass->getViewMatrix());
	cam.setProjectionMatrix(*this->activeRenderPass->getProjectionMatrix());
    
	std::vector<Renderer *>* usedRendererList;
	usedRendererList = this->activeRenderPass->usedRendererList;

	std::list<SPTR<Node> >::iterator nodeIt;
	Node* node;

	if(!this->quadTreeBuilt)
		this->buildQuadTree();
	usedRendererList->clear();

	Renderer *renderer;

	if(this->enableFrustumCulling) {
		Plane view[4];
		
		view[0] = cam.getNearPlane();
		view[1] = cam.getFarPlane();
		view[2] = cam.getLeftPlane();
		view[3] = cam.getRightPlane();
		this->fcQuad.clipQuadAgainstCamera(&view[0]);

		for(nodeIt = this->nodeList.begin(); nodeIt!=this->nodeList.end();nodeIt++) {
			node = (*nodeIt).get();
			if(!node->onStandBy() && node->visible && node->hasRenderer() &&  node->testAgainstFrustum && this->fcQuad.nodeInside(node)) {	
				renderer = node->getRenderer().get();
				if(this->activeRenderPass == &this->defaultRenderPass) {
					if(renderer->isA(Renderer::RENDERER_PARTICLE)) {
						this->needDepthPass |= renderer->needsExtraPass();
						if(((ParticleRenderer*) renderer)->needHeatHazePass()) {
							this->needDistortionPass = true;
							this->heatHazeParticleRendererList.push_back((ParticleRenderer*) renderer);
						}
					} else if(renderer->isA(Renderer::RENDERER_RAYTRACE)) {
						this->needRaytracePass = true;
						this->raytraceRendererList.push_back((RaytraceRenderer*) renderer);
					}
				}
				usedRendererList->push_back(renderer);
			} else if(!node->onStandBy() && node->visible && node->hasRenderer() && !node->testAgainstFrustum) {
				renderer = node->getRenderer().get();
				if(this->activeRenderPass == &this->defaultRenderPass) {
					if(renderer->isA(Renderer::RENDERER_PARTICLE)) {
						this->needDepthPass |= renderer->needsExtraPass();
						if(((ParticleRenderer*) renderer)->needHeatHazePass()) {
							this->needDistortionPass = true;
							this->heatHazeParticleRendererList.push_back((ParticleRenderer*) renderer);
						}
					} else if(renderer->isA(Renderer::RENDERER_RAYTRACE)) {
						this->needRaytracePass = true;
						this->raytraceRendererList.push_back((RaytraceRenderer*) renderer);
					}
				}
				usedRendererList->push_back(renderer);
			}
		}
	} else {	
		for(nodeIt = this->nodeList.begin(); nodeIt!=this->nodeList.end();nodeIt++) {
			node = (*nodeIt).get();
			if(!node->onStandBy() && node->visible && node->hasRenderer()) {	
				renderer = node->getRenderer().get();
				if(this->activeRenderPass == &this->defaultRenderPass) {
					if(renderer->isA(Renderer::RENDERER_PARTICLE)) {
						this->needDepthPass |= renderer->needsExtraPass();
						if(((ParticleRenderer*) renderer)->needHeatHazePass()) {
							this->needDistortionPass = true;
							this->heatHazeParticleRendererList.push_back((ParticleRenderer*) renderer);
						}
					} else if(renderer->isA(Renderer::RENDERER_RAYTRACE)) {
						this->needRaytracePass = true;
						this->raytraceRendererList.push_back((RaytraceRenderer*) renderer);
					}
				}
				usedRendererList->push_back(renderer);
			}
		}
	}
}

void Scene::doViewingTransformation() 
{
	this->device->SetTransform(D3DTS_VIEW, this->activeCamera->getViewMatrix() );
}


void Scene::renderNodes()
{
	std::vector<Renderer *>* usedRendererList;
	usedRendererList = this->activeRenderPass->usedRendererList;

	//Sorts the rendering processes by its priority!
	std::sort(usedRendererList->begin(), usedRendererList->end(), renderSortFunction());

	std::vector<Renderer *>::iterator it;
	for(it=usedRendererList->begin();it!=usedRendererList->end();it++) {
		if((*it) == 0) {
			this->manager->printToConsole("Renderer in usedRenderList is NULL!!!!");
		}
		if((*it)->nodeAdded) {
			SPTR<Node> n = (*it)->myNode.lock();
			if(!n->onStandBy() && n->visible) {
				this->worldMatrix = *n->getWorldMatrix();
				(*it)->render();
			}
		}
	}
	if(this->usePhysXDebugger && this->activeRenderPass==&this->defaultRenderPass) {
		D3DXMATRIX worldMat;
		D3DXMatrixIdentity(&worldMat);
		this->device->SetTransform( D3DTS_WORLD, &worldMat);
		this->device->SetTransform( D3DTS_PROJECTION, this->activeCamera->getProjectionMatrix());
		this->device->SetTransform( D3DTS_VIEW, this->activeCamera->getViewMatrix());
		const NxDebugRenderable *dbgRenderable = pScene->getDebugRenderable();
		this->physxRenderer.render(*dbgRenderable);
		this->device->SetTransform( D3DTS_PROJECTION, &worldMat);
		this->device->SetTransform( D3DTS_VIEW, &worldMat);
	}
	/*D3DXMatrixIdentity(&this->worldMatrix);
	if(this->drawBBoxes && this->boundingBox!=NULL) {
		for(it=this->usedRendererList.begin();it!=this->usedRendererList.end();it++) {
			SPTR<Node> n = (*it)->myNode.lock();
			D3DXMATRIX tMat;
			Vector dim = *n->getAbsMaxBBox() - *n->getAbsMinBBox();
			Vector absPos;
			absPos = *n->getAbsMinBBox()+dim/2;
			D3DXMatrixTranslation(&tMat, absPos.x, absPos.y, absPos.z);
			this->device->SetTransform( D3DTS_WORLD, &tMat);
			
			this->boundingBox->setDimension(dim.x,  dim.y, dim.z);
			this->boundingBox->getRenderer()->render();
		}
	}*/
}

void Scene::cleanUpScene()
{
	std::list<SPTR<Node> >::iterator it;
	std::list<SPTR<Node> >::iterator nit;
	std::vector<SPTR<Renderer> >::iterator rit;
	Node* node;
	for(it=this->zombieNodeList.begin();it!=this->zombieNodeList.end();it++) {
		node = (*it).get();
		node->getFather()->removeChild(*it);

		//Delete Renderer
		if(node->hasRenderer())
		{
			Renderer *r = node->getRenderer().get();
			for(rit=this->rendererList.begin();rit!=this->rendererList.end();rit++) {
				if((*rit).get() == r)
				{
					this->rendererList.erase(rit);
					break;
				}
			}
		}

		//Delete Physic Actor
		if(node->getActor()!=NULL)
		{
			this->pScene->releaseActor(*node->getActor());
		}

		//Delete from NodeList
		this->deleteNodeInList(node, this->nodeList);
		this->deleteNodeInList(node, this->particleList);
		this->deleteNodeInList(node, this->soundNodeList);
	}
	this->zombieNodeList.clear();
}

void Scene::deleteNodeInList(Node* node, std::list<SPTR<Node> > &list) {
	std::list<SPTR<Node> >::iterator it;
	for(it=list.begin();it!=list.end();it++) {
		if((*it).get() == node)
		{
			list.erase(it);
			break;
		}
	}
}

void Scene::deleteRendererInList(Renderer* renderer) {
	// remove particle renderer
	std::vector<SPTR<Renderer> >::iterator it;
	for(it=rendererList.begin();it!=rendererList.end();it++) {
		if((*it).get() == renderer) {
			rendererList.erase(it);
			break;
		}
	}
}

void Scene::startPhysic()
{
	this->pScene->simulate(this->dt);
	this->pScene->flushStream();
}

void Scene::clearRenderTargetAndZBuffer()
{
	DXUTGetD3DDevice()->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(255, 0, 0, 0), 1.0f, 0);
}

//Clear SharedResources
void Scene::clearSharedResources()
{
	for(UINT i=0;i<this->sharedResourceVector.size();i++) {
		this->sharedResourceVector.at(i)->setResourceAvailable(false);
	}
}

void Scene::setKeyPressed(UINT key, bool bKeyPressed) 
{
	this->keyDown[key] = bKeyPressed;
}

void Scene::setMouseStatus(bool bLeftButtonDown,  bool bRightButtonDown,bool bMiddleButtonDown,
						bool bSideButton1Down, bool bSideButton2Down, int nMouseWheelDelta,
						int xPos, int yPos)
{
	this->mouseButton[MOUSE_LEFT]	= bLeftButtonDown;
	this->mouseButton[MOUSE_RIGHT]	= bRightButtonDown;
	this->mouseButton[MOUSE_MIDDLE] = bMiddleButtonDown;
	this->mouseButton[MOUSE_SIDE1] = bSideButton1Down;
	this->mouseButton[MOUSE_SIDE2]	= bSideButton2Down;
	this->mousePos[0] = xPos;
	this->mousePos[1] = yPos;
	this->mouseWheel = nMouseWheelDelta;
}

Node* Scene::createNode(int type)
{
	return this->createNode(type, this->root, true, false);
}

Node* Scene::createNode(int type, Node &father)
{
	return this->createNode(type, father, true, false);
}

Node* Scene::createNode(int type, bool addDefaultRenderer)
{
	return this->createNode(type, this->root, addDefaultRenderer, false);
}

Node* Scene::createNode(int type, Node &father, bool addDefaultRenderer) {
	return this->createNode(type, father, addDefaultRenderer, false);
}

Node* Scene::createReferenceNode(int type, bool addDefaultRenderer)
{
	Node* n=0;
	Node* newNode = this->createNode(type, *n, addDefaultRenderer, true);
	newNode->setStandBy(true);
	return newNode;
}

Node* Scene::createNode(int type, Node &father, bool addDefaultRenderer, bool isReference)
{
    switch(type) 
	{
		case NODE_OBJECT3D:
			{
				SPTR<Node> node(new Object3d);
				node->setScene(*this);
				if(!isReference) {
					father.addChild(node);
					this->nodeList.push_back(node);
				} else {
					this->refObject3dList.push_back(node);
				}
				if(addDefaultRenderer) {
					SPTR<Renderer> renderer(new SimpleMeshRenderer);
					renderer->setScene(*this);
					WPTR<Node> wn(node);
					renderer->setNode(wn);
					node->setRenderer(renderer);
					renderer->init();
					this->rendererList.push_back(renderer);
				}
				return node.get(); 
			}
			break;
		case NODE_CAMERA:
			{
				SPTR<Node> node(new Camera);
				if(!isReference) {
					father.addChild(node);
					this->nodeList.push_back(node);
				} else {
					this->refCameraList.push_back(node);
				}
				node->setScene(*this);
				
				return node.get();
			}
			break;
		case NODE_SOUND:
			{
				SPTR<Node> node(new SoundNode);
				if(!isReference) {
					father.addChild(node);
					this->nodeList.push_back(node);
					this->soundNodeList.push_back(node);
				} else {
					this->refSoundList.push_back(node);
				}
				node->setScene(*this);
				
				return node.get(); 
			}
		case NODE_BOX:
			{
				SPTR<Node> node(new Box);
				node->setScene(*this);
				if(!isReference) {
					father.addChild(node);
					this->nodeList.push_back(node);
				}
				if(addDefaultRenderer) {
					SPTR<Renderer> renderer(new SimpleMeshRenderer);
					renderer->setScene(*this);
					WPTR<Node> wn(node);
					renderer->setNode(wn);
					node->setRenderer(renderer);
					renderer->init();
					this->rendererList.push_back(renderer);
				}
				return node.get(); 
			}
			break;
		case NODE_SPRITE:
			{
				SPTR<Node> node(new Sprite);
				node->setScene(*this);
				if(!isReference) {
					father.addChild(node);
					this->nodeList.push_back(node);
				} else {
					this->refObject3dList.push_back(node);
				}
				if(addDefaultRenderer) {
					SPTR<Renderer> renderer(new ParticleRenderer);
					renderer->setScene(*this);
					WPTR<Node> wn(node);
					renderer->setNode(wn);
					((ParticleRenderer*) renderer.get())->setRenderSingleParticle(true);
					node->setRenderer(renderer);
					renderer->init();
					this->rendererList.push_back(renderer);
				}
				return node.get();
			}
			break;
		case NODE_PARTICLEGROUP:
			{
				SPTR<Node> node(new ParticleGroup);
				node->setScene(*this);
				if(!isReference) {
					if(&father != this->getRoot()) {
						this->manager->printToConsole("ERROR: Call of createNode for ParticleGroup only allows rootNode as father!!");
					}
					father.addChild(node);
					this->nodeList.push_back(node);
				}
				if(addDefaultRenderer) {
					//TODO add ParticleRenderer
					SPTR<Renderer> renderer(new ParticleRenderer);
					renderer->setScene(*this);
					WPTR<Node> wn(node);
					renderer->setNode(wn);
					node->setRenderer(renderer);
					renderer->init();
					this->rendererList.push_back(renderer);
				}
				((ParticleGroup*) node.get())->setParticleGroup(this->particleGroupCounter);
				this->particleGroupVector.push_back(node);
				this->particleGroupCounter++;
				return node.get(); 
			}
			break;
		case NODE_PARTICLEEMITTER:
			{
				SPTR<Node> node(new ParticleEmitter);
				node->setScene(*this);
				if(!isReference) {
					father.addChild(node);
					this->nodeList.push_back(node);
				}
				return node.get(); 
			}
			break;
	}
	return 0;
}

void Scene::connectNodeAndRenderer(Node &node, SPTR<Renderer> &renderer)
{
	std::list<SPTR<Node> >::iterator it;
	SPTR<Node> sN;
	for(it = this->nodeList.begin(); it!=this->nodeList.end();it++) {
		if((*it).get() == &node) {
			WPTR<Node> wn(*it);
			renderer->setScene(*this);
			renderer->setNode(wn);
			(*it)->setRenderer(renderer);
			renderer->init();
			this->rendererList.push_back(renderer);
			break;
		}
	}
}

void Scene::OnLostDevice( void* pUserContext )
{
	SAFE_RELEASE(this->finalImage);
	SAFE_RELEASE(this->finalImageSurface);
	SAFE_RELEASE(this->quadMesh);
	SAFE_RELEASE(this->depthSurface);
	SAFE_RELEASE(this->preDistortionFinal);
	SAFE_RELEASE(this->preDistortionFinalSurface);
	SAFE_RELEASE(this->screenDistortionMapSurface);
	this->finalImage = NULL;
	this->finalImageSurface = NULL;
	this->meshCreated = false;
	this->quadMesh = NULL;
	this->preDistortionFinal = NULL;
	this->preDistortionFinalSurface = NULL;
	this->screenDistortionMapSurface = NULL;

	std::list<SPTR<Node> >::iterator nit;
	for(nit=this->nodeList.begin();nit!=this->nodeList.end();nit++) {
		(*nit)->OnLostDevice(pUserContext);
	}

	for(UINT i=0;i<this->sharedResourceVector.size();i++) {
		this->sharedResourceVector.at(i)->OnLostDevice();
	}

	std::vector<SPTR<Renderer> >::iterator it;
	for(it=this->rendererList.begin();it!=this->rendererList.end();it++) {
		(*it)->OnLostDevice(pUserContext);
	}
}

void Scene::OnDestroyDevice( void* pUserContext )
{
	std::list<SPTR<Node> >::iterator nit;
	for(nit=this->nodeList.begin();nit!=this->nodeList.end();nit++) {
		(*nit)->OnDestroyDevice(pUserContext);
	}

	std::vector<SPTR<Renderer> >::iterator it;
	for(it=this->rendererList.begin();it!=this->rendererList.end();it++) {
		(*it)->OnDestroyDevice(pUserContext);
	}

	this->depthTextureResource = NULL;
	this->sharedResourceVector.clear();
	this->distortionMap1 = NULL;
	this->distortionMap2 = NULL;
	this->screenDistortionMap = NULL;
	this->preDistortionFinal = NULL;
}

HRESULT Scene::OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
	HRESULT hr;

	//Restore that stuff
	this->device = pd3dDevice;

	SAFE_RELEASE(this->quadMesh);
	SAFE_RELEASE(this->depthSurface);
	SAFE_RELEASE(this->preDistortionFinal);
	SAFE_RELEASE(this->preDistortionFinalSurface);
	SAFE_RELEASE(this->screenDistortionMapSurface);


	//Textur für endgültiges Bild erzeugen
	if(!this->finalImage) {
		//Create Texture
		V( DXUTGetD3DDevice()->CreateTexture(this->manager->screenWidth, this->manager->screenHeight, 1, D3DUSAGE_RENDERTARGET, 
		D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &this->finalImage, NULL ) );

		//Get Surface for RenderTarget
		this->finalImage->GetSurfaceLevel(0, &this->finalImageSurface);
	}

	//Depth RenderPass
	this->depthTextureResource = (SharedResourceTexture*) this->getSharedResource(Scene::SR_TEXTURE_VIEWDEPTH);
	if(!this->depthTextureResource) {
		this->depthTextureResource = (SharedResourceTexture*) this->createSharedResource(Scene::SR_TEXTURE_VIEWDEPTH);
	}
	this->depthTextureResource->getTexture()->GetSurfaceLevel(0, &this->depthSurface);

	//Load DistortionMaps
	if(!this->distortionMap1)
		this->distortionMap1 = this->manager->resManager.loadTexture("./media/textures/heatnoise.tga");
	if(!this->distortionMap2) 
		this->distortionMap2 = this->manager->resManager.loadTexture("./media/textures/heatnoise2.tga");
	if(!this->screenDistortionMap) {
		SharedResourceTexture* distMap = (SharedResourceTexture*) this->createSharedResource(Scene::SR_TEXTURE_DISTORTION);
		this->screenDistortionMap = distMap->getTexture();
		this->screenDistortionMap->GetSurfaceLevel(0, &this->screenDistortionMapSurface);
	}

	if(!this->preDistortionFinal) {
		//Create Texture
		V( DXUTGetD3DDevice()->CreateTexture(this->manager->screenWidth, this->manager->screenHeight, 1, D3DUSAGE_RENDERTARGET, 
		D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &this->preDistortionFinal, NULL ) );

		//Get Surface for RenderTarget
		this->preDistortionFinal->GetSurfaceLevel(0, &this->preDistortionFinalSurface);
	}

	this->defaultRenderPass.setRenderTarget(this->finalImageSurface);
	this->depthRenderPass.setRenderTarget(this->depthSurface);

	std::list<SPTR<Node> >::iterator nit;
	for(nit=this->nodeList.begin();nit!=this->nodeList.end();nit++) {
		(*nit)->OnResetDevice(pd3dDevice, pBackBufferSurfaceDesc, pUserContext);
	}

	std::vector<SPTR<Renderer> >::iterator it;
	for(it=this->rendererList.begin();it!=this->rendererList.end();it++) {
		(*it)->OnResetDevice(pd3dDevice, pBackBufferSurfaceDesc, pUserContext);
	}
	return S_OK;
}

Vector Scene::getSunDirection() 
{
	return this->sunDirection;
}

void Scene::setSunDirection(Vector &v)
{
	this->sunDirection.x = v.x;
	this->sunDirection.y = v.y;
	this->sunDirection.z = v.z;
	this->sunDirection.normalize();
}

D3DXMATRIX Scene::getIdentityMatrix()
{
	return this->identMatrix;
}

D3DXMATRIX Scene::getWorldMatrix()
{
	return this->worldMatrix;
}

D3DXMATRIX Scene::getViewMatrix()
{
	return *this->activeRenderPass->getViewMatrix();
}

D3DXMATRIX Scene::getProjectionMatrix()
{
	return *this->activeRenderPass->getProjectionMatrix();
}

void Scene::setTrigger(int type, float time)
{
	SPTR<Trigger> t(new Trigger(type, time));
	this->triggerList.push_back(t);
	std::sort(this->triggerList.begin(), this->triggerList.end(), triggerSortFunction());
}

void Scene::setTrigger(int type, Node *node, float time)
{
	SPTR<Node> sN = this->getSmartPointer(node);
	
	SPTR<Trigger> t(new Trigger(type, sN, time));
	this->triggerList.push_back(t);
	std::sort(this->triggerList.begin(), this->triggerList.end(), triggerSortFunction());
}

void Scene::setTrigger(int type, Node *node, Node* secondNode, float time)
{
	SPTR<Node> sN = this->getSmartPointer(node);
	SPTR<Node> secondSN = this->getSmartPointer(secondNode);
	
	SPTR<Trigger> t(new Trigger(type, sN, secondSN, time));
	this->triggerList.push_back(t);
	std::sort(this->triggerList.begin(), this->triggerList.end(), triggerSortFunction());
}

void Scene::setTrigger(int type, Node *node, Node* secondNode, Vector normal, float time)
{
	SPTR<Node> sN = this->getSmartPointer(node);
	SPTR<Node> secondSN = this->getSmartPointer(secondNode);
	
	SPTR<Trigger> t(new Trigger(type, sN, secondSN, normal, time));
	this->triggerList.push_back(t);
	std::sort(this->triggerList.begin(), this->triggerList.end(), triggerSortFunction());
}

SPTR<Node> Scene::getSmartPointer(Node *node)
{
	std::list<SPTR<Node> >::iterator it;
	for(it = this->nodeList.begin(); it!=this->nodeList.end();it++) {
		if((*it).get() == node) {
			break;
		}
	}
	if(it==this->nodeList.end()) {
		this->manager->printToConsole("NODE NOT FOUND IN LIST!!!");
	}
	return (*it);
}

void Scene::executeTrigger(SPTR<Trigger> trigger)
{
	Trigger *t = trigger.get();
	switch(t->getType())
	{
		case this->TRIGGER_UNSETSTANDBY:
			if(!t->getNode()->isA(Scene::NODE_SOUND)) {
				t->getNode()->setStandBy(false);
			} else {
				t->getNode()->setStandBy(false);
				((SoundNode*) t->getNode().get())->play();
			}
			break;
		case this->TRIGGER_KILLNODE:
			t->getNode()->killMe();
			break;
		case this->TRIGGER_SETDETAIL:
			break;
	}
}

void Scene::deleteNode(Node* node)
{
	std::list<SPTR<Node> >::iterator it;
	for(it=this->zombieNodeList.begin();it!=this->zombieNodeList.end();it++) {
		if((*it).get() == node) {
			return;
		}
	}
	SPTR<Node> sn = this->getSmartPointer(node);
	this->zombieNodeList.push_back(sn);
}

void Scene::setContactReport(NxUserContactReport *_contactReport)
{
	this->contactReport = _contactReport;
	((UserContactReport*) this->contactReport)->setScene(this);
}

void Scene::setTriggerReport(NxUserTriggerReport *_triggerReport)
{
	this->triggerReport = _triggerReport;
	((UserTriggerReport*) this->triggerReport)->setScene(this);
}

void Scene::setNotifyReport(NxUserNotify* _notifyReport)
{
	this->notifyReport = _notifyReport;
	((UserNotify*) this->notifyReport)->setScene(this);
}

void Scene::setLight(Vector direction) {
	//set ambient light:
	DXUTGetD3DDevice()->SetRenderState( D3DRS_AMBIENT, D3DCOLOR_XRGB(120,120,120) );

	// Fill in a light structure defining our light
	D3DLIGHT9 light;
	ZeroMemory( &light, sizeof(D3DLIGHT9) );
	light.Type       = D3DLIGHT_DIRECTIONAL;
	light.Diffuse.r  = 1.0f;
	light.Diffuse.g  = 1.0f;
	light.Diffuse.b  = 1.0f;
	light.Diffuse.a  = 1.0f;
	light.Range      = 1000.0f;

	// Create a direction for our light - it must be normalized  
	D3DXVECTOR3 vecDir;
	vecDir = D3DXVECTOR3(direction.x,direction.y,direction.z);
	D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecDir );

	// Tell the device about the light and turn it on
	DXUTGetD3DDevice()->SetLight( 0, &light );
	DXUTGetD3DDevice()->LightEnable( 0, TRUE );
}

std::list<SPTR<Node> >* Scene::getParticleList()
{
	return &this->particleList;
}

void Scene::addToParticleList(Node *node)
{
	SPTR<Node> sn = this->getSmartPointer(node);
	this->particleList.push_back(sn);
}

ParticleGroup* Scene::getParticleGroup(int id)
{
	ParticleGroup* pg;
	for(UINT i=0;i<this->particleGroupVector.size();i++) {
		pg = (ParticleGroup*) this->particleGroupVector.at(i).get();
		if(pg->getParticleGroup()==id) {
			return pg;
		}
	}
	return NULL;
}

SharedResource* Scene::createSharedResource(int id)
{
	switch(id) {
		case this->SR_TEXTURE_VIEWDEPTH:
			{
				SPTR<SharedResource> srt(new SharedResourceTexture);
				SharedResourceTexture* t = (SharedResourceTexture*) srt.get();
				t->setResourceIdentifier(id);
				t->createTexture(this->manager->screenWidth, this->manager->screenHeight, D3DFMT_A16B16G16R16F, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT);
				this->sharedResourceVector.push_back(srt);
				return t;
			}
			break;
		case this->SR_TEXTURE_DISTORTION:
			{
				SPTR<SharedResource> srt(new SharedResourceTexture);
				SharedResourceTexture* t = (SharedResourceTexture*) srt.get();
				t->setResourceIdentifier(id);
				t->createTexture(this->manager->screenWidth, this->manager->screenHeight, D3DFMT_A16B16G16R16F, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT);
				this->sharedResourceVector.push_back(srt);
				return t;
			}
			break;
	}
	return NULL;
}

SharedResource* Scene::getSharedResource(int id)
{
	for(UINT i=0;i<this->sharedResourceVector.size();i++) {
		if(this->sharedResourceVector.at(i)->getResourceIdentifier()==id) {
			SharedResource* sr = this->sharedResourceVector.at(i).get();
			return sr;
		}
	}
	return NULL;
}

int* Scene::getMousePos() {
	return this->mousePos;
}

void Scene::OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
}

void Scene::createQuadMesh()
{	
	HRESULT hr;
	//Create a quad for rendering to screen
	if(SUCCEEDED( D3DXCreateMeshFVF(2, 4, D3DXMESH_MANAGED, this->FVF_Flags, this->device, &this->quadMesh)) ) {
		//lock vertex buffer
		Vector ecken[4];
		Vertex* pVertices;
		V( this->quadMesh->LockVertexBuffer( 0, (void**)&pVertices ) );
		
		ecken[0] = Vector(-1.0f, 1.0f, 0.0f);
		ecken[1] = Vector(-1.0f, -1.0f, 0.0f);
		ecken[2] = Vector(1.0f, -1.0f, 0.0f);
		ecken[3] = Vector(1.0f, 1.0f, 0.0f);

		pVertices[0] = Vertex(ecken[0], 0.0f, 0.0f); 
		pVertices[1] = Vertex(ecken[1], 0.0f, 1.0f);
		pVertices[2] = Vertex(ecken[2], 1.0f, 1.0f);
		pVertices[3] = Vertex(ecken[3], 1.0f, 0.0f);

		//unlock vertex buffer
		V( this->quadMesh->UnlockVertexBuffer() );	

		// fill the indices:
		WORD* pIndices = NULL;
		this->quadMesh->LockIndexBuffer( 0, (void**)&pIndices );

		pIndices[0] = (WORD) 0; pIndices[1] = (WORD) 2; pIndices[2] = (WORD) 1;
		pIndices[3] = (WORD) 0; pIndices[4] = (WORD) 3; pIndices[5] = (WORD) 2;

		this->quadMesh->UnlockIndexBuffer();
		this->meshCreated=true;
	}  else {
		this->manager->printToConsole("ERROR creating mesh!");
	}
	
}

void Scene::renderFinalImage(ID3DXEffect* fadeEffect)
{
	HRESULT hr = 0;
	
	
	if(!this->meshCreated) {
		this->createQuadMesh();
	}

	UINT cPass;
	V( fadeEffect->SetFloat("alpha", this->sceneAlpha) );
	V( fadeEffect->SetTexture("sceneRendering", this->finalImage) );
	V( fadeEffect->CommitChanges() );
	V( fadeEffect->SetTechnique("fade") );
	V( fadeEffect->Begin( &cPass, 0 ) );
	V( fadeEffect->BeginPass( 0 ) );
	V( this->device->BeginScene() );
	V( this->device->SetTexture(0, this->finalImage) );
	V( this->quadMesh->DrawSubset(0) );
	V( this->device->SetTexture(0, 0) );
	V( this->device->EndScene() );
	V( fadeEffect->EndPass() );
	V( fadeEffect->End() );
}

int Scene::getActivePassId() {
	if(this->activeRenderPass==NULL) {
		return this->PASS_NORMAL;
	} else {
		return this->activeRenderPass->getRenderPassId();
	}
}

void Scene::setActiveRenderPass(RenderPass &_activePass)
{
	this->activeRenderPass = &_activePass;
	this->activeRenderPass->calculateMatrices();
}

void Scene::startRenderPasses()
{
	//char temp[100];
	HRESULT hr;
	bool tempDistortionPass = false;

	//Reset values
	this->needDepthPass = false;
	this->needRaytracePass = false;
	this->needDistortionPass = false;
	this->heatHazeParticleRendererList.clear();

	//DefaultRenderPass aktivieren
	this->defaultRenderPass.setViewMatrix(*this->activeCamera->getViewMatrix());
	this->defaultRenderPass.setProjectionMatrix(*this->activeCamera->getProjectionMatrix());
	this->setActiveRenderPass(this->defaultRenderPass);
	//Gegen Frustum Cullen
	this->doFrustumCulling();

	//Ueberprufen ob heatHaze benötigt wird, defaultRenderPass...renderTarget umstellen!
	if(this->needDistortionPass) {
		tempDistortionPass = true;
		this->defaultRenderPass.setRenderTarget(this->preDistortionFinalSurface);
	}

	//Ueberpruefen welche Passes gerendert werden
	if(this->needDepthPass && this->useDepthImposter) {
		//this->depthRenderPass.setRenderTarget(this->finalImageSurface);
		//this->manager->printToConsole("DepthPass Needed");
		this->depthRenderPass.setViewMatrix(*this->activeCamera->getViewMatrix());
		this->depthRenderPass.setProjectionMatrix(*this->activeCamera->getProjectionMatrix());
		this->setActiveRenderPass(this->depthRenderPass);
		this->activeRenderPass->executePass();
		this->depthTextureResource->setResourceAvailable(true);
	}

	if(this->needRaytracePass) {
		//Nächster Raytracerenderer finden
		Vector objPos;
		Vector camPos;
		Vector dist;
		float minDistance=9999999;
		float distance=0;
		RaytraceRenderer* nearestRenderer = NULL;
		camPos = this->activeCamera->getAbsolutePosition();

		for(UINT i=0;i<this->raytraceRendererList.size();i++) {
			objPos = this->raytraceRendererList.at(i)->myNode.lock().get()->getAbsolutePosition();
			distance = (camPos-objPos).length();
			if(minDistance>distance) {
				minDistance = distance;
				nearestRenderer = this->raytraceRendererList.at(i);
			}
		}

		//RaytracePass aktivieren
		bool oldFrustum = this->enableFrustumCulling;
		this->raytraceRenderPass.setProjectionMatrix(*nearestRenderer->getCubeMapProjectionMatrix());
		for(int i=0;i<6;i++) {
			this->raytraceRenderPass.setViewMatrix(nearestRenderer->getCubeMapView(i));
			this->raytraceRenderPass.setRenderTarget(nearestRenderer->getCubeMapSurface(i));
			this->setActiveRenderPass(this->raytraceRenderPass);
			if(i==2)
				this->enableFrustumCulling = false ;
			this->activeRenderPass->executePass();
			if(i==2)
				this->enableFrustumCulling = oldFrustum;
			SAFE_RELEASE(this->raytraceRenderPass.renderTarget);

			//BlurThatStuff
			//nearestRenderer->blurDepthPass(i);
		}
		RaytraceRenderer* tempRenderer;
		for(UINT i=0;i<this->raytraceRendererList.size();i++) {
			tempRenderer = this->raytraceRendererList.at(i);
			if(tempRenderer!=nearestRenderer && tempRenderer->needsUpdate()) {
				//this->manager->printToConsole("UPDATING OTHER RAYTRACER!");
				this->raytraceRenderPass.setProjectionMatrix(*tempRenderer->getCubeMapProjectionMatrix());
				for(int i=0;i<6;i++) {
					this->raytraceRenderPass.setViewMatrix(tempRenderer->getCubeMapView(i));
					this->raytraceRenderPass.setRenderTarget(tempRenderer->getCubeMapSurface(i));
					this->setActiveRenderPass(this->raytraceRenderPass);
					if(i==2)
						this->enableFrustumCulling = false ;
					this->activeRenderPass->executePass();
					if(i==2)
						this->enableFrustumCulling = oldFrustum;
					SAFE_RELEASE(this->raytraceRenderPass.renderTarget);
				}
			}
		}

		//Cullen, Nodes rendern...gegen die 6 flächen....
		//Clear Raytracerlist
		this->raytraceRendererList.clear();
	}

	FSOUND_Update();	//Update sount because of jittering

	//DefaultRenderPass aktivieren
	this->setActiveRenderPass(this->defaultRenderPass);
	this->activeRenderPass->executePass();

	//if(this->needDistortionPass) {
	if(tempDistortionPass) {
		//Distortion
		if(!this->meshCreated) {
			this->createQuadMesh();
		}

		ID3DXEffect* particleEffect;
		particleEffect = this->manager->getEffect(GameManager::EFFECT_DEPTHIMP);

		//Distortion Map rendern
		this->device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
		this->device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
		this->device->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW);
		this->device->SetRenderState( D3DRS_LIGHTING, FALSE );
		this->device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
		this->device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
		this->device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
		this->device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		this->device->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		this->device->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		this->device->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );

		this->device->SetRenderTarget(0, this->screenDistortionMapSurface);
		this->device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 128, 128, 128), 1.0f, 0);

		V( particleEffect->SetTexture("distortionMap1", this->distortionMap1) );
		V( particleEffect->SetTexture("distortionMap2", this->distortionMap2) );
		V( particleEffect->SetTexture("screenDistortionMap", this->screenDistortionMap) );
		V( particleEffect->CommitChanges() );

		for(UINT i=0;i<this->heatHazeParticleRendererList.size();i++) {
			this->heatHazeParticleRendererList.at(i)->renderHeatHaze();
		}

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

		//Bild auf finalRenderPass rendern
		this->device->SetRenderTarget(0, this->finalImageSurface);
		this->device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
		
		
		//Bild in finalImageSurface kopieren
		UINT cPass;
		V( particleEffect->SetTexture("preDistortion", this->preDistortionFinal) );
		V( particleEffect->CommitChanges() );
		V( particleEffect->SetTechnique("HeatHazeCopy") );
		V( particleEffect->Begin( &cPass, 0 ) );
		V( particleEffect->BeginPass( 0 ) );
		V( this->device->BeginScene() );
		V( this->quadMesh->DrawSubset(0) );
		V( this->device->SetTexture(0, 0) );
		V( this->device->EndScene() );
		V( particleEffect->EndPass() );
		V( particleEffect->End() );

		this->device->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
		this->device->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);

		//Reset default RenderTarget
		this->defaultRenderPass.setRenderTarget(this->finalImageSurface);
	}
}

void Scene::updateSoundNodeVolume()
{
	std::list<SPTR<Node> >::iterator it;
	for(it = this->soundNodeList.begin();it!=this->soundNodeList.end();it++) {
		((SoundNode*) it->get())->setSceneAlpha(this->sceneAlpha);
	}
	if(this->bgSoundChannel!=-1 && !this->muteMusic) {
		FSOUND_SetVolume(this->bgSoundChannel, (int)(255*this->bgSoundVolume*this->sceneAlpha));
	}
}

LPD3DXMESH Scene::getQuadMesh()
{
	if(!this->meshCreated) {
		this->createQuadMesh();
	}
	return this->quadMesh;
}

void Scene::setBackgroundSoundMute(bool _muteMusic)
{	
	this->muteMusic = _muteMusic;
	if(!this->muteMusic) {
		if(this->bgSoundChannel!=-1) {
			FSOUND_SetVolume(this->bgSoundChannel, (int)(255*this->bgSoundVolume*this->sceneAlpha));
		}
	} else {
		if(this->bgSoundChannel!=-1) {
			FSOUND_SetVolume(this->bgSoundChannel, 0);
		}
	}
}

bool Scene::getBackgroundSoundMute() {
	return this->muteMusic;
}

void Scene::setBackgroundSound(std::string filename) {
	this->bgMusicStream = FSOUND_Stream_Open(filename.c_str(), FSOUND_LOOP_NORMAL, 0, 0);
}

void Scene::setBackgroundSoundVolume(float vol) {
	this->bgSoundVolume = vol;
	if(this->bgSoundChannel!=-1) {
		if(!this->muteMusic) {
			FSOUND_SetVolume(this->bgSoundChannel, (int)(255*this->bgSoundVolume));
		} else {
			FSOUND_SetVolume(this->bgSoundChannel, 0);
		}
	}
}

void Scene::playBackgroundSound() {
	if(this->bgMusicStream!=NULL) {
		this->bgSoundChannel = FSOUND_Stream_Play(FSOUND_FREE, this->bgMusicStream);
		if(!this->muteMusic) {
			FSOUND_SetVolume(this->bgSoundChannel, (int)(255*this->bgSoundVolume));
		} else {
			FSOUND_SetVolume(this->bgSoundChannel, 0);
		}
	}
}