Code rework. Basically cleaned up a mess of tabs and whitespaces.

converter/converter.hh

@@ -13,9 +13,8 @@ class Converter {
         ~Converter();
         void updateComposition(int idG, int idB, float posX, float posZ); //updates the position of a composition
         std::vector<int> newComposition(int type, float posX, float posZ);//creates a new composition and returns its ID
-	    void deleteComposition(int idG, int idB);
-	    void save();                    //writes the xml to file
-
+        void deleteComposition(int idG, int idB);
+        void save();                    //writes the xml to file
     private:
         void errorCheck(XMLError error);
         std::vector<int> nextID;

entity.hh

@@ -7,7 +7,7 @@ class Entity {
     public:
         Entity(glm::vec3 position, glm::vec3 rotation);
         Entity(glm::vec3 position, glm::mat4 rotation);
-	    Entity();
+        Entity();
         ~Entity();
         void setPosition(glm::vec3 positon);
         void setRotation(glm::vec3 rotation);

graphics.cc

@@ -217,7 +217,6 @@ glm::mat4 Graphics::buildViewMatrix(Level* level) {
     
     return glm::lookAt((level->getCameraCenter()->getPosition() + level->getCamera()->getVector()),
             level->getCameraCenter()->getPosition(), glm::vec3(0.0f, 1.0f, 0.0f));
-            
 }
 
 float Graphics::getFarPlane() {

loader.cc

@@ -116,10 +116,10 @@ void Loader::load(std::string filePath, Level* level, std::string compositionsPa
     errorCheck(terrainElement->FirstChildElement("shininess")->QueryFloatText(&terrainShininess));
     Material terrainMaterial = Material(terrainTexture, terrainAmbientFactor, terrainDiffuseFactor, terrainSpecularFactor, terrainShininess);
     Object* terrainObject = new Object(terrainModel, terrainMaterial,
-	glm::vec3(-0.5*(float)level->getTerrain()->getHeightmapHeight(), 0.0f, -0.5f*(float)level->getTerrain()->getHeightmapWidth()),
+    glm::vec3(-0.5*(float)level->getTerrain()->getHeightmapHeight(), 0.0f, -0.5f*(float)level->getTerrain()->getHeightmapWidth()),
         glm::vec3(0.0f, 0.0f, 0.0f), true);
     level->addObject(terrainObject);
-	level->getPhysics()->addTerrain(level->getTerrain()->getHeightmapWidth(), level->getTerrain()->getHeightmapHeight(), level->getTerrain()->getHeightmap());
+    level->getPhysics()->addTerrain(level->getTerrain()->getHeightmapWidth(), level->getTerrain()->getHeightmapHeight(), level->getTerrain()->getHeightmap());
     
     //load the skydome
     XMLElement* skydomeElement = doc->FirstChildElement("skydome");

main.cc

@@ -142,7 +142,6 @@ int main( int argc, char *argv[] )
     
     double lastUpdate=0.0f;
     
-
     do {
         
         double now = glfwGetTime()- startTimeInSeconds;

material.hh

@@ -10,7 +10,7 @@ class Material{
     public:
         Material(std::string filePath, float ambientFactor,
             float diffuseFactor, float specularFactor, float shininess);
-	    Material();
+        Material();
         ACGL::OpenGL::SharedTexture2D getReference();
         ~Material();
         float getAmbientFactor();

model.hh

@@ -7,8 +7,8 @@
 class Model {
     public:
         Model(std::string filePath, float scale=1.0f);
-	Model(ACGL::OpenGL::SharedVertexArrayObject vao, float scale=1.0f);
-	    Model();
+        Model(ACGL::OpenGL::SharedVertexArrayObject vao, float scale=1.0f);
+        Model();
         ~Model();
         ACGL::OpenGL::SharedVertexArrayObject getReference();
         void setScale(float scale);

physics.cc

@@ -10,11 +10,11 @@ Physics::~Physics() {
 
 void Physics::init(std::string geometryPath) //prepares bullet by creating all initial classes
 {
-	colConfig = new btDefaultCollisionConfiguration();
-	dispatcher = new btCollisionDispatcher(colConfig);
-	broadphase = new btDbvtBroadphase();
-	solver = new btSequentialImpulseConstraintSolver();
-	world = new btDiscreteDynamicsWorld(dispatcher,broadphase,solver,colConfig);
+    colConfig = new btDefaultCollisionConfiguration();
+    dispatcher = new btCollisionDispatcher(colConfig);
+    broadphase = new btDbvtBroadphase();
+    solver = new btSequentialImpulseConstraintSolver();
+    world = new btDiscreteDynamicsWorld(dispatcher,broadphase,solver,colConfig);
     world->setGravity(btVector3(0,-10,-0));
     if (world == NULL) {
         printf("No World after init\n");
@@ -24,23 +24,22 @@ void Physics::init(std::string geometryPath) //prepares bullet by creating all i
 
 void Physics::takeUpdateStep(float timeDiff)
 {
+    counter++;
+    if(counter<1)
+    {
+        world->stepSimulation(timeDiff); //allows the world to be simmulated correctly indipendant of the timedifferences between frames
+        return;
+    }
     
-	counter++;
-	if(counter<1)
-	{
-	    world->stepSimulation(timeDiff);//allows the world to be simmulated correctly indipendant of the timedifferences between frames
-	    return;
-	}
-	            
-	for(unsigned i = 0; i < allPositionConstraints.size();i++) //this handles the spring constraints
-	{
-	    if(allPositionConstraints[i].position != allPositionConstraints[i].body->getCenterOfMassPosition()) //if constraint != position of the body because otherwise dir = 0
-	    {
-	        btVector3 dir = allPositionConstraints[i].position - allPositionConstraints[i].body->getCenterOfMassPosition();
-	        dir = dir*allPositionConstraints[i].strength - allPositionConstraints[i].body->getLinearVelocity();
-	        allPositionConstraints[i].body->applyCentralForce(dir*allPositionConstraints[i].strength); //apply a foce upon the object pushing it towards the constraint position
-	    }	
-	}
+    for(unsigned i = 0; i < allPositionConstraints.size();i++) //this handles the spring constraints
+    {
+        if(allPositionConstraints[i].position != allPositionConstraints[i].body->getCenterOfMassPosition()) //if constraint != position of the body because otherwise dir = 0
+        {
+            btVector3 dir = allPositionConstraints[i].position - allPositionConstraints[i].body->getCenterOfMassPosition();
+            dir = dir*allPositionConstraints[i].strength - allPositionConstraints[i].body->getLinearVelocity();
+            allPositionConstraints[i].body->applyCentralForce(dir*allPositionConstraints[i].strength); //apply a foce upon the object pushing it towards the constraint position
+        }
+    }
     
     
     btVector3 position = cameraBody->getCenterOfMassPosition() - playerBall->getCenterOfMassPosition(); //gets a vector from the player to the camera
@@ -50,32 +49,32 @@ void Physics::takeUpdateStep(float timeDiff)
     
     //prevent the camera from being dragged along on the ground
     if (position.getY() < playerBall->getCenterOfMassPosition().getY() + 1)
-	    position.setY(playerBall->getCenterOfMassPosition().getY() + 1);
+        position.setY(playerBall->getCenterOfMassPosition().getY() + 1);
     
-	btVector3 dir = cameraBody->getCenterOfMassPosition() - position;
-	float str = 50 * dir.length() / cameraBody->getInvMass();
-	cameraBody->applyCentralForce(-dir*str);//scale the force by camera mass
-	counter=0;
-	float speed = cameraBody->getLinearVelocity().length();
-	if(speed>20.0f)
-	{
-	    printf("%f , %f \n", speed, position.length());
-	    position = cameraBody->getLinearVelocity();
-	    position.normalize();
-	    cameraBody->setLinearVelocity(position*20);
-	}
-	world->stepSimulation(timeDiff);
+    btVector3 dir = cameraBody->getCenterOfMassPosition() - position;
+    float str = 50 * dir.length() / cameraBody->getInvMass(); //getInvMass() returns the inverted mass
+    cameraBody->applyCentralForce(-dir*str); //scale the force by camera mass
+    counter=0;
+    float speed = cameraBody->getLinearVelocity().length();
+    if(speed>20.0f)
+    {
+        printf("%f , %f \n", speed, position.length());
+        position = cameraBody->getLinearVelocity();
+        position.normalize();
+        cameraBody->setLinearVelocity(position*20);
+    }
+    world->stepSimulation(timeDiff);
 }
-//
+
 void Physics::removePositionConstraint(int bodyIndice) //remover function for deleting all pos constraints on one body
 {
-	for(unsigned i = 0; i < allPositionConstraints.size(); i++)
-	{
-	    if(allPositionConstraints[i].body == bodies[bodyIndice])
-	    {
-	        allPositionConstraints.erase(allPositionConstraints.begin()+i);
-	    }
-	}
+    for(unsigned i = 0; i < allPositionConstraints.size(); i++)
+    {
+        if(allPositionConstraints[i].body == bodies[bodyIndice])
+        {
+            allPositionConstraints.erase(allPositionConstraints.begin()+i);
+        }
+    }
 }
 
 void Physics::addPositionConstraint(int bodyIndice, float strength, glm::vec3 position) //function for adding position constraints
@@ -90,45 +89,45 @@ void Physics::addPositionConstraint(int bodyIndice, float strength, glm::vec3 po
 //players and objects
 void Physics::addPlayer(float friction, float rad, Entity entity, float mass, float dampningL, float dampningA, unsigned indice)
 {
-	if(bodies.size() == indice)
-		throw std::invalid_argument( "Bodies out of Sync" ); //these error are to ensure that level can always communicate with physics without having to worry about synching errors
+    if(bodies.size() == indice)
+        throw std::invalid_argument( "Bodies out of Sync" ); //these error are to ensure that level can always communicate with physics without having to worry about synching errors
     
-	btSphereShape* sphere = new btSphereShape(rad); //the first thing we need for a rigid body is the shape
-	btVector3 inertia(0,0,0);
-	if(mass != 0.0)
-	{
-		sphere->calculateLocalInertia((btScalar)mass,inertia); //from this shape we can then calculate the innertia, as long as the mass != 0 (otherwise inertia = 0)
-	}
+    btSphereShape* sphere = new btSphereShape(rad); //the first thing we need for a rigid body is the shape
+    btVector3 inertia(0,0,0);
+    if(mass != 0.0)
+    {
+        sphere->calculateLocalInertia((btScalar)mass,inertia); //from this shape we can then calculate the innertia, as long as the mass != 0 (otherwise inertia = 0)
+    }
     
-	glm::quat glmQuat = glm::quat_cast(entity.getRotation());
+    glm::quat glmQuat = glm::quat_cast(entity.getRotation());
     
-	btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z))); //next we define the motionstate, wich describes the innital position and rotation
+    btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z))); //next we define the motionstate, wich describes the innital position and rotation
     
-	btRigidBody::btRigidBodyConstructionInfo info(mass,motion,sphere,inertia); //next we process all data for the rigid body into info
+    btRigidBody::btRigidBodyConstructionInfo info(mass,motion,sphere,inertia); //next we process all data for the rigid body into info
     
     info.m_friction = friction*2; //here we modify the friction and restitution (bounciness) of the object
     info.m_restitution = 0.1f;
     
-	playerBall = new btRigidBody(info); //finally we create the rigid body using the info
+    playerBall = new btRigidBody(info); //finally we create the rigid body using the info
     
     playerBall->setDamping(dampningL, dampningA); //here we can set the dampning (how much of the motion is lost)
     
-	world->addRigidBody(playerBall,COL_OBJECTS,COL_OBJECTS|COL_OBJECTS_NO_TERRAIN|COL_TERRAIN); //then we add the rigid body to the wiorld, allowing it to be simulated
+    world->addRigidBody(playerBall,COL_OBJECTS,COL_OBJECTS|COL_OBJECTS_NO_TERRAIN|COL_TERRAIN); //then we add the rigid body to the wiorld, allowing it to be simulated
     
-	bodies.push_back(playerBall); //next we add the rigid body to our own list (for cleanup and for synchronitaation with level)
+    bodies.push_back(playerBall); //next we add the rigid body to our own list (for cleanup and for synchronitaation with level)
     //note, while we can always access playerBall through its global name, we add it to this array for synchronization purposes
     
     playerBall->setSleepingThresholds(0,0); //in a final step we make sure that the body never is removed from the active rigid bodies
     
-	if(bodies.size() != indice)
-		throw std::invalid_argument( "Bodies out of Sync" );  //one last check to make sure level and physics are in synch
+    if(bodies.size() != indice)
+        throw std::invalid_argument( "Bodies out of Sync" ); //one last check to make sure level and physics are in synch
     
     addCamera(); //now that the player exists add a camera for the player
 }
 
 void Physics::addTerrain(int width, int length, float** heightData) //The terrain adding function
 {
-	float* heightfield = new float[width * length];//bullet only accepts data in a one dimensional array, so parse data into appropriate format
+    float* heightfield = new float[width * length]; //bullet only accepts data in a one dimensional array, so parse data into appropriate format
     int highest = -999999, j = 0, i = 0;
     for (i = 0; i < width; i++)
     {
@@ -136,31 +135,31 @@ void Physics::addTerrain(int width, int length, float** heightData) //The terrai
             heightfield[i*length+j] =  heightData[j][i]; //reverse order because they are loaded backwards
             
             if (heightData[j][i] > highest)
-                    highest = heightData[j][i]; //bullet needs to know the highest point of the heightmap
+                highest = heightData[j][i]; //bullet needs to know the highest point of the heightmap
         }
     }
     highest++;
     
     btHeightfieldTerrainShape* terrainShape = new btHeightfieldTerrainShape(length,width,heightfield,highest,1,true,false);
-	btRigidBody::btRigidBodyConstructionInfo info(0,new btDefaultMotionState(),terrainShape,btVector3(0,0,0)); //next we process all data for the rigid body into info
-	info.m_friction = 1;
+    btRigidBody::btRigidBodyConstructionInfo info(0,new btDefaultMotionState(),terrainShape,btVector3(0,0,0)); //next we process all data for the rigid body into info
+    info.m_friction = 1;
     info.m_restitution = 0;
-	btRigidBody* tBody = new btRigidBody(info);
+    btRigidBody* tBody = new btRigidBody(info);
     
-	tBody->getWorldTransform().setOrigin(btVector3(0,((float)highest)/2,0)); //we have to move the origin of our rigid body down, because bullet sets the origin (0,0,0) at (width/2, height/2, length/2) in the map the x and z are correct in our level, but y needs to be addapted
+    tBody->getWorldTransform().setOrigin(btVector3(0,((float)highest)/2,0)); //we have to move the origin of our rigid body down, because bullet sets the origin (0,0,0) at (width/2, height/2, length/2) in the map the x and z are correct in our level, but y needs to be addapted
     
-	terrainBody = tBody;
+    terrainBody = tBody;
     if (world == NULL) {
         printf("No World while adding terrain.\n");
     }
-	world->addRigidBody(terrainBody, COL_TERRAIN, COL_TERRAIN | COL_OBJECTS); //COL_XXXX are collision masks, allowing us to ignore collisions between certain object groups (required for buttons)
+    world->addRigidBody(terrainBody, COL_TERRAIN, COL_TERRAIN | COL_OBJECTS); //COL_XXXX are collision masks, allowing us to ignore collisions between certain object groups (required for buttons)
 }
 
 void Physics::addTriangleMeshBody(Entity entity, std::string path, float mass, float dampningL, float dampningA,unsigned indice,float scaling, bool rotate)
 {
     
-	if(bodies.size() == indice)
-		throw std::invalid_argument( "Bodies out of Sync" );  
+    if(bodies.size() == indice)
+        throw std::invalid_argument( "Bodies out of Sync" );
     
     std::vector< unsigned int > vertexIndices; //temp lists for data sets
     std::vector< btVector3 > temp_vertices;
@@ -171,10 +170,10 @@ void Physics::addTriangleMeshBody(Entity entity, std::string path, float mass, f
     }
     while( 1 ){
         char lineHeader[128];
-        // read the first word of the line
+        //read the first word of the line
         int res = fscanf(file, "%s", lineHeader);
         if (res == EOF)
-            break; // while not at end do loop
+            break; //while not at end do loop
         if ( strcmp( lineHeader, "v" ) == 0 ){ //if a vertex
             glm::vec3 vertex;
             fscanf(file, "%f %f %f\n", &vertex.x, &vertex.y, &vertex.z );
@@ -183,7 +182,7 @@ void Physics::addTriangleMeshBody(Entity entity, std::string path, float mass, f
         else if ( strcmp( lineHeader, "f" ) == 0 ){ //if face (index for 3 vertexes for a triangle)
             std::string vertex1, vertex2, vertex3;
             unsigned int vertexIndex[3], uvIndex[3], normalIndex[3];
-            int matches = fscanf(file, "%d/%d/%d %d/%d/%d %d/%d/%d\n", &vertexIndex[0], &uvIndex[0], &normalIndex[0], &vertexIndex[1], &uvIndex[1], &normalIndex[1], &vertexIndex[2], &uvIndex[2], &normalIndex[2] );
+            int matches = fscanf(file, "%d/%d/%d %d/%d/%d %d/%d/%d\n", &vertexIndex[0], &uvIndex[0], &normalIndex[0], &vertexIndex[1], &uvIndex[1], &normalIndex[1], &vertexIndex[2], &uvIndex[2], &normalIndex[2]);
             vertexIndices.push_back(vertexIndex[0]);
             vertexIndices.push_back(vertexIndex[1]);
             vertexIndices.push_back(vertexIndex[2]); //save 3 indexes in array
@@ -194,191 +193,187 @@ void Physics::addTriangleMeshBody(Entity entity, std::string path, float mass, f
     
     for(unsigned i = 2; i < vertexIndices.size();i+=3)
     {
-        triMesh->addTriangle(temp_vertices[vertexIndices[i]],temp_vertices[vertexIndices[i-1]],temp_vertices[vertexIndices[i-2]]); // for every face (3 elements in vertexIndices) create triangle use the indices to find correct vertexes to make the triangle        
+        triMesh->addTriangle(temp_vertices[vertexIndices[i]],temp_vertices[vertexIndices[i-1]],temp_vertices[vertexIndices[i-2]]); //for every face (3 elements in vertexIndices) create triangle use the indices to find correct vertexes to make the triangle
     }
     
     btBvhTriangleMeshShape* shape = new btBvhTriangleMeshShape(triMesh,true);
     shape->setLocalScaling(btVector3(scaling,scaling,scaling)); //we need to add a scaling here because the objects seem to have diffrent sizes when loaded (no clue why, see composition.xml for exact scaling factors)
     
     
-	glm::quat glmQuat = glm::quat_cast(entity.getRotation());
+    glm::quat glmQuat = glm::quat_cast(entity.getRotation());
     
-	btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z)));
+    btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z)));
 	
     btVector3 inertia(0,0,0);
-	if(mass != 0.0 && rotate) //&& rotate lets certain objects get inertia (0,0,0) (not rotateable) 
-	{
-		shape->calculateLocalInertia((btScalar)mass,inertia);
-	}
+    if(mass != 0.0 && rotate) //&& rotate lets certain objects get inertia (0,0,0) (not rotateable)
+    {
+        shape->calculateLocalInertia((btScalar)mass,inertia);
+    }
     
-	btRigidBody::btRigidBodyConstructionInfo info(mass,motion,shape,inertia);
+    btRigidBody::btRigidBodyConstructionInfo info(mass,motion,shape,inertia);
     
-	btRigidBody* body = new btRigidBody(info);	
+    btRigidBody* body = new btRigidBody(info);
     
-	body->setDamping(dampningL,dampningA);    
+    body->setDamping(dampningL,dampningA);
     
-	bodies.push_back(body);
+    bodies.push_back(body);
     
-	world->addRigidBody(body,COL_OBJECTS, objectsPhysicsCollision);
+    world->addRigidBody(body,COL_OBJECTS, objectsPhysicsCollision);
     
     
-	if(bodies.size() != indice)
-		throw std::invalid_argument( "Bodies out of Sync" ); 
+    if(bodies.size() != indice)
+        throw std::invalid_argument( "Bodies out of Sync" );
 }
 
 void Physics::addButton(float width, float height, float length, Entity entity, float mass, float dampningL, float dampningA, unsigned indice,bool rotate)
 {
     
-	if(bodies.size() == indice)
-		throw std::invalid_argument( "Bodies out of Sync" );  
+    if(bodies.size() == indice)
+        throw std::invalid_argument( "Bodies out of Sync" );
     
-		btBoxShape* box = new btBoxShape(btVector3(width/2,height/2,length/2));	
+    btBoxShape* box = new btBoxShape(btVector3(width/2,height/2,length/2));
     
-	glm::quat glmQuat = glm::quat_cast(entity.getRotation());
+    glm::quat glmQuat = glm::quat_cast(entity.getRotation());
     
-	btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z))); 	
+    btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z)));
     
     btVector3 inertia(0,0,0);
