Changed tabs to spaces.

gameplay/src/AudioController.cpp

@@ -38,9 +38,9 @@ void AudioController::initialize()
         return;  
     }
         
-	_alcContext = alcCreateContext(_alcDevice, NULL);
+    _alcContext = alcCreateContext(_alcDevice, NULL);
     ALCenum alcErr = alcGetError(_alcDevice);
-	if (!_alcContext || alcErr != ALC_NO_ERROR)
+    if (!_alcContext || alcErr != ALC_NO_ERROR)
     {
         alcCloseDevice (_alcDevice);
         LOG_ERROR_VARG("AudioController::initialize() error. Unable to create OpenAL context. Error: %d\n", alcErr);

gameplay/src/AudioSource.cpp

@@ -466,7 +466,7 @@ void AudioSource::transformChanged(Transform* transform, long cookie)
 #ifndef __ANDROID__
     if (_node)
     {
-    	Vector3 translation = _node->getTranslationWorld();
+        Vector3 translation = _node->getTranslationWorld();
         alSourcefv(_alSource, AL_POSITION, (const ALfloat*)&translation.x);
     }
 #else

gameplay/src/BoundingBox.cpp

@@ -57,9 +57,9 @@ void BoundingBox::getCorners(Vector3* dst) const
 
 Vector3 BoundingBox::getCenter() const
 {
-	Vector3 center;
-	getCenter(&center);
-	return center;
+    Vector3 center;
+    getCenter(&center);
+    return center;
 }
 
 void BoundingBox::getCenter(Vector3* dst) const

gameplay/src/BoundingBox.h

@@ -53,7 +53,7 @@ public:
      */
     static const BoundingBox& empty();
 
-	/**
+    /**
      * Gets the center point of the bounding box.
      *
      * This method computes the center point of the box from its min and max.

gameplay/src/FileSystem.cpp

@@ -117,9 +117,9 @@ bool FileSystem::listFiles(const char* dirPath, std::vector<std::string>& files)
 #else
     std::string path(FileSystem::getResourcePath());
     if (dirPath && strlen(dirPath) > 0)
-	{
-		path.append(dirPath);
-	}
+    {
+        path.append(dirPath);
+    }
     path.append("/.");
     struct dirent* dp;
     DIR* dir = opendir(path.c_str());
@@ -127,23 +127,23 @@ bool FileSystem::listFiles(const char* dirPath, std::vector<std::string>& files)
     {
         return false;
     }
-	while ((dp = readdir(dir)) != NULL)
-	{
-		std::string filepath(path);
-		filepath.append("/");
-		filepath.append(dp->d_name);
-
-		struct stat buf;
-		if (!stat(filepath.c_str(), &buf))
-		{
+    while ((dp = readdir(dir)) != NULL)
+    {
+        std::string filepath(path);
+        filepath.append("/");
+        filepath.append(dp->d_name);
+
+        struct stat buf;
+        if (!stat(filepath.c_str(), &buf))
+        {
             // Add to the list if this is not a directory
-			if (!S_ISDIR(buf.st_mode))
-			{
-				files.push_back(dp->d_name);
-			}
-		}
-	}
-	closedir(dir);
+            if (!S_ISDIR(buf.st_mode))
+            {
+                files.push_back(dp->d_name);
+            }
+        }
+    }
+    closedir(dir);
     return true;
 #endif
 }

gameplay/src/Font.h

@@ -150,7 +150,7 @@ public:
      * @param clip A region to clip text within after applying justification to the viewport area.
      */
     void drawText(const char* text, const Rectangle& area, const Vector4& color, unsigned int size = 0, 
-				  Justify justify = ALIGN_TOP_LEFT, bool wrap = true, bool rightToLeft = false, const Rectangle* clip = NULL);
+                  Justify justify = ALIGN_TOP_LEFT, bool wrap = true, bool rightToLeft = false, const Rectangle* clip = NULL);
 
     /**
      * Measures a string's width and height without alignment, wrapping or clipping.
@@ -237,7 +237,7 @@ private:
     unsigned int _glyphCount;
     Texture* _texture;
     SpriteBatch* _batch;
-	Rectangle _viewport;
+    Rectangle _viewport;
 };
 
 }

gameplay/src/Form.cpp

@@ -168,18 +168,18 @@ namespace gameplay
             {
                 _frameBuffer->bind();
 
-				Game* game = Game::getInstance();
-				Rectangle prevViewport = game->getViewport();
+                Game* game = Game::getInstance();
+                Rectangle prevViewport = game->getViewport();
                 
-				game->setViewport(Rectangle(_position.x, _position.y, _size.x, _size.y));
+                game->setViewport(Rectangle(_position.x, _position.y, _size.x, _size.y));
 
                 draw(_theme->getSpriteBatch(), _clip);
 
                 // Rebind the default framebuffer and game viewport.
                 FrameBuffer::bindDefault();
 
-				// restore the previous game viewport
-				game->setViewport(prevViewport);
+                // restore the previous game viewport
+                game->setViewport(prevViewport);
             }
 
             _quad->draw();
@@ -299,7 +299,7 @@ namespace gameplay
 
                         // Unproject point into world space.
                         Ray ray;
-						camera->pickRay(Game::getInstance()->getViewport(), x, y, &ray);
+                        camera->pickRay(Game::getInstance()->getViewport(), x, y, &ray);
 
                         // Find the quad's plane.
                         // We know its normal is the quad's forward vector.

gameplay/src/Form.h

@@ -107,7 +107,7 @@ public:
 
 protected:
     
-	Form();
+    Form();
 
     virtual ~Form();
 

gameplay/src/Game.cpp

@@ -93,7 +93,7 @@ bool Game::startup()
     if (_state != UNINITIALIZED)
         return false;
 
-	setViewport(Rectangle(0.0f, 0.0f, (float)_width, (float)_height));
+    setViewport(Rectangle(0.0f, 0.0f, (float)_width, (float)_height));
 
     RenderState::initialize();
 
@@ -217,8 +217,8 @@ void Game::frame()
 
 void Game::setViewport(const Rectangle& viewport)
 {
-	_viewport = viewport;
-	glViewport((GLuint)viewport.x, (GLuint)viewport.y, (GLuint)viewport.width, (GLuint)viewport.height); 
+    _viewport = viewport;
+    glViewport((GLuint)viewport.x, (GLuint)viewport.y, (GLuint)viewport.width, (GLuint)viewport.height); 
 }
 
 void Game::clear(ClearFlags flags, const Vector4& clearColor, float clearDepth, int clearStencil)

gameplay/src/Game.h

@@ -152,21 +152,21 @@ public:
      */
     inline unsigned int getHeight() const;
 
-	/**
-	 * Gets the game current viewport.
-	 *
-	 * The default viewport is Rectangle(0, 0, Game::getWidth(), Game::getHeight()).
-	 */
-	inline const Rectangle& getViewport() const;
-
-	/**
-	 * Set the game current viewport.
-	 *
-	 * The x, y, width and height of the viewport must all be positive.
-	 *
-	 * viewport The custom viewport to be set on the game.
-	 */
-	void setViewport(const Rectangle& viewport);
+    /**
+     * Gets the game current viewport.
+     *
+     * The default viewport is Rectangle(0, 0, Game::getWidth(), Game::getHeight()).
+     */
+    inline const Rectangle& getViewport() const;
+
+    /**
+     * Set the game current viewport.
+     *
+     * The x, y, width and height of the viewport must all be positive.
+     *
+     * viewport The custom viewport to be set on the game.
+     */
+    void setViewport(const Rectangle& viewport);
 
     /**
      * Clears the specified resource buffers to the specified clear values. 
@@ -402,7 +402,7 @@ private:
     unsigned int _frameRate;                    // The current frame rate.
     unsigned int _width;                        // The game's display width.
     unsigned int _height;                       // The game's display height.
-	Rectangle _viewport;						// the games's current viewport.
+    Rectangle _viewport;                        // the games's current viewport.
     Vector4 _clearColor;                        // The clear color value last used for clearing the color buffer.
     float _clearDepth;                          // The clear depth value last used for clearing the depth buffer.
     int _clearStencil;                          // The clear stencil value last used for clearing the stencil buffer.

gameplay/src/Game.inl

@@ -26,7 +26,7 @@ inline unsigned int Game::getHeight() const
 
 inline const Rectangle& Game::getViewport() const
 {
-	return _viewport;
+    return _viewport;
 }
 
 inline AnimationController* Game::getAnimationController() const

gameplay/src/Node.cpp

@@ -22,7 +22,7 @@ namespace gameplay
 Node::Node(const char* id)
     : _scene(NULL), _firstChild(NULL), _nextSibling(NULL), _prevSibling(NULL), _parent(NULL), _childCount(NULL),
     _nodeFlags(NODE_FLAG_VISIBLE), _camera(NULL), _light(NULL), _model(NULL), _form(NULL), _audioSource(NULL), _particleEmitter(NULL),
-	_collisionObject(NULL), _dirtyBits(NODE_DIRTY_ALL), _notifyHierarchyChanged(true), _userData(NULL)
+    _collisionObject(NULL), _dirtyBits(NODE_DIRTY_ALL), _notifyHierarchyChanged(true), _userData(NULL)
 {
     if (id)
     {
@@ -363,7 +363,7 @@ const Matrix& Node::getWorldMatrix() const
         // If we have a parent, multiply our parent world transform by our local
         // transform to obtain our final resolved world transform.
         Node* parent = getParent();
-		if (parent && (!_collisionObject || _collisionObject->isKinematic()))
+        if (parent && (!_collisionObject || _collisionObject->isKinematic()))
         {
             Matrix::multiply(parent->getWorldMatrix(), getMatrix(), &_world);
         }
@@ -891,30 +891,30 @@ PhysicsCollisionObject* Node::getCollisionObject() const
 
 PhysicsCollisionObject* Node::setCollisionObject(PhysicsCollisionObject::Type type, const PhysicsCollisionShape::Definition& shape, PhysicsRigidBody::Parameters* rigidBodyParameters)
 {
-	SAFE_DELETE(_collisionObject);
+    SAFE_DELETE(_collisionObject);
 
-	switch (type)
-	{
-	case PhysicsCollisionObject::RIGID_BODY:
-		{
-			_collisionObject = new PhysicsRigidBody(this, shape, rigidBodyParameters ? *rigidBodyParameters : PhysicsRigidBody::Parameters());
-		}
-		break;
+    switch (type)
+    {
+    case PhysicsCollisionObject::RIGID_BODY:
+        {
+            _collisionObject = new PhysicsRigidBody(this, shape, rigidBodyParameters ? *rigidBodyParameters : PhysicsRigidBody::Parameters());
+        }
+        break;
 
-	case PhysicsCollisionObject::GHOST_OBJECT:
-		{
-			_collisionObject = new PhysicsGhostObject(this, shape);
-		}
-		break;
+    case PhysicsCollisionObject::GHOST_OBJECT:
+        {
+            _collisionObject = new PhysicsGhostObject(this, shape);
+        }
+        break;
 
-	case PhysicsCollisionObject::CHARACTER:
-		{
-			_collisionObject = new PhysicsCharacter(this, shape);
-		}
-		break;
-	}
+    case PhysicsCollisionObject::CHARACTER:
+        {
+            _collisionObject = new PhysicsCharacter(this, shape);
+        }
+        break;
+    }
 
-	return _collisionObject;
+    return _collisionObject;
 }
 
 PhysicsCollisionObject* Node::setCollisionObject(const char* filePath)
@@ -960,7 +960,7 @@ PhysicsCollisionObject* Node::setCollisionObject(Properties* properties)
     {
         _collisionObject = PhysicsRigidBody::create(this, properties);
     }
-	return _collisionObject;
+    return _collisionObject;
 }
 
 NodeCloneContext::NodeCloneContext()

gameplay/src/Node.h

@@ -431,59 +431,59 @@ public:
      */
     void setParticleEmitter(ParticleEmitter* emitter);
 
-	/**
-	 * Returns the pointer to this node's physics collision object.
-	 *
-	 * The type of the returned collision object can be queried using
-	 * the PhysicsCollisionObject::getType() method.
-	 *
-	 * @return The pointer to this node's physics collision object.
-	 */
-	PhysicsCollisionObject* getCollisionObject() const;
-
-	/**
-	 * Sets (or disables) the physics collision object for this node.
-	 *
-	 * The supported collision object types include rigid bodies, ghost objects and 
-	 * characters.
-	 *
-	 * Rigid bodies are used to represent most physical objects in a game. The important
-	 * feature of rigid bodies is that they can be simulated by the physics system as other
-	 * rigid bodies or collision objects collide with them. To support this physics simulation,
-	 * rigid bodies require additional parameters, such as mass, friction and restitution to
-	 * define their physical features. These parameters can be passed into the
-	 * 'rigidBodyParameters' parameter.
-	 *
-	 * Ghost objects are a simple type of collision object that are not simulated. By default
-	 * they pass through other objects in the scene without affecting them. Ghost objects do
-	 * receive collision events however, which makes them useful for representing non-simulated
-	 * entities in a game that still require collision events, such as volumetric triggers, 
-	 * power-ups, etc.
-	 *
-	 * Characters are an extention of ghost objects which provide a number of additional features
-	 * for animating and moving characters within a game. Characters are represented as ghost
-	 * objects instead of rigid bodies to allow more direct control over character movement,
-	 * since attempting to model a physics character with a simulated rigid body usually results
-	 * in unresponse and unpredictable character movement. Unlike normal ghost objects,
-	 * characters to react to other characters and rigid bodies in the world. Characters react
-	 * to gravity and collide (and respond) with rigid bodies to allow them to walk on the ground,
-	 * slide along walls and walk up/down slopes and stairs.
-	 *
-	 * @param type The type of the collision object to set; to disable the physics
-	 *		collision object, pass PhysicsCollisionObject::NONE.
-	 * @param shape Definition of a physics collision shape to be used for this collision object.
-	 *		Use the static shape methods on the PhysicsCollisionShape class to specificy a shape
-	 *		definition, such as PhysicsCollisionShape::box().
-	 * @param rigidBodyParameters If type is PhysicsCollisionObject::RIGID_BODY, this
-	 *		must point to a valid rigid body parameters object containing information
-	 *		about the rigid body; otherwise, this parmater may be NULL.
-	 */
-	PhysicsCollisionObject* setCollisionObject(PhysicsCollisionObject::Type type, const PhysicsCollisionShape::Definition& shape, PhysicsRigidBody::Parameters* rigidBodyParameters = NULL);
+    /**
+     * Returns the pointer to this node's physics collision object.
+     *
+     * The type of the returned collision object can be queried using
+     * the PhysicsCollisionObject::getType() method.
+     *
+     * @return The pointer to this node's physics collision object.
+     */
+    PhysicsCollisionObject* getCollisionObject() const;
+
+    /**
+     * Sets (or disables) the physics collision object for this node.
+     *
+     * The supported collision object types include rigid bodies, ghost objects and 
+     * characters.
+     *
+     * Rigid bodies are used to represent most physical objects in a game. The important
+     * feature of rigid bodies is that they can be simulated by the physics system as other
+     * rigid bodies or collision objects collide with them. To support this physics simulation,
+     * rigid bodies require additional parameters, such as mass, friction and restitution to
+     * define their physical features. These parameters can be passed into the
+     * 'rigidBodyParameters' parameter.
+     *
+     * Ghost objects are a simple type of collision object that are not simulated. By default
+     * they pass through other objects in the scene without affecting them. Ghost objects do
+     * receive collision events however, which makes them useful for representing non-simulated
+     * entities in a game that still require collision events, such as volumetric triggers, 
+     * power-ups, etc.
+     *
+     * Characters are an extention of ghost objects which provide a number of additional features
+     * for animating and moving characters within a game. Characters are represented as ghost
+     * objects instead of rigid bodies to allow more direct control over character movement,
+     * since attempting to model a physics character with a simulated rigid body usually results
+     * in unresponse and unpredictable character movement. Unlike normal ghost objects,
+     * characters to react to other characters and rigid bodies in the world. Characters react
+     * to gravity and collide (and respond) with rigid bodies to allow them to walk on the ground,
+     * slide along walls and walk up/down slopes and stairs.
+     *
+     * @param type The type of the collision object to set; to disable the physics
+     *        collision object, pass PhysicsCollisionObject::NONE.
+     * @param shape Definition of a physics collision shape to be used for this collision object.
+     *        Use the static shape methods on the PhysicsCollisionShape class to specificy a shape
+     *        definition, such as PhysicsCollisionShape::box().
+     * @param rigidBodyParameters If type is PhysicsCollisionObject::RIGID_BODY, this
+     *        must point to a valid rigid body parameters object containing information
+     *        about the rigid body; otherwise, this parmater may be NULL.
+     */
+    PhysicsCollisionObject* setCollisionObject(PhysicsCollisionObject::Type type, const PhysicsCollisionShape::Definition& shape, PhysicsRigidBody::Parameters* rigidBodyParameters = NULL);
 
     /**
      * Sets the physics collision object for this node using the definition in the given file.
      * 
-     * @param filePath The path to the file that contains the collision object definition.
+     * @param filePath The path to the file that set the collision object definition.
      */
     PhysicsCollisionObject* setCollisionObject(const char* filePath);
 
