Rename TransformFeedback members to match the spec.

src/libANGLE/State.cpp

@@ -851,7 +851,7 @@ TransformFeedback *State::getCurrentTransformFeedback() const
 bool State::isTransformFeedbackActiveUnpaused() const
 {
     gl::TransformFeedback *curTransformFeedback = getCurrentTransformFeedback();
-    return curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused();
+    return curTransformFeedback && curTransformFeedback->isActive() && !curTransformFeedback->isPaused();
 }
 
 void State::detachTransformFeedback(GLuint transformFeedback)
@@ -1149,8 +1149,8 @@ void State::getBooleanv(GLenum pname, GLboolean *params)
       case GL_DEPTH_TEST:                *params = mDepthStencil.depthTest;       break;
       case GL_BLEND:                     *params = mBlend.blend;                  break;
       case GL_DITHER:                    *params = mBlend.dither;                 break;
-      case GL_TRANSFORM_FEEDBACK_ACTIVE: *params = getCurrentTransformFeedback()->isStarted(); break;
-      case GL_TRANSFORM_FEEDBACK_PAUSED: *params = getCurrentTransformFeedback()->isPaused();  break;
+      case GL_TRANSFORM_FEEDBACK_ACTIVE: *params = getCurrentTransformFeedback()->isActive() ? GL_TRUE : GL_FALSE; break;
+      case GL_TRANSFORM_FEEDBACK_PAUSED: *params = getCurrentTransformFeedback()->isPaused() ? GL_TRUE : GL_FALSE; break;
       default:
         UNREACHABLE();
         break;

src/libANGLE/TransformFeedback.cpp

@@ -12,60 +12,70 @@ namespace gl
 
 TransformFeedback::TransformFeedback(rx::TransformFeedbackImpl* impl, GLuint id)
     : RefCountObject(id),
-      mTransformFeedback(impl),
-      mStarted(GL_FALSE),
+      mImplementation(impl),
+      mActive(false),
       mPrimitiveMode(GL_NONE),
-      mPaused(GL_FALSE)
+      mPaused(false)
 {
     ASSERT(impl != NULL);
 }
 
 TransformFeedback::~TransformFeedback()
 {
-    SafeDelete(mTransformFeedback);
+    SafeDelete(mImplementation);
 }
 
-void TransformFeedback::start(GLenum primitiveMode)
+void TransformFeedback::begin(GLenum primitiveMode)
 {
-    mStarted = GL_TRUE;
+    mActive = true;
     mPrimitiveMode = primitiveMode;
-    mPaused = GL_FALSE;
-    mTransformFeedback->begin(primitiveMode);
+    mPaused = false;
+    mImplementation->begin(primitiveMode);
 }
 
-void TransformFeedback::stop()
+void TransformFeedback::end()
 {
-    mStarted = GL_FALSE;
+    mActive = false;
     mPrimitiveMode = GL_NONE;
-    mPaused = GL_FALSE;
-    mTransformFeedback->end();
+    mPaused = false;
+    mImplementation->end();
 }
 
-GLboolean TransformFeedback::isStarted() const
+void TransformFeedback::pause()
 {
-    return mStarted;
+    mPaused = true;
+    mImplementation->pause();
 }
 
-GLenum TransformFeedback::getDrawMode() const
+void TransformFeedback::resume()
 {
-    return mPrimitiveMode;
+    mPaused = false;
+    mImplementation->resume();
 }
 
-void TransformFeedback::pause()
+bool TransformFeedback::isActive() const
 {
-    mPaused = GL_TRUE;
-    mTransformFeedback->pause();
+    return mActive;
 }
 
-void TransformFeedback::resume()
+bool TransformFeedback::isPaused() const
 {
-    mPaused = GL_FALSE;
-    mTransformFeedback->resume();
+    return mPaused;
 }
 
-GLboolean TransformFeedback::isPaused() const
+GLenum TransformFeedback::getPrimitiveMode() const
 {
-    return mPaused;
+    return mPrimitiveMode;
+}
+
+rx::TransformFeedbackImpl *TransformFeedback::getImplementation()
+{
+    return mImplementation;
+}
+
+const rx::TransformFeedbackImpl *TransformFeedback::getImplementation() const
+{
+    return mImplementation;
 }
 
 }

