git_clone/thorvg
1
0
Fork 0
mirror of https://github.com/thorvg/thorvg.git synced 2025-06-08 05:33:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

gl_engine: ++binary optimization

Browse source 
- removed unique_ptr, shared_ptr
- replaced std::vector with tvg::Array
- reduced binary size by -10kb
This commit is contained in:
Hermet Park 2024-12-30 18:44:01 +09:00 • committed by Hermet Park
parent 38a4465656
commit ccf5a8158f
17 changed files with 378 additions and 498 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/renderer/gl_engine/meson.build
View file

@ -1,6 +1,5 @@
source_file = [ source_file = [
'tvgGlCommon.h', 'tvgGlCommon.h',
'tvgGlGeometry.h',
'tvgGlGpuBuffer.h', 'tvgGlGpuBuffer.h',
'tvgGlList.h', 'tvgGlList.h',
'tvgGlProgram.h', 'tvgGlProgram.h',

87
src/renderer/gl_engine/tvgGlCommon.h
View file

@ -41,6 +41,7 @@
#endif #endif
#include "tvgCommon.h" #include "tvgCommon.h"
#include "tvgRender.h" #include "tvgRender.h"
#include "tvgMath.h"
#ifdef __EMSCRIPTEN__ #ifdef __EMSCRIPTEN__
// query GL Error on WebGL is very slow, so disable it on WebGL // query GL Error on WebGL is very slow, so disable it on WebGL
@ -57,6 +58,61 @@
} while(0) } while(0)
#endif #endif
#define MIN_GL_STROKE_WIDTH 1.0f
#define MVP_MATRIX(w, h) \
float mvp[4*4] = { \
2.f / w, 0.0, 0.0f, 0.0f, \
0.0, -2.f / h, 0.0f, 0.0f, \
0.0f, 0.0f, -1.f, 0.0f, \
-1.f, 1.f, 0.0f, 1.0f \
};
#define MULTIPLY_MATRIX(A, B, transform) \
for(auto i = 0; i < 4; ++i) \
{ \
for(auto j = 0; j < 4; ++j) \
{ \
float sum = 0.0; \
for (auto k = 0; k < 4; ++k) \
sum += A[k*4+i] * B[j*4+k]; \
transform[j*4+i] = sum; \
} \
}
/**
* mat3x3 mat4x4
*
* [ e11 e12 e13 ] [ e11 e12 0 e13 ]
* [ e21 e22 e23 ] => [ e21 e22 0 e23 ]
* [ e31 e32 e33 ] [ 0 0 1 0 ]
* [ e31 e32 0 e33 ]
*
*/
// All GPU use 4x4 matrix with column major order
#define GET_MATRIX44(mat3, mat4) \
do { \
mat4[0] = mat3.e11; \
mat4[1] = mat3.e21; \
mat4[2] = 0; \
mat4[3] = mat3.e31; \
mat4[4] = mat3.e12; \
mat4[5] = mat3.e22; \
mat4[6] = 0; \
mat4[7] = mat3.e32; \
mat4[8] = 0; \
mat4[9] = 0; \
mat4[10] = 1; \
mat4[11] = 0; \
mat4[12] = mat3.e13; \
mat4[13] = mat3.e23; \
mat4[14] = 0; \
mat4[15] = mat3.e33; \
} while (false)
static inline float getScaleFactor(const Matrix& m) static inline float getScaleFactor(const Matrix& m)
{ {
return sqrtf(m.e11 * m.e11 + m.e21 * m.e21); return sqrtf(m.e11 * m.e11 + m.e21 * m.e21);
@ -69,7 +125,34 @@ enum class GlStencilMode {
Stroke, Stroke,
}; };
class GlGeometry;
class GlStageBuffer;
class GlRenderTask;
class GlGeometry
{
public:
bool tesselate(const RenderShape& rshape, RenderUpdateFlag flag);
bool tesselate(const RenderSurface* image, RenderUpdateFlag flag);
void disableVertex(uint32_t location);
bool draw(GlRenderTask* task, GlStageBuffer* gpuBuffer, RenderUpdateFlag flag);
void updateTransform(const Matrix& m);
void setViewport(const RenderRegion& viewport);
const RenderRegion& getViewport();
const Matrix& getTransformMatrix();
GlStencilMode getStencilMode(RenderUpdateFlag flag);
RenderRegion getBounds() const;
private:
RenderRegion viewport = {};
Array<float> fillVertex;
Array<float> strokeVertex;
Array<uint32_t> fillIndex;
Array<uint32_t> strokeIndex;
Matrix mMatrix = {};
FillRule mFillRule = FillRule::NonZero;
RenderRegion mBounds = {};
};
struct GlShape struct GlShape
{ {
@ -81,7 +164,7 @@ struct GlShape
uint32_t texFlipY = 0; uint32_t texFlipY = 0;
ColorSpace texColorSpace = ColorSpace::ABGR8888; ColorSpace texColorSpace = ColorSpace::ABGR8888;
RenderUpdateFlag updateFlag = None; RenderUpdateFlag updateFlag = None;
unique_ptr<GlGeometry> geometry; GlGeometry geometry;
Array<RenderData> clips; Array<RenderData> clips;
}; };

6
src/renderer/gl_engine/tvgGlGeometry.cpp
View file

@ -20,15 +20,11 @@
* SOFTWARE. * SOFTWARE.
*/ */
#include "tvgGlCommon.h"
#include "tvgGlGpuBuffer.h" #include "tvgGlGpuBuffer.h"
#include "tvgGlGeometry.h"
#include "tvgGlTessellator.h" #include "tvgGlTessellator.h"
#include "tvgGlRenderTask.h" #include "tvgGlRenderTask.h"
GlGeometry::~GlGeometry()
{
}
bool GlGeometry::tesselate(const RenderShape& rshape, RenderUpdateFlag flag) bool GlGeometry::tesselate(const RenderShape& rshape, RenderUpdateFlag flag)
{ {
if (flag & (RenderUpdateFlag::Color | RenderUpdateFlag::Gradient | RenderUpdateFlag::Transform | RenderUpdateFlag::Path)) { if (flag & (RenderUpdateFlag::Color | RenderUpdateFlag::Gradient | RenderUpdateFlag::Transform | RenderUpdateFlag::Path)) {

115
src/renderer/gl_engine/tvgGlGeometry.h
View file

@ -1,115 +0,0 @@
/*
* Copyright (c) 2020 - 2024 the ThorVG project. All rights reserved.
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef _TVG_GL_GEOMETRY_H_
#define _TVG_GL_GEOMETRY_H_
#include <vector>
#include "tvgGlCommon.h"
#include "tvgMath.h"
#define MIN_GL_STROKE_WIDTH 1.0f
#define MVP_MATRIX(w, h) \
float mvp[4*4] = { \
2.f / w, 0.0, 0.0f, 0.0f, \
0.0, -2.f / h, 0.0f, 0.0f, \
0.0f, 0.0f, -1.f, 0.0f, \
-1.f, 1.f, 0.0f, 1.0f \
};
#define MULTIPLY_MATRIX(A, B, transform) \
for(auto i = 0; i < 4; ++i) \
{ \
for(auto j = 0; j < 4; ++j) \
{ \
float sum = 0.0; \
for (auto k = 0; k < 4; ++k) \
sum += A[k*4+i] * B[j*4+k]; \
transform[j*4+i] = sum; \
} \
}
/**
* mat3x3 mat4x4
*
* [ e11 e12 e13 ] [ e11 e12 0 e13 ]
* [ e21 e22 e23 ] => [ e21 e22 0 e23 ]
* [ e31 e32 e33 ] [ 0 0 1 0 ]
* [ e31 e32 0 e33 ]
*
*/
// All GPU use 4x4 matrix with column major order
#define GET_MATRIX44(mat3, mat4) \
do { \
mat4[0] = mat3.e11; \
mat4[1] = mat3.e21; \
mat4[2] = 0; \
mat4[3] = mat3.e31; \
mat4[4] = mat3.e12; \
mat4[5] = mat3.e22; \
mat4[6] = 0; \
mat4[7] = mat3.e32; \
mat4[8] = 0; \
mat4[9] = 0; \
mat4[10] = 1; \
mat4[11] = 0; \
mat4[12] = mat3.e13; \
mat4[13] = mat3.e23; \
mat4[14] = 0; \
mat4[15] = mat3.e33; \
} while (false)
class GlStageBuffer;
class GlRenderTask;
class GlGeometry
{
public:
GlGeometry() = default;
~GlGeometry();
bool tesselate(const RenderShape& rshape, RenderUpdateFlag flag);
bool tesselate(const RenderSurface* image, RenderUpdateFlag flag);
void disableVertex(uint32_t location);
bool draw(GlRenderTask* task, GlStageBuffer* gpuBuffer, RenderUpdateFlag flag);
void updateTransform(const Matrix& m);
void setViewport(const RenderRegion& viewport);
const RenderRegion& getViewport();
const Matrix& getTransformMatrix();
GlStencilMode getStencilMode(RenderUpdateFlag flag);
RenderRegion getBounds() const;
private:
RenderRegion viewport = {};
Array<float> fillVertex = {};
Array<float> strokeVertex = {};
Array<uint32_t> fillIndex = {};
Array<uint32_t> strokeIndex = {};
Matrix mMatrix = {};
FillRule mFillRule = FillRule::NonZero;
RenderRegion mBounds = {};
};
#endif /* _TVG_GL_GEOMETRY_H_ */

43
src/renderer/gl_engine/tvgGlProgram.cpp
View file

@ -29,25 +29,29 @@
uint32_t GlProgram::mCurrentProgram = 0; uint32_t GlProgram::mCurrentProgram = 0;
void GlProgram::linkProgram(std::shared_ptr<GlShader> shader) /************************************************************************/
/* External Class Implementation */
/************************************************************************/
GlProgram::GlProgram(const char* vertSrc, const char* fragSrc)
{ {
GLint linked; auto shader = GlShader(vertSrc, fragSrc);
// Create the program object // Create the program object
uint32_t progObj = glCreateProgram(); uint32_t progObj = glCreateProgram();
assert(progObj); assert(progObj);
glAttachShader(progObj, shader->getVertexShader()); glAttachShader(progObj, shader.getVertexShader());
glAttachShader(progObj, shader->getFragmentShader()); glAttachShader(progObj, shader.getFragmentShader());
// Link the program // Link the program
glLinkProgram(progObj); glLinkProgram(progObj);
// Check the link status // Check the link status
GLint linked;
glGetProgramiv(progObj, GL_LINK_STATUS, &linked); glGetProgramiv(progObj, GL_LINK_STATUS, &linked);
if (!linked) if (!linked) {
{
GLint infoLen = 0; GLint infoLen = 0;
glGetProgramiv(progObj, GL_INFO_LOG_LENGTH, &infoLen); glGetProgramiv(progObj, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 0) if (infoLen > 0)
@ -66,39 +70,16 @@ void GlProgram::linkProgram(std::shared_ptr<GlShader> shader)
} }
/************************************************************************/
/* External Class Implementation */
/************************************************************************/
unique_ptr<GlProgram> GlProgram::gen(std::shared_ptr<GlShader> shader)
{
return make_unique<GlProgram>(shader);
}
GlProgram::GlProgram(std::shared_ptr<GlShader> shader)
{
linkProgram(shader);
}
GlProgram::~GlProgram() GlProgram::~GlProgram()
{ {
if (mCurrentProgram == mProgramObj) if (mCurrentProgram == mProgramObj) unload();
{
unload();
}
glDeleteProgram(mProgramObj); glDeleteProgram(mProgramObj);
} }
void GlProgram::load() void GlProgram::load()
{ {
if (mCurrentProgram == mProgramObj) if (mCurrentProgram == mProgramObj) return;
{
return;
}
mCurrentProgram = mProgramObj; mCurrentProgram = mProgramObj;
GL_CHECK(glUseProgram(mProgramObj)); GL_CHECK(glUseProgram(mProgramObj));

6
src/renderer/gl_engine/tvgGlProgram.h
View file

@ -28,8 +28,7 @@
class GlProgram class GlProgram
{ {
public: public:
static std::unique_ptr<GlProgram> gen(std::shared_ptr<GlShader> shader); GlProgram(const char* vertSrc, const char* fragSrc);
GlProgram(std::shared_ptr<GlShader> shader);
~GlProgram(); ~GlProgram();
void load(); void load();
@ -49,11 +48,8 @@ public:
void setUniform4x4Value(int32_t location, int count, const float* values); void setUniform4x4Value(int32_t location, int count, const float* values);
private: private:
void linkProgram(std::shared_ptr<GlShader> shader);
uint32_t mProgramObj; uint32_t mProgramObj;
static uint32_t mCurrentProgram; static uint32_t mCurrentProgram;
}; };
#endif /* _TVG_GL_PROGRAM_H_ */ #endif /* _TVG_GL_PROGRAM_H_ */

3
src/renderer/gl_engine/tvgGlRenderPass.cpp
View file

@ -21,10 +21,9 @@
* SOFTWARE. * SOFTWARE.
*/ */
#include "tvgMath.h" #include "tvgGlCommon.h"
#include "tvgGlRenderPass.h" #include "tvgGlRenderPass.h"
#include "tvgGlRenderTask.h" #include "tvgGlRenderTask.h"
#include "tvgGlGeometry.h"
GlRenderPass::GlRenderPass(GlRenderTarget* fbo): mFbo(fbo), mTasks(), mDrawDepth(0) {} GlRenderPass::GlRenderPass(GlRenderTarget* fbo): mFbo(fbo), mTasks(), mDrawDepth(0) {}

3
src/renderer/gl_engine/tvgGlRenderPass.h
View file

@ -23,9 +23,6 @@
#ifndef _TVG_GL_RENDER_PASS_H_ #ifndef _TVG_GL_RENDER_PASS_H_
#define _TVG_GL_RENDER_PASS_H_ #define _TVG_GL_RENDER_PASS_H_
#include <memory>
#include <vector>
#include "tvgGlCommon.h" #include "tvgGlCommon.h"
#include "tvgGlRenderTask.h" #include "tvgGlRenderTask.h"
#include "tvgGlRenderTarget.h" #include "tvgGlRenderTarget.h"

6
src/renderer/gl_engine/tvgGlRenderTarget.cpp
View file

@ -22,8 +22,6 @@
#include "tvgGlRenderTarget.h" #include "tvgGlRenderTarget.h"
GlRenderTarget::GlRenderTarget(uint32_t width, uint32_t height): mWidth(width), mHeight(height) {}
GlRenderTarget::~GlRenderTarget() GlRenderTarget::~GlRenderTarget()
{ {
if (mFbo == 0) return; if (mFbo == 0) return;
@ -124,7 +122,9 @@ GlRenderTarget* GlRenderTargetPool::getRenderTarget(const RenderRegion& vp, GLui
} }
} }
auto rt = new GlRenderTarget(width, height); auto rt = new GlRenderTarget;
rt->mWidth = width;
rt->mHeight = height;
rt->init(resolveId); rt->init(resolveId);
rt->setViewport(vp); rt->setViewport(vp);
mPool.push(rt); mPool.push(rt);

6
src/renderer/gl_engine/tvgGlRenderTarget.h
View file

@ -28,7 +28,6 @@
class GlRenderTarget class GlRenderTarget
{ {
public: public:
GlRenderTarget(uint32_t width, uint32_t height);
~GlRenderTarget(); ~GlRenderTarget();
void init(GLint resolveId); void init(GLint resolveId);
@ -43,9 +42,10 @@ public:
void setViewport(const RenderRegion& vp) { mViewport = vp; } void setViewport(const RenderRegion& vp) { mViewport = vp; }
const RenderRegion& getViewport() const { return mViewport; } const RenderRegion& getViewport() const { return mViewport; }
uint32_t mWidth;
uint32_t mHeight;
private: private:
uint32_t mWidth = 0;
uint32_t mHeight = 0;
RenderRegion mViewport{}; RenderRegion mViewport{};
GLuint mFbo = 0; GLuint mFbo = 0;
GLuint mColorBuffer = 0; GLuint mColorBuffer = 0;

3
src/renderer/gl_engine/tvgGlRenderTask.h
View file

@ -23,9 +23,6 @@
#ifndef _TVG_GL_RENDER_TASK_H_ #ifndef _TVG_GL_RENDER_TASK_H_
#define _TVG_GL_RENDER_TASK_H_ #define _TVG_GL_RENDER_TASK_H_
#include <memory>
#include <vector>
#include "tvgGlCommon.h" #include "tvgGlCommon.h"
#include "tvgGlProgram.h" #include "tvgGlProgram.h"

526
src/renderer/gl_engine/tvgGlRenderer.cpp
View file

@ -20,10 +20,9 @@
* SOFTWARE. * SOFTWARE.
*/ */
#include "tvgMath.h" #include "tvgGlCommon.h"
#include "tvgGlRenderer.h" #include "tvgGlRenderer.h"
#include "tvgGlGpuBuffer.h" #include "tvgGlGpuBuffer.h"
#include "tvgGlGeometry.h"
#include "tvgGlRenderTask.h" #include "tvgGlRenderTask.h"
#include "tvgGlProgram.h" #include "tvgGlProgram.h"
#include "tvgGlShaderSrc.h" #include "tvgGlShaderSrc.h"
@ -46,87 +45,102 @@ static void _termEngine()
} }
void GlRenderer::clearDisposes() void GlRenderer::flush()
{ {
if (mDisposed.textures.count > 0) { if (mDisposed.textures.count > 0) {
glDeleteTextures(mDisposed.textures.count, mDisposed.textures.data); glDeleteTextures(mDisposed.textures.count, mDisposed.textures.data);
mDisposed.textures.clear(); mDisposed.textures.clear();
} }
for (auto p = mRenderPassStack.begin(); p < mRenderPassStack.end(); ++p) {
delete(*p);
}
mRenderPassStack.clear();
for (auto p = mComposePool.begin(); p < mComposePool.end(); p++) {
delete(*p);
}
mComposePool.clear();
for (auto p = mBlendPool.begin(); p < mBlendPool.end(); p++) {
delete(*p);
}
mBlendPool.clear();
for (auto p = mComposeStack.begin(); p < mComposeStack.end(); p++) {
delete(*p);
}
mComposeStack.clear();
} }
GlRenderer::GlRenderer() :mGpuBuffer(new GlStageBuffer), mPrograms(), mComposePool() GlRenderer::GlRenderer()
{ {
} }
GlRenderer::~GlRenderer() GlRenderer::~GlRenderer()
{ {
for (uint32_t i = 0; i < mComposePool.count; i++) {
if (mComposePool[i]) delete mComposePool[i];
}
for (uint32_t i = 0; i < mBlendPool.count; i++) {
if (mBlendPool[i]) delete mBlendPool[i];
}
--rendererCnt; --rendererCnt;
flush();
for (auto p = mPrograms.begin(); p < mPrograms.end(); ++p) {
delete(*p);
}
if (rendererCnt == 0 && initEngineCnt == 0) _termEngine(); if (rendererCnt == 0 && initEngineCnt == 0) _termEngine();
} }
void GlRenderer::initShaders() void GlRenderer::initShaders()
{ {
// Solid Color Renderer mPrograms.reserve((int)RT_None);
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(COLOR_VERT_SHADER, COLOR_FRAG_SHADER)));
// Linear Gradient Renderer mPrograms.push(new GlProgram(COLOR_VERT_SHADER, COLOR_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(GRADIENT_VERT_SHADER, LINEAR_GRADIENT_FRAG_SHADER))); mPrograms.push(new GlProgram(GRADIENT_VERT_SHADER, LINEAR_GRADIENT_FRAG_SHADER));
mPrograms.push(new GlProgram(GRADIENT_VERT_SHADER, RADIAL_GRADIENT_FRAG_SHADER));
// Radial Gradient Renderer mPrograms.push(new GlProgram(IMAGE_VERT_SHADER, IMAGE_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(GRADIENT_VERT_SHADER, RADIAL_GRADIENT_FRAG_SHADER)));
// image Renderer
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(IMAGE_VERT_SHADER, IMAGE_FRAG_SHADER)));
// compose Renderer // compose Renderer
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_ALPHA_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_ALPHA_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_INV_ALPHA_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_INV_ALPHA_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_LUMA_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_LUMA_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_INV_LUMA_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_INV_LUMA_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_ADD_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_ADD_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_SUB_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_SUB_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_INTERSECT_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_INTERSECT_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_DIFF_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_DIFF_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_LIGHTEN_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_LIGHTEN_FRAG_SHADER));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MASK_DARKEN_FRAG_SHADER))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MASK_DARKEN_FRAG_SHADER));
// stencil Renderer // stencil Renderer
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(STENCIL_VERT_SHADER, STENCIL_FRAG_SHADER))); mPrograms.push(new GlProgram(STENCIL_VERT_SHADER, STENCIL_FRAG_SHADER));
// blit Renderer // blit Renderer
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(BLIT_VERT_SHADER, BLIT_FRAG_SHADER))); mPrograms.push(new GlProgram(BLIT_VERT_SHADER, BLIT_FRAG_SHADER));
// complex blending Renderer // complex blending Renderer
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, MULTIPLY_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, MULTIPLY_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, SCREEN_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, SCREEN_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, OVERLAY_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, OVERLAY_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, COLOR_DODGE_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, COLOR_DODGE_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, COLOR_BURN_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, COLOR_BURN_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, HARD_LIGHT_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, HARD_LIGHT_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, SOFT_LIGHT_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, SOFT_LIGHT_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, DIFFERENCE_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, DIFFERENCE_BLEND_FRAG));
mPrograms.push_back(make_unique<GlProgram>(GlShader::gen(MASK_VERT_SHADER, EXCLUSION_BLEND_FRAG))); mPrograms.push(new GlProgram(MASK_VERT_SHADER, EXCLUSION_BLEND_FRAG));
} }
void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdateFlag flag, int32_t depth) void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdateFlag flag, int32_t depth)
{ {
auto vp = currentPass()->getViewport(); auto vp = currentPass()->getViewport();
auto bbox = sdata.geometry->getViewport(); auto bbox = sdata.geometry.getViewport();
bbox.intersect(vp); bbox.intersect(vp);
auto complexBlend = beginComplexBlending(bbox, sdata.geometry->getBounds()); auto complexBlend = beginComplexBlending(bbox, sdata.geometry.getBounds());
if (complexBlend) { if (complexBlend) {
vp = currentPass()->getViewport(); vp = currentPass()->getViewport();
@ -139,12 +153,12 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdat
auto h = bbox.h; auto h = bbox.h;
GlRenderTask* task = nullptr; GlRenderTask* task = nullptr;
if (mBlendMethod != BlendMethod::Normal && !complexBlend) task = new GlSimpleBlendTask(mBlendMethod, mPrograms[RT_Color].get()); if (mBlendMethod != BlendMethod::Normal && !complexBlend) task = new GlSimpleBlendTask(mBlendMethod, mPrograms[RT_Color]);
else task = new GlRenderTask(mPrograms[RT_Color].get()); else task = new GlRenderTask(mPrograms[RT_Color]);
task->setDrawDepth(depth); task->setDrawDepth(depth);
if (!sdata.geometry->draw(task, mGpuBuffer.get(), flag)) { if (!sdata.geometry.draw(task, &mGpuBuffer, flag)) {
delete task; delete task;
return; return;
} }
@ -153,16 +167,16 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdat
GlRenderTask* stencilTask = nullptr; GlRenderTask* stencilTask = nullptr;
GlStencilMode stencilMode = sdata.geometry->getStencilMode(flag); GlStencilMode stencilMode = sdata.geometry.getStencilMode(flag);
if (stencilMode != GlStencilMode::None) { if (stencilMode != GlStencilMode::None) {
stencilTask = new GlRenderTask(mPrograms[RT_Stencil].get(), task); stencilTask = new GlRenderTask(mPrograms[RT_Stencil], task);
stencilTask->setDrawDepth(depth); stencilTask->setDrawDepth(depth);
} }
auto a = MULTIPLY(c.a, sdata.opacity); auto a = MULTIPLY(c.a, sdata.opacity);
if (flag & RenderUpdateFlag::Stroke) { if (flag & RenderUpdateFlag::Stroke) {
float strokeWidth = sdata.rshape->strokeWidth() * getScaleFactor(sdata.geometry->getTransformMatrix()); float strokeWidth = sdata.rshape->strokeWidth() * getScaleFactor(sdata.geometry.getTransformMatrix());
if (strokeWidth < MIN_GL_STROKE_WIDTH) { if (strokeWidth < MIN_GL_STROKE_WIDTH) {
float alpha = strokeWidth / MIN_GL_STROKE_WIDTH; float alpha = strokeWidth / MIN_GL_STROKE_WIDTH;
a = MULTIPLY(a, static_cast<uint8_t>(alpha * 255)); a = MULTIPLY(a, static_cast<uint8_t>(alpha * 255));
@ -170,16 +184,16 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdat
} }
// matrix buffer // matrix buffer
const auto& matrix = sdata.geometry->getTransformMatrix(); const auto& matrix = sdata.geometry.getTransformMatrix();
float matrix44[16]; float matrix44[16];
currentPass()->getMatrix(matrix44, matrix); currentPass()->getMatrix(matrix44, matrix);
auto viewOffset = mGpuBuffer->push(matrix44, 16 * sizeof(float), true); auto viewOffset = mGpuBuffer.push(matrix44, 16 * sizeof(float), true);
task->addBindResource(GlBindingResource{ task->addBindResource(GlBindingResource{
0, 0,
task->getProgram()->getUniformBlockIndex("Matrix"), task->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
viewOffset, viewOffset,
16 * sizeof(float), 16 * sizeof(float),
}); });
@ -188,7 +202,7 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdat
stencilTask->addBindResource(GlBindingResource{ stencilTask->addBindResource(GlBindingResource{
0, 0,
stencilTask->getProgram()->getUniformBlockIndex("Matrix"), stencilTask->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
viewOffset, viewOffset,
16 * sizeof(float), 16 * sizeof(float),
}); });
@ -200,8 +214,8 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdat
task->addBindResource(GlBindingResource{ task->addBindResource(GlBindingResource{
1, 1,
task->getProgram()->getUniformBlockIndex("ColorInfo"), task->getProgram()->getUniformBlockIndex("ColorInfo"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
mGpuBuffer->push(color, 4 * sizeof(float), true), mGpuBuffer.push(color, 4 * sizeof(float), true),
4 * sizeof(float), 4 * sizeof(float),
}); });
@ -209,9 +223,9 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdat
else currentPass()->addRenderTask(task); else currentPass()->addRenderTask(task);
if (complexBlend) { if (complexBlend) {
auto task = new GlRenderTask(mPrograms[RT_Stencil].get()); auto task = new GlRenderTask(mPrograms[RT_Stencil]);
sdata.geometry->draw(task, mGpuBuffer.get(), flag); sdata.geometry.draw(task, &mGpuBuffer, flag);
endBlendingCompose(task, sdata.geometry->getTransformMatrix()); endBlendingCompose(task, sdata.geometry.getTransformMatrix());
} }
} }
@ -219,7 +233,7 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const RenderColor& c, RenderUpdat
void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFlag flag, int32_t depth) void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFlag flag, int32_t depth)
{ {
auto vp = currentPass()->getViewport(); auto vp = currentPass()->getViewport();
auto bbox = sdata.geometry->getViewport(); auto bbox = sdata.geometry.getViewport();
bbox.intersect(vp); bbox.intersect(vp);
@ -230,21 +244,21 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFla
GlRenderTask* task = nullptr; GlRenderTask* task = nullptr;
if (fill->type() == Type::LinearGradient) { if (fill->type() == Type::LinearGradient) {
task = new GlRenderTask(mPrograms[RT_LinGradient].get()); task = new GlRenderTask(mPrograms[RT_LinGradient]);
} else if (fill->type() == Type::RadialGradient) { } else if (fill->type() == Type::RadialGradient) {
task = new GlRenderTask(mPrograms[RT_RadGradient].get()); task = new GlRenderTask(mPrograms[RT_RadGradient]);
} else { } else {
return; return;
} }
task->setDrawDepth(depth); task->setDrawDepth(depth);
if (!sdata.geometry->draw(task, mGpuBuffer.get(), flag)) { if (!sdata.geometry.draw(task, &mGpuBuffer, flag)) {
delete task; delete task;
return; return;
} }
auto complexBlend = beginComplexBlending(bbox, sdata.geometry->getBounds()); auto complexBlend = beginComplexBlending(bbox, sdata.geometry.getBounds());
if (complexBlend) vp = currentPass()->getViewport(); if (complexBlend) vp = currentPass()->getViewport();
@ -254,14 +268,14 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFla
task->setViewport({x, vp.h - y - bbox.h, bbox.w, bbox.h}); task->setViewport({x, vp.h - y - bbox.h, bbox.w, bbox.h});
GlRenderTask* stencilTask = nullptr; GlRenderTask* stencilTask = nullptr;
GlStencilMode stencilMode = sdata.geometry->getStencilMode(flag); GlStencilMode stencilMode = sdata.geometry.getStencilMode(flag);
if (stencilMode != GlStencilMode::None) { if (stencilMode != GlStencilMode::None) {
stencilTask = new GlRenderTask(mPrograms[RT_Stencil].get(), task); stencilTask = new GlRenderTask(mPrograms[RT_Stencil], task);
stencilTask->setDrawDepth(depth); stencilTask->setDrawDepth(depth);
} }
// matrix buffer // matrix buffer
const auto& matrix = sdata.geometry->getTransformMatrix(); const auto& matrix = sdata.geometry.getTransformMatrix();
float invMat4[16]; float invMat4[16];
Matrix inv; Matrix inv;
inverse(&fill->transform(), &inv); inverse(&fill->transform(), &inv);
@ -270,12 +284,12 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFla
float matrix44[16]; float matrix44[16];
currentPass()->getMatrix(matrix44, matrix); currentPass()->getMatrix(matrix44, matrix);
auto viewOffset = mGpuBuffer->push(matrix44, 16 * sizeof(float), true); auto viewOffset = mGpuBuffer.push(matrix44, 16 * sizeof(float), true);
task->addBindResource(GlBindingResource{ task->addBindResource(GlBindingResource{
0, 0,
task->getProgram()->getUniformBlockIndex("Matrix"), task->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
viewOffset, viewOffset,
16 * sizeof(float), 16 * sizeof(float),
}); });
@ -284,18 +298,18 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFla
stencilTask->addBindResource(GlBindingResource{ stencilTask->addBindResource(GlBindingResource{
0, 0,
stencilTask->getProgram()->getUniformBlockIndex("Matrix"), stencilTask->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
viewOffset, viewOffset,
16 * sizeof(float), 16 * sizeof(float),
}); });
} }
viewOffset = mGpuBuffer->push(invMat4, 16 * sizeof(float), true); viewOffset = mGpuBuffer.push(invMat4, 16 * sizeof(float), true);
task->addBindResource(GlBindingResource{ task->addBindResource(GlBindingResource{
1, 1,
task->getProgram()->getUniformBlockIndex("InvMatrix"), task->getProgram()->getUniformBlockIndex("InvMatrix"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
viewOffset, viewOffset,
16 * sizeof(float), 16 * sizeof(float),
}); });
@ -344,8 +358,8 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFla
gradientBinding = GlBindingResource{ gradientBinding = GlBindingResource{
2, 2,
loc, loc,
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
mGpuBuffer->push(&gradientBlock, sizeof(GlLinearGradientBlock), true), mGpuBuffer.push(&gradientBlock, sizeof(GlLinearGradientBlock), true),
sizeof(GlLinearGradientBlock), sizeof(GlLinearGradientBlock),
}; };
} else { } else {
@ -382,8 +396,8 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFla
gradientBinding = GlBindingResource{ gradientBinding = GlBindingResource{
2, 2,
loc, loc,
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
mGpuBuffer->push(&gradientBlock, sizeof(GlRadialGradientBlock), true), mGpuBuffer.push(&gradientBlock, sizeof(GlRadialGradientBlock), true),
sizeof(GlRadialGradientBlock), sizeof(GlRadialGradientBlock),
}; };
} }
@ -397,10 +411,9 @@ void GlRenderer::drawPrimitive(GlShape& sdata, const Fill* fill, RenderUpdateFla
} }
if (complexBlend) { if (complexBlend) {
auto task = new GlRenderTask(mPrograms[RT_Stencil].get()); auto task = new GlRenderTask(mPrograms[RT_Stencil]);
sdata.geometry->draw(task, mGpuBuffer.get(), flag); sdata.geometry.draw(task, &mGpuBuffer, flag);
endBlendingCompose(task, sdata.geometry.getTransformMatrix());
endBlendingCompose(task, sdata.geometry->getTransformMatrix());
} }
} }
@ -437,9 +450,9 @@ void GlRenderer::drawClip(Array<RenderData>& clips)
mat4[10] = 1.f; mat4[10] = 1.f;
mat4[15] = 1.f; mat4[15] = 1.f;
auto identityVertexOffset = mGpuBuffer->push(identityVertex.data, 8 * sizeof(float)); auto identityVertexOffset = mGpuBuffer.push(identityVertex.data, 8 * sizeof(float));
auto identityIndexOffset = mGpuBuffer->pushIndex(identityIndex.data, 6 * sizeof(uint32_t)); auto identityIndexOffset = mGpuBuffer.pushIndex(identityIndex.data, 6 * sizeof(uint32_t));
auto mat4Offset = mGpuBuffer->push(mat4, 16 * sizeof(float), true); auto mat4Offset = mGpuBuffer.push(mat4, 16 * sizeof(float), true);
Array<int32_t> clipDepths(clips.count); Array<int32_t> clipDepths(clips.count);
clipDepths.count = clips.count; clipDepths.count = clips.count;
@ -453,13 +466,13 @@ void GlRenderer::drawClip(Array<RenderData>& clips)
for (uint32_t i = 0; i < clips.count; ++i) { for (uint32_t i = 0; i < clips.count; ++i) {
auto sdata = static_cast<GlShape*>(clips[i]); auto sdata = static_cast<GlShape*>(clips[i]);
auto clipTask = new GlRenderTask(mPrograms[RT_Stencil].get()); auto clipTask = new GlRenderTask(mPrograms[RT_Stencil]);
clipTask->setDrawDepth(clipDepths[i]); clipTask->setDrawDepth(clipDepths[i]);
sdata->geometry->draw(clipTask, mGpuBuffer.get(), RenderUpdateFlag::Path); sdata->geometry.draw(clipTask, &mGpuBuffer, RenderUpdateFlag::Path);
auto bbox = sdata->geometry->getViewport(); auto bbox = sdata->geometry.getViewport();
bbox.intersect(vp); bbox.intersect(vp);
@ -468,35 +481,22 @@ void GlRenderer::drawClip(Array<RenderData>& clips)
clipTask->setViewport({x, vp.h - y - bbox.h, bbox.w, bbox.h}); clipTask->setViewport({x, vp.h - y - bbox.h, bbox.w, bbox.h});
const auto& matrix = sdata->geometry->getTransformMatrix(); const auto& matrix = sdata->geometry.getTransformMatrix();
float matrix44[16]; float matrix44[16];
currentPass()->getMatrix(matrix44, matrix); currentPass()->getMatrix(matrix44, matrix);
auto loc = clipTask->getProgram()->getUniformBlockIndex("Matrix"); auto loc = clipTask->getProgram()->getUniformBlockIndex("Matrix");
auto viewOffset = mGpuBuffer->push(matrix44, 16 * sizeof(float), true); auto viewOffset = mGpuBuffer.push(matrix44, 16 * sizeof(float), true);
clipTask->addBindResource(GlBindingResource{ clipTask->addBindResource(GlBindingResource{0, loc, mGpuBuffer.getBufferId(), viewOffset, 16 * sizeof(float), });
0,
loc,
mGpuBuffer->getBufferId(),
viewOffset,
16 * sizeof(float),
});
auto maskTask = new GlRenderTask(mPrograms[RT_Stencil].get()); auto maskTask = new GlRenderTask(mPrograms[RT_Stencil]);
maskTask->setDrawDepth(clipDepths[i]); maskTask->setDrawDepth(clipDepths[i]);
maskTask->addVertexLayout(GlVertexLayout{0, 2, 2 * sizeof(float), identityVertexOffset}); maskTask->addVertexLayout(GlVertexLayout{0, 2, 2 * sizeof(float), identityVertexOffset});
maskTask->addBindResource(GlBindingResource{ maskTask->addBindResource(GlBindingResource{0, loc, mGpuBuffer.getBufferId(), mat4Offset, 16 * sizeof(float), });
0,
loc,
mGpuBuffer->getBufferId(),
mat4Offset, 16 * sizeof(float),
});
maskTask->setDrawRange(identityIndexOffset, 6); maskTask->setDrawRange(identityIndexOffset, 6);
maskTask->setViewport({0, 0, static_cast<int32_t>(vp.w), static_cast<int32_t>(vp.h)}); maskTask->setViewport({0, 0, static_cast<int32_t>(vp.w), static_cast<int32_t>(vp.h)});
@ -507,8 +507,7 @@ void GlRenderer::drawClip(Array<RenderData>& clips)
GlRenderPass* GlRenderer::currentPass() GlRenderPass* GlRenderer::currentPass()
{ {
if (mRenderPassStack.empty()) return nullptr; if (mRenderPassStack.empty()) return nullptr;
return mRenderPassStack.last();
return &mRenderPassStack.back();
} }
bool GlRenderer::beginComplexBlending(const RenderRegion& vp, RenderRegion bounds) bool GlRenderer::beginComplexBlending(const RenderRegion& vp, RenderRegion bounds)
@ -525,21 +524,21 @@ bool GlRenderer::beginComplexBlending(const RenderRegion& vp, RenderRegion bound
auto blendFbo = mBlendPool[0]->getRenderTarget(bounds); auto blendFbo = mBlendPool[0]->getRenderTarget(bounds);
mRenderPassStack.emplace_back(GlRenderPass{blendFbo}); mRenderPassStack.push(new GlRenderPass(blendFbo));
return true; return true;
} }
void GlRenderer::endBlendingCompose(GlRenderTask* stencilTask, const Matrix& matrix) void GlRenderer::endBlendingCompose(GlRenderTask* stencilTask, const Matrix& matrix)
{ {
auto blendPass = std::move(mRenderPassStack.back()); auto blendPass = mRenderPassStack.last();
mRenderPassStack.pop_back(); mRenderPassStack.pop();
blendPass.setDrawDepth(currentPass()->nextDrawDepth()); blendPass->setDrawDepth(currentPass()->nextDrawDepth());
auto composeTask = blendPass.endRenderPass<GlComposeTask>(nullptr, currentPass()->getFboId()); auto composeTask = blendPass->endRenderPass<GlComposeTask>(nullptr, currentPass()->getFboId());
const auto& vp = blendPass.getViewport(); const auto& vp = blendPass->getViewport();
if (mBlendPool.count < 2) mBlendPool.push(new GlRenderTargetPool(surface.w, surface.h)); if (mBlendPool.count < 2) mBlendPool.push(new GlRenderTargetPool(surface.w, surface.h));
auto dstCopyFbo = mBlendPool[1]->getRenderTarget(vp); auto dstCopyFbo = mBlendPool[1]->getRenderTarget(vp);
@ -560,11 +559,11 @@ void GlRenderer::endBlendingCompose(GlRenderTask* stencilTask, const Matrix& mat
// set view matrix // set view matrix
float matrix44[16]; float matrix44[16];
currentPass()->getMatrix(matrix44, matrix); currentPass()->getMatrix(matrix44, matrix);
uint32_t viewOffset = mGpuBuffer->push(matrix44, 16 * sizeof(float), true); uint32_t viewOffset = mGpuBuffer.push(matrix44, 16 * sizeof(float), true);
stencilTask->addBindResource(GlBindingResource{ stencilTask->addBindResource(GlBindingResource{
0, 0,
stencilTask->getProgram()->getUniformBlockIndex("Matrix"), stencilTask->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
viewOffset, viewOffset,
16 * sizeof(float), 16 * sizeof(float),
}); });
@ -572,40 +571,32 @@ void GlRenderer::endBlendingCompose(GlRenderTask* stencilTask, const Matrix& mat
auto task = new GlComplexBlendTask(getBlendProgram(), currentPass()->getFbo(), dstCopyFbo, stencilTask, composeTask); auto task = new GlComplexBlendTask(getBlendProgram(), currentPass()->getFbo(), dstCopyFbo, stencilTask, composeTask);
prepareCmpTask(task, vp, blendPass.getFboWidth(), blendPass.getFboHeight()); prepareCmpTask(task, vp, blendPass->getFboWidth(), blendPass->getFboHeight());
task->setDrawDepth(currentPass()->nextDrawDepth()); task->setDrawDepth(currentPass()->nextDrawDepth());
// src and dst texture // src and dst texture
task->addBindResource(GlBindingResource{1, blendPass.getFbo()->getColorTexture(), task->getProgram()->getUniformLocation("uSrcTexture")}); task->addBindResource(GlBindingResource{1, blendPass->getFbo()->getColorTexture(), task->getProgram()->getUniformLocation("uSrcTexture")});
task->addBindResource(GlBindingResource{2, dstCopyFbo->getColorTexture(), task->getProgram()->getUniformLocation("uDstTexture")}); task->addBindResource(GlBindingResource{2, dstCopyFbo->getColorTexture(), task->getProgram()->getUniformLocation("uDstTexture")});
currentPass()->addRenderTask(task); currentPass()->addRenderTask(task);
delete(blendPass);
} }
GlProgram* GlRenderer::getBlendProgram() GlProgram* GlRenderer::getBlendProgram()
{ {
switch (mBlendMethod) { switch (mBlendMethod) {
case BlendMethod::Multiply: case BlendMethod::Multiply: return mPrograms[RT_MultiplyBlend];
return mPrograms[RT_MultiplyBlend].get(); case BlendMethod::Screen: return mPrograms[RT_ScreenBlend];
case BlendMethod::Screen: case BlendMethod::Overlay: return mPrograms[RT_OverlayBlend];
return mPrograms[RT_ScreenBlend].get(); case BlendMethod::ColorDodge: return mPrograms[RT_ColorDodgeBlend];
case BlendMethod::Overlay: case BlendMethod::ColorBurn: return mPrograms[RT_ColorBurnBlend];
return mPrograms[RT_OverlayBlend].get(); case BlendMethod::HardLight: return mPrograms[RT_HardLightBlend];
case BlendMethod::ColorDodge: case BlendMethod::SoftLight: return mPrograms[RT_SoftLightBlend];
return mPrograms[RT_ColorDodgeBlend].get(); case BlendMethod::Difference: return mPrograms[RT_DifferenceBlend];
case BlendMethod::ColorBurn: case BlendMethod::Exclusion: return mPrograms[RT_ExclusionBlend];
return mPrograms[RT_ColorBurnBlend].get(); default: return nullptr;
case BlendMethod::HardLight:
return mPrograms[RT_HardLightBlend].get();
case BlendMethod::SoftLight:
return mPrograms[RT_SoftLightBlend].get();
case BlendMethod::Difference:
return mPrograms[RT_DifferenceBlend].get();
case BlendMethod::Exclusion:
return mPrograms[RT_ExclusionBlend].get();
default:
return nullptr;
} }
} }
@ -680,8 +671,8 @@ void GlRenderer::prepareCmpTask(GlRenderTask* task, const RenderRegion& vp, uint
indices.push(1); indices.push(1);
indices.push(3); indices.push(3);
uint32_t vertexOffset = mGpuBuffer->push(vertices.data, vertices.count * sizeof(float)); uint32_t vertexOffset = mGpuBuffer.push(vertices.data, vertices.count * sizeof(float));
uint32_t indexOffset = mGpuBuffer->pushIndex(indices.data, indices.count * sizeof(uint32_t)); uint32_t indexOffset = mGpuBuffer.pushIndex(indices.data, indices.count * sizeof(uint32_t));
task->addVertexLayout(GlVertexLayout{0, 2, 4 * sizeof(float), vertexOffset}); task->addVertexLayout(GlVertexLayout{0, 2, 4 * sizeof(float), vertexOffset});
task->addVertexLayout(GlVertexLayout{1, 2, 4 * sizeof(float), vertexOffset + 2 * sizeof(float)}); task->addVertexLayout(GlVertexLayout{1, 2, 4 * sizeof(float), vertexOffset + 2 * sizeof(float)});
@ -694,111 +685,91 @@ void GlRenderer::prepareCmpTask(GlRenderTask* task, const RenderRegion& vp, uint
void GlRenderer::endRenderPass(RenderCompositor* cmp) void GlRenderer::endRenderPass(RenderCompositor* cmp)
{ {
auto gl_cmp = static_cast<GlCompositor*>(cmp); auto glCmp = static_cast<GlCompositor*>(cmp);
if (cmp->method != MaskMethod::None) { if (cmp->method != MaskMethod::None) {
auto self_pass = std::move(mRenderPassStack.back()); auto selfPass = mRenderPassStack.last();
mRenderPassStack.pop_back(); mRenderPassStack.pop();
// mask is pushed first // mask is pushed first
auto mask_pass = std::move(mRenderPassStack.back()); auto maskPass = mRenderPassStack.last();
mRenderPassStack.pop_back(); mRenderPassStack.pop();
if (self_pass.isEmpty() || mask_pass.isEmpty()) return;
GlProgram* program = nullptr; GlProgram* program = nullptr;
switch(cmp->method) { switch(cmp->method) {
case MaskMethod::Alpha: case MaskMethod::Alpha: program = mPrograms[RT_MaskAlpha]; break;
program = mPrograms[RT_MaskAlpha].get(); case MaskMethod::InvAlpha: program = mPrograms[RT_MaskAlphaInv]; break;
break; case MaskMethod::Luma: program = mPrograms[RT_MaskLuma]; break;
case MaskMethod::InvAlpha: case MaskMethod::InvLuma: program = mPrograms[RT_MaskLumaInv]; break;
program = mPrograms[RT_MaskAlphaInv].get(); case MaskMethod::Add: program = mPrograms[RT_MaskAdd]; break;
break; case MaskMethod::Subtract: program = mPrograms[RT_MaskSub]; break;
case MaskMethod::Luma: case MaskMethod::Intersect: program = mPrograms[RT_MaskIntersect]; break;
program = mPrograms[RT_MaskLuma].get(); case MaskMethod::Difference: program = mPrograms[RT_MaskDifference]; break;
break; case MaskMethod::Lighten: program = mPrograms[RT_MaskLighten]; break;
case MaskMethod::InvLuma: case MaskMethod::Darken: program = mPrograms[RT_MaskDarken]; break;
program = mPrograms[RT_MaskLumaInv].get(); default: break;
break;
case MaskMethod::Add:
program = mPrograms[RT_MaskAdd].get();
break;
case MaskMethod::Subtract:
program = mPrograms[RT_MaskSub].get();
break;
case MaskMethod::Intersect:
program = mPrograms[RT_MaskIntersect].get();
break;
case MaskMethod::Difference:
program = mPrograms[RT_MaskDifference].get();
break;
case MaskMethod::Lighten:
program = mPrograms[RT_MaskLighten].get();
break;
case MaskMethod::Darken:
program = mPrograms[RT_MaskDarken].get();
break;
default:
break;
} }
if (!program) return; if (program && !selfPass->isEmpty() && !maskPass->isEmpty()) {
auto prev_task = maskPass->endRenderPass<GlComposeTask>(nullptr, currentPass()->getFboId());
prev_task->setDrawDepth(currentPass()->nextDrawDepth());
prev_task->setRenderSize(static_cast<uint32_t>(glCmp->bbox.w), static_cast<uint32_t>(glCmp->bbox.h));
prev_task->setViewport(glCmp->bbox);
auto prev_task = mask_pass.endRenderPass<GlComposeTask>(nullptr, currentPass()->getFboId()); auto compose_task = selfPass->endRenderPass<GlDrawBlitTask>(program, currentPass()->getFboId());
prev_task->setDrawDepth(currentPass()->nextDrawDepth()); compose_task->setRenderSize(static_cast<uint32_t>(glCmp->bbox.w), static_cast<uint32_t>(glCmp->bbox.h));
prev_task->setRenderSize(static_cast<uint32_t>(gl_cmp->bbox.w), static_cast<uint32_t>(gl_cmp->bbox.h)); compose_task->setPrevTask(prev_task);
prev_task->setViewport(gl_cmp->bbox);
auto compose_task = self_pass.endRenderPass<GlDrawBlitTask>(program, currentPass()->getFboId()); prepareCmpTask(compose_task, glCmp->bbox, selfPass->getFboWidth(), selfPass->getFboHeight());
compose_task->setRenderSize(static_cast<uint32_t>(gl_cmp->bbox.w), static_cast<uint32_t>(gl_cmp->bbox.h));
compose_task->setPrevTask(prev_task);
prepareCmpTask(compose_task, gl_cmp->bbox, self_pass.getFboWidth(), self_pass.getFboHeight()); compose_task->addBindResource(GlBindingResource{0, selfPass->getTextureId(), program->getUniformLocation("uSrcTexture")});
compose_task->addBindResource(GlBindingResource{1, maskPass->getTextureId(), program->getUniformLocation("uMaskTexture")});
compose_task->addBindResource(GlBindingResource{0, self_pass.getTextureId(), program->getUniformLocation("uSrcTexture")}); compose_task->setDrawDepth(currentPass()->nextDrawDepth());
compose_task->addBindResource(GlBindingResource{1, mask_pass.getTextureId(), program->getUniformLocation("uMaskTexture")}); compose_task->setParentSize(static_cast<uint32_t>(currentPass()->getViewport().w), static_cast<uint32_t>(currentPass()->getViewport().h));
currentPass()->addRenderTask(compose_task);
}
compose_task->setDrawDepth(currentPass()->nextDrawDepth()); delete(selfPass);
compose_task->setParentSize(static_cast<uint32_t>(currentPass()->getViewport().w), static_cast<uint32_t>(currentPass()->getViewport().h)); delete(maskPass);
currentPass()->addRenderTask(compose_task);
} else { } else {
auto renderPass = std::move(mRenderPassStack.back()); auto renderPass = mRenderPassStack.last();
mRenderPassStack.pop_back(); mRenderPassStack.pop();
if (renderPass.isEmpty()) return; if (!renderPass->isEmpty()) {
auto task = renderPass->endRenderPass<GlDrawBlitTask>(mPrograms[RT_Image], currentPass()->getFboId());
task->setRenderSize(static_cast<uint32_t>(glCmp->bbox.w), static_cast<uint32_t>(glCmp->bbox.h));
prepareCmpTask(task, glCmp->bbox, renderPass->getFboWidth(), renderPass->getFboHeight());
task->setDrawDepth(currentPass()->nextDrawDepth());
auto task = renderPass.endRenderPass<GlDrawBlitTask>( // matrix buffer
mPrograms[RT_Image].get(), currentPass()->getFboId()); float matrix[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
task->setRenderSize(static_cast<uint32_t>(gl_cmp->bbox.w), static_cast<uint32_t>(gl_cmp->bbox.h));
prepareCmpTask(task, gl_cmp->bbox, renderPass.getFboWidth(), renderPass.getFboHeight());
task->setDrawDepth(currentPass()->nextDrawDepth());
// matrix buffer task->addBindResource(GlBindingResource{
float matrix[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}; 0,
task->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer.getBufferId(),
mGpuBuffer.push(matrix, 16 * sizeof(float), true),
16 * sizeof(float),
});
task->addBindResource(GlBindingResource{ // image info
0, uint32_t info[4] = {(uint32_t)ColorSpace::ABGR8888, 0, cmp->opacity, 0};
task->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer->getBufferId(),
mGpuBuffer->push(matrix, 16 * sizeof(float), true),
16 * sizeof(float),
});
// image info task->addBindResource(GlBindingResource{
uint32_t info[4] = {(uint32_t)ColorSpace::ABGR8888, 0, cmp->opacity, 0}; 1,
task->getProgram()->getUniformBlockIndex("ColorInfo"),
mGpuBuffer.getBufferId(),
mGpuBuffer.push(info, 4 * sizeof(uint32_t), true),
4 * sizeof(uint32_t),
});
task->addBindResource(GlBindingResource{ // texture id
1, task->addBindResource(GlBindingResource{0, renderPass->getTextureId(), task->getProgram()->getUniformLocation("uTexture")});
task->getProgram()->getUniformBlockIndex("ColorInfo"), task->setParentSize(static_cast<uint32_t>(currentPass()->getViewport().w), static_cast<uint32_t>(currentPass()->getViewport().h));
mGpuBuffer->getBufferId(), currentPass()->addRenderTask(std::move(task));
mGpuBuffer->push(info, 4 * sizeof(uint32_t), true), }
4 * sizeof(uint32_t), delete(renderPass);
});
// texture id
task->addBindResource(GlBindingResource{0, renderPass.getTextureId(), task->getProgram()->getUniformLocation("uTexture")});
task->setParentSize(static_cast<uint32_t>(currentPass()->getViewport().w), static_cast<uint32_t>(currentPass()->getViewport().h));
currentPass()->addRenderTask(std::move(task));
} }
} }
@ -809,8 +780,6 @@ void GlRenderer::endRenderPass(RenderCompositor* cmp)
bool GlRenderer::clear() bool GlRenderer::clear()
{ {
clearDisposes();
mClearBuffer = true; mClearBuffer = true;
return true; return true;
} }
@ -820,24 +789,18 @@ bool GlRenderer::target(int32_t id, uint32_t w, uint32_t h)
{ {
if (id == GL_INVALID_VALUE || w == 0 || h == 0) return false; if (id == GL_INVALID_VALUE || w == 0 || h == 0) return false;
flush();
surface.stride = w; surface.stride = w;
surface.w = w; surface.w = w;
surface.h = h; surface.h = h;
mTargetFboId = static_cast<GLint>(id); mTargetFboId = static_cast<GLint>(id);
mRootTarget = make_unique<GlRenderTarget>(surface.w, surface.h); mRootTarget.mWidth = surface.w;
mRootTarget->setViewport({0, 0, static_cast<int32_t>(surface.w), static_cast<int32_t>(surface.h)}); mRootTarget.mHeight = surface.h;
mRootTarget->init(mTargetFboId); mRootTarget.setViewport({0, 0, static_cast<int32_t>(surface.w), static_cast<int32_t>(surface.h)});
mRootTarget.init(mTargetFboId);
mRenderPassStack.clear();
mComposeStack.clear();
for (uint32_t i = 0; i < mComposePool.count; i++) delete mComposePool[i];
for (uint32_t i = 0; i < mBlendPool.count; i++) delete mBlendPool[i];
mComposePool.clear();
mBlendPool.clear();
return true; return true;
} }
@ -846,7 +809,7 @@ bool GlRenderer::target(int32_t id, uint32_t w, uint32_t h)
bool GlRenderer::sync() bool GlRenderer::sync()
{ {
//nothing to be done. //nothing to be done.
if (mRenderPassStack.size() == 0) return true; if (mRenderPassStack.empty()) return true;
// Blend function for straight alpha // Blend function for straight alpha
GL_CHECK(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA)); GL_CHECK(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
@ -857,26 +820,23 @@ bool GlRenderer::sync()
GL_CHECK(glEnable(GL_DEPTH_TEST)); GL_CHECK(glEnable(GL_DEPTH_TEST));
GL_CHECK(glDepthFunc(GL_GREATER)); GL_CHECK(glDepthFunc(GL_GREATER));
auto task = mRenderPassStack.front().endRenderPass<GlBlitTask>(mPrograms[RT_Blit].get(), mTargetFboId); auto task = mRenderPassStack.first()->endRenderPass<GlBlitTask>(mPrograms[RT_Blit], mTargetFboId);
prepareBlitTask(task); prepareBlitTask(task);
task->mClearBuffer = mClearBuffer; task->mClearBuffer = mClearBuffer;
task->setTargetViewport({0, 0, static_cast<int32_t>(surface.w), static_cast<int32_t>(surface.h)}); task->setTargetViewport({0, 0, static_cast<int32_t>(surface.w), static_cast<int32_t>(surface.h)});
if (mGpuBuffer->flushToGPU()) { if (mGpuBuffer.flushToGPU()) {
mGpuBuffer->bind(); mGpuBuffer.bind();
task->run(); task->run();
} }
mGpuBuffer->unbind(); mGpuBuffer.unbind();
GL_CHECK(glDisable(GL_SCISSOR_TEST)); GL_CHECK(glDisable(GL_SCISSOR_TEST));
mRenderPassStack.clear(); flush();
clearDisposes();
delete task; delete task;
@ -889,7 +849,7 @@ RenderRegion GlRenderer::region(RenderData data)
if (currentPass()->isEmpty()) return {0, 0, 0, 0}; if (currentPass()->isEmpty()) return {0, 0, 0, 0};
auto shape = reinterpret_cast<GlShape*>(data); auto shape = reinterpret_cast<GlShape*>(data);
auto bounds = shape->geometry->getBounds(); auto bounds = shape->geometry.getBounds();
auto const& vp = currentPass()->getViewport(); auto const& vp = currentPass()->getViewport();
bounds.intersect(vp); bounds.intersect(vp);
@ -900,12 +860,8 @@ RenderRegion GlRenderer::region(RenderData data)
bool GlRenderer::preRender() bool GlRenderer::preRender()
{ {
if (mPrograms.size() == 0) if (mPrograms.empty()) initShaders();
{ mRenderPassStack.push(new GlRenderPass(&mRootTarget));
initShaders();
}
mRenderPassStack.emplace_back(GlRenderPass(mRootTarget.get()));
return true; return true;
} }
@ -924,8 +880,8 @@ RenderCompositor* GlRenderer::target(const RenderRegion& region, TVG_UNUSED Colo
vp.intersect(currentPass()->getViewport()); vp.intersect(currentPass()->getViewport());
mComposeStack.emplace_back(make_unique<GlCompositor>(vp)); mComposeStack.push(new GlCompositor(vp));
return mComposeStack.back().get(); return mComposeStack.last();
} }
@ -936,7 +892,7 @@ bool GlRenderer::beginComposite(RenderCompositor* cmp, MaskMethod method, uint8_
cmp->method = method; cmp->method = method;
cmp->opacity = opacity; cmp->opacity = opacity;
uint32_t index = mRenderPassStack.size() - 1; uint32_t index = mRenderPassStack.count - 1;
if (index >= mComposePool.count) { if (index >= mComposePool.count) {
mComposePool.push( new GlRenderTargetPool(surface.w, surface.h)); mComposePool.push( new GlRenderTargetPool(surface.w, surface.h));
@ -946,10 +902,10 @@ bool GlRenderer::beginComposite(RenderCompositor* cmp, MaskMethod method, uint8_
if (glCmp->bbox.w > 0 && glCmp->bbox.h > 0) { if (glCmp->bbox.w > 0 && glCmp->bbox.h > 0) {
auto renderTarget = mComposePool[index]->getRenderTarget(glCmp->bbox); auto renderTarget = mComposePool[index]->getRenderTarget(glCmp->bbox);
mRenderPassStack.emplace_back(GlRenderPass(renderTarget)); mRenderPassStack.push(new GlRenderPass(renderTarget));
} else { } else {
// empty render pass // empty render pass
mRenderPassStack.emplace_back(GlRenderPass(nullptr)); mRenderPassStack.push(new GlRenderPass(nullptr));
} }
return true; return true;
@ -959,15 +915,17 @@ bool GlRenderer::beginComposite(RenderCompositor* cmp, MaskMethod method, uint8_
bool GlRenderer::endComposite(RenderCompositor* cmp) bool GlRenderer::endComposite(RenderCompositor* cmp)
{ {
if (mComposeStack.empty()) return false; if (mComposeStack.empty()) return false;
if (mComposeStack.back().get() != cmp) return false; if (mComposeStack.last() != cmp) return false;
// end current render pass; // end current render pass;
auto currCmp = std::move(mComposeStack.back()); auto curCmp = mComposeStack.last();
mComposeStack.pop_back(); mComposeStack.pop();
assert(cmp == currCmp.get()); assert(cmp == curCmp);
endRenderPass(currCmp.get()); endRenderPass(curCmp);
delete(curCmp);
return true; return true;
} }
@ -1020,7 +978,7 @@ bool GlRenderer::renderImage(void* data)
if ((sdata->updateFlag & RenderUpdateFlag::Image) == 0) return true; if ((sdata->updateFlag & RenderUpdateFlag::Image) == 0) return true;
auto vp = currentPass()->getViewport(); auto vp = currentPass()->getViewport();
auto bbox = sdata->geometry->getViewport(); auto bbox = sdata->geometry.getViewport();
bbox.intersect(vp); bbox.intersect(vp);
@ -1034,28 +992,28 @@ bool GlRenderer::renderImage(void* data)
if (!sdata->clips.empty()) drawClip(sdata->clips); if (!sdata->clips.empty()) drawClip(sdata->clips);
auto task = new GlRenderTask(mPrograms[RT_Image].get()); auto task = new GlRenderTask(mPrograms[RT_Image]);
task->setDrawDepth(drawDepth); task->setDrawDepth(drawDepth);
if (!sdata->geometry->draw(task, mGpuBuffer.get(), RenderUpdateFlag::Image)) { if (!sdata->geometry.draw(task, &mGpuBuffer, RenderUpdateFlag::Image)) {
delete task; delete task;
return true; return true;
} }
bool complexBlend = beginComplexBlending(bbox, sdata->geometry->getBounds()); bool complexBlend = beginComplexBlending(bbox, sdata->geometry.getBounds());
if (complexBlend) vp = currentPass()->getViewport(); if (complexBlend) vp = currentPass()->getViewport();
// matrix buffer // matrix buffer
const auto& matrix = sdata->geometry->getTransformMatrix(); const auto& matrix = sdata->geometry.getTransformMatrix();
float matrix44[16]; float matrix44[16];
currentPass()->getMatrix(matrix44, matrix); currentPass()->getMatrix(matrix44, matrix);
task->addBindResource(GlBindingResource{ task->addBindResource(GlBindingResource{
0, 0,
task->getProgram()->getUniformBlockIndex("Matrix"), task->getProgram()->getUniformBlockIndex("Matrix"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
mGpuBuffer->push(matrix44, 16 * sizeof(float), true), mGpuBuffer.push(matrix44, 16 * sizeof(float), true),
16 * sizeof(float), 16 * sizeof(float),
}); });
@ -1065,8 +1023,8 @@ bool GlRenderer::renderImage(void* data)
task->addBindResource(GlBindingResource{ task->addBindResource(GlBindingResource{
1, 1,
task->getProgram()->getUniformBlockIndex("ColorInfo"), task->getProgram()->getUniformBlockIndex("ColorInfo"),
mGpuBuffer->getBufferId(), mGpuBuffer.getBufferId(),
mGpuBuffer->push(info, 4 * sizeof(uint32_t), true), mGpuBuffer.push(info, 4 * sizeof(uint32_t), true),
4 * sizeof(uint32_t), 4 * sizeof(uint32_t),
}); });
@ -1078,9 +1036,9 @@ bool GlRenderer::renderImage(void* data)
currentPass()->addRenderTask(task); currentPass()->addRenderTask(task);
if (complexBlend) { if (complexBlend) {
auto task = new GlRenderTask(mPrograms[RT_Stencil].get()); auto task = new GlRenderTask(mPrograms[RT_Stencil]);
sdata->geometry->draw(task, mGpuBuffer.get(), RenderUpdateFlag::Image); sdata->geometry.draw(task, &mGpuBuffer, RenderUpdateFlag::Image);
endBlendingCompose(task, sdata->geometry->getTransformMatrix()); endBlendingCompose(task, sdata->geometry.getTransformMatrix());
} }
return true; return true;
@ -1097,7 +1055,7 @@ bool GlRenderer::renderShape(RenderData data)
const auto& vp = currentPass()->getViewport(); const auto& vp = currentPass()->getViewport();
auto bbox = sdata->geometry->getViewport(); auto bbox = sdata->geometry.getViewport();
bbox.intersect(vp); bbox.intersect(vp);
if (bbox.w <= 0 || bbox.h <= 0) return true; if (bbox.w <= 0 || bbox.h <= 0) return true;
@ -1187,13 +1145,13 @@ RenderData GlRenderer::prepare(RenderSurface* image, RenderData data, const Matr
sdata->opacity = opacity; sdata->opacity = opacity;
sdata->texColorSpace = image->cs; sdata->texColorSpace = image->cs;
sdata->texFlipY = 1; sdata->texFlipY = 1;
sdata->geometry = make_unique<GlGeometry>(); sdata->geometry = GlGeometry();
} }
sdata->geometry->updateTransform(transform); sdata->geometry.updateTransform(transform);
sdata->geometry->setViewport(mViewport); sdata->geometry.setViewport(mViewport);
sdata->geometry->tesselate(image, flags); sdata->geometry.tesselate(image, flags);
if (!clips.empty()) { if (!clips.empty()) {
sdata->clips.clear(); sdata->clips.clear();
@ -1220,7 +1178,7 @@ RenderData GlRenderer::prepare(const RenderShape& rshape, RenderData data, const
sdata->viewHt = static_cast<float>(surface.h); sdata->viewHt = static_cast<float>(surface.h);
sdata->updateFlag = RenderUpdateFlag::None; sdata->updateFlag = RenderUpdateFlag::None;
sdata->geometry = make_unique<GlGeometry>(); sdata->geometry = GlGeometry();
sdata->opacity = opacity; sdata->opacity = opacity;
//invisible? //invisible?
@ -1245,12 +1203,12 @@ RenderData GlRenderer::prepare(const RenderShape& rshape, RenderData data, const
if (sdata->updateFlag == RenderUpdateFlag::None) return sdata; if (sdata->updateFlag == RenderUpdateFlag::None) return sdata;
sdata->geometry->updateTransform(transform); sdata->geometry.updateTransform(transform);
sdata->geometry->setViewport(mViewport); sdata->geometry.setViewport(mViewport);
if (sdata->updateFlag & (RenderUpdateFlag::Color | RenderUpdateFlag::Stroke | RenderUpdateFlag::Gradient | RenderUpdateFlag::GradientStroke | RenderUpdateFlag::Transform | RenderUpdateFlag::Path)) if (sdata->updateFlag & (RenderUpdateFlag::Color | RenderUpdateFlag::Stroke | RenderUpdateFlag::Gradient | RenderUpdateFlag::GradientStroke | RenderUpdateFlag::Transform | RenderUpdateFlag::Path))
{ {
if (!sdata->geometry->tesselate(rshape, sdata->updateFlag)) return sdata; if (!sdata->geometry.tesselate(rshape, sdata->updateFlag)) return sdata;
} }
if (!clipper && !clips.empty()) { if (!clipper && !clips.empty()) {

25
src/renderer/gl_engine/tvgGlRenderer.h
View file

@ -23,8 +23,7 @@
#ifndef _TVG_GL_RENDERER_H_ #ifndef _TVG_GL_RENDERER_H_
#define _TVG_GL_RENDERER_H_ #define _TVG_GL_RENDERER_H_
#include <vector> #include "tvgArray.h"
#include "tvgGlRenderTarget.h" #include "tvgGlRenderTarget.h"
#include "tvgGlRenderTask.h" #include "tvgGlRenderTask.h"
#include "tvgGlGpuBuffer.h" #include "tvgGlGpuBuffer.h"
@ -113,29 +112,27 @@ private:
void prepareCmpTask(GlRenderTask* task, const RenderRegion& vp, uint32_t cmpWidth, uint32_t cmpHeight); void prepareCmpTask(GlRenderTask* task, const RenderRegion& vp, uint32_t cmpWidth, uint32_t cmpHeight);
void endRenderPass(RenderCompositor* cmp); void endRenderPass(RenderCompositor* cmp);
void clearDisposes(); void flush();
RenderSurface surface; RenderSurface surface;
GLint mTargetFboId = 0; GLint mTargetFboId = 0;
RenderRegion mViewport; RenderRegion mViewport;
//TODO: remove all unique_ptr / replace the vector with tvg::Array GlStageBuffer mGpuBuffer;
unique_ptr<GlStageBuffer> mGpuBuffer; GlRenderTarget mRootTarget;
vector<std::unique_ptr<GlProgram>> mPrograms; Array<GlProgram*> mPrograms;
unique_ptr<GlRenderTarget> mRootTarget = {}; Array<GlRenderTargetPool*> mComposePool;
Array<GlRenderTargetPool*> mComposePool = {}; Array<GlRenderTargetPool*> mBlendPool;
Array<GlRenderTargetPool*> mBlendPool = {}; Array<GlRenderPass*> mRenderPassStack;
vector<GlRenderPass> mRenderPassStack = {}; Array<GlCompositor*> mComposeStack;
vector<unique_ptr<GlCompositor>> mComposeStack = {};
//Disposed resources. They should be released on synced call. //Disposed resources. They should be released on synced call.
struct { struct {
Array<GLuint> textures = {}; Array<GLuint> textures;
Key key; Key key;
} mDisposed; } mDisposed;
bool mClearBuffer = true; //FIXME: clear buffer should be optional (default is false)
BlendMethod mBlendMethod = BlendMethod::Normal; BlendMethod mBlendMethod = BlendMethod::Normal;
bool mClearBuffer = true; //FIXME: clear buffer should be optional (default is false)
}; };
#endif /* _TVG_GL_RENDERER_H_ */ #endif /* _TVG_GL_RENDERER_H_ */

14
src/renderer/gl_engine/tvgGlShader.cpp
View file

@ -26,13 +26,6 @@
/* Internal Class Implementation */ /* Internal Class Implementation */
/************************************************************************/ /************************************************************************/
void GlShader::createShader(const char* vertSrc, const char* fragSrc)
{
mVtShader = compileShader(GL_VERTEX_SHADER, const_cast<char*>(vertSrc));
mFrShader = compileShader(GL_FRAGMENT_SHADER, const_cast<char*>(fragSrc));
}
uint32_t GlShader::compileShader(uint32_t type, char* shaderSrc) uint32_t GlShader::compileShader(uint32_t type, char* shaderSrc)
{ {
GLuint shader; GLuint shader;
@ -88,11 +81,10 @@ uint32_t GlShader::compileShader(uint32_t type, char* shaderSrc)
/* External Class Implementation */ /* External Class Implementation */
/************************************************************************/ /************************************************************************/
shared_ptr<GlShader> GlShader::gen(const char* vertSrc, const char* fragSrc) GlShader::GlShader(const char* vertSrc, const char* fragSrc)
{ {
shared_ptr<GlShader> shader = make_shared<GlShader>(); mVtShader = compileShader(GL_VERTEX_SHADER, const_cast<char*>(vertSrc));
shader->createShader(vertSrc, fragSrc); mFrShader = compileShader(GL_FRAGMENT_SHADER, const_cast<char*>(fragSrc));
return shader;
} }

3
src/renderer/gl_engine/tvgGlShader.h
View file

@ -28,14 +28,13 @@
class GlShader class GlShader
{ {
public: public:
static std::shared_ptr<GlShader> gen(const char* vertSrc, const char* fragSrc); GlShader(const char* vertSrc, const char* fragSrc);
~GlShader(); ~GlShader();
uint32_t getVertexShader(); uint32_t getVertexShader();
uint32_t getFragmentShader(); uint32_t getFragmentShader();
private: private:
void createShader(const char* vertSrc, const char* fragSrc);
uint32_t compileShader(uint32_t type, char* shaderSrc); uint32_t compileShader(uint32_t type, char* shaderSrc);
uint32_t mVtShader; uint32_t mVtShader;

24
src/renderer/gl_engine/tvgGlTessellator.cpp
View file

@ -20,15 +20,15 @@
* SOFTWARE. * SOFTWARE.
*/ */
#include "tvgMath.h"
#include "tvgGlTessellator.h"
#include "tvgRender.h"
#include "tvgGlList.h"
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
#include <cstdint> #include <cstdint>
#include "tvgGlCommon.h"
#include "tvgGlTessellator.h"
#include "tvgRender.h"
#include "tvgGlList.h"
namespace tvg namespace tvg
{ {
@ -845,6 +845,8 @@ Tessellator::~Tessellator()
for (uint32_t i = 0; i < outlines.count; i++) { for (uint32_t i = 0; i < outlines.count; i++) {
delete outlines[i]; delete outlines[i];
} }
delete pHeap;
delete pMesh; delete pMesh;
} }
@ -1146,11 +1148,11 @@ bool Tessellator::tessMesh()
if (v->edge_above.head) { if (v->edge_above.head) {
// add above edge first // add above edge first
if (leftPoly) { if (leftPoly) {
leftPoly = leftPoly->addEdge(v->edge_above.head, Side::kRight, pHeap.get()); leftPoly = leftPoly->addEdge(v->edge_above.head, Side::kRight, pHeap);
} }
if (rightPoly) { if (rightPoly) {
rightPoly = rightPoly->addEdge(v->edge_above.tail, Side::kLeft, pHeap.get()); rightPoly = rightPoly->addEdge(v->edge_above.tail, Side::kLeft, pHeap);
} }
// walk through all edges end with this vertex // walk through all edges end with this vertex
@ -1160,12 +1162,12 @@ bool Tessellator::tessMesh()
ael.remove(e); ael.remove(e);
if (e->rightPoly) { if (e->rightPoly) {
e->rightPoly->addEdge(right_edge, Side::kLeft, pHeap.get()); e->rightPoly->addEdge(right_edge, Side::kLeft, pHeap);
} }
// this means there is a new polygon between e and right_edge // this means there is a new polygon between e and right_edge
if (right_edge->leftPoly && right_edge->leftPoly != e->rightPoly) { if (right_edge->leftPoly && right_edge->leftPoly != e->rightPoly) {
right_edge->leftPoly->addEdge(e, Side::kRight, pHeap.get()); right_edge->leftPoly->addEdge(e, Side::kRight, pHeap);
} }
} }
@ -1212,8 +1214,8 @@ bool Tessellator::tessMesh()
// need to link this vertex to above polygon // need to link this vertex to above polygon
auto join = pHeap->allocate<Edge>(leftPoly->lastVertex(), v, 1); auto join = pHeap->allocate<Edge>(leftPoly->lastVertex(), v, 1);
leftPoly = leftPoly->addEdge(join, Side::kRight, pHeap.get()); leftPoly = leftPoly->addEdge(join, Side::kRight, pHeap);
rightPoly = rightPoly->addEdge(join, Side::kLeft, pHeap.get()); rightPoly = rightPoly->addEdge(join, Side::kLeft, pHeap);
} }
} }

5
src/renderer/gl_engine/tvgGlTessellator.h
View file

@ -24,8 +24,7 @@
#define _TVG_GL_TESSELLATOR_H_ #define _TVG_GL_TESSELLATOR_H_
#include <cstdint> #include <cstdint>
#include "tvgGlGeometry.h" #include "tvgGlCommon.h"
#include "tvgMath.h"
namespace tvg namespace tvg
{ {
@ -63,7 +62,7 @@ private:
void emitTriangle(Vertex* p1, Vertex* p2, Vertex* p3); void emitTriangle(Vertex* p1, Vertex* p2, Vertex* p3);
FillRule fillRule = FillRule::NonZero; FillRule fillRule = FillRule::NonZero;
std::unique_ptr<ObjectHeap> pHeap; ObjectHeap* pHeap;
Array<VertexList*> outlines; Array<VertexList*> outlines;
VertexList* pMesh; VertexList* pMesh;
Polygon* pPolygon; Polygon* pPolygon;