[orx-mesh-generators] Add Segment and ShapeContour based generators

Author: hamoid

orx-mesh-generators/src/demo/kotlin/DemoCurve01.kt

@@ -0,0 +1,38 @@
+import org.openrndr.application
+import org.openrndr.color.ColorRGBa
+import org.openrndr.draw.DrawPrimitive
+import org.openrndr.extra.meshgenerators.toMesh
+import org.openrndr.math.Vector2
+import org.openrndr.shape.Segment
+
+/**
+ * Demonstrates how to convert a [Segment] into a
+ * vertex buffer to be drawn as a TRIANGLE_STRIP
+ * of constant width.
+ */
+fun main() = application {
+    program {
+        // Segments can have 2, 3 or 4 vertices
+        val seg = Segment(
+            Vector2(100.0, 100.0),
+            Vector2(width - 100.0, 100.0),
+            Vector2(100.0, height - 100.0),
+            Vector2(width - 100.0, height - 100.0)
+        )
+        val geometry = seg.toMesh(20) { 10.0 }
+
+        extend {
+            drawer.clear(ColorRGBa.PINK)
+
+            // Visualize the texture coordinates.
+            // They can be used to map a texture into the mesh.
+            //drawer.shadeStyle = shadeStyle {
+            //    fragmentTransform = """
+            //        x_fill.rg = va_texCoord0;
+            //    """.trimIndent()
+            //}
+
+            drawer.vertexBuffer(geometry, DrawPrimitive.TRIANGLE_STRIP)
+        }
+    }
+}

orx-mesh-generators/src/demo/kotlin/DemoCurve02.kt

@@ -0,0 +1,44 @@
+import org.openrndr.application
+import org.openrndr.color.ColorRGBa
+import org.openrndr.draw.DrawPrimitive
+import org.openrndr.extra.meshgenerators.toMesh
+import org.openrndr.extra.shapes.hobbyCurve
+import org.openrndr.math.Polar
+import org.openrndr.shape.ShapeContour
+import kotlin.math.PI
+import kotlin.math.cos
+
+/**
+ * Demonstrates how to convert a [ShapeContour] into a
+ * vertex buffer to be drawn as a TRIANGLE_STRIP.
+ * Uses a cosine wave to specify the thickness.
+ */
+fun main() = application {
+    program {
+        val contour = ShapeContour.fromPoints(
+            List(10) {
+                Polar(
+                    it * 36.0,
+                    120.0 + (it % 2) * 80.0
+                ).cartesian + drawer.bounds.center
+            }, true
+        ).hobbyCurve()
+
+        val geometry = contour.toMesh(100) { t ->
+            15.0 + 10.0 * cos(t * PI * 6)
+        }
+        extend {
+            drawer.clear(ColorRGBa.PINK)
+
+            // Visualize the texture coordinates
+            // They can be used to map a texture into the mesh.
+            //drawer.shadeStyle = shadeStyle {
+            //    fragmentTransform = """
+            //        x_fill.rg = va_texCoord0;
+            //    """.trimIndent()
+            //}
+
+            drawer.vertexBuffer(geometry, DrawPrimitive.TRIANGLE_STRIP)
+        }
+    }
+}

orx-mesh-generators/src/demo/kotlin/DemoCurve03.kt

