Bevels Added, and improved rendernig performance.

CameraController.cpp

@@ -7,18 +7,17 @@
 
 
 
-CameraController::CameraController(){
+CameraController::CameraController() :
-	yaw=0;
+yaw(0), 
-	pitch=0;
+pitch(0),
-	moveRate=0.5f;
+moveRate(1.0f),
-	forwards=false;
+forwards(false),
-	backwards=false;
+backwards(false),
-	left=false;
+left(false),
-	right=false;
+right(false),
-	zoom=7.f;
+zoom(14.f),
-	rightButtonHolding=false;
+rightButtonHolding(false),
-	focusPosition=Vector3(0,0,0);
+focusPosition(Vector3(0,0,0)) {}
-}
 
 GCamera* CameraController::getCamera()
 {
@@ -209,10 +208,10 @@ void CameraController::update(Demo* demo)
 	}
 
 	if(GetHoldKeyState(VK_RSHIFT) || GetHoldKeyState(VK_LSHIFT)) {
-		moveRate = 1;
+		moveRate = 2.f;
 	}
 	else {
-		moveRate = 0.5;
+		moveRate = 1.f;
 	}
 
 	if(GetHoldKeyState(VK_RBUTTON))

Instance.cpp

@@ -22,11 +22,19 @@ Instance::Instance(const Instance &oinst)
 
 
 void Instance::render(RenderDevice* rd)
