From 4645f5e72fe3ab5fc0443e21c29c7a3b7109016d Mon Sep 17 00:00:00 2001 From: deanlee Date: Tue, 27 May 2025 19:55:42 +0800 Subject: [PATCH] Add GPU-accelerated polygon rendering with anti-aliased edges and gradient support --- system/ui/lib/shader_polygon.py | 339 ++++++++++++++++++++++++++++++++ 1 file changed, 339 insertions(+) create mode 100644 system/ui/lib/shader_polygon.py diff --git a/system/ui/lib/shader_polygon.py b/system/ui/lib/shader_polygon.py new file mode 100644 index 0000000000..af633c5806 --- /dev/null +++ b/system/ui/lib/shader_polygon.py @@ -0,0 +1,339 @@ +import pyray as rl +from typing import Any + + +FRAGMENT_SHADER = """ +#version 300 es +precision mediump float; + +in vec2 fragTexCoord; +out vec4 finalColor; + +uniform vec2 points[100]; +uniform int pointCount; +uniform vec4 fillColor; +uniform vec2 resolution; + +uniform bool useGradient; +uniform vec2 gradientStart; +uniform vec2 gradientEnd; +uniform vec4 gradientColors[8]; +uniform float gradientStops[8]; +uniform int gradientColorCount; + +vec4 getGradientColor(vec2 pos) { + vec2 gradientDir = gradientEnd - gradientStart; + float gradientLength = length(gradientDir); + + if (gradientLength < 0.001) return gradientColors[0]; + + vec2 normalizedDir = gradientDir / gradientLength; + vec2 pointVec = pos - gradientStart; + float projection = dot(pointVec, normalizedDir); + float t = clamp(projection / gradientLength, 0.0, 1.0); + + for (int i = 0; i < gradientColorCount - 1; i++) { + if (t >= gradientStops[i] && t <= gradientStops[i+1]) { + float segmentT = (t - gradientStops[i]) / (gradientStops[i+1] - gradientStops[i]); + return mix(gradientColors[i], gradientColors[i+1], segmentT); + } + } + + return gradientColors[gradientColorCount-1]; +} + +float distanceToEdge(vec2 p) { + float minDist = 1000.0; + + for (int i = 0, j = pointCount - 1; i < pointCount; j = i++) { + vec2 edge0 = points[j]; + vec2 edge1 = points[i]; + + if (edge0 == edge1) continue; + + vec2 v1 = p - edge0; + vec2 v2 = edge1 - edge0; + float l2 = dot(v2, v2); + + if (l2 < 0.0001) { + float dist = length(v1); + minDist = min(minDist, dist); + continue; + } + + float t = max(0.0, min(1.0, dot(v1, v2) / l2)); + + vec2 projection = edge0 + t * v2; + + float dist = length(p - projection); + minDist = min(minDist, dist); + } + + return minDist; +} + +bool isPointInsidePolygon(vec2 p) { + if (pointCount < 3) return false; + + if (pointCount == 3) { + vec2 v0 = points[0]; + vec2 v1 = points[1]; + vec2 v2 = points[2]; + + float d = (v1.y - v2.y) * (v0.x - v2.x) + (v2.x - v1.x) * (v0.y - v2.y); + if (abs(d) < 0.0001) return false; + + float a = ((v1.y - v2.y) * (p.x - v2.x) + (v2.x - v1.x) * (p.y - v2.y)) / d; + float b = ((v2.y - v0.y) * (p.x - v2.x) + (v0.x - v2.x) * (p.y - v2.y)) / d; + float c = 1.0 - a - b; + + return (a >= 0.0 && b >= 0.0 && c >= 0.0); + } + + bool inside = false; + for (int i = 0, j = pointCount - 1; i < pointCount; j = i++) { + if (points[i] == points[j]) continue; + + float dy = points[j].y - points[i].y; + if (abs(dy) < 0.0001) continue; + + if (((points[i].y > p.y) != (points[j].y > p.y))) { + float x_intersect = points[i].x + (points[j].x - points[i].x) * (p.y - points[i].y) / dy; + if (p.x < x_intersect) { + inside = !inside; + } + } + } + return inside; +} + +void main() { + vec2 pixel = fragTexCoord * resolution; + + bool inside = isPointInsidePolygon(pixel); + + float dist = distanceToEdge(pixel); + + float aaWidth = 1.0; + + float alpha = inside ? + min(1.0, dist / aaWidth) : + max(0.0, 1.0 - dist / aaWidth); + + if (alpha > 0.0) { + vec4 color; + if (useGradient) { + color = getGradientColor(fragTexCoord); + } else { + color = fillColor; + } + + finalColor = vec4(color.rgb, color.a * alpha); + } else { + finalColor = vec4(0.0, 0.0, 0.0, 0.0); + } +} +""" + +# Default vertex shader +VERTEX_SHADER = """ +#version 300 es +in vec3 vertexPosition; +in vec2 vertexTexCoord; +out vec2 fragTexCoord; +uniform mat4 mvp; + +void main() { + fragTexCoord = vertexTexCoord; + gl_Position = mvp * vec4(vertexPosition, 1.0); +} +""" + + +class ShaderState: + _instance: Any = None + + @classmethod + def get_instance(cls): + if cls._instance is None: + cls._instance = cls() + return cls._instance + + def __init__(self): + if ShaderState._instance is not None: + raise Exception("This class is a singleton. Use get_instance() instead.") + + self.initialized = False + self.shader = None + self.white_texture = None + + # Shader uniform locations + self.locations = { + 'pointCount': None, + 'fillColor': None, + 'resolution': None, + 'points': None, + 'useGradient': None, + 'gradientStart': None, + 'gradientEnd': None, + 'gradientColors': None, + 'gradientStops': None, + 'gradientColorCount': None, + 'mvp': None, + } + + def initialize(self): + if self.initialized: + return + + vertex_shader = rl.load_shader_from_memory(VERTEX_SHADER, FRAGMENT_SHADER) + self.shader = vertex_shader + + # Create and cache white texture + white_img = rl.gen_image_color(2, 2, rl.WHITE) + self.white_texture = rl.load_texture_from_image(white_img) + rl.set_texture_filter(self.white_texture, rl.TEXTURE_FILTER_BILINEAR) + rl.unload_image(white_img) + + # Cache all uniform locations + for uniform in self.locations.keys(): + self.locations[uniform] = rl.get_shader_location(self.shader, uniform) + + # Setup default MVP matrix + mvp_ptr = rl.ffi.new("float[16]", [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]) + rl.set_shader_value_matrix(self.shader, self.locations['mvp'], rl.Matrix(*mvp_ptr)) + + self.initialized = True + + def cleanup(self): + if not self.initialized: + return + + if self.white_texture: + rl.unload_texture(self.white_texture) + self.white_texture = None + + if self.shader: + rl.unload_shader(self.shader) + self.shader = None + + self.initialized = False + + +def draw_polygon(points, color=None, gradient=None): + """ + Draw a complex polygon using shader-based even-odd fill rule + + Args: + points: List of (x,y) points defining the polygon + color: Solid fill color (rl.Color) + gradient: Dict with gradient parameters: + { + 'start': (x1, y1), # Start point (normalized 0-1) + 'end': (x2, y2), # End point (normalized 0-1) + 'colors': [rl.Color], # List of colors at stops + 'stops': [float] # List of positions (0-1) + } + """ + if len(points) < 3: + return + + # Get shader state singleton + state = ShaderState.get_instance() + + # Initialize shader if not already done + if not state.initialized: + state.initialize() + + # Find bounding box + min_x = min(p[0] for p in points) + max_x = max(p[0] for p in points) + min_y = min(p[1] for p in points) + max_y = max(p[1] for p in points) + + width = max(1, max_x - min_x) + height = max(1, max_y - min_y) + + # Transform points to shader space + transformed_points = [(p[0] - min_x, p[1] - min_y) for p in points] + + # Set basic shader uniforms using cached locations + point_count_ptr = rl.ffi.new("int[]", [len(transformed_points)]) + rl.set_shader_value(state.shader, state.locations['pointCount'], point_count_ptr, rl.SHADER_UNIFORM_INT) + + resolution_ptr = rl.ffi.new("float[]", [width, height]) + rl.set_shader_value(state.shader, state.locations['resolution'], resolution_ptr, rl.SHADER_UNIFORM_VEC2) + + # Set points + points_ptr = rl.ffi.new("float[]", len(transformed_points) * 2) + for i, p in enumerate(transformed_points): + points_ptr[i * 2] = float(p[0]) + points_ptr[i * 2 + 1] = float(p[1]) + rl.set_shader_value_v( + state.shader, state.locations['points'], points_ptr, rl.SHADER_UNIFORM_VEC2, len(transformed_points) + ) + + # Set gradient or solid color based on what was provided + if gradient: + # Enable gradient + use_gradient_ptr = rl.ffi.new("int[]", [1]) + rl.set_shader_value(state.shader, state.locations['useGradient'], use_gradient_ptr, rl.SHADER_UNIFORM_INT) + + # Set gradient start/end + start_ptr = rl.ffi.new("float[]", [gradient['start'][0], gradient['start'][1]]) + end_ptr = rl.ffi.new("float[]", [gradient['end'][0], gradient['end'][1]]) + rl.set_shader_value(state.shader, state.locations['gradientStart'], start_ptr, rl.SHADER_UNIFORM_VEC2) + rl.set_shader_value(state.shader, state.locations['gradientEnd'], end_ptr, rl.SHADER_UNIFORM_VEC2) + + # Set gradient colors + colors = gradient['colors'] + color_count = min(len(colors), 8) # Max 8 colors + colors_ptr = rl.ffi.new("float[]", color_count * 4) + for i, c in enumerate(colors[:color_count]): + colors_ptr[i * 4] = c.r / 255.0 + colors_ptr[i * 4 + 1] = c.g / 255.0 + colors_ptr[i * 4 + 2] = c.b / 255.0 + colors_ptr[i * 4 + 3] = c.a / 255.0 + rl.set_shader_value_v( + state.shader, state.locations['gradientColors'], colors_ptr, rl.SHADER_UNIFORM_VEC4, color_count + ) + + # Set gradient stops + stops = gradient.get('stops', [i / (color_count - 1) for i in range(color_count)]) + stops_ptr = rl.ffi.new("float[]", color_count) + for i, s in enumerate(stops[:color_count]): + stops_ptr[i] = s + rl.set_shader_value_v( + state.shader, state.locations['gradientStops'], stops_ptr, rl.SHADER_UNIFORM_FLOAT, color_count + ) + + # Set color count + color_count_ptr = rl.ffi.new("int[]", [color_count]) + rl.set_shader_value(state.shader, state.locations['gradientColorCount'], color_count_ptr, rl.SHADER_UNIFORM_INT) + else: + # Disable gradient + use_gradient_ptr = rl.ffi.new("int[]", [0]) + rl.set_shader_value(state.shader, state.locations['useGradient'], use_gradient_ptr, rl.SHADER_UNIFORM_INT) + + # Set solid color + if color is None: + color = rl.WHITE + fill_color_ptr = rl.ffi.new("float[]", [color.r / 255.0, color.g / 255.0, color.b / 255.0, color.a / 255.0]) + rl.set_shader_value(state.shader, state.locations['fillColor'], fill_color_ptr, rl.SHADER_UNIFORM_VEC4) + + # Draw with shader + rl.begin_shader_mode(state.shader) + rl.draw_texture_pro( + state.white_texture, + rl.Rectangle(0, 0, 2, 2), + rl.Rectangle(int(min_x), int(min_y), int(width), int(height)), + rl.Vector2(0, 0), + 0.0, + rl.WHITE, + ) + rl.end_shader_mode() + + +def cleanup_shader_resources(): + state = ShaderState.get_instance() + state.cleanup()