void EntityManager::setCameraToPrimaryCharacer()
{
	mView->setCenter(getCharacterPos());
}
void RenderCharacters()
{
	NxU32 number = gManager->getNbControllers();
	for(NxU32 i=0;i<number;i++)
	{
		if(i&1)
		{
			//#ifdef USE_BOX_CONTROLLER
			glDisable(GL_LIGHTING);

			NxBoxController* bc = static_cast<NxBoxController*>(gManager->getController(i));

			// Catch current extents
			const NxVec3& extents = bc->getExtents();

			// Generate 8 corners of the bbox
			NxExtendedVec3 tmp = GetCharacterPos(i);
			NxVec3 min = NxVec3(tmp.x, tmp.y, tmp.z) - extents;
			NxVec3 max = NxVec3(tmp.x, tmp.y, tmp.z) + extents;

			NxVec3 e = extents;
			e.y += SKINWIDTH;
			min = NxVec3(tmp.x, tmp.y, tmp.z) - e;
			max = NxVec3(tmp.x, tmp.y, tmp.z) + e;

			NxVec3 pts[8];
			pts[0] = NxVec3(min.x, min.y, min.z);
			pts[1] = NxVec3(max.x, min.y, min.z);
			pts[2] = NxVec3(max.x, max.y, min.z);
			pts[3] = NxVec3(min.x, max.y, min.z);
			pts[4] = NxVec3(min.x, min.y, max.z);
			pts[5] = NxVec3(max.x, min.y, max.z);
			pts[6] = NxVec3(max.x, max.y, max.z);
			pts[7] = NxVec3(min.x, max.y, max.z);

			// Render box

			static float vertexBuf[24*3];
			vertexBuf[ 0] = pts[0].x;
			vertexBuf[ 1] = pts[0].y;
			vertexBuf[ 2] = pts[0].z;
			vertexBuf[ 3] = pts[1].x;
			vertexBuf[ 4] = pts[1].y;
			vertexBuf[ 5] = pts[1].z;
			vertexBuf[ 6] = pts[1].x;
			vertexBuf[ 7] = pts[1].y;
			vertexBuf[ 8] = pts[1].z;
			vertexBuf[ 9] = pts[2].x;
			vertexBuf[10] = pts[2].y;
			vertexBuf[11] = pts[2].z;
			vertexBuf[12] = pts[2].x;
			vertexBuf[13] = pts[2].y;
			vertexBuf[14] = pts[2].z;
			vertexBuf[15] = pts[3].x;
			vertexBuf[16] = pts[3].y;
			vertexBuf[17] = pts[3].z;
			vertexBuf[18] = pts[3].x;
			vertexBuf[19] = pts[3].y;
			vertexBuf[20] = pts[3].z;
			vertexBuf[21] = pts[0].x;
			vertexBuf[22] = pts[0].y;
			vertexBuf[23] = pts[0].z;
			vertexBuf[24] = pts[4].x;
			vertexBuf[25] = pts[4].y;
			vertexBuf[26] = pts[4].z;
			vertexBuf[27] = pts[5].x;
			vertexBuf[28] = pts[5].y;
			vertexBuf[29] = pts[5].z;
			vertexBuf[30] = pts[5].x;
			vertexBuf[31] = pts[5].y;
			vertexBuf[32] = pts[5].z;
			vertexBuf[33] = pts[6].x;
			vertexBuf[34] = pts[6].y;
			vertexBuf[35] = pts[6].z;
			vertexBuf[36] = pts[6].x;
			vertexBuf[37] = pts[6].y;
			vertexBuf[38] = pts[6].z;
			vertexBuf[39] = pts[7].x;
			vertexBuf[40] = pts[7].y;
			vertexBuf[41] = pts[7].z;
			vertexBuf[42] = pts[7].x;
			vertexBuf[43] = pts[7].y;
			vertexBuf[44] = pts[7].z;
			vertexBuf[45] = pts[4].x;
			vertexBuf[46] = pts[4].y;
			vertexBuf[47] = pts[4].z;
			vertexBuf[48] = pts[0].x;
			vertexBuf[49] = pts[0].y;
			vertexBuf[50] = pts[0].z;
			vertexBuf[51] = pts[4].x;
			vertexBuf[52] = pts[4].y;
			vertexBuf[53] = pts[4].z;
			vertexBuf[54] = pts[1].x;
			vertexBuf[55] = pts[1].y;
			vertexBuf[56] = pts[1].z;
			vertexBuf[57] = pts[5].x;
			vertexBuf[58] = pts[5].y;
			vertexBuf[59] = pts[5].z;
			vertexBuf[60] = pts[3].x;
			vertexBuf[61] = pts[3].y;
			vertexBuf[62] = pts[3].z;
			vertexBuf[63] = pts[7].x;
			vertexBuf[64] = pts[7].y;
			vertexBuf[65] = pts[7].z;
			vertexBuf[66] = pts[2].x;
			vertexBuf[67] = pts[2].y;
			vertexBuf[68] = pts[2].z;
			vertexBuf[69] = pts[6].x;
			vertexBuf[70] = pts[6].y;
			vertexBuf[71] = pts[6].z;

			glEnableClientState(GL_VERTEX_ARRAY);

			glVertexPointer(3, GL_FLOAT, 0, 24, vertexBuf);

			//		if(i!=0 || !gJump) 
			glColor4f(1.0f, 1.0f, 0.0f, 1.0f);
			//		else               glColor4f(1.0f, 0.0f, 1.0f, 1.0f);

			glDrawArrays(GL_LINES, 0, 24);
			glDisableClientState(GL_VERTEX_ARRAY);
			//#endif
		}
		else
		{
			//#ifdef USE_CAPSULE_CONTROLLER
			glEnable(GL_LIGHTING);
			glEnable(GL_BLEND);
			glBlendFunc(GL_ONE, GL_ONE);
			glDepthMask(GL_FALSE);

			NxCapsuleController* cc = static_cast<NxCapsuleController*>(gManager->getController(i));

#ifdef DEBUG_CCT
			const NxExtendedVec3& pos = i ? getCharacterPos(i) : gLimitPos;
#else
			const NxExtendedVec3& pos = GetCharacterPos(i);
#endif
			NxF32 r = cc->getRadius();
			const NxF32 h = cc->getHeight();
			if(gDrawSkinWidth)	r += SKINWIDTH;

			glDisable(GL_LIGHTING);
			glDisable(GL_BLEND);
			static GLfloat colorBuf[] = {
				1.0f, 0.0f, 0.0f, 1.0f,
				1.0f, 0.0f, 0.0f, 1.0f,
				0.0f, 1.0f, 0.0f, 1.0f,
				0.0f, 1.0f, 0.0f, 1.0f,
				0.0f, 0.0f, 1.0f, 1.0f,
				0.0f, 0.0f, 1.0f, 1.0f,
				1.0f, 1.0f, 0.0f, 1.0f,
				1.0f, 1.0f, 0.0f, 1.0f
			};

			static GLfloat vertexBuf[8*3];
			vertexBuf[ 0] = pos.x;
			vertexBuf[ 1] = pos.y;
			vertexBuf[ 2] = pos.z;
			vertexBuf[ 3] = pos.x+h;
			vertexBuf[ 4] = pos.y;
			vertexBuf[ 5] = pos.z;
			vertexBuf[ 6] = pos.x;
			vertexBuf[ 7] = pos.y;
			vertexBuf[ 8] = pos.z;
			vertexBuf[ 9] = pos.x;
			vertexBuf[10] = pos.y+h;
			vertexBuf[11] = pos.z;
			vertexBuf[12] = pos.x;
			vertexBuf[13] = pos.y;
			vertexBuf[14] = pos.z;
			vertexBuf[15] = pos.x;
			vertexBuf[16] = pos.y;
			vertexBuf[17] = pos.z+h;
			vertexBuf[18] = pos.x;
			vertexBuf[19] = pos.y-h*0.5f-r;
			vertexBuf[20] = pos.z;
			vertexBuf[21] =	pos.x;
			vertexBuf[22] = pos.y+h*0.5f+r;
			vertexBuf[23] = pos.z;

			glEnableClientState(GL_VERTEX_ARRAY);
			glEnableClientState(GL_COLOR_ARRAY);

			glVertexPointer(3, GL_FLOAT, 0, 8, vertexBuf);
			glColorPointer(4, GL_FLOAT, 0, 8, colorBuf);

			glDrawArrays(GL_LINES, 0, 8);

			glDisableClientState(GL_COLOR_ARRAY);
			glDisableClientState(GL_VERTEX_ARRAY);

			glEnable(GL_BLEND);
			glEnable(GL_LIGHTING);

			float glmat[16];
			memset(glmat, 0, 16*4);
			glmat[0] = glmat[5] = glmat[10] = glmat[15] = 1.0f;
			glmat[12] = pos.x;
			glmat[13] = pos.y;
			glmat[14] = pos.z;

			glPushMatrix();
			glMultMatrixf(&(glmat[0]));
			NxVec3 color(1.0f, 1.0f, 1.0f);
			DrawCapsule(color, r, h);
			glPopMatrix();
			//#endif
		}


#ifdef __PPCGEKKO__
		glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
		glBegin(GL_LINES, 2);
		glVertex3d(gPts[i].x, gPts[i].y, gPts[i].z);
		glVertex3d(gPts[i].x+1.0f, gPts[i].y, gPts[i].z);
		glEnd();
		
		glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
		glBegin(GL_LINES, 2);
		glVertex3d(gPts[i].x, gPts[i].y, gPts[i].z);
		glVertex3d(gPts[i].x, gPts[i].y+1.0f, gPts[i].z);
		glEnd();
		
		glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
		glBegin(GL_LINES, 2);
		glVertex3d(gPts[i].x, gPts[i].y, gPts[i].z);
		glVertex3d(gPts[i].x, gPts[i].y, gPts[i].z+1.0f);
		glEnd();
#else
		glEnableClientState(GL_VERTEX_ARRAY);
		float line1[2][3] = { {gPts[i].x, gPts[i].y, gPts[i].z}, {gPts[i].x+1.0f, gPts[i].y, gPts[i].z}};
		glVertexPointer(3, GL_FLOAT, 0, line1);
		glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
		glDrawArrays(GL_LINES, 0, 2);
		float line2[2][3] = { {gPts[i].x, gPts[i].y, gPts[i].z}, {gPts[i].x, gPts[i].y+1.0f, gPts[i].z}};
		glVertexPointer(3, GL_FLOAT, 0, line2);
		glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
		glDrawArrays(GL_LINES, 0, 2);
		float line3[2][3] = { {gPts[i].x, gPts[i].y, gPts[i].z}, {gPts[i].x, gPts[i].y, gPts[i].z+1.0f}};
		glVertexPointer(3, GL_FLOAT, 0, line3);
		glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
		glDrawArrays(GL_LINES, 0, 2);
		glDisableClientState(GL_VERTEX_ARRAY);
#endif
#ifdef DRAW_CONTACT_DATA
		// Draw contact data, if valid
		if(gNbContactPts)
		{
			NxVec3* t = new NxVec3[gNbContactPts*2];
			for(NxU32 i=0;i<gNbContactPts;i++)
			{
				t[i*2+0] = gContactPt[i];
				t[i*2+1] = gContactPt[i] + gContactNorm[i] * 10.0f;
			}
			glEnableClientState(GL_VERTEX_ARRAY);
			glVertexPointer(3, GL_FLOAT, 0, t);
			glColor4f(1.0f, 0.0f, 1.0f, 1.0f);
			glDrawArrays(GL_LINES, 0, gNbContactPts*2);
			glDisableClientState(GL_VERTEX_ARRAY);
			delete[]t;
			gNbContactPts = 0;
		}
#endif

#ifdef DRAW_TOUCHED_TRIANGLE
		// Draw touched triangle, if valid
		if(gValidTouchedTri)
		{
			glDisable(GL_CULL_FACE);
			/*			glEnableClientState(GL_VERTEX_ARRAY);
			glVertexPointer(3, GL_FLOAT, 0, &gTouchedTri);
			glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
			glDrawArrays(GL_TRIANGLES, 0, 3);
			glDisableClientState(GL_VERTEX_ARRAY);*/

			NxVec3 t[6];
			t[0] = gTouchedTri.verts[0];
			t[1] = gTouchedTri.verts[1];
			t[2] = gTouchedTri.verts[1];
			t[3] = gTouchedTri.verts[2];
			t[4] = gTouchedTri.verts[2];
			t[5] = gTouchedTri.verts[0];
			glEnableClientState(GL_VERTEX_ARRAY);
			glVertexPointer(3, GL_FLOAT, 0, t);
			glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
			glDrawArrays(GL_LINES, 0, 6);
			glDisableClientState(GL_VERTEX_ARRAY);
			glEnable(GL_CULL_FACE);
		}
#endif
	}

	//#ifdef USE_CAPSULE_CONTROLLER
	glDisable(GL_BLEND);
	glDepthMask(GL_TRUE);
	//#endif

	glEnable(GL_LIGHTING);
}
// updaterar view positionen
void EntityManager::updateView()
{
	sf::Vector2f playerPos = getCharacterPos();

	sf::Vector2f dist = playerPos - mCameraFakePos;

	float length = 0;
	length = std::sqrt((dist.x * dist.x) + (dist.y *dist.y));
	
	if(dist != sf::Vector2f(0, 0))
	{
		
		dist.x *= 1.0f / length;
		dist.y *= 1.0f / length;
	}	

	if(length > 5)
	{
		if(length < 100)
		{
			if(length > 20)
			{
				mCameraSpeed = 6.5;
			}
			else
			{
				mCameraSpeed = 1.5;	
				mParalax = true;
			}	
			
		}
		mCameraFakePos += sf::Vector2f(dist.x * mCameraSpeed, dist.y * mCameraSpeed);
	}
	else
	{
		mCameraFakePos = playerPos;
	}
	
	mView->setCenter(mCameraFakePos);
	
	if(mView->getCenter().x < mMapLeft)
	{
		mView->setCenter(sf::Vector2f(mMapLeft, mView->getCenter().y));
		mParalax = true;
	}
	else if(mView->getCenter().x > mMapRight)
	{
		mView->setCenter(sf::Vector2f(mMapRight, mView->getCenter().y));
		mParalax = true;
	}
	if(mView->getCenter().y < mMapTop)
	{
		mView->setCenter(sf::Vector2f(mView->getCenter().x, mMapTop));
		mParalax = true;
	}
	else if(mView->getCenter().y > mMapBottom)
	{
		mView->setCenter(sf::Vector2f(mView->getCenter().x, mMapBottom));
		mParalax = true;
	}

	//if(playerPos.x > mMapLeft && playerPos.x < mMapRight)
	//{
	//	mView->setCenter(sf::Vector2f(playerPos.x, mView->getCenter().y));
	//}
	//else
	//{
	//	if(playerPos.x > mMapRight / 2)
	//	{
	//		mView->setCenter(sf::Vector2f(mMapRight, mView->getCenter().y));
	//	}
	//	else
	//	{
	//		mView->setCenter(sf::Vector2f(mMapLeft, mView->getCenter().y));
	//	}	
	//}
	//// det står fan totte överallt
	//// jag vet!!! och det stör mig som faaan!
	//if(playerPos.y > mMapTop && playerPos.y < mMapBottom)
	//{
	//	mView->setCenter(sf::Vector2f(mView->getCenter().x, playerPos.y));
	//}
	//else
	//{
	//	if(playerPos.y > mMapBottom / 2)
	//	{
	//		mView->setCenter(sf::Vector2f(mView->getCenter().x, mMapBottom));
	//	}
	//	else
	//	{
	//		mView->setCenter(sf::Vector2f(mView->getCenter().x, mMapTop));
	//	}
	//}
	
}