-	if(mass != 0.0 && rotate) //&& rotate lets certain objects get inertia (0,0,0) (not rotateable) 
-	{
-		box->calculateLocalInertia((btScalar)mass,inertia);
-	}
-	btRigidBody::btRigidBodyConstructionInfo info(mass,motion,box,inertia);
+    if(mass != 0.0 && rotate) //&& rotate lets certain objects get inertia (0,0,0) (not rotateable)
+    {
+        box->calculateLocalInertia((btScalar)mass,inertia);
+    }
+    btRigidBody::btRigidBodyConstructionInfo info(mass,motion,box,inertia);
     
-	btRigidBody* body = new btRigidBody(info);	
+    btRigidBody* body = new btRigidBody(info);
     
     body->setDamping(dampningL, dampningA);
     
-	world->addRigidBody(body,COL_OBJECTS_NO_TERRAIN, specialPhysicsCollision); //the specialPhysicsCollision allows these objects to not collide with the terrain
+    world->addRigidBody(body,COL_OBJECTS_NO_TERRAIN, specialPhysicsCollision); //the specialPhysicsCollision allows these objects to not collide with the terrain
     
-	bodies.push_back(body);
+    bodies.push_back(body);
     
-	if(bodies.size() != indice)
-		throw std::invalid_argument( "Bodies out of Sync" ); 	
+    if(bodies.size() != indice)
+        throw std::invalid_argument( "Bodies out of Sync" );
 }
 
 void Physics::addBox(float width, float height, float length, Entity entity, float mass, float dampningL, float dampningA, unsigned indice,bool rotate)
 {
     //similar to other constructors
-	if(bodies.size() == indice)
-		throw std::invalid_argument( "Bodies out of Sync" );  
+    if(bodies.size() == indice)
+        throw std::invalid_argument( "Bodies out of Sync" );
     
-	glm::quat glmQuat = glm::quat_cast(entity.getRotation());
-	btBoxShape* box = new btBoxShape(btVector3(width/2,height/2,length/2));	
-	btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z)));
+    glm::quat glmQuat = glm::quat_cast(entity.getRotation());
+    btBoxShape* box = new btBoxShape(btVector3(width/2,height/2,length/2));
+    btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z)));
     
