#include "dxstdafx.h"
#include ".\node.h"
#include "Scene.h"
#include "GameManager.h"

Node::Node(void)
{
	this->testAgainstFrustum = true;
	this->behaveAs = NORMAL;
	this->updateMe = true;
	this->visible = true;
	this->standBy = false;
	this->rendererAdded = false;
	this->aClone = false;
	this->calcBoundingBox = true;
	this->absMaxAABBox.x = 0.1f;
	this->absMaxAABBox.y = 0.1f;
	this->absMaxAABBox.z = 0.1f;
	this->absMinAABBox.x = -0.1f;
	this->absMinAABBox.y = -0.1f;
	this->absMinAABBox.z = -0.1f;
	this->absBoxCenter.x = 0.0f;
	this->absBoxCenter.y = 0.0f;
	this->absBoxCenter.z = 0.0f;
	D3DXMatrixIdentity(&this->myWorldMatrix);
	
	//Physic Stuff
	this->pActor = NULL;
	this->pActorDesc.density       = 10.0f;
	this->pActorDesc.body          = &this->pBodyDesc;
	this->pMaterialId = 0;

	this->bOverrideWorldMatrix = false;
	this->timeToLive = -100;
	this->pColDetGroup = 0;
	this->nodeType = 0;
	this->maxAge = 0;
	this->userData = NULL;
	this->father = NULL;
	//this->pShapeDescSize = 0;

	this->softKill = false;
	this->softKillDuration = 0;
	this->doingSoftKill = false;
	this->softKillAlpha = 1.0f;
}

Node::~Node(void)
{
	this->children.clear();
	//if(this->pActor!=NULL) 
	//	this->myScene->pScene->releaseActor(*this->pActor);
}

void Node::setBehaveAs(int _behaveAs) 
{
	if(_behaveAs > this->NORMAL && this->pActor==NULL) {
		this->pActorDesc.globalPose.t.set(this->myPosition.getNxVector());		
		if(_behaveAs == this->STATIC) {
			this->pActorDesc.body = NULL;
			this->calcStaticPhysicWorldMatrix();
		}
		this->pActorDesc.userData = this;
		if(!this->pActorDesc.isValid()) {
			this->myScene->manager->printToConsole("ActorDescriptor is not valid!!");
			return;
		}

		this->pActor = this->myScene->pScene->createActor(this->pActorDesc);
		this->pActor->userData = this;
		if(_behaveAs == this->KINEMATIC) {
			this->pActor->raiseBodyFlag(NX_BF_KINEMATIC);
		} else {
			this->pActor->clearBodyFlag(NX_BF_KINEMATIC);
		}

	} else if(_behaveAs == this->KINEMATIC && this->pActor!=NULL) {
			this->pActor->raiseBodyFlag(NX_BF_KINEMATIC);
	} else {
			this->pActor->clearBodyFlag(NX_BF_KINEMATIC);
	}
	this->behaveAs = _behaveAs;
}

void Node::setRenderer(SPTR<Renderer> &_myRenderer)
{
	this->rendererAdded = true;
	this->myRenderer = _myRenderer;
}

void Node::removeRenderer()
{
	if(this->rendererAdded) {
		this->rendererAdded = false;
		Renderer* r = this->myRenderer.get();
		this->myScene->deleteRendererInList(r);
		this->myRenderer.reset();
	}
}

SPTR<Renderer> Node::getRenderer()
{
	return this->myRenderer;
}

bool Node::hasRenderer()
{
	return this->rendererAdded;
}

void Node::setVisible(bool _visible) 
{
	this->visible = _visible;
    std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin(); it!=this->children.end();it++) {
		(*it)->setVisible(_visible);
	}
}

bool Node::isVisible()
{
	return this->visible;
}

void Node::setStandBy(bool _standBy)
{
	this->standBy = _standBy;
    std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin(); it!=this->children.end();it++) {
		(*it)->setStandBy(_standBy);
	}
	if(this->pActor) {
		if(_standBy) {
			this->pActor->putToSleep();
		} else {
			this->pActor->wakeUp();
		}
	}
}

bool Node::onStandBy()
{
	return this->standBy;
}

