unity 一万个量具有相同动画的物体渲染

• 先显示效果，帧率在70左右
• 性能分析
• 大量具有相同动画的物体，首先想到的是GPU Instancing
• • 首先Skin Mesh合并，一个物体下面的所有mesh合并，并且共用一个材质球。（这一步目前没做）
  • 设置一个结构体，这个结构体里面有物体的位置和角度信息。通过job system，转换为本地2世界坐标矩阵
  • 得到物体每帧动画的mesh，然后用GPU Instancing大批量渲染这些mesh。
• C#代码
• 调用代码，渲染一万个物体
• shader代码

首先说明本人机器CPU是 i5-7400，GPU是GTX 1060 3G。模型三角面大约2K，分辨率1080P。

先显示效果，帧率在70左右

性能分析

渲染阴影大约用时2ms

渲染物体大约用时2.3ms

渲染一万个物体 cpu一共耗时2.3ms

BaseRenderStruct[] baseRenderStructs = new BaseRenderStruct[10000];
for (int i = 0; i < 100; i++)
{
    for (int j = 0; j < 100; j++)
    {
        baseRenderStructs[i*100+j].position = new War.Vector2(j,i);
        baseRenderStructs[i*100+j].rotation = j * 36;
    }
    
}


 Observable.EveryUpdate()
     .Subscribe(_ =>
    {
         Profiler.BeginSample("CharacterRender");
         m_renderManger.DrawCharacterInstanced(baseRenderStructs);
         Profiler.EndSample();
     });

大量具有相同动画的物体，首先想到的是GPU Instancing

物体具有动画和Skinned Mesh，而且mesh不只有一个。物体可以投射阴影和接受阴影。思想如下：

首先Skin Mesh合并，一个物体下面的所有mesh合并，并且共用一个材质球。（这一步目前没做）

链接: SkinMesh合并

设置一个结构体，这个结构体里面有物体的位置和角度信息。通过job system，转换为本地2世界坐标矩阵

public struct BaseRenderStruct
{
    public Vector2 position;
    public float rotation;
}

public struct MyParallelJob : IJobParallelFor
{
    [ReadOnly]
    public NativeArray<BaseRenderStruct> datas;

    [ReadOnly] public Matrix4x4 selfRotation;
    public NativeArray<Matrix4x4> result;

    public void Execute(int i)
    {
        Matrix4x4 mat = Matrix4x4.identity;
        mat.m03 = (float) datas[i].position.x;
        mat.m13 = 0.0f;
        mat.m23 = (float) datas[i].position.y;
        result[i] = mat * Matrix4x4.Rotate(Quaternion.Euler(0, datas[i].rotation - 90, 0)) * selfRotation;
    }
}

得到物体每帧动画的mesh，然后用GPU Instancing大批量渲染这些mesh。

这里主要使用skinnedMeshRenderers.BakeMesh的方法烘培一个Mesh。
然后用Graphics.DrawMesh绘制大量Mesh。

C#代码

// 渲染结构体
public struct BaseRenderStruct
{
    public Vector2 position;
    public float rotation;
}

public class Player3DCharacterRender
{
    private List<SkinnedMeshRenderer> m_skinnedMeshRenderers;
    private List<Mesh> m_animedMeshs;

    private int m_CurFrameCount = -1;
    private float m_StartTime;
    private Animator m_Animator;
    private GameObject m_go;
    private AnimationClip m_clip;
    private Matrix4x4 m_selfRotation;
    MyParallelJob myParallelJob;
    public void Init(GameObject go)
    {
        m_go = go;
        m_StartTime = Time.time;
        m_skinnedMeshRenderers = new List<SkinnedMeshRenderer>();
        m_animedMeshs = new List<Mesh>();
        m_Animator = m_go.GetComponent<Animator>();
        m_selfRotation = Matrix4x4.Rotate(Quaternion.Euler(-90, 0, 0));
        SkinnedMeshRenderer[] skinnedMeshRenderers = m_go.GetComponentsInChildren<SkinnedMeshRenderer>();
        foreach (var skinnedMeshRenderer in skinnedMeshRenderers)
        {
            m_skinnedMeshRenderers.Add(skinnedMeshRenderer);
            m_animedMeshs.Add(new Mesh());
        }
        foreach (var clip in m_Animator.runtimeAnimatorController.animationClips)
        {
            if (clip.name.Equals("run(WeaponOneHand)"))
            {
                m_clip = clip;
                break;
            }
        }
        
        myParallelJob = new MyParallelJob();
        myParallelJob.selfRotation = m_selfRotation;
    }
    
