はじめに

前回、VTF(Vertex Texture Fetch)の方法について解説しました。
Blender→Unity間でVTF(Vertex Texture Fetch)を行いオブジェクトを変形させる

簡単に言えば静止オブジェクトの頂点情報をテクスチャに書きこむことを行いました。

そこで、上記データをモーションフレーム毎に用意すればアニメーションデータすらも格納できることがわかります。

テクスチャを何枚も用意して切り替えるのは大変なので、1枚にまとめることが多いです。
また、そのテスクチャのことをVAT(Vertex Animation Texture)と言います。

それでは今回はBlenderにてVATを作成し、Unityで読みだすということをやっていきます。

やっていることはVTFの時とほとんど同じなので先にそちらを読んでおくとよいかもしれません。

Blender

テクスチャ作成

テクスチャクラスは前回作成したものを流用していきます。
画像形式はEXRです。

import bpy
import numpy as np

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()

UV配置

テクスチャにはX軸とY軸があるので、今回はX軸（横軸）に各頂点の情報を羅列し、Y軸（縦軸）を時間軸とします。

なのでUV配置は各頂点が横一列に並ぶように配置します。

import bpy
import numpy as np

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


+ def FixUV(mesh, width, height):
+     uv_layer = mesh.uv_layers.get("VertexUV")
+     if not uv_layer:
+         uv_layer = mesh.uv_layers.new(name="VertexUV")
+     
+     for face in mesh.polygons:
+         for i, loop_index in enumerate(face.loop_indices):
+             uv_layer.data[loop_index].uv = [
+                 loop_index * (1 / width) + 1 / (width * 2),
+                 0 + 1 / (height * 2)
+                 ]


# テスト用
obj = bpy.context.active_object
FixUV(obj.data, 32, 32)

立方体に適応すると以下のようになります。

内容についてはほぼ前回と同じなので、細かな説明はそちらを参考にしてください。

アニメーション後のメッシュ情報の取得

指定したアニメーションフレームのメッシュ情報を取得する関数を定義します。

import bpy
import numpy as np

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def FixUV(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    for face in mesh.polygons:
        for i, loop_index in enumerate(face.loop_indices):
            uv_layer.data[loop_index].uv = [
                loop_index * (1 / width) + 1 / (width * 2),
                0 + 1 / (height * 2)
                ]

+ def GetMesh(obj, frame):
+     bpy.context.scene.frame_set(frame)
+     bpy.context.view_layer.update()
+     depsgraph = bpy.context.evaluated_depsgraph_get()
+     eval_obj = obj.evaluated_get(depsgraph)
+     return eval_obj.to_mesh()


# テスト用
obj = bpy.context.active_object
start_frame = bpy.context.scene.frame_start
end_frame = bpy.context.scene.frame_end

for frame in range(start_frame, end_frame + 1):
    mesh = GetMesh(obj, frame)
    # 0ポリゴン目の0頂点目の位置情報（ワールド座標系）を表示する
    print(f"frame: {frame}, {obj.matrix_world @ mesh.vertices[mesh.polygons[0].vertices[0]].co}")

関数の検証として、立方体に対して0フレームから20フレームにかけてX軸に5m移動するというアニメーションを作成しました。
またアニメーション範囲はタイムラインの値から引用しているため、開始と終了の数値を変更する必要があります。

そして上記プログラムを適応すると以下の表示を得られます。

きちんと動いているのが確認できますね。

メッシュ取得

def GetMesh(obj, frame):
    bpy.context.scene.frame_set(frame)
    bpy.context.view_layer.update()
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    return eval_obj.to_mesh()

通常、アニメーションフレームを動かすだけならframe_set関数のみで良いのですが、その場合モディファイアが適応されていません。
そのため物理演算などの結果を得ることが出来ません。

モディファイアを適応した後のメッシュを得るためにはいくつかの手順を踏む必要があるようです。
スクリプトでモディファイアを適用したメッシュを作成する

また注意点として座標値などを得る場合、ワールド座標系である必要があります。

頂点情報記録

それでは前回と同じように各ピクセルに頂点情報と法線情報を格納します。

import bpy
import numpy as np
+ import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def FixUV(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    for face in mesh.polygons:
        for i, loop_index in enumerate(face.loop_indices):
            uv_layer.data[loop_index].uv = [
                loop_index * (1 / width) + 1 / (width * 2),
                0 + 1 / (height * 2)
                ]

def GetMesh(obj, frame):
    bpy.context.scene.frame_set(frame)
    bpy.context.view_layer.update()
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    return eval_obj.to_mesh()

+ def NormalToFloat(x, y, z):
+     x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
+     packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
+     return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

+ def Main(obj, width, height):
+     start_frame = bpy.context.scene.frame_start
+     end_frame = bpy.context.scene.frame_end
+     texture = TextureClass(obj.name + '_pos', width, height)
+ 
+     FixUV(obj.data, width, height)
+     uv_layer = obj.data.uv_layers.get("VertexUV")
+ 
+     for frame in range(start_frame, end_frame + 1):
+         mesh = GetMesh(obj, frame)
+         for polygon in mesh.polygons:
+             for i, loop_index in enumerate(polygon.loop_indices):
+                 uv = uv_layer.data[loop_index].uv
+                 pixel = [int(uv.y * height), int(uv.x * width)]
+                 pixel[0] += frame - start_frame
+ 
+                 vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
+                 normal = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
+                 normal = normal.normalized()
+ 
+                 texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))
+ 
+     texture.Export()


+ obj = bpy.context.active_object
+ Main(obj, 32, 32)

先ほど作成したアニメーション付きの立方体に対して実行すると、以下のテクスチャが得られました。

時間軸の変更

    for frame in range(start_frame, end_frame + 1):
        #...
                pixel = [int(uv.y * height), int(uv.x * width)]
                pixel[0] += frame - start_frame

フレームが進むごとにY軸を変えています。

頂点座標の取得

                vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                normal = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                normal = normal.normalized()

先述した通り、座標値などはワールド座標系を参照するようにします。

normalについては多少複雑になっていますが、奥が深いので色々試してみてください。

欲しい法線を取得するのに数時間苦戦しました pic.twitter.com/5kdzPy2LiC
— nekoco (@nekoco_vrc) August 1, 2024

スクリプト全文

import bpy
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def FixUV(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    for face in mesh.polygons:
        for i, loop_index in enumerate(face.loop_indices):
            uv_layer.data[loop_index].uv = [
                loop_index * (1 / width) + 1 / (width * 2),
                0 + 1 / (height * 2)
                ]

def GetMesh(obj, frame):
    bpy.context.scene.frame_set(frame)
    bpy.context.view_layer.update()
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    return eval_obj.to_mesh()

def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

def Main(obj, width, height):
    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    texture = TextureClass(obj.name + '_pos', width, height)

    FixUV(obj.data, width, height)
    uv_layer = obj.data.uv_layers.get("VertexUV")

    for frame in range(start_frame, end_frame + 1):
        mesh = GetMesh(obj, frame)
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                uv = uv_layer.data[loop_index].uv
                pixel = [int(uv.y * height), int(uv.x * width)]
                pixel[0] += frame - start_frame

                vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                normal = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                normal = normal.normalized()

                texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()


obj = bpy.context.active_object
Main(obj, 32, 32)

Unity

改変元プログラム

以下のランバートシェーダーを基本として拡張していきます。

Shader "nekoya/VAT"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : TEXCOORD1;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _LightColor0;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.normal = UnityObjectToWorldNormal(v.normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                col.rgb *= clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
                return col;
            }
            ENDCG
        }
    }
}

改変後プログラム

VTFに対応させたシェーダーは以下の通りです。

Shader "nekoya/VAT"
{
    Properties
    {
+         _Texture("Positon Texture", 2D) = "white" {}
+         _Motion("Motion", Float) = 0.0
+         _MaxMotion("Max Motion", Float) = 0.0
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
-                 float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
+                 float2 VertexUV : TEXCOORD1;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : TEXCOORD1;
            };

-             sampler2D _MainTex;
+             sampler2D _MainTex, _Texture;
-             float4 _MainTex_ST;
+             float4 _MainTex_ST, _Texture_TexelSize;
            fixed4 _LightColor0;
+             float _Motion, _MaxMotion;

+             half3 NormalUnpack(float v){
+                 uint ix = asuint(v);
+                 half3 normal = half3((ix & 0x00FF0000) >> 16, (ix & 0x0000FF00) >> 8, ix & 0x000000FF);
+                 return ((normal / 255.0f) - 0.5f) * 2.0f;
+             }

            v2f vert (appdata v)
            {
+                 float motion = _Motion % _MaxMotion;
+                 float2 uv = v.VertexUV;
+                 uv.y += floor(motion) * _Texture_TexelSize.y;
+ 
+                 float4 tex = tex2Dlod(_Texture, float4(uv, 0, 0));
+                 float4 pos = float4(tex.r, tex.b, tex.g, v.vertex.w);
+                 half3 normal = NormalUnpack(tex.a);
+                 normal = normalize(half3(normal.x, normal.z, normal.y));

                v2f o;
-                 o.vertex = UnityObjectToClipPos(v.vertex);
+                 o.vertex = UnityObjectToClipPos(pos);
-                 o.normal = UnityObjectToWorldNormal(v.normal);
+                 o.normal = UnityObjectToWorldNormal(normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                col.rgb *= clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
                return col;
            }
            ENDCG
        }
    }
}

