Move Clear logic into RendererD3D.

src/libGLESv2/Context.cpp

@@ -1307,153 +1307,47 @@ Error Context::clear(GLbitfield mask)
         return Error(GL_NO_ERROR);
     }
 
-    ClearParameters clearParams = mState.getClearParameters(mask);
-
-    //TODO(jmadill): Renderer refactor
-    rx::RendererD3D *rendererD3D = rx::RendererD3D::makeRendererD3D(mRenderer);
-
-    // Clips the clear to the scissor rectangle but not the viewport
-    Error error = rendererD3D->applyRenderTarget(getData(), GL_TRIANGLES, true);
-    if (error.isError())
-    {
-        return error;
-    }
-
-    return mRenderer->clear(clearParams, mState.getDrawFramebuffer());
+    return mRenderer->clear(getData(), mask);
 }
 
-Error Context::clearBufferfv(GLenum buffer, int drawbuffer, const float *values)
+Error Context::clearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *values)
 {
     if (mState.isRasterizerDiscardEnabled())
     {
         return Error(GL_NO_ERROR);
     }
 
-    // glClearBufferfv can be called to clear the color buffer or depth buffer
-    ClearParameters clearParams = mState.getClearParameters(0);
-
-    if (buffer == GL_COLOR)
-    {
-        for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
-        {
-            clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
-        }
-        clearParams.colorFClearValue = ColorF(values[0], values[1], values[2], values[3]);
-        clearParams.colorClearType = GL_FLOAT;
-    }
-
-    if (buffer == GL_DEPTH)
-    {
-        clearParams.clearDepth = true;
-        clearParams.depthClearValue = values[0];
-    }
-
-    //TODO(jmadill): Renderer refactor
-    rx::RendererD3D *rendererD3D = rx::RendererD3D::makeRendererD3D(mRenderer);
-
-    // Clips the clear to the scissor rectangle but not the viewport
-    Error error = rendererD3D->applyRenderTarget(getData(), GL_TRIANGLES, true);
-    if (error.isError())
-    {
-        return error;
-    }
-
-    return mRenderer->clear(clearParams, mState.getDrawFramebuffer());
+    return mRenderer->clearBufferfv(getData(), buffer, drawbuffer, values);
 }
 
-Error Context::clearBufferuiv(GLenum buffer, int drawbuffer, const unsigned int *values)
+Error Context::clearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *values)
 {
     if (mState.isRasterizerDiscardEnabled())
     {
         return Error(GL_NO_ERROR);
     }
 
-    // glClearBufferuv can only be called to clear a color buffer
-    ClearParameters clearParams = mState.getClearParameters(0);
-    for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
-    {
-        clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
-    }
-    clearParams.colorUIClearValue = ColorUI(values[0], values[1], values[2], values[3]);
-    clearParams.colorClearType = GL_UNSIGNED_INT;
-
-    //TODO(jmadill): Renderer refactor
-    rx::RendererD3D *rendererD3D = rx::RendererD3D::makeRendererD3D(mRenderer);
-
-    // Clips the clear to the scissor rectangle but not the viewport
-    Error error = rendererD3D->applyRenderTarget(getData(), GL_TRIANGLES, true);
-    if (error.isError())
-    {
-        return error;
-    }
-
-    return mRenderer->clear(clearParams, mState.getDrawFramebuffer());
+    return mRenderer->clearBufferuiv(getData(), buffer, drawbuffer, values);
 }
 
-Error Context::clearBufferiv(GLenum buffer, int drawbuffer, const int *values)
+Error Context::clearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *values)
 {
     if (mState.isRasterizerDiscardEnabled())
     {
         return Error(GL_NO_ERROR);
     }
 
-    // glClearBufferfv can be called to clear the color buffer or stencil buffer
-    ClearParameters clearParams = mState.getClearParameters(0);
-
-    if (buffer == GL_COLOR)
-    {
-        for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
-        {
-            clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
-        }
-        clearParams.colorIClearValue = ColorI(values[0], values[1], values[2], values[3]);
-        clearParams.colorClearType = GL_INT;
-    }
-
-    if (buffer == GL_STENCIL)
-    {
-        clearParams.clearStencil = true;
-        clearParams.stencilClearValue = values[1];
-    }
-
-    //TODO(jmadill): Renderer refactor
-    rx::RendererD3D *rendererD3D = rx::RendererD3D::makeRendererD3D(mRenderer);
-
-    // Clips the clear to the scissor rectangle but not the viewport
-    Error error = rendererD3D->applyRenderTarget(getData(), GL_TRIANGLES, true);
-    if (error.isError())
-    {
-        return error;
-    }
-
-    return mRenderer->clear(clearParams, mState.getDrawFramebuffer());
+    return mRenderer->clearBufferiv(getData(), buffer, drawbuffer, values);
 }
 