void Node::translate(float dx, float dy, float dz)
{
	if(this->behaveAs != this->STATIC) {
		this->myPosition.x += dx;
		this->myPosition.y += dy;
		this->myPosition.z += dz;
	
		if(this->pActor==NULL) {
			this->pActorDesc.globalPose.t+=NxVec3(dx, dy, dz);
		}
	}
}

void Node::translate(Vector &tv)
{
	if(this->behaveAs != this->STATIC) {
		this->myPosition += tv;
	
		if(this->pActor==NULL) {
			this->pActorDesc.globalPose.t+=tv.getNxVector();
		}
	}
}

void Node::rotate(float dalpha, float dbeta, float dgamma)
{
	if(this->behaveAs != this->STATIC) {
		this->myRotation.x += dalpha;
		this->myRotation.y += dbeta;
		this->myRotation.z += dgamma;
	
		if(this->pActor==NULL) {
			NxQuat q;
			q.setx(this->myRotation.x);
			q.sety(this->myRotation.y);
			q.setz(this->myRotation.z);
			q.setw(1);
			NxMat33 m(q);
			this->pActorDesc.globalPose.M = this->pActorDesc.globalPose.M*m;
		}
	}
}

void Node::setPosition(float x, float y, float z)
{
	if(this->behaveAs == this->PARTICLE) {
		this->pActor->setGlobalPosition(NxVec3(x,y,z));
		return;
	}
	if(this->behaveAs != this->STATIC) {
		this->myPosition.x = x;
		this->myPosition.y = y;
		this->myPosition.z = z;

		if(this->pActor==NULL) {
			this->pActorDesc.globalPose.t.x = x;
			this->pActorDesc.globalPose.t.y = y;
			this->pActorDesc.globalPose.t.z = z;
		}
	}/* else if(this->behaveAs == this->PARTICLE) {  //ZIEMLICHER SCHWACHSINN nach != STATIC!!
		this->pActor->setGlobalPosition(NxVec3(x,y,z));
	}*/
}

void Node::setPosition(Vector &p)
{
	if(this->behaveAs == this->PARTICLE) {
		this->pActor->setGlobalPosition(p.getNxVector());
		return;
	}
	if(this->behaveAs != this->STATIC) {
		this->myPosition = p;
	
		if(this->pActor==NULL) {
			this->pActorDesc.globalPose.t=p.getNxVector();
		}
	}
}

Vector Node::getPosition()
{
	return this->myPosition;
}

void Node::setRotation(float alpha, float beta, float gamma)
{
	if(this->behaveAs != this->STATIC) {
		this->myRotation.x = alpha;
		this->myRotation.y = beta;
		this->myRotation.z = gamma;
	
		if(this->pActor==NULL) {
			/*NxQuat q;
			q.setx(this->myRotation.x);
			q.sety(this->myRotation.y);
			q.setz(this->myRotation.z);
			q.setw(1);*/
			NxMat33 m(this->myRotation.getNxQuatRotation());
			this->pActorDesc.globalPose.M = m*this->pActorDesc.globalPose.M;
		}
	}
}

void Node::setRotation(Vector &r)
{
	if(this->behaveAs != this->STATIC) {
		this->myRotation = r;

		if(this->pActor==NULL) {
			/*NxQuat q;
			q.setx(this->myRotation.x);
			q.sety(this->myRotation.y);
			q.setz(this->myRotation.z);
			q.setw(1);*/
			NxMat33 m(this->myRotation.getNxQuatRotation());
			this->pActorDesc.globalPose.M = m*this->pActorDesc.globalPose.M;
		}
	}
}

float Node::getRotationX()
{
	return this->myRotation.x;
}

float Node::getRotationY()
{
	return this->myRotation.y;
}

float Node::getRotationZ()
{
	return this->myRotation.z;
}


std::list<SPTR<Node> >::iterator Node::addChild(SPTR<Node> _child)
{
	//_child->myScene = this->myScene;
	//this->myScene->nodeList.push_back(_child);
	if(_child->getFather()) {
		_child->getFather()->removeChild(_child);
	}
	_child->father = this;
	this->children.push_back(_child);
	std::list<SPTR<Node> >::iterator it = this->children.end();
	it--;
	return it;
}