-	btVector3 inertia(0,0,0);	
-	if(mass != 0.0)
-	{
-		box->calculateLocalInertia((btScalar)mass,inertia);
-	}
+    btVector3 inertia(0,0,0);
+    if(mass != 0.0)
+    {
+        box->calculateLocalInertia((btScalar)mass,inertia);
+    }
     
+    btRigidBody::btRigidBodyConstructionInfo info(mass,motion,box,inertia);
     
-	btRigidBody::btRigidBodyConstructionInfo info(mass,motion,box,inertia);
-	
-	btRigidBody* body = new btRigidBody(info);	
+    btRigidBody* body = new btRigidBody(info);
     
     body->setDamping(dampningL, dampningA);
     
-	world->addRigidBody(body,COL_OBJECTS, objectsPhysicsCollision);
+    world->addRigidBody(body,COL_OBJECTS, objectsPhysicsCollision);
     
-	bodies.push_back(body);
+    bodies.push_back(body);
     
-	if(bodies.size() != indice)
-		throw std::invalid_argument( "Bodies out of Sync" ); 
+    if(bodies.size() != indice)
+        throw std::invalid_argument( "Bodies out of Sync" );
 }
 
 void Physics::addSphere(float rad, Entity entity, float mass, float dampningL, float dampningA, unsigned indice,bool rotate)
 {
-	if(bodies.size() == indice) //(user's initial) height, not the actual height. More...
-		throw std::invalid_argument( "Bodies out of Sync" ); 
+    if(bodies.size() == indice) //(user's initial) height, not the actual height. More...
+        throw std::invalid_argument( "Bodies out of Sync" );
     
-	btSphereShape* sphere = new btSphereShape(rad);
-	btVector3 inertia(0,0,0);
-	if(mass != 0.0)
-	{
-		sphere->calculateLocalInertia((btScalar)mass,inertia);
-	}
+    btSphereShape* sphere = new btSphereShape(rad);
+    btVector3 inertia(0,0,0);
+    if(mass != 0.0)
+    {
+        sphere->calculateLocalInertia((btScalar)mass,inertia);
+    }
     
-	glm::quat glmQuat = glm::quat_cast(entity.getRotation());
+    glm::quat glmQuat = glm::quat_cast(entity.getRotation());
     
-	btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z)));
+    btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(glmQuat.x,glmQuat.y,glmQuat.z,glmQuat.w),btVector3(entity.getPosition().x,entity.getPosition().y,entity.getPosition().z)));
     
