Draw call batching for Paths

worldwind/src/commonMain/kotlin/earth/worldwind/WorldWind.kt

@@ -118,6 +118,7 @@ open class WorldWind @JvmOverloads constructor(
     private val scratchProjection = Matrix4()
     private val scratchPoint = Vec3()
     private val scratchRay = Line()
+    private var frameIndex = 0L
 
     init {
         // Initialize default camera location based on user time zone
@@ -444,6 +445,7 @@ open class WorldWind @JvmOverloads constructor(
         )
         rc.renderResourceCache = renderResourceCache
         rc.verticalExaggeration = verticalExaggeration
+        rc.frameIndex = frameIndex
         rc.densityFactor = densityFactor
         rc.atmosphereAltitude = atmosphereAltitude
         rc.globeState = globe.state
@@ -494,6 +496,8 @@ open class WorldWind @JvmOverloads constructor(
         // Reset the render context's state in preparation for the next frame.
         rc.reset()
 
+        ++frameIndex
+
         return isRedrawRequested
     }
 

worldwind/src/commonMain/kotlin/earth/worldwind/draw/DrawShapeState.kt

@@ -5,16 +5,15 @@ import earth.worldwind.geom.Vec3
 import earth.worldwind.render.Color
 import earth.worldwind.render.Texture
 import earth.worldwind.render.buffer.AbstractBufferObject
-import earth.worldwind.render.buffer.FloatBufferObject
 import earth.worldwind.render.program.TriangleShaderProgram
+import earth.worldwind.render.VertexState
 
 open class DrawShapeState internal constructor() {
     companion object {
         const val MAX_DRAW_ELEMENTS = 4
     }
 
     var program: TriangleShaderProgram? = null
-    var vertexBuffer: FloatBufferObject? = null
     var elementBuffer: AbstractBufferObject? = null
     val vertexOrigin = Vec3()
     var vertexStride = 0
@@ -23,32 +22,34 @@ open class DrawShapeState internal constructor() {
     var enableDepthWrite = true
     var depthOffset = 0.0
     var isLine = false
+    var isStatic = false
+    val vertexState = VertexState()
+    var pickIdOffset = 0
     protected val color = Color()
     protected var opacity = 1.0f
     protected var lineWidth = 1f
     protected var texture: Texture? = null
     protected val texCoordMatrix = Matrix3()
-    private val texCoordAttrib = VertexAttrib()
     internal var primCount = 0
     internal val prims = Array(MAX_DRAW_ELEMENTS) { DrawElements() }
 
     open fun reset() {
         program = null
-        vertexBuffer = null
+        vertexState.reset()
         elementBuffer = null
         vertexOrigin.set(0.0, 0.0, 0.0)
         vertexStride = 0
         enableCullFace = true
         enableDepthTest = true
         isLine = false
+        isStatic = false
         depthOffset = 0.0
         color.set(1f, 1f, 1f, 1f)
+        pickIdOffset = 0
         opacity = 1.0f
         lineWidth = 1f
         texture = null
         texCoordMatrix.setToIdentity()
-        texCoordAttrib.size = 0
-        texCoordAttrib.offset = 0
         primCount = 0
         for (idx in 0 until MAX_DRAW_ELEMENTS) prims[idx].texture = null
     }
@@ -63,11 +64,6 @@ open class DrawShapeState internal constructor() {
 
     fun texCoordMatrix(matrix: Matrix3) = apply { texCoordMatrix.copy(matrix) }
 
-    fun texCoordAttrib(size: Int, offset: Int) = apply {
-        texCoordAttrib.size = size
-        texCoordAttrib.offset = offset
-    }
-
     open fun drawElements(mode: Int, count: Int, type: Int, offset: Int) {
         val prim = prims[primCount++]
         prim.mode = mode
@@ -79,8 +75,6 @@ open class DrawShapeState internal constructor() {
         prim.lineWidth = lineWidth
         prim.texture = texture
         prim.texCoordMatrix.copy(texCoordMatrix)
-        prim.texCoordAttrib.size = texCoordAttrib.size
-        prim.texCoordAttrib.offset = texCoordAttrib.offset
     }
 
     internal open class DrawElements {
@@ -93,11 +87,5 @@ open class DrawShapeState internal constructor() {
         var lineWidth = 0f
         var texture: Texture? = null
         val texCoordMatrix = Matrix3()
-        val texCoordAttrib = VertexAttrib()
-    }
-
-    internal open class VertexAttrib {
-        var size = 0
-        var offset = 0
     }
 }

worldwind/src/commonMain/kotlin/earth/worldwind/draw/DrawableLines.kt

@@ -53,8 +53,9 @@ open class DrawableLines protected constructor(): Drawable {
         // Disable texturing.
         program.enableTexture(false)
 
-        // Ensure program is in triangles mode
-        program.enableOneVertexMode(false)
+        // Ensure program is in lines mode
+        program.enableLinesMode(true)
+        program.enableVertexColorAndWidth(false)
 
         // Use the leader's color.
         program.loadColor(color)
@@ -75,8 +76,8 @@ open class DrawableLines protected constructor(): Drawable {
         if (!enableDepthTest) dc.gl.disable(GL_DEPTH_TEST)
 
         // Use the leader line as the vertex point attribute.
-        dc.gl.enableVertexAttribArray(1 /*value*/)
-        dc.gl.enableVertexAttribArray(2 /*value*/)
+        dc.gl.enableVertexAttribArray(1 /*pointB*/)
+        dc.gl.enableVertexAttribArray(2 /*pointC*/)
 
         // Use the shape's vertex point attribute and vertex texture coordinate attribute.
         dc.gl.vertexAttribPointer(0 /*pointA*/, 4, GL_FLOAT, false, 20, offset + 0)
@@ -89,7 +90,7 @@ open class DrawableLines protected constructor(): Drawable {
         // Restore the default WorldWind OpenGL state.
         if (!enableDepthTest) dc.gl.enable(GL_DEPTH_TEST)
 
-        dc.gl.disableVertexAttribArray(1 /*value*/)
-        dc.gl.disableVertexAttribArray(2 /*value*/)
+        dc.gl.disableVertexAttribArray(1 /*pointB*/)
+        dc.gl.disableVertexAttribArray(2 /*pointC*/)
     }
 }

worldwind/src/commonMain/kotlin/earth/worldwind/draw/DrawableShape.kt

@@ -4,7 +4,9 @@ import earth.worldwind.geom.Matrix4
 import earth.worldwind.util.Pool
 import earth.worldwind.util.kgl.GL_CULL_FACE
 import earth.worldwind.util.kgl.GL_DEPTH_TEST
-import earth.worldwind.util.kgl.GL_FLOAT
+import earth.worldwind.util.kgl.GL_LINES
+import earth.worldwind.util.kgl.GL_LINE_LOOP
+import earth.worldwind.util.kgl.GL_LINE_STRIP
 import earth.worldwind.util.kgl.GL_TEXTURE0
 import kotlin.jvm.JvmStatic
 
@@ -32,7 +34,7 @@ open class DrawableShape protected constructor(): Drawable {
         // TODO shape batching
         val program = drawState.program ?: return // program unspecified
         if (!program.useProgram(dc)) return // program failed to build
-        if (drawState.vertexBuffer?.bindBuffer(dc) != true) return  // vertex buffer unspecified or failed to bind
+        if (!drawState.vertexState.bind(dc)) return
         if (drawState.elementBuffer?.bindBuffer(dc) != true) return  // element buffer unspecified or failed to bind
 
         // Use the draw context's pick mode.
@@ -51,6 +53,7 @@ open class DrawableShape protected constructor(): Drawable {
             drawState.vertexOrigin.z
         )
         program.loadModelviewProjection(mvpMatrix)
+        program.loadPickIdOffset(drawState.pickIdOffset)
 
         // Disable triangle back face culling if requested.
         if (!drawState.enableCullFace) dc.gl.disable(GL_CULL_FACE)
@@ -64,48 +67,30 @@ open class DrawableShape protected constructor(): Drawable {
         // Make multi-texture unit 0 active.
         dc.activeTextureUnit(GL_TEXTURE0)
 
-        // Use the shape's vertex point attribute and vertex texture coordinate attribute.
-        dc.gl.enableVertexAttribArray(1 /*vertexTexCoord*/)
-        dc.gl.enableVertexAttribArray(2 /*vertexTexCoord*/)
-        dc.gl.enableVertexAttribArray(3 /*vertexTexCoord*/)
+        program.enableLinesMode(drawState.isLine)
+        program.enableVertexColorAndWidth(drawState.isStatic)
+        if (drawState.isLine) program.loadScreen(
+            dc.viewport.width.toFloat(),
+            dc.viewport.height.toFloat()
+        )
 
-        if (drawState.isLine) {
-            program.enableOneVertexMode(false)
-            program.loadScreen(dc.viewport.width.toFloat(), dc.viewport.height.toFloat())
-            dc.gl.vertexAttribPointer(0 /*pointA*/, 4, GL_FLOAT, false, 20, 0)
-            dc.gl.vertexAttribPointer(1 /*pointB*/, 4, GL_FLOAT, false, 20, 40)
-            dc.gl.vertexAttribPointer(2 /*pointC*/, 4, GL_FLOAT, false, 20, 80)
-            dc.gl.vertexAttribPointer(3 /*texCoord*/, 1, GL_FLOAT, false, 20, 56)
-        } else {
-            program.enableOneVertexMode(true)
-            dc.gl.vertexAttribPointer(0 /*vertexPoint*/, 3, GL_FLOAT, false, drawState.vertexStride, 0)
-            dc.gl.vertexAttribPointer(1 /*vertexPoint*/, 3, GL_FLOAT, false, drawState.vertexStride, 0)
-            dc.gl.vertexAttribPointer(2 /*vertexPoint*/, 3, GL_FLOAT, false, drawState.vertexStride, 0)
-        }
         // Draw the specified primitives.
         for (idx in 0 until drawState.primCount) {
             val prim = drawState.prims[idx]
-            program.loadColor(prim.color)
             program.loadOpacity(prim.opacity)
+            if (!drawState.isStatic) {
+                program.loadColor(prim.color)
+                program.loadLineWidth(prim.lineWidth)
+            }
             if (prim.texture?.bindTexture(dc) == true) {
                 program.loadTexCoordMatrix(prim.texCoordMatrix)
                 program.enableTexture(true)
             } else {
                 program.enableTexture(false)
             }
-            if (drawState.isLine) {
-                program.loadLineWidth(prim.lineWidth)
-            } else {
-                dc.gl.vertexAttribPointer(
-                    3 /*vertexTexCoord*/,
-                    prim.texCoordAttrib.size,
-                    GL_FLOAT,
-                    false,
-                    drawState.vertexStride,
-                    prim.texCoordAttrib.offset
-                )
-                dc.gl.lineWidth(prim.lineWidth)
-            }
+            if (prim.mode == GL_LINES || prim.mode == GL_LINE_STRIP || prim.mode == GL_LINE_LOOP) dc.gl.lineWidth(
+                prim.lineWidth
+            )
             dc.gl.drawElements(prim.mode, prim.count, prim.type, prim.offset)
         }
 
@@ -115,8 +100,6 @@ open class DrawableShape protected constructor(): Drawable {
         if (!drawState.enableDepthWrite) dc.gl.depthMask(true)
         dc.gl.lineWidth(1f)
         dc.gl.enable(GL_CULL_FACE)
-        dc.gl.disableVertexAttribArray(1 /*vertexTexCoord*/)
-        dc.gl.disableVertexAttribArray(2 /*vertexTexCoord*/)
-        dc.gl.disableVertexAttribArray(3 /*vertexTexCoord*/)
+        drawState.vertexState.unbind(dc)
     }
 }

worldwind/src/commonMain/kotlin/earth/worldwind/draw/DrawableSurfaceShape.kt

@@ -42,11 +42,6 @@ open class DrawableSurfaceShape protected constructor(): Drawable {
         // Make multi-texture unit 0 active.
         dc.activeTextureUnit(GL_TEXTURE0)
 
-        // Set up to use vertex tex coord attributes.
-        dc.gl.enableVertexAttribArray(1 /*vertexTexCoord*/)
-        dc.gl.enableVertexAttribArray(2 /*vertexTexCoord*/)
-        dc.gl.enableVertexAttribArray(3 /*vertexTexCoord*/)
-
         // Accumulate shapes in the draw context's scratch list.
         // TODO accumulate in a geospatial quadtree
         val scratchList = dc.scratchList
@@ -75,10 +70,6 @@ open class DrawableSurfaceShape protected constructor(): Drawable {
         } finally {
             // Clear the accumulated shapes.
             scratchList.clear()
-            // Restore the default WorldWind OpenGL state.
-            dc.gl.disableVertexAttribArray(1 /*vertexTexCoord*/)
-            dc.gl.disableVertexAttribArray(2 /*vertexTexCoord*/)
-            dc.gl.disableVertexAttribArray(3 /*vertexTexCoord*/)
         }
     }
 
@@ -124,9 +115,16 @@ open class DrawableSurfaceShape protected constructor(): Drawable {
                 // Get the shape.
                 val shape = element as DrawableSurfaceShape
                 if (shape.offset != terrain.offset || !shape.sector.intersectsOrNextTo(terrainSector)) continue
-                if (shape.drawState.vertexBuffer?.bindBuffer(dc) != true) continue  // vertex buffer unspecified or failed to bind
+                if (!shape.drawState.vertexState.bind(dc)) continue
                 if (shape.drawState.elementBuffer?.bindBuffer(dc) != true) continue  // element buffer unspecified or failed to bind
 
+                program.enableLinesMode(shape.drawState.isLine)
+                program.enableVertexColorAndWidth(shape.drawState.isStatic)
+                if (shape.drawState.isLine) program.loadScreen(
+                    colorAttachment.width.toFloat(),
+                    colorAttachment.height.toFloat()
+                )
+
                 // Transform local shape coordinates to texture fragments appropriate for the terrain sector.
                 mvpMatrix.copy(textureMvpMatrix)
                 mvpMatrix.multiplyByTranslation(
@@ -135,51 +133,32 @@ open class DrawableSurfaceShape protected constructor(): Drawable {
                     shape.drawState.vertexOrigin.z
                 )
                 program.loadModelviewProjection(mvpMatrix)
-                if (shape.drawState.isLine) {
-                    program.enableOneVertexMode(false)
-                    program.loadScreen(colorAttachment.width.toFloat(), colorAttachment.height.toFloat())
-
-                    dc.gl.vertexAttribPointer(0 /*pointA*/, 4, GL_FLOAT, false, 20, 0)
-                    dc.gl.vertexAttribPointer(1 /*pointB*/, 4, GL_FLOAT, false, 20, 40)
-                    dc.gl.vertexAttribPointer(2 /*pointC*/, 4, GL_FLOAT, false, 20, 80)
-                    dc.gl.vertexAttribPointer(3 /*vertexTexCoord*/, 1, GL_FLOAT, false, 20, 56)
-                } else {
-                    program.enableOneVertexMode(true)
-
-                    // Use the shape's vertex point attribute.
-                    dc.gl.vertexAttribPointer(0 /*vertexPoint*/, 3, GL_FLOAT, false, shape.drawState.vertexStride, 0)
-                    dc.gl.vertexAttribPointer(1 /*vertexPoint*/, 3, GL_FLOAT, false, shape.drawState.vertexStride, 0)
-                    dc.gl.vertexAttribPointer(2 /*vertexPoint*/, 3, GL_FLOAT, false, shape.drawState.vertexStride, 0)
-                }
+                program.loadPickIdOffset(shape.drawState.pickIdOffset)
+
                 // Draw the specified primitives to the framebuffer texture.
                 for (primIdx in 0 until shape.drawState.primCount) {
                     val prim = shape.drawState.prims[primIdx]
-                    program.loadColor(prim.color)
                     program.loadOpacity(prim.opacity)
+                    if (!drawState.isStatic) {
+                        program.loadColor(prim.color)
+                        program.loadLineWidth(prim.lineWidth)
+                    }
                     if (prim.texture?.bindTexture(dc) == true) {
                         program.loadTexCoordMatrix(prim.texCoordMatrix)
                         program.enableTexture(true)
                     } else {
                         program.enableTexture(false)
                     }
-                    if (shape.drawState.isLine) {
-                        program.loadLineWidth(prim.lineWidth)
-                    } else {
-                        dc.gl.vertexAttribPointer(
-                            3 /*vertexTexCoord*/,
-                            prim.texCoordAttrib.size,
-                            GL_FLOAT,
-                            false,
-                            shape.drawState.vertexStride,
-                            prim.texCoordAttrib.offset
-                        )
-                        dc.gl.lineWidth(prim.lineWidth)
-                    }
+                    if (prim.mode == GL_LINES || prim.mode == GL_LINE_STRIP || prim.mode == GL_LINE_LOOP) dc.gl.lineWidth(
+                        prim.lineWidth
+                    )
                     dc.gl.drawElements(prim.mode, prim.count, prim.type, prim.offset)
                 }
 
                 // Accumulate the number of shapes drawn into the texture.
                 shapeCount++
+
+                shape.drawState.vertexState.unbind(dc)
             }
         } finally {
             // Restore the default WorldWind OpenGL state.
@@ -194,22 +173,24 @@ open class DrawableSurfaceShape protected constructor(): Drawable {
     protected open fun drawTextureToTerrain(dc: DrawContext, terrain: DrawableTerrain) {
         val program = drawState.program ?: return
         try {
+            dc.gl.enableVertexAttribArray(3 /*vertexTexCoord*/)
             if (!terrain.useVertexPointAttrib(dc, 0 /*vertexPoint*/)) return // terrain vertex attribute failed to bind
-            if (!terrain.useVertexPointAttrib(dc, 1 /*vertexPoint*/)) return // terrain vertex attribute failed to bind
-            if (!terrain.useVertexPointAttrib(dc, 2 /*vertexPoint*/)) return // terrain vertex attribute failed to bind
             if (!terrain.useVertexTexCoordAttrib(dc, 3 /*vertexTexCoord*/)) return // terrain vertex attribute failed to bind
+
             val colorAttachment = dc.scratchFramebuffer.getAttachedTexture(GL_COLOR_ATTACHMENT0)
             if (!colorAttachment.bindTexture(dc)) return  // framebuffer texture failed to bind
 
             // Configure the program to draw texture fragments unmodified and aligned with the terrain.
             // TODO consolidate pickMode and enableTexture into a single textureMode
             // TODO it's confusing that pickMode must be disabled during surface shape render-to-texture
-            program.enableOneVertexMode(true)
+            program.enableLinesMode(false)
+            program.enableVertexColorAndWidth(false)
             program.enablePickMode(false)
             program.enableTexture(true)
             program.loadTexCoordMatrix(identityMatrix3)
             program.loadColor(color)
             program.loadOpacity(opacity)
+            program.loadPickIdOffset(0)
 
             // Use the draw context's modelview projection matrix, transformed to terrain local coordinates.
             val terrainOrigin = terrain.vertexOrigin
@@ -220,6 +201,7 @@ open class DrawableSurfaceShape protected constructor(): Drawable {
             // Draw the terrain as triangles.
             terrain.drawTriangles(dc)
         } finally {
+            dc.gl.disableVertexAttribArray(3 /*vertexTexCoord*/)
             // Unbind color attachment texture to avoid feedback loop
             dc.bindTexture(KglTexture.NONE)
         }