Add new landmarks renderers

build.gradle.kts

@@ -3,7 +3,7 @@ import org.gradle.internal.os.OperatingSystem
 
 plugins {
     kotlin("jvm") version "1.7.20"
-    id("org.openjfx.javafxplugin") version "0.0.10"
+    id("org.openjfx.javafxplugin") version "0.0.14"
     id("org.jlleitschuh.gradle.ktlint") version "11.3.2"
     id("application")
     application

src/main/kotlin/solve/constants/ResourcesPaths.kt

@@ -30,8 +30,16 @@ const val IconsGrid = "/icons/sidepanel/Grid.png"
 const val IconsGridSelected = "/icons/sidepanel/GridSelected.png"
 
 // Engine shaders.
-const val ShadersDefaultVertexPath = "engine/shaders/default/default.vert"
-const val ShadersDefaultFragmentPath = "engine/shaders/default/default.frag"
+const val ShadersDefaultVertexPath = "engine/shaders/default/sprite.vert"
+const val ShadersDefaultFragmentPath = "engine/shaders/default/sprite.frag"
 const val ShadersFrameVertexPath = "engine/shaders/frame/frame.vert"
 const val ShadersFrameGeometryPath = "engine/shaders/frame/frame.geom"
 const val ShadersFrameFragmentPath = "engine/shaders/frame/frame.frag"
+const val ShadersPointLandmarkVertexPath = "engine/shaders/landmark/point/point.vert"
+const val ShadersPointLandmarkFragmentPath = "engine/shaders/landmark/point/point.frag"
+const val ShadersLineLandmarkVertexPath = "engine/shaders/landmark/line/line.vert"
+const val ShadersLineLandmarkFragmentPath = "engine/shaders/landmark/line/line.frag"
+const val ShadersPlaneLandmarkVertexPath = "engine/shaders/landmark/plane/plane.vert"
+const val ShadersPlaneLandmarkFragmentPath = "engine/shaders/landmark/plane/plane.frag"
+const val ShadersPointAssociationVertexPath = "engine/shaders/association/point/point.vert"
+const val ShadersPointAssociationFragmentPath = "engine/shaders/association/point/point.frag"

src/main/kotlin/solve/main/splitpane/SidePanelSplitPane.kt

@@ -21,10 +21,10 @@ class SidePanelSplitPane(
         }
 
         if (location == SidePanelLocation.Left && !isLeftSidePanelHidden) {
-            items.removeFirst()
+            items.removeAt(0)
             isLeftSidePanelHidden = true
         } else if (location == SidePanelLocation.Right && !isRightSidePanelHidden) {
-            items.removeLast()
+            items.removeAt(items.count() - 1)
             isRightSidePanelHidden = true
         } else {
             return

src/main/kotlin/solve/parsers/factories/PlaneFactory.kt

@@ -14,7 +14,6 @@ object PlaneFactory : LandmarkFactory<StoragePlane, ScenePlane, PlaneLayerSettin
     ): ScenePlane = ScenePlane(
         storageFormatLandmark.uid,
         containingLayerSettings,
-        containingLayerState,
-        storageFormatLandmark.points
+        containingLayerState
     )
 }

src/main/kotlin/solve/parsers/planes/ImagePlanesParser.kt