void Node::removeChild(std::list<SPTR<Node> >::iterator _it)
{
	this->children.remove((SPTR<Node>) *_it);
}

void Node::removeChild(SPTR<Node> _child)
{
	this->children.remove(_child);
}

void Node::removeAllChildren()
{
	std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin(); it!=this->children.end();it++) {
		(*it)->killMe();
	}
	//this->children.clear();
}

Vector* Node::getAbsMinBBox()
{
	return &this->absMinAABBox;
}

Vector* Node::getAbsMaxBBox() 
{
	return &this->absMaxAABBox;
}

Vector Node::getAbsBoxCenter() 
{
	return this->absBoxCenter;
}

void Node::update(float dt)
{
	std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin(); it!=this->children.end();it++) {
		if(!(*it)->standBy && (*it)->updateMe) {
			(*it)->update(dt);
		}
	}

	if(this->timeToLive!=-100) {
		this->timeToLive-=dt;
		if(this->timeToLive<=this->softKillDuration) {
			this->doingSoftKill = true;
			this->softKillAlpha = this->timeToLive/this->softKillDuration;
		}
		if(this->timeToLive<=0) {
			this->setVisible(false);
			this->killMe();
		}
	}
}

void Node::calcWorldMatrix(D3DXMATRIX &pMatWorld)
{
	if(this->standBy) {
		return;
	}
	std::list<SPTR<Node> >::iterator it;
	if(this->bOverrideWorldMatrix) {
		this->bOverrideWorldMatrix = false;
		for(it=this->children.begin(); it!=this->children.end();it++) {
			(*it)->calcWorldMatrix(this->myWorldMatrix);
		}
		return;
	}
	switch(this->behaveAs) {
		case NORMAL:
			this->calcNormalWorldMatrix(pMatWorld);
			break;
		/*case STATIC:
			this->calcStaticPhysicWorldMatrix(pMatWorld);
			break;*/
		case KINEMATIC:
			this->calcKinematicWorldMatrix(pMatWorld);
			break;
		case RIGIDBODY:
		case PARTICLE:
			this->calcPhysicWorldMatrix(pMatWorld);
			break;
	}
	
	for(it=this->children.begin(); it!=this->children.end();it++) {
		(*it)->calcWorldMatrix(this->myWorldMatrix);
	}
	this->getAbsoluteVector(this->absMinAABBox, this->minAABBox);
	this->getAbsoluteVector(this->absMaxAABBox, this->maxAABBox);
	this->getAbsoluteVector(this->myAbsPos, Vector(0, 0, 0));
	Vector camPos = this->myScene->getActiveCamera()->getAbsolutePosition();
	this->camDistance = (camPos - this->getAbsolutePosition()).length();
}

void Node::calcNormalWorldMatrix(D3DXMATRIX &pMatWorld)
{
	D3DXQUATERNION quat;
	D3DXMATRIX tempWorld;
	D3DXMATRIX tempTrans;
    D3DXMATRIX MatRot;   // Final rotation matrix, applied to 
                         // pMatWorld.

	float x = this->myPosition.x;
	float y = this->myPosition.y;
	float z = this->myPosition.z;

	float a = this->myRotation.x;
	float b = this->myRotation.y;
	float g = this->myRotation.z;

	//tempWorld = pMatWorld;
    D3DXMatrixTranslation(&tempTrans, x, y, z);
	D3DXMatrixMultiply(&this->myWorldMatrix, &tempTrans, &pMatWorld);
	if(a!=0 || b!=0 || g!=0) {
		D3DXQuaternionIdentity(&quat);
		D3DXQuaternionRotationYawPitchRoll(&quat, b, a, g);
		D3DXMatrixRotationQuaternion(&MatRot, &quat);
		D3DXMatrixMultiply(&this->myWorldMatrix, &MatRot, &this->myWorldMatrix);
	}
}