    public void Render(BaseRenderStruct data)
    {
        if(m_go == null)
            return;
        if(m_CurFrameCount != Time.frameCount)
            BakeMesh();
        MaterialPropertyBlock properties = new MaterialPropertyBlock();
        Matrix4x4 m;
        CalculateWorldMatAndPlayIndex(data, out m);
        for (int i = 0; i < m_animedMeshs.Count; i++)
        {
            Graphics.DrawMesh(m_animedMeshs[i] ,m,m_skinnedMeshRenderers[i].sharedMaterial,0,Camera.main,0,properties,ShadowCastingMode.On);
        }
    }
    
    public void Render(BaseRenderStruct[] data)
    {
        if(m_go == null)
            return;
        if(m_CurFrameCount != Time.frameCount)
            BakeMesh();

        int group = data.Length / 1000;
        group += data.Length % 1000 > 0 ? 1 : 0;
        MaterialPropertyBlock properties = new MaterialPropertyBlock();
        
        /*for(int i = 0;i<data.Length;i++)
           CalculateWorldMatAndPlayIndex(data[i], out m[i]);*/
        myParallelJob.datas = new NativeArray<BaseRenderStruct>(data.Length, Allocator.TempJob);
        myParallelJob.datas.CopyFrom(data);
        NativeArray<Matrix4x4> result = new NativeArray<Matrix4x4>(data.Length, Allocator.TempJob);
        myParallelJob.result = result;
        JobHandle handle = myParallelJob.Schedule(data.Length, 1);

        handle.Complete();
        Matrix4x4[] m = result.ToArray();
        Matrix4x4[] subM = new Matrix4x4[1000];
        for (int n = 0; n < group; n++)
        {
            int count = data.Length - n * 1000;
            count = count > 1000 ? 1000 : count;
            Array.Copy(m, n * 1000, subM, 0, count);
            for (int i = 0; i < m_animedMeshs.Count; i++)
            {
                Graphics.DrawMeshInstanced(m_animedMeshs[i] ,0,m_skinnedMeshRenderers[i].sharedMaterial,subM,count,properties);
            }
        }
        

        myParallelJob.datas.Dispose();
        result.Dispose();
    }

    void CalculateWorldMatAndPlayIndex(BaseRenderStruct data ,out Matrix4x4 mat)
    {
        mat = Matrix4x4.identity;
        mat.m03 = (float) data.position.x;
        mat.m13 = 0.0f;
        mat.m23 = (float) data.position.y;
        mat =  mat*Matrix4x4.Rotate(Quaternion.Euler(0,data.rotation - 90,0))*m_selfRotation;
    }
    
    public struct MyParallelJob : IJobParallelFor
    {
        [ReadOnly]
        public NativeArray<BaseRenderStruct> datas;

        [ReadOnly] public Matrix4x4 selfRotation;
        public NativeArray<Matrix4x4> result;

        public void Execute(int i)
        {
            Matrix4x4 mat = Matrix4x4.identity;
            mat.m03 = (float) datas[i].position.x;
            mat.m13 = 0.0f;
            mat.m23 = (float) datas[i].position.y;
            result[i] = mat * Matrix4x4.Rotate(Quaternion.Euler(0, datas[i].rotation - 90, 0)) * selfRotation;
        }
    }

    void BakeMesh()
    {
        m_CurFrameCount = Time.frameCount;
        float time = (Time.time - m_StartTime) % m_clip.length;
        m_clip.SampleAnimation(m_go, time);
        for (int i = 0; i < m_skinnedMeshRenderers.Count; i++)
        {
            m_animedMeshs[i].Clear();
            m_skinnedMeshRenderers[i].BakeMesh(m_animedMeshs[i]);
        }
    }
}

调用代码，渲染一万个物体

// A code block
BaseRenderStruct[] baseRenderStructs = new BaseRenderStruct[10000];
for (int i = 0; i < 100; i++)
{
    for (int j = 0; j < 100; j++)
    {
        baseRenderStructs[i*100+j].position = new War.Vector2(j,i);
        baseRenderStructs[i*100+j].rotation = j * 36;
    }
    
}


 Observable.EveryUpdate()
     .Subscribe(_ =>
    {
         Profiler.BeginSample("CharacterRender");
         m_renderManger.DrawCharacterInstanced(baseRenderStructs);
         Profiler.EndSample();
     });

