CappedTwistFixture.kt

    fun cappedTwistGltf(): String {
        val positions = FloatArray(VERTEX_COUNT * 3)
        val normals = FloatArray(VERTEX_COUNT * 3)
        val joints = ByteArray(VERTEX_COUNT * 4)
        val weights = FloatArray(VERTEX_COUNT * 4)

        fun put(i: Int, x: Float, y: Float, z: Float, nx: Float, ny: Float, nz: Float, upper: Float) {
            positions[i * 3] = x; positions[i * 3 + 1] = y; positions[i * 3 + 2] = z
            normals[i * 3] = nx; normals[i * 3 + 1] = ny; normals[i * 3 + 2] = nz
            // joint 0 = boneLower, joint 1 = boneUpper; slots 2 and 3 unused.
            joints[i * 4] = 0; joints[i * 4 + 1] = 1
            weights[i * 4] = 1f - upper; weights[i * 4 + 1] = upper
        }

        for (ring in 0 until RINGS) {
            val y = ring * RING_SPACING
            val upper = RiggedFixture.upperWeight(y)
            for (k in 0 until SEGMENTS) {
                val theta = 2.0 * Math.PI * k / SEGMENTS
                val cx = Math.cos(theta).toFloat()
                val cz = Math.sin(theta).toFloat()
                put(ring * SEGMENTS + k, RADIUS * cx, y, RADIUS * cz, cx, 0f, cz, upper)
            }
        }
        val bottom = SEGMENTS * RINGS
        val top = bottom + 1
        put(bottom, 0f, 0f, 0f, 0f, -1f, 0f, RiggedFixture.upperWeight(0f))
        put(top, 0f, HEIGHT, 0f, 0f, 1f, 0f, RiggedFixture.upperWeight(HEIGHT))

        val indices = ShortArray(TRIANGLE_COUNT * 3)
        var t = 0
        fun tri(a: Int, b: Int, c: Int) {
            indices[t++] = a.toShort(); indices[t++] = b.toShort(); indices[t++] = c.toShort()
        }
        for (ring in 0 until RINGS - 1) {
            for (k in 0 until SEGMENTS) {
                val a = ring * SEGMENTS + k
                val b = ring * SEGMENTS + (k + 1) % SEGMENTS
                val c = (ring + 1) * SEGMENTS + k
                val d = (ring + 1) * SEGMENTS + (k + 1) % SEGMENTS
                // The same outward winding as RiggedFixture's side wall.
                tri(a, c, d); tri(a, d, b)
            }
        }
        val last = (RINGS - 1) * SEGMENTS
        for (k in 0 until SEGMENTS) {
            val k1 = (k + 1) % SEGMENTS
            // (centre, P_k, P_k+1) has normal P_k × P_k+1, whose y is sin(θ_k − θ_k+1) < 0: outward
            // for the bottom cap. The top cap is the same fan wound the other way.
            tri(bottom, k, k1)
            tri(top, last + k1, last + k)
        }

        val inverseBind = floatArrayOf(
            1f, 0f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 0f, 1f,
            1f, 0f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 0f, 1f, 0f, 0f, -UPPER_JOINT_Y, 0f, 1f,
        )

        val times = floatArrayOf(0f, 1f)
        fun yQuat(degrees: Double): FloatArray {
            val half = Math.toRadians(degrees) / 2.0
            return floatArrayOf(0f, Math.sin(half).toFloat(), 0f, Math.cos(half).toFloat())
        }
        // Key 0 is the exact identity quaternion; key 1 is the half-turn about +y.
        val twistUpper = yQuat(0.0) + yQuat(MAX_TWIST_DEGREES.toDouble())

        val views = ArrayList<IntArray>()
        val bytes = java.io.ByteArrayOutputStream()
        fun view(block: (ByteBuffer) -> Unit, length: Int): Int {
            while (bytes.size() % 4 != 0) bytes.write(0)
            val offset = bytes.size()
            val b = ByteBuffer.allocate(length).order(ByteOrder.LITTLE_ENDIAN)
            block(b)
            bytes.write(b.array())
            views += intArrayOf(offset, length)
            return views.size - 1
        }
        fun floats(v: FloatArray) = view({ b -> v.forEach(b::putFloat) }, v.size * 4)
        fun shorts(v: ShortArray) = view({ b -> v.forEach(b::putShort) }, v.size * 2)
        fun raw(v: ByteArray) = view({ b -> b.put(v) }, v.size)

        val vPos = floats(positions)
        val vNrm = floats(normals)
        val vJnt = raw(joints)
        val vWgt = floats(weights)
        val vIdx = shorts(indices)
        val vIbm = floats(inverseBind)
        val vTime = floats(times)
        val vTwist = floats(twistUpper)

        val base64 = Base64.getEncoder().encodeToString(bytes.toByteArray())
        val bufferViews = views.joinToString(",\n   ") { (o, l) ->
            """{"buffer": 0, "byteOffset": $o, "byteLength": $l}"""
        }

        return """
        {
         "asset": {"version": "2.0", "generator": "afield.graphics.scene.CappedTwistFixture"},
         "scene": 0,
         "scenes": [{"nodes": [0, 1]}],
         "nodes": [
          {"name": "tube",      "mesh": 0, "skin": 0},
          {"name": "armature",  "children": [2]},
          {"name": "boneLower", "children": [3]},
          {"name": "boneUpper", "translation": [0.0, $UPPER_JOINT_Y, 0.0]}
         ],
         "skins": [
          {"name": "twoBone", "skeleton": 2, "joints": [2, 3], "inverseBindMatrices": $vIbm}
         ],
         "meshes": [{"name": "tube", "primitives": [
           {"attributes": {"POSITION": $vPos, "NORMAL": $vNrm, "JOINTS_0": $vJnt, "WEIGHTS_0": $vWgt},
            "indices": $vIdx, "mode": 4}]}],
         "animations": [
          {"name": "twist",
           "samplers": [{"input": $vTime, "output": $vTwist, "interpolation": "LINEAR"}],
           "channels": [{"sampler": 0, "target": {"node": 3, "path": "rotation"}}]}
         ],
         "accessors": [
          {"bufferView": $vPos, "componentType": 5126, "count": $VERTEX_COUNT, "type": "VEC3",
           "min": [${-RADIUS}, 0.0, ${-RADIUS}], "max": [$RADIUS, $HEIGHT, $RADIUS]},
          {"bufferView": $vNrm, "componentType": 5126, "count": $VERTEX_COUNT, "type": "VEC3"},
          {"bufferView": $vJnt, "componentType": 5121, "count": $VERTEX_COUNT, "type": "VEC4"},
          {"bufferView": $vWgt, "componentType": 5126, "count": $VERTEX_COUNT, "type": "VEC4"},
          {"bufferView": $vIdx, "componentType": 5123, "count": ${TRIANGLE_COUNT * 3}, "type": "SCALAR"},
          {"bufferView": $vIbm, "componentType": 5126, "count": 2, "type": "MAT4"},
          {"bufferView": $vTime, "componentType": 5126, "count": ${times.size}, "type": "SCALAR",
           "min": [${times.first()}], "max": [${times.last()}]},
          {"bufferView": $vTwist, "componentType": 5126, "count": ${times.size}, "type": "VEC4"}
         ],
         "bufferViews": [
          $bufferViews
         ],
         "buffers": [{"byteLength": ${bytes.size()},
                      "uri": "data:application/octet-stream;base64,$base64"}]
        }
        """.trimIndent() + "\n"
    }