-	btRigidBody::btRigidBodyConstructionInfo info(mass,motion,sphere,inertia);
+    btRigidBody::btRigidBodyConstructionInfo info(mass,motion,sphere,inertia);
     
-
-	btRigidBody* body = new btRigidBody(info);
+    btRigidBody* body = new btRigidBody(info);
     
     body->setDamping(dampningL, dampningA);
     
-	world->addRigidBody(body,COL_OBJECTS, objectsPhysicsCollision);
+    world->addRigidBody(body,COL_OBJECTS, objectsPhysicsCollision);
     
-	bodies.push_back(body);
+    bodies.push_back(body);
     
     body->setSleepingThresholds(0,0);
     
-	if(bodies.size() != indice)
-		throw std::invalid_argument( "Bodies out of Sync" ); 
-
+    if(bodies.size() != indice)
+        throw std::invalid_argument( "Bodies out of Sync" );
 }
 
 void Physics::addCamera() //Camera Creator automatically called when player is created
 {
-    btSphereShape* sphere = new btSphereShape(0.5f);//we use this to make a more interesting camera, that does not interpenetrate with the terrain/objects
+    btSphereShape* sphere = new btSphereShape(0.5f); //we use this to make a more interesting camera, that does not interpenetrate with the terrain/objects
     
-	btVector3 inertia(0,0,0); //rotation handled elsewhere (as it always has to look at the player)
+    btVector3 inertia(0,0,0); //rotation handled elsewhere (as it always has to look at the player)
     
-	btVector3 direction(1,1,1);
-	direction.normalize();
-	direction*=5; //create a offset of lenth 5 so we have a stable camera at the beginning
-	btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1),playerBall->getCenterOfMassPosition()+direction));
+    btVector3 direction(1,1,1);
+    direction.normalize();
+    direction*=5; //create a offset of lenth 5 so we have a stable camera at the beginning
+    btDefaultMotionState* motion = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1),playerBall->getCenterOfMassPosition()+direction));
     