各種設定を行い、Motionパラメータを変更するとオブジェクトが動きます。
法線情報がちゃんと保存できているか確認するためにX軸上に360度回転するアニメーションも追加しました。

画像サイズ

            sampler2D ..., _Texture;
            float4 ..., _Texture_TexelSize;

{テクスチャ名}_TexelSizeを定義するとテクスチャサイズが取得できるようです。
Cg/HLSL でシェーダープロパティを参照する

時間軸

                float2 uv = v.VertexUV;
                uv.y += int(_Motion) % _MaxMotion * _Texture_TexelSize.y;

_Motionパラメータを変えることで参照するテクスチャ位置を変更するようにします。
floor(_Motion) % _MaxMotionにて何px縦軸に移動するか計算した後、_Texture_TexelSize.y（1.0/height）を掛けることでUVに変換します。

シェーダー全文

Shader "nekoya/VAT"
{
    Properties
    {
        _Texture("Positon Texture", 2D) = "white" {}
        _Motion("Motion", Float) = 0.0
        _MaxMotion("Max Motion", Float) = 0.0
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float2 VertexUV : TEXCOORD1;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : TEXCOORD1;
            };

            sampler2D _MainTex, _Texture;
            float4 _MainTex_ST, _Texture_TexelSize;
            fixed4 _LightColor0;
            float _Motion, _MaxMotion;

            half3 NormalUnpack(float v){
                uint ix = asuint(v);
                half3 normal = half3((ix & 0x00FF0000) >> 16, (ix & 0x0000FF00) >> 8, ix & 0x000000FF);
                return ((normal / 255.0f) - 0.5f) * 2.0f;
            }

            v2f vert (appdata v)
            {
                float motion = _Motion % _MaxMotion;
                float2 uv = v.VertexUV;
                uv.y += floor(motion) * _Texture_TexelSize.y;

                float4 tex = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos = float4(tex.r, tex.b, tex.g, v.vertex.w);
                half3 normal = NormalUnpack(tex.a);
                normal = normalize(half3(normal.x, normal.z, normal.y));
                
                v2f o;
                o.vertex = UnityObjectToClipPos(pos);
                o.normal = UnityObjectToWorldNormal(normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                col.rgb *= clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
                return col;
            }
            ENDCG
        }
    }
}

使用方法

1.頂点テクスチャ作成

まずBlenderにてオブジェクトを作成し、アニメーションを作成します。
タイムラインの開始と終了の値も変更します。
続いてオブジェクトを選択して、スクリプトを実行します。

テクスチャが出力出来たら保存します。
保存形式は以前の記事に書いた通りです。

項目	値
ファイルフォーマット	OpenEXR
カラー	RGBA
色深度	Float(Full)
コーデック	なし
色空間	非カラー

2.オブジェクト出力

選択したオブジェクトをFBXとして出力します。
出力前にアニメーションフレームを開始地点に戻しておくとよいかもしれません。

3.Unityにインポート

テクスチャ、FBXをUnityにインポートして設定します。

テクスチャのインポート設定は以下の通りです。

Filter Mode：Point (no filter)
Format：RGBA Float

また、プロジェクトの色空間設定はLinerに設定しておいてください。

4.マテリアル設定、適応

マテリアルの設定は以下の通りです。

Positon Texture：インポートした頂点情報の入ったテクスチャ
Max Motion：作成したアニメーションの合計フレーム数（終了フレームー開始フレーム）

マテリアルを適応して完成です。

モーションの線形補完

現状ではMotionパラメータが1増えるごとに動きが変わっています。
しかしそのままでは動きがカクカクしているため、線形補完しましょう。

シェーダーは以下の通りです。

Shader "nekoya/VAT"
{
    Properties
    {
        _Texture("Positon Texture", 2D) = "white" {}
        _Motion("Motion", Float) = 0.0
        _MaxMotion("Max Motion", Float) = 0.0
+         [Toggle]_IsLerp("Is Lerp", Float) = 0.0
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float2 VertexUV : TEXCOORD1;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : TEXCOORD1;
            };

            sampler2D _MainTex, _Texture;
            float4 _MainTex_ST, _Texture_TexelSize;
            fixed4 _LightColor0;
            float _Motion, _MaxMotion;

            half3 NormalUnpack(float v){
                uint ix = asuint(v);
                half3 normal = half3((ix & 0x00FF0000) >> 16, (ix & 0x0000FF00) >> 8, ix & 0x000000FF);
                return ((normal / 255.0f) - 0.5f) * 2.0f;
            }

+             #pragma shader_feature _ISLERP_ON

            v2f vert (appdata v)
            {
                float motion = _Motion % _MaxMotion;
                float2 uv = v.VertexUV;
                uv.y += floor(motion) * _Texture_TexelSize.y;

                float4 tex = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos = float4(tex.r, tex.b, tex.g, v.vertex.w);
                half3 normal = NormalUnpack(tex.a);
                normal = normalize(half3(normal.x, normal.z, normal.y));
+ # ifdef _ISLERP_ON
+                 uv.y = (motion >= _MaxMotion - 1.0f)
+                     ? v.VertexUV.y + _Texture_TexelSize.y
+                     : v.VertexUV.y + ceil(motion) * _Texture_TexelSize.y;
+ 
+                 float4 tex2 = tex2Dlod(_Texture, float4(uv, 0, 0));
+                 float4 pos2 = float4(tex2.r, tex2.b, tex2.g, v.vertex.w);
+                 half3 normal2 = NormalUnpack(tex2.a);
+                 normal2 = normalize(half3(normal2.x, normal2.z, normal2.y));
+ 
+                 pos = lerp(pos, pos2, frac(motion));
+                 normal = lerp(normal, normal2, frac(motion));
+ #endif
                v2f o;
                o.vertex = UnityObjectToClipPos(pos);
                o.normal = UnityObjectToWorldNormal(normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                col.rgb *= clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
                return col;
            }
            ENDCG
        }
    }
}

きちんと間の動きが補完されていますね。

法線をハードエッジ化

Unityの画面を見てみると影の付き方がおかしいことが分かります。

これはBlenderでいうスムーズシェードになっているためこのような見た目になります。

なぜスムーズシェードになってしまうかというと、1つの頂点に対して1種類の法線情報しか存在しないためです。
各頂点から法線情報を取得する方法だとスムーズシェードの法線情報を取得してしまいます。

そのためフラットシェードにするためには、各ポリゴンから法線情報を取得し保存する必要があります。

スクリプトは以下の通りです。

