uniquake/Assets/Scripts/Modules/RenderModule.cs

using UnityEngine;
using UnityEngine.Rendering;

public partial class RenderModule
{
    private readonly UniQuake uq;

    public RenderModule(UniQuake uniQuake)
    {
        uq = uniQuake;
        BuildCallbacks();
    }

    private float xPos = -8f;

    private int UploadAliasModel(string name, QAliasHeader header, 
        QTriVertex[][] poseVertices, QTriangle[] triangles, QSTVert[] stVertices)
    {
        Debug.Log($"Alias model '{name}' with {header.numVerts} vertices, {header.numTriangles} triangles, {header.numFrames} frame(s)");

        ConvertTriangles(triangles, out var indices);
        ConvertUVs(stVertices, header.skinWidth, header.skinHeight, out var uvs);

        string modelName = System.IO.Path.GetFileNameWithoutExtension(name);
        AliasModel aliasModel = new AliasModel(modelName);
        
        Mesh mesh;
        string animName = null;
        int startFrame = 0;
        for (int frameIdx = 0; frameIdx < header.numFrames; ++frameIdx)
        {
            string frameName = AliasModel.AnimationRegex.Match(header.frames[frameIdx].name).Value;
            if (animName == null)
            {
                animName = frameName;
                continue;
            }

            if (frameName != animName)
            {
                // New animation sequence; convert the previous sequence into a blend shape animation
                mesh = CreateAnimatedMesh(header, poseVertices, indices, uvs, $"{modelName}_{animName}", startFrame, frameIdx);
                aliasModel.AddAnimation(startFrame, mesh);
                
                animName = frameName;
                startFrame = frameIdx;
            }
        }
        
        mesh = CreateAnimatedMesh(header, poseVertices, indices, uvs, $"{modelName}_{animName}", startFrame, header.numFrames);
        aliasModel.AddAnimation(startFrame, mesh);

        var go = new GameObject(modelName);
        go.transform.SetPositionAndRotation(new Vector3(xPos, 0, 0), Quaternion.Euler(-90, 90, 0));

        if (header.numFrames > 1)
        {
            var mr = go.AddComponent<SkinnedMeshRenderer>();
            mr.material = new Material(Shader.Find("Universal Render Pipeline/Simple Lit"));
            mr.sharedMesh = mesh;
            mr.shadowCastingMode = ShadowCastingMode.Off;
            mr.receiveShadows = false;
            mr.lightProbeUsage = LightProbeUsage.Off;
            mr.reflectionProbeUsage = ReflectionProbeUsage.Off;
            
            var animator = go.AddComponent<AliasModelAnimator>();
            animator.aliasModel = aliasModel;
        }
        else
        {
            var mf = go.AddComponent<MeshFilter>();
            mf.sharedMesh = mesh;
            var mr = go.AddComponent<MeshRenderer>();
            mr.material = new Material(Shader.Find("Universal Render Pipeline/Simple Lit"));
            mr.shadowCastingMode = ShadowCastingMode.Off;
            mr.receiveShadows = false;
            mr.lightProbeUsage = LightProbeUsage.Off;
            mr.reflectionProbeUsage = ReflectionProbeUsage.Off;
        }

        xPos += 0.5f;
        return 1;
    }

    private static void ConvertVertices(QAliasHeader header, QTriVertex[] triVerts, out Vector3[] vertices, out Vector3[] normals)
    {
        int numVerts = triVerts.Length;
        vertices = new Vector3[numVerts];
        normals = new Vector3[numVerts];

        Vector3 scale = header.scale.ToVector3();
        Vector3 origin = header.scaleOrigin.ToVector3();
        
        for (int i = 0; i < numVerts; ++i)
        {
            vertices[i] = Vector3.Scale(triVerts[i].ToVector3(), scale);
            normals[i] = QLightNormals.Get(triVerts[i].lightNormalIndex);
        }
    }

    private static void ConvertTriangles(QTriangle[] triangles, out ushort[] indices)
    {
        int numTris = triangles.Length;
        indices = new ushort[numTris * 3];
        
        for (int i = 0; i < numTris; ++i)
        {
            indices[i * 3 + 0] = (ushort)triangles[i].vertIndex[2];
            indices[i * 3 + 1] = (ushort)triangles[i].vertIndex[1];
            indices[i * 3 + 2] = (ushort)triangles[i].vertIndex[0];
        }
    }

    private static void ConvertUVs(QSTVert[] stVerts, int skinWidth, int skinHeight, out Vector2[] uvs)
    {
        int numVerts = stVerts.Length;
        uvs = new Vector2[numVerts];

        // TODO FIXME: this only works correctly for the front side of a model.
        // To also correctly UV the back side, we need to duplicate vertices on the back/front seam,
        // and add half the skin width to UVs that are on back side vertices.
        Vector2 scale = new Vector2(1.0f / skinWidth, 1.0f / skinHeight);
        
        for (int i = 0; i < numVerts; ++i)
        {
            uvs[i] = Vector2.Scale(new Vector2(stVerts[i].s, skinHeight - stVerts[i].t), scale);
        }
    }

    private static Mesh CreateAnimatedMesh(
        QAliasHeader header, QTriVertex[][] poseVertices, ushort[] indices, Vector2[] uvs,
        string animationName, int startFrame, int endFrame)
    {
        ConvertVertices(header, poseVertices[startFrame], out var baseVertices, out var baseNormals);
        
        var mesh = new Mesh { name = animationName };
        mesh.SetVertices(baseVertices);
        mesh.SetNormals(baseNormals);

        CreateBlendShapes(mesh, animationName, baseVertices, baseNormals, header, poseVertices, startFrame, endFrame);
        
        mesh.SetIndices(indices, MeshTopology.Triangles, 0, false);
        mesh.SetUVs(0, uvs);
        mesh.Optimize();
        mesh.RecalculateBounds();
        mesh.UploadMeshData(true);
        return mesh;
    }

    private static void CreateBlendShapes(
        Mesh mesh, string animName, Vector3[] baseVertices, Vector3[] baseNormals,
        QAliasHeader header, QTriVertex[][] poseVertices, int startFrame, int endFrame)
    {
        var deltaVertices = new Vector3[header.numVerts];
        var deltaNormals = new Vector3[header.numVerts];
        
        Vector3 scale = header.scale.ToVector3();
        Vector3 origin = header.scaleOrigin.ToVector3();
        
        int numFrames = endFrame - startFrame;
        
        // Repeat the first frame at the end, so we can smoothly animate the entire cycle and loop the animation without any breaks.
        for (int index = 1; index <= numFrames; ++index)
        {
            int frameIdx = startFrame + index % numFrames;
            var poseVerts = poseVertices[frameIdx];
            
            for (int vertIdx = 0; vertIdx < header.numVerts; ++vertIdx)
            {
                Vector3 vert = Vector3.Scale(poseVerts[vertIdx].ToVector3(), scale);
                deltaVertices[vertIdx] = vert - baseVertices[vertIdx];
                deltaNormals[vertIdx] = QLightNormals.Get(poseVerts[vertIdx].lightNormalIndex) - baseNormals[vertIdx];
            }
            
            mesh.AddBlendShapeFrame(animName, (float)index / numFrames, deltaVertices, deltaNormals, null);
        }
    }
}