surface_pattern_t and gradient_pattern_t structs

4 files changed, 79 insertions, 98 deletions

diff --git a/src/vkvg_context.c b/src/vkvg_context.c
index 5a7c1eb..3445693 100644
--- a/src/vkvg_context.c
+++ b/src/vkvg_context.c
@@ -1070,7 +1070,7 @@ void vkvg_set_source_surface(VkvgContext ctx, VkvgSurface surf, float x, float y
 
     CmdBindDescriptorSets(ctx->cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, ctx->dev->pipelineLayout,
                           1, 1, &surf->dsSrc, 0, NULL);
-
+    //vkvg_surface_reference(surf);
 }
 void vkvg_set_source(VkvgContext ctx, VkvgPattern pat) {
     if (vkvg_status(ctx) || vkvg_pattern_status(pat))
diff --git a/src/vkvg_context_internal.c b/src/vkvg_context_internal.c
index 5488a6c..d9d9c75 100644
--- a/src/vkvg_context_internal.c
+++ b/src/vkvg_context_internal.c
@@ -790,9 +790,9 @@ void _update_cur_pattern(VkvgContext ctx, VkvgPattern pat) {
         ctx->pushConsts.source = bounds;
 
         // transform control point with current ctx matrix
-        vkvg_gradient_t grad = *(vkvg_gradient_t*)pat->data;
+        vkvg_gradient_t* grad = &((vkvg_gradient_pattern_t*)pat)->gradient;
 
-        if (grad.count < 2) {
+        if (grad->count < 2) {
             ctx->status = VKVG_STATUS_PATTERN_INVALID_GRADIENT;
             return;
         }
@@ -802,26 +802,26 @@ void _update_cur_pattern(VkvgContext ctx, VkvgPattern pat) {
             vkvg_pattern_get_matrix(pat, &mat);
             /*if (vkvg_matrix_invert(&mat) != VKVG_STATUS_SUCCESS)
                 mat = VKVG_IDENTITY_MATRIX;*/
-            vkvg_matrix_transform_point(&mat, &grad.cp[0].x, &grad.cp[0].y);
+            vkvg_matrix_transform_point(&mat, &grad->cp[0].x, &grad->cp[0].y);
         }
 
-        vkvg_matrix_transform_point(&ctx->pushConsts.mat, &grad.cp[0].x, &grad.cp[0].y);
+        vkvg_matrix_transform_point(&ctx->pushConsts.mat, &grad->cp[0].x, &grad->cp[0].y);
         if (pat->type == VKVG_PATTERN_TYPE_LINEAR) {
             if (pat->hasMatrix)
-                vkvg_matrix_transform_point(&mat, &grad.cp[0].z, &grad.cp[0].w);
-            vkvg_matrix_transform_point(&ctx->pushConsts.mat, &grad.cp[0].z, &grad.cp[0].w);
+                vkvg_matrix_transform_point(&mat, &grad->cp[0].z, &grad->cp[0].w);
+            vkvg_matrix_transform_point(&ctx->pushConsts.mat, &grad->cp[0].z, &grad->cp[0].w);
         } else {
             if (pat->hasMatrix)
-                vkvg_matrix_transform_point(&mat, &grad.cp[1].x, &grad.cp[1].y);
-            vkvg_matrix_transform_point(&ctx->pushConsts.mat, &grad.cp[1].x, &grad.cp[1].y);
+                vkvg_matrix_transform_point(&mat, &grad->cp[1].x, &grad->cp[1].y);
+            vkvg_matrix_transform_point(&ctx->pushConsts.mat, &grad->cp[1].x, &grad->cp[1].y);
 
             // radii
             if (pat->hasMatrix) {
-                vkvg_matrix_transform_distance(&mat, &grad.cp[0].z, &grad.cp[0].w);
-                vkvg_matrix_transform_distance(&mat, &grad.cp[1].z, &grad.cp[0].w);
+                vkvg_matrix_transform_distance(&mat, &grad->cp[0].z, &grad->cp[0].w);
+                vkvg_matrix_transform_distance(&mat, &grad->cp[1].z, &grad->cp[0].w);
             }
-            vkvg_matrix_transform_distance(&ctx->pushConsts.mat, &grad.cp[0].z, &grad.cp[0].w);
-            vkvg_matrix_transform_distance(&ctx->pushConsts.mat, &grad.cp[1].z, &grad.cp[0].w);
+            vkvg_matrix_transform_distance(&ctx->pushConsts.mat, &grad->cp[0].z, &grad->cp[0].w);
+            vkvg_matrix_transform_distance(&ctx->pushConsts.mat, &grad->cp[1].z, &grad->cp[0].w);
         }
 
         memcpy(vkh_buffer_get_mapped_pointer(&ctx->uboGrad), &grad, sizeof(vkvg_gradient_t));
diff --git a/src/vkvg_pattern.c b/src/vkvg_pattern.c
index 1781689..a2a28d4 100644
--- a/src/vkvg_pattern.c
+++ b/src/vkvg_pattern.c
@@ -18,29 +18,67 @@ VkvgPattern vkvg_pattern_create_for_surface(VkvgSurface surf) {
     if (!surf) {
         return (VkvgPattern)&_vkvg_status_null_pointer;
     }
-    VkvgPattern pat = (vkvg_pattern_t*)calloc(1, sizeof(vkvg_pattern_t));
+    vkvg_surface_pattern_t* pat = (vkvg_surface_pattern_t*)calloc(1, sizeof(vkvg_surface_pattern_t));
     if (!pat) {
         return (VkvgPattern)&_vkvg_status_no_memory;
     }
 
-    pat->type       = VKVG_PATTERN_TYPE_SURFACE;
-    pat->extend     = VKVG_EXTEND_NONE;
-    pat->data       = surf;
-    atomic_init(&pat->references, 1);
+    pat->base.type      = VKVG_PATTERN_TYPE_SURFACE;
+    pat->base.extend    = VKVG_EXTEND_NONE;
+    pat->surf           = surf;
+    atomic_init(&pat->base.references, 1);
 
     vkvg_surface_reference(surf);
     if (vkvg_surface_status(surf))
-        pat->status = VKVG_STATUS_INVALID_SURFACE;
+        pat->base.status = VKVG_STATUS_INVALID_SURFACE;
+
+    return (VkvgPattern)pat;
+}
+VkvgPattern vkvg_pattern_create_linear(float x0, float y0, float x1, float y1) {
+    vkvg_gradient_pattern_t* pat = (vkvg_gradient_pattern_t*)calloc(1, sizeof(vkvg_gradient_pattern_t));
+    if (!pat) {
+        return (VkvgPattern)&_vkvg_status_no_memory;
+    }
+    pat->base.type   = VKVG_PATTERN_TYPE_LINEAR;
+    pat->base.extend = VKVG_EXTEND_NONE;
+
+    pat->gradient.cp[0] = (vec4){{x0}, {y0}, {x1}, {y1}};
+
+    atomic_init(&pat->base.references, 1);
+
+    return (VkvgPattern)pat;
+}
+VkvgPattern vkvg_pattern_create_radial(float cx0, float cy0, float radius0, float cx1, float cy1, float radius1) {
+    vkvg_gradient_pattern_t* pat = (vkvg_gradient_pattern_t*)calloc(1, sizeof(vkvg_gradient_pattern_t));
+    if (!pat) {
+        return (VkvgPattern)&_vkvg_status_no_memory;
+    }
+    pat->base.type   = VKVG_PATTERN_TYPE_RADIAL;
+    pat->base.extend = VKVG_EXTEND_NONE;
+
+    vkvg_pattern_edit_radial((VkvgPattern)pat, cx0, cy0, radius0, cx1, cy1, radius1);
+    atomic_init(&pat->base.references, 1);
 
+    return (VkvgPattern)pat;
+}
+VkvgPattern vkvg_pattern_reference(VkvgPattern pat) {
+    if (!vkvg_pattern_status(pat))
+        atomic_fetch_add_explicit(&pat->references, 1, memory_order_relaxed);
     return pat;
 }
+uint32_t vkvg_pattern_get_reference_count(VkvgPattern pat) {
+    if (vkvg_pattern_status(pat))
+        return 0;
+    return atomic_load_explicit(&pat->references, memory_order_relaxed);
+}
+
 vkvg_status_t vkvg_pattern_get_linear_points(VkvgPattern pat, float* x0, float* y0, float* x1, float* y1) {
     if (vkvg_pattern_status(pat))
         return vkvg_pattern_status(pat);
     if (pat->type != VKVG_PATTERN_TYPE_LINEAR)
         return VKVG_STATUS_PATTERN_TYPE_MISMATCH;
 
-    vkvg_gradient_t* grad = (vkvg_gradient_t*)pat->data;
+    vkvg_gradient_t* grad = &((vkvg_gradient_pattern_t*)pat)->gradient;
 
     *x0 = grad->cp[0].x;
     *y0 = grad->cp[0].y;
@@ -54,30 +92,12 @@ vkvg_status_t vkvg_pattern_edit_linear(VkvgPattern pat, float x0, float y0, floa
     if (pat->type != VKVG_PATTERN_TYPE_LINEAR)
         return VKVG_STATUS_PATTERN_TYPE_MISMATCH;
 
-    vkvg_gradient_t* grad = (vkvg_gradient_t*)pat->data;
 
+    vkvg_gradient_t* grad = &((vkvg_gradient_pattern_t*)pat)->gradient;
     grad->cp[0] = (vec4){{x0}, {y0}, {x1}, {y1}};
     return VKVG_STATUS_SUCCESS;
 }
-VkvgPattern vkvg_pattern_create_linear(float x0, float y0, float x1, float y1) {
-    VkvgPattern pat = (vkvg_pattern_t*)calloc(1, sizeof(vkvg_pattern_t));
-    if (!pat) {
-        return (VkvgPattern)&_vkvg_status_no_memory;
-    }
-    pat->type   = VKVG_PATTERN_TYPE_LINEAR;
-    pat->extend = VKVG_EXTEND_NONE;
-
-    pat->data = (void*)calloc(1, sizeof(vkvg_gradient_t));
 
-    if (pat->data) {
-        vkvg_pattern_edit_linear(pat, x0, y0, x1, y1);
-        atomic_init(&pat->references, 1);
-    } else {
-        pat->status = VKVG_STATUS_PATTERN_INVALID_GRADIENT;
-    }
-
-    return pat;
-}
 vkvg_status_t vkvg_pattern_edit_radial(VkvgPattern pat, float cx0, float cy0, float radius0, float cx1, float cy1,
                                        float radius1) {
     if (vkvg_pattern_status(pat))
@@ -85,7 +105,7 @@ vkvg_status_t vkvg_pattern_edit_radial(VkvgPattern pat, float cx0, float cy0, fl
     if (pat->type != VKVG_PATTERN_TYPE_RADIAL)
         return VKVG_STATUS_PATTERN_TYPE_MISMATCH;
 
-    vkvg_gradient_t* grad = (vkvg_gradient_t*)pat->data;
+    vkvg_gradient_t* grad = &((vkvg_gradient_pattern_t*)pat)->gradient;
 
     vec2 c0 = {cx0, cy0};
     vec2 c1 = {cx1, cy1};
@@ -102,45 +122,17 @@ vkvg_status_t vkvg_pattern_edit_radial(VkvgPattern pat, float cx0, float cy0, fl
     grad->cp[0] = (vec4){{c0.x}, {c0.y}, {radius0}, {0}};
     grad->cp[1] = (vec4){{c1.x}, {c1.y}, {radius1}, {0}};
 
-    LOG(VKVG_LOG_INFO, "vkvg_pattern_edit_radial: %p data: %p status: %d\n", pat, pat->data, pat->status);
+    LOG(VKVG_LOG_INFO, "vkvg_pattern_edit_radial: %p status: %d\n", pat, pat->status);
 
     return VKVG_STATUS_SUCCESS;
 }
-VkvgPattern vkvg_pattern_create_radial(float cx0, float cy0, float radius0, float cx1, float cy1, float radius1) {
-    VkvgPattern pat = (vkvg_pattern_t*)calloc(1, sizeof(vkvg_pattern_t));
-    if (!pat) {
-        return (VkvgPattern)&_vkvg_status_no_memory;
-    }
-    pat->type   = VKVG_PATTERN_TYPE_RADIAL;
-    pat->extend = VKVG_EXTEND_NONE;
-
-    pat->data = (void*)calloc(1, sizeof(vkvg_gradient_t));
-
-    if (pat->data) {
-        vkvg_pattern_edit_radial(pat, cx0, cy0, radius0, cx1, cy1, radius1);
-        atomic_init(&pat->references, 1);
-    } else
-        pat->status = VKVG_STATUS_NO_MEMORY;
-
-    return pat;
-}
-VkvgPattern vkvg_pattern_reference(VkvgPattern pat) {
-    if (!vkvg_pattern_status(pat))
-        atomic_fetch_add_explicit(&pat->references, 1, memory_order_relaxed);
-    return pat;
-}
-uint32_t vkvg_pattern_get_reference_count(VkvgPattern pat) {
-    if (vkvg_pattern_status(pat))
-        return 0;
-    return atomic_load_explicit(&pat->references, memory_order_relaxed);
-}
 vkvg_status_t vkvg_pattern_add_color_stop(VkvgPattern pat, float offset, float r, float g, float b, float a) {
     if (vkvg_pattern_status(pat))
         return vkvg_pattern_status(pat);
     if (pat->type == VKVG_PATTERN_TYPE_SURFACE || pat->type == VKVG_PATTERN_TYPE_SOLID)
         return VKVG_STATUS_PATTERN_TYPE_MISMATCH;
 
-    vkvg_gradient_t* grad = (vkvg_gradient_t*)pat->data;
+    vkvg_gradient_t* grad = &((vkvg_gradient_pattern_t*)pat)->gradient;
 #ifdef VKVG_PREMULT_ALPHA
     vkvg_color_t c = {a * r, a * g, a * b, a};
 #else
@@ -186,7 +178,7 @@ vkvg_status_t vkvg_pattern_get_color_stop_count(VkvgPattern pat, uint32_t* count
         return vkvg_pattern_status(pat);
     if (pat->type == VKVG_PATTERN_TYPE_SURFACE || pat->type == VKVG_PATTERN_TYPE_SOLID)
         return VKVG_STATUS_PATTERN_TYPE_MISMATCH;
-    vkvg_gradient_t* grad = (vkvg_gradient_t*)pat->data;
+    vkvg_gradient_t* grad = &((vkvg_gradient_pattern_t*)pat)->gradient;
     *count                = grad->count;
     return VKVG_STATUS_SUCCESS;
 }
@@ -196,7 +188,7 @@ vkvg_status_t vkvg_pattern_get_color_stop_rgba(VkvgPattern pat, uint32_t index,
         return vkvg_pattern_status(pat);
     if (pat->type == VKVG_PATTERN_TYPE_SURFACE || pat->type == VKVG_PATTERN_TYPE_SOLID)
         return VKVG_STATUS_PATTERN_TYPE_MISMATCH;
-    vkvg_gradient_t* grad = (vkvg_gradient_t*)pat->data;
+    vkvg_gradient_t* grad = &((vkvg_gradient_pattern_t*)pat)->gradient;
     if (index >= grad->count)
         return VKVG_STATUS_INVALID_INDEX;
 #ifdef VKVG_ENABLE_VK_SCALAR_BLOCK_LAYOUT
@@ -236,10 +228,8 @@ void vkvg_pattern_destroy(VkvgPattern pat) {
         return;
 
     if (pat->type == VKVG_PATTERN_TYPE_SURFACE) {
-        VkvgSurface surf = (VkvgSurface)pat->data;
-        vkvg_surface_destroy(surf);
-    } else// if (pat->type != VKVG_PATTERN_TYPE_SOLID)
-        free(pat->data);
+        vkvg_surface_destroy(((vkvg_surface_pattern_t*)pat)->surf);
+    }
 
     free(pat);
     pat = NULL;
diff --git a/src/vkvg_pattern.h b/src/vkvg_pattern.h
index 1c1975e..eb89a7f 100644
--- a/src/vkvg_pattern.h
+++ b/src/vkvg_pattern.h
@@ -1,24 +1,6 @@
-/*
- * Copyright (c) 2018-2022 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
- *
- * 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.
- */
+// Copyright (c) 2018-2026 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 #ifndef VKVG_PATTERN_H
 #define VKVG_PATTERN_H
 
@@ -32,9 +14,13 @@ typedef struct _vkvg_pattern_t {
     vkvg_filter_t       filter;
     vkvg_matrix_t       matrix;
     bool                hasMatrix;
-    void*               data;
 } vkvg_pattern_t;
 
+typedef struct _vkvg_surface_pattern_t {
+    vkvg_pattern_t      base;
+    VkvgSurface         surf;
+} vkvg_surface_pattern_t;
+
 typedef struct _vkvg_gradient_t {
     vkvg_color_t colors[16];
 #ifdef VKVG_ENABLE_VK_SCALAR_BLOCK_LAYOUT
@@ -46,4 +32,9 @@ typedef struct _vkvg_gradient_t {
     uint32_t count;
 } vkvg_gradient_t;
 
+typedef struct _vkvg_gradient_pattern_t {
+    vkvg_pattern_t      base;
+    vkvg_gradient_t     gradient;
+} vkvg_gradient_pattern_t;
+
 #endif