void Node::calcKinematicWorldMatrix(D3DXMATRIX &pMatWorld)
{
	//calculate position of physic actor or particle
	if(this->pActor!=NULL) {
		//this->pActor->moveGlobalPosition(this->myPosition.getNxVector());
		NxMat33 m(this->myRotation.getNxQuatRotation());
		NxMat34 mat;
		mat.M = m;
		mat.t = this->myPosition.getNxVector();
		this->pActor->moveGlobalPose(mat);
	}
	this->calcPhysicWorldMatrix(pMatWorld);
}

void Node::calcPhysicWorldMatrix(D3DXMATRIX &pMatWorld)
{
	if(this->pActor!=NULL) {
		this->pActor->getGlobalPose().getColumnMajor44(((NxF32 *) &this->myWorldMatrix.m[0][0]));
	}
}

void Node::calcStaticPhysicWorldMatrix()
{
	NxMat34 m(this->pActorDesc.globalPose.M, this->pActorDesc.globalPose.t);
	m.getColumnMajor44(((NxF32 *) &this->myWorldMatrix.m[0][0]));
}

void Node::getAbsoluteVector(Vector &pOut, Vector &pin)
{
	//D3DXVECTOR4 temp;
	D3DXVec4Transform(&pOut, &pin, &this->myWorldMatrix);
	//Vector v(temp.x, temp.y, temp.z);
	//return v;
}

void Node::getAbsoluteDirectionVector(Vector &dirOut, Vector &dirIn)
{
	Vector temp;
	temp = this->getAbsolutePosition();
	this->getAbsoluteVector(dirOut, dirIn);
	dirOut.x-= temp.x;
	dirOut.y-= temp.y;
	dirOut.z-= temp.z;
}

Vector Node::getAbsolutePosition() 
{
	/*Vector origin(0, 0, 0);
	this->getAbsoluteVector(origin, origin);
	return origin;*/
	return this->myAbsPos;
}

void Node::setWorldMatrix(D3DXMATRIXA16 &worldMatrix)
{
	this->bOverrideWorldMatrix = true;
	this->myWorldMatrix = worldMatrix;
	this->getAbsoluteVector(this->myAbsPos, Vector(0, 0, 0));
}


D3DXMATRIXA16* Node::getWorldMatrix()
{
	return &this->myWorldMatrix;
}

void Node::setScene(Scene &scene)
{
	this->myScene = &scene;
}

void Node::killMe()
{
	std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin();it!=this->children.end();it++) 
	{
		(*it)->killMe();
	}
	//this->myScene->manager->printToConsole("killMe called, but not yet implemented!");
	//delete my, in father, the phyisc model, in scene...with (virtual void Scene::killNode(Node *node))
	this->myScene->deleteNode(this);
	this->updateMe = false;
}

NxActorDesc* Node::getActorDescriptor() 
{
	return &this->pActorDesc;
}

NxBodyDesc*	Node::getBodyDescriptor()
{
	return &this->pBodyDesc;
}

NxActor* Node::getActor() 
{
	return this->pActor;
}

void Node::setPMaterial(int id)
{
	this->pMaterialId = id;
	if(this->pActor) {
		int nbShapes = this->pActor->getNbShapes();
		for(int i=0;i<nbShapes;i++) {
			this->pActor->getShapes()[i]->setMaterial(id);
		}
	}
}

void Node::setColDetGroup(int group)
{
	this->pColDetGroup = group;
	if(this->pActor) {
		bool disableRayCasting;
		disableRayCasting = (group==UserContactReport::COLGROUP_NOCOL) ? true : false;
		NxU32 shapeNb = this->pActor->getNbShapes();
		NxShape *const* shapes = this->pActor->getShapes();
		for(UINT i=0;i<shapeNb;i++) {
			(*shapes)->setGroup(group);
			(*shapes)->setFlag(NX_SF_DISABLE_RAYCASTING, disableRayCasting);
			shapes++;
		}
		this->pActor->setGroup(group);
	}/* else {
		this->myScene->manager->printToConsole("Node::setColDetGroup called before actor created!!!");
	}*/
}

Node* Node::getFather()
{
	return this->father;
}

std::list<SPTR<Node> > *Node::getChildren() {
	return &this->children;
}

void Node::setParticleGroup(int _group)
{
	this->particleGroup = _group;	
	if(this->pActorDesc.shapes.size()==0) {
		this->myScene->manager->printToConsole("I HAVE NO SHAPES!!!");
	} else {
		this->setBehaveAs(this->PARTICLE);
	}
}