src/libANGLE/TransformFeedback.h

@@ -27,22 +27,24 @@ class TransformFeedback : public RefCountObject
     TransformFeedback(rx::TransformFeedbackImpl* impl, GLuint id);
     virtual ~TransformFeedback();
 
-    void start(GLenum primitiveMode);
-    void stop();
-    GLboolean isStarted() const;
-
-    GLenum getDrawMode() const;
-
+    void begin(GLenum primitiveMode);
+    void end();
     void pause();
     void resume();
-    GLboolean isPaused() const;
+
+    bool isActive() const;
+    bool isPaused() const;
+    GLenum getPrimitiveMode() const;
+
+    rx::TransformFeedbackImpl *getImplementation();
+    const rx::TransformFeedbackImpl *getImplementation() const;
 
   private:
-    rx::TransformFeedbackImpl* mTransformFeedback;
+    rx::TransformFeedbackImpl* mImplementation;
 
-    GLboolean mStarted;
+    bool mActive;
     GLenum mPrimitiveMode;
-    GLboolean mPaused;
+    bool mPaused;
 };
 
 }

src/libANGLE/TransformFeedback_unittest.cpp

@@ -63,32 +63,32 @@ TEST_F(TransformFeedbackTest, SideEffectsOfStartAndStop)
 {
     testing::InSequence seq;
 
-    EXPECT_EQ(GL_FALSE, mFeedback->isStarted());
+    EXPECT_FALSE(mFeedback->isActive());
     EXPECT_CALL(*mImpl, begin(GL_TRIANGLES));
-    mFeedback->start(GL_TRIANGLES);
-    EXPECT_EQ(GL_TRUE, mFeedback->isStarted());
-    EXPECT_EQ(static_cast<GLenum>(GL_TRIANGLES), mFeedback->getDrawMode());
+    mFeedback->begin(GL_TRIANGLES);
+    EXPECT_TRUE(mFeedback->isActive());
+    EXPECT_EQ(static_cast<GLenum>(GL_TRIANGLES), mFeedback->getPrimitiveMode());
     EXPECT_CALL(*mImpl, end());
-    mFeedback->stop();
-    EXPECT_EQ(GL_FALSE, mFeedback->isStarted());
+    mFeedback->end();
+    EXPECT_FALSE(mFeedback->isActive());
 }
 
 TEST_F(TransformFeedbackTest, SideEffectsOfPauseAndResume)
 {
     testing::InSequence seq;
 
-    EXPECT_FALSE(mFeedback->isStarted());
+    EXPECT_FALSE(mFeedback->isActive());
     EXPECT_CALL(*mImpl, begin(GL_TRIANGLES));
-    mFeedback->start(GL_TRIANGLES);
-    EXPECT_EQ(GL_FALSE, mFeedback->isPaused());
+    mFeedback->begin(GL_TRIANGLES);
+    EXPECT_FALSE(mFeedback->isPaused());
     EXPECT_CALL(*mImpl, pause());
     mFeedback->pause();
-    EXPECT_EQ(GL_TRUE, mFeedback->isPaused());
+    EXPECT_TRUE(mFeedback->isPaused());
     EXPECT_CALL(*mImpl, resume());
     mFeedback->resume();
-    EXPECT_EQ(GL_FALSE, mFeedback->isPaused());
+    EXPECT_FALSE(mFeedback->isPaused());
     EXPECT_CALL(*mImpl, end());
-    mFeedback->stop();
+    mFeedback->end();
 }
 
 } // namespace

src/libANGLE/validationES.cpp

