Update README.md: change Java requirement 14 -> 17

README.md

@@ -24,7 +24,7 @@ See the [wiki](https://github.com/openrndr/openrndr-template/wiki)
 
 ## Cross builds
 
-See the [wiki](https://github.com/openrndr/openrndr-template/wiki)
+To create a runnable jar for a platform different from your current platform, use `./gradlew jar -PtargetPlatform=<platform>`, where `<platform>` is either `windows`, `macos`, `linux-x64`, or `linux-arm64`. 
 
 ## Updating OPENRNDR, ORX and other dependencies
 
@@ -64,10 +64,3 @@ any time a commit is tagged with a version number like `v1.*`. For example, we c
     ```
 
     You can follow the progress of the action under the Actions tab in GitHub. Once complete, the executables will appear under the Releases section.
-
-## Building libraries
-
-This template can be used to create a library with your classes and extensions and reuse them across projects or share them with other people. 
-To publish the project as a library, open [build.gradle.kts](build.gradle.kts) and replace the `conventions.distribute-application` plugin with `conventions.publish-library`. 
-This automatically sets up the `maven-publish` plugin, which adds the `publishToMavenLocal` task. 
-The plugin also adds a `demo` sourceSet with runtime dependencies set to go. Demos can be placed in `src/demo/kotlin` and started right away.

build.gradle.kts

@@ -1,31 +1,374 @@
-group = property("project.group") ?: error("project.group not set")
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-version = property("project.version") ?: error("project.version not set")
+import org.gradle.internal.os.OperatingSystem
+import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
+group = "org.openrndr.template"
+version = "1.0.0"
+
+val applicationMainClass = "TemplateProgramKt"
+
+/**  ## additional ORX features to be added to this project */
+val orxFeatures = setOf<String>(
+//  "orx-axidraw",
+//  "orx-boofcv",
+    "orx-camera",
+//  "orx-chataigne",
+    "orx-color",
+    "orx-composition",
+    "orx-compositor",
+//  "orx-compute-graph",
+//  "orx-compute-graph-nodes",
+    "orx-delegate-magic",
+//  "orx-dnk3",
+//  "orx-easing",
+    "orx-envelopes",
+//  "orx-expression-evaluator",
+//  "orx-fcurve",
+//  "orx-fft",
+//  "orx-file-watcher",
+    "orx-fx",
+//  "orx-git-archiver",
+//  "orx-gradient-descent",
+    "orx-gui",
+//  "orx-hash-grid",
+    "orx-image-fit",
+//  "orx-integral-image",
+//  "orx-interval-tree",
+//  "orx-jumpflood",
+//  "orx-kdtree",
+//  "orx-keyframer",
+//  "orx-kinect-v1",
+//  "orx-kotlin-parser",
+//  "orx-marching-squares",
+//  "orx-math",
+//  "orx-mesh-generators",
+//  "orx-midi",
+//  "orx-minim",
+    "orx-no-clear",
+    "orx-noise",
+//  "orx-obj-loader",
+    "orx-olive",
+//  "orx-osc",
+//  "orx-palette",
+    "orx-panel",
+//  "orx-parameters",
+//  "orx-poisson-fill",
+//  "orx-property-watchers",
+//  "orx-quadtree",
+//  "orx-rabbit-control",
+//  "orx-realsense2",
+//  "orx-runway",
+    "orx-shade-styles",
+//  "orx-shader-phrases",
+    "orx-shapes",
+    "orx-svg",
+//  "orx-syphon",
+//  "orx-temporal-blur",
+//  "orx-tensorflow",
+    "orx-text-writer",
+//  "orx-time-operators",
+//  "orx-timer",
+//  "orx-triangulation",
+//  "orx-turtle",
+    "orx-video-profiles",
+    "orx-view-box",
+)
+
+/** ## additional ORML features to be added to this project */
+val ormlFeatures = setOf<String>(
+//    "orml-blazepose",
+//    "orml-dbface",
+//    "orml-facemesh",
+//    "orml-image-classifier",
+//    "orml-psenet",
+//    "orml-ssd",
+//    "orml-style-transfer",
+//    "orml-super-resolution",
+//    "orml-u2net",
+)
+
+/** ## additional OPENRNDR features to be added to this project */
+val openrndrFeatures = setOfNotNull(
+    if (DefaultNativePlatform("current").architecture.name != "arm-v8") "video" else null
+)
+
+/** ## configure the type of logging this project uses */
+enum class Logging { NONE, SIMPLE, FULL }
+
+val applicationLogging = Logging.FULL
+
+// ------------------------------------------------------------------------------------------------------------------ //
+
+@Suppress("DSL_SCOPE_VIOLATION")
 plugins {
+    java
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.shadow)
+    alias(libs.plugins.runtime)
+    alias(libs.plugins.gitarchive.tomarkdown).apply(false)
+    alias(libs.plugins.versions)
     alias(libs.plugins.kotlin.serialization)
-    id("conventions.kotlin-jvm")
+}
-    id("conventions.openrndr-tasks")
+
-    id("conventions.distribute-application")
+repositories {
+    mavenCentral()
+    mavenLocal()
 }
 
 dependencies {
-    implementation(openrndr.application)
-    implementation(openrndr.draw)
-    runtimeOnly(openrndr.gl3)
 
-    implementation(openrndr.dialogs)
+//    implementation(libs.jsoup)
-    implementation(openrndr.orextensions)
+//    implementation(libs.csv)
+
+    /* ORSL dependencies */
+
+//    implementation(libs.orsl.shader.generator)
+//    implementation(libs.orsl.extension.color)
+//    implementation(libs.orsl.extension.easing)
+//    implementation(libs.orsl.extension.gradient)
+//    implementation(libs.orsl.extension.noise)
+//    implementation(libs.orsl.extension.pbr)
+//    implementation(libs.orsl.extension.raymarching)
+//    implementation(libs.orsl.extension.sdf)
 
-    implementation(openrndr.ffmpeg)
-    implementation(orx.bundles.basic)
-    implementation(orx.olive)
     implementation(libs.kotlinx.coroutines.core)
     implementation(libs.kotlinx.serialization.core)
     implementation(libs.kotlinx.serialization.json)
     implementation(libs.slf4j.api)
     implementation(libs.kotlin.logging)
 
-    runtimeOnly(libs.bundles.logging.simple)
+    when (applicationLogging) {
-
+        Logging.NONE -> runtimeOnly(libs.slf4j.nop)
+        Logging.SIMPLE -> runtimeOnly(libs.slf4j.simple)
+        Logging.FULL -> {
+            runtimeOnly(libs.log4j.slf4j2)
+            runtimeOnly(libs.log4j.core)
+            runtimeOnly(libs.jackson.databind)
+            runtimeOnly(libs.jackson.json)
+        }
+    }
+    implementation(kotlin("stdlib-jdk8"))
     testImplementation(libs.junit)
 }
+
+// ------------------------------------------------------------------------------------------------------------------ //
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+kotlin {
+    compilerOptions {
+        languageVersion = KotlinVersion.KOTLIN_2_0
+        apiVersion = KotlinVersion.KOTLIN_2_0
+        jvmTarget = JvmTarget.JVM_17
+    }
+}
+
+// ------------------------------------------------------------------------------------------------------------------ //
+
+application {
+    mainClass = if (hasProperty("openrndr.application"))
+        "${property("openrndr.application")}"
+    else
+        applicationMainClass
+}
+
+tasks {
+    named<ShadowJar>("shadowJar") {
+        manifest {
+            attributes["Main-Class"] = applicationMainClass
+            attributes["Implementation-Version"] = project.version
+        }
+        minimize {
+            exclude(dependency("org.openrndr:openrndr-gl3:.*"))
+            exclude(dependency("org.jetbrains.kotlin:kotlin-reflect:.*"))
+            exclude(dependency("org.slf4j:slf4j-simple:.*"))
+            exclude(dependency("org.apache.logging.log4j:log4j-slf4j2-impl:.*"))
+            exclude(dependency("com.fasterxml.jackson.core:jackson-databind:.*"))
+            exclude(dependency("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:.*"))
+            exclude(dependency("org.bytedeco:.*"))
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------------------------ //
+
+tasks {
+    named<org.beryx.runtime.JPackageTask>("jpackage") {
+        doLast {
+            val destPath = if (OperatingSystem.current().isMacOsX)
+                "build/jpackage/openrndr-application.app/Contents/Resources/data"
+            else
+                "build/jpackage/openrndr-application/data"
+
+            copy {
+                from("data") { include("**/*") }
+                into(destPath)
+            }
+        }
+    }
+
+    register<Zip>("jpackageZip") {
+        archiveFileName = "openrndr-application.zip"
+        from("${layout.buildDirectory.get()}/jpackage") {
+            include("**/*")
+        }
+        dependsOn("jpackage")
+    }
+}
+
+runtime {
+    jpackage {
+        imageName = "openrndr-application"
+        skipInstaller = true
+        if (OperatingSystem.current().isMacOsX) {
+            jvmArgs.add("-XstartOnFirstThread")
+            jvmArgs.add("-Duser.dir=${"$"}APPDIR/../Resources")
+        }
+    }
+    options = listOf("--strip-debug", "--compress", "1", "--no-header-files", "--no-man-pages")
+    modules = listOf("jdk.unsupported", "java.management", "java.desktop")
+}
+
+// ------------------------------------------------------------------------------------------------------------------ //
+
+tasks {
+    register<org.openrndr.extra.gitarchiver.GitArchiveToMarkdown>("gitArchiveToMarkDown") {
+        historySize = 20
+    }
+}
+
+// ------------------------------------------------------------------------------------------------------------------ //
+
+tasks {
+    dependencyUpdates {
+        gradleReleaseChannel = "current"
+
+        val nonStableKeywords = listOf("alpha", "beta", "rc")
+
+        fun isNonStable(version: String) = nonStableKeywords.any {
+            version.lowercase().contains(it)
+        }
+
+        rejectVersionIf {
+            isNonStable(candidate.version) && !isNonStable(currentVersion)
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------------------------ //
+
+class Openrndr {
+    val openrndrVersion = libs.versions.openrndr.get()
+    val orxVersion = libs.versions.orx.get()
+    val ormlVersion = libs.versions.orml.get()
+
+    // choices are "orx-tensorflow-gpu", "orx-tensorflow"
+    val orxTensorflowBackend = "orx-tensorflow"
+
+    val currArch = DefaultNativePlatform("current").architecture.name
+    val currOs = OperatingSystem.current()
+    val os = if (project.hasProperty("targetPlatform")) {
+        val supportedPlatforms = setOf("windows", "macos", "linux-x64", "linux-arm64")
+        val platform: String = project.property("targetPlatform") as String
+        if (platform !in supportedPlatforms) {
+            throw IllegalArgumentException("target platform not supported: $platform")
+        } else {
+            platform
+        }
+    } else when {
+        currOs.isWindows -> "windows"
+        currOs.isMacOsX -> when (currArch) {
+            "aarch64", "arm-v8" -> "macos-arm64"
+            else -> "macos"
+        }
+
+        currOs.isLinux -> when (currArch) {
+            "x86-64" -> "linux-x64"
+            "aarch64" -> "linux-arm64"
+            else -> throw IllegalArgumentException("architecture not supported: $currArch")
+        }
+
+        else -> throw IllegalArgumentException("os not supported: ${currOs.name}")
+    }
+
+    fun orx(module: String) = "org.openrndr.extra:$module:$orxVersion"
+    fun orml(module: String) = "org.openrndr.orml:$module:$ormlVersion"
+    fun openrndr(module: String) = "org.openrndr:openrndr-$module:$openrndrVersion"
+    fun openrndrNatives(module: String) = "org.openrndr:openrndr-$module-natives-$os:$openrndrVersion"
+    fun orxNatives(module: String) = "org.openrndr.extra:$module-natives-$os:$orxVersion"
+
+    init {
+        dependencies {
+            runtimeOnly(openrndr("gl3"))
+            runtimeOnly(openrndrNatives("gl3"))
+            implementation(openrndr("openal"))
+            runtimeOnly(openrndrNatives("openal"))
+            implementation(openrndr("application"))
+            implementation(openrndr("animatable"))
+            implementation(openrndr("extensions"))
+            implementation(openrndr("filter"))
+            implementation(openrndr("dialogs"))
+            if ("video" in openrndrFeatures) {
+                implementation(openrndr("ffmpeg"))
+                runtimeOnly(openrndrNatives("ffmpeg"))
+            }
+            for (feature in orxFeatures) {
+                implementation(orx(feature))
+            }
+            for (feature in ormlFeatures) {
+                implementation(orml(feature))
+            }
+            if ("orx-tensorflow" in orxFeatures) runtimeOnly("org.openrndr.extra:$orxTensorflowBackend-natives-$os:$orxVersion")
+            if ("orx-kinect-v1" in orxFeatures) runtimeOnly(orxNatives("orx-kinect-v1"))
+            if ("orx-olive" in orxFeatures) implementation(libs.kotlin.script.runtime)
+        }
+    }
+}
+
+val openrndr = Openrndr()
+
+if (properties["openrndr.tasks"] == "true") {
+    tasks.register("create executable jar for $applicationMainClass") {
+        group = " \uD83E\uDD8C OPENRNDR"
+        dependsOn("shadowJar")
+    }
+
+    tasks.register("run $applicationMainClass") {
+        group = " \uD83E\uDD8C OPENRNDR"
+        dependsOn("run")
+    }
+
+    tasks.register("create standalone executable for $applicationMainClass") {
+        group = " \uD83E\uDD8C OPENRNDR"
+        dependsOn("jpackageZip")
+    }
+
+    tasks.register("add IDE file scopes") {
+        group = " \uD83E\uDD8C OPENRNDR"
+        val scopesFolder = File("${project.projectDir}/.idea/scopes")
+        scopesFolder.mkdirs()
+
+        val files = listOf(
+            "Code" to "file:*.kt||file:*.frag||file:*.vert||file:*.glsl",
+            "Text" to "file:*.txt||file:*.md||file:*.xml||file:*.json",
+            "Gradle" to "file[*buildSrc*]:*/||file:*gradle.*||file:*.gradle||file:*/gradle-wrapper.properties||file:*.toml",
+            "Media" to "file:*.png||file:*.jpg||file:*.dds||file:*.exr||file:*.mp3||file:*.wav||file:*.mp4||file:*.mov||file:*.svg"
+        )
+        files.forEach { (name, pattern) ->
+            val file = File(scopesFolder, "__$name.xml")
+            if (!file.exists()) {
+                file.writeText(
+                    """
+                    <component name="DependencyValidationManager">
+                      <scope name=" ★ $name" pattern="$pattern" />
+                    </component>
+                    """.trimIndent()
+                )
+            }
+        }
+    }
+}

buildSrc/build.gradle.kts

@@ -1,12 +0,0 @@
-plugins {
-    `kotlin-dsl`
-}
-
-val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
-
-dependencies {
-    implementation(libs.findLibrary("shadow-gradle-plugin").get())
-    implementation(libs.findLibrary("runtime-gradle-plugin").get())
-    implementation(libs.findLibrary("kotlin-gradle-plugin").get())
-    implementation(libs.findLibrary("xversions-gradle-plugin").get())
-}

buildSrc/settings.gradle.kts

@@ -1,39 +0,0 @@
-rootProject.name = "buildSrc"
-
-dependencyResolutionManagement {
-    repositories {
-        mavenCentral()
-        gradlePluginPortal()
-        mavenLocal {
-            content {
-                includeGroup("org.openrndr")
-                includeGroup("org.openrndr.extra")
-            }
-        }
-    }
-
-    versionCatalogs {
-        create("libs") {
-            from(files("../gradle/libs.versions.toml"))
-        }
-        // We use a regex to get the openrndr/orx versions from the primary catalog as there is no public Gradle API to parse catalogs.
-        val orRegEx = Regex("^openrndr[ ]*=[ ]*(?:\\{[ ]*require[ ]*=[ ]*)?\"(.*)\"[ ]*(?:\\})?", RegexOption.MULTILINE)
-        val orxRegEx = Regex("^orx[ ]*=[ ]*(?:\\{[ ]*require[ ]*=[ ]*)?\"(.*)\"[ ]*(?:\\})?", RegexOption.MULTILINE)
-        val openrndrVersion = orRegEx.find(File(rootDir,"../gradle/libs.versions.toml").readText())?.groupValues?.get(1) ?: error("can't find openrndr version")
-        val orxVersion = orxRegEx.find(File(rootDir,"../gradle/libs.versions.toml").readText())?.groupValues?.get(1) ?: error("can't find orx version")
-
-        create("orx") {
-            from("org.openrndr.extra:orx-module-catalog:$orxVersion")
-        }
-        create("openrndr") {
-            from("org.openrndr:openrndr-module-catalog:$openrndrVersion")
-        }
-    }
-}
-
-pluginManagement {
-    repositories {
-        gradlePluginPortal()
-
-    }
-}

buildSrc/src/main/kotlin/conventions/distribute-application.gradle.kts

@@ -1,73 +0,0 @@
-package conventions
-import org.gradle.internal.os.OperatingSystem
-import kotlin.collections.set
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-
-plugins {
-    id("com.gradleup.shadow")
-    id("org.beryx.runtime")
-}
-
-val applicationMainClass: String by properties
-
-application {
-    mainClass = if (hasProperty("openrndr.application"))
-        "${property("openrndr.application")}"
-    else
-        applicationMainClass
-}
-
-tasks {
-    named<ShadowJar>("shadowJar") {
-        manifest {
-            attributes["Main-Class"] = applicationMainClass
-            attributes["Implementation-Version"] = project.version
-        }
-        minimize {
-            exclude(dependency("org.openrndr:openrndr-gl3:.*"))
-            exclude(dependency("org.jetbrains.kotlin:kotlin-reflect:.*"))
-            exclude(dependency("org.slf4j:slf4j-simple:.*"))
-            exclude(dependency("org.apache.logging.log4j:log4j-slf4j2-impl:.*"))
-            exclude(dependency("com.fasterxml.jackson.core:jackson-databind:.*"))
-            exclude(dependency("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:.*"))
-            exclude(dependency("org.bytedeco:.*"))
-        }
-    }
-}
-
-tasks {
-    named<org.beryx.runtime.JPackageTask>("jpackage") {
-        doLast {
-            val destPath = if (OperatingSystem.current().isMacOsX)
-                "build/jpackage/openrndr-application.app/Contents/Resources/data"
-            else
-                "build/jpackage/openrndr-application/data"
-
-            copy {
-                from("data") { include("**/*") }
-                into(destPath)
-            }
-        }
-    }
-
-    register<Zip>("jpackageZip") {
-        archiveFileName = "openrndr-application.zip"
-        from("${layout.buildDirectory.get()}/jpackage") {
-            include("**/*")
-        }
-        dependsOn("jpackage")
-    }
-}
-
-runtime {
-    jpackage {
-        imageName = "openrndr-application"
-        skipInstaller = true
-        if (OperatingSystem.current().isMacOsX) {
-            jvmArgs.add("-XstartOnFirstThread")
-            jvmArgs.add("-Duser.dir=${"$"}APPDIR/../Resources")
-        }
-    }
-    options = listOf("--strip-debug", "--compress", "1", "--no-header-files", "--no-man-pages")
-    modules = listOf("jdk.unsupported", "java.management", "java.desktop")
-}

buildSrc/src/main/kotlin/conventions/kotlin-jvm.gradle.kts

@@ -1,71 +0,0 @@
-package conventions
-import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
-
-val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
-
-plugins {
-    java
-    kotlin("jvm")
-    id("com.github.ben-manes.versions")
-}
-
-repositories {
-    mavenCentral()
-    mavenLocal()
-}
-
-java {
-    targetCompatibility = JavaVersion.valueOf("VERSION_${libs.findVersion("jvmTarget").get().displayName}")
-    sourceCompatibility = JavaVersion.valueOf("VERSION_${libs.findVersion("jvmTarget").get().displayName}")
-}
-
-kotlin {
-    compilerOptions {
-        apiVersion.set(KotlinVersion.valueOf("KOTLIN_${libs.findVersion("kotlinApi").get().displayName.replace(".", "_")}"))
-        languageVersion.set(KotlinVersion.valueOf("KOTLIN_${libs.findVersion("kotlinLanguage").get().displayName.replace(".", "_")}"))
-        jvmTarget.set(JvmTarget.valueOf("JVM_${libs.findVersion("jvmTarget").get().displayName}"))
-    }
-}
-
-fun arch(arch: String = System.getProperty("os.arch")): String {
-    return when (arch) {
-        "x86-64", "x86_64", "amd64" -> "x86-64"
-        "arm64", "aarch64" -> "aarch64"
-        else -> error("unsupported arch $arch")
-    }
-}
-
-fun Project.addHostMachineAttributesToRuntimeConfigurations() {
-    val currentOperatingSystemName: String = DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName()
-    val currentArchitectureName: String = arch()
-
-    configurations.matching {
-        it.name.endsWith("runtimeClasspath", ignoreCase = true)
-    }.configureEach {
-        attributes {
-            attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, objects.named(currentOperatingSystemName))
-            attribute(MachineArchitecture.ARCHITECTURE_ATTRIBUTE, objects.named(currentArchitectureName))
-        }
-    }
-}
-
-addHostMachineAttributesToRuntimeConfigurations()
-
-
-tasks {
-    dependencyUpdates {
-        gradleReleaseChannel = "current"
-
-        val nonStableKeywords = listOf("alpha", "beta", "rc")
-
-        fun isNonStable(version: String) = nonStableKeywords.any {
-            version.lowercase().contains(it)
-        }
-
-        rejectVersionIf {
-            isNonStable(candidate.version) && !isNonStable(currentVersion)
-        }
-    }
-}

buildSrc/src/main/kotlin/conventions/openrndr-tasks.gradle.kts

@@ -1,42 +0,0 @@
-package conventions
-
-val applicationMainClass by properties
-tasks.register("create executable jar for $applicationMainClass") {
-    group = " \uD83E\uDD8C OPENRNDR"
-    dependsOn("shadowJar")
-}
-
-tasks.register("run $applicationMainClass") {
-    group = " \uD83E\uDD8C OPENRNDR"
-    dependsOn("run")
-}
-
-tasks.register("create standalone executable for $applicationMainClass") {
-    group = " \uD83E\uDD8C OPENRNDR"
-    dependsOn("jpackageZip")
-}
-
-tasks.register("add IDE file scopes") {
-    group = " \uD83E\uDD8C OPENRNDR"
-    val scopesFolder = File("${project.projectDir}/.idea/scopes")
-    scopesFolder.mkdirs()
-
-    val files = listOf(
-        "Code" to "file:*.kt||file:*.frag||file:*.vert||file:*.glsl",
-        "Text" to "file:*.txt||file:*.md||file:*.xml||file:*.json",
-        "Gradle" to "file[*buildSrc*]:*/||file:*gradle.*||file:*.gradle||file:*/gradle-wrapper.properties||file:*.toml",
-        "Media" to "file:*.png||file:*.jpg||file:*.dds||file:*.exr||file:*.mp3||file:*.wav||file:*.mp4||file:*.mov||file:*.svg"
-    )
-    files.forEach { (name, pattern) ->
-        val file = File(scopesFolder, "__$name.xml")
-        if (!file.exists()) {
-            file.writeText(
-                """
-                    <component name="DependencyValidationManager">
-                      <scope name=" ★ $name" pattern="$pattern" />
-                    </component>
-                    """.trimIndent()
-            )
-        }
-    }
-}

buildSrc/src/main/kotlin/conventions/publish-library.gradle.kts

@@ -1,37 +0,0 @@
-package conventions
-
-import org.gradle.kotlin.dsl.java
-import org.gradle.kotlin.dsl.kotlin
-
-plugins {
-    java
-    kotlin("jvm")
-    `maven-publish`
-}
-
-val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
-val openrndr = extensions.getByType<VersionCatalogsExtension>().named("openrndr")
-
-val demo = sourceSets.create("demo")
-val main = sourceSets.getByName("main")
-
-demo.compileClasspath += main.compileClasspath
-demo.runtimeClasspath += main.runtimeClasspath
-demo.compileClasspath += main.output
-demo.runtimeClasspath += main.output
-
-dependencies {
-    "demoRuntimeOnly"(openrndr.findLibrary("gl3").get())
-}
-
-publishing {
-    publications {
-        create<MavenPublication>("maven") {
-            from(components["java"])
-            groupId = property("project.group")?.toString() ?: error("project.group not set")
-            artifactId = property("project.name")?.toString() ?: error("project.name not set")
-            description = property("project.name")?.toString() ?: error("project.name not set")
-            version = property("project.version")?.toString() ?: error("project.version not set")
-        }
-    }
-}

gradle.properties

@@ -1,7 +1,3 @@
-project.name=openrndr-template
-project.group=org.openrndr
-project.version=1.0.0
-applicationMainClass=TemplateProgramKt
 openrndr.tasks=true
 kotlin.code.style=official
 #org.gradle.configuration-cache=true

gradle/libs.versions.toml

@@ -1,14 +1,9 @@
 [versions]
-jvmTarget = "17"
 kotlin = "2.2.10"
-kotlinApi = "2.2"
+openrndr = "0.4.5"
-kotlinLanguage = "2.2"
+orx = "0.4.5"
-
-openrndr = "0.5.0-SNAPSHOT"
-orx = "0.5.0-SNAPSHOT"
 orsl = "0.4.5-alpha5"
 orml = "0.4.1"
-
 slf4j = "2.0.17"
 log4j = "2.23.1"
 jackson = "2.17.2"
@@ -33,10 +28,15 @@ log4j-core = { group = "org.apache.logging.log4j", name = "log4j-core", version.
 jackson-databind = { group = "com.fasterxml.jackson.core", name = "jackson-databind", version.ref = "jackson" }
 jackson-json = { group = "com.fasterxml.jackson.dataformat", name = "jackson-dataformat-yaml", version.ref = "jackson" }
 
-shadow-gradle-plugin = { group = "com.gradleup.shadow", name = "com.gradleup.shadow.gradle.plugin", version.ref = "shadow" }
+orsl-shader-generator = { group = "org.openrndr.extra", name = "orsl-shader-generator", version.ref = "orsl" }
-runtime-gradle-plugin = { group = "org.beryx.runtime", name = "org.beryx.runtime.gradle.plugin", version.ref = "runtime" }
+orsl-extension-color = { group = "org.openrndr.extra", name = "orsl-extension-color", version.ref = "orsl" }
-kotlin-gradle-plugin = { group = "org.jetbrains.kotlin.jvm", name = "org.jetbrains.kotlin.jvm.gradle.plugin", version.ref = "kotlin" }
+orsl-extension-easing = { group = "org.openrndr.extra", name = "orsl-extension-easing", version.ref = "orsl" }
-xversions-gradle-plugin = { group = "com.github.ben-manes.versions", name = "com.github.ben-manes.versions.gradle.plugin", version.ref = "versions" }
+orsl-extension-gradient = { group = "org.openrndr.extra", name = "orsl-extension-gradient", version.ref = "orsl" }
+orsl-extension-noise = { group = "org.openrndr.extra", name = "orsl-extension-noise", version.ref = "orsl" }
+orsl-extension-pbr = { group = "org.openrndr.extra", name = "orsl-extension-pbr", version.ref = "orsl" }
+orsl-extension-raymarching = { group = "org.openrndr.extra", name = "orsl-extension-raymarching", version.ref = "orsl" }
+orsl-extension-sdf = { group = "org.openrndr.extra", name = "orsl-extension-sdf", version.ref = "orsl" }
+
 kotlinx-coroutines-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-core", version.ref = "kotlinxCoroutines" }
 kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerialization" }
 kotlinx-serialization-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-core", version.ref = "kotlinxSerialization" }
@@ -52,8 +52,3 @@ shadow = { id = "com.gradleup.shadow", version.ref = "shadow" }
 runtime = { id = "org.beryx.runtime", version.ref = "runtime" }
 gitarchive-tomarkdown = { id = "org.openrndr.extra.gitarchiver.tomarkdown", version.ref = "orx" }
 versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }
-
-[bundles]
-logging-none = ["slf4j-nop"]
-logging-simple = ["slf4j-simple"]
-loggin-full = ["log4j-slf4j2", "log4j-core", "jackson-databind", "jackson-json"]

settings.gradle.kts

@@ -1,4 +1,4 @@
-rootProject.name = extra["project.name"]?.toString() ?: error("project.name not set")
+rootProject.name = "openrndr-template"
 
 pluginManagement {
     repositories {
@@ -6,30 +6,3 @@ pluginManagement {
         mavenLocal()
     }
 }
-
-dependencyResolutionManagement {
-    repositories {
-        mavenCentral()
-        mavenLocal {
-            content {
-                includeGroup("org.openrndr")
-                includeGroup("org.openrndr.extra")
-            }
-        }
-    }
-
-    versionCatalogs {
-        // We use a regex to get the openrndr/orx versions from the primary catalog as there is no public Gradle API to parse catalogs.
-        val orRegEx = Regex("^openrndr[ ]*=[ ]*(?:\\{[ ]*require[ ]*=[ ]*)?\"(.*)\"[ ]*(?:\\})?", RegexOption.MULTILINE)
-        val orxRegEx = Regex("^orx[ ]*=[ ]*(?:\\{[ ]*require[ ]*=[ ]*)?\"(.*)\"[ ]*(?:\\})?", RegexOption.MULTILINE)
-        val openrndrVersion = orRegEx.find(File(rootDir,"gradle/libs.versions.toml").readText())?.groupValues?.get(1) ?: error("can't find openrndr version")
-        val orxVersion = orxRegEx.find(File(rootDir,"gradle/libs.versions.toml").readText())?.groupValues?.get(1) ?: error("can't find orx version")
-
-        create("orx") {
-            from("org.openrndr.extra:orx-module-catalog:$orxVersion")
-        }
-        create("openrndr") {
-            from("org.openrndr:openrndr-module-catalog:$openrndrVersion")
-        }
-    }
-}