int Node::getParticleGroup()
{
	return this->particleGroup;
}

Node* Node::clone()
{
	return NULL;
}

void Node::setTimeToLive(float _timeToLive)
{
	/*std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin(); it!=this->children.end();it++) {
		(*it)->setTimeToLive(_timeToLive);
	}*/
	this->timeToLive = _timeToLive;
	this->maxAge = _timeToLive;
}

float Node::getTimeToLive() {
	return this->timeToLive;
}

void Node::cloneChildren(Node *clonedNode)
{
	Node* n;
	std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin();it!=this->children.end();it++) {
		n = (*it).get();
		SPTR<Node> sn = this->myScene->getSmartPointer(n->clone());
		clonedNode->addChild(sn);
	}
}

void Node::updateBBox() {
	std::list<SPTR<Node> >::iterator it;
	std::list<SPTR<Node> >::iterator itEnd;
	Node* node;
	itEnd = this->children.end();
	if(this->calcBoundingBox) {
		Vector childMinBBox(9999999,9999999,9999999);
		Vector childMaxBBox(-9999999,-9999999,-9999999);
		
		for(it=this->children.begin();it!=itEnd;it++) {
			node = (*it).get();
			if(!node->onStandBy() && node->isVisible()) {
				node->updateBBox();
			}
		}
		/*for(it=this->children.begin();it!=itEnd;it++) {
			node = (*it).get();
			if(!node->onStandBy() && node->isVisible() &&
				node->absMinAABBox.x!=0 && node->absMinAABBox.y!=0 && node->absMinAABBox.z!=0) {
				//min
				childMinBBox.x = (childMinBBox.x < node->absMinAABBox.x) ? childMinBBox.x : node->absMinAABBox.x;
				childMinBBox.y = (childMinBBox.y < node->absMinAABBox.y) ? childMinBBox.y : node->absMinAABBox.y;
				childMinBBox.z = (childMinBBox.z < node->absMinAABBox.z) ? childMinBBox.z : node->absMinAABBox.z;

				//max
				childMaxBBox.x = (childMaxBBox.x > node->absMaxAABBox.x) ? childMaxBBox.x : node->absMaxAABBox.x;
				childMaxBBox.y = (childMaxBBox.y > node->absMaxAABBox.y) ? childMaxBBox.y : node->absMaxAABBox.y;
				childMaxBBox.z = (childMaxBBox.z > node->absMaxAABBox.z) ? childMaxBBox.z : node->absMaxAABBox.z;
			}
		}*/
		
		corner[0] = this->minAABBox;
		corner[1] = this->minAABBox; corner[1].x = this->maxAABBox.x;
		corner[2] = this->maxAABBox; corner[2].y = this->minAABBox.y;
		corner[3] = this->minAABBox; corner[3].z = this->maxAABBox.z;
		corner[4] = this->minAABBox; corner[4].y = this->maxAABBox.y;
		corner[5] = this->maxAABBox; corner[5].z = this->minAABBox.z;
		corner[6] = this->maxAABBox;
		corner[7] = this->maxAABBox; corner[7].x = this->minAABBox.x;
		for(int i=0;i<8;i++) {
			this->getAbsoluteVector(corner[i], corner[i]);
			//min
			childMinBBox.x = (childMinBBox.x < corner[i].x) ? childMinBBox.x : corner[i].x;
			childMinBBox.y = (childMinBBox.y < corner[i].y) ? childMinBBox.y : corner[i].y;
			childMinBBox.z = (childMinBBox.z < corner[i].z) ? childMinBBox.z : corner[i].z;

			childMaxBBox.x = (childMaxBBox.x > corner[i].x) ? childMaxBBox.x : corner[i].x;
			childMaxBBox.y = (childMaxBBox.y > corner[i].y) ? childMaxBBox.y : corner[i].y;
			childMaxBBox.z = (childMaxBBox.z > corner[i].z) ? childMaxBBox.z : corner[i].z;
		}
		this->absMinAABBox = childMinBBox;
		this->absMaxAABBox = childMaxBBox;
		this->absBoxCenter = (this->absMinAABBox + this->absMaxAABBox)/2;
	} else {
		for(it=this->children.begin();it!=itEnd;it++) {
			node = (*it).get();
			if(!node->onStandBy() && node->isVisible()) {
				node->updateBBox();
			}
		}
	}
}

