unbuffered ellipse shader: remove geometry shader

Author: einarf

arcade/context.py

@@ -159,7 +159,6 @@ def __init__(
         self.shape_ellipse_filled_unbuffered_program: Program = self.load_program(
             vertex_shader=":system:shaders/shapes/ellipse/filled_unbuffered_vs.glsl",
             fragment_shader=":system:shaders/shapes/ellipse/filled_unbuffered_fs.glsl",
-            geometry_shader=":system:shaders/shapes/ellipse/filled_unbuffered_geo.glsl",
         )
         self.shape_ellipse_outline_unbuffered_program: Program = self.load_program(
             vertex_shader=":system:shaders/shapes/ellipse/outline_unbuffered_vs.glsl",
@@ -258,11 +257,8 @@ def __init__(
             ],
             mode=self.TRIANGLE_STRIP,
         )
-        # ellipse/circle filled
-        self.shape_ellipse_unbuffered_buffer = self.buffer(reserve=8)
-        self.shape_ellipse_unbuffered_geometry: Geometry = self.geometry(
-            [BufferDescription(self.shape_ellipse_unbuffered_buffer, "2f", ["in_vert"])]
-        )
+        # ellipse/circle filled. Empty geometry. We generate it on the fly in the vertex shader.
+        self.shape_ellipse_unbuffered_geometry: Geometry = self.geometry()
         # ellipse/circle outline
         self.shape_ellipse_outline_unbuffered_buffer = self.buffer(reserve=8)
         self.shape_ellipse_outline_unbuffered_geometry: Geometry = self.geometry(

arcade/draw/circle.py

@@ -129,23 +129,31 @@ def draw_ellipse_filled(
     # Fail immediately if we have no window or context
     window = get_window()
     ctx = window.ctx
-    ctx.enable(ctx.BLEND)
 
     program = ctx.shape_ellipse_filled_unbuffered_program
     geometry = ctx.shape_ellipse_unbuffered_geometry
-    buffer = ctx.shape_ellipse_unbuffered_buffer  # type: ignore
 
     # Normalize the color because this shader takes a float uniform
     color_normalized = Color.from_iterable(color).normalized
 
+    # Auto select number of segments if not specified
+    if num_segments == -1:
+        size = max(width, height)
+        if size <= 12:
+            num_segments = 6
+        else:
+            num_segments = int(size) // 2
+
+    if num_segments < 3:
+        num_segments = 3
+
     # Pass data to the shader
+    program["center"] = center_x, center_y
     program["color"] = color_normalized
     program["shape"] = width / 2, height / 2, tilt_angle
     program["segments"] = num_segments
-    buffer.orphan()
-    buffer.write(data=array.array("f", (center_x, center_y)))
-
-    geometry.render(program, mode=gl.POINTS, vertices=1)
+    ctx.enable(ctx.BLEND)
+    geometry.render(program, mode=ctx.TRIANGLES, vertices=num_segments * 3)
     ctx.disable(ctx.BLEND)
 
 

arcade/resources/system/shaders/shapes/ellipse/filled_unbuffered_geo.glsl

@@ -1,7 +1,39 @@
 #version 330
 
+uniform WindowBlock {
+    mat4 projection;
+    mat4 view;
+} window;
+
+uniform vec2 center;
+uniform int segments;
+// [w, h, tilt]
+uniform vec3 shape;
+
 in vec2 in_vert;
 
+const float PI = 3.141592;
+
 void main() {
-    gl_Position = vec4(in_vert, 0.0, 1.0);
+    int triangle_id = gl_VertexID / 3;
+    int vertex_id = gl_VertexID % 3;
+
+    // Calculate rotation/tilt
+    float angle = radians(shape.z);
+    mat2 rot = mat2(
+        cos(angle), -sin(angle),
+        sin(angle),  cos(angle)
+    );
+    // Calculate the positions for the full triangle in the current segment
+    vec2 positions[3] = vec2[3](
+        vec2(0.0, 0.0),
+        vec2(sin((float(triangle_id) + 1.0) * (PI * 2.0 / float(segments))), 
+             cos((float(triangle_id) + 1.0) * (PI * 2.0 / float(segments)))) * shape.xy,
+        vec2(sin(float(triangle_id) * (PI * 2.0 / float(segments))), 
+             cos(float(triangle_id) * (PI * 2.0 / float(segments)))) * shape.xy
+    );
+
+    mat4 mvp = window.projection * window.view;
+    vec4 pos = vec4(rot * positions[vertex_id] + center, 0.0, 1.0);
+    gl_Position = mvp * pos;
 }