Build fixed. JS visualization loop added

build.gradle.kts

@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 buildscript {
     val kotlinVersion: String by rootProject.extra("1.3.21")
@@ -39,7 +40,7 @@ allprojects {
     }
 
     group = "hep.dataforge"
-    version = "0.1.1-dev-4"
+    version = "0.1.1-dev-5"
 
     // apply bintray configuration
     apply(from = "${rootProject.rootDir}/gradle/bintray.gradle")
@@ -50,42 +51,6 @@ allprojects {
 }
 
 subprojects {
-    extensions.findByType<KotlinMultiplatformExtension>()?.apply {
-        jvm {
-            compilations.all {
-                kotlinOptions {
-                    jvmTarget = "1.8"
-                }
-            }
-        }
-
-        js{
-            configure(listOf(compilations["main"], compilations["test"])) {
-                tasks.getByName(compileKotlinTaskName) {
-                    kotlinOptions {
-                        metaInfo = true
-                        sourceMap = true
-                        sourceMapEmbedSources = "always"
-                        moduleKind = "umd"
-                    }
-                }
-            }
-
-            configure(listOf(compilations["main"])) {
-                tasks.getByName(compileKotlinTaskName) {
-                    kotlinOptions {
-                        main = "call"
-                    }
-                }
-            }
-        }
-
-        targets.all {
-            sourceSets.all {
-                languageSettings.progressiveMode = true
-            }
-        }
-    }
 
     //    dokka {
 //        outputFormat = "html"
@@ -97,46 +62,79 @@ subprojects {
 //            classifier = "javadoc"
 //    }
 
+    // Create empty jar for sources classifier to satisfy maven requirements
+    val stubSources by tasks.registering(Jar::class) {
+        archiveClassifier.set("sources")
+        //from(sourceSets.main.get().allSource)
+    }
 
-    if (!name.startsWith("dataforge")) return@subprojects
+    // Create empty jar for javadoc classifier to satisfy maven requirements
+    val stubJavadoc by tasks.registering(Jar::class) {
+        archiveClassifier.set("javadoc")
+    }
 
-    extensions.findByType<PublishingExtension>()?.apply {
+    tasks.withType<KotlinCompile> {
-        publications.filterIsInstance<MavenPublication>().forEach { publication ->
+        kotlinOptions{
-            if (publication.name == "kotlinMultiplatform") {
+            jvmTarget = "1.8"
-                // for our root metadata publication, set artifactId with a package and project name
-                publication.artifactId = project.name
-            } else {
-                // for targets, set artifactId with a package, project name and target name (e.g. iosX64)
-                publication.artifactId = "${project.name}-${publication.name}"
-            }
         }
+    }
 
-        // Create empty jar for sources classifier to satisfy maven requirements
-        val stubSources by tasks.registering(Jar::class) {
-            archiveClassifier.set("sources")
-            //from(sourceSets.main.get().allSource)
-        }
-
-        // Create empty jar for javadoc classifier to satisfy maven requirements
-        val stubJavadoc by tasks.registering(Jar::class) {
-            archiveClassifier.set("javadoc")
-        }
 
+    afterEvaluate {
         extensions.findByType<KotlinMultiplatformExtension>()?.apply {
+            jvm {
+                compilations.all {
+                    kotlinOptions {
+                        jvmTarget = "1.8"
+                    }
+                }
+            }
 
-            targets.forEach { target ->
+            js {
-                val publication = publications.findByName(target.name) as MavenPublication
+                compilations.all {
+                    tasks.getByName(compileKotlinTaskName) {
+                        kotlinOptions {
+                            metaInfo = true
+                            sourceMap = true
+                            sourceMapEmbedSources = "always"
+                            moduleKind = "umd"
+                        }
+                    }
+                }
 
-                // Patch publications with fake javadoc
+                configure(listOf(compilations["main"])) {
-                publication.artifact(stubJavadoc)
+                    tasks.getByName(compileKotlinTaskName) {
+                        kotlinOptions {
+                            main = "call"
+                        }
+                    }
+                }
+            }
 
-                // Remove gradle metadata publishing from all targets which are not native
+            targets.all {
-//                if (target.platformType.name != "native") {
+                sourceSets.all {
-//                    publication.gradleModuleMetadataFile = null
+                    languageSettings.progressiveMode = true
-//                    tasks.matching { it.name == "generateMetadataFileFor${name.capitalize()}Publication" }.all {
+                }
-//                        onlyIf { false }
+            }
-//                    }
+
-//                }
+            configure<PublishingExtension> {
+
+                publications.filterIsInstance<MavenPublication>().forEach { publication ->
+                    if (publication.name == "kotlinMultiplatform") {
+                        // for our root metadata publication, set artifactId with a package and project name
+                        publication.artifactId = project.name
+                    } else {
+                        // for targets, set artifactId with a package, project name and target name (e.g. iosX64)
+                        publication.artifactId = "${project.name}-${publication.name}"
+                    }
+                }
+
+                targets.all {
+                    val publication = publications.findByName(name) as MavenPublication
+
+                    // Patch publications with fake javadoc
+                    publication.artifact(stubJavadoc.get())
+                }
             }
         }
     }

dataforge-meta/build.gradle.kts

@@ -48,3 +48,13 @@ kotlin {
 //        }
     }
 }
+
+//tasks.withType<Kotlin2JsCompile>{
+//    kotlinOptions{
+//        metaInfo = true
+//        outputFile = "${project.buildDir.path}/js/${project.name}.js"
+//        sourceMap = true
+//        moduleKind = "umd"
+//        main = "call"
+//    }
+//}

dataforge-meta/src/commonTest/kotlin/hep/dataforge/meta/MetaDelegateTest.kt

@@ -14,9 +14,9 @@ class MetaDelegateTest {
     fun delegateTest() {
         val testObject = object : Specification {
             override val config: Config = Config()
-            var myValue by string()
+            var myValue by config.string()
-            var safeValue by number(2.2)
+            var safeValue by config.number(2.2)
-            var enumValue by enum(TestEnum.YES)
+            var enumValue by config.enum(TestEnum.YES)
         }
         testObject.config["myValue"] = "theString"
         testObject.enumValue = TestEnum.NO

dataforge-vis/build.gradle.kts

@@ -1,8 +1,5 @@
-import org.openjfx.gradle.JavaFXOptions
-
 plugins {
     kotlin("multiplatform")
-    id("org.openjfx.javafxplugin")
 }
 
 kotlin {
@@ -26,7 +23,3 @@ kotlin {
         }
     }
 }
-
-configure<JavaFXOptions>{
-    modules("javafx.controls")
-}

dataforge-vis/dataforge-vis-spatial-fx/build.gradle.kts

@@ -1,4 +1,3 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.openjfx.gradle.JavaFXOptions
 
 plugins {
@@ -6,7 +5,8 @@ plugins {
     id("org.openjfx.javafxplugin")
 }
 
-dependencies{
+dependencies {
+    api(project(":dataforge-vis"))
     api(project(":dataforge-vis:dataforge-vis-spatial"))
     api("no.tornado:tornadofx:1.7.18")
     implementation("org.fxyz3d:fxyz3d:0.4.0")
@@ -15,9 +15,3 @@ dependencies{
 configure<JavaFXOptions> {
     modules("javafx.controls")
 }
-
-tasks.withType<KotlinCompile> {
-    kotlinOptions{
-        jvmTarget = "1.8"
-    }
-}

dataforge-vis/dataforge-vis-spatial-fx/src/main/kotlin/hep/dataforge/vis/DisplayObjectPropertyListener.kt

@@ -1,5 +1,8 @@
 package hep.dataforge.vis
 
+import hep.dataforge.meta.*
+import hep.dataforge.names.Name
+import hep.dataforge.names.toName
 import javafx.beans.binding.ObjectBinding
 import tornadofx.*
 

dataforge-vis/dataforge-vis-spatial-fx/src/main/kotlin/hep/dataforge/vis/spatial/FX3DOutput.kt

@@ -1,6 +1,12 @@
 package hep.dataforge.vis.spatial
 
+import hep.dataforge.context.Context
+import hep.dataforge.io.Output
+import hep.dataforge.meta.Meta
+import hep.dataforge.vis.DisplayGroup
 import hep.dataforge.vis.DisplayObjectPropertyListener
+import hep.dataforge.vis.float
+import hep.dataforge.vis.transform
 import javafx.scene.Group
 import javafx.scene.Node
 import org.fxyz3d.shapes.primitives.CuboidMesh
@@ -22,7 +28,7 @@ class FX3DOutput(override val context: Context) : Output<Any> {
                 val y = listener["y"].float()
                 val z = listener["z"].float()
                 val center = objectBinding(x, y, z) {
-                    Point3D(x.value ?: 0f, y.value ?: 0f, z.value ?: 0f)
+                    org.fxyz3d.geometry.Point3D(x.value ?: 0f, y.value ?: 0f, z.value ?: 0f)
                 }
                 when (obj) {
                     is DisplayGroup3D -> Group(obj.children.map { buildNode(it) }).apply {

dataforge-vis/dataforge-vis-spatial-fx/src/main/kotlin/hep/dataforge/vis/spatial/Materials.kt

@@ -1,5 +1,10 @@
 package hep.dataforge.vis.spatial
 
+import hep.dataforge.meta.MetaItem
+import hep.dataforge.meta.double
+import hep.dataforge.meta.get
+import hep.dataforge.meta.int
+import hep.dataforge.values.ValueType
 import javafx.scene.paint.Color
 import javafx.scene.paint.Material
 import javafx.scene.paint.PhongMaterial
@@ -51,11 +56,12 @@ fun MetaItem<*>.color(): Color {
 /**
  * Infer FX material based on meta item
  */
-fun MetaItem<*>.material(): Material {
+fun MetaItem<*>?.material(): Material {
     return when (this) {
+        null -> Materials.GREY
         is MetaItem.ValueItem -> PhongMaterial(color())
         is MetaItem.NodeItem -> PhongMaterial().apply {
-            node["color"]?.let { diffuseColor = it.color() }
+            (node["color"]?: this@material).let { diffuseColor = it.color() }
             node["specularColor"]?.let { specularColor = it.color() }
         }
     }

dataforge-vis/dataforge-vis-spatial-fx/src/main/kotlin/hep/dataforge/vis/spatial/RendererDemoApp.kt

@@ -1,5 +1,8 @@
 package hep.dataforge.vis.spatial
 
+import hep.dataforge.context.Global
+import hep.dataforge.meta.number
+import hep.dataforge.vis.DisplayGroup
 import javafx.scene.Parent
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.delay

dataforge-vis/dataforge-vis-spatial-js/src/main/kotlin/hep/dataforge/vis/spatial/Materials.kt

@@ -0,0 +1,59 @@
+package hep.dataforge.vis.spatial
+
+import hep.dataforge.meta.MetaItem
+import hep.dataforge.meta.double
+import hep.dataforge.meta.get
+import hep.dataforge.meta.int
+import hep.dataforge.values.ValueType
+import info.laht.threekt.materials.Material
+import info.laht.threekt.materials.MeshPhongMaterial
+import info.laht.threekt.math.Color
+import info.laht.threekt.math.ColorConstants
+
+object Materials {
+    val DEFAULT = MeshPhongMaterial().apply {
+        this.color.set(ColorConstants.darkgreen)
+    }
+}
+
+/**
+ * Infer color based on meta item
+ */
+fun MetaItem<*>.color(): Color {
+    return when (this) {
+        is MetaItem.ValueItem -> if (this.value.type == ValueType.STRING) {
+            Color(this.value.string)
+        } else {
+            val int = value.number.toInt()
+            val red = int and 0x00ff0000 shr 16
+            val green = int and 0x0000ff00 shr 8
+            val blue = int and 0x000000ff
+            Color(red, green, blue)
+        }
+        is MetaItem.NodeItem -> {
+            Color(
+                node["red"]?.int ?: 0,
+                node["green"]?.int ?: 0,
+                node["blue"]?.int ?: 0
+            )
+        }
+    }
+}
+
+/**
+ * Infer FX material based on meta item
+ */
+fun MetaItem<*>?.material(): Material {
+    return when (this) {
+        null -> Materials.DEFAULT
+        is MetaItem.ValueItem -> MeshPhongMaterial().apply {
+            color = this@material.color()
+        }
+        is MetaItem.NodeItem -> MeshPhongMaterial().apply {
+            (node["color"] ?: this@material).let { color = it.color() }
+            opacity = node["opacity"]?.double ?: 1.0
+            node["specularColor"]?.let { specular = it.color() }
+        }
+    }
+}
+

dataforge-vis/dataforge-vis-spatial-js/src/main/kotlin/hep/dataforge/vis/spatial/ThreeDemoApp.kt

@@ -4,6 +4,7 @@ import hep.dataforge.context.Global
 import hep.dataforge.meta.number
 import hep.dataforge.vis.ApplicationBase
 import hep.dataforge.vis.DisplayGroup
+import info.laht.threekt.external.controls.OrbitControls
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
@@ -17,9 +18,9 @@ class ThreeDemoApp : ApplicationBase() {
     override val stateKeys: List<String> = emptyList()
 
     override fun start(state: Map<String, Any>) {
-        println("started")
         val renderer = ThreeOutput(Global)
-        document.getElementById("canvas")?.appendChild(renderer.root)
+        renderer.start(document.getElementById("canvas")!!)
+        println("started")
 
         lateinit var group: DisplayGroup
 

dataforge-vis/dataforge-vis-spatial-js/src/main/kotlin/hep/dataforge/vis/spatial/ThreeOutput.kt

@@ -3,17 +3,25 @@ package hep.dataforge.vis.spatial
 import hep.dataforge.context.Context
 import hep.dataforge.io.Output
 import hep.dataforge.meta.Meta
+import hep.dataforge.meta.get
 import hep.dataforge.vis.DisplayGroup
 import info.laht.threekt.WebGLRenderer
 import info.laht.threekt.cameras.PerspectiveCamera
+import info.laht.threekt.core.BufferGeometry
 import info.laht.threekt.core.Object3D
 import info.laht.threekt.external.controls.OrbitControls
+import info.laht.threekt.extras.curves.CatmullRomCurve3
 import info.laht.threekt.geometries.BoxBufferGeometry
 import info.laht.threekt.lights.AmbientLight
+import info.laht.threekt.materials.LineBasicMaterial
+import info.laht.threekt.materials.MeshBasicMaterial
 import info.laht.threekt.materials.MeshPhongMaterial
 import info.laht.threekt.math.ColorConstants
+import info.laht.threekt.math.Vector3
+import info.laht.threekt.objects.Line
 import info.laht.threekt.objects.Mesh
 import info.laht.threekt.scenes.Scene
+import org.w3c.dom.Element
 import kotlin.browser.window
 
 class ThreeOutput(override val context: Context) : Output<Any> {
@@ -23,28 +31,39 @@ class ThreeOutput(override val context: Context) : Output<Any> {
         setSize(window.innerWidth, window.innerHeight)
     }
 
-    private val scene: Scene = Scene().apply {
+    val scene: Scene = Scene().apply {
         add(AmbientLight())
     }
-    private val camera = PerspectiveCamera(
+
+    val camera = PerspectiveCamera(
         75,
         window.innerWidth.toDouble() / window.innerHeight,
         0.1,
         10000
     ).apply {
-        position.z = 4500.0
+        position.setZ(1000)
     }
 
-    private val controls: OrbitControls = OrbitControls(camera, renderer.domElement)
+    val controls: OrbitControls = OrbitControls(camera, renderer.domElement)
 
-    val root by lazy {
+    val root get() = renderer.domElement
+
+    private fun animate() {
+        window.requestAnimationFrame {
+            animate()
+        }
+        renderer.render(scene, camera)
+    }
+
+    fun start(element: Element) {
         window.addEventListener("resize", {
             camera.aspect = window.innerWidth.toDouble() / window.innerHeight;
             camera.updateProjectionMatrix();
 
             renderer.setSize(window.innerWidth, window.innerHeight)
         }, false)
-        renderer.domElement
+        element.appendChild(root)
+        animate()
     }
 
 
@@ -65,12 +84,10 @@ class ThreeOutput(override val context: Context) : Output<Any> {
                         this.translateZ(obj.z)
                     }
                     is Box -> {
+                        //TODO add bindings
                         val geometry = BoxBufferGeometry(obj.xSize, obj.ySize, obj.zSize)
                             .translate(obj.x, obj.y, obj.z)
-                        val material = MeshPhongMaterial().apply {
+                        Mesh(geometry, obj.properties["color"].material())
-                            this.color.set(ColorConstants.darkgreen)
-                        }
-                        Mesh(geometry, material)
                     }
                     else -> {
                         logger.error { "No renderer defined for ${obj::class}" }
@@ -90,9 +107,9 @@ class ThreeOutput(override val context: Context) : Output<Any> {
         buildNode(obj)?.let { scene.add(it) }
     }
 
-    //    init {
+//    init {
 //        val cube: Mesh
-
+//
 //        cube = Mesh(
 //            BoxBufferGeometry(1, 1, 1),
 //            MeshPhongMaterial().apply {
@@ -125,16 +142,6 @@ class ThreeOutput(override val context: Context) : Output<Any> {
 //
 //        // Create the final object to add to the scene
 //        Line(geometry, material).apply(scene::add)
-
-//    }
-
-//    fun animate() {
-//        window.requestAnimationFrame {
-//            cube.rotation.x += 0.01
-//            cube.rotation.y += 0.01
-//            animate()
-//        }
-//        renderer.render(scene, camera)
 //    }
 
 }

dataforge-vis/dataforge-vis-spatial/build.gradle.kts

@@ -4,26 +4,7 @@ plugins {
 
 kotlin {
     jvm()
-    js {
+    js()
-        configure(listOf(compilations["main"], compilations["test"])) {
-            tasks.getByName(compileKotlinTaskName) {
-                kotlinOptions {
-                    metaInfo = true
-                    sourceMap = true
-                    sourceMapEmbedSources = "always"
-                    moduleKind = "umd"
-                }
-            }
-        }
-
-        configure(listOf(compilations["main"])) {
-            tasks.getByName(compileKotlinTaskName) {
-                kotlinOptions {
-                    main = "call"
-                }
-            }
-        }
-    }
 
     sourceSets {
         val commonMain by getting {