-{
+{	
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glEnableClientState(GL_COLOR_ARRAY);
+	glEnableClientState(GL_NORMAL_ARRAY);
+
 	for(size_t i = 0; i < children.size(); i++)
 	{
 		children.at(i)->render(rd);
 	}
+
+	glDisableClientState(GL_VERTEX_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
+	glDisableClientState(GL_NORMAL_ARRAY);
 }
 
 

PhysicalInstance.cpp

@@ -1,10 +1,12 @@
 #include "PhysicalInstance.h"
 #include "Globals.h"
+#include <sstream>
+#include <iomanip>
 
+using namespace G3D;
 
-PhysicalInstance::PhysicalInstance(void)
+PhysicalInstance::PhysicalInstance(void) : _bevelSize(0.03f), _parseVert(0), _debugTimer(0)
 {
-	Instance::Instance();
     name = "Default PhysicalInstance";
 	className = "Part";
 	canCollide = true;
@@ -98,9 +100,18 @@ void PhysicalInstance::setCFrame(CoordinateFrame coordinateFrame)
 
 CoordinateFrame PhysicalInstance::getCFrameRenderBased()
 {
-	return CoordinateFrame(getCFrame().rotation,Vector3(getCFrame().translation.x/2, getCFrame().translation.y/2, getCFrame().translation.z/2));
+	return CoordinateFrame(getCFrame().rotation,Vector3(getCFrame().translation.x, getCFrame().translation.y, getCFrame().translation.z));
 }
 
+#ifdef NEW_BOX_RENDER
+Box PhysicalInstance::getBox()
+{	
+	Box box = Box(Vector3(size.x/2, size.y/2, size.z/2) ,Vector3(-size.x/2,-size.y/2,-size.z/2));
+	CoordinateFrame c = getCFrameRenderBased();
+	itemBox = c.toWorldSpace(box);
+	return itemBox;
+}
+#else
 Box PhysicalInstance::getBox()
 {
 	if(changed)
@@ -111,36 +122,268 @@ Box PhysicalInstance::getBox()
 		Vector3 v0,v1,v2,v3;
 		for (int f = 0; f < 6; f++) {
 			itemBox.getFaceCorners(f, v0,v1,v2,v3);
-			vertecies[f*16] = v0.x;
+			_vertices[f*16] = v0.x;
-			vertecies[(f*16)+1] = v0.y;
+			_vertices[(f*16)+1] = v0.y;
-			vertecies[(f*16)+2] = v0.z;
+			_vertices[(f*16)+2] = v0.z;
-			vertecies[(f*16)+3] = v1.x;
+			_vertices[(f*16)+3] = v1.x;
-			vertecies[(f*16)+4] = v1.y;
+			_vertices[(f*16)+4] = v1.y;
-			vertecies[(f*16)+5] = v1.z;
+			_vertices[(f*16)+5] = v1.z;
-			vertecies[(f*16)+6] = v2.x;
+			_vertices[(f*16)+6] = v2.x;
-			vertecies[(f*16)+7] = v2.y;
+			_vertices[(f*16)+7] = v2.y;
-			vertecies[(f*16)+8] = v2.z;
+			_vertices[(f*16)+8] = v2.z;
-			vertecies[(f*16)+9] = v3.x;
+			_vertices[(f*16)+9] = v3.x;
-			vertecies[(f*16)+10] = v3.y;
+			_vertices[(f*16)+10] = v3.y;
-			vertecies[(f*16)+11] = v3.z;
+			_vertices[(f*16)+11] = v3.z;
-			vertecies[(f*16)+12] = color.r;
+			_vertices[(f*16)+12] = color.r;
-			vertecies[(f*16)+13] = color.g;
+			_vertices[(f*16)+13] = color.g;
-			vertecies[(f*16)+14] = color.b;
+			_vertices[(f*16)+14] = color.b;
-			vertecies[(f*16)+15] = 1;
+			_vertices[(f*16)+15] = 1;
 		}
 	}
 	return itemBox;
 }
+#endif
 
 bool PhysicalInstance::collides(Box box)
 {
 	return CollisionDetection::fixedSolidBoxIntersectsFixedSolidBox(getBox(), box);
 }
+#ifdef NEW_BOX_RENDER
 
+void PhysicalInstance::addVertex(Vector3 vertexPos,Color3 color)
+{
+	_vertices.push_back(vertexPos.x);
+	_vertices.push_back(vertexPos.y);
+	_vertices.push_back(vertexPos.z);
+	_vertices.push_back(color.r);
+	_vertices.push_back(color.g);
+	_vertices.push_back(color.b);
+}
+
+void PhysicalInstance::addNormals(Vector3 normal)
+{
+	for (unsigned int i=0;i<3;i+=1) {
+		_normals.push_back(normal.x);
+		_normals.push_back(normal.y);
+		_normals.push_back(normal.z);
+	}
+}
+
+void PhysicalInstance::addTriangle(Vector3 v1,Vector3 v2,Vector3 v3)
+{
+	addVertex(v1,color);
+	addVertex(v2,color);
+	addVertex(v3,color);
+	addNormals(cross(v2-v1,v3-v1).direction());
+}
+
+void PhysicalInstance::debugPrintVertexIDs(RenderDevice* rd,GFontRef font,Matrix3 rot)
+{
+	_debugUniqueVertices.clear();
+	glDisable(GL_DEPTH_TEST);
+	
+	for (unsigned int i=0;i<_vertices.size();i+=6)
+	{
+		std::stringstream stream;
+		stream << std::fixed << std::setprecision(1) << i;
+		Vector3 testVector = Vector3(_vertices[i],_vertices[i+1],_vertices[i+2]);
+		if (isUniqueVertex(testVector))
+		{
+			
+			font->draw3D(rd, stream.str(), CoordinateFrame(testVector) * -rot, 0.05, Color3::fromARGB(0xFF4F0000), Color4::clear());
+			_debugUniqueVertices.push_back(testVector);
+
+		}
+	}
+
+
+	glEnable(GL_DEPTH_TEST);
+}
+
+void PhysicalInstance::makeFace(int vertex1,int vertex2, int vertex3)
+{
+	addTriangle(Vector3(_vertices[vertex1],_vertices[vertex1+1],_vertices[vertex1+2]),
+		Vector3(_vertices[vertex2],_vertices[vertex2+1],_vertices[vertex2+2]),
+		Vector3(_vertices[vertex3],_vertices[vertex3+1],_vertices[vertex3+2]));
+}
+bool PhysicalInstance::isUniqueVertex(Vector3 pos)
+{
+	for (unsigned int i=0;i<_debugUniqueVertices.size();i+=1)
+	{
+		if (pos==_debugUniqueVertices[i])
+		{
+			return false;
+		}
+	}
+	return true;
+}
+void PhysicalInstance::render(RenderDevice* rd) {
+
+	if (changed)
+	{
+		getBox();
+		_vertices.clear();
+		Vector3 renderSize = size/2;
+
+		// Front
+		addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,renderSize.z),
+			Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,renderSize.z),
+			Vector3(renderSize.x-_bevelSize,-renderSize.y+_bevelSize,renderSize.z)
+			);
+	
+		addTriangle(Vector3(-renderSize.x+_bevelSize,renderSize.y-_bevelSize,renderSize.z),
+			Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,renderSize.z),
+			Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,renderSize.z)
+			);
+		
+		// Top
+		addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y,renderSize.z-_bevelSize),
+			Vector3(renderSize.x-_bevelSize,renderSize.y,-renderSize.z+_bevelSize),
+			Vector3(-renderSize.x+_bevelSize,renderSize.y,renderSize.z-_bevelSize)
+			);
+		addTriangle(Vector3(-renderSize.x+_bevelSize,renderSize.y,renderSize.z-_bevelSize),
+			Vector3(renderSize.x-_bevelSize,renderSize.y,-renderSize.z+_bevelSize),
+			Vector3(-renderSize.x+_bevelSize,renderSize.y,-renderSize.z+_bevelSize)
+			);
+		
+		// Back
+		addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,-renderSize.z),
+			Vector3(renderSize.x-_bevelSize,-renderSize.y+_bevelSize,-renderSize.z),
+			Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,-renderSize.z)
+			);
+		addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,-renderSize.z),
+			Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,-renderSize.z),
+			Vector3(-renderSize.x+_bevelSize,renderSize.y-_bevelSize,-renderSize.z)
+			);
+
+		
+		// Bottom
+		addTriangle(Vector3(renderSize.x-_bevelSize,-renderSize.y,-renderSize.z+_bevelSize),
+			Vector3(renderSize.x-_bevelSize,-renderSize.y,renderSize.z-_bevelSize),
+			Vector3(-renderSize.x+_bevelSize,-renderSize.y,renderSize.z-_bevelSize)
+			);
+		addTriangle(Vector3(-renderSize.x+_bevelSize,-renderSize.y,renderSize.z-_bevelSize),
+			Vector3(-renderSize.x+_bevelSize,-renderSize.y,-renderSize.z+_bevelSize),
+			Vector3(renderSize.x-_bevelSize,-renderSize.y,-renderSize.z+_bevelSize)
+			);
+
+		// Left
+		addTriangle(Vector3(-renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize),
+			Vector3(-renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize),
+			Vector3(-renderSize.x,renderSize.y-_bevelSize,renderSize.z-_bevelSize)
+			);
+		addTriangle(Vector3(-renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize),
+			Vector3(-renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize),
+			Vector3(-renderSize.x,-renderSize.y+_bevelSize,-renderSize.z+_bevelSize)
+			);
+
+		// Right
+		addTriangle(Vector3(renderSize.x,renderSize.y-_bevelSize,renderSize.z-_bevelSize),
+			Vector3(renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize),
+			Vector3(renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize)
+			);
+		addTriangle(Vector3(renderSize.x,-renderSize.y+_bevelSize,-renderSize.z+_bevelSize),
+			Vector3(renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize),
+			Vector3(renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize)
+			);
+		
+
+		// Bevel Top Front
+		makeFace(0,36,48);
+		makeFace(48,18,0);
+
+		// Bevel Left Front Corner
+		makeFace(18,156,162);
+		makeFace(24,18,162);
+
+		// Bevel Left Front Top Corner
+		makeFace(48,156,18);
+
+		// Bevel Left Front Bottom Corner
+		makeFace(120,6,150);
+
+		// Bevel Left Top
+		makeFace(48,66,156);
+		makeFace(144,156,66);
+
+		// Bevel Bottom
+		makeFace(6,120,114);
+		makeFace(114,12,6);
+
+		// Left Bottom
+		makeFace(120,150,174);
+		makeFace(174,132,120);
+
+		// Right Front Top Corner
+		makeFace(36,0,180);
+
+		// Right Front Corner
+		makeFace(180,0,12);
+		makeFace(186,180,12);
+
+		// Right Front Bottom Corner
+		makeFace(186,12,114);
+
+		// Right Bottom
+		makeFace(186,114,108);
+		makeFace(108,198,186);
+
+		// Right Top Corner
+		makeFace(180,192,36);
+		makeFace(192,42,36);
+
+		// Right Back Top Corner
+		makeFace(72,42,192);
+
+		// Right Back Bottom Corner
+		makeFace(78,198,108);
+
+		// Right Back Corner
+		makeFace(72,192,198);
+		makeFace(198,78,72);
+
+		// Back Bottom Corner
+		makeFace(78,108,132);
+		makeFace(132,84,78);
+
+		// Back Top
+		makeFace(42,72,102);
+		makeFace(102,66,42);
+
+		// Back Left Top Corner
+		makeFace(144,66,102);
+
+		// Back Left Corner
+		makeFace(144,102,84);
+		makeFace(84,174,144);
+
+		// Back Left Bottom Corner
+		makeFace(174,84,132);
+	
+		for (unsigned short i=0;i<_vertices.size()/6;i++) {
+			_indices.push_back(i);
+		}		
+
+		changed=false;
+	}
+
+	glVertexPointer(3, GL_FLOAT,6 * sizeof(GLfloat), &_vertices[0]);
+	glColorPointer(3, GL_FLOAT,6 * sizeof(GLfloat), &_vertices[3]);
+	glNormalPointer(GL_FLOAT,3 * sizeof(GLfloat), &_normals[0]);
+
+	glPushMatrix();
+	glTranslatef(position.x,position.y,position.z);
+	glDrawElements(GL_TRIANGLES, _indices.size(), GL_UNSIGNED_SHORT, &_indices[0]);
+	glPopMatrix();
+}
+#else
 void PhysicalInstance::render(RenderDevice* rd)
 {
 	if(changed)
+	{
 		Box box = getBox();
+		changed=false;
+	}
 	
 	glColor(color);
 	/*glEnable( GL_TEXTURE_2D );
@@ -170,14 +413,14 @@ void PhysicalInstance::render(RenderDevice* rd)
 		else if(face == Inlets)
 			add = 0.2;*/
 
-		Vector3 v0 = Vector3(vertecies[i], vertecies[i+1], vertecies[i+2]), v1 = Vector3(vertecies[i+3], vertecies[i+4], vertecies[i+5]), v3 = Vector3(vertecies[i+9], vertecies[i+10], vertecies[i+11]);
+		Vector3 v0 = Vector3(_vertices[i], _vertices[i+1], _vertices[i+2]), v1 = Vector3(_vertices[i+3], _vertices[i+4], _vertices[i+5]), v3 = Vector3(_vertices[i+9], _vertices[i+10], _vertices[i+11]);
 		/*glNormal3fv((v1 - v0).cross(v3 - v0).direction());
 		glTexCoord2f(0.0F,0.0F);
 		glVertex3fv(v0);
 		glTexCoord2f(1.0F,0.0F);
 		glVertex3fv(v1);
 		glTexCoord2f(1.0F,0.25F);
-		glVertex3f(vertecies[i+6], vertecies[i+7], vertecies[i+8]);
+		glVertex3f(_vertices[i+6], _vertices[i+7], _vertices[i+8]);
 		glTexCoord2f(0.0F,0.25F);
 		glVertex3fv(v3);*/
 
@@ -192,7 +435,7 @@ void PhysicalInstance::render(RenderDevice* rd)
 		glTexCoord2d( 1.0,0.0+add);
 		glVertex3fv(v1);
 		glTexCoord2d(1.0,0.2+add);
-		glVertex3f(vertecies[i+6], vertecies[i+7], vertecies[i+8]);
+		glVertex3f(_vertices[i+6], _vertices[i+7], _vertices[i+8]);
 		glTexCoord2d( 0.0,0.2+add);
 		glVertex3fv(v3);
 		glEnd();
@@ -210,6 +453,7 @@ void PhysicalInstance::render(RenderDevice* rd)
 	}
 	
 }