-	btRigidBody::btRigidBodyConstructionInfo info(0.001,motion,sphere,inertia);
+    btRigidBody::btRigidBodyConstructionInfo info(0.001,motion,sphere,inertia);
     
-	cameraBody = new btRigidBody(info);
+    cameraBody = new btRigidBody(info);
     
     cameraBody->setDamping(0.9,0.5); //this damping factor leaves a relativly smoothe system
     
-	world->addRigidBody(cameraBody,COL_OBJECTS, objectsPhysicsCollision);
+    world->addRigidBody(cameraBody,COL_OBJECTS, objectsPhysicsCollision);
     
-	cameraBody->setGravity(btVector3(0,0,0));	
+    cameraBody->setGravity(btVector3(0,0,0));
     
     cameraBody->setSleepingThresholds(0,0); //very important, otherwise camera may go to sleep, aka not move until next collision
-    
 }
 
 
 //update functions
 glm::vec3 Physics::getCameraPosition()
 {
-	btVector3 origin = cameraBody->getCenterOfMassPosition();
-	glm::vec3 save(origin.getX(),origin.getY(),origin.getZ());
-	return save;
+    btVector3 origin = cameraBody->getCenterOfMassPosition();
+    glm::vec3 save(origin.getX(),origin.getY(),origin.getZ());
+    return save;
 }
 
