kscience/visionforge
7
1
Fork 1
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

Working Server server provider.

Browse Source
This commit is contained in:
Alexander Nozik 2020-12-06 19:16:48 +03:00
parent 9b42d4f186
commit a85cd828e6
25 changed files with 409 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
demo/sat-demo/build.gradle.kts
View File

@ -1,24 +1,59 @@
plugins {
id("ru.mipt.npm.mpp")
application
}
val kvisionVersion: String = "3.16.2"
group = "ru.mipt.npm"
//val kvisionVersion: String = "3.16.2"
kscience{
useSerialization{
json()
}
application()
}
val ktorVersion: String by rootProject.extra
kotlin {
afterEvaluate {
val jsBrowserDistribution by tasks.getting
jvm {
withJava()
compilations[org.jetbrains.kotlin.gradle.plugin.KotlinCompilation.Companion.MAIN_COMPILATION_NAME]?.apply {
tasks.getByName<ProcessResources>(processResourcesTaskName) {
dependsOn(jsBrowserDistribution)
afterEvaluate {
from(jsBrowserDistribution)
}
}
}
}
}
sourceSets {
commonMain {
dependencies {
implementation(project(":visionforge-solid"))
}
}
jvmMain {
dependencies {
implementation(project(":visionforge-server"))
}
}
jsMain {
dependencies {
implementation(project(":visionforge-threejs"))
}
}
}
}
}
application {
mainClass.set("ru.mipt.npm.sat.SatServerKt")
}

58
demo/sat-demo/src/jsMain/kotlin/ru/mipt/npm/sat/SatDemoApp.kt
View File

@ -1,34 +1,40 @@
package ru.mipt.npm.sat
import hep.dataforge.Application
import hep.dataforge.context.Global
import hep.dataforge.meta.invoke
import hep.dataforge.startApplication
import hep.dataforge.vision.client.VisionClient
import hep.dataforge.vision.client.fetchAndRenderAllVisions
import hep.dataforge.vision.solid.three.ThreePlugin
import hep.dataforge.vision.solid.three.render
import kotlinx.browser.document
import org.w3c.dom.HTMLElement
import kotlinx.browser.window
private class SatDemoApp : Application {
override fun start(state: Map<String, Any>) {
val element = document.getElementById("canvas") as? HTMLElement
?: error("Element with id 'canvas' not found on page")
val three = Global.plugins.fetch(ThreePlugin)
val sat = visionOfSatellite(
ySegments = 3,
)
three.render(element, sat){
minSize = 500
axes{
size = 500.0
visible = true
}
}
}
}
//private class SatDemoApp : Application {
//
// override fun start(state: Map<String, Any>) {
// val element = document.getElementById("canvas") as? HTMLElement
// ?: error("Element with id 'canvas' not found on page")
// val three = Global.plugins.fetch(ThreePlugin)
//
// val sat = visionOfSatellite(
// ySegments = 3,
// )
// three.render(element, sat){
// minSize = 500
// axes{
// size = 500.0
// visible = true
// }
// }
// }
//
//}
//
//fun main() {
// startApplication(::SatDemoApp)
//}
fun main() {
startApplication(::SatDemoApp)
//Loading three-js renderer
Global.plugins.load(ThreePlugin)
window.onload = {
Global.plugins.fetch(VisionClient).fetchAndRenderAllVisions()
}
}

35
demo/sat-demo/src/jvmMain/kotlin/ru/mipt/npm/sat/satServer.kt Normal file
View File

@ -0,0 +1,35 @@
package ru.mipt.npm.sat
import hep.dataforge.context.Global
import hep.dataforge.names.asName
import hep.dataforge.vision.server.visionModule
import hep.dataforge.vision.solid.SolidManager
import io.ktor.server.cio.CIO
import io.ktor.server.engine.embeddedServer
import io.ktor.util.KtorExperimentalAPI
import kotlinx.html.script
@OptIn(KtorExperimentalAPI::class)
fun main() {
val sat = visionOfSatellite(
ySegments = 3,
)
val context = Global.context("SAT"){
plugin(SolidManager)
}
embeddedServer(CIO, 8080, host = "localhost"){
visionModule(context).apply {
header {
script {
src = "sat-demo.js"
}
}
page {
vision("main".asName(), sat)
}
}
}.start(wait = true)
}