@@ -596,6 +596,7 @@ protected:
 
     struct UserData
     {
+        UserData() : pointer(NULL), cleanupCallback(NULL) {}
         void* pointer;
         void (*cleanupCallback)(void*);
     };

gameplay/src/ParticleEmitter.cpp

@@ -50,7 +50,7 @@ ParticleEmitter* ParticleEmitter::create(const char* textureFile, TextureBlendin
     Texture* texture = NULL;
     texture = Texture::create(textureFile, true);    
 
-	if (!texture)
+    if (!texture)
     {
         LOG_ERROR_VARG("Error creating ParticleEmitter: Could not read texture file: %s", textureFile);
         return NULL;

gameplay/src/PhysicsCharacter.cpp

@@ -17,42 +17,42 @@ class ClosestNotMeConvexResultCallback : public btCollisionWorld::ClosestConvexR
 {
 public:
 
-	ClosestNotMeConvexResultCallback(btCollisionObject* me, const btVector3& up, btScalar minSlopeDot)
+    ClosestNotMeConvexResultCallback(btCollisionObject* me, const btVector3& up, btScalar minSlopeDot)
         : btCollisionWorld::ClosestConvexResultCallback(btVector3(0.0, 0.0, 0.0), btVector3(0.0, 0.0, 0.0)), _me(me), _up(up), _minSlopeDot(minSlopeDot)
-	{
-	}
+    {
+    }
 
-	btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace)
-	{
-		if (convexResult.m_hitCollisionObject == _me)
-			return btScalar(1.0);
+    btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace)
+    {
+        if (convexResult.m_hitCollisionObject == _me)
+            return btScalar(1.0);
 
         /*
-		btVector3 hitNormalWorld;
-		if (normalInWorldSpace)
-		{
-			hitNormalWorld = convexResult.m_hitNormalLocal;
-		} else
-		{
-			// transform normal into worldspace
-			hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
-		}
-
-		btScalar dotUp = _up.dot(hitNormalWorld);
-		if (dotUp < _minSlopeDot)
+        btVector3 hitNormalWorld;
+        if (normalInWorldSpace)
+        {
+            hitNormalWorld = convexResult.m_hitNormalLocal;
+        } else
+        {
+            // transform normal into worldspace
+            hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
+        }
+
+        btScalar dotUp = _up.dot(hitNormalWorld);
+        if (dotUp < _minSlopeDot)
         {
-			return btScalar(1.0);
-		}
+            return btScalar(1.0);
+        }
         */
 
-		return ClosestConvexResultCallback::addSingleResult(convexResult, normalInWorldSpace);
-	}
+        return ClosestConvexResultCallback::addSingleResult(convexResult, normalInWorldSpace);
+    }
 
 protected:
 
-	btCollisionObject* _me;
-	const btVector3 _up;
-	btScalar _minSlopeDot;
+    btCollisionObject* _me;
+    const btVector3 _up;
+    btScalar _minSlopeDot;
 };
 
 PhysicsCharacter::PhysicsCharacter(Node* node, const PhysicsCollisionShape::Definition& shape)