-glm::vec3 Physics::getCameraToPlayer()//returns a glm::vec3 the goes from the camera to the player
+glm::vec3 Physics::getCameraToPlayer() //returns a glm::vec3 the goes from the camera to the player
 {
-	btVector3 origin = playerBall->getCenterOfMassPosition() - cameraBody->getCenterOfMassPosition();
-	glm::vec3 save(origin.getX(),origin.getY(),origin.getZ());
-	return save;
+    btVector3 origin = playerBall->getCenterOfMassPosition() - cameraBody->getCenterOfMassPosition();
+    glm::vec3 save(origin.getX(),origin.getY(),origin.getZ());
+    return save;
 }
 
 glm::vec3 Physics::getPos(int i) //this and the next function are used to synchronize the graphics data and the physics data
 {
-	btVector3 origin = bodies[i]->getCenterOfMassPosition();
-	glm::vec3 save(origin.getX(),origin.getY(),origin.getZ());
-	return save;
+    btVector3 origin = bodies[i]->getCenterOfMassPosition();
+    glm::vec3 save(origin.getX(),origin.getY(),origin.getZ());
+    return save;
 }
 
 glm::mat4 Physics::getRotation(int i)
 {
-	btQuaternion quat = bodies[i]->getOrientation();
+    btQuaternion quat = bodies[i]->getOrientation();
     
-	glm::mat4 matrix = glm::rotate(
-	    quat.getAngle(),
-	    glm::vec3(quat.getAxis().getX(), quat.getAxis().getY(), quat.getAxis().getZ())
-	); //somewhat clunky, but basicly creates a rotation matrix out of the angle of the body, and its axis (from the quaterion in bullet)
-	return matrix;
+    glm::mat4 matrix = glm::rotate(
+        quat.getAngle(),
+        glm::vec3(quat.getAxis().getX(), quat.getAxis().getY(), quat.getAxis().getZ())
+    ); //somewhat clunky, but basicly creates a rotation matrix out of the angle of the body, and its axis (from the quaterion in bullet)
+    return matrix;
 }
 
 //these are used to apply a force to the camera body according to the movement of the mouse