shader代码

Shader "Unlit/CharacterDefault"
{
    Properties
    {
        _BaseMap ("Base Texture",2D) = "white"{}
        _BaseColor("Base Color",Color)=(1,1,1,1)
        [Toggle]_IsSpecular("是否开启高光", Float) = 1
    }
    SubShader
    {
        Tags
        {
            "RenderPipeline"="UniversalPipeline"
            "Queue"="Geometry"
            "RenderType"="Opaque"
        }
        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
        #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"
       
        CBUFFER_START(UnityPerMaterial)
        float4 _BaseMap_ST;
        half4 _BaseColor;
        half _IsSpecular;
        CBUFFER_END
        ENDHLSL

        Pass
        {
            Tags{"LightMode"="UniversalForward"}

            HLSLPROGRAM //CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_instancing
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE

            struct Attributes
            {
                float4 positionOS : POSITION;
                float4 normalOS : NORMAL;
                float2 uv : TEXCOORD;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            struct Varings//这就是v2f
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD;
                float3 positionWS : TEXCOORD1;
                float3 viewDirWS : TEXCOORD2;
                float3 normalWS : TEXCOORD3;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);

            Varings vert(Attributes IN)
            {
                Varings OUT;
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_TRANSFER_INSTANCE_ID(IN, OUT);
                VertexPositionInputs positionInputs = GetVertexPositionInputs(IN.positionOS.xyz);
                VertexNormalInputs normalInputs = GetVertexNormalInputs(IN.normalOS.xyz);
                OUT.positionCS = positionInputs.positionCS;
                  
                OUT.uv=TRANSFORM_TEX(IN.uv,_BaseMap);
                OUT.positionWS = positionInputs.positionWS;
                OUT.viewDirWS = GetCameraPositionWS() - positionInputs.positionWS;
                OUT.normalWS = normalInputs.normalWS;
                return OUT;
            }

            float4 frag(Varings IN):SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, IN.uv);
                float4 SHADOW_COORDS = TransformWorldToShadowCoord(IN.positionWS);
                Light light = GetMainLight(SHADOW_COORDS);
                half3 n = normalize(IN.normalWS);
                half3 v = normalize(IN.viewDirWS);
                half3 h = normalize(light.direction + v);
                
                
                half nl = max(0.0,dot(light.direction ,n));
                half nh = max(0.0,dot(h ,n));
                
                half atten = step(0.5, light.shadowAttenuation);
                half3 diffuse = atten * lerp(0.5*baseMap.xyz ,baseMap.xyz ,nl) + (1 - atten) * 0.4 * baseMap.xyz * light.color ;
                half3 specular = _IsSpecular * atten * light.color * step(0.8,pow(nh ,8));
                
                
                uint pixelLightCount = GetAdditionalLightsCount();
                for (uint lightIndex = 0; lightIndex < pixelLightCount; ++lightIndex)
                {
                    Light add_light = GetAdditionalLight(lightIndex, IN.positionWS);
                    half3 add_h = normalize(add_light.direction + v);
                
                
                    half add_nl = max(0.0,dot(add_light.direction ,n));
                    half add_nh = max(0.0,dot(add_h ,n));
                    diffuse += baseMap.xyz * add_nl* add_light.color * add_light.distanceAttenuation;
                    specular += _IsSpecular * add_light.color * add_light.distanceAttenuation * step(0.8,pow(add_nh ,8));
                }
                half3 color=diffuse*_BaseColor.xyz;
                           
                return half4(color ,1.0);
            }
            ENDHLSL  //ENDCG          
        }
        
        pass {
			Tags{ "LightMode" = "ShadowCaster" }
			HLSLPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile_instancing
 
			struct Attributes
			{
				float4 vertex : POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
			};
 
			struct Varings
			{
				float4 pos : SV_POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
			};
 
			sampler2D _MainTex;
			float4 _MainTex_ST;
 
			Varings vert(Attributes v)
			{
				Varings o = (Varings)0;
				UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
				o.pos = mul(UNITY_MATRIX_MVP,v.vertex);
				return o;
			}
			float4 frag(Varings i) : SV_Target
			{
			    UNITY_SETUP_INSTANCE_ID(i);
				return half4(0.0,0.0,0.0,1.0);
			}
			ENDHLSL
		}
    }
}