[orx-mesh, orx-obj-loader] Separate into commonMain and jvmMain

2024-09-16 22:12:48 +02:00
parent 8bccf54447
commit ed55899230
20 changed files with 425 additions and 86 deletions
--- a/orx-obj-loader/src/commonMain/kotlin/ObjReader.kt
+++ b/orx-obj-loader/src/commonMain/kotlin/ObjReader.kt
@@ -0,0 +1,112 @@
+package org.openrndr.extra.objloader
+
+import org.openrndr.color.ColorRGBa
+import org.openrndr.draw.VertexBuffer
+import org.openrndr.math.Vector2
+import org.openrndr.math.Vector3
+
+fun readObjMeshData(lines: Iterable<String>): CompoundMeshData {
+    val meshes = mutableMapOf<String, List<IndexedPolygon>>()
+    val positions = mutableListOf<Vector3>()
+    val normals = mutableListOf<Vector3>()
+    val tangents = mutableListOf<Vector3>()
+    val bitangents = mutableListOf<Vector3>()
+    val textureCoords = mutableListOf<Vector2>()
+    val colors = mutableListOf<ColorRGBa>()
+    var activeMesh = mutableListOf<IndexedPolygon>()
+
+    lines.forEach { line ->
+        if (line.isNotEmpty()) {
+            val tokens = line.split(Regex("[ |\t]+")).map { it.trim() }.filter { it.isNotEmpty() }
+
+            if (tokens.isNotEmpty()) {
+                when (tokens[0]) {
+                    "v" -> {
+                        when (tokens.size) {
+                            3, 4 -> {
+                                positions += Vector3(tokens[1].toDouble(), tokens[2].toDouble(), tokens[3].toDouble())
+                            }
+
+                            6 -> {
+                                positions += Vector3(tokens[1].toDouble(), tokens[2].toDouble(), tokens[3].toDouble())
+                                colors += ColorRGBa(tokens[4].toDouble(), tokens[5].toDouble(), tokens[6].toDouble())
+                            }
+
+                            7 -> {
+                                positions += Vector3(tokens[1].toDouble(), tokens[2].toDouble(), tokens[3].toDouble())
+                                colors += ColorRGBa(
+                                    tokens[4].toDouble(),
+                                    tokens[5].toDouble(),
+                                    tokens[6].toDouble(),
+                                    tokens[7].toDouble()
+                                )
+                            }
+
+                            else -> error("vertex has ${tokens.size - 1} components, loader only supports 3/4/6/7 components")
+                        }
+                    }
+
+                    "vn" -> {
+                        when (tokens.size) {
+                            3, 4 -> normals += Vector3(tokens[1].toDouble(), tokens[2].toDouble(), tokens[3].toDouble())
+                            9 -> {
+                                normals += Vector3(tokens[1].toDouble(), tokens[2].toDouble(), tokens[3].toDouble())
+                                tangents += Vector3(tokens[4].toDouble(), tokens[5].toDouble(), tokens[6].toDouble())
+                                bitangents += Vector3(tokens[7].toDouble(), tokens[8].toDouble(), tokens[9].toDouble())
+                            }
+
+                        }
+                    }
+
+                    "vt" -> textureCoords += Vector2(tokens[1].toDouble(), tokens[2].toDouble())
+                    "g" -> {
+                        activeMesh = mutableListOf()
+                        meshes[tokens.getOrNull(1) ?: "no-name-${meshes.size}"] = activeMesh
+                    }
+
+                    "f" -> {
+                        val indices = tokens.subList(1, tokens.size).map { it.split("/") }.map {
+                            it.map { it.toIntOrNull() ?: 0 }
+                        }
+                        val hasPosition = (indices[0].getOrNull(0) ?: 0) != 0
+                        val hasUV = (indices[0].getOrNull(1) ?: 0) != 0
+                        val hasNormal = (indices[0].getOrNull(2) ?: 0) != 0
+                        val hasColor = colors.isNotEmpty()
+                        val hasTangents = tangents.isNotEmpty()
+                        val hasBitangents = bitangents.isNotEmpty()
+
+                        activeMesh.add(
+                            IndexedPolygon(
+                                if (hasPosition) indices.map { it[0] - 1 } else listOf(),
+                                if (hasUV) indices.map { it[1] - 1 } else listOf(),
+                                if (hasNormal) indices.map { it[2] - 1 } else listOf(),
+                                if (hasColor) indices.map { it[0] - 1 } else listOf(),
+                                if (hasTangents) indices.map { it[2] - 1 } else listOf(),
+                                if (hasBitangents) indices.map { it[2] - 1 } else listOf()
+                            )
+                        )
+
+                        if (meshes.isEmpty()) {
+                            meshes["no-name"] = activeMesh
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    val vertexData = VertexData(positions, normals, textureCoords, colors)
+    return CompoundMeshData(
+        vertexData,
+        meshes.mapValues {
+            MeshData(vertexData, it.value)
+        }
+    )
+}
+
+fun loadOBJasVertexBuffer(lines: List<String>): VertexBuffer {
+    return readObjMeshData(lines).toVertexBuffer()
+}
+
+fun loadOBJ(lines: List<String>): Map<String, List<IPolygon>> = readObjMeshData(lines).triangulate().toPolygons()
+