initial commit

shape.h

@@ -0,0 +1,169 @@
+#pragma once
+
+#include "diffvg.h"
+#include "color.h"
+#include "ptr.h"
+#include "vector.h"
+#include "matrix.h"
+
+enum class ShapeType {
+    Circle,
+    Ellipse,
+    Path,
+    Rect
+};
+
+struct Circle {
+    float radius;
+    Vector2f center;
+
+    ptr<void> get_ptr() {
+        return ptr<void>(this);
+    }
+};
+
+struct Ellipse {
+    Vector2f radius;
+    Vector2f center;
+
+    ptr<void> get_ptr() {
+        return ptr<void>(this);
+    }
+};
+
+struct Path {
+    Path(ptr<int> num_control_points,
+         ptr<float> points,
+         ptr<float> thickness,
+         int num_base_points,
+         int num_points,
+         bool is_closed,
+         bool use_distance_approx) :
+        num_control_points(num_control_points.get()),
+        points(points.get()),
+        thickness(thickness.get()),
+        num_base_points(num_base_points),
+        num_points(num_points),
+        is_closed(is_closed),
+        use_distance_approx(use_distance_approx) {}
+
+    int *num_control_points;
+    float *points;
+    float *thickness;
+    int num_base_points;
+    int num_points;
+    bool is_closed;
+    bool use_distance_approx;
+
+    bool has_thickness() const {
+        return thickness != nullptr;
+    }
+    void copy_to(ptr<float> points, ptr<float> thickness) const;
+
+    ptr<void> get_ptr() {
+        return ptr<void>(this);
+    }
+};
+
+struct Rect {
+    Vector2f p_min;
+    Vector2f p_max;
+
+    ptr<void> get_ptr() {
+        return ptr<void>(this);
+    }
+};
+
+struct Shape {
+    Shape() {}
+    Shape(const ShapeType &type,
+          ptr<void> shape_ptr,
+          float stroke_width)    
+        : type(type), ptr(shape_ptr.get()), stroke_width(stroke_width) {}
+
+    Circle as_circle() const {
+        return *(Circle*)ptr;
+    }
+
+    Ellipse as_ellipse() const {
+        return *(Ellipse*)ptr;
+    }
+
+    Path as_path() const {
+        return *(Path*)ptr;
+    }
+
+    Rect as_rect() const {
+        return *(Rect*)ptr;
+    }
+
+    ShapeType type;
+    void *ptr;
+    float stroke_width;
+};
+
+struct ShapeGroup {
+    ShapeGroup() {}
+    ShapeGroup(ptr<int> shape_ids,
+               int num_shapes,
+               const ColorType &fill_color_type,
+               ptr<void> fill_color,
+               const ColorType &stroke_color_type,
+               ptr<void> stroke_color,
+               bool use_even_odd_rule,
+               ptr<float> shape_to_canvas)
+        : shape_ids(shape_ids.get()),
+          num_shapes(num_shapes),
+          fill_color_type(fill_color_type),
+          fill_color(fill_color.get()),
+          stroke_color_type(stroke_color_type),
+          stroke_color(stroke_color.get()),
+          use_even_odd_rule(use_even_odd_rule),
+          shape_to_canvas(shape_to_canvas.get()) {
+        canvas_to_shape = inverse(this->shape_to_canvas);
+    }
+
+    bool has_fill_color() const {
+        return fill_color != nullptr;
+    }
+
+    Constant fill_color_as_constant() const {
+        return *(Constant*)fill_color;
+    }
+
+    LinearGradient fill_color_as_linear_gradient() const {
+        return *(LinearGradient*)fill_color;
+    }
+
+    RadialGradient fill_color_as_radial_gradient() const {
+        return *(RadialGradient*)fill_color;
+    }
+
+    bool has_stroke_color() const {
+        return stroke_color != nullptr;
+    }
+
+    Constant stroke_color_as_constant() const {
+        return *(Constant*)stroke_color;
+    }
+
+    LinearGradient stroke_color_as_linear_gradient() const {
+        return *(LinearGradient*)stroke_color;
+    }
+
+    RadialGradient stroke_color_as_radial_gradient() const {
+        return *(RadialGradient*)stroke_color;
+    }
+
+    void copy_to(ptr<float> shape_to_canvas) const;
+
+    int *shape_ids;
+    int num_shapes;
+    ColorType fill_color_type;
+    void *fill_color;
+    ColorType stroke_color_type;
+    void *stroke_color;
+    bool use_even_odd_rule;
+    Matrix3x3f canvas_to_shape;
+    Matrix3x3f shape_to_canvas;
+};