bufferOf

Author: elect86

build.gradle

@@ -16,7 +16,7 @@ ext{
     kotlin = 'org.jetbrains.kotlin:kotlin'
     kotlin_version = '1.3.11'
     kotlintest_version = '3.1.11'
-    gln_version = '63d26807879c3519744f5aae7a059e3ca40a894a'
+    gln_version = '42256d1618525ea96a91848ec21bcbe15cdeba29'
     vkk_version = 'a0d037b48e'
     lwjgl_version = "3.2.1"
     lwjgl_natives = current() == WINDOWS ? "windows" : current() == LINUX ? "linux" : "macos"

src/main/kotlin/uno/buffer/of.kt

@@ -2,14 +2,14 @@ package uno.buffer
 
 import glm_.BYTES
 import glm_.b
-import glm_.i
 import glm_.vec2.Vec2
 import glm_.vec2.Vec2i
 import glm_.vec3.Vec3
 import glm_.vec3.Vec3i
 import glm_.vec4.Vec4
 import glm_.vec4.Vec4b
 import glm_.vec4.Vec4i
+import glm_.vec4.Vec4ub
 import gln.glf.Vertex
 import gln.glf.glf
 import kool.Buffer
@@ -60,66 +60,55 @@ fun bufferOf(vertices: Collection<*>): ByteBuffer {
     return res
 }
 
-fun bufferOf(vararg vertices: Any): ByteBuffer {
-    val res: ByteBuffer
-    when (vertices.elementAt(0)) {
-        is Float -> {
-            res = Buffer(Float.BYTES * vertices.size)
-            for (i in 0 until vertices.size)
-                res.putFloat(i * Float.BYTES, (vertices[i] as Float))
-        }
-        is Int -> {
-            res = Buffer(Int.BYTES * vertices.size)
-            for (i in 0 until vertices.size)
-                res.putInt(i * Int.BYTES, (vertices[i] as Int))
-        }
-        is Vec2 -> {
-            res = Buffer(Vec2.size * vertices.size)
-            for (i in 0 until vertices.size)
-                (vertices[i] as Vec2).to(res, i * Vec2.size)
-        }
-        is Vec3 -> {
-            res = Buffer(Vec3.size * vertices.size)
-            for (i in 0 until vertices.size)
-                (vertices[i] as Vec3).to(res, i * Vec3.size)
-        }
-        is Vec4 -> {
-            res = Buffer(Vec4.size * vertices.size)
-            for (i in 0 until vertices.size)
-                (vertices[i] as Vec4).to(res, i * Vec4.size)
-        }
-        is Vec4b -> {
-            res = Buffer(Vec4b.size * vertices.size)
-            for (i in 0 until vertices.size)
-                (vertices[i] as Vec4b).to(res, i * Vec4b.size)
+fun bufferOf(vararg elements: Any): ByteBuffer {
+    val size = elements.sumBy {
+        when (it) {
+            is Float, Int, Vec4b -> Float.BYTES
+            is Vec2 -> Vec2.size
+            is Vec3 -> Vec3.size
+            is Vec4 -> Vec4.size
+            is Vertex.pos2_tc2 -> Vec2.size * 2
+            is Vertex.pos3_col4ub -> Vec3.size + Vec4ub.size
+            is Vertex.pos3_nor3_col4 -> Vec3.size * 2 + Vec4.size
+            else -> throw Exception("Invalid")
         }
-        is Vertex.pos2_tc2 -> {
-            res = Buffer(glf.pos2_tc2.stride * vertices.size)
-            for (i in 0 until vertices.size) {
-                val v = vertices.elementAt(i) as Vertex.pos2_tc2
-                v.p.to(res, i * glf.pos2_tc2.stride)
-                v.t.to(res, i * glf.pos2_tc2.stride + Vec2.size)
+    }
+    val res = Buffer(size)
+    var offset = 0
+    for (e in elements)
+        when (e) {
+            is Float -> {
+                res.putFloat(offset, e)
+                offset += Float.BYTES
             }
-        }
-        is Vertex.pos3_col4ub -> {
-            res = Buffer(glf.pos3_col4ub.stride * vertices.size)
-            for (i in 0 until vertices.size) {
-                val v = vertices.elementAt(i) as Vertex.pos3_col4ub
-                v.p.to(res, i * glf.pos3_col4ub.stride)
-                v.c.to(res, i * glf.pos3_col4ub.stride + Vec3.size)
+            is Int -> {
+                res.putInt(offset, e)
+                offset += Int.BYTES
             }
-        }
-        is Vertex.pos3_nor3_col4 -> {
-            res = Buffer(glf.pos3_nor3_col4.stride * vertices.size)
-            for (i in 0 until vertices.size) {
-                val v = vertices.elementAt(i) as Vertex.pos3_nor3_col4
-                v.p.to(res, i * glf.pos3_nor3_col4.stride)
-                v.n.to(res, i * glf.pos3_nor3_col4.stride + Vec3.size)
-                v.c.to(res, i * glf.pos3_nor3_col4.stride + Vec3.size * 2)
+            is Vec4b -> {
+                e.to(res, offset)
+                offset += Vec4b.size
             }
+            is Vec2 -> {
+                e.to(res, offset)
+                offset += Vec2.size
+            }
+            is Vec3 -> {
+                e.to(res, offset)
+                offset += Vec3.size
+            }
+            is Vec4 -> {
+                e.to(res, offset)
+                offset += Vec4.size
+            }
+//            is Vertex.pos2_tc2 -> {
+//                e.to(res, offset)
+//                offset += Vec4b.size
+//            }
+//            is Vertex.pos3_col4ub -> Vec3.size + Vec4ub.size
+//            is Vertex.pos3_nor3_col4 -> Vec3.size * 2 + Vec4.size
+            else -> throw Exception("Invalid")
         }
-        else -> throw Error()
-    }
     return res
 }