+#endif
 
 PhysicalInstance::~PhysicalInstance(void)
 {

PhysicalInstance.h

@@ -2,6 +2,8 @@
 #include "instance.h"
 #include "Enum.h"
 
+#define NEW_BOX_RENDER
+
 class PhysicalInstance :
 	public Instance
 {
@@ -35,10 +37,29 @@ public:
 	bool collides(Box);
 	virtual std::vector<PROPGRIDITEM> getProperties();
 	virtual void PropUpdate(LPPROPGRIDITEM &pItem);
+	void addVertex(Vector3 vertexPos,Color3 color);
+	void addNormals(Vector3 normal);
+	void addTriangle(Vector3 vertexPos,Vector3 vertexPos2, Vector3 vertexPos3);
+	void debugPrintVertexIDs(RenderDevice* rd, GFontRef font, Matrix3 camRot);
+	void makeFace(int vertex1, int vertex2, int vertex3);
+	bool isUniqueVertex(Vector3 pos);
 private:
 	Vector3 position;
 	Vector3 size;
-	GLfloat vertecies[96];
+	float	_bevelSize;
+	int		_parseVert;
+	int		_debugTimer;
+	std::vector<Vector3> _debugUniqueVertices;
+
+	#ifdef NEW_BOX_RENDER
+		std::vector<GLfloat> _vertices;
+		std::vector<GLfloat> _normals;
+	#else
+		GLfloat _vertices[96];
+	#endif
+
+	std::vector<GLushort> _indices;
+
 	bool changed;
 	Box itemBox;
 };

TextButtonInstance.cpp

@@ -68,6 +68,9 @@ void TextButtonInstance::drawObj(RenderDevice* rd, Vector2 mousePos, bool mouseD
 {
 	Vector3 point1;
 	Vector3 point2;
+
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
 	if(floatBottom)
 	{
 		point1 = Vector3(boxBegin.x, rd->getHeight() + boxBegin.y,0);
@@ -95,6 +98,8 @@ void TextButtonInstance::drawObj(RenderDevice* rd, Vector2 mousePos, bool mouseD
 		Draw::box(Box(point1, point2), rd, boxColor, boxOutlineColor);
 		font->draw2D(rd, title, RelativeTo, textSize, textColor, textOutlineColor);
 	}
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glEnableClientState(GL_COLOR_ARRAY);
 }
 
 void doNullCheck()

main.cpp

@@ -715,9 +715,7 @@ void Demo::onInit()  {
 	test->setSize(Vector3(24,1,24));
 	test->setPosition(Vector3(0,0,0));
 	test->setCFrame(test->getCFrame() * Matrix3::fromEulerAnglesXYZ(0,toRadians(0),toRadians(0)));
-	
 
-	
 	test = makePart();
 	test->setParent(dataModel->getWorkspace());
 	test->color = Color3(.5F,1,.5F);
@@ -729,6 +727,7 @@ void Demo::onInit()  {
 	test->setSize(Vector3(4,1,2));
 	test->setPosition(Vector3(10,1,0));
 
+	
 	test = makePart();
 	test->setParent(dataModel->getWorkspace());
 	test->color = Color3::gray();
@@ -1007,17 +1006,17 @@ void drawOutline(Vector3 from, Vector3 to, RenderDevice* rd, LightingParameters
 {
 
 	Color3 outline = Color3::cyan();//Color3(0.098F,0.6F,1.0F);
-	float offsetSize = 0.05F;
+	float offsetSize = 0.1F;
 	//X
 	Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, from.y + offsetSize, from.z + offsetSize), Vector3(to.x + offsetSize, from.y - offsetSize, from.z - offsetSize))), rd, outline, Color4::clear()); 
 	Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, to.y + offsetSize, from.z + offsetSize), Vector3(to.x + offsetSize, to.y - offsetSize, from.z - offsetSize))), rd, outline, Color4::clear()); 
 	Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, to.y + offsetSize, to.z + offsetSize), Vector3(to.x + offsetSize, to.y - offsetSize, to.z - offsetSize))), rd, outline, Color4::clear()); 
 	Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, from.y + offsetSize, to.z + offsetSize), Vector3(to.x + offsetSize, from.y - offsetSize, to.z - offsetSize))), rd, outline, Color4::clear()); 
 	//Y
