13 년 전 · 009777c9a3
--- a/gameplay-api/gameplay.html
+++ b/gameplay-api/gameplay.html
@@ -0,0 +1,5 @@
 
				+<HTML>

			
 
				+<HEAD>

			
 
				+<META HTTP-EQUIV="Refresh" CONTENT="0; URL=html/index.html">

			
 
				+</HEAD>

			
 
				+</HTML>
			
--- a/gameplay/gameplay.vcxproj
+++ b/gameplay/gameplay.vcxproj
@@ -37,7 +37,6 @@
 
				     <ClCompile Include="src\DepthStencilTarget.cpp" />

			
 
				     <ClCompile Include="src\Effect.cpp" />

			
 
				     <ClCompile Include="src\FileSystem.cpp" />

			
 
				-    <ClCompile Include="src\FlowLayout.cpp" />

			
 
				     <ClCompile Include="src\Font.cpp" />

			
 
				     <ClCompile Include="src\Form.cpp" />

			
 
				     <ClCompile Include="src\FrameBuffer.cpp" />

			
@@ -129,7 +128,6 @@
 
				     <ClInclude Include="src\DepthStencilTarget.h" />

			
 
				     <ClInclude Include="src\Effect.h" />

			
 
				     <ClInclude Include="src\FileSystem.h" />

			
 
				-    <ClInclude Include="src\FlowLayout.h" />

			
 
				     <ClInclude Include="src\Font.h" />

			
 
				     <ClInclude Include="src\Form.h" />

			
 
				     <ClInclude Include="src\FrameBuffer.h" />

			