22
playground/build.gradle.kts
View File

@ -12,16 +12,30 @@ repositories{
}
kotlin {
jvm()
js(IR) {
browser {}
browser {
}
binaries.executable()
}
sourceSets {
commonMain {
dependencies {
api(project(":visionforge-solid"))
api(project(":visionforge-gdml"))
api(project(":ui:bootstrap"))
implementation(project(":visionforge-solid"))
implementation(project(":visionforge-gdml"))
}
}
val jsMain by getting{
dependencies {
implementation(project(":ui:bootstrap"))
}
}
val jvmMain by getting{
dependencies {
implementation("com.github.Ricky12Awesome:json-schema-serialization:0.6.6")
}
}
}

20
visionforge-solid/src/jvmMain/kotlin/hep/dataforge/vision/solid/generateSchema.kt → playground/src/jvmMain/kotlin/hep/dataforge/vision/solid/generateSchema.kt
View File

@ -1,4 +1,22 @@
//package hep.dataforge.vision.solid
package hep.dataforge.vision.solid
import com.github.ricky12awesome.jss.encodeToSchema
import kotlinx.serialization.json.Json
fun main() {
val schema = Json {
serializersModule = SolidManager.serializersModuleForSolids
prettyPrintIndent = " "
prettyPrint = true
ignoreUnknownKeys = true
isLenient = true
coerceInputValues = true
encodeDefaults = true
}.encodeToSchema(SolidGroup.serializer(), generateDefinitions = false)
println(schema)
}
//
//import hep.dataforge.meta.JSON_PRETTY
//import kotlinx.serialization.*

1
visionforge-core/src/commonMain/kotlin/hep/dataforge/vision/VisionManager.kt
View File

@ -54,6 +54,7 @@ public class VisionManager(meta: Meta) : AbstractPlugin(meta) {
private val defaultSerialModule: SerializersModule = SerializersModule {
polymorphic(Vision::class) {
default { VisionBase.serializer() }
subclass(VisionBase.serializer())
subclass(VisionGroupBase.serializer())
}

2
visionforge-core/src/commonMain/kotlin/hep/dataforge/vision/html/HtmlOutputScope.kt
View File

@ -63,5 +63,7 @@ public abstract class HtmlOutputScope<R, V : Vision>(
public companion object {
public const val OUTPUT_CLASS: String = "visionforge-output"
public const val OUTPUT_NAME_ATTRIBUTE: String = "data-output-name"
public const val OUTPUT_ENDPOINT_ATTRIBUTE: String = "data-output-endpoint"
public const val DEFAULT_ENDPOINT: String = "."
}
}

43
visionforge-core/src/jsMain/kotlin/hep/dataforge/vision/client/ClientVisionManager.kt
View File

@ -1,43 +0,0 @@
package hep.dataforge.vision.client
import hep.dataforge.context.Context
import hep.dataforge.context.Global
import hep.dataforge.vision.VisionManager
import hep.dataforge.vision.html.HtmlOutputScope
import kotlinx.browser.window
import org.w3c.dom.Element
import org.w3c.dom.get
import org.w3c.dom.url.URL
@JsExport
public class ClientVisionManager {
private val visionForgeContext: Context = Global.context("client") {
plugin(VisionManager)
}
private val visionManager: VisionManager = visionForgeContext.plugins.fetch(VisionManager)
/**
* Up-going tree traversal in search for endpoint attribute
*/
private fun resolveEndpoint(element: Element?): String {
if(element == null) return DEFAULT_ENDPOINT
val attribute = element.attributes[OUTPUT_ENDPOINT_ATTRIBUTE]
return attribute?.value ?: resolveEndpoint(element.parentElement)
}
public fun renderVision(element: Element){
if(!element.classList.contains(HtmlOutputScope.OUTPUT_CLASS)) error("The element $element is not an output element")
val endpoint = URL(resolveEndpoint(element))
window.fetch("$endpoint/vision").then {response->
TODO()
}
}
public companion object {
public const val OUTPUT_ENDPOINT_ATTRIBUTE: String = "data-output-endpoint"
public const val DEFAULT_ENDPOINT: String = ".."
}
}

124
visionforge-core/src/jsMain/kotlin/hep/dataforge/vision/client/VisionClient.kt Normal file
View File

@ -0,0 +1,124 @@
package hep.dataforge.vision.client
import hep.dataforge.context.*
import hep.dataforge.meta.Meta
import hep.dataforge.vision.Vision
import hep.dataforge.vision.VisionManager
import hep.dataforge.vision.html.HtmlOutputScope
import hep.dataforge.vision.html.HtmlOutputScope.Companion.OUTPUT_ENDPOINT_ATTRIBUTE
import hep.dataforge.vision.html.HtmlOutputScope.Companion.OUTPUT_NAME_ATTRIBUTE
import kotlinx.browser.document
import kotlinx.browser.window
import org.w3c.dom.Element
import org.w3c.dom.WebSocket
import org.w3c.dom.asList
import org.w3c.dom.get
import org.w3c.dom.url.URL
import kotlin.reflect.KClass
public class VisionClient : AbstractPlugin() {
override val tag: PluginTag get() = Companion.tag
private val visionManager: VisionManager by require(VisionManager)
/**
* Up-going tree traversal in search for endpoint attribute
*/
private fun resolveEndpoint(element: Element?): String {
if (element == null) return window.location.href
val attribute = element.attributes[OUTPUT_ENDPOINT_ATTRIBUTE]
return attribute?.value ?: resolveEndpoint(element.parentElement)
}
private fun resolveName(element: Element): String? {
val attribute = element.attributes[OUTPUT_NAME_ATTRIBUTE]
return attribute?.value
}
private fun getRenderers() = context.gather<ElementVisionRenderer>(ElementVisionRenderer.TYPE).values
public fun findRendererFor(vision: Vision): ElementVisionRenderer? = getRenderers().maxByOrNull { it.rateVision(vision) }
/**
* Fetch from server and render a vision, described in a given with [HtmlOutputScope.OUTPUT_CLASS] class.
*/
public fun fetchAndRenderVision(element: Element, requestUpdates: Boolean = true) {
val name = resolveName(element) ?: error("The element is not a vision output")
console.info("Found DF output with name $name")
if (!element.classList.contains(HtmlOutputScope.OUTPUT_CLASS)) error("The element $element is not an output element")
val endpoint = resolveEndpoint(element)
console.info("Vision server is resolved to $endpoint")
val fetchUrl = URL(endpoint).apply {
searchParams.append("name", name)
pathname += "/vision"
}
window.fetch(fetchUrl).then { response ->
if (response.ok) {
response.text().then { text ->
val vision = visionManager.jsonFormat.decodeFromString(Vision.serializer(), text)
val renderer = findRendererFor(vision) ?: error("Could nof find renderer for $vision")
renderer.render(element, vision)
if (requestUpdates) {
val wsUrl = URL(endpoint).apply {
pathname += "/ws"
protocol = "ws"
searchParams.append("name", name)
}
val ws = WebSocket(wsUrl.toString()).apply {
onmessage = { messageEvent ->
val stringData: String? = messageEvent.data as? String
if (stringData != null) {
val update = visionManager.jsonFormat.decodeFromString(Vision.serializer(), text)
vision.update(update)
} else {
console.error("WebSocket message data is not a string")
}
}
onopen = {
console.info("WebSocket update channel established for output '$name'")
}
onclose = {
console.info("WebSocket update channel closed for output '$name'")
}
onerror = {
console.error("WebSocket update channel error for output '$name'")
}
}
}
}
} else {
console.error("Failed to fetch initial vision state from $endpoint")
}
}
}
public companion object : PluginFactory<VisionClient> {
override fun invoke(meta: Meta, context: Context): VisionClient = VisionClient()
override val tag: PluginTag = PluginTag(name = "vision.client", group = PluginTag.DATAFORGE_GROUP)
override val type: KClass<out VisionClient> = VisionClient::class
}
}
/**
* Fetch and render visions for all elements with [HtmlOutputScope.OUTPUT_CLASS] class inside given [element].
*/
public fun VisionClient.fetchVisionsInChildren(element: Element, requestUpdates: Boolean = true) {
val elements = element.getElementsByClassName(HtmlOutputScope.OUTPUT_CLASS)
console.info("Finished search for outputs. Found ${elements.length} items")
elements.asList().forEach { child ->
fetchAndRenderVision(child, requestUpdates)
}
}
/**
* Fetch visions from the server for all elements with [HtmlOutputScope.OUTPUT_CLASS] class in the document body
*/
public fun VisionClient.fetchAndRenderAllVisions(requestUpdates: Boolean = true){
val element = document.body ?: error("Document does not have a body")
fetchVisionsInChildren(element, requestUpdates)
}

52
visionforge-core/src/jsMain/kotlin/hep/dataforge/vision/client/elementOutput.kt
View File

@ -1,7 +1,9 @@
package hep.dataforge.vision.client
import hep.dataforge.meta.DFExperimental
import hep.dataforge.names.Name
import hep.dataforge.names.toName
import hep.dataforge.provider.Type
import hep.dataforge.vision.Vision
import hep.dataforge.vision.html.BindingHtmlOutputScope
import hep.dataforge.vision.html.HtmlOutputScope
@ -10,18 +12,38 @@ import kotlinx.browser.document
import kotlinx.html.TagConsumer
import org.w3c.dom.*
public interface ElementVisionRenderer<in V : Vision> {
public fun render(element: Element, vision: V): Unit
}
@Type(ElementVisionRenderer.TYPE)
public interface ElementVisionRenderer {
public fun <V : Vision> Map<String, V>.bind(renderer: ElementVisionRenderer<V>) {
forEach { (id, vision) ->
val element = document.getElementById(id) ?: error("Could not find element with id $id")
renderer.render(element, vision)
/**
* Give a [vision] integer rating based on this renderer capabilities. [ZERO_RATING] or negative values means that this renderer
* can't process a vision. The value of [DEFAULT_RATING] used for default renderer. Specialized renderers could specify
* higher value in order to "steal" rendering job
*/
public fun rateVision(vision: Vision): Int
/**
* Display the [vision] inside a given [element] replacing its current content
*/
public fun render(element: Element, vision: Vision): Unit
public companion object {
public const val TYPE: String = "elementVisionRenderer"
public const val ZERO_RATING: Int = 0
public const val DEFAULT_RATING: Int = 10
}
}
public fun <V : Vision> Element.renderVisions(renderer: ElementVisionRenderer<V>, visionProvider: (Name) -> V?) {
@DFExperimental
public fun Map<String, Vision>.bind(rendererFactory: (Vision) -> ElementVisionRenderer) {
forEach { (id, vision) ->
val element = document.getElementById(id) ?: error("Could not find element with id $id")
rendererFactory(vision).render(element, vision)
}
}
@DFExperimental
public fun Element.renderAllVisions(visionProvider: (Name) -> Vision, rendererFactory: (Vision) -> ElementVisionRenderer) {
val elements = getElementsByClassName(HtmlOutputScope.OUTPUT_CLASS)
elements.asList().forEach { element ->
val name = element.attributes[HtmlOutputScope.OUTPUT_NAME_ATTRIBUTE]?.value
@ -30,21 +52,19 @@ public fun <V : Vision> Element.renderVisions(renderer: ElementVisionRenderer<V>
return@forEach
}
val vision = visionProvider(name.toName())
if (vision == null) {
console.error("Vision with name $name is not resolved")
return@forEach
}
renderer.render(element, vision)
rendererFactory(vision).render(element, vision)
}
}
public fun <V : Vision> Document.renderVisions(renderer: ElementVisionRenderer<V>, visionProvider: (Name) -> V?): Unit {
documentElement?.renderVisions(renderer, visionProvider)
@DFExperimental
public fun Document.renderAllVisions(visionProvider: (Name) -> Vision, rendererFactory: (Vision) -> ElementVisionRenderer): Unit {
documentElement?.renderAllVisions(visionProvider,rendererFactory)
}
@DFExperimental
public fun HtmlVisionFragment<Vision>.renderInDocument(
root: TagConsumer<HTMLElement>,
renderer: ElementVisionRenderer<Vision>,
renderer: ElementVisionRenderer,
): HTMLElement = BindingHtmlOutputScope<HTMLElement, Vision>(root).apply(content).let { scope ->
scope.finalize().apply {
scope.bindings.forEach { (name, vision) ->

139
visionforge-server/src/main/kotlin/hep/dataforge/vision/server/VisionServer.kt
View File

@ -14,6 +14,7 @@ import hep.dataforge.vision.html.*
import hep.dataforge.vision.server.VisionServer.Companion.DEFAULT_PAGE
import io.ktor.application.*
import io.ktor.features.CORS
import io.ktor.features.CallLogging
import io.ktor.html.respondHtml
import io.ktor.http.ContentType
import io.ktor.http.HttpStatusCode
@ -23,7 +24,10 @@ import io.ktor.http.content.static
import io.ktor.http.withCharset
import io.ktor.response.respond
import io.ktor.response.respondText
import io.ktor.routing.*
import io.ktor.routing.application
import io.ktor.routing.get
import io.ktor.routing.route
import io.ktor.routing.routing
import io.ktor.server.engine.ApplicationEngine
import io.ktor.websocket.WebSockets
import io.ktor.websocket.webSocket
@ -34,9 +38,12 @@ import java.awt.Desktop
import java.net.URI
import kotlin.time.milliseconds
/**
* A ktor plugin container with given [routing]
*/
public class VisionServer internal constructor(
private val visionManager: VisionManager,
private val routing: Routing,
private val application: Application,
private val rootRoute: String,
) : Configurable {
override val config: Config = Config()
@ -57,7 +64,7 @@ public class VisionServer internal constructor(
title: String,
headers: List<HtmlFragment>,
): Map<Name, Vision> {
lateinit var result: Map<Name, Vision>
lateinit var visionMap: Map<Name, Vision>
head {
meta {
@ -69,21 +76,26 @@ public class VisionServer internal constructor(
title(title)
}
body {
result = visionFragment(visionFragment)
script {
type = "text/javascript"
val normalizedRoute = if (rootRoute.endsWith("/")) {
rootRoute
} else {
"$rootRoute/"
}
src = TODO()//"${normalizedRoute}js/plotlyConnect.js"
}
// attributes[OUTPUT_ENDPOINT_ATTRIBUTE] = if (rootRoute.endsWith("/")) {
// rootRoute
// } else {
// "$rootRoute/"
// }
//Load the fragment and remember all loaded visions
visionMap = visionFragment(visionFragment)
// //The script runs when all headers already with required libraries are already loaded
// script {
// type = "text/javascript"
//
// val normalizedRoute =
// unsafe {
// //language=JavaScript
// +"fetchAndRenderAllVisions()"
// }
// }
}
return result
return visionMap
}
public fun page(
@ -102,56 +114,50 @@ public class VisionServer internal constructor(
null
}
routing.createRouteFromPath(rootRoute).apply {
route(route) {
//Update websocket
webSocket("ws") {
val name: String = call.request.queryParameters["name"]
?: error("Vision name is not defined in parameters")
application.routing {
route(rootRoute) {
route(route) {
//Update websocket
webSocket("ws") {
val name: String = call.request.queryParameters["name"]
?: error("Vision name is not defined in parameters")
application.log.debug("Opened server socket for $name")
val vision: Vision = visions[name.toName()] ?: error("Plot with id='$name' not registered")
try {
vision.flowChanges(this, updateInterval.milliseconds).collect { update ->
val json = visionManager.encodeToString(update)
outgoing.send(Frame.Text(json))
application.log.debug("Opened server socket for $name")
val vision: Vision = visions[name.toName()] ?: error("Plot with id='$name' not registered")
try {
vision.flowChanges(this, updateInterval.milliseconds).collect { update ->
val json = visionManager.encodeToString(update)
outgoing.send(Frame.Text(json))
}
} catch (ex: Exception) {
application.log.debug("Closed server socket for $name")
}
} catch (ex: Exception) {
application.log.debug("Closed server socket for $name")
}
}
//Plots in their json representation
get("vision") {
val name: String = call.request.queryParameters["name"]
?: error("Vision name is not defined in parameters")
//Plots in their json representation
get("vision") {
val name: String = call.request.queryParameters["name"]
?: error("Vision name is not defined in parameters")
val vision: Vision? = visions[name.toName()]
if (vision == null) {
call.respond(HttpStatusCode.NotFound, "Vision with name '$name' not found")
} else {
call.respondText(
visionManager.encodeToString(vision),
contentType = ContentType.Application.Json,
status = HttpStatusCode.OK
)
}
}
//filled pages
get {
// val origin = call.request.origin
// val url = URLBuilder().apply {
// protocol = URLProtocol.createOrDefault(origin.scheme)
// //workaround for https://github.com/ktorio/ktor/issues/1663
// host = if (origin.host.startsWith("0:")) "[${origin.host}]" else origin.host
// port = origin.port
// encodedPath = origin.uri
// }.build()
if (cachedHtml == null) {
call.respondHtml {
visions.putAll(buildPage(visionFragment, title, headers))
val vision: Vision? = visions[name.toName()]
if (vision == null) {
call.respond(HttpStatusCode.NotFound, "Vision with name '$name' not found")
} else {
call.respondText(
visionManager.encodeToString(vision),
contentType = ContentType.Application.Json,
status = HttpStatusCode.OK
)
}
}
//filled pages
get {
if (cachedHtml == null) {
call.respondHtml {
visions.putAll(buildPage(visionFragment, title, headers))
}
} else {
call.respondText(cachedHtml, ContentType.Text.Html.withCharset(Charsets.UTF_8))
}
} else {
call.respondText(cachedHtml, ContentType.Text.Html.withCharset(Charsets.UTF_8))
}
}
}
@ -160,7 +166,7 @@ public class VisionServer internal constructor(
public fun page(
route: String = DEFAULT_PAGE,
title: String = "Plotly server page '$route'",
title: String = "VisionForge server page '$route'",
headers: List<HtmlFragment> = emptyList(),
content: HtmlOutputScope<*, Vision>.() -> Unit,
) {
@ -170,7 +176,6 @@ public class VisionServer internal constructor(
public companion object {
public const val DEFAULT_PAGE: String = "/"
public val UPDATE_MODE_KEY: Name = "update.mode".toName()
public val UPDATE_INTERVAL_KEY: Name = "update.interval".toName()
}
}
@ -190,8 +195,12 @@ public fun Application.visionModule(context: Context, route: String = DEFAULT_PA
}
}
if(featureOrNull(CallLogging) == null){
install(CallLogging)
}
val routing = routing {
routing {
route(route) {
static {
resources()
@ -201,7 +210,7 @@ public fun Application.visionModule(context: Context, route: String = DEFAULT_PA
val visionManager = context.plugins.fetch(VisionManager)
return VisionServer(visionManager, routing, route)
return VisionServer(visionManager, this, route)
}
public fun ApplicationEngine.show() {

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/Box.kt
View File

@ -12,7 +12,7 @@ public class Box(
public val xSize: Float,
public val ySize: Float,
public val zSize: Float
) : BasicSolid(), GeometrySolid {
) : SolidBase(), GeometrySolid {
//TODO add helper for color configuration
override fun <T : Any> toGeometry(geometryBuilder: GeometryBuilder<T>) {

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/Composite.kt
View File

@ -19,7 +19,7 @@ public class Composite(
public val compositeType: CompositeType,
public val first: Solid,
public val second: Solid
) : BasicSolid(), Solid, VisionGroup {
) : SolidBase(), Solid, VisionGroup {
init {
first.parent = this

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/ConeSegment.kt
View File

@ -18,7 +18,7 @@ public class ConeSegment(
public var upperRadius: Float,
public var startAngle: Float = 0f,
public var angle: Float = PI2
) : BasicSolid(), GeometrySolid {
) : SolidBase(), GeometrySolid {
override fun <T : Any> toGeometry(geometryBuilder: GeometryBuilder<T>) {
val segments = detail ?: 8

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/Convex.kt
View File

@ -7,7 +7,7 @@ import kotlinx.serialization.Serializable
@Serializable
@SerialName("solid.convex")
public class Convex(public val points: List<Point3D>) : BasicSolid(), Solid
public class Convex(public val points: List<Point3D>) : SolidBase(), Solid
public inline fun VisionContainerBuilder<Solid>.convex(name: String = "", action: ConvexBuilder.() -> Unit = {}): Convex =
ConvexBuilder().apply(action).build().also { set(name, it) }

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/Extruded.kt
View File

@ -39,7 +39,7 @@ public data class Layer(var x: Float, var y: Float, var z: Float, var scale: Flo
public class Extruded(
public var shape: List<Point2D> = ArrayList(),
public var layers: MutableList<Layer> = ArrayList()
) : BasicSolid(), GeometrySolid {
) : SolidBase(), GeometrySolid {
public fun shape(block: Shape2DBuilder.() -> Unit) {
this.shape = Shape2DBuilder().apply(block).build()

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/PolyLine.kt
View File

@ -12,7 +12,7 @@ import kotlinx.serialization.Serializable
@Serializable
@SerialName("solid.line")
public class PolyLine(public var points: List<Point3D>) : BasicSolid(), Solid {
public class PolyLine(public var points: List<Point3D>) : SolidBase(), Solid {
//var lineType by string()
public var thickness: Number by props().number(1.0, key = SolidMaterial.MATERIAL_KEY + THICKNESS_KEY)

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/BasicSolid.kt → visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/SolidBase.kt
View File

@ -12,7 +12,7 @@ import kotlinx.serialization.Serializable
@Serializable
@SerialName("solid")
public open class BasicSolid : VisionBase(), Solid {
public open class SolidBase : VisionBase(), Solid {
override val descriptor: NodeDescriptor get() = Solid.descriptor
override var position: Point3D? = null

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/SolidLabel.kt
View File

@ -11,7 +11,7 @@ public class SolidLabel(
public var text: String,
public var fontSize: Double,
public var fontFamily: String,
) : BasicSolid(), Solid
) : SolidBase(), Solid
public fun VisionContainerBuilder<Solid>.label(
text: String,

8
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/SolidManager.kt
View File

@ -7,10 +7,7 @@ import hep.dataforge.context.PluginTag
import hep.dataforge.meta.Meta
import hep.dataforge.names.Name
import hep.dataforge.names.toName
import hep.dataforge.vision.Vision
import hep.dataforge.vision.VisionGroup
import hep.dataforge.vision.VisionGroupBase
import hep.dataforge.vision.VisionManager
import hep.dataforge.vision.*
import hep.dataforge.vision.VisionManager.Companion.VISION_SERIALIZER_MODULE_TARGET
import kotlinx.serialization.json.Json
import kotlinx.serialization.modules.PolymorphicModuleBuilder
@ -42,6 +39,7 @@ public class SolidManager(meta: Meta) : AbstractPlugin(meta) {
subclass(Composite.serializer())
subclass(Tube.serializer())
subclass(Box.serializer())
subclass(ConeSegment.serializer())
subclass(Convex.serializer())
subclass(Extruded.serializer())
subclass(PolyLine.serializer())
@ -51,11 +49,13 @@ public class SolidManager(meta: Meta) : AbstractPlugin(meta) {
public val serializersModuleForSolids: SerializersModule = SerializersModule {
polymorphic(Vision::class) {
subclass(VisionBase.serializer())
subclass(VisionGroupBase.serializer())
solids()
}
polymorphic(Solid::class) {
default { SolidBase.serializer() }
solids()
}
}

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/SolidReference.kt
View File

@ -9,7 +9,7 @@ import kotlinx.serialization.Serializable
import kotlinx.serialization.Transient
import kotlin.collections.set
public abstract class AbstractReference : BasicSolid(), VisionGroup {
public abstract class AbstractReference : SolidBase(), VisionGroup {
public abstract val prototype: Solid
override fun getProperty(name: Name, inherit: Boolean): MetaItem<*>? = sequence {

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/Sphere.kt
View File

@ -16,7 +16,7 @@ public class Sphere(
public var phi: Float = PI2,
public var thetaStart: Float = 0f,
public var theta: Float = PI.toFloat(),
) : BasicSolid(), GeometrySolid {
) : SolidBase(), GeometrySolid {
override fun <T : Any> toGeometry(geometryBuilder: GeometryBuilder<T>) {
fun point3DfromSphCoord(r: Float, theta: Float, phi: Float): Point3D {

2
visionforge-solid/src/commonMain/kotlin/hep/dataforge/vision/solid/Tube.kt
View File

@ -19,7 +19,7 @@ public class Tube(
public var innerRadius: Float = 0f,
public var startAngle: Float = 0f,
public var angle: Float = PI2,
) : BasicSolid(), GeometrySolid {
) : SolidBase(), GeometrySolid {
init {
require(radius > 0)

17
visionforge-threejs/src/main/kotlin/hep/dataforge/vision/solid/three/ThreePlugin.kt
View File

@ -15,7 +15,7 @@ import kotlin.collections.set
import kotlin.reflect.KClass
import info.laht.threekt.objects.Group as ThreeGroup
public class ThreePlugin : AbstractPlugin(), ElementVisionRenderer<Solid> {
public class ThreePlugin : AbstractPlugin(), ElementVisionRenderer {
override val tag: PluginTag get() = Companion.tag
public val solidManager: SolidManager by require(SolidManager)
@ -122,8 +122,19 @@ public class ThreePlugin : AbstractPlugin(), ElementVisionRenderer<Solid> {
attach(element)
}
override fun render(element: Element, vision: Solid) {
createCanvas(element).render(vision)
override fun content(target: String): Map<Name, Any> {
return when (target) {
ElementVisionRenderer.TYPE -> mapOf("three".asName() to this)
else -> super.content(target)
}
}
override fun rateVision(vision: Vision): Int {
return if (vision is Solid) ElementVisionRenderer.DEFAULT_RATING else ElementVisionRenderer.ZERO_RATING
}
override fun render(element: Element, vision: Vision) {
createCanvas(element).render(vision as? Solid ?: error("Only solids are rendered"))
}
public companion object : PluginFactory<ThreePlugin> {

4
visionforge-threejs/src/main/kotlin/hep/dataforge/vision/solid/three/ThreeVision.kt
View File

@ -1,11 +1,11 @@
package hep.dataforge.vision.solid.three
import hep.dataforge.vision.solid.BasicSolid
import hep.dataforge.vision.solid.SolidBase
import info.laht.threekt.core.Object3D
/**
* A custom visual object that has its own Three.js renderer
*/
public abstract class ThreeVision : BasicSolid() {
public abstract class ThreeVision : SolidBase() {
public abstract fun render(): Object3D
}