gl_engine: support clip by using scissor and stencil

src/renderer/gl_engine/tvgGlGeometry.cpp

@@ -178,7 +178,7 @@ bool GlGeometry::draw(GlRenderTask* task, GlStageBuffer* gpuBuffer, RenderUpdate
         task->addVertexLayout(GlVertexLayout{0, 3, 3 * sizeof(float), vertexOffset});
     }
     task->setDrawRange(indexOffset, indexBuffer->count);
-
+    task->setViewport(viewport);
     return true;
 }
 
@@ -200,6 +200,11 @@ void GlGeometry::updateTransform(const RenderTransform* transform, float w, floa
     MULTIPLY_MATRIX(mvp, modelMatrix, mTransform)
 }
 
+void GlGeometry::setViewport(const RenderRegion& viewport)
+{
+    this->viewport = viewport;
+}
+
 float* GlGeometry::getTransforMatrix()
 {
     return mTransform;

src/renderer/gl_engine/tvgGlGeometry.h

@@ -193,9 +193,11 @@ public:
     void disableVertex(uint32_t location);
     bool draw(GlRenderTask* task, GlStageBuffer* gpuBuffer, RenderUpdateFlag flag);
     void updateTransform(const RenderTransform* transform, float w, float h);
+    void setViewport(const RenderRegion& viewport);
     float* getTransforMatrix();
 
 private:
+    RenderRegion viewport = {};
     Array<float> fillVertex = {};
     Array<float> strokeVertex = {};
     Array<uint32_t> fillIndex = {};

src/renderer/gl_engine/tvgGlRenderTask.cpp

@@ -31,6 +31,10 @@ void GlRenderTask::run()
 {
     // bind shader
     mProgram->load();
+
+    // setup scissor rect
+    GL_CHECK(glScissor(mViewport.x, mViewport.y, mViewport.w, mViewport.h));
+
     // setup attribute layout
     for (uint32_t i = 0; i < mVertexLayout.count; i++) {
         const auto &layout = mVertexLayout[i];
@@ -79,4 +83,9 @@ void GlRenderTask::setDrawRange(uint32_t offset, uint32_t count)
 {
     mIndexOffset = offset;
     mIndexCount = count;
-}
+}
+
+void GlRenderTask::setViewport(const RenderRegion &viewport)
+{
+    mViewport = viewport;
+}

src/renderer/gl_engine/tvgGlRenderTask.h

@@ -81,10 +81,12 @@ public:
     void addVertexLayout(const GlVertexLayout& layout);
     void addBindResource(const GlBindingResource& binding);
     void setDrawRange(uint32_t offset, uint32_t count);
+    void setViewport(const RenderRegion& viewport);
 
     GlProgram* getProgram() { return mProgram; }
 private:
     GlProgram* mProgram;
+    RenderRegion mViewport = {};
     uint32_t mIndexOffset = {};
     uint32_t mIndexCount = {};
     Array<GlVertexLayout> mVertexLayout = {};

src/renderer/gl_engine/tvgGlRenderer.cpp

@@ -63,6 +63,11 @@ bool GlRenderer::target(TVG_UNUSED uint32_t* buffer, uint32_t stride, uint32_t w
     surface.w = w;
     surface.h = h;
 
+    mViewport.x = 0;
+    mViewport.y = 0;
+    mViewport.w = surface.w;
+    mViewport.h = surface.h;
+
     return true;
 }
 
@@ -74,6 +79,7 @@ bool GlRenderer::sync()
     // Blend function for straight alpha
     GL_CHECK(glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
     GL_CHECK(glEnable(GL_BLEND));
+    GL_CHECK(glEnable(GL_SCISSOR_TEST));
 
     mGpuBuffer->bind();
 
@@ -85,6 +91,8 @@ bool GlRenderer::sync()
 
     mRenderTasks.clear();
 
+    GL_CHECK(glDisable(GL_SCISSOR_TEST));
+
     return true;
 }
 
@@ -204,8 +212,6 @@ bool GlRenderer::renderShape(RenderData data)
     uint8_t r = 0, g = 0, b = 0, a = 0;
     size_t flags = static_cast<size_t>(sdata->updateFlag);
 
-    GL_CHECK(glViewport(0, 0, (GLsizei)sdata->viewWd, (GLsizei)sdata->viewHt));
-
     if (flags & (RenderUpdateFlag::Gradient | RenderUpdateFlag::Transform))
     {
         auto gradient = sdata->rshape->fill;
@@ -283,6 +289,12 @@ RenderData GlRenderer::prepare(Surface* image, const RenderMesh* mesh, RenderDat
     sdata->geometry = make_unique<GlGeometry>();
 
     sdata->geometry->updateTransform(transform, sdata->viewWd, sdata->viewHt);
+    sdata->geometry->setViewport(RenderRegion{
+        mViewport.x,
+        static_cast<int32_t>((surface.h - mViewport.y - mViewport.h)),
+        mViewport.w,
+        mViewport.h,
+    });
 
     sdata->geometry->tesselate(image, mesh, flags);
 
@@ -327,6 +339,12 @@ RenderData GlRenderer::prepare(const RenderShape& rshape, RenderData data, const
     }
 
     sdata->geometry->updateTransform(transform, sdata->viewWd, sdata->viewHt);
+    sdata->geometry->setViewport(RenderRegion{
+        mViewport.x,
+        static_cast<int32_t>(surface.h - mViewport.y - mViewport.h),
+        mViewport.w,
+        mViewport.h,
+    });
 
     if (sdata->updateFlag & (RenderUpdateFlag::Color | RenderUpdateFlag::Stroke | RenderUpdateFlag::Gradient | RenderUpdateFlag::Transform) )
     {
@@ -342,9 +360,9 @@ RenderRegion GlRenderer::viewport()
 }
 
 
-bool GlRenderer::viewport(TVG_UNUSED const RenderRegion& vp)
+bool GlRenderer::viewport(const RenderRegion& vp)
 {
-    //TODO:
+    mViewport = vp;
     return true;
 }
 
@@ -382,7 +400,7 @@ GlRenderer* GlRenderer::gen()
     return new GlRenderer();
 }
 
-GlRenderer::GlRenderer() :mGpuBuffer(new GlStageBuffer), mPrograms(), mRenderTasks()
+GlRenderer::GlRenderer() :mViewport() ,mGpuBuffer(new GlStageBuffer), mPrograms(), mRenderTasks()
 {
 }
 

src/renderer/gl_engine/tvgGlRenderer.h

@@ -78,6 +78,7 @@ private:
     void drawPrimitive(GlShape& sdata, uint8_t r, uint8_t g, uint8_t b, uint8_t a, RenderUpdateFlag flag);
     void drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFlag flag);
 
+    RenderRegion mViewport;
     std::unique_ptr<GlStageBuffer> mGpuBuffer;
     vector<std::unique_ptr<GlProgram>> mPrograms;
     vector<std::unique_ptr<GlRenderTask>> mRenderTasks;