@@ -28,37 +28,6 @@ object ImagePlanesParser : Parser<Plane> {
     const val ColorBitsNumber = 8
     const val BackgroundColor = 0
 
-    private fun convertSeparateToWholeRGB(r: UByte, g: UByte, b: UByte): Int =
-        (r.toInt() shl ColorBitsNumber * 2) + (g.toInt() shl ColorBitsNumber) + b.toInt()
-
-    private fun getPlanePixelColor(
-        pixelIndex: Int,
-        imageByteDataArray: ByteArray,
-        segmentsType: ColorSegmentsType
-    ): Int {
-        val segmentsByteOffset = segmentsType.segmentsByteOffset
-
-        return convertSeparateToWholeRGB(
-            imageByteDataArray[pixelIndex + segmentsByteOffset + 2].toUByte(),
-            imageByteDataArray[pixelIndex + segmentsByteOffset + 1].toUByte(),
-            imageByteDataArray[pixelIndex + segmentsByteOffset].toUByte()
-        )
-    }
-
-    private fun getImageByteDataArray(image: BufferedImage) = (image.data.dataBuffer as DataBufferByte).data
-
-    private inline fun BufferedImage.forEachPixelColor(action: (index: Int, color: Int) -> Unit) {
-        val imageByteDataArray = getImageByteDataArray(this)
-        val colorSegmentsType: ColorSegmentsType =
-            ColorSegmentsType.getColorSegmentsType(colorModel.numComponents) ?: return
-        val colorComponentsNumber = colorSegmentsType.colorComponentsNumber
-
-        for (i in imageByteDataArray.indices step colorComponentsNumber) {
-            val pixelColor = getPlanePixelColor(i, imageByteDataArray, colorSegmentsType)
-            action(i / colorComponentsNumber, pixelColor)
-        }
-    }
-
     override fun parse(filePath: String): List<Plane> {
         val bufferedImage = loadBufferedImage(filePath) ?: return emptyList()
 
@@ -75,7 +44,7 @@ object ImagePlanesParser : Parser<Plane> {
             }
         }
 
-        return planePoints.keys.map { Plane(it, planePoints[it] ?: emptyList()) }
+        return planePoints.keys.map { Plane(it) }
     }
 
     override fun extractUIDs(filePath: String): List<Long> {
@@ -92,4 +61,51 @@ object ImagePlanesParser : Parser<Plane> {
 
         return uids.toList()
     }
+
+    fun getPixelColor(filePath: String, pixelPosition: Point): Int? {
+        val bufferedImage = loadBufferedImage(filePath) ?: return null
+
+        return bufferedImage.getPixelColor(pixelPosition)
+    }
+
+    private fun convertSeparateToWholeRGB(r: UByte, g: UByte, b: UByte): Int =
+        (r.toInt() shl ColorBitsNumber * 2) + (g.toInt() shl ColorBitsNumber) + b.toInt()
+
+    private fun getImageByteDataPixelColor(
+        pixelIndex: Int,
+        imageByteDataArray: ByteArray,
+        segmentsType: ColorSegmentsType
+    ): Int {
+        val segmentsByteOffset = segmentsType.segmentsByteOffset
+
+        return convertSeparateToWholeRGB(
+            imageByteDataArray[pixelIndex + segmentsByteOffset + 2].toUByte(),
+            imageByteDataArray[pixelIndex + segmentsByteOffset + 1].toUByte(),
+            imageByteDataArray[pixelIndex + segmentsByteOffset].toUByte()
+        )
+    }
+
+    private fun getImageByteDataArray(image: BufferedImage) = (image.data.dataBuffer as DataBufferByte).data
+
+    private inline fun BufferedImage.forEachPixelColor(action: (index: Int, color: Int) -> Unit) {
+        val imageByteDataArray = getImageByteDataArray(this)
+        val colorSegmentsType: ColorSegmentsType =
+            ColorSegmentsType.getColorSegmentsType(colorModel.numComponents) ?: return
+        val colorComponentsNumber = colorSegmentsType.colorComponentsNumber
+
+        for (i in imageByteDataArray.indices step colorComponentsNumber) {
+            val pixelColor = getImageByteDataPixelColor(i, imageByteDataArray, colorSegmentsType)
+            action(i / colorComponentsNumber, pixelColor)
+        }
+    }
+
+    private fun BufferedImage.getPixelColor(pixelPosition: Point): Int? {
+        val imageByteDataArray = getImageByteDataArray(this)
+        val colorSegmentsType: ColorSegmentsType =
+            ColorSegmentsType.getColorSegmentsType(colorModel.numComponents) ?: return null
+        val colorComponentsNumber = colorSegmentsType.colorComponentsNumber
+        val pixelFirstComponentIndex = (pixelPosition.y * this.width + pixelPosition.x) * colorComponentsNumber
+
+        return getImageByteDataPixelColor(pixelFirstComponentIndex, imageByteDataArray, colorSegmentsType)
+    }
 }

src/main/kotlin/solve/parsers/structures/Plane.kt

@@ -1,5 +1,3 @@
 package solve.parsers.structures
 
-import solve.scene.model.Point
-
-data class Plane(val uid: Long, val points: List<Point>)
+data class Plane(val uid: Long)

src/main/kotlin/solve/rendering/canvas/OpenGLCanvas.kt

@@ -8,16 +8,22 @@ import com.huskerdev.openglfx.events.GLReshapeEvent
 import com.huskerdev.openglfx.lwjgl.LWJGLExecutor
 import org.joml.Vector2i
 import org.lwjgl.opengl.GL.createCapabilities
+import org.lwjgl.opengl.GL11.GL_ALPHA_TEST
+import org.lwjgl.opengl.GL11.GL_BLEND
 import org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT
 import org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT
 import org.lwjgl.opengl.GL11.GL_DEPTH_TEST
 import org.lwjgl.opengl.GL11.GL_LEQUAL
+import org.lwjgl.opengl.GL11.GL_ONE_MINUS_SRC_ALPHA
 import org.lwjgl.opengl.GL11.GL_PROJECTION
+import org.lwjgl.opengl.GL11.GL_SRC_ALPHA
+import org.lwjgl.opengl.GL11.glBlendFunc
 import org.lwjgl.opengl.GL11.glClear
 import org.lwjgl.opengl.GL11.glDepthFunc
 import org.lwjgl.opengl.GL11.glEnable
 import org.lwjgl.opengl.GL11.glLoadIdentity
 import org.lwjgl.opengl.GL11.glMatrixMode
+import org.lwjgl.opengl.GL13.GL_MULTISAMPLE
 import solve.rendering.engine.Window
 import solve.rendering.engine.utils.minus
 import solve.rendering.engine.utils.plus
@@ -33,10 +39,17 @@ abstract class OpenGLCanvas {
         canvas.animator = GLCanvasAnimator(OpenGLCanvasFPS)
     }
 
-    open fun onInit() { }
-
     open fun onDraw(deltaTime: Float) { }
 
+    open fun onInit() {
+        glEnable(GL_ALPHA_TEST)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glEnable(GL_BLEND)
+        glEnable(GL_DEPTH_TEST)
+        glEnable(GL_MULTISAMPLE)
+        glDepthFunc(GL_LEQUAL)
+    }
+
     open fun onDispose() { }
 
     protected fun initializeCanvasEvents() {
@@ -55,8 +68,6 @@ abstract class OpenGLCanvas {
     }
 
     private fun render(event: GLRenderEvent) {
-        glEnable(GL_DEPTH_TEST)
-        glDepthFunc(GL_LEQUAL)
         glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT)
 
         onDraw(event.delta.toFloat())