@@ -388,13 +383,12 @@ void Physics::updateCameraPos(glm::vec2 mouseMovement, float strength)
     btVector3 change =  playerBall->getCenterOfMassPosition()-cameraBody->getCenterOfMassPosition();
     change.setY(0);
     change.normalize(); //normalize so that the distance between camera and body does not matter
-    change *= (mouseMovement.y);//we start with left/right movement because this needs to be calculated via a crossproduct, and the up down value would alter that
+    change *= (mouseMovement.y); //we start with left/right movement because this needs to be calculated via a crossproduct, and the up down value would alter that
     change = btCross(btVector3(0,1,0),change);
-    change.setY(mouseMovement.x/5);//scaleing because otherwise oup/down much stronger then left right
+    change.setY(mouseMovement.x/5); //scaleing because otherwise oup/down much stronger then left right
     change *= strength / cameraBody->getInvMass();
     
     cameraBody->applyCentralForce(change);
-        
 }
 
 //use the crossproduct to correctly apply a torque to the palyer if function called
@@ -441,47 +435,47 @@ void Physics::rollRight(glm::vec3 camPos,float strength)
 
 void Physics::addStaticGroundPlane()
 {
-	btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0, 1, 0), 0);
-	btDefaultMotionState* groundMotionState = new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, 0, 0)));
-	btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0, groundMotionState, groundShape, btVector3(0, 0, 0));
-        staticGroundBody = new btRigidBody(groundRigidBodyCI);
+    btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0, 1, 0), 0);
+    btDefaultMotionState* groundMotionState = new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, 0, 0)));
+    btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0, groundMotionState, groundShape, btVector3(0, 0, 0));
+    staticGroundBody = new btRigidBody(groundRigidBodyCI);
     
-        world->addRigidBody(staticGroundBody);
-}//not needed anymoer, but still good for debugging
+    world->addRigidBody(staticGroundBody);
+} //not needed anymoer, but still good for debugging
 
 
-void Physics::kill()//delete dynamically allocated memory
+void Physics::kill() //delete dynamically allocated memory
 {
     if (world == NULL) {
         return;
     }
-	//btDynamimcWorld*
-	for(unsigned i = 0; i < bodies.size();i++)
-	{
-		world->removeCollisionObject(bodies[i]); //go through the list of bodies in world for each body b, then remove exactly this body b from world
-		btMotionState* motionState = bodies[i]->getMotionState();
-		btCollisionShape* shape = bodies[i]->getCollisionShape();
-		delete shape;
-		delete motionState;
-		delete bodies[i];
-	}
-	btMotionState* motionState = terrainBody->getMotionState();//delete the rest that are not in the array bodies
-	btCollisionShape* shape = terrainBody->getCollisionShape();
-	delete shape;
-	delete motionState;
-	delete terrainBody;
+    //btDynamimcWorld*
+    for(unsigned i = 0; i < bodies.size();i++)
+    {
+        world->removeCollisionObject(bodies[i]); //go through the list of bodies in world for each body b, then remove exactly this body b from world
+        btMotionState* motionState = bodies[i]->getMotionState();
+        btCollisionShape* shape = bodies[i]->getCollisionShape();
+        delete shape;
+        delete motionState;
+    delete bodies[i];
+    }
+    btMotionState* motionState = terrainBody->getMotionState(); //delete the rest that are not in the array bodies
+    btCollisionShape* shape = terrainBody->getCollisionShape();
+    delete shape;
+    delete motionState;
+    delete terrainBody;
     
-	motionState = cameraBody->getMotionState();
-	shape = cameraBody->getCollisionShape();
-	delete shape;
-	delete motionState;
-	delete cameraBody; //note: palyerBall is also in the array bodies so we do not need to clean it up	
+    motionState = cameraBody->getMotionState();
+    shape = cameraBody->getCollisionShape();
+    delete shape;
+    delete motionState;
+    delete cameraBody; //note: palyerBall is also in the array bodies so we do not need to clean it up
     
-	delete dispatcher; //clean up rest
-	delete colConfig;
-	delete solver;
-	delete broadphase;
-	delete world;
+    delete dispatcher; //clean up rest
+    delete colConfig;
+    delete solver;
+    delete broadphase;
+    delete world;
     
-	//feel like a good little programmer because everything is clean
+    //feel like a good little programmer because everything is clean
 }

physics.hh

