[orx-shapes] convert to MPP

orx-shapes/build.gradle

@@ -1,19 +0,0 @@
-sourceSets {
-    demo {
-        java {
-            srcDirs = ["src/demo/kotlin"]
-            compileClasspath += main.getCompileClasspath()
-            runtimeClasspath += main.getRuntimeClasspath()
-        }
-    }
-}
-
-dependencies {
-    implementation(project(":orx-color"))
-    implementation(project(":orx-shader-phrases"))
-    demoImplementation("org.openrndr:openrndr-application:$openrndrVersion")
-    demoImplementation("org.openrndr:openrndr-extensions:$openrndrVersion")
-    demoRuntimeOnly("org.openrndr:openrndr-gl3:$openrndrVersion")
-    demoRuntimeOnly("org.openrndr:openrndr-gl3-natives-$openrndrOS:$openrndrVersion")
-    demoImplementation(sourceSets.getByName("main").output)
-}

orx-shapes/build.gradle.kts

@@ -0,0 +1,98 @@
+import Orx_embed_shaders_gradle.EmbedShadersTask
+
+plugins {
+    kotlin("multiplatform")
+    kotlin("plugin.serialization")
+    id("orx.embed-shaders")
+}
+
+val kotlinxSerializationVersion: String by rootProject.extra
+val kotestVersion: String by rootProject.extra
+val junitJupiterVersion: String by rootProject.extra
+val jvmTarget: String by rootProject.extra
+val kotlinApiVersion: String by rootProject.extra
+val kotlinVersion: String by rootProject.extra
+val kotlinLoggingVersion: String by rootProject.extra
+val kluentVersion: String by rootProject.extra
+val openrndrVersion: String by rootProject.extra
+val openrndrOS: String by rootProject.extra
+val spekVersion: String by rootProject.extra
+
+kotlin {
+    jvm {
+        compilations {
+            val demo by creating {
+                defaultSourceSet {
+                    kotlin.srcDir("src/demo")
+                    dependencies {
+                        implementation(project(":orx-camera"))
+                        implementation(project(":orx-color"))
+                        implementation("org.openrndr:openrndr-application:$openrndrVersion")
+                        implementation("org.openrndr:openrndr-extensions:$openrndrVersion")
+                        runtimeOnly("org.openrndr:openrndr-gl3:$openrndrVersion")
+                        runtimeOnly("org.openrndr:openrndr-gl3-natives-$openrndrOS:$openrndrVersion")
+                        implementation(compilations["main"]!!.output.allOutputs)
+                    }
+                }
+            }
+        }
+        compilations.all {
+            kotlinOptions.jvmTarget = jvmTarget
+            kotlinOptions.apiVersion = kotlinApiVersion
+        }
+        testRuns["test"].executionTask.configure {
+            useJUnitPlatform()
+        }
+    }
+    js(IR) {
+        browser()
+        nodejs()
+    }
+
+    sourceSets {
+        @Suppress("UNUSED_VARIABLE")
+        val commonMain by getting {
+            dependencies {
+                implementation(project(":orx-parameters"))
+                implementation(project(":orx-shader-phrases"))
+                implementation(project(":orx-color"))
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:$kotlinxSerializationVersion")
+                implementation("org.openrndr:openrndr-application:$openrndrVersion")
+                implementation("org.openrndr:openrndr-draw:$openrndrVersion")
+                implementation("org.openrndr:openrndr-filter:$openrndrVersion")
+                implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion")
+                implementation("io.github.microutils:kotlin-logging:$kotlinLoggingVersion")
+            }
+        }
+        @Suppress("UNUSED_VARIABLE")
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test-common"))
+                implementation(kotlin("test-annotations-common"))
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlinxSerializationVersion")
+                implementation("io.kotest:kotest-assertions-core:$kotestVersion")
+            }
+        }
+
+        @Suppress("UNUSED_VARIABLE")
+        val jvmTest by getting {
+            dependencies {
+                implementation(kotlin("test-common"))
+                implementation(kotlin("test-annotations-common"))
+                implementation(kotlin("test-junit5"))
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlinxSerializationVersion")
+                runtimeOnly("org.junit.jupiter:junit-jupiter-api:$junitJupiterVersion")
+                runtimeOnly("org.junit.jupiter:junit-jupiter-engine:$junitJupiterVersion")
+                implementation("org.spekframework.spek2:spek-dsl-jvm:$spekVersion")
+                implementation("org.amshove.kluent:kluent:$kluentVersion")
+            }
+        }
+
+        @Suppress("UNUSED_VARIABLE")
+        val jsTest by getting {
+            dependencies {
+                implementation(kotlin("test-js"))
+            }
+        }
+    }
+}

