Implement md2 model animation (VAT) #117 [DRAFT]

assets/shaders/vat.glsl

@@ -1,24 +1,22 @@
-#version 130 // required by gl_VertexID
-
-attribute vec2 a_texCoord1; // Texture coordinates
+attribute float a_vat_index;
+attribute vec2 a_texCoord1; // Diffuse Texture coordinates
 
 uniform mat4 u_worldTrans; // World transformation matrix
 uniform mat4 u_projViewTrans; // View transformation matrix
 
 uniform sampler2D u_vertexAnimationTexture; // Texture containing animated vertex positions (float texture)
-uniform float u_textureHeight; // Height of the vertex texture (number of animation frames)
-uniform float u_textureWidth; // Width of the vertex texture (number of vertices)
-uniform float u_frame1; // Index of the first frame in the animation texture
-uniform float u_frame2; // Index of the second frame in the animation texture
+uniform int u_textureHeight; // Height of the vertex texture (number of animation frames)
+uniform int u_textureWidth; // Width of the vertex texture (number of vertices)
+uniform int u_frame1; // Index of the first frame in the animation texture
+uniform int u_frame2; // Index of the second frame in the animation texture
 uniform float u_interpolation; // Interpolation factor between two animation frames (0.0 to 1.0)
 
-varying vec2 v_texCoord;
+varying vec2 v_diffuseUV;
 
 void main() {
-    float index = float(gl_VertexID);
     vec2 texelSize = vec2(1.0 / u_textureWidth, 1.0 / u_textureHeight);
-    vec2 vertexTextureCoord1 = vec2((index + 0.5) * texelSize.x, (u_frame1 + 0.5) * texelSize.y);
-    vec2 vertexTextureCoord2 = vec2((index + 0.5) * texelSize.x, (u_frame2 + 0.5) * texelSize.y);
+    vec2 vertexTextureCoord1 = vec2((a_vat_index + 0.5) * texelSize.x, (u_frame1 + 0.5) * texelSize.y);
+    vec2 vertexTextureCoord2 = vec2((a_vat_index + 0.5) * texelSize.x, (u_frame2 + 0.5) * texelSize.y);
 
     // Sample the vertex texture to get the animated positions for the two frames
     // The texture stores vec3 positions in RGB channels (assuming float texture)
@@ -30,5 +28,5 @@ void main() {
 
     // Apply the final interpolated position
     gl_Position = u_projViewTrans * u_worldTrans * vec4(finalPosition, 1.0);
-    v_texCoord = a_texCoord1;
+    v_diffuseUV = a_texCoord1;
 }

cake/core/src/main/java/org/demoth/cake/stages/Game3dScreen.kt

@@ -11,8 +11,10 @@ import com.badlogic.gdx.graphics.g3d.Environment
 import com.badlogic.gdx.graphics.g3d.Model
 import com.badlogic.gdx.graphics.g3d.ModelBatch
 import com.badlogic.gdx.graphics.g3d.ModelInstance
+import com.badlogic.gdx.graphics.g3d.Renderable
 import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute
 import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight
+import com.badlogic.gdx.graphics.g3d.shaders.DefaultShader
 import com.badlogic.gdx.math.MathUtils.degRad
 import com.badlogic.gdx.math.Vector3
 import com.badlogic.gdx.scenes.scene2d.ui.Skin
@@ -145,7 +147,6 @@ class Game3dScreen : KtxScreen, InputProcessor, ServerMessageProcessor {
     )
 
     // mappings for input command: which are sent on every client update frame
-    private val mouseSensitivity = 1f // todo cvar
     private var mouseWasMoved = false
 
     private val inputKeyMappings: MutableMap<Int, ClientCommands> = mutableMapOf(
@@ -200,7 +201,30 @@ class Game3dScreen : KtxScreen, InputProcessor, ServerMessageProcessor {
 
         // create camera
         camera.update()
-        modelBatch = ModelBatch()
+
+        // fixme: make a free internal md2 model specifically for the shader initialization, don't use q2 resources
+        val md2 = Md2ModelLoader(locator).loadMd2ModelData("models/monsters/berserk/tris.md2", null, 0)!!
+        val model = createModel(md2.mesh, md2.material)
+        val md2Instance = ModelInstance(model)
+
+        md2Instance.userData = Md2CustomData(
+            0,
+            if (md2.frames > 1) 1 else 0,
+            0f,
+            md2.frames
+        )
+
+        val tempRenderable = Renderable()
+        val md2Shader = Md2Shader(
+            md2Instance!!.getRenderable(tempRenderable), // may not be obvious, but it's required for the shader initialization, the renderable is not used after that
+            DefaultShader.Config(
+                Gdx.files.internal("shaders/vat.glsl").readString(),
+                null, // use default fragment shader
+            )
+        )
+        md2Shader.init()
+
+        modelBatch = ModelBatch(Md2ShaderProvider(md2Shader))
 
         ClientCommands.entries.forEach { commandsState[it] = false }
     }
@@ -256,7 +280,7 @@ class Game3dScreen : KtxScreen, InputProcessor, ServerMessageProcessor {
 
             it.modelInstance.transform.setTranslation(x, y, z)
 
-            modelBatch.render(it.modelInstance, environment);
+            modelBatch.render(it.modelInstance, environment)
         }
         modelBatch.end()
 
@@ -344,18 +368,19 @@ class Game3dScreen : KtxScreen, InputProcessor, ServerMessageProcessor {
         for (i in startIndex .. MAX_MODELS) {
             gameConfig[i]?.let { config ->
                 config.value.let {
-                    config.resource = Md2ModelLoader(locator).loadMd2Model(it, skinIndex = 0, frameIndex = 0)
+                    val md2 = Md2ModelLoader(locator).loadMd2ModelData(it, skinIndex = 0)!!
+                    config.resource = createModel(md2.mesh, md2.material)
                 }
             }
         }
 
         // temporary: load one fixed player model
-        playerModel = Md2ModelLoader(locator).loadMd2Model(
+        val playerModelData = Md2ModelLoader(locator).loadMd2ModelData(
             modelName = playerModelPath,
             playerSkin = playerSkinPath,
             skinIndex = 0,
-            frameIndex = 0
         )!!
+        playerModel = createModel(playerModelData.mesh, playerModelData.material)
 
         gameConfig.getSounds().forEach { config ->
             if (config != null) {

cake/core/src/main/kotlin/org/demoth/cake/modelviewer/CakeModelViewer.kt

@@ -10,9 +10,9 @@ import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.badlogic.gdx.graphics.g3d.*
 import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute
 import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight
+import com.badlogic.gdx.graphics.g3d.shaders.DefaultShader
 import com.badlogic.gdx.graphics.g3d.utils.CameraInputController
 import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder
-import com.badlogic.gdx.graphics.glutils.ShaderProgram
 import com.badlogic.gdx.math.Vector3
 import jake2.qcommon.filesystem.PCX
 import jake2.qcommon.filesystem.WAL
@@ -34,16 +34,16 @@ class CakeModelViewer(val args: Array<String>) : ApplicationAdapter() {
     private lateinit var camera: Camera
     private lateinit var cameraInputController: CameraInputController
     // rendered with the default libgdx shader
-    private val models: MutableList<ModelInstance> = mutableListOf()
+    private val instances: MutableList<ModelInstance> = mutableListOf()
     private lateinit var environment: Environment
     private lateinit var font: BitmapFont
-    private var frameTime = 0f
-
-
-    private lateinit var md2Shader: ShaderProgram
-    private var md2ShaderModel: Md2ShaderModel? = null
-    private var md2AnimationTimer = 0.1f
+    private var frameTime = 0f // to have an idea of the fps
 
+    // md2 related stuff
+    private var md2Instance: ModelInstance? = null // to control the model animation
+    private var md2AnimationFrameTime = 0.1f
+    private var md2AnimationTime = 0.0f
+    private var playingMd2Animation = false
 
     override fun create() {
 
@@ -68,35 +68,48 @@ class CakeModelViewer(val args: Array<String>) : ApplicationAdapter() {
             }
             "md2" -> {
 
-                // Create the shader program
-                val vertexShader =
-                    Gdx.files.internal("shaders/vat.glsl").readString() // Assuming vat.vert contains the shader code above
-                val fragmentShader = "void main() { gl_FragColor = vec4(1.0); }" // Simple dummy fragment shader
-                md2Shader = ShaderProgram(vertexShader, fragmentShader)
-                if (!md2Shader.isCompiled) {
-                    Gdx.app.error("Shader Error", md2Shader.getLog())
-                    Gdx.app.exit()
-                }
+                val md2 = Md2ModelLoader(locator).loadMd2ModelData(file.absolutePath, null, 0)!!
+                val model = createModel(md2.mesh, md2.material)
+                md2Instance = ModelInstance(model) // ok
+                md2Instance!!.userData = Md2CustomData(
+                    0,
+                    if (md2.frames > 1) 1 else 0,
+                    0f,
+                    md2.frames
+                )
 
-                md2ShaderModel = Md2ModelLoader(locator).loadAnimatedModel(
-                    modelName = file.path, // will be passed to the ResourceLocator
-                    playerSkin = null,
-                    skinIndex = 0
+                val tempRenderable = Renderable()
+                val md2Shader = Md2Shader(
+                    md2Instance!!.getRenderable(tempRenderable), // may not be obvious, but it's required for the shader initialization, the renderable is not used after that
+                    DefaultShader.Config(
+                        Gdx.files.internal("shaders/vat.glsl").readString(),
+                        null, // use default fragment shader
+                    )
                 )
-                models.add(createOriginArrows(GRID_SIZE))
-                models.add(createGrid(GRID_SIZE, GRID_DIVISIONS))
+                md2Shader.init()
+
+                modelBatch = ModelBatch(Md2ShaderProvider(md2Shader))
+
+                instances.add(md2Instance!!)
+                instances.add(createOriginArrows(GRID_SIZE))
+                instances.add(createGrid(GRID_SIZE, GRID_DIVISIONS))
             }
             "bsp" -> {
+                modelBatch = ModelBatch()
+                // todo: fix bsp back!
 //                models.add(BspLoader().loadBSPModelWireFrame(file).transformQ2toLibgdx())
 //                models.addAll(BspLoader(gameDir).loadBspModels(file))
-                models.add(createOriginArrows(GRID_SIZE))
-                models.add(createGrid(GRID_SIZE, GRID_DIVISIONS))
+                instances.add(createOriginArrows(GRID_SIZE))
+                instances.add(createGrid(GRID_SIZE, GRID_DIVISIONS))
+            }
+            else -> {
+                println("Unsupported file format ${file.extension}")
+                Gdx.app.exit()
             }
         }
 
         batch = SpriteBatch()
 
-        modelBatch = ModelBatch()
         camera = PerspectiveCamera(90f, Gdx.graphics.width.toFloat(), Gdx.graphics.height.toFloat())
         camera.position.set(0f, 0f, 0f);
         camera.near = 1f
@@ -113,33 +126,43 @@ class CakeModelViewer(val args: Array<String>) : ApplicationAdapter() {
     }
 
     override fun render() {
-        // advance the model animation (if any) each 0.1 seconds
-        md2AnimationTimer -= Gdx.graphics.deltaTime
-        if (md2AnimationTimer < 0f) {
-            md2AnimationTimer = 0.1f
-            //model?.nextFrame()
+        if (Gdx.input.isKeyJustPressed(Input.Keys.SPACE)) {
+            playingMd2Animation = !playingMd2Animation
+        } else if (Gdx.input.isKeyJustPressed(Input.Keys.ESCAPE)) {
+            Gdx.app.exit()
+        } else if (Gdx.input.isKeyJustPressed(Input.Keys.RIGHT)) {
+            md2AnimationTime = 0f
+            changeFrame(1, md2Instance!!.getMd2CustomData())
+        } else if (Gdx.input.isKeyJustPressed(Input.Keys.LEFT)) {
+            md2AnimationTime = 0f
+            changeFrame(-1, md2Instance!!.getMd2CustomData())
         }
 
-        frameTime = measureTimeMillis {
-            if (Gdx.input.isKeyJustPressed(Input.Keys.ESCAPE)) {
-                Gdx.app.exit()
+        if (playingMd2Animation) {
+            md2AnimationTime += Gdx.graphics.deltaTime
+            if (md2AnimationTime >  md2AnimationFrameTime) {
+                md2AnimationTime = 0f
+                changeFrame(1, md2Instance!!.getMd2CustomData())
             }
-            Gdx.gl.glClearColor(0.1f, 0.1f, 0.1f, 1f)
+            md2Instance!!.getMd2CustomData().interpolation = md2AnimationTime / md2AnimationFrameTime
+
+        }
+
+        frameTime = measureTimeMillis {
+            Gdx.gl.glClearColor(0.0f, 0.0f, 0.0f, 1f)
             Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT or GL20.GL_DEPTH_BUFFER_BIT)
-            camera.update();
+            camera.update()
 
 
-            if (models.isNotEmpty()) {
+            if (instances.isNotEmpty()) {
                 modelBatch.begin(camera)
-                models.forEach {
+                instances.forEach {
                     modelBatch.render(it)
                 }
                 modelBatch.end()
 
             }
 
-            md2ShaderModel?.render(md2Shader, camera.combined)
-
             batch.use {
                 // draw frame time in the bottom left corner
                 font.draw(batch, "Frame time ms: $frameTime", 0f, font.lineHeight)
@@ -160,11 +183,26 @@ class CakeModelViewer(val args: Array<String>) : ApplicationAdapter() {
     override fun dispose() {
         batch.dispose()
         image?.dispose()
-        models.forEach { it.model.dispose() }
+        instances.forEach { it.model.dispose() }
         modelBatch.dispose()
     }
 }
 
+private fun changeFrame(delta: Int, md2CustomData: Md2CustomData) {
+    // advance animation frames: frame1++ frame2++, keep in mind number of frames
+    md2CustomData.frame1 = (md2CustomData.frame1 + delta) % md2CustomData.frames
+    md2CustomData.frame2 = (md2CustomData.frame2 + delta) % md2CustomData.frames
+    if (md2CustomData.frame1 < 0) {
+        md2CustomData.frame1 += md2CustomData.frames
+    }
+    if (md2CustomData.frame2 < 0) {
+        md2CustomData.frame2 += md2CustomData.frames
+    }
+    md2CustomData.interpolation = 0f
+}
+
+fun ModelInstance.getMd2CustomData(): Md2CustomData = userData as Md2CustomData
+
 fun createGrid(size: Float, divisions: Int): ModelInstance {
     val modelBuilder = ModelBuilder()
     // grid is in XZ plane