example/capi: chores++

This commit is contained in:
Hermet Park 2025-03-07 00:59:52 +09:00
parent c854a7207f
commit 57dd66de1b

View file

@ -37,202 +37,181 @@ static Tvg_Animation* animation = NULL;
void contents() void contents()
{ {
//////1. Linear gradient shape with a linear gradient stroke //Linear gradient shape with a linear gradient stroke
//Set a shape
Tvg_Paint* shape1 = tvg_shape_new();
tvg_shape_move_to(shape1, 25.0f, 25.0f);
tvg_shape_line_to(shape1, 375.0f, 25.0f);
tvg_shape_cubic_to(shape1, 500.0f, 100.0f, -500.0f, 200.0f, 375.0f, 375.0f);
tvg_shape_close(shape1);
//Prepare a gradient for the fill
Tvg_Gradient* grad1 = tvg_linear_gradient_new();
tvg_linear_gradient_set(grad1, 25.0f, 25.0f, 200.0f, 200.0f);
Tvg_Color_Stop color_stops1[4] =
{ {
{0.00f, 255, 0, 0, 155}, //Set a shape
{0.33f, 0, 255, 0, 100}, Tvg_Paint* shape1 = tvg_shape_new();
{0.66f, 255, 0, 255, 100}, tvg_shape_move_to(shape1, 25.0f, 25.0f);
{1.00f, 0, 0, 255, 155} tvg_shape_line_to(shape1, 375.0f, 25.0f);
}; tvg_shape_cubic_to(shape1, 500.0f, 100.0f, -500.0f, 200.0f, 375.0f, 375.0f);
tvg_gradient_set_color_stops(grad1, color_stops1, 4); tvg_shape_close(shape1);
tvg_gradient_set_spread(grad1, TVG_STROKE_FILL_REFLECT);
//Prepare a gradient for the stroke //Prepare a gradient for the fill
Tvg_Gradient* grad1_stroke = tvg_gradient_duplicate(grad1); Tvg_Gradient* grad = tvg_linear_gradient_new();
tvg_linear_gradient_set(grad, 25.0f, 25.0f, 200.0f, 200.0f);
Tvg_Color_Stop color_stops[4] = {{0.00f, 255, 0, 0, 155}, {0.33f, 0, 255, 0, 100}, {0.66f, 255, 0, 255, 100}, {1.00f, 0, 0, 255, 155}};
tvg_gradient_set_color_stops(grad, color_stops, 4);
tvg_gradient_set_spread(grad, TVG_STROKE_FILL_REFLECT);
//Set a gradient fill //Prepare a gradient for the stroke
tvg_shape_set_gradient(shape1, grad1); Tvg_Gradient* grad_stroke = tvg_gradient_duplicate(grad);
//Set a gradient stroke //Set a gradient fill
tvg_shape_set_stroke_width(shape1, 20.0f); tvg_shape_set_gradient(shape1, grad);
tvg_shape_set_stroke_gradient(shape1, grad1_stroke);
tvg_shape_set_stroke_join(shape1, TVG_STROKE_JOIN_ROUND);
//Set a gradient stroke
tvg_shape_set_stroke_width(shape1, 20.0f);
tvg_shape_set_stroke_gradient(shape1, grad_stroke);
tvg_shape_set_stroke_join(shape1, TVG_STROKE_JOIN_ROUND);
//////2. Solid transformed shape tvg_canvas_push(canvas, shape1);
//Set a shape }
const Tvg_Path_Command* cmds;
const Tvg_Point* pts;
uint32_t cmdCnt, ptsCnt;
tvg_shape_get_path(shape1, &cmds, &cmdCnt, &pts, &ptsCnt);
Tvg_Paint* shape2 = tvg_shape_new(); //Solid transformed shape
tvg_shape_append_path(shape2, cmds, cmdCnt, pts, ptsCnt);
tvg_shape_set_fill_color(shape2, 255, 255, 255, 128);
//Transform a shape
tvg_paint_scale(shape2, 0.3f);
tvg_paint_translate(shape2, 100.0f, 100.0f);
//Push shapes 1 and 2 into the canvas
tvg_canvas_push(canvas, shape1);
tvg_canvas_push(canvas, shape2);
//////3. Radial gradient shape with a radial dashed stroke
//Set a shape
Tvg_Paint* shape3 = tvg_shape_new();
tvg_shape_append_rect(shape3, 550.0f, 20.0f, 100.0f, 50.0f, 0.0f, 0.0f, true);
tvg_shape_append_circle(shape3, 600.0f, 150.0f, 100.0f, 50.0f, true);
tvg_shape_append_rect(shape3, 550.0f, 230.0f, 100.0f, 100.0f, 20.0f, 40.0f, true);
//Prepare a radial gradient for the fill
Tvg_Gradient* grad2 = tvg_radial_gradient_new();
tvg_radial_gradient_set(grad2, 600.0f, 180.0f, 50.0f, 640.0f, 180.0f, 0.0f);
Tvg_Color_Stop color_stops2[3] =
{ {
{0.0f, 255, 0, 255, 255}, //Set a shape
{0.5f, 0, 0, 255, 255}, Tvg_Paint* shape = tvg_shape_new();
{1.0f, 50, 55, 155, 255} tvg_shape_move_to(shape, 25.0f, 25.0f);
}; tvg_shape_line_to(shape, 375.0f, 25.0f);
tvg_gradient_set_color_stops(grad2, color_stops2, 3); tvg_shape_cubic_to(shape, 500.0f, 100.0f, -500.0f, 200.0f, 375.0f, 375.0f);
tvg_gradient_set_spread(grad2, TVG_STROKE_FILL_PAD); tvg_shape_close(shape);
tvg_shape_set_fill_color(shape, 255, 255, 255, 128);
//Set a gradient fill //Transform a shape
tvg_shape_set_gradient(shape3, grad2); tvg_paint_scale(shape, 0.3f);
tvg_paint_translate(shape, 100.0f, 100.0f);
//Prepare a radial gradient for the stroke tvg_canvas_push(canvas, shape);
uint32_t cnt; }
const Tvg_Color_Stop* color_stops2_get;
tvg_gradient_get_color_stops(grad2, &color_stops2_get, &cnt);
float cx, cy, r, fx, fy, fr;
tvg_radial_gradient_get(grad2, &cx, &cy, &r, &fx, &fy, &fr);
Tvg_Gradient* grad2_stroke = tvg_radial_gradient_new();
tvg_radial_gradient_set(grad2_stroke, cx, cy, r, fx, fy, fr);
tvg_gradient_set_color_stops(grad2_stroke, color_stops2_get, cnt);
tvg_gradient_set_spread(grad2_stroke, TVG_STROKE_FILL_REPEAT);
//Set a gradient stroke
tvg_shape_set_stroke_width(shape3, 30.0f);
tvg_shape_set_stroke_gradient(shape3, grad2_stroke);
tvg_paint_set_opacity(shape3, 200);
//Push the shape into the canvas
tvg_canvas_push(canvas, shape3);
//////4. Scene //Radial gradient shape with a radial dashed stroke
//Set a scene {
Tvg_Paint* scene = tvg_scene_new(); //Set a shape
Tvg_Paint* shape = tvg_shape_new();
tvg_shape_append_rect(shape, 550.0f, 20.0f, 100.0f, 50.0f, 0.0f, 0.0f, true);
tvg_shape_append_circle(shape, 600.0f, 150.0f, 100.0f, 50.0f, true);
tvg_shape_append_rect(shape, 550.0f, 230.0f, 100.0f, 100.0f, 20.0f, 40.0f, true);
//Set circles //Prepare a radial gradient for the fill
Tvg_Paint* scene_shape1 = tvg_shape_new(); Tvg_Gradient* grad = tvg_radial_gradient_new();
tvg_shape_append_circle(scene_shape1, 80.0f, 650.f, 40.0f, 140.0f, true); tvg_radial_gradient_set(grad, 600.0f, 180.0f, 50.0f, 640.0f, 180.0f, 0.0f);
tvg_shape_append_circle(scene_shape1, 180.0f, 600.f, 40.0f, 60.0f, true); Tvg_Color_Stop color_stops2[3] = {{0.0f, 255, 0, 255, 255}, {0.5f, 0, 0, 255, 255}, {1.0f, 50, 55, 155, 255}};
tvg_shape_set_fill_color(scene_shape1, 0, 0, 255, 150); tvg_gradient_set_color_stops(grad, color_stops2, 3);
tvg_shape_set_stroke_color(scene_shape1, 75, 25, 155, 255); tvg_gradient_set_spread(grad, TVG_STROKE_FILL_PAD);
tvg_shape_set_stroke_width(scene_shape1, 10.0f);
tvg_shape_set_stroke_cap(scene_shape1, Tvg_Stroke_Cap::TVG_STROKE_CAP_ROUND);
tvg_shape_set_stroke_join(scene_shape1, Tvg_Stroke_Join::TVG_STROKE_JOIN_ROUND);
tvg_shape_set_trimpath(scene_shape1, 0.25f, 0.75f, true);
//Set circles with a dashed stroke //Set a gradient fill
Tvg_Paint* scene_shape2 = tvg_paint_duplicate(scene_shape1); tvg_shape_set_gradient(shape, grad);
tvg_shape_set_fill_color(scene_shape2, 75, 25, 155, 200);
//Prapare a dash for the stroke //Prepare a radial gradient for the stroke
float dashPattern[4] = {15.0f, 30.0f, 2.0f, 30.0f}; uint32_t cnt;
tvg_shape_set_stroke_dash(scene_shape2, dashPattern, 4, 0.0f); const Tvg_Color_Stop* color_stops2_get;
tvg_shape_set_stroke_cap(scene_shape2, TVG_STROKE_CAP_ROUND); tvg_gradient_get_color_stops(grad, &color_stops2_get, &cnt);
tvg_shape_set_stroke_color(scene_shape2, 0, 0, 255, 255);
tvg_shape_set_stroke_width(scene_shape2, 15.0f);
//Transform a shape float cx, cy, r, fx, fy, fr;
tvg_paint_scale(scene_shape2, 0.8f); tvg_radial_gradient_get(grad, &cx, &cy, &r, &fx, &fy, &fr);
tvg_paint_rotate(scene_shape2, -90.0f);
tvg_paint_translate(scene_shape2, -200.0f, 800.0f);
//Push the shapes into the scene Tvg_Gradient* grad_stroke = tvg_radial_gradient_new();
tvg_scene_push(scene, scene_shape1); tvg_radial_gradient_set(grad_stroke, cx, cy, r, fx, fy, fr);
tvg_scene_push(scene, scene_shape2); tvg_gradient_set_color_stops(grad_stroke, color_stops2_get, cnt);
tvg_gradient_set_spread(grad_stroke, TVG_STROKE_FILL_REPEAT);
//Push the scene into the canvas //Set a gradient stroke
tvg_canvas_push(canvas, scene); tvg_shape_set_stroke_width(shape, 30.0f);
tvg_shape_set_stroke_gradient(shape, grad_stroke);
//////5. Masked picture tvg_paint_set_opacity(shape, 200);
//Set a scene
Tvg_Paint* pict = tvg_picture_new();
if (tvg_picture_load(pict, EXAMPLE_DIR"/svg/tiger.svg") != TVG_RESULT_SUCCESS) {
printf("Problem with loading an svg file\n");
tvg_paint_del(pict);
} else {
float w, h;
tvg_picture_get_size(pict, &w, &h);
tvg_picture_set_size(pict, w/2, h/2);
Tvg_Matrix m = {0.8f, 0.0f, 400.0f, 0.0f, 0.8f, 400.0f, 0.0f, 0.0f, 1.0f};
tvg_paint_set_transform(pict, &m);
// Set a composite shape //Push the shape into the canvas
Tvg_Paint* comp = tvg_shape_new(); tvg_canvas_push(canvas, shape);
tvg_shape_append_circle(comp, 600.0f, 600.0f, 100.0f, 100.0f, true); }
tvg_shape_set_fill_color(comp, 0, 0, 0, 200);
tvg_paint_set_mask_method(pict, comp, TVG_MASK_METHOD_INVERSE_ALPHA); //Scene
{
//Set a scene
Tvg_Paint* scene = tvg_scene_new();
//Set circles
Tvg_Paint* scene_shape1 = tvg_shape_new();
tvg_shape_append_circle(scene_shape1, 80.0f, 650.f, 40.0f, 140.0f, true);
tvg_shape_append_circle(scene_shape1, 180.0f, 600.f, 40.0f, 60.0f, true);
tvg_shape_set_fill_color(scene_shape1, 0, 0, 255, 150);
tvg_shape_set_stroke_color(scene_shape1, 75, 25, 155, 255);
tvg_shape_set_stroke_width(scene_shape1, 10.0f);
tvg_shape_set_stroke_cap(scene_shape1, Tvg_Stroke_Cap::TVG_STROKE_CAP_ROUND);
tvg_shape_set_stroke_join(scene_shape1, Tvg_Stroke_Join::TVG_STROKE_JOIN_ROUND);
tvg_shape_set_trimpath(scene_shape1, 0.25f, 0.75f, true);
//Set circles with a dashed stroke
Tvg_Paint* scene_shape2 = tvg_paint_duplicate(scene_shape1);
tvg_shape_set_fill_color(scene_shape2, 75, 25, 155, 200);
//Prapare a dash for the stroke
float dashPattern[4] = {15.0f, 30.0f, 2.0f, 30.0f};
tvg_shape_set_stroke_dash(scene_shape2, dashPattern, 4, 0.0f);
tvg_shape_set_stroke_cap(scene_shape2, TVG_STROKE_CAP_ROUND);
tvg_shape_set_stroke_color(scene_shape2, 0, 0, 255, 255);
tvg_shape_set_stroke_width(scene_shape2, 15.0f);
//Transform a shape
tvg_paint_scale(scene_shape2, 0.8f);
tvg_paint_rotate(scene_shape2, -90.0f);
tvg_paint_translate(scene_shape2, -200.0f, 800.0f);
//Push the shapes into the scene
tvg_scene_push(scene, scene_shape1);
tvg_scene_push(scene, scene_shape2);
//Push the scene into the canvas //Push the scene into the canvas
tvg_canvas_push(canvas, pict); tvg_canvas_push(canvas, scene);
} }
//////6. Animation with a picture //Masked picture
//instead loading from a memory, an animation can be loaded directly from a file using: {
//tvg_picture_load(pict_lottie, EXAMPLE_DIR"/lottie/sample.json") //Set a scene
FILE *file = fopen(EXAMPLE_DIR"/lottie/sample.json", "r"); Tvg_Paint* pict = tvg_picture_new();
if (file == NULL) return; if (tvg_picture_load(pict, EXAMPLE_DIR"/svg/tiger.svg") != TVG_RESULT_SUCCESS) {
fseek(file, 0, SEEK_END); printf("Problem with loading an svg file\n");
long data_size = ftell(file); tvg_paint_del(pict);
fseek(file, 0, SEEK_SET); } else {
auto data = (char*)malloc(data_size + 1); float w, h;
if (!data) return; tvg_picture_get_size(pict, &w, &h);
if (fread(data, 1, data_size, file) != (size_t)data_size) { tvg_picture_set_size(pict, w/2, h/2);
free(data); Tvg_Matrix m = {0.8f, 0.0f, 400.0f, 0.0f, 0.8f, 400.0f, 0.0f, 0.0f, 1.0f};
fclose(file); tvg_paint_set_transform(pict, &m);
return;
}
//ensure null-termination in case tvg_picture_load_data is called with copy = false
data[data_size++] = '\0';
animation = tvg_animation_new(); // Set a composite shape
Tvg_Paint* pict_lottie = tvg_animation_get_picture(animation); Tvg_Paint* comp = tvg_shape_new();
if (tvg_picture_load_data(pict_lottie, data, data_size, "lot", nullptr, false) != TVG_RESULT_SUCCESS) { tvg_shape_append_circle(comp, 600.0f, 600.0f, 100.0f, 100.0f, true);
printf("Problem with loading a lottie file\n"); tvg_shape_set_fill_color(comp, 0, 0, 0, 200);
tvg_animation_del(animation); tvg_paint_set_mask_method(pict, comp, TVG_MASK_METHOD_INVERSE_ALPHA);
} else {
tvg_paint_scale(pict_lottie, 3.0f); //Push the scene into the canvas
tvg_canvas_push(canvas, pict_lottie); tvg_canvas_push(canvas, pict);
}
} }
free(data); //Animation with a picture
fclose(file); {
animation = tvg_animation_new();
Tvg_Paint* pict_lottie = tvg_animation_get_picture(animation);
if (tvg_picture_load(pict_lottie, EXAMPLE_DIR"/lottie/sample.json") != TVG_RESULT_SUCCESS) {
printf("Problem with loading a lottie file\n");
tvg_animation_del(animation);
animation = NULL;
} else {
tvg_paint_scale(pict_lottie, 0.75f);
tvg_canvas_push(canvas, pict_lottie);
}
}
//Text 1
{
//load from a file
if (tvg_font_load(EXAMPLE_DIR"/font/SentyCloud.ttf") != TVG_RESULT_SUCCESS) {
printf("Problem with loading the font from the file. Did you enable TTF Loader?\n");
}
//////7. Text
//load from a file
if (tvg_font_load(EXAMPLE_DIR"/font/SentyCloud.ttf") != TVG_RESULT_SUCCESS) {
printf("Problem with loading the font from the file. Did you enable TTF Loader?\n");
} else {
Tvg_Paint *text = tvg_text_new(); Tvg_Paint *text = tvg_text_new();
tvg_text_set_font(text, "SentyCloud", 25.0f, ""); tvg_text_set_font(text, "SentyCloud", 25.0f, "");
tvg_text_set_fill_color(text, 0, 0, 255); tvg_text_set_fill_color(text, 0, 0, 255);
@ -240,30 +219,28 @@ void contents()
tvg_paint_translate(text, 50.0f, 380.0f); tvg_paint_translate(text, 50.0f, 380.0f);
tvg_canvas_push(canvas, text); tvg_canvas_push(canvas, text);
} }
//load from a memory
file = fopen(EXAMPLE_DIR"/font/SentyCloud.ttf", "rb"); //Text 2
if (file == NULL) return; {
fseek(file, 0, SEEK_END); //load from a memory
data_size = ftell(file); FILE* file = fopen(EXAMPLE_DIR"/font/Arial.ttf", "rb");
fseek(file, 0, SEEK_SET); if (file) {
data = (char*)malloc(data_size); fseek(file, 0, SEEK_END);
if (!data) return; size_t data_size = ftell(file);
if (fread(data, 1, data_size, file) != (size_t)data_size) { fseek(file, 0, SEEK_SET);
free(data); char* data = (char*)malloc(data_size);
fclose(file); if (fread(data, 1, data_size, file) == data_size) {
return; if (tvg_font_load_data("Arial", data, data_size, "ttf", true) != TVG_RESULT_SUCCESS) {
} printf("Problem with loading the font file from a memory. Did you enable TTF Loader?\n");
if (tvg_font_load_data("Arial", data, data_size, "ttf", true) != TVG_RESULT_SUCCESS) { }
printf("Problem with loading the font file from a memory. Did you enable TTF Loader?\n"); }
} else { free(data);
//Radial gradient fclose(file);
}
Tvg_Gradient* grad = tvg_radial_gradient_new(); Tvg_Gradient* grad = tvg_radial_gradient_new();
tvg_radial_gradient_set(grad, 200.0f, 200.0f, 20.0f, 200.0f, 200.0f, 0.0f); tvg_radial_gradient_set(grad, 200.0f, 200.0f, 20.0f, 200.0f, 200.0f, 0.0f);
Tvg_Color_Stop color_stops[2] = Tvg_Color_Stop color_stops[2] = {{0.0f, 255, 0, 255, 255}, {1.0f, 0, 0, 255, 255}};
{
{0.0f, 255, 0, 255, 255},
{1.0f, 0, 0, 255, 255}
};
tvg_gradient_set_color_stops(grad, color_stops, 2); tvg_gradient_set_color_stops(grad, color_stops, 2);
tvg_gradient_set_spread(grad, TVG_STROKE_FILL_REFLECT); tvg_gradient_set_spread(grad, TVG_STROKE_FILL_REFLECT);
@ -274,8 +251,6 @@ void contents()
tvg_paint_translate(text, 70.0f, 420.0f); tvg_paint_translate(text, 70.0f, 420.0f);
tvg_canvas_push(canvas, text); tvg_canvas_push(canvas, text);
} }
free(data);
fclose(file);
} }
@ -306,13 +281,19 @@ int main(int argc, char **argv)
contents(); contents();
//display the first frame
tvg_canvas_draw(canvas, true);
tvg_canvas_sync(canvas);
SDL_UpdateWindowSurface(window);
//app main loop!
SDL_Event event; SDL_Event event;
auto running = true; auto running = true;
auto ptime = SDL_GetTicks(); auto ptime = SDL_GetTicks();
auto elapsed = 0; auto elapsed = 0;
while (running) { while (running) {
//SDL Event handling //SDL event handling
while (SDL_PollEvent(&event)) { while (SDL_PollEvent(&event)) {
switch (event.type) { switch (event.type) {
case SDL_QUIT: { case SDL_QUIT: {
@ -328,7 +309,7 @@ int main(int argc, char **argv)
} }
} }
//Update the animation //update the animation
if (animation) { if (animation) {
float duration, totalFrame; float duration, totalFrame;
tvg_animation_get_duration(animation, &duration); tvg_animation_get_duration(animation, &duration);
@ -336,7 +317,7 @@ int main(int argc, char **argv)
tvg_animation_set_frame(animation, totalFrame * progress(elapsed, duration)); tvg_animation_set_frame(animation, totalFrame * progress(elapsed, duration));
} }
//Draw the canvas //draw the canvas
tvg_canvas_update(canvas); tvg_canvas_update(canvas);
tvg_canvas_draw(canvas, true); tvg_canvas_draw(canvas, true);
tvg_canvas_sync(canvas); tvg_canvas_sync(canvas);