@@ -61,7 +61,7 @@ PhysicsCharacter::PhysicsCharacter(Node* node, const PhysicsCollisionShape::Defi
     _colliding(false), _collisionNormal(0,0,0), _currentPosition(0,0,0),
     _stepHeight(0.1f), _slopeAngle(0.0f), _cosSlopeAngle(0.0f), _physicsEnabled(true)
 {
-	setMaxSlopeAngle(45.0f);
+    setMaxSlopeAngle(45.0f);
 
     // Set the collision flags on the ghost object to indicate it's a character
     _ghostObject->setCollisionFlags(_ghostObject->getCollisionFlags() | btCollisionObject::CF_CHARACTER_OBJECT);
@@ -356,21 +356,21 @@ void PhysicsCharacter::updateAction(btCollisionWorld* collisionWorld, btScalar d
         //_colliding = fixCollision(collisionWorld);
         _colliding = false;
         int stepCount = 0;
-	    while (fixCollision(collisionWorld))
-	    {
+        while (fixCollision(collisionWorld))
+        {
             _colliding = true;
 
             if (++stepCount > 4)
-		    {
+            {
                 // Most likely we are wedged between a number of different collision objects
-			    break;
-		    }
-	    }
+                break;
+            }
+        }
     }
 
     // Update current and target world positions
-	btVector3 startPosition = _ghostObject->getWorldTransform().getOrigin();
-	_currentPosition = startPosition;
+    btVector3 startPosition = _ghostObject->getWorldTransform().getOrigin();
+    _currentPosition = startPosition;
 
     // Process movement in the up direction
     if (_physicsEnabled)
@@ -380,12 +380,12 @@ void PhysicsCharacter::updateAction(btCollisionWorld* collisionWorld, btScalar d
     stepForwardAndStrafe(collisionWorld, deltaTimeStep);
 
     // Process movement in the down direction
-	if (_physicsEnabled)
-		stepDown(collisionWorld, deltaTimeStep);
+    if (_physicsEnabled)
+        stepDown(collisionWorld, deltaTimeStep);
 
     // Set new position
-	btVector3 translation = _currentPosition - startPosition;
-	_node->translate(translation.x(), translation.y(), translation.z());
+    btVector3 translation = _currentPosition - startPosition;
+    _node->translate(translation.x(), translation.y(), translation.z());
 }
 
 void PhysicsCharacter::stepUp(btCollisionWorld* collisionWorld, btScalar time)
@@ -398,7 +398,7 @@ void PhysicsCharacter::stepUp(btCollisionWorld* collisionWorld, btScalar time)
     // 
     // Note that stepDown() will be called right after this, so the character will move back
     // down to collide with the ground so that he smoothly steps up stairs.
-	_currentPosition += btVector3(0, _stepHeight, 0);
+    _currentPosition += btVector3(0, _stepHeight, 0);
 }
 
 void PhysicsCharacter::stepForwardAndStrafe(btCollisionWorld* collisionWorld, float time)
@@ -448,7 +448,7 @@ void PhysicsCharacter::stepForwardAndStrafe(btCollisionWorld* collisionWorld, fl
     {
         // No velocity, so we aren't moving
         return;
-	}
+    }
 
     // Translate the target position by the velocity vector (already scaled by t)
     btVector3 targetPosition = _currentPosition + velocity;
@@ -462,60 +462,60 @@ void PhysicsCharacter::stepForwardAndStrafe(btCollisionWorld* collisionWorld, fl
 
     // Check for collisions by performing a bullet convex sweep test
     btTransform start;
-	btTransform end;
-	start.setIdentity();
-	end.setIdentity();
+    btTransform end;
+    start.setIdentity();
+    end.setIdentity();
 
-	btScalar fraction = 1.0;
-	btScalar distance2;
+    btScalar fraction = 1.0;
+    btScalar distance2;
 
-	if (_colliding && (_normalizedVelocity.dot(_collisionNormal) > btScalar(0.0)))
-	{
+    if (_colliding && (_normalizedVelocity.dot(_collisionNormal) > btScalar(0.0)))
+    {
         updateTargetPositionFromCollision(targetPosition, _collisionNormal);
-	}
+    }
 
-	int maxIter = 10;
+    int maxIter = 10;
 
-	while (fraction > btScalar(0.01) && maxIter-- > 0)
-	{
-		start.setOrigin(_currentPosition);
-		end.setOrigin(targetPosition);
+    while (fraction > btScalar(0.01) && maxIter-- > 0)
+    {
+        start.setOrigin(_currentPosition);
+        end.setOrigin(targetPosition);
 
-		btVector3 sweepDirNegative(_currentPosition - targetPosition);
+        btVector3 sweepDirNegative(_currentPosition - targetPosition);
 
-		ClosestNotMeConvexResultCallback callback(_ghostObject, sweepDirNegative, btScalar(0.0));
-		callback.m_collisionFilterGroup = _ghostObject->getBroadphaseHandle()->m_collisionFilterGroup;
-		callback.m_collisionFilterMask = _ghostObject->getBroadphaseHandle()->m_collisionFilterMask;
+        ClosestNotMeConvexResultCallback callback(_ghostObject, sweepDirNegative, btScalar(0.0));
+        callback.m_collisionFilterGroup = _ghostObject->getBroadphaseHandle()->m_collisionFilterGroup;
+        callback.m_collisionFilterMask = _ghostObject->getBroadphaseHandle()->m_collisionFilterMask;
 
-		_ghostObject->convexSweepTest(static_cast<btConvexShape*>(_collisionShape->getShape()), start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
+        _ghostObject->convexSweepTest(static_cast<btConvexShape*>(_collisionShape->getShape()), start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
 
-		fraction -= callback.m_closestHitFraction;
+        fraction -= callback.m_closestHitFraction;
 
-		if (callback.hasHit())
+        if (callback.hasHit())
         {
-			/*Vector3 normal(callback.m_hitNormalWorld.x(), callback.m_hitNormalWorld.y(), callback.m_hitNormalWorld.z());
-			PhysicsCollisionObject* o = Game::getInstance()->getPhysicsController()->getCollisionObject(callback.m_hitCollisionObject);
-			if (o->getType() == PhysicsCollisionObject::RIGID_BODY && o->isDynamic())
-			{
-				PhysicsRigidBody* rb = static_cast<PhysicsRigidBody*>(o);
-				normal.normalize();
-				rb->applyImpulse(-normal);
-			}*/
+            /*Vector3 normal(callback.m_hitNormalWorld.x(), callback.m_hitNormalWorld.y(), callback.m_hitNormalWorld.z());
+            PhysicsCollisionObject* o = Game::getInstance()->getPhysicsController()->getCollisionObject(callback.m_hitCollisionObject);
+            if (o->getType() == PhysicsCollisionObject::RIGID_BODY && o->isDynamic())
+            {
+                PhysicsRigidBody* rb = static_cast<PhysicsRigidBody*>(o);
+                normal.normalize();
+                rb->applyImpulse(-normal);
+            }*/
 
             updateTargetPositionFromCollision(targetPosition, callback.m_hitNormalWorld);
 
-			btVector3 currentDir = targetPosition - _currentPosition;
-			distance2 = currentDir.length2();
-			if (distance2 > FLT_EPSILON)
-			{
-				currentDir.normalize();
-
-				// If velocity is against original velocity, stop to avoid tiny oscilations in sloping corners.
-				if (currentDir.dot(_normalizedVelocity) <= btScalar(0.0))
-				{
-					break;
-				}
-			}
+            btVector3 currentDir = targetPosition - _currentPosition;
+            distance2 = currentDir.length2();
+            if (distance2 > FLT_EPSILON)
+            {
+                currentDir.normalize();
+
+                // If velocity is against original velocity, stop to avoid tiny oscilations in sloping corners.
+                if (currentDir.dot(_normalizedVelocity) <= btScalar(0.0))
+                {
+                    break;
+                }
+            }
         }
         else
         {
@@ -530,39 +530,39 @@ void PhysicsCharacter::stepForwardAndStrafe(btCollisionWorld* collisionWorld, fl
 void PhysicsCharacter::stepDown(btCollisionWorld* collisionWorld, btScalar time)
 {
     // Contribute basic gravity to fall velocity.
-	btVector3 gravity = Game::getInstance()->getPhysicsController()->_world->getGravity();
+    btVector3 gravity = Game::getInstance()->getPhysicsController()->_world->getGravity();
     _fallVelocity += (gravity * time);
 
     btVector3 targetPosition = _currentPosition + (_fallVelocity * time);
-	targetPosition -= btVector3(0, _stepHeight, 0);
+    targetPosition -= btVector3(0, _stepHeight, 0);
 
     // Perform a convex sweep test between current and target position
-	btTransform start;
-	btTransform end;
-	start.setIdentity();
-	end.setIdentity();
-	start.setOrigin(_currentPosition);
-	end.setOrigin(targetPosition);
+    btTransform start;
+    btTransform end;
+    start.setIdentity();
+    end.setIdentity();
+    start.setOrigin(_currentPosition);
+    end.setOrigin(targetPosition);
 
     ClosestNotMeConvexResultCallback callback(_ghostObject, btVector3(0, 1, 0), _cosSlopeAngle);
-	callback.m_collisionFilterGroup = _ghostObject->getBroadphaseHandle()->m_collisionFilterGroup;
-	callback.m_collisionFilterMask = _ghostObject->getBroadphaseHandle()->m_collisionFilterMask;
+    callback.m_collisionFilterGroup = _ghostObject->getBroadphaseHandle()->m_collisionFilterGroup;
+    callback.m_collisionFilterMask = _ghostObject->getBroadphaseHandle()->m_collisionFilterMask;
 
-	_ghostObject->convexSweepTest(static_cast<btConvexShape*>(_collisionShape->getShape()), start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
+    _ghostObject->convexSweepTest(static_cast<btConvexShape*>(_collisionShape->getShape()), start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
 
-	if (callback.hasHit())
-	{
+    if (callback.hasHit())
+    {
         // Collision detected, fix it
-		_currentPosition.setInterpolate3(_currentPosition, targetPosition, callback.m_closestHitFraction);
+        _currentPosition.setInterpolate3(_currentPosition, targetPosition, callback.m_closestHitFraction);
 
         // Zero out fall velocity when we hit an object
         _fallVelocity.setZero();
-	}
+    }
     else
     {
         // We can move here
         _currentPosition = targetPosition;
-	}
+    }
 }
 
 /*
@@ -570,7 +570,7 @@ void PhysicsCharacter::stepDown(btCollisionWorld* collisionWorld, btScalar time)
  */
 btVector3 computeReflectionDirection(const btVector3& direction, const btVector3& normal)
 {
-	return direction - (btScalar(2.0) * direction.dot(normal)) * normal;
+    return direction - (btScalar(2.0) * direction.dot(normal)) * normal;
 }
 
 /*
@@ -578,8 +578,8 @@ btVector3 computeReflectionDirection(const btVector3& direction, const btVector3
  */
 btVector3 parallelComponent(const btVector3& direction, const btVector3& normal)
 {
-	btScalar magnitude = direction.dot(normal);
-	return normal * magnitude;
+    btScalar magnitude = direction.dot(normal);
+    return normal * magnitude;
 }
 
 /*
@@ -587,7 +587,7 @@ btVector3 parallelComponent(const btVector3& direction, const btVector3& normal)
  */
 btVector3 perpindicularComponent(const btVector3& direction, const btVector3& normal)
 {
-	return direction - parallelComponent(direction, normal);
+    return direction - parallelComponent(direction, normal);
 }
 
 void PhysicsCharacter::updateTargetPositionFromCollision(btVector3& targetPosition, const btVector3& collisionNormal)
@@ -595,100 +595,100 @@ void PhysicsCharacter::updateTargetPositionFromCollision(btVector3& targetPositi
     //btScalar tangentMag = 0.0;
     //btScalar normalMag = 1.0;
 
-	btVector3 movementDirection = targetPosition - _currentPosition;
-	btScalar movementLength = movementDirection.length();
-
-	if (movementLength > FLT_EPSILON)
-	{
-		movementDirection.normalize();
+    btVector3 movementDirection = targetPosition - _currentPosition;
+    btScalar movementLength = movementDirection.length();
 
-		btVector3 reflectDir = computeReflectionDirection(movementDirection, collisionNormal);
-		reflectDir.normalize();
+    if (movementLength > FLT_EPSILON)
+    {
+        movementDirection.normalize();
 
-		//btVector3 parallelDir = parallelComponent(reflectDir, collisionNormal);
-		btVector3 perpindicularDir = perpindicularComponent(reflectDir, collisionNormal);
+        btVector3 reflectDir = computeReflectionDirection(movementDirection, collisionNormal);
+        reflectDir.normalize();
 
-		targetPosition = _currentPosition;
-		/*if (tangentMag != 0.0)
-		{
-			btVector3 parComponent = parallelDir * btScalar (tangentMag*movementLength);
-			targetPosition +=  parComponent;
-		}*/
+        //btVector3 parallelDir = parallelComponent(reflectDir, collisionNormal);
+        btVector3 perpindicularDir = perpindicularComponent(reflectDir, collisionNormal);
 
-		//if (normalMag != 0.0)
-		//{
-			btVector3 perpComponent = perpindicularDir * btScalar (/*normalMag **/ movementLength);
-			targetPosition += perpComponent;
-		//}
-	}
+        targetPosition = _currentPosition;
+        /*if (tangentMag != 0.0)
+        {
+            btVector3 parComponent = parallelDir * btScalar (tangentMag*movementLength);
+            targetPosition +=  parComponent;
+        }*/
+
+        //if (normalMag != 0.0)
+        //{
+            btVector3 perpComponent = perpindicularDir * btScalar (/*normalMag **/ movementLength);
+            targetPosition += perpComponent;
+        //}
+    }
 }
 
 bool PhysicsCharacter::fixCollision(btCollisionWorld* world)
 {
-	bool collision = false;
+    bool collision = false;
 
     btOverlappingPairCache* pairCache = _ghostObject->getOverlappingPairCache();
 
     // Tell the world to dispatch collision events for our ghost object
-	world->getDispatcher()->dispatchAllCollisionPairs(pairCache, world->getDispatchInfo(), world->getDispatcher());
+    world->getDispatcher()->dispatchAllCollisionPairs(pairCache, world->getDispatchInfo(), world->getDispatcher());
 
     // Store our current world position
     Vector3 startPosition;
-	_node->getWorldMatrix().getTranslation(&startPosition);
-	btVector3 currentPosition = BV(startPosition);
+    _node->getWorldMatrix().getTranslation(&startPosition);
+    btVector3 currentPosition = BV(startPosition);
 
     // Handle all collisions/overlappign pairs
-	btScalar maxPenetration = btScalar(0.0);
-	for (int i = 0, count = pairCache->getNumOverlappingPairs(); i < count; ++i)
-	{
-		_manifoldArray.resize(0);
+    btScalar maxPenetration = btScalar(0.0);
+    for (int i = 0, count = pairCache->getNumOverlappingPairs(); i < count; ++i)
+    {
+        _manifoldArray.resize(0);
 
         // Query contacts between this overlapping pair (store in _manifoldArray)
-		btBroadphasePair* collisionPair = &pairCache->getOverlappingPairArray()[i];
-		if (collisionPair->m_algorithm)
+        btBroadphasePair* collisionPair = &pairCache->getOverlappingPairArray()[i];
+        if (collisionPair->m_algorithm)
         {
-			collisionPair->m_algorithm->getAllContactManifolds(_manifoldArray);
+            collisionPair->m_algorithm->getAllContactManifolds(_manifoldArray);
         }
 
-		for (int j = 0, manifoldCount = _manifoldArray.size(); j < manifoldCount; ++j)
-		{
-			btPersistentManifold* manifold = _manifoldArray[j];
+        for (int j = 0, manifoldCount = _manifoldArray.size(); j < manifoldCount; ++j)
+        {
+            btPersistentManifold* manifold = _manifoldArray[j];
 
             // Get the direction of the contact points (used to scale normal vector in the correct direction).
             btScalar directionSign = manifold->getBody0() == _ghostObject ? -1.0f : 1.0f;
 
-			for (int p = 0, contactCount = manifold->getNumContacts(); p < contactCount; ++p)
-			{
-				const btManifoldPoint& pt = manifold->getContactPoint(p);
+            for (int p = 0, contactCount = manifold->getNumContacts(); p < contactCount; ++p)
+            {
+                const btManifoldPoint& pt = manifold->getContactPoint(p);
 
                 // Get penetration distance for this contact point
-				btScalar dist = pt.getDistance();
+                btScalar dist = pt.getDistance();
 
-				if (dist < 0.0)
-				{
+                if (dist < 0.0)
+                {
                     // A negative distance means the objects are overlapping
-					if (dist < maxPenetration)
-					{
+                    if (dist < maxPenetration)
+                    {
                         // Store collision normal for this point
-						maxPenetration = dist;
+                        maxPenetration = dist;
                         _collisionNormal = pt.m_normalWorldOnB * directionSign;
-					}
+                    }
 
-					//Node* node = Game::getInstance()->getPhysicsController()->getCollisionObject((btCollisionObject*)(manifold->getBody0() == _ghostObject ? manifold->getBody1() : manifold->getBody0()))->getNode();
+                    //Node* node = Game::getInstance()->getPhysicsController()->getCollisionObject((btCollisionObject*)(manifold->getBody0() == _ghostObject ? manifold->getBody1() : manifold->getBody0()))->getNode();
 
                     // Calculate new position for object, which is translated back along the collision normal
-					currentPosition += pt.m_normalWorldOnB * directionSign * dist * 0.2f;
-					collision = true;
-				}
-			}
-			//manifold->clearManifold();
-		}
-	}
-
-	// Set the new world transformation to apply to fix the collision
-	_node->translate(Vector3(currentPosition.x(), currentPosition.y(), currentPosition.z()) - startPosition);
-
-	return collision;
+                    currentPosition += pt.m_normalWorldOnB * directionSign * dist * 0.2f;
+                    collision = true;
+                }
+            }
+            //manifold->clearManifold();
+        }
+    }
+
+    // Set the new world transformation to apply to fix the collision
+    _node->translate(Vector3(currentPosition.x(), currentPosition.y(), currentPosition.z()) - startPosition);
+
+    return collision;
 }
 
 void PhysicsCharacter::debugDraw(btIDebugDraw* debugDrawer)

gameplay/src/PhysicsCharacter.h

@@ -258,7 +258,7 @@ public:
     /**
      * @see btActionInterface::debugDraw
      */
-	void debugDraw(btIDebugDraw* debugDrawer);
+    void debugDraw(btIDebugDraw* debugDrawer);
 
 protected:
 
@@ -287,9 +287,9 @@ private:
      * Use PhysicsController::createCharacter to create physics characters.
      *
      * @param node Scene node that represents the character.
-	 * @param shape Physis collision shape definition.
+     * @param shape Physis collision shape definition.
      */
-	PhysicsCharacter(Node* node, const PhysicsCollisionShape::Definition& shape);
+    PhysicsCharacter(Node* node, const PhysicsCollisionShape::Definition& shape);
 
     /**
      * Destructor.
@@ -333,7 +333,7 @@ private:
     btVector3 _currentPosition;
     std::map<const char*, CharacterAnimation> _animations;
     std::map<unsigned int, CharacterAnimation*> _layers;
-    btManifoldArray	_manifoldArray;
+    btManifoldArray _manifoldArray;
     float _stepHeight;
     float _slopeAngle;
     float _cosSlopeAngle;

gameplay/src/PhysicsCollisionObject.cpp

@@ -10,56 +10,56 @@ namespace gameplay
 struct CollidesWithCallback : public btCollisionWorld::ContactResultCallback
 {
     btScalar addSingleResult(btManifoldPoint& cp, 
-		const btCollisionObject* a, int partIdA, int indexA, 
-		const btCollisionObject* b, int partIdB, int indexB)
-	{
-		result = true;
-		return 0.0f;
-	}
+        const btCollisionObject* a, int partIdA, int indexA, 
+        const btCollisionObject* b, int partIdB, int indexB)
+    {
+        result = true;
+        return 0.0f;
+    }
 
     bool result;
 };
 
 PhysicsCollisionObject::PhysicsCollisionObject(Node* node)
-	: _node(node), _motionState(NULL), _collisionShape(NULL)
+    : _node(node), _motionState(NULL), _collisionShape(NULL)
 {
 }
 
 PhysicsCollisionObject::~PhysicsCollisionObject()
 {
-	SAFE_DELETE(_motionState);
+    SAFE_DELETE(_motionState);
 
-	Game::getInstance()->getPhysicsController()->destroyShape(_collisionShape);
+    Game::getInstance()->getPhysicsController()->destroyShape(_collisionShape);
 }
 
 PhysicsCollisionShape::Type PhysicsCollisionObject::getShapeType() const
 {
-	return getCollisionShape()->getType();
+    return getCollisionShape()->getType();
 }
 
 Node* PhysicsCollisionObject::getNode() const
 {
-	return _node;
+    return _node;
 }
 
 PhysicsCollisionShape* PhysicsCollisionObject::getCollisionShape() const
 {
-	return _collisionShape;
+    return _collisionShape;
 }
 
 PhysicsMotionState* PhysicsCollisionObject::getMotionState() const
 {
-	return _motionState;
+    return _motionState;
 }
 
 bool PhysicsCollisionObject::isKinematic() const
 {
-	return getCollisionObject()->isKinematicObject();
+    return getCollisionObject()->isKinematicObject();
 }
 
 bool PhysicsCollisionObject::isDynamic() const
 {
-	return !getCollisionObject()->isStaticOrKinematicObject();
+    return !getCollisionObject()->isStaticOrKinematicObject();
 }
 
 void PhysicsCollisionObject::addCollisionListener(CollisionListener* listener, PhysicsCollisionObject* object)

gameplay/src/PhysicsCollisionObject.h

@@ -16,7 +16,7 @@ class Node;
 class PhysicsCollisionObject
 {
     friend class PhysicsController;
-	friend class PhysicsConstraint;
+    friend class PhysicsConstraint;
 
 public:
 
@@ -40,10 +40,10 @@ public:
          */
         GHOST_OBJECT,
 
-		/**
-		 * No collision object.
-		 */
-		NONE
+        /**
+         * No collision object.
+         */
+        NONE
     };
 
     /** 
@@ -122,7 +122,7 @@ public:
                                     const Vector3& contactPointB = Vector3::zero()) = 0;
     };
 
-	/**
+    /**
      * Virtual destructor.
      */
     virtual ~PhysicsCollisionObject();
@@ -132,38 +132,38 @@ public:
      */
     virtual PhysicsCollisionObject::Type getType() const = 0;
 
-	/**
-	 * Returns the type of the shape for this collision object.
-	 */
-	PhysicsCollisionShape::Type getShapeType() const;
+    /**
+     * Returns the type of the shape for this collision object.
+     */
+    PhysicsCollisionShape::Type getShapeType() const;
 
     /**
      * Returns the node associated with this collision object.
      */
     Node* getNode() const;
 
-	/**
+    /**
      * Returns the collision shape.
      *
      * @return The collision shape.
      */
     PhysicsCollisionShape* getCollisionShape() const;
 
-	/**
-	 * Returns whether this collision object is kinematic.
-	 *
-	 * A kinematic collision object is an object that is not simulated by
-	 * the physics system and instead has its transform driven manually.
-	 *
-	 * @return Whether the collision object is kinematic.
-	 */
-	bool isKinematic() const;
+    /**
+     * Returns whether this collision object is kinematic.
+     *
+     * A kinematic collision object is an object that is not simulated by
+     * the physics system and instead has its transform driven manually.
+     *
+     * @return Whether the collision object is kinematic.
+     */
+    bool isKinematic() const;
 
     /**
      * Returns whether this collision object is dynamic.
-	 *
-	 * A dynamic collision object is simulated entirely by the physics system,
-	 * such as with dynamic rigid bodies. 
+     *
+     * A dynamic collision object is simulated entirely by the physics system,
+     * such as with dynamic rigid bodies. 
      *
      * @return Whether the collision object is dynamic.
      */
@@ -207,15 +207,15 @@ protected:
      */
     virtual btCollisionObject* getCollisionObject() const = 0;
 
-	/**
-	 * Returns the physics motion state.
-	 *
-	 * @return The motion state object.
-	 */
-	PhysicsMotionState* getMotionState() const;
+    /**
+     * Returns the physics motion state.
+     *
+     * @return The motion state object.
+     */
+    PhysicsMotionState* getMotionState() const;
 
-	// Common member variables
-	Node* _node;
+    // Common member variables
+    Node* _node;
     PhysicsMotionState* _motionState;
     PhysicsCollisionShape* _collisionShape;
 

gameplay/src/PhysicsCollisionShape.cpp

@@ -14,7 +14,7 @@ PhysicsCollisionShape::PhysicsCollisionShape(Type type, btCollisionShape* shape)
 
 PhysicsCollisionShape::PhysicsCollisionShape(const PhysicsCollisionShape& copy)
 {
-	// hidden
+    // hidden
 }
 
 PhysicsCollisionShape::~PhysicsCollisionShape()
@@ -331,13 +331,13 @@ PhysicsCollisionShape::Definition PhysicsCollisionShape::box()
 
 PhysicsCollisionShape::Definition PhysicsCollisionShape::box(const Vector3& extents, const Vector3& center, bool absolute)
 {
-	Definition d;
-	d.type = SHAPE_BOX;
-	memcpy(d.data.box.extents, &extents.x, sizeof(float) * 3);
-	memcpy(d.data.box.center, &center.x, sizeof(float) * 3);
-	d.isExplicit = true;
-	d.centerAbsolute = absolute;
-	return d;
+    Definition d;
+    d.type = SHAPE_BOX;
+    memcpy(d.data.box.extents, &extents.x, sizeof(float) * 3);
+    memcpy(d.data.box.center, &center.x, sizeof(float) * 3);
+    d.isExplicit = true;
+    d.centerAbsolute = absolute;
+    return d;
 }
 
 PhysicsCollisionShape::Definition PhysicsCollisionShape::sphere()
@@ -351,13 +351,13 @@ PhysicsCollisionShape::Definition PhysicsCollisionShape::sphere()
 
 PhysicsCollisionShape::Definition PhysicsCollisionShape::sphere(float radius, const Vector3& center, bool absolute)
 {
-	Definition d;
-	d.type = SHAPE_SPHERE;
-	d.data.sphere.radius = radius;
-	memcpy(d.data.sphere.center, &center.x, sizeof(float) * 3);
-	d.isExplicit  = true;
-	d.centerAbsolute = absolute;
-	return d;
+    Definition d;
+    d.type = SHAPE_SPHERE;
+    d.data.sphere.radius = radius;
+    memcpy(d.data.sphere.center, &center.x, sizeof(float) * 3);
+    d.isExplicit  = true;
+    d.centerAbsolute = absolute;
+    return d;
 }
 
 PhysicsCollisionShape::Definition PhysicsCollisionShape::capsule()
@@ -371,14 +371,14 @@ PhysicsCollisionShape::Definition PhysicsCollisionShape::capsule()
 
 PhysicsCollisionShape::Definition PhysicsCollisionShape::capsule(float radius, float height, const Vector3& center, bool absolute)
 {
-	Definition d;
-	d.type = SHAPE_CAPSULE;
-	d.data.capsule.radius = radius;
-	d.data.capsule.height = height;
-	memcpy(d.data.capsule.center, &center.x, sizeof(float) * 3);
-	d.isExplicit = true;
-	d.centerAbsolute = absolute;
-	return d;
+    Definition d;
+    d.type = SHAPE_CAPSULE;
+    d.data.capsule.radius = radius;
+    d.data.capsule.height = height;
+    memcpy(d.data.capsule.center, &center.x, sizeof(float) * 3);
+    d.isExplicit = true;
+    d.centerAbsolute = absolute;
+    return d;
 }
 
 PhysicsCollisionShape::Definition PhysicsCollisionShape::heightfield(Image* image)

gameplay/src/PhysicsCollisionShape.h

@@ -69,19 +69,19 @@ public:
         // Shape type.
         PhysicsCollisionShape::Type type;
 
-		// Shape data.
-		struct BoxData { float center[3], extents[3]; };
-		struct SphereData { float center[3]; float radius; };
-		struct CapsuleData { float center[3]; float radius, height; };
+        // Shape data.
+        struct BoxData { float center[3], extents[3]; };
+        struct SphereData { float center[3]; float radius; };
+        struct CapsuleData { float center[3]; float radius, height; };
 
         union
         {
-			BoxData box;
-			SphereData sphere;
-			CapsuleData capsule;
-			Image* heightfield;
-			Mesh* mesh;
-		} data;
+            BoxData box;
+            SphereData sphere;
+            CapsuleData capsule;
+            Image* heightfield;
+            Mesh* mesh;
+        } data;
 
         // Whether the shape definition is explicit, or if it is inherited from node bounds.
         bool isExplicit;
@@ -97,15 +97,15 @@ public:
      */
     PhysicsCollisionShape::Type getType() const;
 
-	/**
-	 * Returns the internal bullet physics shape object.
-	 *
-	 * @return The bullet shape object.
-	 */
-	btCollisionShape* getShape() const
-	{
-		return _shape;
-	}
+    /**
+     * Returns the internal bullet physics shape object.
+     *
+     * @return The bullet shape object.
+     */
+    btCollisionShape* getShape() const
+    {
+        return _shape;
+    }
 
     /**
      * Defines a box shape, using the bounding volume of the node it is attached to.
@@ -120,8 +120,8 @@ public:
      * @param extents Extents of the box shape along the x, y and z axes.
      * @param center Center point of the box.
      * @param absolute True to specifiy that the given center point is an absolute position.
-     *		By default the center point is treated as relative to the location of the node
-     *		that the shape is attached to.
+     *        By default the center point is treated as relative to the location of the node
+     *        that the shape is attached to.
      *
      * @return Definition of a box shape.
      */
@@ -140,8 +140,8 @@ public:
      * @param radius Radius of the sphere.
      * @param center Center point of the sphere.
      * @param absolute True to specifiy that the given center point is an absolute position.
-     *		By default the center point is treated as relative to the location of the node
-     *		that the shape is attached to.
+     *        By default the center point is treated as relative to the location of the node
+     *        that the shape is attached to.
      *
      * @return Definition of a sphere shape.
      */
@@ -161,8 +161,8 @@ public:
      * @param height Height of the capsule.
      * @param center Center point of the capsule.
      * @param absolute True to specifiy that the given center point is an absolute position.
-     *		By default the center point is treated as relative to the location of the node
-     *		that the shape is attached to.
+     *        By default the center point is treated as relative to the location of the node
+     *        that the shape is attached to.
      *
      * @return Definition of a capsule shape.
      */
@@ -204,15 +204,15 @@ private:
      */
     PhysicsCollisionShape(Type type, btCollisionShape* shape);
 
-	/** 
-	 * Hidden copy constructor.
-	 */
-	PhysicsCollisionShape(const PhysicsCollisionShape& copy);
+    /** 
+     * Hidden copy constructor.
+     */
+    PhysicsCollisionShape(const PhysicsCollisionShape& copy);
 
-	/**
-	 * Destructor.
-	 */
-	~PhysicsCollisionShape();
+    /**
+     * Destructor.
+     */
+    ~PhysicsCollisionShape();
 
 
     // Shape type

gameplay/src/PhysicsConstraint.cpp

@@ -155,7 +155,7 @@ Vector3 PhysicsConstraint::getWorldCenterOfMass(const Model* model)
 
 Vector3 PhysicsConstraint::offsetByCenterOfMass(const Node* node, const Vector3& v)
 {
-	btVector3 centerOfMassOffset = (node->getCollisionObject()->getMotionState())->_centerOfMassOffset.getOrigin();
+    btVector3 centerOfMassOffset = (node->getCollisionObject()->getMotionState())->_centerOfMassOffset.getOrigin();
     return Vector3(v.x + centerOfMassOffset.x(), v.y + centerOfMassOffset.y(), v.z + centerOfMassOffset.z());
 }
 

gameplay/src/PhysicsController.cpp

@@ -235,7 +235,7 @@ void PhysicsController::initialize()
     _ghostPairCallback = bullet_new<btGhostPairCallback>();
     _world->getPairCache()->setInternalGhostPairCallback(_ghostPairCallback);
 
-	_world->getDispatchInfo().m_allowedCcdPenetration = 0.0001f;
+    _world->getDispatchInfo().m_allowedCcdPenetration = 0.0001f;
 
     // Set up debug drawing.
     _debugDrawer = new DebugDrawer();
@@ -404,15 +404,15 @@ void PhysicsController::addCollisionObject(PhysicsCollisionObject* object)
     switch (object->getType())
     {
     case PhysicsCollisionObject::RIGID_BODY:
-		_world->addRigidBody(static_cast<btRigidBody*>(object->getCollisionObject()), btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::DefaultFilter | btBroadphaseProxy::StaticFilter | btBroadphaseProxy::CharacterFilter | btBroadphaseProxy::AllFilter);
+        _world->addRigidBody(static_cast<btRigidBody*>(object->getCollisionObject()), btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::DefaultFilter | btBroadphaseProxy::StaticFilter | btBroadphaseProxy::CharacterFilter | btBroadphaseProxy::AllFilter);
         break;
 
     case PhysicsCollisionObject::CHARACTER:
-		_world->addCollisionObject(object->getCollisionObject(), btBroadphaseProxy::CharacterFilter, btBroadphaseProxy::DefaultFilter | btBroadphaseProxy::StaticFilter | btBroadphaseProxy::CharacterFilter | btBroadphaseProxy::AllFilter);
+        _world->addCollisionObject(object->getCollisionObject(), btBroadphaseProxy::CharacterFilter, btBroadphaseProxy::DefaultFilter | btBroadphaseProxy::StaticFilter | btBroadphaseProxy::CharacterFilter | btBroadphaseProxy::AllFilter);
         break;
 
     case PhysicsCollisionObject::GHOST_OBJECT:
-		_world->addCollisionObject(object->getCollisionObject(), btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::DefaultFilter | btBroadphaseProxy::StaticFilter | btBroadphaseProxy::CharacterFilter | btBroadphaseProxy::AllFilter);
+        _world->addCollisionObject(object->getCollisionObject(), btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::DefaultFilter | btBroadphaseProxy::StaticFilter | btBroadphaseProxy::CharacterFilter | btBroadphaseProxy::AllFilter);
         break;
 
     default:
@@ -460,199 +460,199 @@ PhysicsCollisionObject* PhysicsController::getCollisionObject(const btCollisionO
 
 void getBoundingBox(Node* node, BoundingBox* out, bool merge = false)
 {
-	if (node->getModel())
-	{
-		if (merge)
-			out->merge(node->getModel()->getMesh()->getBoundingBox());
-		else
-		{
-			out->set(node->getModel()->getMesh()->getBoundingBox());
-			merge = true;
-		}
-	}
-
-	Node* child = node->getFirstChild();
-	while (child)
-	{
-		getBoundingBox(child, out, merge);
-		child = child->getNextSibling();
-	}
+    if (node->getModel())
+    {
+        if (merge)
+            out->merge(node->getModel()->getMesh()->getBoundingBox());
+        else
+        {
+            out->set(node->getModel()->getMesh()->getBoundingBox());
+            merge = true;
+        }
+    }
+
+    Node* child = node->getFirstChild();
+    while (child)
+    {
+        getBoundingBox(child, out, merge);
+        child = child->getNextSibling();
+    }
 }
 
 void getBoundingSphere(Node* node, BoundingSphere* out, bool merge = false)
 {
-	if (node->getModel())
-	{
-		if (merge)
-			out->merge(node->getModel()->getMesh()->getBoundingSphere());
-		else
-		{
-			out->set(node->getModel()->getMesh()->getBoundingSphere());
-			merge = true;
-		}
-	}
-
-	Node* child = node->getFirstChild();
-	while (child)
-	{
-		getBoundingSphere(child, out, merge);
-		child = child->getNextSibling();
-	}
+    if (node->getModel())
+    {
+        if (merge)
+            out->merge(node->getModel()->getMesh()->getBoundingSphere());
+        else
+        {
+            out->set(node->getModel()->getMesh()->getBoundingSphere());
+            merge = true;
+        }
+    }
+
+    Node* child = node->getFirstChild();
+    while (child)
+    {
+        getBoundingSphere(child, out, merge);
+        child = child->getNextSibling();
+    }
 }
 
 void computeCenterOfMass(const Vector3& center, const Vector3& scale, Vector3* centerOfMassOffset)
 {
-	// Update center of mass offset
-	*centerOfMassOffset = center;
-	centerOfMassOffset->x *= scale.x;
-	centerOfMassOffset->y *= scale.y;
-	centerOfMassOffset->z *= scale.z;
-	centerOfMassOffset->negate();
+    // Update center of mass offset
+    *centerOfMassOffset = center;
+    centerOfMassOffset->x *= scale.x;
+    centerOfMassOffset->y *= scale.y;
+    centerOfMassOffset->z *= scale.z;
+    centerOfMassOffset->negate();
 }
 
 PhysicsCollisionShape* PhysicsController::createShape(Node* node, const PhysicsCollisionShape::Definition& shape, Vector3* centerOfMassOffset)
 {
-	PhysicsCollisionShape* collisionShape = NULL;
+    PhysicsCollisionShape* collisionShape = NULL;
 
     // Get the node's world scale (we need to apply this during creation since rigid bodies don't scale dynamically).
     Vector3 scale;
     node->getWorldMatrix().getScale(&scale);
 
-	switch (shape.type)
+    switch (shape.type)
     {
-	case PhysicsCollisionShape::SHAPE_BOX:
+    case PhysicsCollisionShape::SHAPE_BOX:
         {
-			if (shape.isExplicit)
-			{
-				// Use the passed in box information
-				collisionShape = createBox(Vector3(shape.data.box.extents), Vector3::one());
-
-				if (shape.centerAbsolute)
-				{
-					computeCenterOfMass(Vector3(shape.data.box.center), Vector3::one(), centerOfMassOffset);
-				}
-				else
-				{
-					BoundingBox box;
-					getBoundingBox(node, &box);
-					computeCenterOfMass(box.getCenter() + Vector3(shape.data.box.center), scale, centerOfMassOffset);
-				}
-			}
-			else
-			{
-				// Automatically compute bounding box from mesh's bounding box
-				BoundingBox box;
-				getBoundingBox(node, &box);
-				collisionShape = createBox(Vector3(std::abs(box.max.x - box.min.x), std::abs(box.max.y - box.min.y), std::abs(box.max.z - box.min.z)), scale);
-
-				computeCenterOfMass(box.getCenter(), scale, centerOfMassOffset);
-			}
+            if (shape.isExplicit)
+            {
+                // Use the passed in box information
+                collisionShape = createBox(Vector3(shape.data.box.extents), Vector3::one());
+
+                if (shape.centerAbsolute)
+                {
+                    computeCenterOfMass(Vector3(shape.data.box.center), Vector3::one(), centerOfMassOffset);
+                }
+                else
+                {
+                    BoundingBox box;
+                    getBoundingBox(node, &box);
+                    computeCenterOfMass(box.getCenter() + Vector3(shape.data.box.center), scale, centerOfMassOffset);
+                }
+            }
+            else
+            {
+                // Automatically compute bounding box from mesh's bounding box
+                BoundingBox box;
+                getBoundingBox(node, &box);
+                collisionShape = createBox(Vector3(std::abs(box.max.x - box.min.x), std::abs(box.max.y - box.min.y), std::abs(box.max.z - box.min.z)), scale);
+
+                computeCenterOfMass(box.getCenter(), scale, centerOfMassOffset);
+            }
         }
-		break;
+        break;
 
-	case PhysicsCollisionShape::SHAPE_SPHERE:
+    case PhysicsCollisionShape::SHAPE_SPHERE:
         {
-			if (shape.isExplicit)
-			{
-				// Use the passed in sphere information
-				collisionShape = createSphere(shape.data.sphere.radius, Vector3::one());
-
-				if (shape.centerAbsolute)
-				{
-					computeCenterOfMass(Vector3(shape.data.sphere.center), Vector3::one(), centerOfMassOffset);
-				}
-				else
-				{
-					BoundingSphere sphere;
-					getBoundingSphere(node, &sphere);
-					computeCenterOfMass(sphere.center + Vector3(shape.data.sphere.center), scale, centerOfMassOffset);
-				}
-			}
-			else
-			{
-				// Automatically compute bounding sphere from mesh's bounding sphere
-				BoundingSphere sphere;
-				getBoundingSphere(node, &sphere);
-				collisionShape = createSphere(sphere.radius, scale);
-
-				computeCenterOfMass(sphere.center, scale, centerOfMassOffset);
-			}
+            if (shape.isExplicit)
+            {
+                // Use the passed in sphere information
+                collisionShape = createSphere(shape.data.sphere.radius, Vector3::one());
+
+                if (shape.centerAbsolute)
+                {
+                    computeCenterOfMass(Vector3(shape.data.sphere.center), Vector3::one(), centerOfMassOffset);
+                }
+                else
+                {
+                    BoundingSphere sphere;
+                    getBoundingSphere(node, &sphere);
+                    computeCenterOfMass(sphere.center + Vector3(shape.data.sphere.center), scale, centerOfMassOffset);
+                }
+            }
+            else
+            {
+                // Automatically compute bounding sphere from mesh's bounding sphere
+                BoundingSphere sphere;
+                getBoundingSphere(node, &sphere);
+                collisionShape = createSphere(sphere.radius, scale);
+
+                computeCenterOfMass(sphere.center, scale, centerOfMassOffset);
+            }
         }
-		break;
-
-	case PhysicsCollisionShape::SHAPE_CAPSULE:
-		{
-			if (shape.isExplicit)
-			{
-				// Use the passed in capsule information
-				collisionShape = createCapsule(shape.data.capsule.radius, shape.data.capsule.height, Vector3::one());
-
-				if (shape.centerAbsolute)
-				{
-					computeCenterOfMass(Vector3(shape.data.capsule.center), Vector3::one(), centerOfMassOffset);
-				}
-				else
-				{
-					BoundingBox box;
-					getBoundingBox(node, &box);
-					computeCenterOfMass(box.getCenter() + Vector3(shape.data.capsule.center), scale, centerOfMassOffset);
-				}
-			}
-			else
-			{
-				// Compute a capsule shape that roughly matches the bounding box of the mesh
-				BoundingBox box;
-				getBoundingBox(node, &box);
-				float radius = std::max((box.max.x - box.min.x) * 0.5f, (box.max.z - box.min.z) * 0.5f);
-				float height = box.max.y - box.min.y;
-				collisionShape = createCapsule(radius, height, scale);
-
-				computeCenterOfMass(box.getCenter(), scale, centerOfMassOffset);
-			}
-		}
-		break;
-
-	case PhysicsCollisionShape::SHAPE_HEIGHTFIELD:
-		{
-			// Build heightfield rigid body from the passed in shape
-			collisionShape = createHeightfield(node, shape.data.heightfield, centerOfMassOffset);
-		}
-		break;
-
-	case PhysicsCollisionShape::SHAPE_MESH:
+        break;
+
+    case PhysicsCollisionShape::SHAPE_CAPSULE:
         {
-			// Build mesh from passed in shape
-			collisionShape = createMesh(shape.data.mesh, scale);
+            if (shape.isExplicit)
+            {
+                // Use the passed in capsule information
+                collisionShape = createCapsule(shape.data.capsule.radius, shape.data.capsule.height, Vector3::one());
+
+                if (shape.centerAbsolute)
+                {
+                    computeCenterOfMass(Vector3(shape.data.capsule.center), Vector3::one(), centerOfMassOffset);
+                }
+                else
+                {
+                    BoundingBox box;
+                    getBoundingBox(node, &box);
+                    computeCenterOfMass(box.getCenter() + Vector3(shape.data.capsule.center), scale, centerOfMassOffset);
+                }
+            }
+            else
+            {
+                // Compute a capsule shape that roughly matches the bounding box of the mesh
+                BoundingBox box;
+                getBoundingBox(node, &box);
+                float radius = std::max((box.max.x - box.min.x) * 0.5f, (box.max.z - box.min.z) * 0.5f);
+                float height = box.max.y - box.min.y;
+                collisionShape = createCapsule(radius, height, scale);
+
+                computeCenterOfMass(box.getCenter(), scale, centerOfMassOffset);
+            }
         }
-		break;
+        break;
+
+    case PhysicsCollisionShape::SHAPE_HEIGHTFIELD:
+        {
+            // Build heightfield rigid body from the passed in shape
+            collisionShape = createHeightfield(node, shape.data.heightfield, centerOfMassOffset);
+        }
+        break;
+
+    case PhysicsCollisionShape::SHAPE_MESH:
+        {
+            // Build mesh from passed in shape
+            collisionShape = createMesh(shape.data.mesh, scale);
+        }
+        break;
     }
 
-	return collisionShape;
+    return collisionShape;
 }
 
 PhysicsCollisionShape* PhysicsController::createBox(const Vector3& extents, const Vector3& scale)
 {
     btVector3 halfExtents(scale.x * 0.5 * extents.x, scale.y * 0.5 * extents.y, scale.z * 0.5 * extents.z);
 
-	PhysicsCollisionShape* shape;
+    PhysicsCollisionShape* shape;
 
     // Return the box shape from the cache if it already exists.
     for (unsigned int i = 0; i < _shapes.size(); ++i)
     {
-		shape = _shapes[i];
-		if (shape->getType() == PhysicsCollisionShape::SHAPE_BOX)
+        shape = _shapes[i];
+        if (shape->getType() == PhysicsCollisionShape::SHAPE_BOX)
         {
-			btBoxShape* box = static_cast<btBoxShape*>(shape->_shape);
+            btBoxShape* box = static_cast<btBoxShape*>(shape->_shape);
             if (box->getHalfExtentsWithMargin() == halfExtents)
             {
-				shape->addRef();
+                shape->addRef();
                 return shape;
             }
         }
     }
 
     // Create the box shape and add it to the cache.
-	shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_BOX, bullet_new<btBoxShape>(halfExtents));
+    shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_BOX, bullet_new<btBoxShape>(halfExtents));
     _shapes.push_back(shape);
 
     return shape;
@@ -668,15 +668,15 @@ PhysicsCollisionShape* PhysicsController::createSphere(float radius, const Vecto
     if (uniformScale < scale.z)
         uniformScale = scale.z;
 
-	float scaledRadius = radius * uniformScale;
+    float scaledRadius = radius * uniformScale;
 
-	PhysicsCollisionShape* shape;
+    PhysicsCollisionShape* shape;
 
     // Return the sphere shape from the cache if it already exists.
     for (unsigned int i = 0; i < _shapes.size(); ++i)
     {
-		shape = _shapes[i];
-		if (shape->getType() == PhysicsCollisionShape::SHAPE_SPHERE)
+        shape = _shapes[i];
+        if (shape->getType() == PhysicsCollisionShape::SHAPE_SPHERE)
         {
             btSphereShape* sphere = static_cast<btSphereShape*>(shape->_shape);
             if (sphere->getRadius() == scaledRadius)
@@ -688,7 +688,7 @@ PhysicsCollisionShape* PhysicsController::createSphere(float radius, const Vecto
     }
 
     // Create the sphere shape and add it to the cache.
-	shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_SPHERE, bullet_new<btSphereShape>(scaledRadius));
+    shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_SPHERE, bullet_new<btSphereShape>(scaledRadius));
     _shapes.push_back(shape);
 
     return shape;
@@ -696,19 +696,19 @@ PhysicsCollisionShape* PhysicsController::createSphere(float radius, const Vecto
 
 PhysicsCollisionShape* PhysicsController::createCapsule(float radius, float height, const Vector3& scale)
 {
-	float girthScale = scale.x;
-	if (girthScale < scale.z)
-		girthScale = scale.z;
-	float scaledRadius = radius * girthScale;
-	float scaledHeight = height * scale.y - radius * 2;
+    float girthScale = scale.x;
+    if (girthScale < scale.z)
+        girthScale = scale.z;
+    float scaledRadius = radius * girthScale;
+    float scaledHeight = height * scale.y - radius * 2;
 
-	PhysicsCollisionShape* shape;
+    PhysicsCollisionShape* shape;
 
     // Return the capsule shape from the cache if it already exists.
     for (unsigned int i = 0; i < _shapes.size(); i++)
     {
-		shape = _shapes[i];
-		if (shape->getType() == PhysicsCollisionShape::SHAPE_CAPSULE)
+        shape = _shapes[i];
+        if (shape->getType() == PhysicsCollisionShape::SHAPE_CAPSULE)
         {
             btCapsuleShape* capsule = static_cast<btCapsuleShape*>(shape->_shape);
             if (capsule->getRadius() == scaledRadius && capsule->getHalfHeight() == 0.5f * scaledHeight)
@@ -720,7 +720,7 @@ PhysicsCollisionShape* PhysicsController::createCapsule(float radius, float heig
     }
 
     // Create the capsule shape and add it to the cache.
-	shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_CAPSULE, bullet_new<btCapsuleShape>(scaledRadius, scaledHeight));
+    shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_CAPSULE, bullet_new<btCapsuleShape>(scaledRadius, scaledHeight));
     _shapes.push_back(shape);
 
     return shape;
@@ -728,25 +728,25 @@ PhysicsCollisionShape* PhysicsController::createCapsule(float radius, float heig
 
 PhysicsCollisionShape* PhysicsController::createHeightfield(Node* node, Image* image, Vector3* centerOfMassOffset)
 {
-	// Get the dimensions of the heightfield.
-	// If the node has a mesh defined, use the dimensions of the bounding box for the mesh.
-	// Otherwise simply use the image dimensions (with a max height of 255).
-	float width, length, minHeight, maxHeight;
-	if (node->getModel() && node->getModel()->getMesh())
-	{
-		const BoundingBox& box = node->getModel()->getMesh()->getBoundingBox();
-		width = box.max.x - box.min.x;
-		length = box.max.z - box.min.z;
-		minHeight = box.min.y;
-		maxHeight = box.max.y;
-	}
-	else
-	{
-		width = image->getWidth();
-		length = image->getHeight();
-		minHeight = 0.0f;
-		maxHeight = 255.0f;
-	}
+    // Get the dimensions of the heightfield.
+    // If the node has a mesh defined, use the dimensions of the bounding box for the mesh.
+    // Otherwise simply use the image dimensions (with a max height of 255).
+    float width, length, minHeight, maxHeight;
+    if (node->getModel() && node->getModel()->getMesh())
+    {
+        const BoundingBox& box = node->getModel()->getMesh()->getBoundingBox();
+        width = box.max.x - box.min.x;
+        length = box.max.z - box.min.z;
+        minHeight = box.min.y;
+        maxHeight = box.max.y;
+    }
+    else
+    {
+        width = image->getWidth();
+        length = image->getHeight();
+        minHeight = 0.0f;
+        maxHeight = 255.0f;
+    }
 
     // Get the size in bytes of a pixel (we ensure that the image's
     // pixel format is actually supported before calling this constructor).
@@ -759,14 +759,14 @@ PhysicsCollisionShape* PhysicsController::createHeightfield(Node* node, Image* i
         case Image::RGBA:
             pixelSize = 4;
             break;
-		default:
-			LOG_ERROR("Unsupported pixel format for heightmap image.");
-			return NULL;
+        default:
+            LOG_ERROR("Unsupported pixel format for heightmap image.");
+            return NULL;
     }
 
     // Calculate the heights for each pixel.
     float* heights = new float[image->getWidth() * image->getHeight()];
-	unsigned char* data = image->getData();
+    unsigned char* data = image->getData();
     for (unsigned int x = 0, w = image->getWidth(); x < w; ++x)
     {
         for (unsigned int y = 0, h = image->getHeight(); y < h; ++y)
@@ -777,16 +777,16 @@ PhysicsCollisionShape* PhysicsController::createHeightfield(Node* node, Image* i
         }
     }
 
-	PhysicsCollisionShape::HeightfieldData* heightfieldData = new PhysicsCollisionShape::HeightfieldData();
-	heightfieldData->heightData = NULL;
-	heightfieldData->inverseIsDirty = true;
+    PhysicsCollisionShape::HeightfieldData* heightfieldData = new PhysicsCollisionShape::HeightfieldData();
+    heightfieldData->heightData = NULL;
+    heightfieldData->inverseIsDirty = true;
 
     // Generate the heightmap data needed for physics (one height per world unit).
     unsigned int sizeWidth = width;
     unsigned int sizeHeight = length;
-	heightfieldData->width = sizeWidth + 1;
+    heightfieldData->width = sizeWidth + 1;
     heightfieldData->height = sizeHeight + 1;
-	heightfieldData->heightData = new float[heightfieldData->width * heightfieldData->height];
+    heightfieldData->heightData = new float[heightfieldData->width * heightfieldData->height];
     unsigned int heightIndex = 0;
     float widthImageFactor = (float)(image->getWidth() - 1) / sizeWidth;
     float heightImageFactor = (float)(image->getHeight() - 1) / sizeHeight;
@@ -796,8 +796,8 @@ PhysicsCollisionShape* PhysicsController::createHeightfield(Node* node, Image* i
     {
         for (unsigned int col = 0, x = 0.0f; col <= sizeWidth; col++, x += 1.0f)
         {
-			heightIndex = row * heightfieldData->width + col;
-			heightfieldData->heightData[heightIndex] = calculateHeight(heights, image->getWidth(), image->getHeight(), x * widthImageFactor, (sizeHeight - z) * heightImageFactor);
+            heightIndex = row * heightfieldData->width + col;
+            heightfieldData->heightData[heightIndex] = calculateHeight(heights, image->getWidth(), image->getHeight(), x * widthImageFactor, (sizeHeight - z) * heightImageFactor);
         }
     }
     SAFE_DELETE_ARRAY(heights);
@@ -806,15 +806,15 @@ PhysicsCollisionShape* PhysicsController::createHeightfield(Node* node, Image* i
     // of its heightfield collision shape; see documentation for the btHeightfieldTerrainShape for more info.
     Vector3 s;
     node->getWorldMatrix().getScale(&s);
-	centerOfMassOffset->set(0.0f, -(maxHeight - (0.5f * (maxHeight - minHeight))) / s.y, 0.0f);
+    centerOfMassOffset->set(0.0f, -(maxHeight - (0.5f * (maxHeight - minHeight))) / s.y, 0.0f);
 
-	// Create the bullet terrain shape
-	btHeightfieldTerrainShape* terrainShape = bullet_new<btHeightfieldTerrainShape>(
-		heightfieldData->width, heightfieldData->height, heightfieldData->heightData, 1.0f, minHeight, maxHeight, 1, PHY_FLOAT, false);
+    // Create the bullet terrain shape
+    btHeightfieldTerrainShape* terrainShape = bullet_new<btHeightfieldTerrainShape>(
+        heightfieldData->width, heightfieldData->height, heightfieldData->heightData, 1.0f, minHeight, maxHeight, 1, PHY_FLOAT, false);
 
-	// Create our collision shape object and store heightfieldData in it
-	PhysicsCollisionShape* shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_HEIGHTFIELD, terrainShape);
-	shape->_shapeData.heightfieldData = heightfieldData;
+    // Create our collision shape object and store heightfieldData in it
+    PhysicsCollisionShape* shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_HEIGHTFIELD, terrainShape);
+    shape->_shapeData.heightfieldData = heightfieldData;
 
     _shapes.push_back(shape);
 
@@ -825,29 +825,29 @@ PhysicsCollisionShape* PhysicsController::createMesh(Mesh* mesh, const Vector3&
 {
     assert(mesh);
 
-	// Only support meshes with triangle list primitive types
-	bool triMesh = true;
-	if (mesh->getPartCount() > 0)
-	{
-		for (unsigned int i = 0; i < mesh->getPartCount(); ++i)
-		{
-			if (mesh->getPart(i)->getPrimitiveType() != Mesh::TRIANGLES)
-			{
-				triMesh = false;
-				break;
-			}
-		}
-	}
-	else
-	{
-		triMesh = mesh->getPrimitiveType() == Mesh::TRIANGLES;
-	}
-
-	if (!triMesh)
-	{
-		LOG_ERROR("Mesh rigid bodies are currently only supported on meshes with TRIANGLES primitive type.");
-		return NULL;
-	}
+    // Only support meshes with triangle list primitive types
+    bool triMesh = true;
+    if (mesh->getPartCount() > 0)
+    {
+        for (unsigned int i = 0; i < mesh->getPartCount(); ++i)
+        {
+            if (mesh->getPart(i)->getPrimitiveType() != Mesh::TRIANGLES)
+            {
+                triMesh = false;
+                break;
+            }
+        }
+    }
+    else
+    {
+        triMesh = mesh->getPrimitiveType() == Mesh::TRIANGLES;
+    }
+
+    if (!triMesh)
+    {
+        LOG_ERROR("Mesh rigid bodies are currently only supported on meshes with TRIANGLES primitive type.");
+        return NULL;
+    }
 
     // The mesh must have a valid URL (i.e. it must have been loaded from a Package)
     // in order to fetch mesh data for computing mesh rigid body.
@@ -863,15 +863,15 @@ PhysicsCollisionShape* PhysicsController::createMesh(Mesh* mesh, const Vector3&
         return NULL;
     }
 
-	// Create mesh data to be populated and store in returned collision shape
-	PhysicsCollisionShape::MeshData* shapeMeshData = new PhysicsCollisionShape::MeshData();
-	shapeMeshData->vertexData = NULL;
+    // Create mesh data to be populated and store in returned collision shape
+    PhysicsCollisionShape::MeshData* shapeMeshData = new PhysicsCollisionShape::MeshData();
+    shapeMeshData->vertexData = NULL;
 
     // Copy the scaled vertex position data to the rigid body's local buffer.
     Matrix m;
     Matrix::createScale(scale, &m);
     unsigned int vertexCount = data->vertexCount;
-	shapeMeshData->vertexData = new float[vertexCount * 3];
+    shapeMeshData->vertexData = new float[vertexCount * 3];
     Vector3 v;
     int vertexStride = data->vertexFormat.getVertexSize();
     for (unsigned int i = 0; i < data->vertexCount; i++)
@@ -880,7 +880,7 @@ PhysicsCollisionShape* PhysicsController::createMesh(Mesh* mesh, const Vector3&
               *((float*)&data->vertexData[i * vertexStride + 1 * sizeof(float)]),
               *((float*)&data->vertexData[i * vertexStride + 2 * sizeof(float)]));
         v *= m;
-		memcpy(&(shapeMeshData->vertexData[i * 3]), &v, sizeof(float) * 3);
+        memcpy(&(shapeMeshData->vertexData[i * 3]), &v, sizeof(float) * 3);
     }
 
     btTriangleIndexVertexArray* meshInterface = bullet_new<btTriangleIndexVertexArray>();
@@ -913,7 +913,7 @@ PhysicsCollisionShape* PhysicsController::createMesh(Mesh* mesh, const Vector3&
 
             // Move the index data into the rigid body's local buffer.
             // Set it to NULL in the MeshPartData so it is not released when the data is freed.
-			shapeMeshData->indexData.push_back(meshPart->indexData);
+            shapeMeshData->indexData.push_back(meshPart->indexData);
             meshPart->indexData = NULL;
 
             // Create a btIndexedMesh object for the current mesh part.
@@ -921,9 +921,9 @@ PhysicsCollisionShape* PhysicsController::createMesh(Mesh* mesh, const Vector3&
             indexedMesh.m_indexType = indexType;
             indexedMesh.m_numTriangles = meshPart->indexCount / 3; // assume TRIANGLES primitive type
             indexedMesh.m_numVertices = meshPart->indexCount;
-			indexedMesh.m_triangleIndexBase = (const unsigned char*)shapeMeshData->indexData[i];
+            indexedMesh.m_triangleIndexBase = (const unsigned char*)shapeMeshData->indexData[i];
             indexedMesh.m_triangleIndexStride = indexStride*3;
-			indexedMesh.m_vertexBase = (const unsigned char*)shapeMeshData->vertexData;
+            indexedMesh.m_vertexBase = (const unsigned char*)shapeMeshData->vertexData;
             indexedMesh.m_vertexStride = sizeof(float)*3;
             indexedMesh.m_vertexType = PHY_FLOAT;
 
@@ -956,9 +956,9 @@ PhysicsCollisionShape* PhysicsController::createMesh(Mesh* mesh, const Vector3&
         meshInterface->addIndexedMesh(indexedMesh, indexedMesh.m_indexType);
     }
 
-	// Create our collision shape object and store shapeMeshData in it
-	PhysicsCollisionShape* shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_MESH, bullet_new<btBvhTriangleMeshShape>(meshInterface, true));
-	shape->_shapeData.meshData = shapeMeshData;
+    // Create our collision shape object and store shapeMeshData in it
+    PhysicsCollisionShape* shape = new PhysicsCollisionShape(PhysicsCollisionShape::SHAPE_MESH, bullet_new<btBvhTriangleMeshShape>(meshInterface, true));
+    shape->_shapeData.meshData = shapeMeshData;
 
     _shapes.push_back(shape);
 
@@ -974,14 +974,14 @@ void PhysicsController::destroyShape(PhysicsCollisionShape* shape)
     {
         if (shape->getRefCount() == 1)
         {
-			// Remove shape from shape cache
+            // Remove shape from shape cache
             std::vector<PhysicsCollisionShape*>::iterator shapeItr = std::find(_shapes.begin(), _shapes.end(), shape);
             if (shapeItr != _shapes.end())
                 _shapes.erase(shapeItr);
         }
 
-		// Release the shape
-		shape->release();
+        // Release the shape
+        shape->release();
     }
 }
 
@@ -1169,7 +1169,7 @@ void PhysicsController::DebugDrawer::setDebugMode(int mode)
     _mode = mode;
 }
 
-int	PhysicsController::DebugDrawer::getDebugMode() const
+int PhysicsController::DebugDrawer::getDebugMode() const
 {
     return _mode;
 }

gameplay/src/PhysicsController.h

@@ -229,7 +229,7 @@ private:
         int _status;
     };
 
-	/**
+    /**
      * Constructor.
      */
     PhysicsController();
@@ -279,30 +279,30 @@ private:
     // Gets the corresponding GamePlay object for the given Bullet object.
     PhysicsCollisionObject* getCollisionObject(const btCollisionObject* collisionObject) const;
 
-	// Creates a collision shape for the given node and gameplay shape definition.
-	// Populates 'centerOfMassOffset' with the correct calculated center of mass offset.
-	PhysicsCollisionShape* createShape(Node* node, const PhysicsCollisionShape::Definition& shape, Vector3* centerOfMassOffset);
+    // Creates a collision shape for the given node and gameplay shape definition.
+    // Populates 'centerOfMassOffset' with the correct calculated center of mass offset.
+    PhysicsCollisionShape* createShape(Node* node, const PhysicsCollisionShape::Definition& shape, Vector3* centerOfMassOffset);
     
     // Creates a box collision shape.
     PhysicsCollisionShape* createBox(const Vector3& extents, const Vector3& scale);
 
-	// Creates a sphere collision shape.
+    // Creates a sphere collision shape.
     PhysicsCollisionShape* createSphere(float radius, const Vector3& scale);
 
     // Creates a capsule collision shape.
     PhysicsCollisionShape* createCapsule(float radius, float height, const Vector3& scale);
 
-	// Creates a heightfield collision shape.
+    // Creates a heightfield collision shape.
     PhysicsCollisionShape* createHeightfield(Node* node, Image* image, Vector3* centerOfMassOffset);
 
     // Creates a triangle mesh collision shape.
     PhysicsCollisionShape* createMesh(Mesh* mesh, const Vector3& scale);
 
-	// Destroys a collision shape created through PhysicsController
-	void destroyShape(PhysicsCollisionShape* shape);
+    // Destroys a collision shape created through PhysicsController
+    void destroyShape(PhysicsCollisionShape* shape);
 
-	// Helper function for calculating heights from heightmap (image) or heightfield data.
-	static float calculateHeight(float* data, unsigned int width, unsigned int height, float x, float y);
+    // Helper function for calculating heights from heightmap (image) or heightfield data.
+    static float calculateHeight(float* data, unsigned int width, unsigned int height, float x, float y);
 
     // Sets up the given constraint for the given two rigid bodies.
     void addConstraint(PhysicsRigidBody* a, PhysicsRigidBody* b, PhysicsConstraint* constraint);
@@ -337,7 +337,7 @@ private:
         void reportErrorWarning(const char* warningString);
         void draw3dText(const btVector3& location, const char* textString);        
         void setDebugMode(int mode);        
-        int	getDebugMode() const;
+        int    getDebugMode() const;
         
     private:
         

gameplay/src/PhysicsGhostObject.cpp

@@ -17,7 +17,7 @@ PhysicsGhostObject::PhysicsGhostObject(Node* node, const PhysicsCollisionShape::
 
     // Create the ghost object.
     _ghostObject = bullet_new<btPairCachingGhostObject>();
-	_ghostObject->setCollisionShape(_collisionShape->getShape());
+    _ghostObject->setCollisionShape(_collisionShape->getShape());
 
     // Initialize a physics motion state object for syncing the transform.
     _motionState = new PhysicsMotionState(_node, &centerOfMassOffset);

gameplay/src/PhysicsMotionState.cpp

@@ -23,7 +23,7 @@ PhysicsMotionState::~PhysicsMotionState()
 
 void PhysicsMotionState::getWorldTransform(btTransform &transform) const
 {
-	if (_node->getCollisionObject() && _node->getCollisionObject()->isKinematic())
+    if (_node->getCollisionObject() && _node->getCollisionObject()->isKinematic())
         updateTransformFromNode();
 
     transform = _centerOfMassOffset.inverse() * _worldTransform;

gameplay/src/PhysicsMotionState.h

@@ -15,10 +15,10 @@ class Node;
  */
 class PhysicsMotionState : public btMotionState
 {
-	friend class PhysicsCollisionObject;
-	friend class PhysicsRigidBody;
-	friend class PhysicsGhostObject;
-	friend class PhysicsCharacter;
+    friend class PhysicsCollisionObject;
+    friend class PhysicsRigidBody;
+    friend class PhysicsGhostObject;
+    friend class PhysicsCharacter;
     friend class PhysicsConstraint;
 
 protected:

gameplay/src/PhysicsRigidBody.cpp

@@ -24,8 +24,8 @@ PhysicsRigidBody::PhysicsRigidBody(Node* node, const PhysicsCollisionShape::Defi
     // inertia. However, if the collision shape is a triangle mesh, we don't calculate 
     // inertia since Bullet doesn't currently support this.
     btVector3 localInertia(0.0, 0.0, 0.0);
-	if (parameters.mass != 0.0 && _collisionShape->getType() != PhysicsCollisionShape::SHAPE_MESH)
-		_collisionShape->getShape()->calculateLocalInertia(parameters.mass, localInertia);
+    if (parameters.mass != 0.0 && _collisionShape->getType() != PhysicsCollisionShape::SHAPE_MESH)
+        _collisionShape->getShape()->calculateLocalInertia(parameters.mass, localInertia);
 
     // Create the Bullet physics rigid body object.
     btRigidBody::btRigidBodyConstructionInfo rbInfo(parameters.mass, _motionState, _collisionShape->getShape(), localInertia);

gameplay/src/PhysicsRigidBody.h

@@ -30,75 +30,75 @@ class PhysicsRigidBody : public PhysicsCollisionObject, public Transform::Listen
 
 public:
 
-	/**
-	 * Rigid body construction parameters.
-	 */
-	struct Parameters
-	{
-		/**
-		 * The mass of the rigid body, in kilograms.
-		 */
-		float mass;
-
-		/**
-		 * The friction of the rigid body (non-zero values give best simulation results).
-		 */
-		float friction;
-
-		/**
-		 * The restitution of the rigid body (this controls the bounciness of
-		 * the rigid body; use zero for best simulation results).
-		 */
+    /**
+     * Rigid body construction parameters.
+     */
+    struct Parameters
+    {
+        /**
+         * The mass of the rigid body, in kilograms.
+         */
+        float mass;
+
+        /**
+         * The friction of the rigid body (non-zero values give best simulation results).
+         */
+        float friction;
+
+        /**
+         * The restitution of the rigid body (this controls the bounciness of
+         * the rigid body; use zero for best simulation results).
+         */
         float restitution;
 
-		/**
-		 * The percentage of linear velocity lost per second (between 0.0 and 1.0).
-		 */
-		float linearDamping;
-
-		/**
-		 * The percentage of angular velocity lost per second (between 0.0 and 1.0).
-		 */
-		float angularDamping;
-
-		/**
-		 * Whether the rigid body is kinematic.
-		 */
-		bool kinematic;
-
-		/**
-		 * The ansitropic friction term for the rigid body.
-		 */
-		Vector3 anisotropicFriction;
-
-		/**
-		 * The gravity acceleration factor for the rigid body.
-		 */
-		Vector3 gravity;
-
-		/**
-		 * Constructor.
-		 */
-		Parameters(float mass = 0.0f, float friction = 0.5f, float resititution = 0.0f,
-			float linearDamping = 0.0f, float angularDamping = 0.0f, bool kinematic = false,
-			const Vector3& anisotropicFriction = Vector3::one(), const Vector3& gravity = Vector3::zero())
-			: mass(mass), friction(friction), restitution(restitution), linearDamping(linearDamping), angularDamping(angularDamping),
-			  kinematic(kinematic), anisotropicFriction(anisotropicFriction), gravity(gravity)
-		{
-		}
-	};
+        /**
+         * The percentage of linear velocity lost per second (between 0.0 and 1.0).
+         */
+        float linearDamping;
+
+        /**
+         * The percentage of angular velocity lost per second (between 0.0 and 1.0).
+         */
+        float angularDamping;
+
+        /**
+         * Whether the rigid body is kinematic.
+         */
+        bool kinematic;
+
+        /**
+         * The ansitropic friction term for the rigid body.
+         */
+        Vector3 anisotropicFriction;
+
+        /**
+         * The gravity acceleration factor for the rigid body.
+         */
+        Vector3 gravity;
+
+        /**
+         * Constructor.
+         */
+        Parameters(float mass = 0.0f, float friction = 0.5f, float resititution = 0.0f,
+            float linearDamping = 0.0f, float angularDamping = 0.0f, bool kinematic = false,
+            const Vector3& anisotropicFriction = Vector3::one(), const Vector3& gravity = Vector3::zero())
+            : mass(mass), friction(friction), restitution(restitution), linearDamping(linearDamping), angularDamping(angularDamping),
+              kinematic(kinematic), anisotropicFriction(anisotropicFriction), gravity(gravity)
+        {
+        }
+    };
 
     /**
      * @see PhysicsCollisionObject#getType
      */
     PhysicsCollisionObject::Type getType() const;
 
-	/**
-	 * Gets the rigid body's mass.
-	 *
-	 * @return The mass.
-	 */
-	inline float getMass() const;
+    /**
+     * Gets the rigid body's mass.
+     *
+     * @return The mass.
+     */
+    inline float getMass() const;
 
     /**
      * Gets the rigid body's friction.
@@ -114,12 +114,12 @@ public:
      */
     inline void setFriction(float friction);
 
-	/**
-	 * Gets the rigid body's restitution.
-	 *
-	 * @return The restitution.
-	 */
-	inline float getRestitution() const;
+    /**
+     * Gets the rigid body's restitution.
+     *
+     * @return The restitution.
+     */
+    inline float getRestitution() const;
 
     /**
      * Sets the rigid body's restitution (or bounciness).
@@ -128,19 +128,19 @@ public:
      */
     inline void setRestitution(float restitution);
 
-	/**
-	 * Gets the rigid body's linear damping.
-	 *
-	 * @return The linear damping.
-	 */
-	inline float getLinearDamping() const;
+    /**
+     * Gets the rigid body's linear damping.
+     *
+     * @return The linear damping.
+     */
+    inline float getLinearDamping() const;
 
-	/**
-	 * Gets the rigid body's angular damping.
-	 *
-	 * @return The angular damping.
-	 */
-	inline float getAngularDamping() const;
+    /**
+     * Gets the rigid body's angular damping.
+     *
+     * @return The angular damping.
+     */
+    inline float getAngularDamping() const;
 
     /**
      * Sets the rigid body's linear and angular damping.
@@ -150,7 +150,7 @@ public:
      */
     inline void setDamping(float linearDamping, float angularDamping);
 
-	/**
+    /**
      * Gets the rigid body's linear velocity.
      * 
      * @return The linear velocity.
@@ -277,7 +277,7 @@ private:
      * @param shape The rigid body shape construction information.
      * @param parameters The rigid body construction parameters.
      */
-	PhysicsRigidBody(Node* node, const PhysicsCollisionShape::Definition& shape, const Parameters& parameters);
+    PhysicsRigidBody(Node* node, const PhysicsCollisionShape::Definition& shape, const Parameters& parameters);
 
     /**
      * Destructor.
@@ -312,8 +312,8 @@ private:
     void transformChanged(Transform* transform, long cookie);
 
     btRigidBody* _body;
-	float _mass;
-	std::vector<PhysicsConstraint*>* _constraints;
+    float _mass;
+    std::vector<PhysicsConstraint*>* _constraints;
 
 };
 

gameplay/src/PhysicsRigidBody.inl

@@ -6,7 +6,7 @@ namespace gameplay
 
 inline float PhysicsRigidBody::getMass() const
 {
-	return _mass;
+    return _mass;
 }
 
 inline float PhysicsRigidBody::getFriction() const
@@ -47,7 +47,7 @@ inline void PhysicsRigidBody::setDamping(float linearDamping, float angularDampi
 inline Vector3 PhysicsRigidBody::getLinearVelocity() const
 {
     const btVector3& v = _body->getLinearVelocity();
-	return Vector3(v.x(), v.y(), v.z());
+    return Vector3(v.x(), v.y(), v.z());
 }
 
 inline void PhysicsRigidBody::setLinearVelocity(const Vector3& velocity)

gameplay/src/PlatformQNX.cpp

@@ -573,70 +573,70 @@ Platform* Platform::create(Game* game)
         goto error;
     }
 
-	screen_display_t screen_display;
+    screen_display_t screen_display;
     rc = screen_get_window_property_pv(__screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
     if (rc)
     {
-    	perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
-    	goto error;
+        perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
+        goto error;
     }
 
-	screen_display_mode_t screen_mode;
-	rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
-	if (rc)
-	{
-		perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
-		goto error;
-	}
+    screen_display_mode_t screen_mode;
+    rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
+    if (rc)
+    {
+        perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
+        goto error;
+    }
 
     int size[2];
-	rc = screen_get_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
-	if (rc)
-	{
-		perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
-		goto error;
-	}
-
-	__screenWindowSize[0] = size[0];
-	__screenWindowSize[1] = size[1];
-
-	if ((angle == 0) || (angle == 180))
-	{
-		if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
-			((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
-		{
-			__screenWindowSize[1] = size[0];
-			__screenWindowSize[0] = size[1];
-		}
-	}
-	else if ((angle == 90) || (angle == 270))
-	{
-		if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
-			((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
-		{
-			__screenWindowSize[1] = size[0];
-			__screenWindowSize[0] = size[1];
-		}
-	}
-	else
-	{
-		perror("Navigator returned an unexpected orientation angle.");
-		goto error;
-	}
-
-	rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, __screenWindowSize);
-	if (rc)
-	{
-		perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
-		goto error;
-	}
-
-	rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_ROTATION, &angle);
-	if (rc)
-	{
-		perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
-		goto error;
-	}
+    rc = screen_get_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
+    if (rc)
+    {
+        perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
+        goto error;
+    }
+
+    __screenWindowSize[0] = size[0];
+    __screenWindowSize[1] = size[1];
+
+    if ((angle == 0) || (angle == 180))
+    {
+        if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
+            ((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
+        {
+            __screenWindowSize[1] = size[0];
+            __screenWindowSize[0] = size[1];
+        }
+    }
+    else if ((angle == 90) || (angle == 270))
+    {
+        if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
+            ((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
+        {
+            __screenWindowSize[1] = size[0];
+            __screenWindowSize[0] = size[1];
+        }
+    }
+    else
+    {
+        perror("Navigator returned an unexpected orientation angle.");
+        goto error;
+    }
+
+    rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, __screenWindowSize);
+    if (rc)
+    {
+        perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
+        goto error;
+    }
+
+    rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_ROTATION, &angle);
+    if (rc)
+    {
+        perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
+        goto error;
+    }
 
     if (windowPosition[0] != 0 || windowPosition[1] != 0)
     {

gameplay/src/PlatformWin32.cpp

@@ -290,7 +290,7 @@ LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
     case WM_LBUTTONDOWN:
         if (!gameplay::Game::getInstance()->mouseEvent(gameplay::Mouse::MOUSE_PRESS_LEFT_BUTTON, LOWORD(lParam), HIWORD(lParam), 0))
         {
-	        gameplay::Platform::touchEventInternal(gameplay::Touch::TOUCH_PRESS, LOWORD(lParam), HIWORD(lParam), 0);
+            gameplay::Platform::touchEventInternal(gameplay::Touch::TOUCH_PRESS, LOWORD(lParam), HIWORD(lParam), 0);
         }
         lMouseDown = true;
         return 0;
@@ -299,7 +299,7 @@ LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         lMouseDown = false;
         if (!gameplay::Game::getInstance()->mouseEvent(gameplay::Mouse::MOUSE_RELEASE_LEFT_BUTTON, LOWORD(lParam), HIWORD(lParam), 0))
         {
-	        gameplay::Platform::touchEventInternal(gameplay::Touch::TOUCH_RELEASE, LOWORD(lParam), HIWORD(lParam), 0);
+            gameplay::Platform::touchEventInternal(gameplay::Touch::TOUCH_RELEASE, LOWORD(lParam), HIWORD(lParam), 0);
         }
         return 0;
 
@@ -380,7 +380,7 @@ LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
         // Suppress key repeats
         if ((lParam & 0x40000000) == 0)
-	        gameplay::Platform::keyEventInternal(gameplay::Keyboard::KEY_PRESS, getKey(wParam, shiftDown ^ capsOn));
+            gameplay::Platform::keyEventInternal(gameplay::Keyboard::KEY_PRESS, getKey(wParam, shiftDown ^ capsOn));
         break;
         
     case WM_KEYUP:

gameplay/src/Scene.cpp

@@ -282,38 +282,38 @@ void Scene::setAmbientColor(float red, float green, float blue)
 
 Material* createDebugMaterial()
 {
-	// Vertex shader for drawing colored lines.
-	const char* vs_str = 
-	{
-		"uniform mat4 u_viewProjectionMatrix;\n"
-		"attribute vec4 a_position;\n"
-		"attribute vec4 a_color;\n"
-		"varying vec4 v_color;\n"
-		"void main(void) {\n"
-		"    v_color = a_color;\n"
-		"    gl_Position = u_viewProjectionMatrix * a_position;\n"
-		"}"
-	};
-
-	// Fragment shader for drawing colored lines.
-	const char* fs_str = 
-	{
-	#ifdef OPENGL_ES
-		"precision highp float;\n"
-	#endif
-		"varying vec4 v_color;\n"
-		"void main(void) {\n"
-		"   gl_FragColor = v_color;\n"
-		"}"
-	};
-
-	Effect* effect = Effect::createFromSource(vs_str, fs_str);
-	Material* material = Material::create(effect);
-	material->getStateBlock()->setDepthTest(true);
-
-	SAFE_RELEASE(effect);
-
-	return material;
+    // Vertex shader for drawing colored lines.
+    const char* vs_str = 
+    {
+        "uniform mat4 u_viewProjectionMatrix;\n"
+        "attribute vec4 a_position;\n"
+        "attribute vec4 a_color;\n"
+        "varying vec4 v_color;\n"
+        "void main(void) {\n"
+        "    v_color = a_color;\n"
+        "    gl_Position = u_viewProjectionMatrix * a_position;\n"
+        "}"
+    };
+
+    // Fragment shader for drawing colored lines.
+    const char* fs_str = 
+    {
+    #ifdef OPENGL_ES
+        "precision highp float;\n"
+    #endif
+        "varying vec4 v_color;\n"
+        "void main(void) {\n"
+        "   gl_FragColor = v_color;\n"
+        "}"
+    };
+
+    Effect* effect = Effect::createFromSource(vs_str, fs_str);
+    Material* material = Material::create(effect);
+    material->getStateBlock()->setDepthTest(true);
+
+    SAFE_RELEASE(effect);
+
+    return material;
 }
 
 struct DebugVertex
@@ -329,7 +329,7 @@ void drawDebugLine(MeshBatch* batch, const Vector3& point1, const Vector3& point
     verts[0].x = point1.x;
     verts[0].y = point1.y;
     verts[0].z = point1.z;
-	verts[0].r = color.x;
+    verts[0].r = color.x;
     verts[0].g = color.y;
     verts[0].b = color.z;
     verts[0].a = 1.0f;
@@ -342,7 +342,7 @@ void drawDebugLine(MeshBatch* batch, const Vector3& point1, const Vector3& point
     verts[1].b = color.z;
     verts[1].a = 1.0f;
 
-	batch->add(verts, 2);
+    batch->add(verts, 2);
 }
 
 #define DEBUG_BOX_COLOR Vector3(0, 1, 0)
@@ -350,141 +350,141 @@ void drawDebugLine(MeshBatch* batch, const Vector3& point1, const Vector3& point
 
 void drawDebugBox(MeshBatch* batch, const BoundingBox& box, const Matrix& matrix)
 {
-	// Transform box into world space (since we only store local boxes on mesh)
-	BoundingBox worldSpaceBox(box);
-	worldSpaceBox.transform(matrix);
+    // Transform box into world space (since we only store local boxes on mesh)
+    BoundingBox worldSpaceBox(box);
+    worldSpaceBox.transform(matrix);
 
-	// Get box corners
+    // Get box corners
     static Vector3 corners[8];
     worldSpaceBox.getCorners(corners);
 
-	// Draw box lines
-	drawDebugLine(batch, corners[0], corners[1], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[1], corners[2], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[2], corners[3], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[3], corners[0], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[4], corners[5], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[5], corners[6], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[6], corners[7], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[7], corners[4], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[0], corners[7], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[1], corners[6], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[2], corners[5], DEBUG_BOX_COLOR);
-	drawDebugLine(batch, corners[3], corners[4], DEBUG_BOX_COLOR);
+    // Draw box lines
+    drawDebugLine(batch, corners[0], corners[1], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[1], corners[2], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[2], corners[3], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[3], corners[0], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[4], corners[5], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[5], corners[6], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[6], corners[7], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[7], corners[4], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[0], corners[7], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[1], corners[6], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[2], corners[5], DEBUG_BOX_COLOR);
+    drawDebugLine(batch, corners[3], corners[4], DEBUG_BOX_COLOR);
 }
 
 void drawDebugSphere(MeshBatch* batch, const BoundingSphere& sphere)
 {
-	// Draw three rings for the sphere (one for the x, y and z axes)
-	Vector3 pos1, pos2;
-	float step = MATH_PI * 0.2f;
-	float max = MATH_PIX2 + step;
-
-	// X ring
-	for (float r = 0.0f; r < max; r += step)
-	{
-		pos2.x = sphere.center.x;
-		pos2.y = sphere.center.y + std::cos(r) * sphere.radius;
-		pos2.z = sphere.center.z + std::sin(r) * sphere.radius;
-
-		if (r > 0)
-			drawDebugLine(batch, pos1, pos2, DEBUG_SPHERE_COLOR);
-
-		pos1 = pos2;
-	}
-
-	// Y ring
-	for (float r = 0.0f; r < max; r += step)
-	{
-		pos2.x = sphere.center.x + std::cos(r) * sphere.radius;
-		pos2.y = sphere.center.y;
-		pos2.z = sphere.center.z + std::sin(r) * sphere.radius;
-
-		if (r > 0)
-			drawDebugLine(batch, pos1, pos2, DEBUG_SPHERE_COLOR);
-
-		pos1 = pos2;
-	}
-
-	// Z ring
-	for (float r = 0.0f; r < max; r += step)
-	{
-		pos2.x = sphere.center.x + std::cos(r) * sphere.radius;
-		pos2.y = sphere.center.y + std::sin(r) * sphere.radius;
-		pos2.z = sphere.center.z;
-
-		if (r > 0)
-			drawDebugLine(batch, pos1, pos2, DEBUG_SPHERE_COLOR);
-
-		pos1 = pos2;
-	}
+    // Draw three rings for the sphere (one for the x, y and z axes)
+    Vector3 pos1, pos2;
+    float step = MATH_PI * 0.2f;
+    float max = MATH_PIX2 + step;
+
+    // X ring
+    for (float r = 0.0f; r < max; r += step)
+    {
+        pos2.x = sphere.center.x;
+        pos2.y = sphere.center.y + std::cos(r) * sphere.radius;
+        pos2.z = sphere.center.z + std::sin(r) * sphere.radius;
+
+        if (r > 0)
+            drawDebugLine(batch, pos1, pos2, DEBUG_SPHERE_COLOR);
+
+        pos1 = pos2;
+    }
+
+    // Y ring
+    for (float r = 0.0f; r < max; r += step)
+    {
+        pos2.x = sphere.center.x + std::cos(r) * sphere.radius;
+        pos2.y = sphere.center.y;
+        pos2.z = sphere.center.z + std::sin(r) * sphere.radius;
+
+        if (r > 0)
+            drawDebugLine(batch, pos1, pos2, DEBUG_SPHERE_COLOR);
+
+        pos1 = pos2;
+    }
+
+    // Z ring
+    for (float r = 0.0f; r < max; r += step)
+    {
+        pos2.x = sphere.center.x + std::cos(r) * sphere.radius;
+        pos2.y = sphere.center.y + std::sin(r) * sphere.radius;
+        pos2.z = sphere.center.z;
+
+        if (r > 0)
+            drawDebugLine(batch, pos1, pos2, DEBUG_SPHERE_COLOR);
+
+        pos1 = pos2;
+    }
 }
 
 void drawDebugNode(MeshBatch* batch, Node* node, unsigned int debugFlags)
 {
-	Model* model = node->getModel();
-
-	if ((debugFlags & Scene::DEBUG_BOXES) && model)
-	{
-		MeshSkin* skin = model->getSkin();
-		if (skin && skin->getRootJoint()->getParent())
-		{
-			// For skinned meshes that have a parent node to the skin's root joint,
-			// we need to transform the bounding volume by that parent node's transform
-			// as well to get the full skinned bounding volume.
-			drawDebugBox(batch, model->getMesh()->getBoundingBox(), node->getWorldMatrix() * skin->getRootJoint()->getParent()->getWorldMatrix());
-		}
-		else
-		{
-			drawDebugBox(batch, model->getMesh()->getBoundingBox(), node->getWorldMatrix());
-		}
-	}
-
-	if ((debugFlags & Scene::DEBUG_SPHERES) && model)
-	{
-		drawDebugSphere(batch, node->getBoundingSphere());
-	}
-
-	Node* child = node->getFirstChild();
-	while (child)
-	{
-		drawDebugNode(batch, child, debugFlags);
-		child = child->getNextSibling();
-	}
+    Model* model = node->getModel();
+
+    if ((debugFlags & Scene::DEBUG_BOXES) && model)
+    {
+        MeshSkin* skin = model->getSkin();
+        if (skin && skin->getRootJoint()->getParent())
+        {
+            // For skinned meshes that have a parent node to the skin's root joint,
+            // we need to transform the bounding volume by that parent node's transform
+            // as well to get the full skinned bounding volume.
+            drawDebugBox(batch, model->getMesh()->getBoundingBox(), node->getWorldMatrix() * skin->getRootJoint()->getParent()->getWorldMatrix());
+        }
+        else
+        {
+            drawDebugBox(batch, model->getMesh()->getBoundingBox(), node->getWorldMatrix());
+        }
+    }
+
+    if ((debugFlags & Scene::DEBUG_SPHERES) && model)
+    {
+        drawDebugSphere(batch, node->getBoundingSphere());
+    }
+
+    Node* child = node->getFirstChild();
+    while (child)
+    {
+        drawDebugNode(batch, child, debugFlags);
+        child = child->getNextSibling();
+    }
 }
 
 void Scene::drawDebug(unsigned int debugFlags)
 {
-	if (_debugBatch == NULL)
-	{
-		Material* material = createDebugMaterial();
+    if (_debugBatch == NULL)
+    {
+        Material* material = createDebugMaterial();
 
-		VertexFormat::Element elements[] =
-		{
-			VertexFormat::Element(VertexFormat::POSITION, 3),
-			VertexFormat::Element(VertexFormat::COLOR, 4)
-		};
+        VertexFormat::Element elements[] =
+        {
+            VertexFormat::Element(VertexFormat::POSITION, 3),
+            VertexFormat::Element(VertexFormat::COLOR, 4)
+        };
 
-		_debugBatch = MeshBatch::create(VertexFormat(elements, 2), Mesh::LINES, material, false);
+        _debugBatch = MeshBatch::create(VertexFormat(elements, 2), Mesh::LINES, material, false);
 
-		SAFE_RELEASE(material);
-	}
+        SAFE_RELEASE(material);
+    }
 
-	_debugBatch->begin();
+    _debugBatch->begin();
 
-	Node* node = _firstNode;
-	while (node)
-	{
-		drawDebugNode(_debugBatch, node, debugFlags);
-		node = node->_nextSibling;
-	}
+    Node* node = _firstNode;
+    while (node)
+    {
+        drawDebugNode(_debugBatch, node, debugFlags);
+        node = node->_nextSibling;
+    }
 
-	_debugBatch->end();
+    _debugBatch->end();
 
-	if (_activeCamera)
-		_debugBatch->getMaterial()->getParameter("u_viewProjectionMatrix")->setValue(_activeCamera->getViewProjectionMatrix());
+    if (_activeCamera)
+        _debugBatch->getMaterial()->getParameter("u_viewProjectionMatrix")->setValue(_activeCamera->getViewProjectionMatrix());
 
-	_debugBatch->draw();
+    _debugBatch->draw();
 }
 
 }

gameplay/src/Scene.h

@@ -14,14 +14,14 @@ class Scene : public Ref
 {
 public:
 
-	/**
-	 * Enumeration of supported scene debug flags for debug drawing.
-	 */
-	enum DebugFlags
-	{
-		DEBUG_BOXES = 1,
-		DEBUG_SPHERES = 2
-	};
+    /**
+     * Enumeration of supported scene debug flags for debug drawing.
+     */
+    enum DebugFlags
+    {
+        DEBUG_BOXES = 1,
+        DEBUG_SPHERES = 2
+    };
 
     /**
      * Creates a new empty scene.
@@ -176,13 +176,13 @@ public:
     template <class T>
     void visit(T* instance, bool (T::*visitMethod)(Node*,void*), void* cookie = 0);
 
-	/**
-	 * Draws debugging information (bounding volumes, etc.) for the scene.
-	 *
-	 * @param debugFlags Bitwise combination of debug flags from mthe DebugFlags 
-	 *		enumeration, specifying which debugging information to draw.
-	 */
-	void drawDebug(unsigned int debugFlags);
+    /**
+     * Draws debugging information (bounding volumes, etc.) for the scene.
+     *
+     * @param debugFlags Bitwise combination of debug flags from mthe DebugFlags 
+     *        enumeration, specifying which debugging information to draw.
+     */
+    void drawDebug(unsigned int debugFlags);
 
 private:
 
@@ -214,7 +214,7 @@ private:
     unsigned int _nodeCount;
     Vector3 _ambientColor;
     bool _bindAudioListenerToCamera;
-	MeshBatch* _debugBatch;
+    MeshBatch* _debugBatch;
 };
 
 template <class T>

gameplay/src/SceneLoader.cpp

@@ -312,22 +312,22 @@ void SceneLoader::applyNodeProperty(SceneNode& sceneNode, Node* node, const Prop
                             Model* model = node->getModel();
                         
                             // Up ref count to prevent node from releasing the model when we swap it.
-						    model->addRef(); 
+                            model->addRef(); 
                         
-						    // Create collision object with new rigidbodymodel set.
+                            // Create collision object with new rigidbodymodel set.
                             node->setModel(modelNode->getModel());
-						    node->setCollisionObject(p);
+                            node->setCollisionObject(p);
 
-						    // Restore original model.
+                            // Restore original model.
                             node->setModel(model);
-						
+                        
                             // Decrement temporarily added reference.
                             model->release();
                         }
                     }
                 }
                 else
-				    node->setCollisionObject(p);
+                    node->setCollisionObject(p);
             }
             break;
         }
@@ -814,12 +814,12 @@ void SceneLoader::loadPhysics(Properties* physics, Scene* scene)
                 WARN_VARG("Node '%s' to be used as 'rigidBodyA' for constraint %s cannot be found.", name, constraint->getId());
                 continue;
             }
-			if (!rbANode->getCollisionObject() || rbANode->getCollisionObject()->getType() != PhysicsCollisionObject::RIGID_BODY)
+            if (!rbANode->getCollisionObject() || rbANode->getCollisionObject()->getType() != PhysicsCollisionObject::RIGID_BODY)
             {
                 WARN_VARG("Node '%s' to be used as 'rigidBodyA' does not have a rigid body.", name);
                 continue;
             }
-			PhysicsRigidBody* rbA = static_cast<PhysicsRigidBody*>(rbANode->getCollisionObject());
+            PhysicsRigidBody* rbA = static_cast<PhysicsRigidBody*>(rbANode->getCollisionObject());
 
             // Attempt to load the second rigid body. If the second rigid body is not
             // specified, that is usually okay (only spring constraints require both and
@@ -835,12 +835,12 @@ void SceneLoader::loadPhysics(Properties* physics, Scene* scene)
                     WARN_VARG("Node '%s' to be used as 'rigidBodyB' for constraint %s cannot be found.", name, constraint->getId());
                     continue;
                 }
-				if (!rbBNode->getCollisionObject() || rbBNode->getCollisionObject()->getType() != PhysicsCollisionObject::RIGID_BODY)
+                if (!rbBNode->getCollisionObject() || rbBNode->getCollisionObject()->getType() != PhysicsCollisionObject::RIGID_BODY)
                 {
                     WARN_VARG("Node '%s' to be used as 'rigidBodyB' does not have a rigid body.", name);
                     continue;
                 }
-				rbB = static_cast<PhysicsRigidBody*>(rbBNode->getCollisionObject());
+                rbB = static_cast<PhysicsRigidBody*>(rbBNode->getCollisionObject());
             }
 
             PhysicsConstraint* physicsConstraint = NULL;

gameplay/src/SceneLoader.h

@@ -16,8 +16,8 @@ namespace gameplay
  * @todo Add support for loading ghost objects and characters for nodes.
  * @todo Add support for explicitly specifying collision shapes for rigid bodies/ghost objects/characters.
  * @todo Consider supporting 'rigidbodymodel' on models/meshes that are not part of the scene to allow
- *		mesh data to be exported from a modelling tool for the sole purpose of representing a physics
- *		rigid body, but not have it get loaded into the scene and rendering context.
+ *        mesh data to be exported from a modelling tool for the sole purpose of representing a physics
+ *        rigid body, but not have it get loaded into the scene and rendering context.
  */
 class SceneLoader
 {

gameplay/src/Texture.cpp

@@ -73,15 +73,15 @@ Texture* Texture::create(const char* path, bool generateMipmaps)
                     texture = create(image, generateMipmaps);
                 SAFE_RELEASE(image);
             }
-			else if (tolower(ext[1]) == 'p' && tolower(ext[2]) == 'v' && tolower(ext[3]) == 'r')
-			{
+            else if (tolower(ext[1]) == 'p' && tolower(ext[2]) == 'v' && tolower(ext[3]) == 'r')
+            {
 #ifdef OPENGL_ES_PVR
-            	// PowerVR Compressed RGBA
-				texture = createCompressedPVR(path);
+                // PowerVR Compressed RGBA
+                texture = createCompressedPVR(path);
 #else
                 texture = NULL; // Cannot handle PVR if not supported on platform
 #endif
-			}
+            }
             break;
         }
     }
@@ -150,134 +150,134 @@ Texture* Texture::create(Format format, unsigned int width, unsigned int height,
 #ifdef OPENGL_ES_PVR
 Texture* Texture::createCompressedPVR(const char* path)
 {
-	char PVRTexIdentifier[] = "PVR!";
-
-	enum
-	{
-	    PVRTextureFlagTypePVRTC_2 = 24,
-	    PVRTextureFlagTypePVRTC_4
-	};
-
-	struct pvr_file_header
-	{
-		unsigned int size;          		// size of the structure
-		unsigned int height;              	// height of surface to be created
-		unsigned int width;               	// width of input surface
-		unsigned int mipmapCount;         	// number of mip-map levels requested
-		unsigned int formatflags;           // pixel format flags
-		unsigned int dataSize;     			// total size in bytes
-		unsigned int bpp;            		// number of bits per pixel
-		unsigned int redBitMask;            // mask for red bit
-		unsigned int greenBitMask;          // mask for green bits
-		unsigned int blueBitMask;           // mask for blue bits
-		unsigned int alphaBitMask;        	// mask for alpha channel
-		unsigned int pvrTag;                // magic number identifying pvr file
-		unsigned int surfaceCount;          // number of surfaces present in the pvr
-	} ;
-
-	FILE* file = FileSystem::openFile(path, "rb");
-	if (file == NULL)
-	{
-		LOG_ERROR_VARG("Failed to load file: %s", path);
-		return NULL;
-	}
-
-	// Read the file header
-	unsigned int size = sizeof(pvr_file_header);
-	pvr_file_header header;
-	unsigned int read = (int)fread(&header, 1, size, file);
-	assert(read == size);
-	if (read != size)
-	{
-		LOG_ERROR_VARG("Read file header error for pvr file: %s (%d < %d)", path, (int)read, (int)size);
-		fclose(file);
-		return NULL;
-	}
-
-	// Proper file header identifier
-	if (PVRTexIdentifier[0] != (char)((header.pvrTag >>  0) & 0xff) ||
-		PVRTexIdentifier[1] != (char)((header.pvrTag >>  8) & 0xff) ||
-	    PVRTexIdentifier[2] != (char)((header.pvrTag >> 16) & 0xff) ||
-	    PVRTexIdentifier[3] != (char)((header.pvrTag >> 24) & 0xff))
-	 {
-		LOG_ERROR_VARG("Invalid PVR texture file: %s", path);
-		fclose(file);
-	    return NULL;
-	}
-
-	// Format flags for GLenum format
-	GLenum format;
-	unsigned int formatFlags = header.formatflags & 0xff;
-	if (formatFlags == PVRTextureFlagTypePVRTC_4)
-	{
-		format = header.alphaBitMask ? COMPRESSED_RGBA_PVRTC_4BPP : COMPRESSED_RGB_PVRTC_4BPP;
-	}
-	else if (formatFlags == PVRTextureFlagTypePVRTC_2)
-	{
-		format = header.alphaBitMask ? COMPRESSED_RGBA_PVRTC_2BPP : COMPRESSED_RGB_PVRTC_2BPP;
-	}
-	else
-	{
-		LOG_ERROR_VARG("Invalid PVR texture format flags for file: %s", path);
-		fclose(file);
-		return NULL;
-	}
-
-	unsigned char* data = new unsigned char[header.dataSize];
-	read = (int)fread(data, 1, header.dataSize, file);
-	assert(read == header.dataSize);
-	if (read != header.dataSize)
-	{
-		LOG_ERROR_VARG("Read file data error for pvr file: %s (%d < %d)", path, (int)read, (int)header.dataSize);
-		SAFE_DELETE_ARRAY(data);
-		fclose(file);
-		return NULL;
-	}
-	// Close file
-	fclose(file);
-
-	// Load our texture.
-	GLuint textureId;
-	GL_ASSERT( glGenTextures(1, &textureId) );
-	GL_ASSERT( glBindTexture(GL_TEXTURE_2D, textureId) );
-	GL_ASSERT( glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, header.mipmapCount > 0 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR ) );
+    char PVRTexIdentifier[] = "PVR!";
+
+    enum
+    {
+        PVRTextureFlagTypePVRTC_2 = 24,
+        PVRTextureFlagTypePVRTC_4
+    };
+
+    struct pvr_file_header
+    {
+        unsigned int size;                  // size of the structure
+        unsigned int height;                  // height of surface to be created
+        unsigned int width;                   // width of input surface
+        unsigned int mipmapCount;             // number of mip-map levels requested
+        unsigned int formatflags;           // pixel format flags
+        unsigned int dataSize;                 // total size in bytes
+        unsigned int bpp;                    // number of bits per pixel
+        unsigned int redBitMask;            // mask for red bit
+        unsigned int greenBitMask;          // mask for green bits
+        unsigned int blueBitMask;           // mask for blue bits
+        unsigned int alphaBitMask;            // mask for alpha channel
+        unsigned int pvrTag;                // magic number identifying pvr file
+        unsigned int surfaceCount;          // number of surfaces present in the pvr
+    } ;
+
+    FILE* file = FileSystem::openFile(path, "rb");
+    if (file == NULL)
+    {
+        LOG_ERROR_VARG("Failed to load file: %s", path);
+        return NULL;
+    }
+
+    // Read the file header
+    unsigned int size = sizeof(pvr_file_header);
+    pvr_file_header header;
+    unsigned int read = (int)fread(&header, 1, size, file);
+    assert(read == size);
+    if (read != size)
+    {
+        LOG_ERROR_VARG("Read file header error for pvr file: %s (%d < %d)", path, (int)read, (int)size);
+        fclose(file);
+        return NULL;
+    }
+
+    // Proper file header identifier
+    if (PVRTexIdentifier[0] != (char)((header.pvrTag >>  0) & 0xff) ||
+        PVRTexIdentifier[1] != (char)((header.pvrTag >>  8) & 0xff) ||
+        PVRTexIdentifier[2] != (char)((header.pvrTag >> 16) & 0xff) ||
+        PVRTexIdentifier[3] != (char)((header.pvrTag >> 24) & 0xff))
+     {
+        LOG_ERROR_VARG("Invalid PVR texture file: %s", path);
+        fclose(file);
+        return NULL;
+    }
+
+    // Format flags for GLenum format
+    GLenum format;
+    unsigned int formatFlags = header.formatflags & 0xff;
+    if (formatFlags == PVRTextureFlagTypePVRTC_4)
+    {
+        format = header.alphaBitMask ? COMPRESSED_RGBA_PVRTC_4BPP : COMPRESSED_RGB_PVRTC_4BPP;
+    }
+    else if (formatFlags == PVRTextureFlagTypePVRTC_2)
+    {
+        format = header.alphaBitMask ? COMPRESSED_RGBA_PVRTC_2BPP : COMPRESSED_RGB_PVRTC_2BPP;
+    }
+    else
+    {
+        LOG_ERROR_VARG("Invalid PVR texture format flags for file: %s", path);
+        fclose(file);
+        return NULL;
+    }
+
+    unsigned char* data = new unsigned char[header.dataSize];
+    read = (int)fread(data, 1, header.dataSize, file);
+    assert(read == header.dataSize);
+    if (read != header.dataSize)
+    {
+        LOG_ERROR_VARG("Read file data error for pvr file: %s (%d < %d)", path, (int)read, (int)header.dataSize);
+        SAFE_DELETE_ARRAY(data);
+        fclose(file);
+        return NULL;
+    }
+    // Close file
+    fclose(file);
+
+    // Load our texture.
+    GLuint textureId;
+    GL_ASSERT( glGenTextures(1, &textureId) );
+    GL_ASSERT( glBindTexture(GL_TEXTURE_2D, textureId) );
+    GL_ASSERT( glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, header.mipmapCount > 0 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR ) );
 
     Texture* texture = new Texture();
     texture->_handle = textureId;
     texture->_width = header.width;
     texture->_height = header.height;
 
-	// Load the data for each level
-	unsigned int width = header.width;
-	unsigned int height = header.height;
-	unsigned int blockSize = 0;
-	unsigned int widthBlocks = 0;
-	unsigned int heightBlocks = 0;
-	unsigned int bpp = 0;
-	unsigned int dataSize = 0;
-	unsigned char* dataOffset = data;
-
-	for (unsigned int level = 0; level <= header.mipmapCount; level++)
-	{
-		if (formatFlags == PVRTextureFlagTypePVRTC_4)
-		{
-			dataSize = ( max((int)width, 8) * max((int)height, 8) * 4 + 7) / 8;
-		}
-		else
-		{
-			dataSize = ( max((int)width, 16) * max((int)height, 8) * 2 + 7) / 8;
-		}
-
-		GL_ASSERT( glCompressedTexImage2D(GL_TEXTURE_2D, level, (GLenum)format, width, height, 0, dataSize, dataOffset) );
-
-		dataOffset += dataSize;
-		width = max((int)width >> 1, 1);
-		height = max((int)height >> 1, 1);
-	}
-
-	SAFE_DELETE_ARRAY(data);
-
-	return texture;
+    // Load the data for each level
+    unsigned int width = header.width;
+    unsigned int height = header.height;
+    unsigned int blockSize = 0;
+    unsigned int widthBlocks = 0;
+    unsigned int heightBlocks = 0;
+    unsigned int bpp = 0;
+    unsigned int dataSize = 0;
+    unsigned char* dataOffset = data;
+
+    for (unsigned int level = 0; level <= header.mipmapCount; level++)
+    {
+        if (formatFlags == PVRTextureFlagTypePVRTC_4)
+        {
+            dataSize = ( max((int)width, 8) * max((int)height, 8) * 4 + 7) / 8;
+        }
+        else
+        {
+            dataSize = ( max((int)width, 16) * max((int)height, 8) * 2 + 7) / 8;
+        }
+
+        GL_ASSERT( glCompressedTexImage2D(GL_TEXTURE_2D, level, (GLenum)format, width, height, 0, dataSize, dataOffset) );
+
+        dataOffset += dataSize;
+        width = max((int)width >> 1, 1);
+        height = max((int)height >> 1, 1);
+    }
+
+    SAFE_DELETE_ARRAY(data);
+
+    return texture;
 }
 #endif
     

gameplay/src/Texture.h

@@ -32,9 +32,9 @@ public:
         DEPTH   = GL_DEPTH_COMPONENT,
 #ifdef OPENGL_ES_PVR
         COMPRESSED_RGB_PVRTC_4BPP = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
-		COMPRESSED_RGBA_PVRTC_4BPP = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
-		COMPRESSED_RGB_PVRTC_2BPP = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
-		COMPRESSED_RGBA_PVRTC_2BPP = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
+        COMPRESSED_RGBA_PVRTC_4BPP = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+        COMPRESSED_RGB_PVRTC_2BPP = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
+        COMPRESSED_RGBA_PVRTC_2BPP = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
 #endif
     };
 
@@ -214,7 +214,7 @@ private:
     virtual ~Texture();
 
 #ifdef OPENGL_ES_PVR
-	static Texture* createCompressedPVR(const char* path);
+    static Texture* createCompressedPVR(const char* path);
 #endif
     
     std::string _path;