--- a/gameplay/src/Animation.cpp
+++ b/gameplay/src/Animation.cpp
@@ -146,6 +146,19 @@ AnimationClip* Animation::getClip(const char* id)
 
				     }

			
 
				 }

			
 
				 

			
 
				+AnimationClip* Animation::getClip(unsigned int index) const

			
 
				+{

			
 
				+    if (_clips)

			
 
				+        return _clips->at(index);

			
 
				+

			
 
				+    return NULL;

			
 
				+}

			
 
				+

			
 
				+unsigned int Animation::getClipCount() const

			
 
				+{

			
 
				+    return _clips ? _clips->size() : 0;

			
 
				+}

			
 
				+

			
 
				 void Animation::play(const char* clipId)

			
 
				 {

			
 
				     // If id is NULL, play the default clip.

			
--- a/gameplay/src/Animation.h
+++ b/gameplay/src/Animation.h
@@ -66,6 +66,18 @@ public:
 
				      * @return The AnimationClip with the specified ID; NULL if an AnimationClip with the given ID is not found.

			
 
				      */

			
 
				     AnimationClip* getClip(const char* clipId = NULL);

			
 
				+

			
 
				+    /**

			
 
				+     * Returns the AnimationClip at the given index.

			
 
				+     *

			
 
				+     * @param index Index of the clip to return.

			
 
				+     */

			
 
				+    AnimationClip* getClip(unsigned int index) const;

			
 
				+

			
 
				+    /**

			
 
				+     * Returns the number of animation clips in this animation.

			
 
				+     */

			
 
				+    unsigned int getClipCount() const;

			
 
				     

			
 
				     /**

			
 
				      * Plays the AnimationClip with the specified name. 

			
--- a/gameplay/src/CheckBox.cpp
+++ b/gameplay/src/CheckBox.cpp
@@ -101,7 +101,7 @@ bool CheckBox::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int cont
 
				 

			
 
				 void CheckBox::update(const Rectangle& clip)

			
 
				 {

			
 
				-    Control::update(clip);

			
 
				+    Label::update(clip);

			
 
				 

			
 
				     Vector2 size;

			
 
				     if (_imageSize.isZero())

			
@@ -125,60 +125,43 @@ void CheckBox::update(const Rectangle& clip)
 
				 

			
 
				     _textBounds.x += iconWidth + 5;

			
 
				     _textBounds.width -= iconWidth + 5;

			
 
				+

			
 
				+    if (_checked)

			
 
				+    {

			
 
				+        _image = getImage("checked", _state);

			
 
				+    }

			
 
				+    else

			
 
				+    {

			
 
				+        _image = getImage("unchecked", _state);

			
 
				+    }

			
 
				 }

			
 
				 

			
 
				 void CheckBox::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)

			
 
				 {

			
 
				     // Left, v-center.

			
 
				     // TODO: Set an alignment for icons.

			
 
				-    const Theme::Border border = getBorder(_state);

			
 
				+    const Theme::Border& border = getBorder(_state);

			
 
				     const Theme::Padding padding = getPadding();

			
 
				-    float opacity = getOpacity(_state);

			
 
				+    

			
 
				+    const Rectangle& region = _image->getRegion();

			
 
				+    const Theme::UVs& uvs = _image->getUVs();

			
 
				+    Vector4 color = _image->getColor();

			
 
				+    color.w *= _opacity;

			
 
				 

			
 
				-    if (_checked)

			
 
				+    Vector2 size;

			
 
				+    if (_imageSize.isZero())

			
 
				     {

			
 
				-        const Rectangle& selectedRegion = getImageRegion("checked", _state);

			
 
				-        const Theme::UVs& selected = getImageUVs("checked", _state);

			
 
				-        Vector4 selectedColor = getImageColor("checked", _state);

			
 
				-        selectedColor.w *= opacity;

			
 
				-

			
 
				-        Vector2 size;

			
 
				-        if (_imageSize.isZero())

			
 
				-        {

			
 
				-            size.set(selectedRegion.width, selectedRegion.height);

			
 
				-        }

			
 
				-        else

			
 
				-        {

			
 
				-            size.set(_imageSize);

			
 
				-        }

			
 
				-

			
 
				-        Vector2 pos(clip.x + _bounds.x + border.left + padding.left,

			
 
				-            clip.y + _bounds.y + (_clipBounds.height - border.bottom - padding.bottom) / 2.0f - size.y / 2.0f);

			
 
				-

			
 
				-        spriteBatch->draw(pos.x, pos.y, size.x, size.y, selected.u1, selected.v1, selected.u2, selected.v2, selectedColor, _clip);

			
 
				+        size.set(region.width, region.height);

			
 
				     }

			
 
				     else

			
 
				     {

			
 
				-        const Rectangle& unselectedRegion = getImageRegion("unchecked", _state);

			
 
				-        const Theme::UVs& unselected = getImageUVs("unchecked", _state);

			
 
				-        Vector4 unselectedColor = getImageColor("unchecked", _state);

			
 
				-        unselectedColor.w *= opacity;

			
 
				-

			
 
				-        Vector2 size;

			
 
				-        if (_imageSize.isZero())

			
 
				-        {

			
 
				-            size.set(unselectedRegion.width, unselectedRegion.height);

			
 
				-        }

			
 
				-        else

			
 
				-        {

			
 
				-            size.set(_imageSize);

			
 
				-        }

			
 
				+        size.set(_imageSize);

			
 
				+    }

			
 
				 

			
 
				-        Vector2 pos(clip.x + _bounds.x + border.left + padding.left,

			
 
				-            clip.y + _bounds.y + (_clipBounds.height - border.bottom - padding.bottom) / 2.0f - size.y / 2.0f);

			
 
				+    Vector2 pos(clip.x + _bounds.x + border.left + padding.left,

			
 
				+        clip.y + _bounds.y + (_clipBounds.height - border.bottom - padding.bottom) / 2.0f - size.y / 2.0f);

			
 
				 

			
 
				-        spriteBatch->draw(pos.x, pos.y, size.x, size.y, unselected.u1, unselected.v1, unselected.u2, unselected.v2, unselectedColor, _clip);

			
 
				-    }

			
 
				+    spriteBatch->draw(pos.x, pos.y, size.x, size.y, uvs.u1, uvs.v1, uvs.u2, uvs.v2, color, _clip);

			
 
				 }

			
 
				 

			
 
				 }

			
--- a/gameplay/src/CheckBox.h
+++ b/gameplay/src/CheckBox.h
@@ -130,6 +130,7 @@ protected:
 
				      */

			
 
				     void drawImages(SpriteBatch* spriteBatch, const Rectangle& clip);

			
 
				 

			
 
				+<<<<<<< HEAD
			
 
				     /**

			
 
				      * Whether this checkbox is currently checked.

			
 
				      */

			
@@ -139,6 +140,11 @@ protected:
 
				      * The size to draw the checkbox icon, if different from its size in the texture.

			
 
				      */

			
 
				     Vector2 _imageSize;

			
 
				+=======
			
 
				+    bool _checked;      // Whether this checkbox is currently checked.

			
 
				+    Vector2 _imageSize;  // The size to draw the checkbox icon, if different from its size in the texture.

			
 
				+    Theme::ThemeImage* _image;

			
 
				+>>>>>>> 6801051a7fa514d1e25fb44f6c95e075c0bfa8be
			
 
				 

			
 
				 private:

			
 
				 

			
--- a/gameplay/src/Control.cpp
+++ b/gameplay/src/Control.cpp
@@ -681,32 +681,34 @@ namespace gameplay
 
				             y = clip.y;

			
 
				 

			
 
				         _clip.set(x, y, width, height);

			
 
				+

			
 
				+        _skin = getSkin(_state);

			
 
				+        _opacity = getOpacity(_state);

			
 
				     }

			
 
				 

			
 
				     void Control::drawBorder(SpriteBatch* spriteBatch, const Rectangle& clip)

			
 
				     {

			
 
				-        if (_bounds.width <= 0 || _bounds.height <= 0)

			
 
				+        if (!_skin || _bounds.width <= 0 || _bounds.height <= 0)

			
 
				             return;

			
 
				 

			
 
				         Vector2 pos(clip.x + _bounds.x, clip.y + _bounds.y);

			
 
				 

			
 
				         // Get the border and background images for this control's current state.

			
 
				-        //Theme::UVs topLeft, top, topRight, left, center, right, bottomLeft, bottom, bottomRight;

			
 
				-        const Theme::UVs& topLeft = getSkinUVs(Theme::Skin::TOP_LEFT, _state);

			
 
				-        const Theme::UVs& top = getSkinUVs(Theme::Skin::TOP, _state);

			
 
				-        const Theme::UVs& topRight = getSkinUVs(Theme::Skin::TOP_RIGHT, _state);

			
 
				-        const Theme::UVs& left = getSkinUVs(Theme::Skin::LEFT, _state);

			
 
				-        const Theme::UVs& center = getSkinUVs(Theme::Skin::CENTER, _state);

			
 
				-        const Theme::UVs& right = getSkinUVs(Theme::Skin::RIGHT, _state);

			
 
				-        const Theme::UVs& bottomLeft = getSkinUVs(Theme::Skin::BOTTOM_LEFT, _state);

			
 
				-        const Theme::UVs& bottom = getSkinUVs(Theme::Skin::BOTTOM, _state);

			
 
				-        const Theme::UVs& bottomRight = getSkinUVs(Theme::Skin::BOTTOM_RIGHT, _state);

			
 
				+        const Theme::UVs& topLeft = _skin->getUVs(Theme::Skin::TOP_LEFT);

			
 
				+        const Theme::UVs& top = _skin->getUVs(Theme::Skin::TOP);

			
 
				+        const Theme::UVs& topRight = _skin->getUVs(Theme::Skin::TOP_RIGHT);

			
 
				+        const Theme::UVs& left = _skin->getUVs(Theme::Skin::LEFT);

			
 
				+        const Theme::UVs& center = _skin->getUVs(Theme::Skin::CENTER);

			
 
				+        const Theme::UVs& right = _skin->getUVs(Theme::Skin::RIGHT);

			
 
				+        const Theme::UVs& bottomLeft = _skin->getUVs(Theme::Skin::BOTTOM_LEFT);

			
 
				+        const Theme::UVs& bottom = _skin->getUVs(Theme::Skin::BOTTOM);

			
 
				+        const Theme::UVs& bottomRight = _skin->getUVs(Theme::Skin::BOTTOM_RIGHT);

			
 
				 

			
 
				         // Calculate screen-space positions.

			
 
				         const Theme::Border& border = getBorder(_state);

			
 
				         const Theme::Padding& padding = getPadding();

			
 
				-        Vector4 skinColor = getSkinColor(_state);

			
 
				-        skinColor.w *= getOpacity(_state);

			
 
				+        Vector4 skinColor = _skin->getColor();

			
 
				+        skinColor.w *= _opacity;

			
 
				 

			
 
				         float midWidth = _bounds.width - border.left - border.right;

			
 
				         float midHeight = _bounds.height - border.top - border.bottom;

			
@@ -790,6 +792,11 @@ namespace gameplay
 
				         return NORMAL;

			
 
				     }

			
 
				 

			
 
				+    Theme::ThemeImage* Control::getImage(const char* id, State state)

			
 
				+    {

			
 
				+        return getOverlay(state)->getImageList()->getImage(id);

			
 
				+    }

			
 
				+

			
 
				     // Implementation of AnimationHandler

			
 
				     unsigned int Control::getAnimationPropertyComponentCount(int propertyId) const

			
 
				     {

			
@@ -996,7 +1003,7 @@ namespace gameplay
 
				     void Control::overrideThemedProperties(Properties* properties, unsigned char states)

			
 
				     {

			
 
				         Theme::ImageList* imageList = NULL;

			
 
				-        Theme::Image* cursor = NULL;

			
 
				+        Theme::ThemeImage* cursor = NULL;

			
 
				         Theme::Skin* skin = NULL;

			
 
				         _style->_theme->lookUpSprites(properties, &imageList, &cursor, &skin);

			
 
				 

			
@@ -1064,7 +1071,7 @@ namespace gameplay
 
				         _dirty = true;

			
 
				     }

			
 
				 

			
 
				-    void Control::setCursor(Theme::Image* cursor, unsigned char states)

			
 
				+    void Control::setCursor(Theme::ThemeImage* cursor, unsigned char states)

			
 
				     {

			
 
				         overrideStyle();

			
 
				         Theme::Style::Overlay* overlays[Theme::Style::OVERLAY_MAX] = { 0 };

			
@@ -1092,6 +1099,11 @@ namespace gameplay
 
				         _dirty = true;

			
 
				     }

			
 
				 

			
 
				+    Theme::Skin* Control::getSkin(State state)

			
 
				+    {

			
 
				+        return getOverlay(state)->getSkin();

			
 
				+    }

			
 
				+

			
 
				     Control::Alignment Control::getAlignment(const char* alignment)

			
 
				     {

			
 
				         if (!alignment)

			
--- a/gameplay/src/Control.h
+++ b/gameplay/src/Control.h
@@ -781,6 +781,8 @@ protected:
 
				      */

			
 
				     static State getState(const char* state);

			
 
				 

			
 
				+    Theme::ThemeImage* getImage(const char* id, State state);

			
 
				+

			
 
				     /**

			
 
				      * Notify this control's listeners of a specific event.

			
 
				      *

			
@@ -861,6 +863,8 @@ protected:
 
				      */

			
 
				     std::map<Listener::EventType, std::list<Listener*>*>* _listeners;

			
 
				 

			
 
				+    float _opacity;         // Current opacity.

			
 
				+

			
 
				 private:

			
 
				 

			
 
				     static const char ANIMATION_POSITION_X_BIT = 0x01;

			
@@ -894,10 +898,12 @@ private:
 
				 

			
 
				     void setImageList(Theme::ImageList* imageList, unsigned char states = STATE_ALL);

			
 
				 

			
 
				-    void setCursor(Theme::Image* cursor, unsigned char states = STATE_ALL);

			
 
				+    void setCursor(Theme::ThemeImage* cursor, unsigned char states = STATE_ALL);

			
 
				 

			
 
				     void setSkin(Theme::Skin* skin, unsigned char states = STATE_ALL);

			
 
				-    

			
 
				+

			
 
				+    Theme::Skin* getSkin(State state);

			
 
				+

			
 
				     void addSpecificListener(Control::Listener* listener, Listener::EventType eventType);

			
 
				     

			
 
				     /**

			
@@ -909,6 +915,7 @@ private:
 
				     virtual void drawBorder(SpriteBatch* spriteBatch, const Rectangle& clip);

			
 
				     

			
 
				     bool _styleOverridden;

			
 
				+    Theme::Skin* _skin;

			
 
				 };

			
 
				 

			
 
				 }

			
--- a/gameplay/src/Form.h
+++ b/gameplay/src/Form.h
@@ -15,17 +15,7 @@ namespace gameplay
 
				 class Theme;

			
 
				 

			
 
				 /**

			
 
				- * Top-level container of UI controls.

			
 
				- */

			
 
				-class Form : public Container

			
 
				-{

			
 
				-    friend class Platform;

			
 
				-

			
 
				-public:

			
 
				-

			
 
				-    /**

			
 
				-     * Create from properties file.

			
 
				-     * The top-most namespace in the file must be named 'form'.  The following properties are available for forms:

			
 
				+ * Top-level container of UI controls.  The following properties are available for forms:

			
 
				 

			
 
				  @verbatim

			
 
				     form <formID>

			
@@ -52,7 +42,16 @@ public:
 
				         slider { }

			
 
				     }

			
 
				  @endverbatim

			
 
				+ */

			
 
				+class Form : public Container

			
 
				+{

			
 
				+    friend class Platform;

			
 
				 

			
 
				+public:

			
 
				+

			
 
				+    /**

			
 
				+     * Create from properties file.

			
 
				+     *

			
 
				      * @param path Path to the properties file to create a new form from.

			
 
				      */

			
 
				     static Form* create(const char* path);

			
--- a/gameplay/src/Label.cpp
+++ b/gameplay/src/Label.cpp
@@ -3,7 +3,7 @@
 
				 

			
 
				 namespace gameplay

			
 
				 {

			
 
				-    Label::Label() : _text("")

			
 
				+    Label::Label() : _text(""), _font(NULL)

			
 
				     {

			
 
				     }

			
 
				 

			
@@ -64,17 +64,25 @@ namespace gameplay
 
				         return _text.c_str();

			
 
				     }

			
 
				 

			
 
				+    void Label::update(const Rectangle& clip)

			
 
				+    {

			
 
				+        Control::update(clip);

			
 
				+

			
 
				+        _font = getFont(_state);

			
 
				+        _textColor = getTextColor(_state);

			
 
				+        _textColor.w *= getOpacity(_state);

			
 
				+    }

			
 
				+

			
 
				     void Label::drawText(const Rectangle& clip)

			
 
				     {

			
 
				         if (_text.size() <= 0)

			
 
				             return;

			
 
				 

			
 
				-        Font* font = getFont(_state);

			
 
				-        Vector4 textColor = getTextColor(_state);

			
 
				-        textColor.w *= getOpacity(_state);

			
 
				-

			
 
				         // Draw the text.

			
 
				-        font->drawText(_text.c_str(), _textBounds, textColor, getFontSize(_state), getTextAlignment(_state), true, getTextRightToLeft(_state), &_clip);

			
 
				+        if (_font)

			
 
				+        {

			
 
				+            _font->drawText(_text.c_str(), _textBounds, _textColor, getFontSize(_state), getTextAlignment(_state), true, getTextRightToLeft(_state), &_clip);

			
 
				+        }

			
 
				 

			
 
				         _dirty = false;

			
 
				     }

			
--- a/gameplay/src/Label.h
+++ b/gameplay/src/Label.h
@@ -86,6 +86,8 @@ protected:
 
				      */

			
 
				     virtual void initialize(Theme::Style* style, Properties* properties);

			
 
				 

			
 
				+    void update(const Rectangle& clip);

			
 
				+

			
 
				     /**

			
 
				      * Draw this label's text.

			
 
				      *

			
@@ -93,10 +95,16 @@ protected:
 
				      */

			
 
				     void drawText(const Rectangle& clip);

			
 
				 

			
 
				+<<<<<<< HEAD
			
 
				     /**

			
 
				      * The text displayed by this label.

			
 
				      */

			
 
				     std::string _text;

			
 
				+=======
			
 
				+    std::string _text;      // The text displayed by this label.

			
 
				+    Font* _font;

			
 
				+    Vector4 _textColor;

			
 
				+>>>>>>> 6801051a7fa514d1e25fb44f6c95e075c0bfa8be
			
 
				 

			
 
				 private:

			
 
				 

			
--- a/gameplay/src/Matrix.cpp
+++ b/gameplay/src/Matrix.cpp
@@ -554,18 +554,18 @@ void Matrix::getLeftVector(Vector3* dst) const
 
				 {

			
 
				     assert(dst);

			
 
				 

			
 
				-    dst->x = -m[0];

			
 
				-    dst->y = -m[1];

			
 
				-    dst->z = -m[2];

			
 
				+    dst->x = m[0];

			
 
				+    dst->y = m[1];

			
 
				+    dst->z = m[2];

			
 
				 }

			
 
				 

			
 
				 void Matrix::getRightVector(Vector3* dst) const

			
 
				 {

			
 
				     assert(dst);

			
 
				 

			
 
				-    dst->x = m[0];

			
 
				-    dst->y = m[1];

			
 
				-    dst->z = m[2];

			
 
				+    dst->x = -m[0];

			
 
				+    dst->y = -m[1];

			
 
				+    dst->z = -m[2];

			
 
				 }

			
 
				 

			
 
				 void Matrix::getForwardVector(Vector3* dst) const

			
--- a/gameplay/src/Node.cpp
+++ b/gameplay/src/Node.cpp
@@ -15,6 +15,7 @@
 
				 // Node property flags

			
 
				 #define NODE_FLAG_VISIBLE 1

			
 
				 #define NODE_FLAG_TRANSPARENT 2

			
 
				+#define NODE_FLAG_DYNAMIC 4

			
 
				 

			
 
				 namespace gameplay

			
 
				 {

			
@@ -235,6 +236,19 @@ void Node::setTransparent(bool transparent)
 
				         _nodeFlags &= ~NODE_FLAG_TRANSPARENT;

			
 
				 }

			
 
				 

			
 
				+bool Node::isDynamic() const

			
 
				+{

			
 
				+    return ((_nodeFlags & NODE_FLAG_DYNAMIC) == NODE_FLAG_DYNAMIC);

			
 
				+}

			
 
				+

			
 
				+void Node::setDynamic(bool dynamic)

			
 
				+{

			
 
				+    if (dynamic)

			
 
				+        _nodeFlags |= NODE_FLAG_DYNAMIC;

			
 
				+    else

			
 
				+        _nodeFlags &= ~NODE_FLAG_DYNAMIC;

			
 
				+}

			
 
				+

			
 
				 void* Node::getUserPointer() const

			
 
				 {

			
 
				     return (_userData ? _userData->pointer : NULL);

			
@@ -1004,8 +1018,8 @@ PhysicsCollisionObject* Node::setCollisionObject(Properties* properties)
 
				     // Check if the properties is valid.

			
 
				     if (!properties || 

			
 
				         !(strcmp(properties->getNamespace(), "character") == 0 || 

			
 
				-        strcmp(properties->getNamespace(), "ghost") == 0 || 

			
 
				-        strcmp(properties->getNamespace(), "rigidbody") == 0))

			
 
				+        strcmp(properties->getNamespace(), "ghostObject") == 0 || 

			
 
				+        strcmp(properties->getNamespace(), "rigidBody") == 0))

			
 
				     {

			
 
				         WARN("Failed to load collision object from properties object: must be non-null object and have namespace equal to \'character\', \'ghost\', or \'rigidbody\'.");

			
 
				         return NULL;

			
@@ -1015,11 +1029,11 @@ PhysicsCollisionObject* Node::setCollisionObject(Properties* properties)
 
				     {

			
 
				         _collisionObject = PhysicsCharacter::create(this, properties);

			
 
				     }

			
 
				-    else if (strcmp(properties->getNamespace(), "ghost") == 0)

			
 
				+    else if (strcmp(properties->getNamespace(), "ghostObject") == 0)

			
 
				     {

			
 
				         _collisionObject = PhysicsGhostObject::create(this, properties);

			
 
				     }

			
 
				-    else if (strcmp(properties->getNamespace(), "rigidbody") == 0)

			
 
				+    else if (strcmp(properties->getNamespace(), "rigidBody") == 0)

			
 
				     {

			
 
				         _collisionObject = PhysicsRigidBody::create(this, properties);

			
 
				     }

			
--- a/gameplay/src/Node.h
+++ b/gameplay/src/Node.h
@@ -148,6 +148,26 @@ public:
 
				      */

			
 
				     void setTransparent(bool transparent);

			
 
				 

			
 
				+    /**

			
 
				+     * Returns whether this node is dynamic.

			
 
				+     *

			
 
				+     * The dynamic propery can be used to flag nodes as being non-static.

			
 
				+     * This can be useful for modifying behavior or rendering/material

			
 
				+     * logic at runtime for static vs dynamic (moving) objects. An

			
 
				+     * example would be determing whether to use static or  dyanmic

			
 
				+     * lighting materials for node models during loading.

			
 
				+     *

			
 
				+     * @return Whether this node is dynamic (false by default).

			
 
				+     */

			
 
				+    bool isDynamic() const;

			
 
				+

			
 
				+    /**

			
 
				+     * Sets whether this node is dynamic.

			
 
				+     *

			
 
				+     * @param dynamic Whether the node is dynamic.

			
 
				+     */

			
 
				+    void setDynamic(bool dynamic);

			
 
				+

			
 
				     /**

			
 
				      * Returns the user pointer for this node.

			
 
				      *

			
--- a/gameplay/src/PhysicsCharacter.cpp
+++ b/gameplay/src/PhysicsCharacter.cpp
@@ -59,9 +59,9 @@ protected:
 
				 

			
 
				 PhysicsCharacter::PhysicsCharacter(Node* node, const PhysicsCollisionShape::Definition& shape, float mass)

			
 
				     : PhysicsGhostObject(node, shape), _moveVelocity(0,0,0), _forwardVelocity(0.0f), _rightVelocity(0.0f),

			
 
				-    _fallVelocity(0, 0, 0), _currentVelocity(0,0,0), _normalizedVelocity(0,0,0),

			
 
				-    _colliding(false), _collisionNormal(0,0,0), _currentPosition(0,0,0),

			
 
				-    _stepHeight(0.1f), _slopeAngle(0.0f), _cosSlopeAngle(0.0f), _physicsEnabled(true), _mass(mass)

			
 
				+    _verticalVelocity(0, 0, 0), _currentVelocity(0,0,0), _normalizedVelocity(0,0,0),

			
 
				+    _colliding(false), _collisionNormal(0,0,0), _currentPosition(0,0,0), _stepHeight(0.1f),

			
 
				+    _slopeAngle(0.0f), _cosSlopeAngle(0.0f), _physicsEnabled(true), _mass(mass)

			
 
				 {

			
 
				     setMaxSlopeAngle(45.0f);

			
 
				 

			
@@ -99,6 +99,8 @@ PhysicsCharacter* PhysicsCharacter::create(Node* node, Properties* properties)
 
				     // Load the character's parameters.

			
 
				     properties->rewind();

			
 
				     float mass = 1.0f;

			
 
				+    float maxStepHeight = 0.1f;

			
 
				+    float maxSlopeAngle = 0.0f;

			
 
				     const char* name = NULL;

			
 
				     while ((name = properties->getNextProperty()) != NULL)

			
 
				     {

			
@@ -106,10 +108,20 @@ PhysicsCharacter* PhysicsCharacter::create(Node* node, Properties* properties)
 
				         {

			
 
				             mass = properties->getFloat();

			
 
				         }

			
 
				+        else if (strcmp(name, "maxStepHeight") == 0)

			
 
				+        {

			
 
				+            maxStepHeight = properties->getFloat();

			
 
				+        }

			
 
				+        else if (strcmp(name, "maxSlopeAngle") == 0)

			
 
				+        {

			
 
				+            maxSlopeAngle = properties->getFloat();

			
 
				+        }

			
 
				     }

			
 
				 

			
 
				     // Create the physics character.

			
 
				     PhysicsCharacter* character = new PhysicsCharacter(node, *shape, mass);

			
 
				+    character->setMaxStepHeight(maxStepHeight);

			
 
				+    character->setMaxSlopeAngle(maxSlopeAngle);

			
 
				     SAFE_DELETE(shape);

			
 
				 

			
 
				     return character;

			
@@ -156,120 +168,6 @@ void PhysicsCharacter::setMaxSlopeAngle(float angle)
 
				     _cosSlopeAngle = std::cos(MATH_DEG_TO_RAD(angle));

			
 
				 }

			
 
				 

			
 
				-void PhysicsCharacter::addAnimation(const char* name, AnimationClip* clip, float moveSpeed)

			
 
				-{

			
 
				-    CharacterAnimation a;

			
 
				-    a.name = name;

			
 
				-    a.clip = clip;

			
 
				-    a.moveSpeed = moveSpeed;

			
 
				-    a.layer = 0;

			
 
				-    a.playing = false;

			
 
				-    a.animationFlags = ANIMATION_STOP;

			
 
				-    a.prev = NULL;

			
 
				-    _animations[name] = a;

			
 
				-}

			
 
				-

			
 
				-AnimationClip* PhysicsCharacter::getAnimation(const char* name)

			
 
				-{

			
 
				-    if (name)

			
 
				-    {

			
 
				-        // Lookup the specified animation

			
 
				-        std::map<const char*, CharacterAnimation>::iterator aitr = _animations.find(name);

			
 
				-        if (aitr != _animations.end())

			
 
				-        {

			
 
				-            return aitr->second.clip;

			
 
				-        }

			
 
				-    }

			
 
				-    return NULL;

			
 
				-}

			
 
				-

			
 
				-void PhysicsCharacter::play(const char* name, AnimationFlags flags, float speed, unsigned int blendDuration, unsigned int layer)

			
 
				-{

			
 
				-    CharacterAnimation* animation = NULL;

			
 
				-    if (name)

			
 
				-    {

			
 
				-        // Lookup the specified animation

			
 
				-        std::map<const char*, CharacterAnimation>::iterator aitr = _animations.find(name);

			
 
				-        if (aitr == _animations.end())

			
 
				-            return; // invalid animation name

			
 
				-

			
 
				-        animation = &(aitr->second);

			
 
				-

			
 
				-        // Set animation flags

			
 
				-        animation->clip->setRepeatCount(flags & ANIMATION_REPEAT ? AnimationClip::REPEAT_INDEFINITE : 1);

			
 
				-        animation->clip->setSpeed(speed);

			
 
				-        animation->animationFlags = flags;

			
 
				-        animation->layer = layer;

			
 
				-        animation->blendDuration = blendDuration;

			
 
				-        animation->prev = NULL;

			
 
				-

			
 
				-        // If the animation is already marked playing, do nothing more

			
 
				-        if (animation->playing)

			
 
				-            return;

			
 
				-    }

			
 
				-

			
 
				-    play(animation, layer);

			
 
				-}

			
 
				-

			
 
				-void PhysicsCharacter::play(CharacterAnimation* animation, unsigned int layer)

			
 
				-{

			
 
				-    // Is there already an animation playing on this layer?

			
 
				-    std::map<unsigned int, CharacterAnimation*>::iterator litr = _layers.find(layer);

			
 
				-    CharacterAnimation* prevAnimation = (litr == _layers.end() ? NULL : litr->second);

			
 
				-    if (prevAnimation && prevAnimation->playing)

			
 
				-    {

			
 
				-        // An animation is already playing on this layer

			
 
				-        if (animation)

			
 
				-        {

			
 
				-            if (animation->animationFlags == ANIMATION_RESUME)

			
 
				-                animation->prev = prevAnimation;

			
 
				-

			
 
				-            if (animation->blendDuration > 0L)

			
 
				-            {

			
 
				-                // Crossfade from current animation into the new one

			
 
				-                prevAnimation->clip->crossFade(animation->clip, animation->blendDuration);

			
 
				-            }

			
 
				-            else

			
 
				-            {

			
 
				-                // Stop the previous animation (no blending)

			
 
				-                prevAnimation->clip->stop();

			
 
				-

			
 
				-                // Play the new animation

			
 
				-                animation->clip->play();

			
 
				-            }

			
 
				-        }

			
 
				-        else

			
 
				-        {

			
 
				-            // No new animaton specified - stop current animation on this layer

			
 
				-            prevAnimation->clip->stop();

			
 
				-        }

			
 
				-

			
 
				-        prevAnimation->playing = false;

			
 
				-    }

			
 
				-    else if (animation)

			
 
				-    {

			
 
				-        // No animations currently playing - just play the new one

			
 
				-        animation->clip->play();

			
 
				-    }

			
 
				-

			
 
				-    // Update animaton and layers

			
 
				-    if (animation)

			
 
				-    {

			
 
				-        animation->playing = true;

			
 
				-

			
 
				-        // Update layer to point to the new animation

			
 
				-        if (litr != _layers.end())

			
 
				-            litr->second = animation;

			
 
				-        else

			
 
				-            _layers[layer] = animation;

			
 
				-    }

			
 
				-    else if (litr != _layers.end())

			
 
				-    {

			
 
				-        // Remove layer sine we stopped the animation previously on it

			
 
				-        _layers.erase(litr);

			
 
				-    }

			
 
				-}

			
 
				-

			
 
				 void PhysicsCharacter::setVelocity(const Vector3& velocity)

			
 
				 {

			
 
				     _moveVelocity.setValue(velocity.x, velocity.y, velocity.z);

			
@@ -307,7 +205,20 @@ void PhysicsCharacter::setRightVelocity(float velocity)
 
				 

			
 
				 void PhysicsCharacter::jump(float height)

			
 
				 {

			
 
				-    // TODO

			
 
				+    // TODO: Add support for different jump modes (i.e. double jump, changing direction in air, holding down jump button for extra height, etc)

			
 
				+    if (!_verticalVelocity.isZero())

			
 
				+        return;

			
 
				+

			
 
				+    // v = sqrt(v0^2 + 2 a s)

			
 
				+    //  v0 == initial velocity (zero for jumping)

			
 
				+    //  a == acceleration (inverse gravity)

			
 
				+    //  s == linear displacement (height)

			
 
				+    Vector3 jumpVelocity = -Game::getInstance()->getPhysicsController()->getGravity() * height * 2.0f;

			
 
				+    jumpVelocity.set(

			
 
				+        jumpVelocity.x == 0 ? 0 : std::sqrt(jumpVelocity.x),

			
 
				+        jumpVelocity.y == 0 ? 0 : std::sqrt(jumpVelocity.y),

			
 
				+        jumpVelocity.z == 0 ? 0 : std::sqrt(jumpVelocity.z));

			
 
				+    _verticalVelocity += BV(jumpVelocity);

			
 
				 }

			
 
				 

			
 
				 void PhysicsCharacter::updateCurrentVelocity()

			
@@ -403,58 +314,26 @@ void PhysicsCharacter::updateAction(btCollisionWorld* collisionWorld, btScalar d
 
				 

			
 
				 void PhysicsCharacter::stepUp(btCollisionWorld* collisionWorld, btScalar time)

			
 
				 {

			
 
				-    // Note: btKinematicCharacterController implements this by always just setting

			
 
				-    // target position to currentPosition.y + stepHeight, and then checking for collisions.

			
 
				-    // Don't let the character move up if it hits the ceiling (or something above).

			
 
				-    // Do this WITHOUT using time in the calculation - this way you are always guarnateed

			
 
				-    // to step over a step that is stepHeight high.

			
 
				-    // 

			
 
				-    // 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);

			
 
				-}

			
 
				+    btVector3 targetPosition(_currentPosition);

			
 
				 

			
 
				-void PhysicsCharacter::stepForwardAndStrafe(btCollisionWorld* collisionWorld, float time)

			
 
				-{

			
 
				-    // Process currently playing movements+animations and determine final move location

			
 
				-    float animationMoveSpeed = 0.0f;

			
 
				-    unsigned int animationCount = 0;

			
 
				-    for (std::map<unsigned int, CharacterAnimation*>::iterator itr = _layers.begin(); itr != _layers.end(); ++itr)

			
 
				+    if (_verticalVelocity.isZero())

			
 
				     {

			
 
				-        CharacterAnimation* animation = itr->second;

			
 
				-

			
 
				-        // If the animation is not playing, ignore it

			
 
				-        if (!animation->playing)

			
 
				-            continue;

			
 
				-

			
 
				-        AnimationClip* clip = animation->clip;

			
 
				-

			
 
				-        // Did the clip finish playing (but we still have it marked playing)?

			
 
				-        if (!clip->isPlaying())

			
 
				-        {

			
 
				-            // If the animaton was flaged the ANIMATION_RESUME bit, start the previously playing animation

			
 
				-            if ((animation->animationFlags == ANIMATION_RESUME) && animation->prev)

			
 
				-            {

			
 
				-                play(animation->prev, animation->prev->layer);

			
 
				-            }

			
 
				-

			
 
				-            animation->playing = false;

			
 
				+        // Simply increase our poisiton by step height to enable us

			
 
				+        // to smoothly move over steps.

			
 
				+        targetPosition += btVector3(0, _stepHeight, 0);

			
 
				+    }

			
 
				 

			
 
				-            continue;

			
 
				-        }

			
 
				+    // TODO: Convex sweep test to ensure we didn't hit anything during the step up.

			
 
				 

			
 
				-        animationMoveSpeed += animation->moveSpeed;

			
 
				-        ++animationCount;

			
 
				-    }

			
 
				+    _currentPosition = targetPosition;

			
 
				+}

			
 
				 

			
 
				+void PhysicsCharacter::stepForwardAndStrafe(btCollisionWorld* collisionWorld, float time)

			
 
				+{

			
 
				     updateCurrentVelocity();

			
 
				 

			
 
				     // Calculate final velocity

			
 
				     btVector3 velocity(_currentVelocity);

			
 
				-    if (animationCount > 0)

			
 
				-    {

			
 
				-        velocity *= animationMoveSpeed;

			
 
				-    }

			
 
				     velocity *= time; // since velocity is in meters per second

			
 
				 

			
 
				     if (velocity.isZero())

			
@@ -542,11 +421,12 @@ void PhysicsCharacter::stepForwardAndStrafe(btCollisionWorld* collisionWorld, fl
 
				 

			
 
				 void PhysicsCharacter::stepDown(btCollisionWorld* collisionWorld, btScalar time)

			
 
				 {

			
 
				-    // Contribute basic gravity to fall velocity.

			
 
				+    // Contribute gravity to vertical velocity.

			
 
				     btVector3 gravity = Game::getInstance()->getPhysicsController()->_world->getGravity();

			
 
				-    _fallVelocity += (gravity * time);

			
 
				+    _verticalVelocity += (gravity * time);

			
 
				 

			
 
				-    btVector3 targetPosition = _currentPosition + (_fallVelocity * time);

			
 
				+    // Compute new position from vertical velocity.

			
 
				+    btVector3 targetPosition = _currentPosition + (_verticalVelocity * time);

			
 
				     targetPosition -= btVector3(0, _stepHeight, 0);

			
 
				 

			
 
				     // Perform a convex sweep test between current and target position

			
@@ -569,7 +449,7 @@ void PhysicsCharacter::stepDown(btCollisionWorld* collisionWorld, btScalar time)
 
				         _currentPosition.setInterpolate3(_currentPosition, targetPosition, callback.m_closestHitFraction);

			
 
				 

			
 
				         // Zero out fall velocity when we hit an object

			
 
				-        _fallVelocity.setZero();

			
 
				+        _verticalVelocity.setZero();

			
 
				     }

			
 
				     else

			
 
				     {

			
--- a/gameplay/src/PhysicsCharacter.h
+++ b/gameplay/src/PhysicsCharacter.h
@@ -18,10 +18,6 @@ namespace gameplay
 
				  * PhysicsCharacter class. This results in a more responsive and typical game

			
 
				  * character than would be possible if trying to move a character by applying

			
 
				  * physical simulation with forces.

			
 
				- *

			
 
				- * This class can also be used to control animations for a character. Animation

			
 
				- * clips can be setup for typical character animations, such as walk, run, jump,

			
 
				- * etc; and the controller will handle blending between these animations as needed.

			
 
				  */

			
 
				 class PhysicsCharacter : public PhysicsGhostObject, public btActionInterface

			
 
				 {

			
@@ -29,27 +25,6 @@ class PhysicsCharacter : public PhysicsGhostObject, public btActionInterface
 
				 

			
 
				 public:

			
 
				 

			
 
				-    /**

			
 
				-     * Flags for controlling how a character animation is played back.

			
 
				-     */

			
 
				-    enum AnimationFlags

			
 
				-    {

			
 
				-        /**

			
 
				-         * Plays an animation once and then stops.

			
 
				-         */

			
 
				-        ANIMATION_STOP,

			
 
				-

			
 
				-        /**

			
 
				-         * Play an animation once and then resumes the previous playing animation.

			
 
				-         */

			
 
				-        ANIMATION_RESUME,

			
 
				-

			
 
				-        /**

			
 
				-         * Plays an animation and repeats it indefinitely.

			
 
				-         */

			
 
				-         ANIMATION_REPEAT

			
 
				-    };

			
 
				-

			
 
				     /**

			
 
				      * @see PhysicsCollisionObject#getType

			
 
				      */

			
@@ -110,74 +85,13 @@ public:
 
				      */

			
 
				     void setMaxSlopeAngle(float angle);

			
 
				 

			
 
				-    /**

			
 
				-     * Configures a new animation for this character.

			
 
				-     *

			
 
				-     * This method registers an animation for the character, with an associated movement speed.

			
 
				-     * The moveSpeed specifies how fast the character moves while the animation is playing.

			
 
				-     * The final velocity of the character is the product of the current move velocity and

			
 
				-     * the currently playing animation(s) moveSpeed.

			
 
				-     *

			
 
				-     * @param name Name of the animation.

			
 
				-     * @param animationClip Animation clip associated with the new character animation.

			
 
				-     * @param moveSpeed Base movement speed (meters per second) associated with the animation.

			
 
				-     */

			
 
				-    void addAnimation(const char* name, AnimationClip* animationClip, float moveSpeed);

			
 
				-

			
 
				-    /**

			
 
				-     * Returns the animation with the specified name.

			
 
				-     *

			
 
				-     * @return The specified animation clip.

			
 
				-     */

			
 
				-    AnimationClip* getAnimation(const char* name);

			
 
				-

			
 
				-    /**

			
 
				-     * Plays the specified animation.

			
 
				-     *

			
 
				-     * There are some limiations and considerations that should be ponited out when

			
 
				-     * playing animations:

			
 
				-     * <li>You should avoid playing multiple animations concurrently that have the same target.

			
 
				-     * For example, two animations targetting the character's joints should not be played 

			
 
				-     * concurrently, but it is fine to play one animation that targets the joints and another

			
 
				-     * that targets the character's Node.

			
 
				-     * <li>When playing an animation that targets the transform of the character's Node

			
 
				-     * (such as a motion path animation), the character's velocity vector should be set to

			
 
				-     * Vector3::zero() so that the PhysicsCharacter stops applying motion directly

			
 
				-     * and instead relies on the motion animation to control the character.

			
 
				-     *

			
 
				-     * The optional animation layer can be used to group animations on separate layers.

			
 
				-     * Each animation layer can have at most one active animation. Playing multiple

			
 
				-     * animations concurrently can be achieved by putting the different animations

			
 
				-     * on separate layers. For example, a motion path animation that targets the

			
 
				-     * character's Node can be put on one layer, while a running animation that targets

			
 
				-     * a character's Joints can be put on a separate layer. This allows a character's

			
 
				-     * movement to be animated at the same time as the run animation is playing.

			
 
				-     *

			
 
				-     * @param name Animation name, or NULL to stop all character animations on the given layer.

			
 
				-     * @param flags Animation flags from the AnimationFlags enumeration.

			
 
				-     * @param animationSpeed Optional animation speed (default is 1.0).

			
 
				-     * @param blendDuration Optional number of milliseconds to crossfade between the

			
 
				-     *      currently playing animation on the given layer and the new animation.

			
 
				-     * @param layer Optional animation layer.

			
 
				-     */

			
 
				-    void play(const char* name, AnimationFlags flags, float animationSpeed = 1.0f, unsigned int blendDuration = 0, unsigned int layer = 0);

			
 
				-

			
 
				     /**

			
 
				      * Sets the velocity of the character.

			
 
				      *

			
 
				      * Calling this function sets the velocity (speed and direction) for the character.

			
 
				      * The velocity is maintained until this method is called again. The final velocity

			
 
				-     * of the character is determined by product of the current velocity vector(s)

			
 
				-     * and the current character animation's move speed. Therefore, specifying a

			
 
				-     * normalized (unit-length) velocity vector results in the character speed being

			
 
				-     * controled entirely by the current animation's velocity; whereas the speed of

			
 
				-     * the character can be augmented by modifying the magnitude of the velocity vector.

			
 
				-

			
 
				-     * Note that a zero velocity vector and/or a zero animation move speed will

			
 
				-     * result in no character movement (the character will be stationary). A zero

			
 
				-     * velocity vector should be used when playing an animation that targets the

			
 
				-     * character's transform directly (such as a motion path animation), since these

			
 
				-     * animations will overwrite any transformations on the character's node.

			
 
				+     * of the character is determined by product of the current velocity, right and

			
 
				+     * forward vectors.

			
 
				      *

			
 
				      * @param velocity Movement velocity.

			
 
				      */

			
@@ -219,9 +133,6 @@ public:
 
				      * The forward velocity is defined by the character's current orientation

			
 
				      * (it is the forward vector from the character's current world transform).

			
 
				      *

			
 
				-     * The specified velocity acts as a multiplier on the currently playing animation's

			
 
				-     * velocity (or, if there is no animation playing, it directly impacts velocity).

			
 
				-     *

			
 
				      * Note that a negative velocity (i.e. -1.0f) will move the character backwards.

			
 
				      *

			
 
				      * @param velocity Optional velocity modifier.

			
@@ -234,9 +145,6 @@ public:
 
				      * The right velocity is defined by the character's current orientation

			
 
				      * (it is the right vector from the character's current world transform).

			
 
				      *

			
 
				-     * The specified velocity acts as a multiplier on the currently playing animation's

			
 
				-     * velocity (or, if there is no animation playing, it directly impacts velocity).

			
 
				-     *

			
 
				      * Note that a negative velocity (i.e. -1.0f) will move the character left.

			
 
				      *

			
 
				      * @param velocity Optional velocity modifier.

			
@@ -269,18 +177,6 @@ protected:
 
				 

			
 
				 private:

			
 
				 

			
 
				-    struct CharacterAnimation

			
 
				-    {

			
 
				-        const char* name;

			
 
				-        AnimationClip* clip;

			
 
				-        float moveSpeed;

			
 
				-        unsigned int layer;

			
 
				-        bool playing;

			
 
				-        AnimationFlags animationFlags;

			
 
				-        unsigned int blendDuration;

			
 
				-        CharacterAnimation* prev;

			
 
				-    };

			
 
				-

			
 
				     /**

			
 
				      * Creates a new PhysicsCharacter.

			
 
				      *

			
@@ -311,8 +207,6 @@ private:
 
				 

			
 
				     void updateCurrentVelocity();

			
 
				 

			
 
				-    void play(CharacterAnimation* animation, unsigned int layer);

			
 
				-

			
 
				     void stepUp(btCollisionWorld* collisionWorld, btScalar time);

			
 
				 

			
 
				     void stepDown(btCollisionWorld* collisionWorld, btScalar time);

			
@@ -326,14 +220,12 @@ private:
 
				     btVector3 _moveVelocity;

			
 
				     float _forwardVelocity;

			
 
				     float _rightVelocity;

			
 
				-    btVector3 _fallVelocity;

			
 
				+    btVector3 _verticalVelocity;

			
 
				     btVector3 _currentVelocity;

			
 
				     btVector3 _normalizedVelocity;

			
 
				     bool _colliding;

			
 
				     btVector3 _collisionNormal;

			
 
				     btVector3 _currentPosition;

			
 
				-    std::map<const char*, CharacterAnimation> _animations;

			
 
				-    std::map<unsigned int, CharacterAnimation*> _layers;

			
 
				     btManifoldArray _manifoldArray;

			
 
				     float _stepHeight;

			
 
				     float _slopeAngle;

			
--- a/gameplay/src/PhysicsCollisionShape.cpp
+++ b/gameplay/src/PhysicsCollisionShape.cpp
@@ -121,8 +121,8 @@ PhysicsCollisionShape::Definition* PhysicsCollisionShape::Definition::create(Nod
 
				     assert(properties);

			
 
				     if (!properties || 

			
 
				         !(strcmp(properties->getNamespace(), "character") == 0 || 

			
 
				-        strcmp(properties->getNamespace(), "ghost") == 0 || 

			
 
				-        strcmp(properties->getNamespace(), "rigidbody") == 0))

			
 
				+        strcmp(properties->getNamespace(), "ghostObject") == 0 || 

			
 
				+        strcmp(properties->getNamespace(), "rigidBody") == 0))

			
 
				     {

			
 
				         WARN("Failed to load physics collision shape from properties object: must be non-null object and have namespace equal to \'character\', \'ghost\', or \'rigidbody\'.");

			
 
				         return NULL;

			
--- a/gameplay/src/PhysicsGhostObject.cpp
+++ b/gameplay/src/PhysicsGhostObject.cpp
@@ -43,7 +43,7 @@ PhysicsGhostObject* PhysicsGhostObject::create(Node* node, Properties* propertie
 
				 {

			
 
				     // Check if the properties is valid and has a valid namespace.

			
 
				     assert(properties);

			
 
				-    if (!properties || !(strcmp(properties->getNamespace(), "ghost") == 0))

			
 
				+    if (!properties || !(strcmp(properties->getNamespace(), "ghostObject") == 0))

			
 
				     {

			
 
				         WARN("Failed to load ghost object from properties object: must be non-null object and have namespace equal to \'ghost\'.");

			
 
				         return NULL;

			
--- a/gameplay/src/PhysicsRigidBody.cpp
+++ b/gameplay/src/PhysicsRigidBody.cpp
@@ -145,9 +145,9 @@ PhysicsRigidBody* PhysicsRigidBody::create(Node* node, Properties* properties)
 
				 {

			
 
				     // Check if the properties is valid and has a valid namespace.

			
 
				     assert(properties);

			
 
				-    if (!properties || !(strcmp(properties->getNamespace(), "rigidbody") == 0))

			
 
				+    if (!properties || !(strcmp(properties->getNamespace(), "rigidBody") == 0))

			
 
				     {

			
 
				-        WARN("Failed to load rigid body from properties object: must be non-null object and have namespace equal to \'rigidbody\'.");

			
 
				+        WARN("Failed to load rigid body from properties object: must be non-null object and have namespace equal to \'rigidBody\'.");

			
 
				         return NULL;

			
 
				     }

			
 
				 

			
--- a/gameplay/src/RadioButton.cpp
+++ b/gameplay/src/RadioButton.cpp
@@ -120,86 +120,69 @@ void RadioButton::clearSelected(const std::string& groupId)
 
				     }

			
 
				 }

			
 
				 

			
 
				-void RadioButton::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)

			
 
				+void RadioButton::update(const Rectangle& clip)

			
 
				 {

			
 
				-    // Left, v-center.

			
 
				-    // TODO: Set an alignment for radio button images.

			
 
				-    const Theme::Border border = getBorder(_state);

			
 
				-    const Theme::Padding padding = getPadding();

			
 
				-    float opacity = getOpacity(_state);

			
 
				+    Label::update(clip);

			
 
				 

			
 
				-    if (_selected)

			
 
				+    Vector2 size;

			
 
				+    if (_imageSize.isZero())

			
 
				     {

			
 
				-        const Rectangle& selectedRegion = getImageRegion("selected", _state);

			
 
				-        const Theme::UVs& selected = getImageUVs("selected", _state);

			
 
				-        Vector4 selectedColor = getImageColor("selected", _state);

			
 
				-        selectedColor.w *= opacity;

			
 
				-

			
 
				-        Vector2 size;

			
 
				-        if (_imageSize.isZero())

			
 
				+        if (_selected)

			
 
				         {

			
 
				+            const Rectangle& selectedRegion = getImageRegion("selected", _state);

			
 
				             size.set(selectedRegion.width, selectedRegion.height);

			
 
				         }

			
 
				         else

			
 
				         {

			
 
				-            size.set(_imageSize);

			
 
				+            const Rectangle& unselectedRegion = getImageRegion("unselected", _state);

			
 
				+            size.set(unselectedRegion.width, unselectedRegion.height);

			
 
				         }

			
 
				-

			
 
				-        Vector2 pos(clip.x + _bounds.x + border.left + padding.left,

			
 
				-            clip.y + _bounds.y + (_clipBounds.height - border.bottom - padding.bottom) / 2.0f - size.y / 2.0f);

			
 
				-

			
 
				-        spriteBatch->draw(pos.x, pos.y, size.x, size.y, selected.u1, selected.v1, selected.u2, selected.v2, selectedColor, _clip);

			
 
				     }

			
 
				     else

			
 
				     {

			
 
				-        const Rectangle& unselectedRegion = getImageRegion("unselected", _state);

			
 
				-        const Theme::UVs& unselected = getImageUVs("unselected", _state);

			
 
				-        Vector4 unselectedColor = getImageColor("unselected", _state);

			
 
				-        unselectedColor.w *= opacity;

			
 
				-

			
 
				-        Vector2 size;

			
 
				-        if (_imageSize.isZero())

			
 
				-        {

			
 
				-            size.set(unselectedRegion.width, unselectedRegion.height);

			
 
				-        }

			
 
				-        else

			
 
				-        {

			
 
				-            size.set(_imageSize);

			
 
				-        }

			
 
				+        size.set(_imageSize);

			
 
				+    }

			
 
				+    float iconWidth = size.x;

			
 
				 

			
 
				-        Vector2 pos(clip.x + _bounds.x + border.left + padding.left,

			
 
				-            clip.y + _bounds.y + (_clipBounds.height - border.bottom - padding.bottom) / 2.0f - size.y / 2.0f);

			
 
				+    _textBounds.x += iconWidth + 5;

			
 
				+    _textBounds.width -= iconWidth + 5;

			
 
				 

			
 
				-        spriteBatch->draw(pos.x, pos.y, size.x, size.y, unselected.u1, unselected.v1, unselected.u2, unselected.v2, unselectedColor, _clip);

			
 
				+    if (_selected)

			
 
				+    {

			
 
				+        _image = getImage("selected", _state);

			
 
				+    }

			
 
				+    else

			
 
				+    {

			
 
				+        _image = getImage("unselected", _state);

			
 
				     }

			
 
				 }

			
 
				 

			
 
				-void RadioButton::update(const Rectangle& clip)

			
 
				+void RadioButton::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)

			
 
				 {

			
 
				-    Control::update(clip);

			
 
				+    // Left, v-center.

			
 
				+    // TODO: Set an alignment for radio button images.

			
 
				+    const Theme::Border& border = getBorder(_state);

			
 
				+    const Theme::Padding padding = getPadding();

			
 
				+    

			
 
				+    const Rectangle& region = _image->getRegion();

			
 
				+    const Theme::UVs& uvs = _image->getUVs();

			
 
				+    Vector4 color = _image->getColor();

			
 
				+    color.w *= _opacity;

			
 
				 

			
 
				     Vector2 size;

			
 
				     if (_imageSize.isZero())

			
 
				     {

			
 
				-        if (_selected)

			
 
				-        {

			
 
				-            const Rectangle& selectedRegion = getImageRegion("selected", _state);

			
 
				-            size.set(selectedRegion.width, selectedRegion.height);

			
 
				-        }

			
 
				-        else

			
 
				-        {

			
 
				-            const Rectangle& unselectedRegion = getImageRegion("unselected", _state);

			
 
				-            size.set(unselectedRegion.width, unselectedRegion.height);

			
 
				-        }

			
 
				+        size.set(region.width, region.height);

			
 
				     }

			
 
				     else

			
 
				     {

			
 
				         size.set(_imageSize);

			
 
				     }

			
 
				-    float iconWidth = size.x;

			
 
				 

			
 
				-    _textBounds.x += iconWidth + 5;

			
 
				-    _textBounds.width -= iconWidth + 5;

			
 
				+    Vector2 pos(clip.x + _bounds.x + border.left + padding.left,

			
 
				+        clip.y + _bounds.y + (_clipBounds.height - border.bottom - padding.bottom) / 2.0f - size.y / 2.0f);

			
 
				+

			
 
				+    spriteBatch->draw(pos.x, pos.y, size.x, size.y, uvs.u1, uvs.v1, uvs.u2, uvs.v2, color, _clip);

			
 
				 }

			
 
				 

			
 
				 }
			
--- a/gameplay/src/RadioButton.h
+++ b/gameplay/src/RadioButton.h
@@ -145,6 +145,7 @@ protected:
 
				      * The size at which the RadioButton's icon will be drawn.

			
 
				      */

			
 
				     Vector2 _imageSize;

			
 
				+    Theme::ThemeImage* _image;

			
 
				 

			
 
				 private:

			
 
				 

			
--- a/gameplay/src/SceneLoader.cpp
+++ b/gameplay/src/SceneLoader.cpp
@@ -61,8 +61,9 @@ Scene* SceneLoader::load(const char* filePath)
 
				         SceneNodeProperty::ROTATE |

			
 
				         SceneNodeProperty::SCALE |

			
 
				         SceneNodeProperty::TRANSLATE | 

			
 
				-        SceneNodeProperty::TRANSPARENT);

			
 
				-    applyNodeProperties(scene, sceneProperties, SceneNodeProperty::CHARACTER | SceneNodeProperty::GHOST | SceneNodeProperty::RIGIDBODY);

			
 
				+        SceneNodeProperty::TRANSPARENT |

			
 
				+        SceneNodeProperty::DYNAMIC);

			
 
				+    applyNodeProperties(scene, sceneProperties, SceneNodeProperty::CHARACTER | SceneNodeProperty::GHOSTOBJECT | SceneNodeProperty::RIGIDBODY);

			
 
				     createAnimations(scene);

			
 
				 

			
 
				     // Find the physics properties object.

			
@@ -195,7 +196,7 @@ void SceneLoader::applyNodeProperty(SceneNode& sceneNode, Node* node, const Prop
 
				         snp._type == SceneNodeProperty::MATERIAL ||

			
 
				         snp._type == SceneNodeProperty::PARTICLE ||

			
 
				         snp._type == SceneNodeProperty::CHARACTER ||

			
 
				-        snp._type == SceneNodeProperty::GHOST ||

			
 
				+        snp._type == SceneNodeProperty::GHOSTOBJECT ||

			
 
				         snp._type == SceneNodeProperty::RIGIDBODY)

			
 
				     {

			
 
				         // Check to make sure the referenced properties object was loaded properly.

			
@@ -250,7 +251,7 @@ void SceneLoader::applyNodeProperty(SceneNode& sceneNode, Node* node, const Prop
 
				             break;

			
 
				         }

			
 
				         case SceneNodeProperty::CHARACTER:

			
 
				-        case SceneNodeProperty::GHOST:

			
 
				+        case SceneNodeProperty::GHOSTOBJECT:

			
 
				         case SceneNodeProperty::RIGIDBODY:

			
 
				         {

			
 
				             // Check to make sure the referenced properties object was loaded properly.

			
@@ -283,20 +284,20 @@ void SceneLoader::applyNodeProperty(SceneNode& sceneNode, Node* node, const Prop
 
				             {

			
 
				                 WARN_VARG("Attempting to set a 'character' (physics collision object attribute) on a node using a '%s' definition.", p->getNamespace());

			
 
				             }

			
 
				-            else if (snp._type == SceneNodeProperty::GHOST && strcmp(p->getNamespace(), "ghost") != 0)

			
 
				+            else if (snp._type == SceneNodeProperty::GHOSTOBJECT && strcmp(p->getNamespace(), "ghostObject") != 0)

			
 
				             {

			
 
				-                WARN_VARG("Attempting to set a 'ghost' (physics collision object attribute) on a node using a '%s' definition.", p->getNamespace());

			
 
				+                WARN_VARG("Attempting to set a 'ghostObject' (physics collision object attribute) on a node using a '%s' definition.", p->getNamespace());

			
 
				             }

			
 
				-            else if (snp._type == SceneNodeProperty::RIGIDBODY && strcmp(p->getNamespace(), "rigidbody") != 0)

			
 
				+            else if (snp._type == SceneNodeProperty::RIGIDBODY && strcmp(p->getNamespace(), "rigidBody") != 0)

			
 
				             {

			
 
				-                WARN_VARG("Attempting to set a 'rigidbody' (physics collision object attribute) on a node using a '%s' definition.", p->getNamespace());

			
 
				+                WARN_VARG("Attempting to set a 'rigidBody' (physics collision object attribute) on a node using a '%s' definition.", p->getNamespace());

			
 
				             }

			
 
				             else

			
 
				             {

			
 
				                 // If the scene file specifies a rigid body model, use it for creating the collision object.

			
 
				                 Properties* np = sceneProperties->getNamespace(sceneNode._nodeID);

			
 
				                 const char* name = NULL;

			
 
				-                if (np && (name = np->getString("rigidbodymodel")))

			
 
				+                if (np && (name = np->getString("rigidBodyModel")))

			
 
				                 {

			
 
				                     Node* modelNode = node->getScene()->findNode(name);

			
 
				                     if (!modelNode)

			
@@ -307,14 +308,14 @@ void SceneLoader::applyNodeProperty(SceneNode& sceneNode, Node* node, const Prop
 
				                             WARN_VARG("Node '%s' does not have a model; attempting to use its model for collision object creation.", name);

			
 
				                         else

			
 
				                         {

			
 
				-                            // Temporarily set rigidbody model on model so it's used during collision object creation.

			
 
				+                            // Temporarily set rigidBody model on model so it's used during collision object creation.

			
 
				                             Model* model = node->getModel();

			
 
				                             assert(model);

			
 
				                         

			
 
				                             // Up ref count to prevent node from releasing the model when we swap it.

			
 
				                             model->addRef(); 

			
 
				                         

			
 
				-                            // Create collision object with new rigidbodymodel set.

			
 
				+                            // Create collision object with new rigidBodyModel set.

			
 
				                             node->setModel(modelNode->getModel());

			
 
				                             node->setCollisionObject(p);

			
 
				 

			
@@ -370,6 +371,11 @@ void SceneLoader::applyNodeProperty(SceneNode& sceneNode, Node* node, const Prop
 
				             node->setTransparent(true);

			
 
				             break;

			
 
				         }

			
 
				+        case SceneNodeProperty::DYNAMIC:

			
 
				+        {

			
 
				+            node->setDynamic(true);

			
 
				+            break;

			
 
				+        }

			
 
				         default:

			
 
				             WARN_VARG("Unsupported node property type: %d.", snp._type);

			
 
				             break;

			
@@ -554,15 +560,15 @@ void SceneLoader::buildReferenceTables(Properties* sceneProperties)
 
				                 {

			
 
				                     addSceneNodeProperty(sceneNode, SceneNodeProperty::CHARACTER, ns->getString());

			
 
				                 }

			
 
				-                else if (strcmp(name, "ghost") == 0)

			
 
				+                else if (strcmp(name, "ghostObject") == 0)

			
 
				                 {

			
 
				-                    addSceneNodeProperty(sceneNode, SceneNodeProperty::GHOST, ns->getString());

			
 
				+                    addSceneNodeProperty(sceneNode, SceneNodeProperty::GHOSTOBJECT, ns->getString());

			
 
				                 }

			
 
				-                else if (strcmp(name, "rigidbody") == 0)

			
 
				+                else if (strcmp(name, "rigidBody") == 0)

			
 
				                 {

			
 
				                     addSceneNodeProperty(sceneNode, SceneNodeProperty::RIGIDBODY, ns->getString());

			
 
				                 }

			
 
				-                else if (strcmp(name, "rigidbodymodel") == 0)

			
 
				+                else if (strcmp(name, "rigidBodyModel") == 0)

			
 
				                 {

			
 
				                     // Ignore this for now. We process this when we do rigid body creation.

			
 
				                 }

			
@@ -582,6 +588,10 @@ void SceneLoader::buildReferenceTables(Properties* sceneProperties)
 
				                 {

			
 
				                     addSceneNodeProperty(sceneNode, SceneNodeProperty::TRANSPARENT);

			
 
				                 }

			
 
				+                else if (strcmp(name, "dynamic") == 0)

			
 
				+                {

			
 
				+                    addSceneNodeProperty(sceneNode, SceneNodeProperty::DYNAMIC);

			
 
				+                }

			
 
				                 else

			
 
				                 {

			
 
				                     WARN_VARG("Unsupported node property: %s = %s", name, ns->getString());

			
--- a/gameplay/src/SceneLoader.h
+++ b/gameplay/src/SceneLoader.h
@@ -46,13 +46,14 @@ private:
 
				             MATERIAL = 2,

			
 
				             PARTICLE = 4,

			
 
				             CHARACTER = 8,

			
 
				-            GHOST = 16,

			
 
				+            GHOSTOBJECT = 16,

			
 
				             RIGIDBODY = 32,

			
 
				             TRANSLATE = 64,

			
 
				             ROTATE = 128,

			
 
				             SCALE = 256,

			
 
				             URL = 512,

			
 
				-            TRANSPARENT = 1024

			
 
				+            TRANSPARENT = 1024,

			
 
				+            DYNAMIC = 2048

			
 
				         };

			
 
				 

			
 
				         SceneNodeProperty(Type type, std::string file, std::string id, int index) : _type(type), _file(file), _id(id), _index(index) { }

			
--- a/gameplay/src/Slider.cpp
+++ b/gameplay/src/Slider.cpp
@@ -141,6 +141,16 @@ bool Slider::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contac
 
				     return Control::touchEvent(evt, x, y, contactIndex);

			
 
				 }

			
 
				 

			
 
				+void Slider::update(const Rectangle& clip)

			
 
				+{

			
 
				+    Label::update(clip);

			
 
				+

			
 
				+    _minImage = getImage("minCap", _state);

			
 
				+    _maxImage = getImage("maxCap", _state);

			
 
				+    _markerImage = getImage("marker", _state);

			
 
				+    _trackImage = getImage("track", _state);

			
 
				+}

			
 
				+

			
 
				 void Slider::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)

			
 
				 {

			
 
				     // TODO: Vertical slider.

			
@@ -151,26 +161,25 @@ void Slider::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)
 
				     const Theme::Border& border = getBorder(_state);

			
 
				     const Theme::Padding& padding = getPadding();

			
 
				 

			
 
				-    const Rectangle& minCapRegion = getImageRegion("minCap", _state);

			
 
				-    const Rectangle& maxCapRegion = getImageRegion("maxCap", _state);

			
 
				-    const Rectangle& markerRegion = getImageRegion("marker", _state);

			
 
				-    const Rectangle& trackRegion = getImageRegion("track", _state);

			
 
				-

			
 
				-    const Theme::UVs minCap = getImageUVs("minCap", _state);

			
 
				-    const Theme::UVs maxCap = getImageUVs("maxCap", _state);

			
 
				-    const Theme::UVs marker = getImageUVs("marker", _state);

			
 
				-    const Theme::UVs track = getImageUVs("track", _state);

			
 
				-

			
 
				-    Vector4 minCapColor = getImageColor("minCap", _state);

			
 
				-    Vector4 maxCapColor = getImageColor("maxCap", _state);

			
 
				-    Vector4 markerColor = getImageColor("marker", _state);

			
 
				-    Vector4 trackColor = getImageColor("track", _state);

			
 
				-

			
 
				-    float opacity = getOpacity(_state);

			
 
				-    minCapColor.w *= opacity;

			
 
				-    maxCapColor.w *= opacity;

			
 
				-    markerColor.w *= opacity;

			
 
				-    trackColor.w *= opacity;

			
 
				+    const Rectangle& minCapRegion = _minImage->getRegion();

			
 
				+    const Rectangle& maxCapRegion = _maxImage->getRegion();

			
 
				+    const Rectangle& markerRegion = _markerImage->getRegion();

			
 
				+    const Rectangle& trackRegion = _trackImage->getRegion();

			
 
				+

			
 
				+    const Theme::UVs minCap = _minImage->getUVs();

			
 
				+    const Theme::UVs maxCap = _maxImage->getUVs();

			
 
				+    const Theme::UVs marker = _markerImage->getUVs();

			
 
				+    const Theme::UVs track = _trackImage->getUVs();

			
 
				+

			
 
				+    Vector4 minCapColor = _minImage->getColor();

			
 
				+    Vector4 maxCapColor = _maxImage->getColor();

			
 
				+    Vector4 markerColor = _markerImage->getColor();

			
 
				+    Vector4 trackColor = _trackImage->getColor();

			
 
				+

			
 
				+    minCapColor.w *= _opacity;

			
 
				+    maxCapColor.w *= _opacity;

			
 
				+    markerColor.w *= _opacity;

			
 
				+    trackColor.w *= _opacity;

			
 
				 

			
 
				     // Draw order: track, caps, marker.

			
 
				     float midY = clip.y + _clipBounds.y + (_clipBounds.height - border.bottom - padding.bottom) / 2.0f;

			
--- a/gameplay/src/Slider.h
+++ b/gameplay/src/Slider.h
@@ -149,9 +149,14 @@ protected:
 
				      */

			
 
				     void drawImages(SpriteBatch* spriteBatch, const Rectangle& clip);

			
 
				 

			
 
				+<<<<<<< HEAD
			
 
				     /**

			
 
				      * The minimum value for the Slider.

			
 
				      */

			
 
				+=======
			
 
				+    void update(const Rectangle& clip);

			
 
				+

			
 
				+>>>>>>> 6801051a7fa514d1e25fb44f6c95e075c0bfa8be
			
 
				     float _min;

			
 
				     

			
 
				     /**

			
@@ -169,6 +174,11 @@ protected:
 
				      */

			
 
				     float _value;

			
 
				 

			
 
				+    Theme::ThemeImage* _minImage;

			
 
				+    Theme::ThemeImage* _maxImage;

			
 
				+    Theme::ThemeImage* _trackImage;

			
 
				+    Theme::ThemeImage* _markerImage;

			
 
				+

			
 
				 private:

			
 
				 

			
 
				     /**

			
--- a/gameplay/src/TextBox.cpp
+++ b/gameplay/src/TextBox.cpp
@@ -274,7 +274,7 @@ void TextBox::keyEvent(Keyboard::KeyEvent evt, int key)
 
				 

			
 
				 void TextBox::update(const Rectangle& clip)

			
 
				 {

			
 
				-    Control::update(clip);

			
 
				+    Label::update(clip);

			
 
				 

			
 
				     // Get index into string and cursor location from the last recorded touch location.

			
 
				     if (_state == FOCUS)

			
@@ -287,6 +287,9 @@ void TextBox::update(const Rectangle& clip)
 
				         font->getIndexAtLocation(_text.c_str(), _clip, fontSize, _caretLocation, &_caretLocation,

			
 
				             textAlignment, true, rightToLeft);

			
 
				     }

			
 
				+

			
 
				+    _fontSize = getFontSize(_state);

			
 
				+    _caretImage = getImage("textCaret", _state);

			
 
				 }

			
 
				 

			
 
				 void TextBox::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)

			
@@ -294,14 +297,14 @@ void TextBox::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)
 
				     if (_state == FOCUS)

			
 
				     {

			
 
				         // Draw the cursor at its current location.

			
 
				-        const Rectangle& region = getImageRegion("textCaret", _state);

			
 
				+        const Rectangle& region = _caretImage->getRegion();

			
 
				         if (!region.isEmpty())

			
 
				         {

			
 
				-            const Vector4& color = getImageColor("textCaret", _state);

			
 
				-            const Theme::UVs uvs = getImageUVs("textCaret", _state);

			
 
				-            unsigned int fontSize = getFontSize(_state);

			
 
				+            const Theme::UVs uvs = _caretImage->getUVs();

			
 
				+            Vector4 color = _caretImage->getColor();

			
 
				+            color.w *= _opacity;

			
 
				 

			
 
				-            spriteBatch->draw(_caretLocation.x - (region.width / 2.0f), _caretLocation.y, region.width, fontSize, uvs.u1, uvs.v1, uvs.u2, uvs.v2, color);

			
 
				+            spriteBatch->draw(_caretLocation.x - (region.width / 2.0f), _caretLocation.y, region.width, _fontSize, uvs.u1, uvs.v1, uvs.u2, uvs.v2, color);

			
 
				         }

			
 
				     }

			
 
				 

			
@@ -310,7 +313,7 @@ void TextBox::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)
 
				 

			
 
				 void TextBox::setCaretLocation(int x, int y)

			
 
				 {

			
 
				-    Theme::Border border = getBorder(_state);

			
 
				+    const Theme::Border& border = getBorder(_state);

			
 
				     Theme::Padding padding = getPadding();

			
 
				 

			
 
				     _caretLocation.set(x - border.left - padding.left + _clip.x,

			
--- a/gameplay/src/TextBox.h
+++ b/gameplay/src/TextBox.h
@@ -136,6 +136,8 @@ protected:
 
				      * The last character that was entered into the TextBox.

			
 
				      */

			
 
				     int _lastKeypress;

			
 
				+    unsigned int _fontSize;

			
 
				+    Theme::ThemeImage* _caretImage;

			
 
				 

			
 
				 private:

			
 
				 

			
--- a/gameplay/src/Theme.cpp
+++ b/gameplay/src/Theme.cpp
@@ -25,7 +25,7 @@ namespace gameplay
 
				 

			
 
				         for (unsigned int i = 0, count = _images.size(); i < count; ++i)

			
 
				         {

			
 
				-            Image* image = _images[i];

			
 
				+            ThemeImage* image = _images[i];

			
 
				             SAFE_RELEASE(image);

			
 
				         }

			
 
				 

			
@@ -106,7 +106,7 @@ namespace gameplay
 
				             

			
 
				             if (strcmp(spacename, "image") == 0)

			
 
				             {

			
 
				-                theme->_images.push_back(Image::create(tw, th, space, Vector4::one()));

			
 
				+                theme->_images.push_back(ThemeImage::create(tw, th, space, Vector4::one()));

			
 
				             }

			
 
				             else if (strcmp(spacename, "imageList") == 0)

			
 
				             {

			
@@ -196,7 +196,7 @@ namespace gameplay
 
				                         }

			
 
				 

			
 
				                         ImageList* imageList = NULL;

			
 
				-                        Image* cursor = NULL;

			
 
				+                        ThemeImage* cursor = NULL;

			
 
				                         Skin* skin = NULL;

			
 
				                         theme->lookUpSprites(innerSpace, &imageList, &cursor, &skin);

			
 
				 

			
@@ -307,7 +307,7 @@ namespace gameplay
 
				                         }

			
 
				 

			
 
				                         ImageList* imageList = NULL;

			
 
				-                        Image* cursor = NULL;

			
 
				+                        ThemeImage* cursor = NULL;

			
 
				                         Skin* skin = NULL;

			
 
				                         theme->lookUpSprites(innerSpace, &imageList, &cursor, &skin);

			
 
				 

			
@@ -468,19 +468,19 @@ namespace gameplay
 
				     }

			
 
				 

			
 
				     /****************

			
 
				-     * Theme::Image *

			
 
				+     * Theme::ThemeImage *

			
 
				      ****************/

			
 
				-    Theme::Image::Image(float tw, float th, const Rectangle& region, const Vector4& color)

			
 
				+    Theme::ThemeImage::ThemeImage(float tw, float th, const Rectangle& region, const Vector4& color)

			
 
				         : _region(region), _color(color)

			
 
				     {

			
 
				         generateUVs(tw, th, region.x, region.y, region.width, region.height, &_uvs);

			
 
				     }

			
 
				 

			
 
				-    Theme::Image::~Image()

			
 
				+    Theme::ThemeImage::~ThemeImage()

			
 
				     {

			
 
				     }

			
 
				 

			
 
				-    Theme::Image* Theme::Image::create(float tw, float th, Properties* properties, const Vector4& defaultColor)

			
 
				+    Theme::ThemeImage* Theme::ThemeImage::create(float tw, float th, Properties* properties, const Vector4& defaultColor)

			
 
				     {

			
 
				         Vector4 regionVector;                

			
 
				         properties->getVector4("region", &regionVector);

			
@@ -496,7 +496,7 @@ namespace gameplay
 
				             color.set(defaultColor);

			
 
				         }

			
 
				 

			
 
				-        Image* image = new Image(tw, th, region, color);

			
 
				+        ThemeImage* image = new ThemeImage(tw, th, region, color);

			
 
				         const char* id = properties->getId();

			
 
				         if (id)

			
 
				         {

			
@@ -506,22 +506,22 @@ namespace gameplay
 
				         return image;

			
 
				     }

			
 
				 

			
 
				-    const char* Theme::Image::getId() const

			
 
				+    const char* Theme::ThemeImage::getId() const

			
 
				     {

			
 
				         return _id.c_str();

			
 
				     }

			
 
				 

			
 
				-    const Theme::UVs& Theme::Image::getUVs() const

			
 
				+    const Theme::UVs& Theme::ThemeImage::getUVs() const

			
 
				     {

			
 
				         return _uvs;

			
 
				     }

			
 
				 

			
 
				-    const Rectangle& Theme::Image::getRegion() const

			
 
				+    const Rectangle& Theme::ThemeImage::getRegion() const

			
 
				     {

			
 
				         return _region;

			
 
				     }

			
 
				 

			
 
				-    const Vector4& Theme::Image::getColor() const

			
 
				+    const Vector4& Theme::ThemeImage::getColor() const

			
 
				     {

			
 
				         return _color;

			
 
				     }

			
@@ -538,20 +538,20 @@ namespace gameplay
 
				         _id = copy._id;

			
 
				         _color = copy._color;

			
 
				 

			
 
				-        std::vector<Image*>::const_iterator it;

			
 
				+        std::vector<ThemeImage*>::const_iterator it;

			
 
				         for (it = copy._images.begin(); it != copy._images.end(); it++)

			
 
				         {

			
 
				-            Image* image = *it;

			
 
				-            _images.push_back(new Image(*image));

			
 
				+            ThemeImage* image = *it;

			
 
				+            _images.push_back(new ThemeImage(*image));

			
 
				         }

			
 
				     }

			
 
				 

			
 
				     Theme::ImageList::~ImageList()

			
 
				     {

			
 
				-        std::vector<Image*>::const_iterator it;

			
 
				+        std::vector<ThemeImage*>::const_iterator it;

			
 
				         for (it = _images.begin(); it != _images.end(); it++)

			
 
				         {

			
 
				-            Image* image = *it;

			
 
				+            ThemeImage* image = *it;

			
 
				             SAFE_RELEASE(image);

			
 
				         }

			
 
				     }

			
@@ -575,7 +575,7 @@ namespace gameplay
 
				         Properties* space = properties->getNextNamespace();

			
 
				         while (space != NULL)

			
 
				         {

			
 
				-            Image* image = Image::create(tw, th, space, color);

			
 
				+            ThemeImage* image = ThemeImage::create(tw, th, space, color);

			
 
				             imageList->_images.push_back(image);

			
 
				             space = properties->getNextNamespace();

			
 
				         }

			
@@ -588,12 +588,12 @@ namespace gameplay
 
				         return _id.c_str();

			
 
				     }

			
 
				 

			
 
				-    Theme::Image* Theme::ImageList::getImage(const char* imageId) const

			
 
				+    Theme::ThemeImage* Theme::ImageList::getImage(const char* imageId) const

			
 
				     {

			
 
				-        std::vector<Image*>::const_iterator it;

			
 
				+        std::vector<ThemeImage*>::const_iterator it;

			
 
				         for (it = _images.begin(); it != _images.end(); it++)

			
 
				         {

			
 
				-            Image* image = *it;

			
 
				+            ThemeImage* image = *it;

			
 
				             if (strcmp(image->getId(), imageId) == 0)

			
 
				             {

			
 
				                 return image;

			
@@ -724,7 +724,7 @@ namespace gameplay
 
				         uvs->v2 = 1.0f - ((y + height) * th);

			
 
				     }

			
 
				 

			
 
				-    void Theme::lookUpSprites(const Properties* overlaySpace, ImageList** imageList, Image** cursor, Skin** Skin)

			
 
				+    void Theme::lookUpSprites(const Properties* overlaySpace, ImageList** imageList, ThemeImage** cursor, Skin** Skin)

			
 
				     {

			
 
				         const char* imageListString = overlaySpace->getString("imageList");

			
 
				         if (imageListString)

			
--- a/gameplay/src/Theme.h
+++ b/gameplay/src/Theme.h
@@ -248,14 +248,12 @@ public:
 
				      */

			
 
				     typedef SideRegions Padding;

			
 
				 

			
 
				-private:

			
 
				-

			
 
				     /**

			
 
				      * Class representing an image within the theme's texture atlas.

			
 
				      * An image has a region and a blend color in addition to an ID.

			
 
				      * UV coordinates are calculated from the region and can be retrieved.

			
 
				      */

			
 
				-    class Image : public Ref

			
 
				+    class ThemeImage : public Ref

			
 
				     {

			
 
				         friend class Theme;

			
 
				         friend class Control;

			
@@ -272,11 +270,11 @@ private:
 
				 

			
 
				     private:

			
 
				 

			
 
				-        Image(float tw, float th, const Rectangle& region, const Vector4& color);

			
 
				+        ThemeImage(float tw, float th, const Rectangle& region, const Vector4& color);

			
 
				 

			
 
				-        ~Image();

			
 
				+        ~ThemeImage();

			
 
				 

			
 
				-        static Image* create(float tw, float th, Properties* properties, const Vector4& defaultColor);

			
 
				+        static ThemeImage* create(float tw, float th, Properties* properties, const Vector4& defaultColor);

			
 
				 

			
 
				         std::string _id;

			
 
				         UVs _uvs;

			
@@ -284,6 +282,8 @@ private:
 
				         Vector4 _color;

			
 
				     };

			
 
				 

			
 
				+private:

			
 
				+

			
 
				     /**

			
 
				      * Class representing a collection of theme images.  An image list

			
 
				      * can be assigned to each overlay of a style, and controls

			
@@ -298,7 +298,7 @@ private:
 
				 

			
 
				         const char* getId() const;

			
 
				 

			
 
				-        Image* getImage(const char* imageId) const;

			
 
				+        ThemeImage* getImage(const char* imageId) const;

			
 
				 

			
 
				     private:

			
 
				 

			
@@ -311,7 +311,7 @@ private:
 
				         static ImageList* create(float tw, float th, Properties* properties);

			
 
				 

			
 
				         std::string _id;

			
 
				-        std::vector<Image*> _images;

			
 
				+        std::vector<ThemeImage*> _images;

			
 
				         Vector4 _color;

			
 
				     };

			
 
				 

			
@@ -411,13 +411,13 @@ private:
 
				 

			
 
				     static void generateUVs(float tw, float th, float x, float y, float width, float height, UVs* uvs);

			
 
				 

			
 
				-    void lookUpSprites(const Properties* overlaySpace, ImageList** imageList, Image** mouseCursor, Skin** skin);

			
 
				+    void lookUpSprites(const Properties* overlaySpace, ImageList** imageList, ThemeImage** mouseCursor, Skin** skin);

			
 
				 

			
 
				     std::string _path;

			
 
				     Texture* _texture;

			
 
				     SpriteBatch* _spriteBatch;

			
 
				     std::vector<Style*> _styles;

			
 
				-    std::vector<Image*> _images;

			
 
				+    std::vector<ThemeImage*> _images;

			
 
				     std::vector<ImageList*> _imageLists;

			
 
				     std::vector<Skin*> _skins;

			
 
				     std::set<Font*> _fonts;

			
--- a/gameplay/src/ThemeStyle.cpp
+++ b/gameplay/src/ThemeStyle.cpp
@@ -96,7 +96,7 @@ Theme::Style::Overlay::Overlay(const Overlay& copy) : _skin(NULL), _cursor(NULL)
 
				     }

			
 
				     if (copy._cursor)

			
 
				     {

			
 
				-        _cursor = new Image(*copy._cursor);

			
 
				+        _cursor = new ThemeImage(*copy._cursor);

			
 
				     }

			
 
				     if (copy._imageList)

			
 
				     {

			
@@ -263,7 +263,7 @@ void Theme::Style::Overlay::setTextColor(const Vector4& color)
 
				 

			
 
				 const Rectangle& Theme::Style::Overlay::getImageRegion(const char* id) const

			
 
				 {

			
 
				-    Image* image = _imageList->getImage(id);

			
 
				+    ThemeImage* image = _imageList->getImage(id);

			
 
				     if (image)

			
 
				     {

			
 
				         return image->getRegion();

			
@@ -276,7 +276,7 @@ const Rectangle& Theme::Style::Overlay::getImageRegion(const char* id) const
 
				     

			
 
				 void Theme::Style::Overlay::setImageRegion(const char* id, const Rectangle& region, float tw, float th)

			
 
				 {

			
 
				-    Image* image = _imageList->getImage(id);

			
 
				+    ThemeImage* image = _imageList->getImage(id);

			
 
				     assert(image);

			
 
				     image->_region.set(region);

			
 
				     generateUVs(tw, th, region.x, region.y, region.width, region.height, &(image->_uvs));

			
@@ -284,7 +284,7 @@ void Theme::Style::Overlay::setImageRegion(const char* id, const Rectangle& regi
 
				 

			
 
				 const Vector4& Theme::Style::Overlay::getImageColor(const char* id) const

			
 
				 {

			
 
				-    Image* image = _imageList->getImage(id);

			
 
				+    ThemeImage* image = _imageList->getImage(id);

			
 
				     if (image)

			
 
				     {

			
 
				         return image->getColor();

			
@@ -297,14 +297,14 @@ const Vector4& Theme::Style::Overlay::getImageColor(const char* id) const
 
				 

			
 
				 void Theme::Style::Overlay::setImageColor(const char* id, const Vector4& color)

			
 
				 {

			
 
				-    Image* image = _imageList->getImage(id);

			
 
				+    ThemeImage* image = _imageList->getImage(id);

			
 
				     assert(image);

			
 
				     image->_color.set(color);

			
 
				 }

			
 
				 

			
 
				 const Theme::UVs& Theme::Style::Overlay::getImageUVs(const char* id) const

			
 
				 {

			
 
				-    Image* image = _imageList->getImage(id);

			
 
				+    ThemeImage* image = _imageList->getImage(id);

			
 
				     if (image)

			
 
				     {

			
 
				         return image->getUVs();

			
@@ -383,7 +383,7 @@ Theme::Skin* Theme::Style::Overlay::getSkin() const
 
				     return _skin;

			
 
				 }

			
 
				 

			
 
				-void Theme::Style::Overlay::setCursor(Image* cursor)

			
 
				+void Theme::Style::Overlay::setCursor(ThemeImage* cursor)

			
 
				 {

			
 
				     if (_cursor != cursor)

			
 
				     {

			
@@ -397,7 +397,7 @@ void Theme::Style::Overlay::setCursor(Image* cursor)
 
				     }

			
 
				 }

			
 
				 

			
 
				-Theme::Image* Theme::Style::Overlay::getCursor() const

			
 
				+Theme::ThemeImage* Theme::Style::Overlay::getCursor() const

			
 
				 {

			
 
				     return _cursor;

			
 
				 }

			
--- a/gameplay/src/ThemeStyle.h
+++ b/gameplay/src/ThemeStyle.h
@@ -138,9 +138,9 @@ private:
 
				 

			
 
				         Theme::Skin* getSkin() const;

			
 
				 

			
 
				-        void setCursor(Theme::Image* cursor);

			
 
				+        void setCursor(Theme::ThemeImage* cursor);

			
 
				             

			
 
				-        Theme::Image* getCursor() const;

			
 
				+        Theme::ThemeImage* getCursor() const;

			
 
				             

			
 
				         void setImageList(Theme::ImageList* imageList);

			
 
				             

			
@@ -149,7 +149,7 @@ private:
 
				         void applyAnimationValueOpacity(float opacity, float blendWeight);

			
 
				 

			
 
				         Skin* _skin;

			
 
				-        Theme::Image* _cursor;

			
 
				+        Theme::ThemeImage* _cursor;

			
 
				         Theme::ImageList* _imageList;

			
 
				         Font* _font;

			
 
				         unsigned int _fontSize;