@@ -81,7 +81,7 @@ class Physics {
 	void addCamera(); //Do NOT impliment before Player has been created;
     
 	btDynamicsWorld* world = NULL; //contains physical attributes of the world.
-	btDispatcher* dispatcher; //
+	btDispatcher* dispatcher;
 	btCollisionConfiguration* colConfig; //defines the type of collision detection.
 	btBroadphaseInterface* broadphase; //defines how objects are culled from collision detection.
 	btConstraintSolver* solver; //solver for forces and impulses.
@@ -103,7 +103,7 @@ enum collisionTypes{
 class btDistanceConstraint : public btPoint2PointConstraint
 {
 protected:
-   btScalar   m_distance;
+   btScalar m_distance;
 public:
    btDistanceConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB, btScalar dist)
       : btPoint2PointConstraint(rbA, rbB, pivotInA, pivotInB)

terrain.cc

@@ -18,16 +18,15 @@ void Terrain::load() {
     if (error) {
         std::cout << "Decoder error " << error << " from Terrain::load: " << lodepng_error_text(error) << std::endl;
     }
-    this->heightmap = new float*[this->heightmapHeight];					//initialize the heightmap
-    for(unsigned int rowNum = 0; rowNum < this->heightmapHeight; rowNum++){				//read in the heightmap
-	    this->heightmap[rowNum] = new float[this->heightmapWidth];
+    this->heightmap = new float*[this->heightmapHeight]; //initialize the heightmap
+    for(unsigned int rowNum = 0; rowNum < this->heightmapHeight; rowNum++){ //read in the heightmap
+        this->heightmap[rowNum] = new float[this->heightmapWidth];
         for(unsigned int columnNum = 0; columnNum < this->heightmapWidth; columnNum++){
-	        this->heightmap[rowNum][columnNum] = (float)(image[(rowNum*heightmapWidth+columnNum)*4]) / 6;  //<--heightmap is scaled here
+            this->heightmap[rowNum][columnNum] = (float)(image[(rowNum*heightmapWidth+columnNum)*4]) / 6; //<--heightmap is scaled here
         }
     }
     this->makeTriangleMesh();
-    heightmapChanged = false;		//no need to make a TriangleMesh again before rendering
-    
+    heightmapChanged = false; //no need to make a TriangleMesh again before rendering
 }
 
 void Terrain::makeTriangleMesh(){
@@ -38,18 +37,18 @@ void Terrain::makeTriangleMesh(){
     ab->defineAttribute("aTexCoord", GL_FLOAT, 2);
     ab->defineAttribute("aNormal", GL_FLOAT, 3);
     
-    unsigned int rowNum=0, columnNum=0, dataCount=0, floatsPerVertex=8;				//initializing:
+    unsigned int rowNum=0, columnNum=0, dataCount=0, floatsPerVertex=8; //initializing:
     bool movingRight = true, isUp = true;
     int numVertices = (this->heightmapHeight - 1) * (this->heightmapWidth * 2 + 1) + 1;
     float* abData = new float[numVertices * floatsPerVertex];
     
-    while(rowNum < this->heightmapHeight){							//traversing the Triangle Strip!
-	    set_abData(abData, dataCount, rowNum, columnNum);
-	    dataCount += floatsPerVertex;
-	    if (isUp){
-	        rowNum = rowNum + 1;
-	        isUp = false;
-	    }
+    while(rowNum < this->heightmapHeight){ //traversing the Triangle Strip!
+        set_abData(abData, dataCount, rowNum, columnNum);
+        dataCount += floatsPerVertex;
+        if (isUp){
+            rowNum = rowNum + 1;
+            isUp = false;
+        }
         else if (movingRight) {
             if (columnNum == this->heightmapWidth - 1) {
                 set_abData(abData, dataCount, rowNum, columnNum);
@@ -103,9 +102,9 @@ void Terrain::set_abData(float* abData, unsigned int dataCount, unsigned int row
     
     //setNormal
     if (rowNum==0 || rowNum==(this->heightmapHeight-1) || columnNum==0 || columnNum==(this->heightmapWidth-1)){
-    	abData[dataCount+5] = 0.0;
-    	abData[dataCount+6] = 1.0;
-    	abData[dataCount+7] = 0.0;
+        abData[dataCount+5] = 0.0;
+        abData[dataCount+6] = 1.0;
+        abData[dataCount+7] = 0.0;
     }
     else {
         glm::vec3 sumNormals = glm::vec3(0.0f, 0.0f, 0.0f);

terrain.hh

@@ -21,7 +21,7 @@ class Terrain {
         Material material;
         std::string heightmapFilePath;
         unsigned int heightmapHeight, heightmapWidth;
-        float** heightmap;				//can be accessed like 'float[][]'
+        float** heightmap; //can be accessed like 'float[][]'
         bool heightmapChanged;
         ACGL::OpenGL::SharedVertexArrayObject triangleMesh;
         void makeTriangleMesh();

trigger.hh

@@ -15,7 +15,7 @@ class Level;
 class Trigger {
     public:
         Trigger(glm::vec3 position, float distance, bool isBigger, Object* object, std::string luaScript, lua_State* L, int objectToChange, std::string scriptPath);
-	    Trigger();
+        Trigger();
         ~Trigger();
         void triggerUpdate();
         bool deleteNotification(int deletedObjectIndex);