@@ -0,0 +1,37 @@
+import org.openrndr.application
+import org.openrndr.color.ColorRGBa
+import org.openrndr.draw.DrawPrimitive
+import org.openrndr.draw.shadeStyle
+import org.openrndr.extra.meshgenerators.toMesh
+import org.openrndr.shape.Circle
+import org.openrndr.shape.Rectangle
+import org.openrndr.shape.ShapeContour
+
+/**
+ * Demonstrates how to convert shapes like a [Rectangle] and a [Circle]
+ * into a vertex buffer to be drawn as a TRIANGLE_STRIP mesh.
+ * Meshes can be drawn in 3D and deformed with vertex shaders.
+ */
+fun main() = application {
+    program {
+        val rect = Rectangle.fromCenter(drawer.bounds.center, 350.0).contour
+        val cir = Circle(drawer.bounds.center, 130.0).contour
+
+        val rectMesh = rect.toMesh(100) { 20.0 }
+        val cirMesh = cir.toMesh(100) { 10.0 }
+        extend {
+            drawer.clear(ColorRGBa.PINK)
+
+            // Uses the texture coordinates to create an animated pattern
+            drawer.shadeStyle = shadeStyle {
+                fragmentTransform = """
+                    x_fill.a = step(0.5, fract(va_texCoord0.x * 10.0 + p_seconds));
+                """.trimIndent()
+                parameter("seconds", seconds)
+            }
+
+            drawer.vertexBuffer(rectMesh, DrawPrimitive.TRIANGLE_STRIP)
+            drawer.vertexBuffer(cirMesh, DrawPrimitive.TRIANGLE_STRIP)
+        }
+    }
+}

orx-mesh-generators/src/main/kotlin/Segment.kt

@@ -0,0 +1,37 @@
+package org.openrndr.extra.meshgenerators
+
+import org.openrndr.draw.VertexBuffer
+import org.openrndr.draw.vertexBuffer
+import org.openrndr.draw.vertexFormat
+import org.openrndr.math.Vector2
+import org.openrndr.shape.Segment
+
+/**
+ * Converts a [Segment] into a [VertexBuffer]. It takes
+ * [samples] samples of the Segment. The thickness can
+ * be constant: `segment.toMesh(50) { 10.0 }`
+ * or variable: `segment.toMesh(50) { t -> 10.0 * t }`
+ * or even:     `segment.toMesh(30) { t -> cos(t * 3.14159) * 10 + 5 }`
+ */
+fun Segment.toMesh(
+    samples: Int,
+    thickness: (Double) -> Double = { 5.0 }
+): VertexBuffer {
+    val vb = vertexBuffer(vertexFormat {
+        position(3)
+        textureCoordinate(2)
+    }, samples * 2)
+
+    vb.put {
+        repeat(samples) {
+            val t = it / (samples - 1.0)
+            val pos = position(t)
+            val n = normal(t)
+            write((pos + n * thickness(t)).xy0)
+            write(Vector2(t, 0.0))
+            write((pos - n * thickness(t)).xy0)
+            write(Vector2(t, 1.0))
+        }
+    }
+    return vb
+}

orx-mesh-generators/src/main/kotlin/ShapeContour.kt

@@ -0,0 +1,39 @@
+package org.openrndr.extra.meshgenerators
+
+import org.openrndr.draw.VertexBuffer
+import org.openrndr.draw.vertexBuffer
+import org.openrndr.draw.vertexFormat
+import org.openrndr.math.Vector2
+import org.openrndr.shape.ShapeContour
+
+/**
+ * Converts a [ShapeContour] into a [VertexBuffer]. It takes
+ * [samples] samples of the Segment. The thickness can
+ * be constant: `contour.toMesh(50) { 10.0 }`
+ * or variable: `contour.toMesh(50) { t -> 10.0 * t }`
+ * or even:     `contour.toMesh(30) { t -> cos(t * 3.14159) * 10 + 5`
+ */
+fun ShapeContour.toMesh(
+    samples: Int,
+    thickness: (Double) -> Double = { 5.0 }
+): VertexBuffer {
+    val actualSamples = samples + if (closed) 1 else 0
+    val vb = vertexBuffer(vertexFormat {
+        position(3)
+        textureCoordinate(2)
+    }, actualSamples * 2)
+
+    vb.put {
+        repeat(actualSamples) {
+            val t = it / samples.toDouble()
+            val t1 = t % 1.0
+            val pos = position(t1)
+            val n = normal(t1)
+            write((pos + n * thickness(t1)).xy0)
+            write(Vector2(t, 0.0))
+            write((pos - n * thickness(t1)).xy0)
+            write(Vector2(t, 1.0))
+        }
+    }
+    return vb
+}