void Node::setDetail(Vector ObjectCenter) {
	//nothing happens here, only in Object3d...
}

void Node::orientAndMove(Vector direction, Vector upVec, Vector moveVec, bool moveRelative)
{
	Vector globalPos;
	//wenn !moveRelative ....absPos+=moveVec
	if(moveRelative) {
		globalPos = this->getAbsolutePosition();
	} else {
		this->getAbsoluteVector(globalPos, moveVec);
	}
	
	//X Axis berechnen mit crossProd
	Vector xAxis;
	direction.normalize();	//z Axis
	upVec.normalize();		//y Axis
	xAxis = upVec.crossProd(direction); //x Axis
	xAxis.normalize();
	upVec = direction.crossProd(xAxis);
	upVec.normalize();
	/*Vector xAxis;
	direction.normalize();	//z Axis
	upVec.normalize();		//y Axis
	xAxis = upVec.crossProd(direction); //x Axis*/

	//Matrix zusammensetzen + translation
	D3DXMATRIXA16 wMat;
	D3DXMatrixIdentity(&wMat);
	wMat._11 = xAxis.x; wMat._12 = upVec.x; wMat._13 = direction.x;
	wMat._21 = xAxis.y; wMat._22 = upVec.y; wMat._23 = direction.y;
	wMat._31 = xAxis.z; wMat._32 = upVec.z; wMat._33 = direction.z;

	wMat._41 = globalPos.x; wMat._42 = globalPos.y; wMat._43 = globalPos.z;

	//wenn moveRelative, translationsMatrix erstellen und "moven"
	if(moveRelative) {
		D3DXMATRIXA16 trans;
		D3DXMatrixTranslation(&trans, moveVec.x, moveVec.y, moveVec.z);
		D3DXMatrixMultiply(&wMat, &trans, &wMat);
	}
	
	//wenn pActor-> matrix dort auch setzen
	if(this->pActor!=NULL) {
		NxMat34 pMat;
		//pMat.setColumnMajor44(((NxF32 *) &wMat.m[0][0]));
		pMat.setRowMajor44(((NxF32 *) &wMat.m[0][0]));
		this->pActor->setGlobalPose(pMat);
		this->pActor->setGlobalPosition(globalPos.getNxVector());
	} else {
		this->setWorldMatrix(wMat);
	}
	this->myPosition = globalPos;
}

bool Node::isA(int _nodeType)
{
	return (this->nodeType & _nodeType);
}

void Node::clonePhysicStuff(Node* obj)
{
/*	obj->pBodyDesc = this->pBodyDesc;
	obj->pActorDesc.body = &obj->pBodyDesc;

	obj->pActorDesc = this->pActorDesc;
	obj->pActorDesc.shapes.clear();
	this->pShapeDescSize = 0;
	for(int i=0;i<this->pActorDesc.shapes.size();i++) {
		NxShapeDesc shapeDesc = *this->pActorDesc.shapes[i];
		
		//this->pShapeDescVector.push_back(shapeDesc);
		this->pShapeDesc[this->pShapeDescSize] = shapeDesc;
		this->pShapeDescSize++;
		//obj->pActorDesc.shapes.pushBack(&this->pShapeDescVector.at(i));
	}*/
}

void Node::OnLostDevice( void* pUserContext )
{
}

void Node::OnDestroyDevice( void* pUserContext ) 
{
}

HRESULT Node::OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) 
{
	return S_OK;
}

void Node::setSoftKill(bool _softKill, float _duration)
{
	this->softKill = _softKill;
	this->softKillDuration = _duration;
	std::list<SPTR<Node> >::iterator it;
	for(it=this->children.begin(); it!=this->children.end();it++) {
		(*it)->setSoftKill(_softKill, _duration);
	}
}

bool Node::getSoftKill()
{
	return this->softKill;
}