-Error Context::clearBufferfi(GLenum buffer, int drawbuffer, float depth, int stencil)
+Error Context::clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
     if (mState.isRasterizerDiscardEnabled())
     {
         return Error(GL_NO_ERROR);
     }
 
-    // glClearBufferfi can only be called to clear a depth stencil buffer
-    ClearParameters clearParams = mState.getClearParameters(0);
-    clearParams.clearDepth = true;
-    clearParams.depthClearValue = depth;
-    clearParams.clearStencil = true;
-    clearParams.stencilClearValue = stencil;
-
-    //TODO(jmadill): Renderer refactor
-    rx::RendererD3D *rendererD3D = rx::RendererD3D::makeRendererD3D(mRenderer);
-
-    // Clips the clear to the scissor rectangle but not the viewport
-    Error error = rendererD3D->applyRenderTarget(getData(), GL_TRIANGLES, true);
-    if (error.isError())
-    {
-        return error;
-    }
-
-    return mRenderer->clear(clearParams, mState.getDrawFramebuffer());
+    return mRenderer->clearBufferfi(getData(), buffer, drawbuffer, depth, stencil);
 }
 
 Error Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,

src/libGLESv2/Context.h

@@ -176,10 +176,10 @@ class Context
     bool getIndexedQueryParameterInfo(GLenum target, GLenum *type, unsigned int *numParams);
 
     Error clear(GLbitfield mask);
-    Error clearBufferfv(GLenum buffer, int drawbuffer, const float *values);
-    Error clearBufferuiv(GLenum buffer, int drawbuffer, const unsigned int *values);
-    Error clearBufferiv(GLenum buffer, int drawbuffer, const int *values);
-    Error clearBufferfi(GLenum buffer, int drawbuffer, float depth, int stencil);
+    Error clearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *values);
+    Error clearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *values);
+    Error clearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *values);
+    Error clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
 
     Error readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);
     Error drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances);

src/libGLESv2/renderer/Renderer.h

@@ -85,8 +85,13 @@ class Renderer
                                    const GLvoid *indices, GLsizei instances,
                                    const RangeUI &indexRange) = 0;
 
+    virtual gl::Error clear(const gl::Data &data, GLbitfield mask) = 0;
+    virtual gl::Error clearBufferfv(const gl::Data &data, GLenum buffer, GLint drawbuffer, const GLfloat *values) = 0;
+    virtual gl::Error clearBufferuiv(const gl::Data &data, GLenum buffer, GLint drawbuffer, const GLuint *values) = 0;
+    virtual gl::Error clearBufferiv(const gl::Data &data, GLenum buffer, GLint drawbuffer, const GLint *values) = 0;
+    virtual gl::Error clearBufferfi(const gl::Data &data, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) = 0;
+
     // TODO(jmadill): pass state and essetial params only
-    virtual gl::Error clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer) = 0;
     virtual gl::Error readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
                                  GLenum type, GLuint outputPitch, const gl::PixelPackState &pack, uint8_t *pixels) = 0;
 

src/libGLESv2/renderer/d3d/RendererD3D.cpp

@@ -618,4 +618,126 @@ gl::Texture *RendererD3D::getIncompleteTexture(GLenum type)
     return mIncompleteTextures[type].get();
 }
 