import bpy
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def FixUV(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    for face in mesh.polygons:
        for i, loop_index in enumerate(face.loop_indices):
            uv_layer.data[loop_index].uv = [
                loop_index / width + 1 / (width * 2),
                0 + 1 / (height * 2)
                ]

def GetMesh(obj, frame):
    bpy.context.scene.frame_set(frame)
    bpy.context.view_layer.update()
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    return eval_obj.to_mesh()
    
def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

- def Main(obj, width, height)
+ def Main(obj, width, height, hard_edge):
    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    texture = TextureClass(obj.name + '_pos', width, height)

    FixUV(obj.data, width, height)
    uv_layer = obj.data.uv_layers.get("VertexUV")

    for frame in range(start_frame, end_frame + 1):
        mesh = GetMesh(obj, frame)
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                uv = uv_layer.data[loop_index].uv
                pixel = [int(uv.y * height), int(uv.x * width)]
                pixel[0] += frame - start_frame

                vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
-                 normal = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
+                 normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
+                     if hard_edge \
+                     else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                normal = normal.normalized()

                texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()


obj = bpy.context.active_object
+ hard_edge = True
- Main(obj, 32, 32)
+ Main(obj, 64, 64, hard_edge)

生成したテクスチャを適応するとフラットシェードになりました。

テクスチャ容量削減

現状すべての頂点座標を保存していますが、オブジェクトの形が変わらない場合情報量を削減することが出来ます。
形が変わらないというのも厳密には重複した頂点数の数が変わらないということですね。

つまり重複した情報は削減するということです。

現状はUVを用いて頂点情報を読みだしており、UVを同じ位置に配置させれば同じ情報を取得できます。

このことを用いてテクスチャサイズを削減します。
スクリプトは以下の通りです。

import bpy
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def FixUV(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    for face in mesh.polygons:
        for i, loop_index in enumerate(face.loop_indices):
            uv_layer.data[loop_index].uv = [
                loop_index / width + 1 / (width * 2),
                0 + 1 / (height * 2)
                ]

+ def FixUV_Dupe(mesh, width, height):
+     uv_layer = mesh.uv_layers.get("VertexUV")
+     if not uv_layer:
+         uv_layer = mesh.uv_layers.new(name="VertexUV")
+     
+     seen_vertices = {}
+     for vertex in mesh.vertices:
+         vertex_co = vertex.co
+         # 位置が重複していない場合のみ追加
+         if tuple(vertex_co) not in seen_vertices:
+             seen_vertices[tuple(vertex_co)] = None
+     
+     for polygon in mesh.polygons:
+         for i, loop_index in enumerate(polygon.loop_indices):
+             vertex_co = mesh.vertices[polygon.vertices[i]].co
+             if tuple(vertex_co) in seen_vertices:
+                 index = list(seen_vertices.keys()).index(tuple(vertex_co))
+                 uv_layer.data[loop_index].uv = [
+                     index / width + 1 / (width * 2),
+                     0 + 1 / (height * 2)
+                     ]

def GetMesh(obj, frame):
    bpy.context.scene.frame_set(frame)
    bpy.context.view_layer.update()
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    return eval_obj.to_mesh()

def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

- def Main(obj, width, height, hard_edge):
+ def Main(obj, width, height, hard_edge, vertex_compress):
+     if vertex_compress:
+         hard_edge = False

    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    texture = TextureClass(obj.name + '_pos', width, height)

-     FixUV(obj.data, width, height)
+     if vertex_compress:
+         FixUV_Dupe(obj.data, width, height)
+     else:
+         FixUV(obj.data, width, height)

    uv_layer = obj.data.uv_layers.get("VertexUV")

    for frame in range(start_frame, end_frame + 1):
        mesh = GetMesh(obj, frame)
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                uv = uv_layer.data[loop_index].uv
                pixel = [int(uv.y * height), int(uv.x * width)]
                pixel[0] += frame - start_frame

                vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                normal = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                normal = normal.normalized()

                texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()


obj = bpy.context.active_object
hard_edge = False
+ vertex_compress = True

- Main(obj, 8, 32, hard_edge)
+ Main(obj, 8, 32, hard_edge, vertex_compress)

立方体に適応すると、横幅が8pxに収まりました。

なお、先述した法線をハードエッジ化の項目とは共存できないため、必ずスムーズシェードになってしまいます。

複数行対応、テクスチャサイズ判定

現状では頂点を横1行にしか配置しないため、頂点数が増えるとテクスチャサイズも増えてしまいます。
しかしUnityで扱える画像サイズは、Unity2022.3.6f1では16384pxまでしかありません。

また頂点数に対してアニメーションフレームはそこまで必要でないと思われるので、複数行に分けて保存できるように変更します。

テクスチャサイズに関しては正方形でなくても良く、2のべき乗値であればよいとのことなのでいい感じの値を返してくれる関数を作成します。

スクリプトは以下の通りです。

import bpy
+ import math
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


+ def GetResolution(max_resolution, vertex_num, frame):
+     height = -1
+     width = -1
+     column = 1
+     
+     for column in range(1, max_resolution + 1):
+         for i in range(0, int(math.log2(max_resolution)) + 1):
+             if vertex_num <= (1 << i) * column:
+                 width = 1 << i
+                 break
+         if width != -1:
+             break
+             
+     for i in range(0, int(math.log2(max_resolution)) + 1):
+         if frame * column + 1 <= (1 << i):
+             height = 1 << i
+             break;
+     
+     return width, height, column

def FixUV(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    for face in mesh.polygons:
        for i, loop_index in enumerate(face.loop_indices):
-             uv_layer.data[loop_index].uv = [
-                 loop_index / width + 1 / (width * 2),
-                 0 + 1 / (height * 2)
-                 ]
+             uv_layer.data[loop_index].uv = [
+                 loop_index % width / width + 1 / (width * 2),
+                 loop_index // width / height + 1 / (height * 2)
+                 ]

def FixUV_Dupe(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    seen_vertices = {}
    for vertex in mesh.vertices:
        vertex_co = vertex.co
        # 位置が重複していない場合のみ追加
        if tuple(vertex_co) not in seen_vertices:
            seen_vertices[tuple(vertex_co)] = None
    
    for polygon in mesh.polygons:
        for i, loop_index in enumerate(polygon.loop_indices):
            vertex_co = mesh.vertices[polygon.vertices[i]].co
            if tuple(vertex_co) in seen_vertices:
                index = list(seen_vertices.keys()).index(tuple(vertex_co))
-                 uv_layer.data[loop_index].uv = [
-                     index / width + 1 / (width * 2),
-                     0 + 1 / (height * 2)
-                     ]
+                 uv_layer.data[loop_index].uv = [
+                     index % width / width + 1 / (width * 2),
+                     index // width / height + 1 / (height * 2)
+                     ]

def GetMesh(obj, frame):
    bpy.context.scene.frame_set(frame)
    bpy.context.view_layer.update()
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    return eval_obj.to_mesh()
    
def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

- def Main(obj, width, height, hard_edge, vertex_compress):
+ def Main(obj, max_resolution, hard_edge, vertex_compress):
    if vertex_compress:
        hard_edge = False

    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
+     vertex_num = len(obj.data.vertices) \
+         if vertex_compress \
+         else len([loop for polygon in obj.data.polygons for loop in polygon.loop_indices])
+     width, height, column = GetResolution(max_resolution, vertex_num, end_frame - start_frame + 1)
+ 
+     if width == -1 or height == -1:
+         print("頂点数またはフレーム数が大きすぎます")
+         return
    
    texture = TextureClass(obj.name + '_pos', width, height)

    if vertex_compress:
        FixUV_Dupe(obj.data, width, height)
    else:
        FixUV(obj.data, width, height)
    
    uv_layer = obj.data.uv_layers.get("VertexUV")

    for frame in range(start_frame, end_frame + 1):
        mesh = GetMesh(obj, frame)
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                uv = uv_layer.data[loop_index].uv
                pixel = [int(uv.y * height), int(uv.x * width)]
-                 pixel[0] += frame - start_frame
+                 pixel[0] += (frame - start_frame) * column

                vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                    if hard_edge \
                    else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                normal = normal.normalized()

                texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()


obj = bpy.context.active_object
hard_edge = False
vertex_compress = True

Main(obj, 64, hard_edge, vertex_compress)

複数行に対応しました。

また現状ではColumnとMaxMotionパラメータをシェーダーに渡す必要があります。
しかし毎回入力するのは面倒なので、テクスチャに入れ込んでしまいましょう。

スクリプトは以下の通りです。

import bpy
import math
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def GetResolution(max_resolution, vertex_num, frame):
    height = -1
    width = -1
    column = 1
    
    for column in range(1, max_resolution + 1):
        for i in range(0, int(math.log2(max_resolution)) + 1):
            if vertex_num <= (1 << i) * column:
                width = 1 << i
                break
        if width != -1:
            break
            
    for i in range(0, int(math.log2(max_resolution)) + 1):
        if frame * column + 1 <= (1 << i):
            height = 1 << i
            break;
    
    return width, height, column

def FixUV(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    for face in mesh.polygons:
        for i, loop_index in enumerate(face.loop_indices):
            uv_layer.data[loop_index].uv = [
                loop_index % width / width + 1 / (width * 2),
-                 loop_index // width / height + 1 / (height * 2)
+                 (loop_index // width + 1) / height + 1 / (height * 2)
                ]

def FixUV_Dupe(mesh, width, height):
    uv_layer = mesh.uv_layers.get("VertexUV")
    if not uv_layer:
        uv_layer = mesh.uv_layers.new(name="VertexUV")
    
    seen_vertices = {}
    for vertex in mesh.vertices:
        vertex_co = vertex.co
        # 位置が重複していない場合のみ追加
        if tuple(vertex_co) not in seen_vertices:
            seen_vertices[tuple(vertex_co)] = None
    
    for polygon in mesh.polygons:
        for i, loop_index in enumerate(polygon.loop_indices):
            vertex_co = mesh.vertices[polygon.vertices[i]].co
            if tuple(vertex_co) in seen_vertices:
                index = list(seen_vertices.keys()).index(tuple(vertex_co))
                uv_layer.data[loop_index].uv = [
                    index % width / width + 1 / (width * 2),
-                     index // width / height + 1 / (height * 2)
+                     (index // width + 1) / height + 1 / (height * 2)
                    ]

def GetMesh(obj, frame):
    bpy.context.scene.frame_set(frame)
    bpy.context.view_layer.update()
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(depsgraph)
    return eval_obj.to_mesh()
    
def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

+ def ShortsToFloat(value1, value2):
+     paced_32bit = (value1 << 16) | value2
+     return struct.unpack('!f', struct.pack('!I', paced_32bit))[0]

def Main(obj, max_resolution, hard_edge, vertex_compress):
    if vertex_compress:
        hard_edge = False

    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    vertex_num = len(obj.data.vertices) \
        if vertex_compress \
        else len([loop for polygon in obj.data.polygons for loop in polygon.loop_indices])
    width, height, column = GetResolution(max_resolution, vertex_num, end_frame - start_frame + 1)

    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(obj.name + '_pos', width, height)

+     param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
+     texture.SetPixel(0, 0, *param)

    if vertex_compress:
        FixUV_Dupe(obj.data, width, height)
    else:
        FixUV(obj.data, width, height)
    
    uv_layer = obj.data.uv_layers.get("VertexUV")

    for frame in range(start_frame, end_frame + 1):
        mesh = GetMesh(obj, frame)
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                uv = uv_layer.data[loop_index].uv
                pixel = [int(uv.y * height), int(uv.x * width)]
                pixel[0] += (frame - start_frame) * column

                vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                    if hard_edge \
                    else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                normal = normal.normalized()

                texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()


obj = bpy.context.active_object
hard_edge = True
vertex_compress = False

Main(obj, 128, hard_edge, vertex_compress)

[0,0]ピクセル（左下）に情報が追加されました。

ではシェーダーの方も変更していきましょう。

Shader "nekoya/VAT"
{
    Properties
    {
        _Texture("Positon Texture", 2D) = "white" {}
        _Motion("Motion", Float) = 0.0
        [Toggle]_IsLerp("Is Lerp", Float) = 0.0
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float2 VertexUV : TEXCOORD1;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : TEXCOORD1;
            };

            sampler2D _MainTex, _Texture;
            float4 _MainTex_ST, _Texture_TexelSize;
            fixed4 _LightColor0;
            float _Motion;

            half3 NormalUnpack(float v){
                uint ix = asuint(v);
                half3 normal = half3((ix & 0x00FF0000) >> 16, (ix & 0x0000FF00) >> 8, ix & 0x000000FF);
                return ((normal / 255.0f) - 0.5f) * 2.0f;
            }

+             void ShortUnpack(float v, out int v1, out int v2){
+                 uint ix = asuint(v);
+                 v1 = (ix & 0xFFFF0000) >> 16;
+                 v2 = (ix & 0x0000FFFF);
+             }

            #pragma shader_feature _ISLERP_ON

            v2f vert (appdata v)
            {
+                 int column, maxMotion;
+                 float4 param = tex2Dlod(_Texture, 0);
+                 ShortUnpack(param.r, column, maxMotion);

-                 float motion = _Motion % _MaxMotion;
+                 float motion = _Motion % maxMotion;
                float2 uv = v.VertexUV;
-                 uv.y += floor(motion) * _Texture_TexelSize.y;
+                 uv.y += floor(motion) * _Texture_TexelSize.y * column;

                float4 tex = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos = float4(tex.r, tex.b, tex.g, v.vertex.w);
                half3 normal = NormalUnpack(tex.a);
                normal = normalize(half3(normal.x, normal.z, normal.y));
# ifdef _ISLERP_ON
-                 uv.y = (motion >= _MaxMotion - 1.0f)
-                     ? v.VertexUV.y + _Texture_TexelSize.y
-                     : v.VertexUV.y + ceil(motion) * _Texture_TexelSize.y;
+                 uv.y = (motion >= maxMotion - 1.0f)
+                     ? v.VertexUV.y + _Texture_TexelSize.y * column
+                     : v.VertexUV.y + ceil(motion) * _Texture_TexelSize.y * column;

                float4 tex2 = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos2 = float4(tex2.r, tex2.b, tex2.g, v.vertex.w);
                half3 normal2 = NormalUnpack(tex2.a);
                normal2 = normalize(half3(normal2.x, normal2.z, normal2.y));

                pos = lerp(pos, pos2, frac(motion));
                normal = lerp(normal, normal2, frac(motion));
#endif
                v2f o;
                o.vertex = UnityObjectToClipPos(pos);
                o.normal = UnityObjectToWorldNormal(normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                col.rgb *= clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
                return col;
            }
            ENDCG
        }
    }
}

無事パラメータも読み出すことができ、復元できました。

複数オブジェクトをまとめる

現状はbpy.context.active_objectでオブジェクトを取得していますが、それでは1つのアクティブなオブジェクトしか取得できません。

そこでbpy.context.selected_objectsを使用することで選択したオブジェクトすべてを取得できます。

各処理も複数オブジェクトに対応するように修正しましょう。
スクリプトは以下の通りです。

import bpy
import math
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def GetResolution(max_resolution, vertex_num, frame):
    height = -1
    width = -1
    column = 1
    
    for column in range(1, max_resolution + 1):
        for i in range(0, int(math.log2(max_resolution)) + 1):
            if vertex_num <= (1 << i) * column:
                width = 1 << i
                break
        if width != -1:
            break
            
    for i in range(0, int(math.log2(max_resolution)) + 1):
        if frame * column + 1 <= (1 << i):
            height = 1 << i
            break;
    
    return width, height, column

- def FixUV(mesh, width, height):
+ def FixUV(meshs, width, height):
+     count = 0
+     for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        for face in mesh.polygons:
            for i, loop_index in enumerate(face.loop_indices):
-                 uv_layer.data[loop_index].uv = [
-                     loop_index % width / width + 1 / (width * 2),
-                     (loop_index // width + 1) / height + 1 / (height * 2)
-                 ]
+                 uv_layer.data[loop_index].uv = [
+                     count % width / width + 1 / (width * 2),
+                     (count // width + 1) / height + 1 / (height * 2)
+                     ]
+                 count += 1

- def FixUV_Dupe(mesh, width, height):
+ def FixUV_Dupe(meshs, width, height):
+     count = 0
+     for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        seen_vertices = {}
        for vertex in mesh.vertices:
            vertex_co = vertex.co
            # 位置が重複していない場合のみ追加
            if tuple(vertex_co) not in seen_vertices:
                seen_vertices[tuple(vertex_co)] = None
        
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                vertex_co = mesh.vertices[polygon.vertices[i]].co
                if tuple(vertex_co) in seen_vertices:
-                     index = list(seen_vertices.keys()).index(tuple(vertex_co))
+                     index = list(seen_vertices.keys()).index(tuple(vertex_co)) + count
                    uv_layer.data[loop_index].uv = [
                        index % width / width + 1 / (width * 2),
                        (index // width + 1) / height + 1 / (height * 2)
                        ]
                    
+         count += len(seen_vertices)

- def GetMesh(obj, frame):
-     bpy.context.scene.frame_set(frame)
-     bpy.context.view_layer.update()
-     depsgraph = bpy.context.evaluated_depsgraph_get()
-     eval_obj = obj.evaluated_get(depsgraph)
-     return eval_obj.to_mesh()
    
def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

def ShortsToFloat(value1, value2):
    paced_32bit = (value1 << 16) | value2
    return struct.unpack('!f', struct.pack('!I', paced_32bit))[0]

def Main(objs, max_resolution, hard_edge, vertex_compress):
    if vertex_compress:
        hard_edge = False

    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    vertex_num = sum(len(obj.data.vertices) for obj in objs) \
        if vertex_compress \
        else len([loop for obj in objs for polygon in obj.data.polygons for loop in polygon.loop_indices])
    width, height, column = GetResolution(max_resolution, vertex_num, end_frame - start_frame + 1)

    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(objs[0].name + '_pos', width, height)

    param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
    texture.SetPixel(0, 0, *param)

+     bpy.context.scene.frame_set(0)
+     origins = {}
+     for obj in objs:
+         origins[obj] = obj.location.copy()

    if vertex_compress:
-         FixUV_Dupe(obj.data, width, height)
+         FixUV_Dupe([obj.data for obj in objs], width, height)
    else:
-         FixUV(obj.data, width, height)
+         FixUV([obj.data for obj in objs], width, height)

-     uv_layer = obj.data.uv_layers.get("VertexUV")
    
    for frame in range(start_frame, end_frame + 1):
-         mesh = GetMesh(obj, frame)
+         bpy.context.scene.frame_set(frame)
+         bpy.context.view_layer.update()
+         depsgraph = bpy.context.evaluated_depsgraph_get()
+         for obj in objs:
+             eval_obj = obj.evaluated_get(depsgraph)
+             mesh = eval_obj.to_mesh()
+             uv_layer = eval_obj.data.uv_layers.get("VertexUV")
            for polygon in mesh.polygons:
                for i, loop_index in enumerate(polygon.loop_indices):
                    uv = uv_layer.data[loop_index].uv
                    pixel = [int(uv.y * height), int(uv.x * width)]
                    pixel[0] += (frame - start_frame) * column

                    vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co - origins[obj]
                    normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                        if hard_edge \
                        else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                    normal = normal.normalized()

                    texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()


objs = bpy.context.selected_objects
hard_edge = True
vertex_compress = False

Main(objs, 1024, hard_edge, vertex_compress)

ちょっと豪勢に立方体が崩壊するアニメーションを作成しました。
このアニメーションがテクスチャ1枚で完結しています。

なお、BlenderとUnityでは座標軸が異なるため、FBX出力時に調整する必要があります。

FBX出力時の設定は以下の通りです。
スケールを適応：FBX単位スケール
前方：Zが前
上：Yが上
トランスフォームを適応：ON

表示用オブジェクトの作成、頂点番号の使用

これまではアニメーションを作成したオブジェクト自体をFXBで出力し、マテリアルを適応していました。
今回は選択した全オブジェクトのポリゴン数を持つオブジェクトを別途作成し、そちらをFBXとして出力するようにしましょう。

また頂点情報の読み出しにUVを使用していましたが、今回は頂点番号を使用して読み出すようにシェーダーも変更します。

スクリプトは以下の通りです。

import bpy
import math
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


+ def GetVertexMax(objs):
+     bpy.context.scene.frame_set(0)
+     bpy.context.view_layer.update()
+     depsgraph = bpy.context.evaluated_depsgraph_get()
+ 
+     vertex = 0
+     for obj in objs:
+         mesh = obj.evaluated_get(depsgraph).to_mesh()
+         for polygon in mesh.polygons:
+             if len(polygon.vertices) >= 4:
+                 return -1
+             vertex += len(polygon.vertices)
+         
+     return vertex

def GetResolution(max_resolution, vertex_num, frame):
    height = -1
    width = -1
    column = 1
    
    for column in range(1, max_resolution + 1):
        for i in range(0, int(math.log2(max_resolution)) + 1):
            if vertex_num <= (1 << i) * column:
                width = 1 << i
                break
        if width != -1:
            break
            
    for i in range(0, int(math.log2(max_resolution)) + 1):
        if frame * column + 1 <= (1 << i):
            height = 1 << i
            break;
    
    return width, height, column

def FixUV(meshs, width, height):
    count = 0
    for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        for face in mesh.polygons:
            for i, loop_index in enumerate(face.loop_indices):
                uv_layer.data[loop_index].uv = [
                    count % width / width + 1 / (width * 2),
                    (count // width + 1) / height + 1 / (height * 2)
                    ]
                count += 1

def FixUV_Dupe(meshs, width, height):
    count = 0
    for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        seen_vertices = {}
        for vertex in mesh.vertices:
            vertex_co = vertex.co
            # 位置が重複していない場合のみ追加
            if tuple(vertex_co) not in seen_vertices:
                seen_vertices[tuple(vertex_co)] = None
        
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                vertex_co = mesh.vertices[polygon.vertices[i]].co
                if tuple(vertex_co) in seen_vertices:
                    index = list(seen_vertices.keys()).index(tuple(vertex_co)) + count
                    uv_layer.data[loop_index].uv = [
                        index % width / width + 1 / (width * 2),
                        (index // width + 1) / height + 1 / (height * 2)
                        ]
                    
        count += len(seen_vertices)
    
def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

def ShortsToFloat(value1, value2):
    paced_32bit = (value1 << 16) | value2
    return struct.unpack('!f', struct.pack('!I', paced_32bit))[0]

+ def CreateObject(polygon_count):
+     mesh = bpy.data.meshes.new(name="TriangleMesh")
+     obj = bpy.data.objects.new("TriangleObject", mesh)
+     bpy.context.collection.objects.link(obj)
+ 
+     vertices = []
+     faces = []
+     for p in range(polygon_count):
+         vertices.append((1, 0, p * 0.001))
+         vertices.append((-1, 0, p * 0.001))
+         vertices.append((0, 1, p * 0.001))
+         faces.append((p * 3, p * 3 + 1, p * 3 + 2))
+ 
+     mesh.from_pydata(vertices, [], faces)
+     mesh.update()

- def Main(objs, max_resolution, hard_edge, vertex_compress):
+ def Main_UV(objs, max_resolution, hard_edge, vertex_compress):
    if vertex_compress:
        hard_edge = False

    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    vertex_num = sum(len(obj.data.vertices) for obj in objs) \
        if vertex_compress \
        else len([loop for obj in objs for polygon in obj.data.polygons for loop in polygon.loop_indices])
    width, height, column = GetResolution(max_resolution, vertex_num, end_frame - start_frame + 1)

    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(objs[0].name + '_pos', width, height)

    param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
    texture.SetPixel(0, 0, *param)

    bpy.context.scene.frame_set(0)
    origins = {}
    for obj in objs:
        origins[obj] = obj.location.copy()

    if vertex_compress:
        FixUV_Dupe([obj.data for obj in objs], width, height)
    else:
        FixUV([obj.data for obj in objs], width, height)
    
    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()
        for obj in objs:
            eval_obj = obj.evaluated_get(depsgraph)
            mesh = eval_obj.to_mesh()
            uv_layer = eval_obj.data.uv_layers.get("VertexUV")
            for polygon in mesh.polygons:
                for i, loop_index in enumerate(polygon.loop_indices):
                    uv = uv_layer.data[loop_index].uv
                    pixel = [int(uv.y * height), int(uv.x * width)]
                    pixel[0] += (frame - start_frame) * column

                    vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co - origins[obj]
                    normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                        if hard_edge \
                        else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                    normal = normal.normalized()

                    texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()

+ def Main_VertexID(objs, max_resolution, hard_edge):
+     start_frame = bpy.context.scene.frame_start
+     end_frame = bpy.context.scene.frame_end
+     vertex_max = GetVertexMax(objs)
+     if vertex_max == -1:
+         print("三角形以外のポリゴンが含まれています")
+         return
+ 
+     width, height, column = GetResolution(max_resolution, vertex_max, end_frame - start_frame + 1)
+     if width == -1 or height == -1:
+         print("頂点数またはフレーム数が大きすぎます")
+         return
+     
+     texture = TextureClass(objs[0].name + '_pos', width, height)
+ 
+     param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
+     texture.SetPixel(0, 0, *param)
+ 
+     for frame in range(start_frame, end_frame + 1):
+         bpy.context.scene.frame_set(frame)
+         bpy.context.view_layer.update()
+         depsgraph = bpy.context.evaluated_depsgraph_get()
+ 
+         count = 0
+         for obj in objs:
+             eval_obj = obj.evaluated_get(depsgraph)
+             mesh = eval_obj.to_mesh()
+             for polygon in mesh.polygons:
+                 for i, loop_index in enumerate(polygon.loop_indices):
+                     pixel = [count // width + 1, count % width]
+                     pixel[0] += (frame - start_frame) * column
+ 
+                     vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
+                     normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
+                         if hard_edge \
+                         else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
+                     normal = normal.normalized()
+ 
+                     texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))
+ 
+                     count += 1
+ 
+     texture.Export()
+     CreateObject(math.ceil(vertex_max / 3))


objs = bpy.context.selected_objects
hard_edge = True
vertex_compress = False
+ mock_object = True

- Main(objs, 1024, hard_edge, vertex_compress)
+ if mock_object:
+     Main_VertexID(objs, 1024, hard_edge)
+ else:
+     Main_UV(objs, 1024, hard_edge, vertex_compress)

TriangleObjectという全体のポリゴン数を持ったオブジェクトが生成されました。
こちらのオブジェクトとテクスチャをUnityにインポートします。

また、シェーダーは以下の通りです。
新しく別のシェーダーに書くのがおすすめです。

- Shader "nekoya/VAT"
+ Shader "nekoya/VAT_Vertex"
{
    Properties
    {
        _Texture("Positon Texture", 2D) = "white" {}
        _Motion("Motion", Float) = 0.0
        [Toggle]_IsLerp("Is Lerp", Float) = 0.0
-         _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100
+         Cull Off

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
-                 float2 uv : TEXCOORD0;
-                 float2 VertexUV : TEXCOORD1;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
-                 float2 uv : TEXCOORD0;
                half3 normal : TEXCOORD1;
            };

-             sampler2D _MainTex, _Texture;
+             sampler2D _Texture;
-             float4 _MainTex_ST, _Texture_TexelSize;
+             float4 _Texture_TexelSize;
            fixed4 _LightColor0;
            float _Motion;

            half3 NormalUnpack(float v){
                uint ix = asuint(v);
                half3 normal = half3((ix & 0x00FF0000) >> 16, (ix & 0x0000FF00) >> 8, ix & 0x000000FF);
                return ((normal / 255.0f) - 0.5f) * 2.0f;
            }

            void ShortUnpack(float v, out int v1, out int v2){
                uint ix = asuint(v);
                v1 = (ix & 0xFFFF0000) >> 16;
                v2 = (ix & 0x0000FFFF);
            }

            #pragma shader_feature _ISLERP_ON

-             v2f vert (appdata v)
+             v2f vert (appdata v, uint vid : SV_VertexID)
            {
                int column, maxMotion;
                float4 param = tex2Dlod(_Texture, 0);
                ShortUnpack(param.r, column, maxMotion);

                float motion = _Motion % maxMotion;
-                 float2 uv = v.VertexUV;
+                 float2 uv = float2(
+                     float(vid) % _Texture_TexelSize.z * _Texture_TexelSize.x,
+                     (int(float(vid) * _Texture_TexelSize.x) + 1.0f) * _Texture_TexelSize.y
+                     );
                uv.y += floor(motion) * _Texture_TexelSize.y * column;

                float4 tex = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos = float4(tex.r, tex.b, tex.g, v.vertex.w);
                half3 normal = NormalUnpack(tex.a);
                normal = normalize(half3(normal.x, normal.z, normal.y));
# ifdef _ISLERP_ON
-                 uv.y = (motion >= maxMotion - 1.0f)
-                     ? v.VertexUV.y + _Texture_TexelSize.y * column
-                     : v.VertexUV.y + ceil(motion) * _Texture_TexelSize.y * column;
+                 uv.y = (int(float(vid) * _Texture_TexelSize.x) + 1.0f) * _Texture_TexelSize.y;
+                 uv.y += (motion >= maxMotion - 1.0f)
+                     ? _Texture_TexelSize.y * column
+                     : ceil(motion) * _Texture_TexelSize.y * column;

                float4 tex2 = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos2 = float4(tex2.r, tex2.b, tex2.g, v.vertex.w);
                half3 normal2 = NormalUnpack(tex2.a);
                normal2 = normalize(half3(normal2.x, normal2.z, normal2.y));

                pos = lerp(pos, pos2, frac(motion));
                normal = lerp(normal, normal2, frac(motion));
#endif
                v2f o;
                o.vertex = UnityObjectToClipPos(pos);
                o.normal = UnityObjectToWorldNormal(normal);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
-                 fixed4 col = tex2D(_MainTex, i.uv);
-                 col.rgb *= clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
-                 return col;
+                 return clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
            }
            ENDCG
        }
    }
}

無事TriangleObjectが変形しました。

なおこちらのオブジェクトは欠点として、テクスチャを張ることが出来ません。
今まではUV展開されたオブジェクト自体にUV2を追加していたので、テクスチャ用のUVも保持されていました。
しかしこちらはUV転写が上手くいかないようなのでテクスチャを張るのは今回断念しました。

流体対応化

それではVATの花形ともいえる流体オブジェクトの対応を行っていきます。

流体の懸念点としては、ポリゴン数が常時変化することが挙げられます。
また最大ポリゴン数も探索する必要があります。

流体についてはUV展開が行えないため、先ほど作成した頂点番号用の処理で行う必要があります。

それではスクリプトは以下の通りです。

import bpy
import math
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


+ def GetVertexMax(objs, start_frame, end_frame):
+     vertex_max = 0
+     for frame in range(start_frame, end_frame + 1):
-         bpy.context.scene.frame_set(0)
+         bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()

        vertex = 0
        for obj in objs:
            mesh = obj.evaluated_get(depsgraph).to_mesh()
            for polygon in mesh.polygons:
                if len(polygon.vertices) >= 4:
                    return -1
                vertex += len(polygon.vertices)
        
+         vertex_max = max(vertex_max, vertex)
-     return vertex
+     return vertex_max

def GetResolution(max_resolution, vertex_num, frame):
    height = -1
    width = -1
    column = 1
    
    for column in range(1, max_resolution + 1):
        for i in range(0, int(math.log2(max_resolution)) + 1):
            if vertex_num <= (1 << i) * column:
                width = 1 << i
                break
        if width != -1:
            break
            
    for i in range(0, int(math.log2(max_resolution)) + 1):
        if frame * column + 1 <= (1 << i):
            height = 1 << i
            break;
    
    return width, height, column

def FixUV(meshs, width, height):
    count = 0
    for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        for face in mesh.polygons:
            for i, loop_index in enumerate(face.loop_indices):
                uv_layer.data[loop_index].uv = [
                    count % width / width + 1 / (width * 2),
                    (count // width + 1) / height + 1 / (height * 2)
                    ]
                count += 1

def FixUV_Dupe(meshs, width, height):
    count = 0
    for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        seen_vertices = {}
        for vertex in mesh.vertices:
            vertex_co = vertex.co
            # 位置が重複していない場合のみ追加
            if tuple(vertex_co) not in seen_vertices:
                seen_vertices[tuple(vertex_co)] = None
        
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                vertex_co = mesh.vertices[polygon.vertices[i]].co
                if tuple(vertex_co) in seen_vertices:
                    index = list(seen_vertices.keys()).index(tuple(vertex_co)) + count
                    uv_layer.data[loop_index].uv = [
                        index % width / width + 1 / (width * 2),
                        (index // width + 1) / height + 1 / (height * 2)
                        ]
                    
        count += len(seen_vertices)
    
def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

def ShortsToFloat(value1, value2):
    paced_32bit = (value1 << 16) | value2
    return struct.unpack('!f', struct.pack('!I', paced_32bit))[0]

def CreateObject(polygon_count):
    mesh = bpy.data.meshes.new(name="TriangleMesh")
    obj = bpy.data.objects.new("TriangleObject", mesh)
    bpy.context.collection.objects.link(obj)

    vertices = []
    faces = []
    for p in range(polygon_count):
        vertices.append((1, 0, p * 0.001))
        vertices.append((-1, 0, p * 0.001))
        vertices.append((0, 1, p * 0.001))
        faces.append((p * 3, p * 3 + 1, p * 3 + 2))

    mesh.from_pydata(vertices, [], faces)
    mesh.update()

def Main_UV(objs, max_resolution, hard_edge, vertex_compress):
    if vertex_compress:
        hard_edge = False

    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    vertex_num = sum(len(obj.data.vertices) for obj in objs) \
        if vertex_compress \
        else len([loop for obj in objs for polygon in obj.data.polygons for loop in polygon.loop_indices])
    width, height, column = GetResolution(max_resolution, vertex_num, end_frame - start_frame + 1)

    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(objs[0].name + '_pos', width, height)

    param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
    texture.SetPixel(0, 0, *param)

    bpy.context.scene.frame_set(0)
    origins = {}
    for obj in objs:
        origins[obj] = obj.location.copy()

    if vertex_compress:
        FixUV_Dupe([obj.data for obj in objs], width, height)
    else:
        FixUV([obj.data for obj in objs], width, height)
    
    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()
        for obj in objs:
            eval_obj = obj.evaluated_get(depsgraph)
            mesh = eval_obj.to_mesh()
            uv_layer = eval_obj.data.uv_layers.get("VertexUV")
            for polygon in mesh.polygons:
                for i, loop_index in enumerate(polygon.loop_indices):
                    uv = uv_layer.data[loop_index].uv
                    pixel = [int(uv.y * height), int(uv.x * width)]
                    pixel[0] += (frame - start_frame) * column

                    vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co - origins[obj]
                    normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                        if hard_edge \
                        else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                    normal = normal.normalized()

                    texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()

def Main_VertexID(objs, max_resolution, hard_edge):
    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
-     vertex_max = GetVertexMax(objs)
+     vertex_max = GetVertexMax(objs, start_frame, end_frame)
    if vertex_max == -1:
        print("三角形以外のポリゴンが含まれています")
        return

    width, height, column = GetResolution(max_resolution, vertex_max, end_frame - start_frame + 1)
    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(objs[0].name + '_pos', width, height)

    param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
    texture.SetPixel(0, 0, *param)

    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()

        count = 0
        for obj in objs:
            eval_obj = obj.evaluated_get(depsgraph)
            mesh = eval_obj.to_mesh()
            for polygon in mesh.polygons:
                for i, loop_index in enumerate(polygon.loop_indices):
                    pixel = [count // width + 1, count % width]
                    pixel[0] += (frame - start_frame) * column

                    vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                    normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                        if hard_edge \
                        else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                    normal = normal.normalized()

                    texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

                    count += 1

    texture.Export()
    CreateObject(math.ceil(vertex_max / 3))


objs = bpy.context.selected_objects
hard_edge = True
vertex_compress = False
mock_object = True

if mock_object:
    Main_VertexID(objs, 4096, hard_edge)
else:
    Main_UV(objs, 4096, hard_edge, vertex_compress)

無事完成しました。

流体アニメーションに関してはポリゴン数が一定ではないため、モーションの線形補完が行えません。

スクリプト全体

import bpy
import math
import numpy as np
import struct

class TextureClass:
    def __init__(self, texture_name, width, height):
        self.image = bpy.data.images.get(texture_name)
        if not self.image:
            self.image = bpy.data.images.new(texture_name, width=width, height=height, alpha=True, float_buffer=True)
        elif self.image.size[0] != width or self.image.size[1] != height:
            self.image.scale(width, height)

        self.image.file_format = 'OPEN_EXR'

        self.point = np.array(self.image.pixels[:])
        self.point.resize(height, width * 4)
        self.point[:] = 0

        self.point_R = self.point[::, 0::4]
        self.point_G = self.point[::, 1::4]
        self.point_B = self.point[::, 2::4]
        self.point_A = self.point[::, 3::4]
    
    def SetPixel(self, py, px, r, g, b, a):
        self.point_R[py][px] = r
        self.point_G[py][px] = g
        self.point_B[py][px] = b
        self.point_A[py][px] = a

    def Export(self):
        self.image.pixels = self.point.flatten()


def GetVertexMax(objs, start_frame, end_frame):
    vertex_max = 0
    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()

        vertex = 0
        for obj in objs:
            mesh = obj.evaluated_get(depsgraph).to_mesh()
            for polygon in mesh.polygons:
                if len(polygon.vertices) >= 4:
                    return -1
                vertex += len(polygon.vertices)
        
        vertex_max = max(vertex_max, vertex)
    return vertex_max

def GetResolution(max_resolution, vertex_num, frame):
    height = -1
    width = -1
    column = 1
    
    for column in range(1, max_resolution + 1):
        for i in range(0, int(math.log2(max_resolution)) + 1):
            if vertex_num <= (1 << i) * column:
                width = 1 << i
                break
        if width != -1:
            break
            
    for i in range(0, int(math.log2(max_resolution)) + 1):
        if frame * column + 1 <= (1 << i):
            height = 1 << i
            break;
    
    return width, height, column

def FixUV(meshs, width, height):
    count = 0
    for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        for face in mesh.polygons:
            for i, loop_index in enumerate(face.loop_indices):
                uv_layer.data[loop_index].uv = [
                    count % width / width + 1 / (width * 2),
                    (count // width + 1) / height + 1 / (height * 2)
                    ]
                count += 1

def FixUV_Dupe(meshs, width, height):
    count = 0
    for mesh in meshs:
        uv_layer = mesh.uv_layers.get("VertexUV")
        if not uv_layer:
            uv_layer = mesh.uv_layers.new(name="VertexUV")
        
        seen_vertices = {}
        for vertex in mesh.vertices:
            vertex_co = vertex.co
            # 位置が重複していない場合のみ追加
            if tuple(vertex_co) not in seen_vertices:
                seen_vertices[tuple(vertex_co)] = None
        
        for polygon in mesh.polygons:
            for i, loop_index in enumerate(polygon.loop_indices):
                vertex_co = mesh.vertices[polygon.vertices[i]].co
                if tuple(vertex_co) in seen_vertices:
                    index = list(seen_vertices.keys()).index(tuple(vertex_co)) + count
                    uv_layer.data[loop_index].uv = [
                        index % width / width + 1 / (width * 2),
                        (index // width + 1) / height + 1 / (height * 2)
                        ]
                    
        count += len(seen_vertices)
    
def NormalToFloat(x, y, z):
    x_8bit, y_8bit, z_8bit = map(lambda v: int((v / 2 + 0.5) * 255), (x, y, z))
    packed_24bit = (x_8bit << 16) | (y_8bit << 8) | z_8bit
    return struct.unpack('!f', struct.pack('!I', packed_24bit))[0]

def ShortsToFloat(value1, value2):
    paced_32bit = (value1 << 16) | value2
    return struct.unpack('!f', struct.pack('!I', paced_32bit))[0]

def CreateObject(polygon_count):
    mesh = bpy.data.meshes.new(name="TriangleMesh")
    obj = bpy.data.objects.new("TriangleObject", mesh)
    bpy.context.collection.objects.link(obj)

    vertices = []
    faces = []
    for p in range(polygon_count):
        vertices.append((1, 0, p * 0.001))
        vertices.append((-1, 0, p * 0.001))
        vertices.append((0, 1, p * 0.001))
        faces.append((p * 3, p * 3 + 1, p * 3 + 2))

    mesh.from_pydata(vertices, [], faces)
    mesh.update()

def Main_UV(objs, max_resolution, hard_edge, vertex_compress):
    if vertex_compress:
        hard_edge = False

    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    vertex_num = sum(len(obj.data.vertices) for obj in objs) \
        if vertex_compress \
        else len([loop for obj in objs for polygon in obj.data.polygons for loop in polygon.loop_indices])
    width, height, column = GetResolution(max_resolution, vertex_num, end_frame - start_frame + 1)

    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(objs[0].name + '_pos', width, height)

    param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
    texture.SetPixel(0, 0, *param)

    bpy.context.scene.frame_set(0)
    origins = {}
    for obj in objs:
        origins[obj] = obj.location.copy()

    if vertex_compress:
        FixUV_Dupe([obj.data for obj in objs], width, height)
    else:
        FixUV([obj.data for obj in objs], width, height)
    
    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()
        for obj in objs:
            eval_obj = obj.evaluated_get(depsgraph)
            mesh = eval_obj.to_mesh()
            uv_layer = eval_obj.data.uv_layers.get("VertexUV")
            for polygon in mesh.polygons:
                for i, loop_index in enumerate(polygon.loop_indices):
                    uv = uv_layer.data[loop_index].uv
                    pixel = [int(uv.y * height), int(uv.x * width)]
                    pixel[0] += (frame - start_frame) * column

                    vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co - origins[obj]
                    normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                        if hard_edge \
                        else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                    normal = normal.normalized()

                    texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

    texture.Export()

def Main_VertexID(objs, max_resolution, hard_edge):
    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    vertex_max = GetVertexMax(objs, start_frame, end_frame)
    if vertex_max == -1:
        print("三角形以外のポリゴンが含まれています")
        return

    width, height, column = GetResolution(max_resolution, vertex_max, end_frame - start_frame + 1)
    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(objs[0].name + '_pos', width, height)

    param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
    texture.SetPixel(0, 0, *param)

    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()

        count = 0
        for obj in objs:
            eval_obj = obj.evaluated_get(depsgraph)
            mesh = eval_obj.to_mesh()
            for polygon in mesh.polygons:
                for i, loop_index in enumerate(polygon.loop_indices):
                    pixel = [count // width + 1, count % width]
                    pixel[0] += (frame - start_frame) * column

                    vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                    normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                        if hard_edge \
                        else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                    normal = normal.normalized()

                    texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

                    count += 1

    texture.Export()
    CreateObject(math.ceil(vertex_max / 3))


objs = bpy.context.selected_objects
resolution = 4096
hard_edge = True
vertex_compress = False
mock_object = True

if mock_object:
    Main_VertexID(objs, resolution, hard_edge)
else:
    Main_UV(objs, resolution, hard_edge, vertex_compress)

UV参照型シェーダー全体

Shader "nekoya/VAT"
{
    Properties
    {
        _Texture("Positon Texture", 2D) = "white" {}
        _Motion("Motion", Float) = 0.0
        [Toggle]_IsLerp("Is Lerp", Float) = 0.0
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float2 VertexUV : TEXCOORD1;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : TEXCOORD1;
            };

            sampler2D _MainTex, _Texture;
            float4 _MainTex_ST, _Texture_TexelSize;
            fixed4 _LightColor0;
            float _Motion;

            half3 NormalUnpack(float v){
                uint ix = asuint(v);
                half3 normal = half3((ix & 0x00FF0000) >> 16, (ix & 0x0000FF00) >> 8, ix & 0x000000FF);
                return ((normal / 255.0f) - 0.5f) * 2.0f;
            }

            void ShortUnpack(float v, out int v1, out int v2){
                uint ix = asuint(v);
                v1 = (ix & 0xFFFF0000) >> 16;
                v2 = (ix & 0x0000FFFF);
            }

            #pragma shader_feature _ISLERP_ON

            v2f vert (appdata v)
            {
                int column, maxMotion;
                float4 param = tex2Dlod(_Texture, 0);
                ShortUnpack(param.r, column, maxMotion);

                float motion = _Motion % maxMotion;
                float2 uv = v.VertexUV;
                uv.y += floor(motion) * _Texture_TexelSize.y * column;

                float4 tex = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos = float4(tex.r, tex.b, tex.g, v.vertex.w);
                half3 normal = NormalUnpack(tex.a);
                normal = normalize(half3(normal.x, normal.z, normal.y));
# ifdef _ISLERP_ON
                uv.y = (motion >= maxMotion - 1.0f)
                    ? v.VertexUV.y + _Texture_TexelSize.y * column
                    : v.VertexUV.y + ceil(motion) * _Texture_TexelSize.y * column;

                float4 tex2 = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos2 = float4(tex2.r, tex2.b, tex2.g, v.vertex.w);
                half3 normal2 = NormalUnpack(tex2.a);
                normal2 = normalize(half3(normal2.x, normal2.z, normal2.y));

                pos = lerp(pos, pos2, frac(motion));
                normal = lerp(normal, normal2, frac(motion));
#endif
                v2f o;
                o.vertex = UnityObjectToClipPos(pos);
                o.normal = UnityObjectToWorldNormal(normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                col.rgb *= clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
                return col;
            }
            ENDCG
        }
    }
}

頂点番号型シェーダー全体

Shader "nekoya/VAT_Vertex"
{
    Properties
    {
        _Texture("Positon Texture", 2D) = "white" {}
        _Motion("Motion", Float) = 0.0
        [Toggle]_IsLerp("Is Lerp", Float) = 0.0
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
        LOD 100
        Cull Off

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                half3 normal : TEXCOORD1;
            };

            sampler2D _Texture;
            float4 _Texture_TexelSize;
            fixed4 _LightColor0;
            float _Motion;

            half3 NormalUnpack(float v){
                uint ix = asuint(v);
                half3 normal = half3((ix & 0x00FF0000) >> 16, (ix & 0x0000FF00) >> 8, ix & 0x000000FF);
                return ((normal / 255.0f) - 0.5f) * 2.0f;
            }

            void ShortUnpack(float v, out int v1, out int v2){
                uint ix = asuint(v);
                v1 = (ix & 0xFFFF0000) >> 16;
                v2 = (ix & 0x0000FFFF);
            }

            #pragma shader_feature _ISLERP_ON

            v2f vert (appdata v, uint vid : SV_VertexID)
            {
                int column, maxMotion;
                float4 param = tex2Dlod(_Texture, 0);
                ShortUnpack(param.r, column, maxMotion);

                float motion = _Motion % maxMotion;
                float2 uv = float2(
                    float(vid) % _Texture_TexelSize.z * _Texture_TexelSize.x,
                    (int(float(vid) * _Texture_TexelSize.x) + 1.0f) * _Texture_TexelSize.y
                    );
                uv.y += floor(motion) * _Texture_TexelSize.y * column;

                float4 tex = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos = float4(tex.r, tex.b, tex.g, v.vertex.w);
                half3 normal = NormalUnpack(tex.a);
                normal = normalize(half3(normal.x, normal.z, normal.y));
# ifdef _ISLERP_ON
                uv.y = (int(float(vid) * _Texture_TexelSize.x) + 1.0f) * _Texture_TexelSize.y;
                uv.y += (motion >= maxMotion - 1.0f)
                    ? _Texture_TexelSize.y * column
                    : ceil(motion) * _Texture_TexelSize.y * column;

                float4 tex2 = tex2Dlod(_Texture, float4(uv, 0, 0));
                float4 pos2 = float4(tex2.r, tex2.b, tex2.g, v.vertex.w);
                half3 normal2 = NormalUnpack(tex2.a);
                normal2 = normalize(half3(normal2.x, normal2.z, normal2.y));

                pos = lerp(pos, pos2, frac(motion));
                normal = lerp(normal, normal2, frac(motion));
#endif
                v2f o;
                o.vertex = UnityObjectToClipPos(pos);
                o.normal = UnityObjectToWorldNormal(normal);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return clamp(dot(i.normal, _WorldSpaceLightPos0), .2f, .98f) * _LightColor0;
            }
            ENDCG
        }
    }
}

補足

別オブジェクトのUV転写

モックオブジェクトに対して元オブジェクトのUVを転写するスクリプトを作成しました。

#...

def CreateObject(polygon_count):
    mesh = bpy.data.meshes.new(name="TriangleMesh")
    obj = bpy.data.objects.new("TriangleObject", mesh)
    bpy.context.collection.objects.link(obj)

    vertices = []
    faces = []
    for p in range(polygon_count):
        vertices.append((1, 0, p * 0.001))
        vertices.append((-1, 0, p * 0.001))
        vertices.append((0, 1, p * 0.001))
        faces.append((p * 3, p * 3 + 1, p * 3 + 2))

    mesh.from_pydata(vertices, [], faces)
    mesh.update()
+     return obj

def Main_VertexID(objs, max_resolution, hard_edge):
    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    vertex_max = GetVertexMax(objs, start_frame, end_frame)
    if vertex_max == -1:
        print("三角形以外のポリゴンが含まれています")
        return

    width, height, column = GetResolution(max_resolution, vertex_max, end_frame - start_frame + 1)
    if width == -1 or height == -1:
        print("頂点数またはフレーム数が大きすぎます")
        return
    
    texture = TextureClass(objs[0].name + '_pos', width, height)

    param = [ShortsToFloat(column, end_frame - start_frame), 0, 0, 1]
    texture.SetPixel(0, 0, *param)

    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        bpy.context.view_layer.update()
        depsgraph = bpy.context.evaluated_depsgraph_get()

        count = 0
        for obj in objs:
            eval_obj = obj.evaluated_get(depsgraph)
            mesh = eval_obj.to_mesh()
            for polygon in mesh.polygons:
                for i, loop_index in enumerate(polygon.loop_indices):
                    pixel = [count // width + 1, count % width]
                    pixel[0] += (frame - start_frame) * column

                    vertex_pos = obj.matrix_world @ mesh.vertices[polygon.vertices[i]].co
                    normal = obj.matrix_world @ polygon.normal - obj.matrix_world.translation \
                        if hard_edge \
                        else obj.matrix_world @ mesh.vertices[polygon.vertices[i]].normal - obj.matrix_world.translation
                    normal = normal.normalized()

                    texture.SetPixel(*pixel, *vertex_pos, NormalToFloat(*normal))

                    count += 1

    texture.Export()
-     CreateObject(math.ceil(vertex_max / 3))
+     mock_obj = CreateObject(math.ceil(vertex_max / 3))
+     uv_layer = mock_obj.data.uv_layers.new(name="UVMap")
+     bpy.context.scene.frame_set(0)
+     bpy.context.view_layer.update()
+     depsgraph = bpy.context.evaluated_depsgraph_get()
+     count = 0
+     for obj in objs:
+         mesh = obj.evaluated_get(depsgraph).to_mesh()
+         ref_uv_layer = mesh.uv_layers.active
+         for polygon in mesh.polygons:
+             for i, loop_index in enumerate(polygon.loop_indices):
+                 uv_layer.data[count].uv = ref_uv_layer.data[loop_index].uv
+                 count += 1

#...

立方体2つのUVが転写できました。
テクスチャを適応します。

左が元オブジェクトで右がモックオブジェクトです。

見てわかる通り、線がずれています。
UV配置は一見ちゃんとしているのになぜでしょうか？
（1頂点ずつ転写しているためズレることは無いと思うのですが...）