Sorry your browser is not supported!

int CNewton::LoadStaticWorld(int nObjectID, char *szObjectFile) {
	nStaticWorldID = nObjectID;	
	dbLoadObject(szObjectFile, nObjectID);

	newtonTreeCol = NewtonCreateTreeCollision(newtonWorld, NULL);	
	NewtonTreeCollisionBeginBuild(newtonTreeCol);

	dbPerformCheckListForObjectLimbs(nObjectID);

	dFloat face[9];

	for (int nLimb = 1; nLimb <= dbChecklistQuantity(); nLimb++) {
		dbLockVertexDataForLimb(nObjectID, nLimb);

		int nTotalVerts = dbGetVertexDataVertexCount();		
		int nVertCount = 0;

		for (int v = 0; v < nTotalVerts; v+=3) {
			face[0] = dbGetVertexDataPositionX(v);
			face[1] = dbGetVertexDataPositionY(v);
			face[2] = dbGetVertexDataPositionZ(v);

			face[3] = dbGetVertexDataPositionX(v + 1);
			face[4] = dbGetVertexDataPositionY(v + 1);
			face[5] = dbGetVertexDataPositionZ(v + 1);

			face[6] = dbGetVertexDataPositionX(v + 2);
			face[7] = dbGetVertexDataPositionY(v + 2);
			face[8] = dbGetVertexDataPositionZ(v + 2);			

			if (v + 3 < nTotalVerts) {
				nVertCount = 3;
			} else {
				nVertCount = nTotalVerts - v;
			}

			NewtonTreeCollisionAddFace(newtonTreeCol, nVertCount, face, 12, 1);
		}
		dbUnlockVertexData();
	}

	NewtonTreeCollisionEndBuild(newtonTreeCol, 1);
	newtonWorldBody = NewtonCreateBody(newtonWorld, newtonTreeCol);

	NewtonReleaseCollision(newtonWorld, newtonTreeCol);
	float m_matrix[16];

	dVector boxP0; 
	dVector boxP1; 
	
	NewtonCollisionCalculateAABB (newtonTreeCol, &m_matrix[0], &boxP0.m_x, &boxP1.m_x); 

	// add some extra padding the world size
	boxP0.m_x -= 50.0f;
	boxP0.m_y -= 50.0f;
	boxP0.m_z -= 50.0f;
	boxP1.m_x += 50.0f;
	boxP1.m_y += 50.0f;
	boxP1.m_z += 50.0f;

	// set the world size
	NewtonSetWorldSize (newtonWorld, &boxP0.m_x, &boxP1.m_x); 

	return 0;
}

void  DebugShowCollision (NewtonWorld* nWorld)
{
	int i;

//	glDisable (GL_LIGHTING);
//	glDisable(GL_TEXTURE_2D);
	
//	glBegin(GL_LINES);
//	glColor3f(1.0f, 1.0f, 0.0f);
	NewtonWorldForEachBodyDo (nWorld, DebugShowBodyCollision);

//	glColor3f(0.0f, 0.0f, 1.0f);
//	for (i = 0; i <debugCount; i ++) {
//		glVertex3f (debugFace[i][0].m_x, debugFace[i][0].m_y, debugFace[i][0].m_z);
//		glVertex3f (debugFace[i][1].m_x, debugFace[i][1].m_y, debugFace[i][1].m_z);
//	}
//	glEnd();
}

void  DebugShowBodyCollision (const NewtonBody* body) {
	dFloat Ixx;
	dFloat Iyy;
	dFloat Izz;
	dFloat mass;

	// only show collision for dynamics objects
	//NewtonBodyGetMassMatrix (body, &mass, &Ixx, &Iyy, &Izz);
	//if (mass > 0.0f) {

		//i commented out this conditional because i want it to show a wireframe for static objects (my level) too
		NewtonBodyForEachPolygonDo (body, DebugShowGeometryCollision);
	//}
}

void DebugShowGeometryCollision (const NewtonBody* body, int vertexCount, const dFloat* faceVertec, int id) {
	int i;

	i = vertexCount - 1;
	dFloat p0[3] = { faceVertec[i * 3 + 0], faceVertec[i * 3 + 1], faceVertec[i * 3 + 2] };

	numpoly++; //just use this to try and keep track of how many polies it thinks it has

	for (i = 0; i < vertexCount; i ++) {
		dFloat p1[3] = { faceVertec[i * 3 + 0], faceVertec[i * 3 + 1], faceVertec[i * 3 + 2] };
		dbMakeObjectTriangle(lines + thisline, p0[0], p0[1], p0[2], p0[0], p0[1] + 0.05f, p0[2], p1[0], p1[1], p1[2]);
		dbColorObject(lines+thisline, dbRgb(255, 0, 0));
		//glVertex3f (p0.m_x, p0.m_y, p0.m_z);
		//glVertex3f (p1.m_x, p1.m_y, p1.m_z);
 		p0[0] = p1[0];
		p0[1] = p1[1];
		p0[2] = p1[2];
		thisline++;	//and this to track how many lines i've made
	}
}

#include "DarkGDK.h"
#include "Newton.h"
#include "CNewton.h"
#include "Vector.h"
#include "Matrix.h"

//#define dbNewtMalloc(n) malloc(n)
//#define dbNewtFree(n) free(n)