+gl::Error RendererD3D::clear(const gl::Data &data, GLbitfield mask)
+{
+    gl::ClearParameters clearParams = data.state->getClearParameters(mask);
+
+    // Clips the clear to the scissor rectangle but not the viewport
+    gl::Error error = applyRenderTarget(data, GL_TRIANGLES, true);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    return clear(clearParams, data.state->getDrawFramebuffer());
+}
+
+gl::Error RendererD3D::clearBufferfv(const gl::Data &data, GLenum buffer, GLint drawbuffer, const GLfloat *values)
+{
+    // glClearBufferfv can be called to clear the color buffer or depth buffer
+    gl::ClearParameters clearParams = data.state->getClearParameters(0);
+
+    if (buffer == GL_COLOR)
+    {
+        for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
+        {
+            clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
+        }
+        clearParams.colorFClearValue = gl::ColorF(values[0], values[1], values[2], values[3]);
+        clearParams.colorClearType = GL_FLOAT;
+    }
+
+    if (buffer == GL_DEPTH)
+    {
+        clearParams.clearDepth = true;
+        clearParams.depthClearValue = values[0];
+    }
+
+    // Clips the clear to the scissor rectangle but not the viewport
+    gl::Error error = applyRenderTarget(data, GL_TRIANGLES, true);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    return clear(clearParams, data.state->getDrawFramebuffer());
+}
+
+gl::Error RendererD3D::clearBufferuiv(const gl::Data &data, GLenum buffer, GLint drawbuffer, const GLuint *values)
+{
+    // glClearBufferuiv can only be called to clear a color buffer
+    gl::ClearParameters clearParams = data.state->getClearParameters(0);
+    for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
+    {
+        clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
+    }
+    clearParams.colorUIClearValue = gl::ColorUI(values[0], values[1], values[2], values[3]);
+    clearParams.colorClearType = GL_UNSIGNED_INT;
+
+    // Clips the clear to the scissor rectangle but not the viewport
+    gl::Error error = applyRenderTarget(data, GL_TRIANGLES, true);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    return clear(clearParams, data.state->getDrawFramebuffer());
+}
+
+gl::Error RendererD3D::clearBufferiv(const gl::Data &data, GLenum buffer, GLint drawbuffer, const GLint *values)
+{
+    // glClearBufferiv can be called to clear the color buffer or stencil buffer
+    gl::ClearParameters clearParams = data.state->getClearParameters(0);
+
+    if (buffer == GL_COLOR)
+    {
+        for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
+        {
+            clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i));
+        }
+        clearParams.colorIClearValue = gl::ColorI(values[0], values[1], values[2], values[3]);
+        clearParams.colorClearType = GL_INT;
+    }
+
+    if (buffer == GL_STENCIL)
+    {
+        clearParams.clearStencil = true;
+        clearParams.stencilClearValue = values[1];
+    }
+
+    // Clips the clear to the scissor rectangle but not the viewport
+    gl::Error error = applyRenderTarget(data, GL_TRIANGLES, true);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    return clear(clearParams, data.state->getDrawFramebuffer());
+}
+
+gl::Error RendererD3D::clearBufferfi(const gl::Data &data, GLenum buffer, GLint drawbuffer,
+                                     GLfloat depth, GLint stencil)
+{
+    if (data.state->isRasterizerDiscardEnabled())
+    {
+        return gl::Error(GL_NO_ERROR);
+    }
+
+    // glClearBufferfi can only be called to clear a depth stencil buffer
+    gl::ClearParameters clearParams = data.state->getClearParameters(0);
+    clearParams.clearDepth = true;
+    clearParams.depthClearValue = depth;
+    clearParams.clearStencil = true;
+    clearParams.stencilClearValue = stencil;
+
+    // Clips the clear to the scissor rectangle but not the viewport
+    gl::Error error = applyRenderTarget(data, GL_TRIANGLES, true);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    return clear(clearParams, data.state->getDrawFramebuffer());
+}
+
 }

src/libGLESv2/renderer/d3d/RendererD3D.h

@@ -51,6 +51,12 @@ class RendererD3D : public Renderer
                            const GLvoid *indices, GLsizei instances,
                            const RangeUI &indexRange) override;
 
