Merge pull request #197 from blackberry-gaming/next

Next

gameplay-encoder/src/EncoderArguments.cpp

@@ -181,7 +181,7 @@ void EncoderArguments::printUsage() const
     fprintf(stderr,"  -t\t\t\tWrite text/xml.\n");
     fprintf(stderr,"  -g <node id> <animation id>\n" \
         "\t\t\tGroup all animation channels targetting the nodes into a new animation.\n");
-    fprintf(stderr,"  -heightmaps \"<node ids>\"\n" \
+    fprintf(stderr,"  -h \"<node ids>\"\n" \
         "\t\t\tList of nodes to generate heightmaps for.\n" \
         "\t\t\tNode id list should be in quotes with a space between each id.\n" \
         "\t\t\tHeightmaps will be saved in files named <nodeid>.png.\n");
@@ -313,7 +313,7 @@ void EncoderArguments::readOption(const std::vector<std::string>& options, size_
         break;
     case 'h':
         {
-            if (str.compare("-heightmaps") == 0)
+            if (str.compare("-heightmaps") == 0 || str.compare("-h") == 0)
             {
                 (*index)++;
                 if (*index < options.size())

gameplay-encoder/src/GPBDecoder.cpp

@@ -40,9 +40,10 @@ void GPBDecoder::readBinary(const std::string& filepath)
 bool GPBDecoder::validateHeading()
 {
     const size_t HEADING_SIZE = 9;
-    const char identifier[] = { '«', 'G', 'P', 'B', '»', '\r', '\n', '\x1A', '\n' };
+    const char identifier[] = "\xABGPB\xBB\r\n\x1A\n";
 
     char heading[HEADING_SIZE];
+    fread(heading, sizeof(unsigned char), HEADING_SIZE, _file);
     for (size_t i = 0; i < HEADING_SIZE; ++i)
     {
         if (heading[i] != identifier[i])

gameplay/src/AnimationClip.h

@@ -256,6 +256,11 @@ private:
          */
         ~ListenerEvent();
 
+        /**
+         * Hidden copy assignment operator.
+         */
+        ListenerEvent& operator=(const ListenerEvent&);
+
         Listener* _listener;        // This listener to call back when this event is triggered.
         unsigned long _eventTime;   // The time at which the listener will be called back at during the playback of the AnimationClip.
     };
@@ -280,6 +285,11 @@ private:
      */
     ~AnimationClip();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    AnimationClip& operator=(const AnimationClip&);
+
     /**
      * Updates the animation with the elapsed time.
      */

gameplay/src/AudioBuffer.h

@@ -29,6 +29,11 @@ private:
      */
     virtual ~AudioBuffer();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    AudioBuffer& operator=(const AudioBuffer&);
+
     /**
      * Creates an audio buffer from a file.
      * 

gameplay/src/AudioSource.h

@@ -158,6 +158,11 @@ private:
      */
     virtual ~AudioSource();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    AudioSource& operator=(const AudioSource&);
+
     /**
      * Sets the node for this audio source.
      */

gameplay/src/Bundle.h

@@ -151,6 +151,11 @@ private:
      */
     ~Bundle();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Bundle& operator=(const Bundle&);
+
     /**
      * Finds a reference by ID.
      */

gameplay/src/Camera.h

@@ -246,6 +246,11 @@ private:
      */
     virtual ~Camera();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Camera& operator=(const Camera&);
+
     /**
      * Clones the camera and returns a new camera.
      * 

gameplay/src/Control.h

@@ -755,6 +755,11 @@ protected:
      */
     virtual ~Control();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Control& operator=(const Control&);
+
     /**
      * Get the overlay type corresponding to this control's current state.
      *

gameplay/src/Curve.h

@@ -385,6 +385,11 @@ private:
          * Destructor.
          */
         ~Point();
+
+        /**
+         * Hidden copy assignment operator.
+         */
+        Point& operator=(const Point&);
     };
 
     /**
@@ -411,7 +416,7 @@ private:
     ~Curve();
 
     /**
-     * Copy assignment operator.
+     * Hidden copy assignment operator.
      */
     Curve& operator=(const Curve&);
 

gameplay/src/DepthStencilTarget.h

@@ -83,6 +83,11 @@ private:
      */
     ~DepthStencilTarget();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    DepthStencilTarget& operator=(const DepthStencilTarget&);
+
     std::string _id;
     Format _format;
     RenderBufferHandle _renderBuffer;

gameplay/src/Effect.h

@@ -223,6 +223,11 @@ private:
      */
     ~Effect();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Effect& operator=(const Effect&);
+
     static Effect* createFromSource(const char* vshPath, const char* vshSource, const char* fshPath, const char* fshSource, const char* defines = NULL);
 
     GLuint _program;
@@ -279,6 +284,11 @@ private:
      */
     ~Uniform();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Uniform& operator=(const Uniform&);
+
     std::string _name;
     GLint _location;
     GLenum _type;

gameplay/src/Font.h

@@ -96,6 +96,11 @@ public:
          */
         ~Text();
 
+        /**
+         * Hidden copy assignment operator.
+         */
+        Text& operator=(const Text&);
+
         /**
          * Get the string that will be drawn from this Text object.
          */
@@ -286,6 +291,11 @@ private:
      */
     ~Font();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Font& operator=(const Font&);
+
     void getMeasurementInfo(const char* text, const Rectangle& area, unsigned int size, Justify justify, bool wrap, bool rightToLeft,
                             std::vector<int>* xPositions, int* yPosition, std::vector<unsigned int>* lineLengths);
 

gameplay/src/FrameBuffer.h

@@ -127,6 +127,11 @@ private:
      */
     ~FrameBuffer();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    FrameBuffer& operator=(const FrameBuffer&);
+
     static void initialize();
 
     static bool isPowerOfTwo(unsigned int value);

gameplay/src/Game.cpp

@@ -63,6 +63,31 @@ void Game::setVsync(bool enable)
     Platform::setVsync(enable);
 }
 
+bool Game::hasMouse()
+{
+    return Platform::hasMouse();
+}
+
+bool Game::isMouseCaptured()
+{
+    return Platform::isMouseCaptured();
+}
+
+void Game::setMouseCapture(bool captured)
+{
+    Platform::setMouseCapture(captured);
+}
+
+void Game::setCursorVisible(bool visible)
+{
+    Platform::setCursorVisible(visible);
+}
+
+bool Game::isCursorVisible()
+{
+    return Platform::isCursorVisible();
+}
+
 bool Game::isVsync()
 {
     return Platform::isVsync();

gameplay/src/Game.h

@@ -76,6 +76,53 @@ public:
      */
     static void setVsync(bool enable);
 
+    /** 
+     * Gets whether the current platform supports mouse input.
+     *
+      * @return true if a mouse is supported, false otherwise.
+      */
+    static bool hasMouse();
+
+    /**
+     * Gets whether mouse input is currently captured.
+     *
+     * @see Platform::isMouseCaptured()
+     */
+    static bool isMouseCaptured();
+
+    /**
+     * Enables or disables mouse capture.
+     *
+     * On platforms that support a mouse, when mouse capture is enabled,
+     * the platform cursor will be hidden and the mouse will be warped
+     * to the center of the screen. While mouse capture is enabled,
+     * all mouse move events will then be delivered as deltas instead
+     * of absolute positions.
+     *
+     * @param captured true to enable mouse capture mode, false to disable it.
+     *
+     * @see Platform::setMouseCapture(bool)
+     */
+    static void setMouseCapture(bool captured);
+
+    /**
+     * Sets the visibility of the platform cursor.
+     *
+     * @param visible true to show the platform cursor, false to hide it.
+     *
+     * @see Platform::setCursorVisible(bool)
+     */
+    static void setCursorVisible(bool visible);
+
+    /**
+     * Determines whether the platform cursor is currently visible.
+     *
+     * @return true if the platform cursor is visible, false otherwise.
+     *
+     * @see Platform::isCursorVisible()
+     */
+    static bool isCursorVisible();
+
     /**
      * Gets the total absolute running time (in milliseconds) since Game::run().
      * 
@@ -100,6 +147,13 @@ public:
      */
     inline State getState() const;
 
+    /**
+     * Determines if the game has been initialized.
+     *
+     * @return true if the game initialization has completed, false otherwise.
+     */
+    inline bool isInitialized() const;
+
     /**
      * Returns the game configuration object.
      *

gameplay/src/Game.inl

@@ -9,6 +9,11 @@ inline Game::State Game::getState() const
     return _state;
 }
 
+inline bool Game::isInitialized() const
+{
+    return _initialized;
+}
+
 inline unsigned int Game::getFrameRate() const
 {
     return _frameRate;

gameplay/src/Image.h

@@ -70,6 +70,11 @@ private:
      */
     ~Image();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Image& operator=(const Image&);
+
     unsigned char* _data;
     Format _format;
     unsigned int _height;

gameplay/src/Joint.h

@@ -91,7 +91,7 @@ private:
     Joint(const Joint& copy);
 
     /**
-     * Copy assignment operator.
+     * Hidden copy assignment operator.
      */
     Joint& operator=(const Joint&);
 

gameplay/src/Light.h

@@ -65,6 +65,11 @@ public:
      */
     virtual ~Light();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Light& operator=(const Light&);
+
     /**
      * Returns the light type.
      * 

gameplay/src/MaterialParameter.h

@@ -177,6 +177,11 @@ private:
      * Destructor.
      */
     ~MaterialParameter();
+
+    /**
+     * Hidden copy assignment operator.
+     */
+    MaterialParameter& operator=(const MaterialParameter&);
     
     /**
      * Interface implemented by templated method bindings for simple storage and iteration.
@@ -191,6 +196,11 @@ private:
          * Destructor.
          */
         virtual ~MethodBinding() { }
+
+        /**
+         * Hidden copy assignment operator.
+         */
+        MethodBinding& operator=(const MethodBinding&);
     };
 
     /**

gameplay/src/Mesh.h

@@ -302,6 +302,11 @@ private:
      */
     Mesh(const Mesh& copy);
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Mesh& operator=(const Mesh&);
+
     std::string _url;
     const VertexFormat _vertexFormat;
     unsigned int _vertexCount;

gameplay/src/MeshSkin.h

@@ -128,7 +128,7 @@ private:
     ~MeshSkin();
     
     /**
-     * Copy assignment operator.
+     * Hidden copy assignment operator.
      */
     MeshSkin& operator=(const MeshSkin&);
 

gameplay/src/Model.h

@@ -157,6 +157,11 @@ private:
      */
     ~Model();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Model& operator=(const Model&);
+
     /**
      * Sets the MeshSkin for this model.
      * 

gameplay/src/ParticleEmitter.h

@@ -637,6 +637,11 @@ private:
      */
     ~ParticleEmitter();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    ParticleEmitter& operator=(const ParticleEmitter&);
+
     /**
      * Sets the node that this emitter is attached to.
      */

gameplay/src/Platform.h

@@ -91,7 +91,10 @@ public:
     static void setVsync(bool enable);
 
     /**
-     * Set if multi-touch is enabled on the platform
+     * Set if multi-touch is enabled on the platform.
+     *
+     * Note that this method does nothing on platforms that do not
+     * support multi-touch.
      */
     static void setMultiTouch(bool enabled);
 
@@ -100,6 +103,54 @@ public:
     */
     static bool isMultiTouch();
 
+    /**
+     * Whether the platform has mouse support.
+     */
+    static bool hasMouse();
+    
+    /**
+     * Enables or disabled mouse capture.
+     *
+     * When mouse capture is enabled, the platform cursor is hidden
+     * and mouse event points are delivered as position deltas instead
+     * of absolute positions.
+     *
+     * This is useful for games that wish to provide uninhibited mouse
+     * movement, such as when implementing free/mouse look in an FPS
+     * game.
+     *
+     * Disabling mouse capture moves the mouse back to the center of the
+     * screen and shows the platform cursor.
+     *
+     * Note that this method does nothing on platforms that do not
+     * support a mouse.
+     *
+     * @param captured True to enable mouse capture, false to disable it.
+     */
+    static void setMouseCapture(bool captured);
+
+    /**
+     * Determines if mouse capture is currently enabled.
+     */
+    static bool isMouseCaptured();
+
+    /**
+     * Sets the visibility of the platform cursor.
+     *
+     * On platforms that support a visible cursor, this method
+     * toggles the visibility of the cursor.
+     *
+     * @param visible true to show the platform cursor, false to hide it.
+     */
+    static void setCursorVisible(bool visible);
+
+    /**
+     * Determines whether the platform cursor is currently visible.
+     *
+     * @return true if the platform cursor is visible, false otherwise.
+     */
+    static bool isCursorVisible();
+
     /**
      * Gets the platform accelerometer values.
      * 

gameplay/src/PlatformAndroid.cpp

@@ -924,6 +924,34 @@ void Platform::getAccelerometerValues(float* pitch, float* roll)
     }
 }
 
+bool Platform::hasMouse()
+{
+    // not supported
+    return false;
+}
+
+void Platform::setMouseCapture(bool captured)
+{
+    // not supported
+}
+
+bool Platform::isMouseCaptured()
+{
+    // not supported
+    return false;
+}
+
+void Platform::setCursorVisible(bool visible)
+{
+    // not supported
+}
+
+bool Platform::isCursorVisible()
+{
+    // not supported
+    return false;
+}
+
 void Platform::swapBuffers()
 {
     if (__eglDisplay && __eglSurface)

gameplay/src/PlatformQNX.cpp

@@ -1120,6 +1120,34 @@ void Platform::getAccelerometerValues(float* pitch, float* roll)
     }
 }
 
+bool Platform::hasMouse()
+{
+    // not supported
+    return false;
+}
+
+void Platform::setMouseCapture(bool captured)
+{
+    // not supported
+}
+
+bool Platform::isMouseCaptured()
+{
+    // not supported
+    return false;
+}
+
+void Platform::setCursorVisible(bool visible)
+{
+    // not supported
+}
+
+bool Platform::isCursorVisible()
+{
+    // not supported
+    return false;
+}
+
 void Platform::swapBuffers()
 {
     if (__eglDisplay && __eglSurface)

gameplay/src/PlatformWin32.cpp

@@ -24,6 +24,9 @@ static HINSTANCE __hinstance = 0;
 static HWND __hwnd = 0;
 static HDC __hdc = 0;
 static HGLRC __hrc = 0;
+static bool __mouseCaptured = false;
+static POINT __mouseCapturePoint = { 0, 0 };
+static bool __cursorVisible = true;
 
 static gameplay::Keyboard::Key getKey(WPARAM win32KeyCode, bool shiftDown)
 {
@@ -255,9 +258,18 @@ void UpdateCapture(LPARAM lParam)
         ReleaseCapture();
 }
 
+void WarpMouse(int clientX, int clientY)
+{
+    POINT p = { clientX, clientY };
+    ClientToScreen(__hwnd, &p);
+    SetCursorPos(p.x, p.y);
+}
+
 LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
-    if (hwnd != __hwnd)
+    static gameplay::Game* game = gameplay::Game::getInstance();
+
+    if (!game->isInitialized() || hwnd != __hwnd)
     {
         // Ignore messages that are not for our game window.
         return DefWindowProc(hwnd, msg, wParam, lParam);
@@ -335,6 +347,21 @@ LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         int x = GET_X_LPARAM(lParam);
         int y = GET_Y_LPARAM(lParam);
 
+        if (__mouseCaptured)
+        {
+            // If the incoming position is the mouse capture point, ignore this event
+            // since this is the event that warped the cursor back.
+            if (x == __mouseCapturePoint.x && y == __mouseCapturePoint.y)
+                break;
+
+            // Convert to deltas
+            x -= __mouseCapturePoint.x;
+            y -= __mouseCapturePoint.y;
+
+            // Warp mouse back to center of screen.
+            WarpMouse(__mouseCapturePoint.x, __mouseCapturePoint.y);
+        }
+
         // Allow Game::mouseEvent a chance to handle (and possibly consume) the event.
         if (!gameplay::Platform::mouseEventInternal(gameplay::Mouse::MOUSE_MOVE, x, y, 0))
         {
@@ -690,7 +717,7 @@ unsigned int Platform::getDisplayHeight()
 {
     return __height;
 }
-    
+
 double Platform::getAbsoluteTime()
 {
     LARGE_INTEGER queryTime;
@@ -719,6 +746,7 @@ void Platform::setVsync(bool enable)
 
 void Platform::setMultiTouch(bool enabled)
 {
+    // not supported
 }
 
 bool Platform::isMultiTouch()
@@ -735,6 +763,54 @@ void Platform::getAccelerometerValues(float* pitch, float* roll)
     *roll = __roll;
 }
 
+bool Platform::hasMouse()
+{
+    return true;
+}
+
+void Platform::setMouseCapture(bool captured)
+{
+    if (captured != __mouseCaptured)
+    {
+        if (captured)
+        {
+            // Hide the cursor and warp it to the center of the screen
+            __mouseCapturePoint.x = getDisplayWidth() / 2;
+            __mouseCapturePoint.y = getDisplayHeight() / 2;
+
+            ShowCursor(FALSE);
+            WarpMouse(__mouseCapturePoint.x, __mouseCapturePoint.y);
+        }
+        else
+        {
+            // Restore cursor
+            WarpMouse(__mouseCapturePoint.x, __mouseCapturePoint.y);
+            ShowCursor(TRUE);
+        }
+
+        __mouseCaptured = captured;
+    }
+}
+
+bool Platform::isMouseCaptured()
+{
+    return __mouseCaptured;
+}
+
+void Platform::setCursorVisible(bool visible)
+{
+    if (visible != __cursorVisible)
+    {
+        ShowCursor(visible ? TRUE : FALSE);
+        __cursorVisible = visible;
+    }
+}
+
+bool Platform::isCursorVisible()
+{
+    return __cursorVisible;
+}
+
 void Platform::swapBuffers()
 {
     if (__hdc)

gameplay/src/PlatformiOS.mm

@@ -894,6 +894,34 @@ void Platform::getAccelerometerValues(float* pitch, float* roll)
     [__appDelegate getAccelerometerPitch:pitch roll:roll];
 }
 
+bool Platform::hasMouse()
+{
+    // not supported
+    return false;
+}
+
+void Platform::setMouseCapture(bool captured)
+{
+    // not supported
+}
+
+bool Platform::isMouseCaptured()
+{
+    // not supported
+    return false;
+}
+
+void Platform::setCursorVisible(bool visible)
+{
+    // not supported
+}
+
+bool Platform::isCursorVisible()
+{
+    // not supported
+    return false;
+}
+
 void Platform::setMultiTouch(bool enabled) 
 {
     __view.multipleTouchEnabled = enabled;

gameplay/src/RenderState.cpp

@@ -361,7 +361,7 @@ void RenderState::cloneInto(RenderState* renderState, NodeCloneContext& context)
 
 RenderState::StateBlock::StateBlock()
     : _cullFaceEnabled(false), _depthTestEnabled(false), _depthWriteEnabled(false),
-      _blendEnabled(false), _blendSrc(RenderState::BLEND_ONE), _blendDst(RenderState::BLEND_ONE),
+      _blendEnabled(false), _blendSrc(RenderState::BLEND_ONE), _blendDst(RenderState::BLEND_ZERO),
       _bits(0L)
 {
 }
@@ -455,10 +455,10 @@ void RenderState::StateBlock::restore(long stateOverrideBits)
     }
     if (!(stateOverrideBits & RS_BLEND_FUNC) && (_defaultState->_bits & RS_BLEND_FUNC))
     {
-        GL_ASSERT( glBlendFunc(GL_ONE, GL_ONE) );
+        GL_ASSERT( glBlendFunc(GL_ONE, GL_ZERO) );
         _defaultState->_bits &= ~RS_BLEND_FUNC;
         _defaultState->_blendSrc = RenderState::BLEND_ONE;
-        _defaultState->_blendDst = RenderState::BLEND_ONE;
+        _defaultState->_blendDst = RenderState::BLEND_ZERO;
     }
     if (!(stateOverrideBits & RS_CULL_FACE) && (_defaultState->_bits & RS_CULL_FACE))
     {
@@ -593,8 +593,9 @@ void RenderState::StateBlock::setBlend(bool enabled)
 void RenderState::StateBlock::setBlendSrc(Blend blend)
 {
     _blendSrc = blend;
-    if (_blendSrc == BLEND_ONE && _blendDst == BLEND_ONE)
+    if (_blendSrc == BLEND_ONE && _blendDst == BLEND_ZERO)
     {
+        // Default blend func
         _bits &= ~RS_BLEND_FUNC;
     }
     else
@@ -606,8 +607,9 @@ void RenderState::StateBlock::setBlendSrc(Blend blend)
 void RenderState::StateBlock::setBlendDst(Blend blend)
 {
     _blendDst = blend;
-    if (_blendSrc == BLEND_ONE && _blendDst == BLEND_ONE)
+    if (_blendSrc == BLEND_ONE && _blendDst == BLEND_ZERO)
     {
+        // Default blend func
         _bits &= ~RS_BLEND_FUNC;
     }
     else

gameplay/src/RenderTarget.h

@@ -63,6 +63,11 @@ private:
      */
     ~RenderTarget();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    RenderTarget& operator=(const RenderTarget&);
+
     std::string _id;
     Texture* _texture;
 };

gameplay/src/Scene.h

@@ -216,6 +216,11 @@ private:
      */
     virtual ~Scene();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Scene& operator=(const Scene&);
+
     /**
      * Visits the given node and all of its children recursively.
      */

gameplay/src/Texture.h

@@ -116,6 +116,11 @@ public:
 
         ~Sampler();
 
+        /**
+         * Hidden copy assignment operator.
+         */
+        Sampler& operator=(const Sampler&);
+
         Texture* _texture;
         Wrap _wrapS;
         Wrap _wrapT;
@@ -224,6 +229,11 @@ private:
      */
     virtual ~Texture();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Texture& operator=(const Texture&);
+
     static Texture* createCompressedPVRTC(const char* path);
 
     static Texture* createCompressedDDS(const char* path);

gameplay/src/Theme.h

@@ -348,6 +348,11 @@ private:
 
         ~ImageList();
 
+        /**
+         * Hidden copy assignment operator.
+         */
+        ImageList& operator=(const ImageList&);
+
         static ImageList* create(float tw, float th, Properties* properties);
 
         std::string _id;
@@ -407,6 +412,11 @@ private:
         
         ~Skin();
 
+        /**
+         * Hidden copy assignment operator.
+         */
+        Skin& operator=(const Skin&);
+
         static Skin* create(const char* id, float tw, float th, const Rectangle& region, const Theme::Border& border, const Vector4& color);
 
         void setRegion(const Rectangle& region, float tw, float th);
@@ -434,6 +444,11 @@ private:
      */
     ~Theme();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Theme& operator=(const Theme&);
+
     void setProjectionMatrix(const Matrix& matrix);
 
     SpriteBatch* getSpriteBatch() const;

gameplay/src/ThemeStyle.h

@@ -69,6 +69,11 @@ private:
             
         ~Overlay();
 
+        /**
+         * Hidden copy assignment operator.
+         */
+        Overlay& operator=(const Overlay&);
+
         static Overlay* create();
 
         OverlayType getType();
@@ -186,6 +191,11 @@ private:
      */
     ~Style();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    Style& operator=(const Style&);
+
     /**
      * Returns the Id of this Style.
      */

gameplay/src/VertexAttributeBinding.h

@@ -99,6 +99,11 @@ private:
      */
     ~VertexAttributeBinding();
 
+    /**
+     * Hidden copy assignment operator.
+     */
+    VertexAttributeBinding& operator=(const VertexAttributeBinding&);
+
     static VertexAttributeBinding* create(Mesh* mesh, const VertexFormat& vertexFormat, void* vertexPointer, Effect* effect);
 
     void setVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalize, GLsizei stride, void* pointer);