void *dbNewtMalloc(int n) { return malloc(n); }
void dbNewtFree(void *p, int s) { free(p); }

int lines = 100;
int thisline = 0;
int numpoly = 0;

CNewton::CNewton() {
	newtonWorld = NULL;
	newtonTreeCol = NULL;

	newtonWorld = NewtonCreate(dbNewtMalloc, dbNewtFree);
	int groupID = NewtonMaterialGetDefaultGroupID(newtonWorld);
	NewtonMaterialSetDefaultFriction(newtonWorld, groupID, groupID, 1.0f, 0.9f);

	bInitialised = true;
}

CNewton::~CNewton() {
	NewtonDestroy(newtonWorld);
}

int facesAdded = 0;

int CNewton::LoadStaticWorld(int nObjectID, char *szObjectFile) {
	nStaticWorldID = nObjectID;	
	dbLoadObject(szObjectFile, nObjectID);
	//dbMakeObjectCube(nObjectID, 100);

	dbMakeMeshFromObject(1, nObjectID);

	newtonTreeCol = NewtonCreateTreeCollision(newtonWorld, NULL);	
	NewtonTreeCollisionBeginBuild(newtonTreeCol);
	

	dbLockVertexDataForMesh(1);
	int nIndices = dbGetVertexDataIndexCount();	
	
	dVector facePoints[3];

	for (int i = 0; i < nIndices; i += 3) {
		facePoints[0].m_x = dbGetVertexDataPositionX(dbGetIndexData(i));
		facePoints[0].m_y = dbGetVertexDataPositionY(dbGetIndexData(i));
		facePoints[0].m_z = dbGetVertexDataPositionZ(dbGetIndexData(i));

		facePoints[1].m_x = dbGetVertexDataPositionX(dbGetIndexData(i + 1));
		facePoints[1].m_y = dbGetVertexDataPositionY(dbGetIndexData(i + 1));
		facePoints[1].m_z = dbGetVertexDataPositionZ(dbGetIndexData(i + 1));

		facePoints[2].m_x = dbGetVertexDataPositionX(dbGetIndexData(i + 2));
		facePoints[2].m_y = dbGetVertexDataPositionY(dbGetIndexData(i + 2));
		facePoints[2].m_z = dbGetVertexDataPositionZ(dbGetIndexData(i + 2));

		//dbMakeObjectTriangle(lines + thisline, facePoints[0].m_x, facePoints[0].m_y, facePoints[0].m_z, facePoints[1].m_x, facePoints[1].m_y, facePoints[1].m_z, facePoints[2].m_x, facePoints[2].m_y, facePoints[2].m_z);
		//dbColorObject(lines+thisline, dbRgb(dbRnd(255), dbRnd(255), dbRnd(255)));
		//thisline++;
		
		facesAdded++;
		NewtonTreeCollisionAddFace(newtonTreeCol, 3, &facePoints[0].m_x, sizeof(dVector), 0);
	}		
	
	dbUnlockVertexData();
	dbDeleteMesh(1);

	NewtonTreeCollisionEndBuild(newtonTreeCol, 0);

	newtonWorldBody = NewtonCreateBody(newtonWorld, newtonTreeCol);
	dMatrix m(GetIdentityMatrix());
	NewtonBodySetMatrix(newtonWorldBody, &m[0][0]);	

	dVector boxP0; 
	dVector boxP1; 	
	NewtonCollisionCalculateAABB(newtonTreeCol, &m[0][0], &boxP0.m_x, &boxP1.m_x); 

	// add some extra padding the world size
	boxP0.m_x -= 10.0f;
	boxP0.m_y -= 10.0f;
	boxP0.m_z -= 10.0f;
	boxP1.m_x += 10.0f;
	boxP1.m_y += 10.0f;
	boxP1.m_z += 10.0f;

	// set the world size
	NewtonSetWorldSize(newtonWorld, &boxP0.m_x, &boxP1.m_x); 
	NewtonReleaseCollision(newtonWorld, newtonTreeCol);

	return 0;
}

int CNewton::LoadDynamicObject(int nObjectID, char *szObjectFile) {
	dbMakeObjectCube(nObjectID, 100);
}


int getlines() {
	return thisline;
}

void DebugShowGeometryCollision (const NewtonBody* body, int vertexCount, const dFloat* faceVertec, int id);
void  DebugShowBodyCollision (const NewtonBody* body);

void  DebugShowCollision (NewtonWorld* nWorld) {
	NewtonWorldForEachBodyDo (nWorld, DebugShowBodyCollision);
}

void  DebugShowBodyCollision (const NewtonBody* body) {	
	NewtonBodyForEachPolygonDo (body, DebugShowGeometryCollision);
}

void DebugShowGeometryCollision (const NewtonBody* body, int vertexCount, const dFloat* faceVertec, int id) {
	int i;

	numpoly++; //just use this to try and keep track of how many polies it thinks it has

	for (i = 0; i < vertexCount; i+=8) {
		dbMakeObjectTriangle(lines + thisline, faceVertec[i], faceVertec[i+1], faceVertec[i+2], faceVertec[i+3], faceVertec[i+4], faceVertec[i+5], faceVertec[i+6], faceVertec[i+7], faceVertec[i+8]);		
		dbColorObject(lines+thisline, dbRgb(dbRnd(255), dbRnd(255), dbRnd(255)));	
		thisline++;
	}
}