+    gl::Error clear(const gl::Data &data, GLbitfield mask) override;
+    gl::Error clearBufferfv(const gl::Data &data, GLenum buffer, int drawbuffer, const GLfloat *values) override;
+    gl::Error clearBufferuiv(const gl::Data &data, GLenum buffer, int drawbuffer, const GLuint *values) override;
+    gl::Error clearBufferiv(const gl::Data &data, GLenum buffer, int drawbuffer, const GLint *values) override;
+    gl::Error clearBufferfi(const gl::Data &data, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override;
+
     // Direct3D Specific methods
     virtual SwapChain *createSwapChain(rx::NativeWindow nativeWindow, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) = 0;
 
@@ -143,13 +149,11 @@ class RendererD3D : public Renderer
     virtual VertexBuffer *createVertexBuffer() = 0;
     virtual IndexBuffer *createIndexBuffer() = 0;
 
-    //TODO(jmadill): Should be private or protected
-    gl::Error applyRenderTarget(const gl::Data &data, GLenum drawMode, bool ignoreViewport);
-
   protected:
     virtual gl::Error drawArrays(GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive) = 0;
     virtual gl::Error drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,
                                    gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances) = 0;
+    virtual gl::Error clear(const gl::ClearParameters &clearParams, const gl::Framebuffer *frameBuffer) = 0;
 
     egl::Display *mDisplay;
 
@@ -162,6 +166,7 @@ class RendererD3D : public Renderer
     gl::Error generateSwizzles(const gl::Data &data, gl::SamplerType type);
     gl::Error generateSwizzles(const gl::Data &data);
 
+    gl::Error applyRenderTarget(const gl::Data &data, GLenum drawMode, bool ignoreViewport);
     gl::Error applyState(const gl::Data &data, GLenum drawMode);
     bool applyTransformFeedbackBuffers(const gl::Data &data);
     gl::Error applyShaders(const gl::Data &data, bool transformFeedbackActive);

src/libGLESv2/renderer/d3d/d3d11/Clear11.cpp

@@ -148,7 +148,7 @@ Clear11::~Clear11()
     SafeRelease(mRasterizerState);
 }
 
-gl::Error Clear11::clearFramebuffer(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer)
+gl::Error Clear11::clearFramebuffer(const gl::ClearParameters &clearParams, const gl::Framebuffer *frameBuffer)
 {
     // First determine if a scissored clear is needed, this will always require drawing a quad.
     //

src/libGLESv2/renderer/d3d/d3d11/Clear11.h

@@ -32,7 +32,7 @@ class Clear11
     ~Clear11();
 
     // Clears the framebuffer with the supplied clear parameters, assumes that the framebuffer is currently applied.
-    gl::Error clearFramebuffer(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer);
+    gl::Error clearFramebuffer(const gl::ClearParameters &clearParams, const gl::Framebuffer *frameBuffer);
 
   private:
     Renderer11 *mRenderer;

src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp

@@ -1643,7 +1643,7 @@ gl::Error Renderer11::applyUniforms(const ProgramImpl &program, const std::vecto
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer11::clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer)
+gl::Error Renderer11::clear(const gl::ClearParameters &clearParams, const gl::Framebuffer *frameBuffer)
 {
     gl::Error error = mClear->clearFramebuffer(clearParams, frameBuffer);
     if (error.isError())

src/libGLESv2/renderer/d3d/d3d11/Renderer11.h

@@ -92,7 +92,7 @@ class Renderer11 : public RendererD3D
     virtual gl::Error drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,
                                    gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances);
 
-    virtual gl::Error clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer);
+    gl::Error clear(const gl::ClearParameters &clearParams, const gl::Framebuffer *frameBuffer) override;
 
     virtual void markAllStateDirty();
 

src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp

@@ -1868,7 +1868,7 @@ void Renderer9::applyUniformnbv(gl::LinkedUniform *targetUniform, const GLint *v
     applyUniformnfv(targetUniform, (GLfloat*)vector);
 }
 
-gl::Error Renderer9::clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer)
+gl::Error Renderer9::clear(const gl::ClearParameters &clearParams, const gl::Framebuffer *frameBuffer)
 {
     if (clearParams.colorClearType != GL_FLOAT)
     {

src/libGLESv2/renderer/d3d/d3d9/Renderer9.h

@@ -95,7 +95,7 @@ class Renderer9 : public RendererD3D
     virtual gl::Error drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,
                                    gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances);
 
-    virtual gl::Error clear(const gl::ClearParameters &clearParams, gl::Framebuffer *frameBuffer);
+    gl::Error clear(const gl::ClearParameters &clearParams, const gl::Framebuffer *frameBuffer) override;
 
     virtual void markAllStateDirty();