git_clone/thorvg
1
0
Fork 0
mirror of https://github.com/thorvg/thorvg.git synced 2025-06-18 22:11:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 5
2459 commits 37 branches 105 tags 406 MiB
Commit graph

121 commits

Author SHA1 Message Date
Hermet Park
8cc8cf3b02 common: Move the list to the gl_engine side. 
Unfortunately, the usage of this list is not intuitive,
so can be confusing. Placed it only for gl.
 2024-01-02 20:34:10 +09:00
Hermet Park
1fbdf7bbb6 renderer, loader: minor code refactoring. 
- sync with its file name
- remove unnecessary section comments
- compact binary size (-300)
- private Task::run() methods from the loaders
 2024-01-02 20:34:10 +09:00
Sergii Liebodkin
51e98eebdb Add support for textures color space formats 
[Issues 1479: pictures](https://github.com/thorvg/thorvg/issues/1479)

Formats supported:
    ABGR8888
    ARGB8888
    ABGR8888S
    ARGB8888S
 2024-01-02 20:34:10 +09:00
Hermet Park
b8b8188879 sw_engine: fixed a bug where strokes were not showing. 
Basic shapes were trimmed entirely when they were outside of the canvas,
even if they had a big enough stroke to be partially on the canvas.

This fixes the issue.

Issue: https://github.com/thorvg/thorvg/issues/1785
 2024-01-02 20:34:10 +09:00
Sergii Liebodkin
c5b642e3e7 wg_engine: introduced images drawing support 
[issues 1479: pictures](https://github.com/thorvg/thorvg/issues/1479)

    auto picture = tvg::Picture::gen();
    picture->load("images/test.png");
    picture->translate(0, 0);
    picture->size(100, 100);
    picture->opacity(255);
    canvas->push(std::move(picture));
 2023-12-26 18:36:45 +09:00
Hermet Park
f58895a04a gl_engine/renderer: skip sync if nothing should be done. 
update by 66305f3e6d
 2023-12-26 18:33:33 +09:00
Hermet Park
27843d2557 savers: provides a background setting. 
Allow users to set a custom background with a saver.

API:
- Result Saver::background(std::unique_ptr<Paint> paint);
 2023-12-26 18:30:06 +09:00
Hermet Park
39022851b7 sw_engine: ++null safety 2023-12-26 18:23:54 +09:00
Hermet Park
042693ccfe renderer/loader: code refactoring 
Move the raw image loading interface to the RawImageLoader.
it is only valid for this component.
 2023-12-26 18:23:25 +09:00
Sergii Liebodkin
bad02c7de0 Added ability to draw solid strokes with dashes 
[issues 1479: Shape](https://github.com/thorvg/thorvg/issues/1479)

In order to build you need third party libraries. Before you start please read this: [LearnWebGPU](https://eliemichel.github.io/LearnWebGPU/getting-started/hello-webgpu.html)

Usage example:

    // init glfw
    glfwInit();

    // create a windowed mode window and its opengl context
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 800, "WebGPU base app", nullptr, nullptr);

    // get window size
    int width{}, height{};
    glfwGetWindowSize(window, &width, &height);

    // init engine webgpu
    tvg::Initializer::init(tvg::CanvasEngine::Wg, 0);

    // create wg canvas
    auto canvasWg = tvg::WgCanvas::gen();
    canvas_wg->target(glfwGetWin32Window(window), width, height);

    //Test for Stroke Dash for Arc, Circle, Rect
    auto shape = tvg::Shape::gen();
    shape->appendArc(70, 600, 160, 10, 30, true);
    shape->appendCircle(70, 700, 20, 60);
    shape->appendRect(130, 710, 100, 40);
    shape->strokeFill(255, 0, 0);
    shape->strokeWidth(5);
    shape->strokeJoin(tvg::StrokeJoin::Round);
    shape->strokeCap(tvg::StrokeCap::Round);
    float dashPattern[2] = {20, 10};
    shape->strokeDash(dashPattern, 2);
    if (canvas_wg->push(std::move(shape)) != tvg::Result::Success) return;

    while (!glfwWindowShouldClose(window)) {
        // webgpu
        canvas_wg->draw();
        canvas_wg->sync();

        // pull events
        glfwPollEvents();
    }

    // terminate engine and window
    tvg::Initializer::term(tvg::CanvasEngine::Wg);
    glfwDestroyWindow(window);
    glfwTerminate();
 2023-12-26 18:18:48 +09:00
Sergii Liebodkin
41ea198a5e Added ability to draw solid strokes 
[issues 1479: Shape](https://github.com/thorvg/thorvg/issues/1479)

In order to build you need third party libraries. Before you start please read this: [LearnWebGPU](https://eliemichel.github.io/LearnWebGPU/getting-started/hello-webgpu.html)

Usage example:

    // init glfw
    glfwInit();

    // create a windowed mode window and its opengl context
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 800, "WebGPU base app", nullptr, nullptr);

    // get window size
    int width{}, height{};
    glfwGetWindowSize(window, &width, &height);

    // init engine webgpu
    tvg::Initializer::init(tvg::CanvasEngine::Wg, 0);

    // create wg canvas
    auto canvasWg = tvg::WgCanvas::gen();
    canvas_wg->target(glfwGetWin32Window(window), width, height);

    //Test for Stroke Dash for Arc, Circle, Rect
    auto shape = tvg::Shape::gen();
    shape->appendArc(70, 600, 160, 10, 30, true);
    shape->appendCircle(70, 700, 20, 60);
    shape->appendRect(130, 710, 100, 40);
    shape->strokeFill(255, 0, 0);
    shape->strokeWidth(5);
    shape->strokeJoin(tvg::StrokeJoin::Round);
    shape->strokeCap(tvg::StrokeCap::Round);
    if (canvas_wg->push(std::move(shape)) != tvg::Result::Success) return;

    while (!glfwWindowShouldClose(window)) {
        // webgpu
        canvas_wg->draw();
        canvas_wg->sync();

        // pull events
        glfwPollEvents();
    }

    // terminate engine and window
    tvg::Initializer::term(tvg::CanvasEngine::Wg);
    glfwDestroyWindow(window);
    glfwTerminate();
 2023-12-26 18:18:42 +09:00
Hermet Park
875b623c95 binding/wasm: updated save features 
- removed the compression option
- added an animation save function.
 2023-12-26 18:17:41 +09:00
RuiwenTang
f3a155bce8 gl_engine: fix memory out of bounds error in GlGpuBuffer 
If buffer data is larger than memory alignment, need to make sure there
is enough memory in current stage buffer
 2023-12-26 18:17:41 +09:00
Hermet Park
b9504ca9c2 renderer: maintain consistency in the logging domain. 2023-12-26 18:17:41 +09:00
JunsuChoi
a20216045a saver GifSaver: Introduce GifSaver for animation 
Add save() API that takes tvg::Animation as a parameter.
This API uses gif.h to create each animation frame as a gif frame.
Gif creation do not support threads because they must be added sequentially.
Please see example/GifSaver.cpp

ex)
auto animation = tvg::Animation::gen();
auto picture = animation->picture();
picture->load(EXAMPLE_DIR"/walker.json");
auto saver = tvg::Saver::gen();
saver->save(std::move(animation), EXAMPLE_DIR"/test.gif");
saver->sync();

New API:
Result Saver::save(std::unique_ptr<Animation> animation, const std::string& path, uint32_t quality = 100, uint32_t fps = 0);

Issue: https://github.com/thorvg/thorvg/issues/1712
 2023-12-26 18:17:38 +09:00
Hermet Park
fba98c8cbf renderer: ++safety 
these member values can be accesssed without update() call.
 2023-12-26 18:06:07 +09:00
Hermet Park
37a01b8735 portability: addressed all compilation warnings from MSVC 2023-12-26 18:05:36 +09:00
Hermet Park
c8a8bb5af4 renderer/paint: added a blend update flag. 
Keep track of the update changes accurately.
We can utilize this value change in the backend engine.
 2023-12-26 18:05:22 +09:00
Hermet Park
c18643f9b6 renderer: revise the internal paints structure. 
Get rid of the polymorphism function table,
use the switch directly instead.

We profiled, both binary & performance is better than before.

Tested on a local machine (single thread):
- Lottie: 2ms improved
- Binary: -0.5kb
 2023-12-26 18:01:57 +09:00
Hermet Park
37fdfaf3d9 renderer/shape: enable returning count values only 2023-12-26 17:53:37 +09:00
Hermet Park
240d540091 canvas/paint: ++exception handling 
enhanced reference count verification
to prevent unintentional deletion of used composition targets.
 2023-12-26 17:53:25 +09:00
SergeyLebedkin
4f0fbc459c wg_engine: Added a feature to draw multiple radial gradient filled shapes 2023-12-26 17:51:59 +09:00
Hermet Park
0832a188fe animation/lottie: updated the frame count unit. 
replace the frame count unit from the int32_t to float
since animations could smoothly interpolate key-frames.

This notificably improve the animation smoothness in Lottie

Beta API changes:
Result Animation::frame(uint32_t no) -> Result Animation::frame(float no)
uint32_t Animation::curFrame() const -> float Animation::curFrame() const
uint32_t Animation::totalFrame() const -> float Animation::totalFrame() const
 2023-12-26 17:51:53 +09:00
RuiwenTang
2038818e16 gl_engine: use raw pointer to pass and hold GlRenderTask 2023-12-26 17:51:46 +09:00
Sergii Liebodkin
db1f171d2a wg_engine: Added ability to draw multiple linear gradient filled shapes 
[issues 1479: LinearGradient](thorvg#1479)

In order to build you need third party libraries. Before you start please read this: [LearnWebGPU](https://eliemichel.github.io/LearnWebGPU/getting-started/hello-webgpu.html)

Usage example:

    // init glfw
    glfwInit();

    // create a windowed mode window and its opengl context
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 800, "WebGPU base app", nullptr, nullptr);

    // get window size
    int width{}, height{};
    glfwGetWindowSize(window, &width, &height);

    // init engine webgpu
    tvg::Initializer::init(tvg::CanvasEngine::Wg, 0);

    // create wg canvas
    auto canvasWg = tvg::WgCanvas::gen();
    canvas_wg->target(glfwGetWin32Window(window), width, height);

    // gradient color stops
    tvg::Fill::ColorStop colorStops[2];
    colorStops[0] = {0, 0, 0, 0, 255};
    colorStops[1] = {1, 255, 255, 255, 255};
    // linear gradient
    auto fill = tvg::LinearGradient::gen();
    fill->linear(0, 0, 400, 400);
    fill->colorStops(colorStops, 2);
    // prepare rectangle
    auto shape1 = tvg::Shape::gen();
    shape1->appendRect(0, 0, 400, 400); //x, y, w, h
    shape1->fill(std::move(fill));
    canvas_wg->push(std::move(shape1));

    // gradient color stops
    tvg::Fill::ColorStop colorStops2[3];
    colorStops2[0] = { 0, 255, 0, 0, 255 };
    colorStops2[1] = { 0.5, 255, 255, 0, 255 };
    colorStops2[2] = { 1, 255, 255, 255, 255 };
    // linear gradient
    auto fill2 = tvg::LinearGradient::gen();
    fill2->linear(400, 200, 400, 600);
    fill2->colorStops(colorStops2, 3);
    // prepare circle
    auto shape2 = tvg::Shape::gen();
    shape2->appendCircle(400, 400, 200, 200); //cx, cy, radiusW, radiusH
    shape2->fill(std::move(fill2));
    canvas_wg->push(std::move(shape2));

    // gradient color stops
    tvg::Fill::ColorStop colorStops3[4];
    colorStops3[0] = { 0, 0, 127, 0, 127 };
    colorStops3[1] = { 0.25, 0, 170, 170, 170 };
    colorStops3[2] = { 0.5, 200, 0, 200, 200 };
    colorStops3[3] = { 1, 255, 255, 255, 255 };
    // linear gradient
    auto fill3 = tvg::LinearGradient::gen();
    fill3->linear(450, 600, 750, 600);
    fill3->colorStops(colorStops3, 4);
    // prepare ellipse
    auto shape3 = tvg::Shape::gen();
    shape3->appendCircle(600, 600, 150, 100); //cx, cy, radiusW, radiusH
    shape3->fill(std::move(fill3));
    canvas_wg->push(std::move(shape3));

    while (!glfwWindowShouldClose(window)) {
        // webgpu
        canvas_wg->draw();
        canvas_wg->sync();

        // pull events
        glfwPollEvents();
    }

    // terminate engine and window
    tvg::Initializer::term(tvg::CanvasEngine::Wg);
    glfwDestroyWindow(window);
    glfwTerminate();
 2023-12-26 17:51:39 +09:00
Hermet Park
97ac3194b4 sw_engine/raster: optimized the scaled image rasterization 
Unified common logic for scaled image raster operations,
Avoid on-spot pixel computation as possible.

Tested on local machine (single thread)

Lottie: 0.057s -> 0.053s (-0.004s)
 2023-12-26 17:51:23 +09:00
Sergii Liebodkin
938b69688d wg_engine: Added ability to draw multiple solid color filled shapes 
[issues 1479: Shape](https://github.com/thorvg/thorvg/issues/1479)

In order to build you need third party libraries. Before you start please read this: [LearnWebGPU](https://eliemichel.github.io/LearnWebGPU/getting-started/hello-webgpu.html)

Usage example:

    // init glfw
    glfwInit();

    // create a windowed mode window and its opengl context
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 800, "WebGPU base app", nullptr, nullptr);

    // get window size
    int width{}, height{};
    glfwGetWindowSize(window, &width, &height);

    // init engine webgpu
    tvg::Initializer::init(tvg::CanvasEngine::Wg, 0);

    // create wg canvas
    auto canvasWg = tvg::WgCanvas::gen();
    canvas_wg->target(glfwGetWin32Window(window), width, height);

    // prepare a shape (Rectangle + Rectangle + Circle + Circle)
    auto shape1 = tvg::Shape::gen();
    shape1->appendRect(0, 0, 200, 200);                //x, y, w, h
    shape1->appendRect(100, 100, 300, 300, 100, 100);  //x, y, w, h, rx, ry
    shape1->appendCircle(400, 400, 100, 100);          //cx, cy, radiusW, radiusH
    shape1->appendCircle(400, 500, 170, 100);          //cx, cy, radiusW, radiusH
    shape1->fill(255, 255, 0);                         //r, g, b

    canvas_wg->push(std::move(shape1));

    while (!glfwWindowShouldClose(window)) {
        // webgpu
        canvas_wg->draw();
        canvas_wg->sync();

        // pull events
        glfwPollEvents();
    }

    // terminate engine and window
    tvg::Initializer::term(tvg::CanvasEngine::Wg);
    glfwDestroyWindow(window);
    glfwTerminate();
 2023-12-26 17:51:17 +09:00
Hermet Park
9cbf300b8e sw_engine raster: fixed a default alpha blending bug. 
alpha value has been missed by a mistake,
a regression by c50d2fd

Issue: https://github.com/thorvg/thorvg/issues/1716
 2023-12-26 17:51:11 +09:00
Hermet Park
43f45ebd65 sw_engine/math: fine-tuning optimization 
Try to minimize the use of sqrt() and arctan() calls
when possible. These calls can be relatively expensive
when accumulated within a single frame.

Also repalce the division with shift operation.
since split cubic function is one of the significant hot-spots
in the data processing, we could earn a noticable enhancement.

Tested on single thread local machine:

Lottie: 0.080 -> 0.052s (-0.028s)
Performance: 0.023 -> 0.022 (-0.001s)
Binary: +34
 2023-12-26 17:51:04 +09:00
Hermet Park
6caf864064 gl_engine: fix a compiler warning. 
../src/renderer/gl_engine/tvgGlRenderPass.cpp:37:29: warning: macro expands to multiple statements [-Wmultistatement-macros]
   37 |     if (mColorTex) GL_CHECK(glDeleteTextures(1, &mColorTex));
 2023-12-26 17:50:58 +09:00
RuiwenTang
a46af19ccb gl_engine: support basic alpha composite 
* introduce a new class GlRenderPass to hold off-screen rendering result
* add basic alpha composite support with begin/end render-pass
 2023-12-26 17:50:50 +09:00
Hermet Park
81e3025ad9 sw_engine/math: Enhance trigonometric functions. 
Streamlining computations with floating-point operations in rotation
thereby improving 'thorvg' speed.

Also use the well-optimized posix math functions instead of
custom math.

Test on my local machine.

Lottie: -0.008s (0.073 -> 0.065)
Performance: -0.0013s (0.0154 -> 0.0141)
Binary: -323
 2023-12-26 17:50:43 +09:00
JunsuChoi
17fa8a7412 renderer/initializer: Support for initializing SW and GL engines together 
Initialize both renderers to allow init(SW | GL);
 2023-12-26 17:49:51 +09:00
SergeyLebedkin
35b03c826e wg_engine: introduce a webgpu canvas(engine) 
WebGPU is a Render Hardware Interface built on top of the various APIs 
provided by the driver/OS depending on your platform. 

WebGPU exposes an API for performing operations, 
such as rendering and computation, on a Graphics Processing Unit.

WebGPU official documentation: https://www.w3.org/TR/webgpu/

The new engine type introduced: tvg::CanvasEngine::Wg

The new canvas type introduced: tvg::WgCanvas

Example:
$meson setup build -Dengines=wg_beta

`
    // init engine webgpu
    tvg::Initializer::init(tvg::CanvasEngine::Wg, 0);

    // create wg canvas
    auto canvasWg = tvg::WgCanvas::gen();
    canvas_wg->target(glfwGetWin32Window(window), width, height);

    // ...

    // terminate engine and window
    tvg::Initializer::term(tvg::CanvasEngine::Wg);
`
Still this feature is under the beta

Issue: https://github.com/thorvg/thorvg/issues/1479
 2023-12-26 17:49:16 +09:00
RuiwenTang
49b7ea4679 gl_engine: support clip by using scissor and stencil 2023-12-26 17:48:41 +09:00
Hermet Park
0a9d98ccfd sw_engine/stroke: enhanced the quality of the dash line corners. 
Previously, the engine didn't properly cover the dash line corner styles
because it considered a new line to start at the corner.

This update modifies the logic to recognize curved lines
as a single line, including the corners.

There may still be some quality issues,
but it's an improvement over the previous version.

@Issue: https://github.com/thorvg/thorvg/issues/121
 2023-12-26 17:47:32 +09:00
RuiwenTang
d257835507 gl_engine: support render image 2023-12-26 17:45:18 +09:00
Hermet Park
12260198d1 release: bump up version v0.11.0 2023-09-28 08:30:34 +09:00
Hermet Park
5ecd3fb479 sw_engine: Correct the color conversion condition. 
The color conversion is supposed to take into account the differences between
straight alpha premultiplied color and pre-multiplied alpha color.

The previous logic does not perfectly cover these conditions.

The problem was occured in the thorvg viewer with a jpeg bgra format.
 2023-09-26 18:57:34 +09:00
Hermet Park
51c3a8912c sw_engine: fix an invalid memory access. 
the surface and mesh data can be missed by an invalid condition.
this fixes an invalid memory access problem.

Issue: https://github.com/thorvg/thorvg/issues/1671
 2023-09-26 17:41:08 +09:00
Hermet Park
e4ade98e8c sw_engine: fix a regression stroke bug 
reverted changes that occurred this issue from d683d2e

Issue: https://github.com/thorvg/thorvg/issues/1670
 2023-09-26 14:26:57 +09:00
Hermet Park
74b67919e0 tvg: support radial gradient focal properties 
properly store/restore the radial gradient focal properties
from the tvg loader and saver
 2023-09-26 13:05:27 +09:00
Hermet Park
ed23b432bb tvg: support dash offset property 
properly store/restore the dash offset property
from the tvg loader and saver

Issue: https://github.com/thorvg/thorvg/issues/1617
 2023-09-26 13:05:27 +09:00
Hermet Park
1819fed033 renderer/paint: fixed a mismatched reference count. 
This correction ensures a consistent use of 'ref' and 'unref' for paints to release memory properly.
The memory leak occurred when a picture was not pushed to a valid canvas.

This issue was reported by the unit-test memory sanitizer.
 2023-09-26 10:48:33 +09:00
RuiwenTang
453cba7ddd gl_engine: make GlRenderTask generic with uniform block 
* Use uniform block to pack all color informations
* Move the actual gl draw call into GlRenderer::sync function, so all
  data is been uploaded into GPU
* Make GlRenderTask simple and generic for direct gl draw
 2023-09-21 22:24:07 +09:00
Hermet Park
9e3b74bac5 sw_engine fill: fixed radial fill focal issue. 
This might be a workaround to correct the issue.
The threshold value comes from the mathematical inaccuracy.

@Issue:https://github.com/thorvg/thorvg/issues/1555
 2023-09-21 22:19:42 +09:00
Hermet Park
edb156f4fc sw_engine/shape: fix a dash-line infite-loop bug. 
a regresion bug was introduced by d683d2e70d
 2023-09-21 21:55:53 +09:00
Hermet Park
bd9d0cea6d sw_engine: properly implemented the missing image composition. 
The 8-bit masking target is the destination with a 32-bit source image and 8-bit composition.
 2023-09-20 18:42:06 +09:00
Martin Capitanio
5ed7034c45 sw_engine: fix VS 2017 issues with Godot's NOMINMAX 
Fixes #1661
 2023-09-19 21:51:54 +09:00
Hermet Park
8aa12ca468 taskschduler: fix a regression deadlock issue 
This fix introduces a workaround to enforce synchronous tasking on worker threads.
Sometimes, out of threads get stuck in a deadlock condition.

@Issue: https://github.com/thorvg/thorvg/issues/1636
 2023-09-18 21:06:01 +09:00