fixing plane renderer bugs

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

@@ -39,3 +39,5 @@ const val ShadersPointLandmarkVertexPath = "engine/shaders/landmark/point/point.
 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"

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

@@ -13,7 +13,10 @@ 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
@@ -35,15 +38,10 @@ abstract class OpenGLCanvas {
         canvas.animator = GLCanvasAnimator(OpenGLCanvasFPS)
     }
 
-    open fun onInit() {
-        glEnable(GL_BLEND)
-        glEnable(GL_DEPTH_TEST)
-        glEnable(GL_MULTISAMPLE)
-        glDepthFunc(GL_LEQUAL)
-    }
-
     open fun onDraw(deltaTime: Float) { }
 
+    open fun onInit() { }
+
     open fun onDispose() { }
 
     protected fun initializeCanvasEvents() {
@@ -57,10 +55,15 @@ abstract class OpenGLCanvas {
     private fun canvasInit(event: GLInitializeEvent) {
         window = Window(canvas.width.toInt(), canvas.height.toInt())
         createCapabilities()
+
         onInit()
     }
 
     private fun render(event: GLRenderEvent) {
+        glEnable(GL_BLEND)
+        glEnable(GL_DEPTH_TEST)
+        glDepthFunc(GL_LEQUAL)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
         glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT)
 
         onDraw(event.delta.toFloat())

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

@@ -4,6 +4,7 @@ import org.joml.Vector2f
 import org.joml.Vector2i
 import solve.rendering.engine.core.renderers.FramesRenderer
 import solve.rendering.engine.core.renderers.LinesLayerRenderer
+import solve.rendering.engine.core.renderers.PlanesLayerRenderer
 import solve.rendering.engine.core.renderers.PointsLayerRenderer
 import solve.rendering.engine.utils.minus
 import solve.rendering.engine.utils.times
@@ -119,9 +120,7 @@ class SceneCanvas : OpenGLCanvas() {
         val scene = this.scene ?: return
 
         scene.layers.forEach { layer ->
-            if (layer is Layer.PointLayer || layer is Layer.LineLayer) {
-                addLandmarkRenderer(layer, scene)
-            }
+            addLandmarkRenderer(layer, scene)
         }
         canvasScene?.landmarkRenderers?.forEach {
             it.setNewGridWidth(sceneController?.installedColumnsNumber ?: SceneController.MaxColumnsNumber)
@@ -131,9 +130,9 @@ class SceneCanvas : OpenGLCanvas() {
 
     private fun addLandmarkRenderer(layer: Layer, scene: Scene) {
         val addingRenderer = when (layer) {
-            is Layer.PointLayer -> PointsLayerRenderer(window)
-            is Layer.LineLayer -> LinesLayerRenderer(window)
-            is Layer.PlaneLayer -> TODO()
+            is Layer.PointLayer -> PointsLayerRenderer(window) { sceneController?.scene }
+            is Layer.LineLayer -> LinesLayerRenderer(window) { sceneController?.scene }
+            is Layer.PlaneLayer -> PlanesLayerRenderer(window) { sceneController?.scene }
         }
         addingRenderer.setNewSceneFrames(scene.frames, framesSize.toFloatVector())
         canvasScene?.addLandmarkRenderer(addingRenderer, layer)

src/main/kotlin/solve/rendering/engine/core/batch/RenderBatch.kt

@@ -3,6 +3,8 @@ package solve.rendering.engine.core.batch
 import org.joml.Vector2f
 import org.joml.Vector3f
 import org.joml.Vector4f
+import org.lwjgl.opengl.GL11
+import org.lwjgl.opengl.GL13
 import org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER
 import org.lwjgl.opengl.GL15.GL_DYNAMIC_DRAW
 import org.lwjgl.opengl.GL15.GL_ELEMENT_ARRAY_BUFFER
@@ -11,6 +13,7 @@ import org.lwjgl.opengl.GL15.glBindBuffer
 import org.lwjgl.opengl.GL15.glBufferData
 import org.lwjgl.opengl.GL15.glBufferSubData
 import org.lwjgl.opengl.GL15.glDeleteBuffers
+import org.lwjgl.opengl.GL15.glDeleteTextures
 import org.lwjgl.opengl.GL15.glGenBuffers
 import org.lwjgl.opengl.GL20.glDisableVertexAttribArray
 import org.lwjgl.opengl.GL20.glEnableVertexAttribArray
@@ -66,7 +69,6 @@ open class RenderBatch(
 
     fun unbind() {
         attributes.forEachIndexed { index, _ -> glDisableVertexAttribArray(index) }
-        textures.forEach { it.unbind() }
         glBindVertexArray(0)
     }
 

src/main/kotlin/solve/rendering/engine/core/renderers/LandmarkLayerRenderer.kt

@@ -4,14 +4,16 @@ import org.joml.Vector2f
 import solve.rendering.engine.Window
 import solve.rendering.engine.utils.plus
 import solve.scene.model.Layer
+import solve.scene.model.Scene
 import solve.scene.model.VisualizationFrame
 
 abstract class LandmarkLayerRenderer(
-    window: Window
+    window: Window,
+    protected val getScene: () -> Scene?
 ) : Renderer(window) {
-    private var gridWidth = FramesRenderer.DefaultGridWidth
-    private var framesSize = Vector2f()
-    private var framesRatio: Float = 1f
+    protected var gridWidth = FramesRenderer.DefaultGridWidth
+    protected var framesSize = Vector2f()
+    protected var framesRatio: Float = 1f
 
     abstract fun setFramesSelectionLayers(layers: List<Layer>)
 
@@ -29,13 +31,15 @@ abstract class LandmarkLayerRenderer(
         this.gridWidth = gridWidth
     }
 
-    protected fun framePixelToShaderPosition(frameIndex: Int, framePixelPosition: Vector2f): Vector2f {
+    protected fun getFrameTopLeftShaderPosition(frameIndex: Int) = Vector2f(
+        (frameIndex % gridWidth).toFloat() * framesRatio,
+        (frameIndex / gridWidth).toFloat()
+    )
+
+    protected fun getFramePixelShaderPosition(frameIndex: Int, framePixelPosition: Vector2f): Vector2f {
         val frameRelativePosition = Vector2f(framePixelPosition) / framesSize.y
-        val previousFramesVector = Vector2f(
-            (frameIndex % gridWidth).toFloat() * framesRatio,
-            (frameIndex / gridWidth).toFloat()
-        )
+        val frameTopLeftPosition = getFrameTopLeftShaderPosition(frameIndex)
 
-        return previousFramesVector + frameRelativePosition
+        return frameTopLeftPosition + frameRelativePosition
     }
 }

src/main/kotlin/solve/rendering/engine/core/renderers/LinesLayerRenderer.kt

@@ -16,10 +16,12 @@ import solve.rendering.engine.utils.times
 import solve.scene.model.Landmark
 import solve.scene.model.Layer
 import solve.scene.model.Layer.LineLayer
+import solve.scene.model.Scene
 
 class LinesLayerRenderer(
-    window: Window
-) : LandmarkLayerRenderer(window) {
+    window: Window,
+    getScene: () -> Scene?
+) : LandmarkLayerRenderer(window, getScene) {
     private var lineLayers = emptyList<LineLayer>()
     private var lineLayersLandmarks = emptyList<List<Landmark.Line>>()
 
@@ -74,8 +76,8 @@ class LinesLayerRenderer(
                     lineLandmark.finishCoordinate.x.toFloat(),
                     lineLandmark.finishCoordinate.y.toFloat()
                 )
-                val lineStartShaderPosition = framePixelToShaderPosition(linesLayerIndex, lineStartPosition)
-                val lineFinishShaderPosition = framePixelToShaderPosition(linesLayerIndex, lineFinishPosition)
+                val lineStartShaderPosition = getFramePixelShaderPosition(linesLayerIndex, lineStartPosition)
+                val lineFinishShaderPosition = getFramePixelShaderPosition(linesLayerIndex, lineFinishPosition)
                 val lineVector = lineFinishShaderPosition - lineStartShaderPosition
                 val normalVector = Vector2f(-lineVector.y, lineVector.x).normalize()
                 val linePoints = listOf(lineStartShaderPosition, lineFinishShaderPosition)

src/main/kotlin/solve/rendering/engine/core/renderers/PlanesLayerRenderer.kt

@@ -1,46 +1,49 @@
 package solve.rendering.engine.core.renderers
 
 import org.joml.Vector2f
-import org.joml.Vector3f
-import solve.constants.ShadersLineLandmarkFragmentPath
-import solve.constants.ShadersLineLandmarkVertexPath
+import solve.constants.ShadersPlaneLandmarkFragmentPath
+import solve.constants.ShadersPlaneLandmarkVertexPath
 import solve.rendering.engine.Window
 import solve.rendering.engine.core.batch.PrimitiveType
 import solve.rendering.engine.core.batch.RenderBatch
+import solve.rendering.engine.core.texture.Texture
+import solve.rendering.engine.core.texture.Texture2D
 import solve.rendering.engine.shader.ShaderAttributeType
 import solve.rendering.engine.shader.ShaderProgram
 import solve.rendering.engine.shader.ShaderType
-import solve.rendering.engine.utils.minus
 import solve.rendering.engine.utils.plus
-import solve.rendering.engine.utils.times
-import solve.scene.model.Landmark
 import solve.scene.model.Layer
-import solve.scene.model.Layer.LineLayer
+import solve.scene.model.Layer.PlaneLayer
+import solve.scene.model.Scene
 
 class PlanesLayerRenderer(
-    window: Window
-) : LandmarkLayerRenderer(window) {
-    private var lineLayers = emptyList<LineLayer>()
-    private var lineLayersLandmarks = emptyList<List<Landmark.Line>>()
+    window: Window,
+    getScene: () -> Scene?
+) : LandmarkLayerRenderer(window, getScene) {
+    private var planeLayers = emptyList<PlaneLayer>()
+    private var planeLayersTextures = emptyList<Texture2D>()
 
     override val maxBatchSize = 1000
 
+    private var needToInitializePlaneTextures = false
+
     override fun setFramesSelectionLayers(layers: List<Layer>) {
-        lineLayers = layers.filterIsInstance<LineLayer>()
-        lineLayersLandmarks = lineLayers.map { it.getLandmarks() }
+        planeLayers = layers.filterIsInstance<PlaneLayer>()
+        needToInitializePlaneTextures = true
     }
 
     override fun createShaderProgram(): ShaderProgram {
         val shaderProgram = ShaderProgram()
-        shaderProgram.addShader(ShadersLineLandmarkVertexPath, ShaderType.VERTEX)
-        shaderProgram.addShader(ShadersLineLandmarkFragmentPath, ShaderType.FRAGMENT)
+        shaderProgram.addShader(ShadersPlaneLandmarkVertexPath, ShaderType.VERTEX)
+        shaderProgram.addShader(ShadersPlaneLandmarkFragmentPath, ShaderType.FRAGMENT)
         shaderProgram.link()
 
         return shaderProgram
     }
 
     override fun createNewBatch(zIndex: Int): RenderBatch {
         val shaderAttributesTypes = listOf(
+            ShaderAttributeType.FLOAT2,
             ShaderAttributeType.FLOAT2,
             ShaderAttributeType.FLOAT
         )
@@ -55,75 +58,46 @@ class PlanesLayerRenderer(
 
     override fun uploadUniforms(shaderProgram: ShaderProgram) {
         shaderProgram.uploadMatrix4f(ProjectionUniformName, window.calculateProjectionMatrix())
-        shaderProgram.uploadInt(UseCommonColorUniformName, if (useCommonColor()) 1 else 0)
-        shaderProgram.uploadVector3f(CommonColorUniformName, getLinesColor())
     }
 
-    override fun updateBatchesData() {
-        val linesWidth = getLinesWidth()
+    override fun beforeRender() {
 
-        lineLayersLandmarks.forEachIndexed { linesLayerIndex, linesLayerLandmarks ->
-            linesLayerLandmarks.forEachIndexed { lineLandmarkIndex, lineLandmark ->
-                val batch = getAvailableBatch(null, 0)
-
-                val lineStartPosition = Vector2f(
-                    lineLandmark.startCoordinate.x.toFloat(),
-                    lineLandmark.startCoordinate.y.toFloat()
-                )
-                val lineFinishPosition = Vector2f(
-                    lineLandmark.finishCoordinate.x.toFloat(),
-                    lineLandmark.finishCoordinate.y.toFloat()
-                )
-                val lineStartShaderPosition = framePixelToShaderPosition(linesLayerIndex, lineStartPosition)
-                val lineFinishShaderPosition = framePixelToShaderPosition(linesLayerIndex, lineFinishPosition)
-                val lineVector = lineFinishShaderPosition - lineStartShaderPosition
-                val normalVector = Vector2f(-lineVector.y, lineVector.x).normalize()
-                val linePoints = listOf(lineStartShaderPosition, lineFinishShaderPosition)
+    }
 
-                linePoints.forEachIndexed { sideIndex, linePoint ->
-                    val pointToVertexVector = Vector2f(normalVector) *
-                        linesWidth / window.camera.zoom / DefaultLocalVerticesPositionsDivider
+    override fun updateBatchesData() {
+        if (needToInitializePlaneTextures) {
+            planeLayersTextures = planeLayers.map { Texture2D(it.filePath.toString()) }
+            needToInitializePlaneTextures = false
+        }
 
-                    val upperVertexPosition = linePoint + pointToVertexVector
-                    val bottomVertexPosition = linePoint - pointToVertexVector
-                    val firstVertexPosition = if (sideIndex == 0) upperVertexPosition else bottomVertexPosition
-                    val secondVertexPosition = if (sideIndex == 0) bottomVertexPosition else upperVertexPosition
-                    batch.pushVector2f(firstVertexPosition)
-                    batch.pushFloat(lineLandmarkIndex.toFloat())
-                    batch.pushVector2f(secondVertexPosition)
-                    batch.pushFloat(lineLandmarkIndex.toFloat())
-                }
+        planeLayers.forEachIndexed { planeLayerIndex, planeLayer ->
+            val planeLayerTexture = planeLayersTextures[planeLayerIndex]
+            //val layerIndex = getScene()?.indexOf(planeLayer.settings) ?: return@forEachIndexed
+            val batch = getAvailableBatch(planeLayerTexture, 0)
+            val textureID = batch.getTextureLocalID(planeLayerTexture)
+            val topLeftFrameShaderPosition = getFrameTopLeftShaderPosition(planeLayerIndex)
+            textureLocalVerticesPositions.forEachIndexed { localVertexIndex, localVertexPosition ->
+                val q = Vector2f(localVertexPosition)
+                if (planeLayer.name.contains("alg1"))
+                    q.mul(0.5f)
+                else
+                    q.mul(0.8f)
+                val scaledLocalVertexPosition = Vector2f(q.x * framesRatio, q.y)
+                val vertexShaderPosition = topLeftFrameShaderPosition + scaledLocalVertexPosition
+                batch.pushVector2f(vertexShaderPosition)
+                batch.pushVector2f(Texture.defaultUVCoordinates[localVertexIndex])
+                batch.pushFloat(textureID.toFloat())
             }
         }
     }
-
-    private fun getLinesColor(): Vector3f {
-        val pointsCommonColor = lineLayers.firstOrNull()?.settings?.commonColor ?: return Vector3f(1f, 0f, 0f)
-
-        return Vector3f(
-            pointsCommonColor.red.toFloat(),
-            pointsCommonColor.green.toFloat(),
-            pointsCommonColor.blue.toFloat()
-        )
-    }
-
-    private fun getLinesWidth(): Float {
-        return lineLayers.firstOrNull()?.settings?.selectedWidth?.toFloat() ?: return 1f
-    }
-
-    private fun useCommonColor(): Boolean {
-        return lineLayers.firstOrNull()?.settings?.useCommonColor ?: false
-    }
-
-    private fun getLineWidth(): Float {
-        return lineLayers.firstOrNull()?.settings?.selectedWidth?.toFloat() ?: return 1f
-    }
-
     companion object {
         private const val ProjectionUniformName = "uProjection"
-        private const val UseCommonColorUniformName = "uUseCommonColor"
-        private const val CommonColorUniformName = "uCommonColor"
 
-        private const val DefaultLocalVerticesPositionsDivider = 800f
+        private val textureLocalVerticesPositions = listOf(
+            Vector2f(0.0f, 1.0f),
+            Vector2f(0.0f, 0.0f),
+            Vector2f(1.0f, 0.0f),
+            Vector2f(1.0f, 1.0f)
+        )
     }
 }

src/main/kotlin/solve/rendering/engine/core/renderers/PointsLayerRenderer.kt

@@ -15,10 +15,12 @@ import solve.rendering.engine.utils.times
 import solve.scene.model.Landmark
 import solve.scene.model.Layer
 import solve.scene.model.Layer.PointLayer
+import solve.scene.model.Scene
 
 class PointsLayerRenderer(
-    window: Window
-) : LandmarkLayerRenderer(window) {
+    window: Window,
+    getScene: () -> Scene?
+) : LandmarkLayerRenderer(window, getScene) {
     private var pointLayers = emptyList<PointLayer>()
     private var pointLayersLandmarks = emptyList<List<Landmark.Keypoint>>()
 
@@ -70,7 +72,7 @@ class PointsLayerRenderer(
                     pointLandmark.coordinate.x.toFloat(),
                     pointLandmark.coordinate.y.toFloat()
                 )
-                val pointShaderPosition = framePixelToShaderPosition(pointsLayerIndex, pointLandmarkPosition)
+                val pointShaderPosition = getFramePixelShaderPosition(pointsLayerIndex, pointLandmarkPosition)
 
                 circleBoundsVerticesLocalPositions.forEach { vertexLocalPosition ->
                     val vertexPosition = pointShaderPosition + Vector2f(vertexLocalPosition) *

src/main/kotlin/solve/rendering/engine/core/renderers/Renderer.kt

@@ -13,8 +13,8 @@ abstract class Renderer(protected val window: Window) {
     protected abstract val maxBatchSize: Int
 
     protected var needToRebuffer = true
-    private lateinit var shaderProgram: ShaderProgram
-    private val batches = mutableListOf<RenderBatch>()
+    protected lateinit var shaderProgram: ShaderProgram
+    protected val batches = mutableListOf<RenderBatch>()
 
     init {
         initialize()