orx-shapes/src/commonMain/kotlin/RegularPolygon.kt

@@ -1,17 +1,19 @@
 package org.openrndr.extra.shapes
 
 import org.openrndr.math.Vector2
+import org.openrndr.math.asRadians
 import org.openrndr.shape.ShapeContour
 import org.openrndr.shape.contour
+import kotlin.math.PI
 import kotlin.math.cos
 import kotlin.math.sin
 
 fun regularPolygon(sides: Int, center: Vector2 = Vector2.ZERO, radius: Double = 100.0, phase: Double = 0.0): ShapeContour {
     val c = contour {
-        val phi = Math.toRadians(phase)
+        val phi = phase.asRadians
         for (i in 0 until sides) {
-            val x = center.x + radius * cos(i.toDouble() / sides * Math.PI * 2 + phi)
-            val y = center.y + radius * sin(i.toDouble() / sides * Math.PI * 2 + phi)
+            val x = center.x + radius * cos(i.toDouble() / sides * PI * 2 + phi)
+            val y = center.y + radius * sin(i.toDouble() / sides * PI * 2 + phi)
 
             moveOrLineTo(x, y)
         }
@@ -22,16 +24,16 @@ fun regularPolygon(sides: Int, center: Vector2 = Vector2.ZERO, radius: Double =
 
 fun regularPolygonRounded(sides: Int, roundFactor: Double = 0.5, center: Vector2 = Vector2.ZERO, radius: Double = 100.0, phase: Double = 0.0): ShapeContour {
     val c = contour {
-        val phi = Math.toRadians(phase)
+        val phi = phase.asRadians
         for (i in 0 until sides) {
-            val x0 = center.x + radius * cos(i.toDouble() / sides * Math.PI * 2 + phi)
-            val y0 = center.y + radius * sin(i.toDouble() / sides * Math.PI * 2 + phi)
+            val x0 = center.x + radius * cos(i.toDouble() / sides * PI * 2 + phi)
+            val y0 = center.y + radius * sin(i.toDouble() / sides * PI * 2 + phi)
 
-            val x1 = center.x + radius * cos((i + 1.0) / sides * Math.PI * 2 + phi)
-            val y1 = center.y + radius * sin((i + 1.0) / sides * Math.PI * 2 + phi)
+            val x1 = center.x + radius * cos((i + 1.0) / sides * PI * 2 + phi)
+            val y1 = center.y + radius * sin((i + 1.0) / sides * PI * 2 + phi)
 
-            val x2 = center.x + radius * cos((i + 2.0) / sides * Math.PI * 2 + phi)
-            val y2 = center.y + radius * sin((i + 2.0) / sides * Math.PI * 2 + phi)
+            val x2 = center.x + radius * cos((i + 2.0) / sides * PI * 2 + phi)
+            val y2 = center.y + radius * sin((i + 2.0) / sides * PI * 2 + phi)
 
             val f = roundFactor / 2.0
 
@@ -60,16 +62,16 @@ fun regularPolygonRounded(sides: Int, roundFactor: Double = 0.5, center: Vector2
 
 fun regularPolygonBeveled(sides: Int, bevelFactor: Double = 0.5, center: Vector2 = Vector2.ZERO, radius: Double = 100.0, phase: Double = 0.0): ShapeContour {
     val c = contour {
-        val phi = Math.toRadians(phase)
+        val phi = phase.asRadians
         for (i in 0 until sides) {
-            val x0 = center.x + radius * cos(i.toDouble() / sides * Math.PI * 2 + phi)
-            val y0 = center.y + radius * sin(i.toDouble() / sides * Math.PI * 2 + phi)
+            val x0 = center.x + radius * cos(i.toDouble() / sides * PI * 2 + phi)
+            val y0 = center.y + radius * sin(i.toDouble() / sides * PI * 2 + phi)
 
-            val x1 = center.x + radius * cos((i + 1.0) / sides * Math.PI * 2 + phi)
-            val y1 = center.y + radius * sin((i + 1.0) / sides * Math.PI * 2 + phi)
+            val x1 = center.x + radius * cos((i + 1.0) / sides * PI * 2 + phi)
+            val y1 = center.y + radius * sin((i + 1.0) / sides * PI * 2 + phi)
 
-            val x2 = center.x + radius * cos((i + 2.0) / sides * Math.PI * 2 + phi)
-            val y2 = center.y + radius * sin((i + 2.0) / sides * Math.PI * 2 + phi)
+            val x2 = center.x + radius * cos((i + 2.0) / sides * PI * 2 + phi)
+            val y2 = center.y + radius * sin((i + 2.0) / sides * PI * 2 + phi)
 
             val f = bevelFactor / 2.0
 

orx-shapes/src/commonMain/kotlin/RegularStar.kt

@@ -1,6 +1,7 @@
 package org.openrndr.extra.shapes
 
 import org.openrndr.math.Vector2
+import org.openrndr.math.asRadians
 import org.openrndr.shape.ShapeContour
 import org.openrndr.shape.contour
 import kotlin.math.PI
@@ -9,7 +10,7 @@ import kotlin.math.sin
 
 fun regularStar(points: Int, innerRadius: Double, outerRadius: Double, center: Vector2 = Vector2.ZERO, phase: Double = 0.0): ShapeContour {
     return contour {
-        val theta = Math.toRadians(phase)
+        val theta = phase.asRadians
         val phi = PI * 2.0 / (points * 2)
         for (i in 0 until points * 2 step 2) {
             val outerPoint = Vector2(cos(i * phi + theta), sin(i * phi + theta)) * outerRadius + center
@@ -26,7 +27,7 @@ fun regularStarRounded(points: Int, innerRadius: Double, outerRadius: Double,
                        center: Vector2 = Vector2.ZERO,
                        phase: Double = 0.0): ShapeContour {
     return contour {
-        val theta = Math.toRadians(phase)
+        val theta = phase.asRadians
         val phi = PI * 2.0 / (points * 2)
         for (i in 0 until points * 2 step 2) {
             val outerPoint0 = Vector2(cos(i * phi + theta), sin(i * phi + theta)) * outerRadius + center
@@ -56,7 +57,7 @@ fun regularStarBeveled(points: Int, innerRadius: Double, outerRadius: Double,
                        center: Vector2 = Vector2.ZERO,
                        phase: Double = 0.0): ShapeContour {
     return contour {
-        val theta = Math.toRadians(phase)
+        val theta = phase.asRadians
         val phi = PI * 2.0 / (points * 2)
         for (i in 0 until points * 2 step 2) {
             val outerPoint0 = Vector2(cos(i * phi + theta), sin(i * phi + theta)) * outerRadius + center

orx-shapes/src/commonMain/kotlin/drawers/BezierPatchDrawer.kt

@@ -14,6 +14,7 @@ import org.openrndr.extra.shapes.phrases.BezierPhraseBook
 import org.openrndr.extras.color.phrases.ColorPhraseBook
 import org.openrndr.extras.color.spaces.ColorOKLABa
 import org.openrndr.math.Vector4
+import kotlin.jvm.JvmName
 
 private val glslVersion = "410 core"