-	Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y - offsetSize + 0.1, from.z + offsetSize), Vector3(from.x - offsetSize, to.y + offsetSize - 0.1, from.z - offsetSize))), rd, outline, Color4::clear()); 
+	Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y - offsetSize + 0.2, from.z + offsetSize), Vector3(from.x - offsetSize, to.y + offsetSize - 0.2, from.z - offsetSize))), rd, outline, Color4::clear()); 
-	Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, from.y - offsetSize + 0.1, from.z + offsetSize), Vector3(to.x - offsetSize, to.y + offsetSize - 0.1, from.z - offsetSize))), rd, outline, Color4::clear()); 
+	Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, from.y - offsetSize + 0.2, from.z + offsetSize), Vector3(to.x - offsetSize, to.y + offsetSize - 0.2, from.z - offsetSize))), rd, outline, Color4::clear()); 
-	Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, from.y - offsetSize + 0.1, to.z + offsetSize), Vector3(to.x - offsetSize, to.y + offsetSize-0.1, to.z - offsetSize))), rd, outline, Color4::clear()); 
+	Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, from.y - offsetSize + 0.2, to.z + offsetSize), Vector3(to.x - offsetSize, to.y + offsetSize-0.2, to.z - offsetSize))), rd, outline, Color4::clear()); 
-	Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y - offsetSize + 0.1, to.z + offsetSize), Vector3(from.x - offsetSize, to.y + offsetSize - 0.1, to.z - offsetSize))), rd, outline, Color4::clear()); 
+	Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y - offsetSize + 0.2, to.z + offsetSize), Vector3(from.x - offsetSize, to.y + offsetSize - 0.2, to.z - offsetSize))), rd, outline, Color4::clear()); 
 
 	//Z
 	Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y + offsetSize, from.z - offsetSize), Vector3(from.x - offsetSize, from.y - offsetSize, to.z + offsetSize))), rd, outline, Color4::clear()); 