@@ -1488,8 +1488,8 @@ bool ValidateDrawArrays(Context *context, GLenum mode, GLint first, GLsizei coun
 
     const State &state = context->getState();
     gl::TransformFeedback *curTransformFeedback = state.getCurrentTransformFeedback();
-    if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused() &&
-        curTransformFeedback->getDrawMode() != mode)
+    if (curTransformFeedback && curTransformFeedback->isActive() && !curTransformFeedback->isPaused() &&
+        curTransformFeedback->getPrimitiveMode() != mode)
     {
         // It is an invalid operation to call DrawArrays or DrawArraysInstanced with a draw mode
         // that does not match the current transform feedback object's draw mode (if transform feedback
@@ -1579,7 +1579,7 @@ bool ValidateDrawElements(Context *context, GLenum mode, GLsizei count, GLenum t
     const State &state = context->getState();
 
     gl::TransformFeedback *curTransformFeedback = state.getCurrentTransformFeedback();
-    if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused())
+    if (curTransformFeedback && curTransformFeedback->isActive() && !curTransformFeedback->isPaused())
     {
         // It is an invalid operation to call DrawElements, DrawRangeElements or DrawElementsInstanced
         // while transform feedback is active, (3.0.2, section 2.14, pg 86)

src/libGLESv2/entry_points_gles_3_0.cpp

@@ -1026,7 +1026,7 @@ void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode)
         TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
         ASSERT(transformFeedback != NULL);
 
-        if (transformFeedback->isStarted())
+        if (transformFeedback->isActive())
         {
             context->recordError(Error(GL_INVALID_OPERATION));
             return;
@@ -1038,7 +1038,7 @@ void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode)
         }
         else
         {
-            transformFeedback->start(primitiveMode);
+            transformFeedback->begin(primitiveMode);
         }
     }
 }
@@ -1059,13 +1059,13 @@ void GL_APIENTRY EndTransformFeedback(void)
         TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
         ASSERT(transformFeedback != NULL);
 
-        if (!transformFeedback->isStarted())
+        if (!transformFeedback->isActive())
         {
             context->recordError(Error(GL_INVALID_OPERATION));
             return;
         }
 
-        transformFeedback->stop();
+        transformFeedback->end();
     }
 }
 
@@ -1126,7 +1126,7 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi
 
                 // Cannot bind a transform feedback buffer if the current transform feedback is active (3.0.4 pg 91 section 2.15.2)
                 TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback();
-                if (curTransformFeedback && curTransformFeedback->isStarted())
+                if (curTransformFeedback && curTransformFeedback->isActive())
                 {
                     context->recordError(Error(GL_INVALID_OPERATION));
                     return;
@@ -1200,7 +1200,7 @@ void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer)
             {
                 // Cannot bind a transform feedback buffer if the current transform feedback is active (3.0.4 pg 91 section 2.15.2)
                 TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback();
-                if (curTransformFeedback && curTransformFeedback->isStarted())
+                if (curTransformFeedback && curTransformFeedback->isActive())
                 {
                     context->recordError(Error(GL_INVALID_OPERATION));
                     return;
@@ -3005,7 +3005,7 @@ void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
             {
                 // Cannot bind a transform feedback object if the current one is started and not paused (3.0.2 pg 85 section 2.14.1)
                 TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback();
-                if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused())
+                if (curTransformFeedback && curTransformFeedback->isActive() && !curTransformFeedback->isPaused())
                 {
                     context->recordError(Error(GL_INVALID_OPERATION));
                     return;
@@ -3104,8 +3104,8 @@ void GL_APIENTRY PauseTransformFeedback(void)
         TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
         ASSERT(transformFeedback != NULL);
 
-        // Current transform feedback must be started and not paused in order to pause (3.0.2 pg 86)
-        if (!transformFeedback->isStarted() || transformFeedback->isPaused())
+        // Current transform feedback must be active and not paused in order to pause (3.0.2 pg 86)
+        if (!transformFeedback->isActive() || transformFeedback->isPaused())
         {
             context->recordError(Error(GL_INVALID_OPERATION));
             return;
@@ -3131,8 +3131,8 @@ void GL_APIENTRY ResumeTransformFeedback(void)
         TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
         ASSERT(transformFeedback != NULL);
 
-        // Current transform feedback must be started and paused in order to resume (3.0.2 pg 86)
-        if (!transformFeedback->isStarted() || !transformFeedback->isPaused())
+        // Current transform feedback must be active and paused in order to resume (3.0.2 pg 86)
+        if (!transformFeedback->isActive() || !transformFeedback->isPaused())
         {
             context->recordError(Error(GL_INVALID_OPERATION));
             return;