@@ -1148,9 +1147,13 @@ void Demo::onGraphics(RenderDevice* rd) {
 
 	renderDevice->setLight(0, GLight::directional(lighting.lightDirection, lighting.lightColor));
 	renderDevice->setAmbientLightColor(lighting.ambient);
-	
+
 	rd->beforePrimitive();
 	dataModel->getWorkspace()->render(rd);
+
+
+	//if (dataModel->children[0]->children.size()>0)
+		//((PhysicalInstance*)dataModel->children[0]->children[0])->debugPrintVertexIDs(rd,fntdominant,-cameraController.getCoordinateFrame().rotation);
 	rd->afterPrimitive();
 
 	if(g_selectedInstances.size() > 0)
@@ -1161,7 +1164,7 @@ void Demo::onGraphics(RenderDevice* rd) {
 			{
 			Vector3 size = part->getSize();
 			Vector3 pos = part->getPosition();
-			drawOutline(Vector3(0+size.x/4, 0+size.y/4, 0+size.z/4) ,Vector3(0-size.x/4,0-size.y/4,0-size.z/4), rd, lighting, Vector3(size.x/2, size.y/2, size.z/2), Vector3(pos.x/2, pos.y/2, pos.z/2), part->getCFrameRenderBased());
+			drawOutline(Vector3(size.x/2, size.y/2, size.z/2) ,Vector3(-size.x/2,-size.y/2,-size.z/2), rd, lighting, Vector3(size.x/2, size.y/2, size.z/2), Vector3(pos.x, pos.y, pos.z), part->getCFrameRenderBased());
 			}
 		}
 	}
@@ -1192,6 +1195,10 @@ void Demo::onGraphics(RenderDevice* rd) {
 		//TODO--Move these to their own instance
 
 		std::stringstream stream;
+		stream << std::fixed << std::setprecision(3) << m_graphicsWatch.FPS();
+		fntdominant->draw2D(rd, "FPS: " + stream.str(), Vector2(120, 25), 10, Color3::fromARGB(0xFFFF00), Color3::black());
+		stream.str("");
+		stream.clear();
 		stream << std::fixed << std::setprecision(1) << dataModel->getWorkspace()->timer;
 		fntdominant->draw2D(rd, "Timer: " + stream.str(), Vector2(rd->getWidth() - 120, 25), 20, Color3::fromARGB(0x81C518), Color3::black());
 		fntdominant->draw2D(rd, "Score: " + Convert(dataModel->getWorkspace()->score), Vector2(rd->getWidth() - 120, 50), 20, Color3::fromARGB(0x81C518), Color3::black());