devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Unity】万人同屏, 从入门到放弃之——自定义BatchRendererGroup合批渲染海量物体_unity batch renderer group

作者：Cpp五条 | 2024-02-15 19:19:17

赞

踩

unity batch renderer group

Unity万人同屏动态避障 GPU动画 Entities Graphics高性能合批渲染插件的使用_哔哩哔哩_bilibili

由于Dots的限制太多，对于需要dlc或热更的项目来说，Dots就爱莫能助。能不能不用Entities，只用Entities Graphics呢？

当然是可以的，Entities Graphics背后使用的接口就是Batch Renderer Group； 

自定义BatchRenderGroup合批渲染, 可以参考Unity官方文档：Initializing a BatchRendererGroup object - Unity 手册

1. 创建一个BatchRenderGroup对象和Graphics Buffer：

m_BRG = new BatchRendererGroup(this.OnPerformCulling, IntPtr.Zero);

m_InstanceData = new GraphicsBuffer(GraphicsBuffer.Target.Raw,
            BufferCountForInstances(kBytesPerInstance, kNumInstances, kExtraBytes),
            sizeof(int));

2. 注册需要渲染的Mesh和对应的Material:

m_MeshID = m_BRG.RegisterMesh(mesh);
m_MaterialID = m_BRG.RegisterMaterial(material); 

3. 为所有需要渲染的目标创建矩阵数组并传入Graphics Buffer里：

 m_InstanceData.SetData(objectToWorld, 0, (int)(byteAddressObjectToWorld / kSizeOfPackedMatrix), objectToWorld.Length);
        m_InstanceData.SetData(worldToObject, 0, (int)(byteAddressWorldToObject / kSizeOfPackedMatrix), worldToObject.Length);

4. 把Graphics Buffer添加到BatchRenderGroup进行批次渲染:

m_BatchID = m_BRG.AddBatch(metadata, m_InstanceData.bufferHandle);

创建BatchRenderGroup需要指定一个OnPerformCulling，在相机Culling时自动回调，这里可以直接使用Unity手册里的示例代码：Creating draw commands - Unity 手册

这里我主要测试的使用BatchRenderGroup合批渲染的性能，使用Job System多线程并行修改矩阵数组的位置和旋转，以控制小人移动起来。

控制小人移动的Job System代码如下：

  1. [BurstCompile]
  2. partial struct RandomMoveJob : IJobParallelFor
  3. {
  4.     [ReadOnly]
  5.     public Unity.Mathematics.Random random;
  6.     [ReadOnly]
  7.     public float4 randomPostionRange;
  8.     [ReadOnly]
  9.     public float m_DeltaTime;
  10.  
  11.     public NativeArray<Matrix4x4> matrices;
  12.     public NativeArray<float3> targetMovePoints;
  13.     public NativeArray<PackedMatrix> obj2WorldArr;
  14.     public NativeArray<PackedMatrix> world2ObjArr;
  15.     [BurstCompile]
  16.     public void Execute(int index)
  17.     {
  18.         float3 curPos = matrices[index].GetPosition();
  19.         float3 dir = targetMovePoints[index] - curPos;
  20.         if (Unity.Mathematics.math.lengthsq(dir) < 0.4f)
  21.         {
  22.             var newTargetPos = targetMovePoints[index];
  23.             newTargetPos.x = random.NextFloat(randomPostionRange.x, randomPostionRange.y);
  24.             newTargetPos.z = random.NextFloat(randomPostionRange.z, randomPostionRange.w);
  25.             targetMovePoints[index] = newTargetPos;
  26.         }
  27.  
  28.         dir = math.normalizesafe(targetMovePoints[index] - curPos, Vector3.forward);
  29.         curPos += dir * m_DeltaTime;// math.lerp(curPos, targetMovePoints[index], m_DeltaTime);
  30.  
  31.         var mat = matrices[index];
  32.         mat.SetTRS(curPos, Quaternion.LookRotation(dir), Vector3.one);
  33.         matrices[index] = mat;
  34.         var item = obj2WorldArr[index];
  35.         item.SetData(mat);
  36.         obj2WorldArr[index] = item;
  37.  
  38.         item = world2ObjArr[index];
  39.         item.SetData(mat.inverse);
  40.         world2ObjArr[index] = item;
  41.     }
  42. }

然后在主线程Update每帧Jobs逻辑，把Jobs运算结果传入Graphics Buffer更新即可：

  1. private void Update()
  2.     {
  3.         NativeArray<Matrix4x4> tempMatrices = new NativeArray<Matrix4x4>(matrices, Allocator.TempJob);
  4.         NativeArray<float3> tempTargetPoints = new NativeArray<float3>(m_TargetPoints, Allocator.TempJob);//worldToObject
  5.         NativeArray<PackedMatrix> tempobjectToWorldArr = new NativeArray<PackedMatrix>(matrices.Length, Allocator.TempJob);
  6.         NativeArray<PackedMatrix> tempWorldToObjectArr = new NativeArray<PackedMatrix>(matrices.Length, Allocator.TempJob);
  7.         random = new Unity.Mathematics.Random((uint)Time.frameCount);
  8.         var moveJob = new RandomMoveJob
  9.         {
  10.             matrices = tempMatrices,
  11.             targetMovePoints = tempTargetPoints,
  12.             random = random,
  13.             m_DeltaTime = Time.deltaTime * 4f,
  14.             randomPostionRange = m_randomRange,
  15.             obj2WorldArr = tempobjectToWorldArr,
  16.             world2ObjArr = tempWorldToObjectArr
  17.         };
  18.         var moveJobHandle = moveJob.Schedule(tempMatrices.Length, 64);
  19.         moveJobHandle.Complete();
  20.         matrices = moveJob.matrices.ToArray();
  21.         m_TargetPoints = moveJob.targetMovePoints.ToArray();
  22.         m_InstanceData.SetData(moveJob.obj2WorldArr, 0, (int)(byteAddressObjectToWorld / kSizeOfPackedMatrix), objectToWorld.Length);
  23.         m_InstanceData.SetData(moveJob.world2ObjArr, 0, (int)(byteAddressWorldToObject / kSizeOfPackedMatrix), worldToObject.Length);
  24.         tempMatrices.Dispose();
  25.         tempTargetPoints.Dispose();
  26.         tempobjectToWorldArr.Dispose();
  27.         tempWorldToObjectArr.Dispose();
  28.     }

Okay，跑起来看看：

 瞬间惊呆了，你没看错，使用Batch Renderer Group创建一万的小人居然能跑600多帧!!! 

难道万人同屏要成了？继续加大药量，创建10万个带有移动逻辑的小人：

 10万个奔跑的3D人物，仍然有100帧以上，有23个线程并行计算移动。

看看性能分析：

 当数量级庞大时，即使Job System + Burst编译再怎么开挂，主线程也会拖后腿的。

100万的压迫感，虽然已经成PPT了：

 难道万人同屏行业难题的门槛就这么被Unity Dots打下来了??

非也，上移动端测试：

同样1万个小人，PC端能达到惊人的600帧，而Android最强骁龙8 Gen2只有10多帧，而且工作线程数才5个； 当数量3000人时，手机端帧数46帧左右，相比传统方式没有任何提升！没错，没有任何提升。

Profiler中可以看到，瓶颈依然是GPU。 而Entities Graphics内部也是通过Batch Renderer Group接口实现，由此可以推断，被吹爆的Entities在移动端因该也是"水土不服"：

 结论：

目前为止，我认为使用自定义BatchRendererGroup合批是PC端万人同屏的最优解了。

但是手机端性能瓶颈任重道远。手机端放弃！

最后附上本文BatchRendererGroup测试代码：

  1. using System;
  2. using TMPro;
  3. using Unity.Burst;
  4. using Unity.Collections;
  5. using Unity.Collections.LowLevel.Unsafe;
  6. using Unity.Jobs;
  7. using Unity.Jobs.LowLevel.Unsafe;
  8. using Unity.Mathematics;
  9. using UnityEngine;
  10. using UnityEngine.Rendering;
  11.  
  12. // The PackedMatrix is a convenience type that converts matrices into
  13. // the format that Unity-provided SRP shaders expect.
  14. struct PackedMatrix
  15. {
  16.     public float c0x;
  17.     public float c0y;
  18.     public float c0z;
  19.     public float c1x;
  20.     public float c1y;
  21.     public float c1z;
  22.     public float c2x;
  23.     public float c2y;
  24.     public float c2z;
  25.     public float c3x;
  26.     public float c3y;
  27.     public float c3z;
  28.  
  29.     public PackedMatrix(Matrix4x4 m)
  30.     {
  31.         c0x = m.m00;
  32.         c0y = m.m10;
  33.         c0z = m.m20;
  34.         c1x = m.m01;
  35.         c1y = m.m11;
  36.         c1z = m.m21;
  37.         c2x = m.m02;
  38.         c2y = m.m12;
  39.         c2z = m.m22;
  40.         c3x = m.m03;
  41.         c3y = m.m13;
  42.         c3z = m.m23;
  43.     }
  44.  
  45.     public void SetData(Matrix4x4 m)
  46.     {
  47.         c0x = m.m00;
  48.         c0y = m.m10;
  49.         c0z = m.m20;
  50.         c1x = m.m01;
  51.         c1y = m.m11;
  52.         c1z = m.m21;
  53.         c2x = m.m02;
  54.         c2y = m.m12;
  55.         c2z = m.m22;
  56.         c3x = m.m03;
  57.         c3y = m.m13;
  58.         c3z = m.m23;
  59.     }
  60. }
  61. public class SimpleBRGExample : MonoBehaviour
  62. {
  63.     public Mesh mesh;
  64.     public Material material;
  65.     public TextMeshProUGUI text;
  66.     public TextMeshProUGUI workerCountText;
  67.     private BatchRendererGroup m_BRG;
  68.  
  69.     private GraphicsBuffer m_InstanceData;
  70.     private BatchID m_BatchID;
  71.     private BatchMeshID m_MeshID;
  72.     private BatchMaterialID m_MaterialID;
  73.  
  74.     // Some helper constants to make calculations more convenient.
  75.     private const int kSizeOfMatrix = sizeof(float) * 4 * 4;
  76.     private const int kSizeOfPackedMatrix = sizeof(float) * 4 * 3;
  77.     private const int kSizeOfFloat4 = sizeof(float) * 4;
  78.     private const int kBytesPerInstance = (kSizeOfPackedMatrix * 2) + kSizeOfFloat4;
  79.     private const int kExtraBytes = kSizeOfMatrix * 2;
  80.     [SerializeField] private int kNumInstances = 20000;
  81.     [SerializeField] private int m_RowCount = 200;
  82.     private Matrix4x4[] matrices;
  83.     private PackedMatrix[] objectToWorld;
  84.     private PackedMatrix[] worldToObject;
  85.     private Vector4[] colors;
  86.  
  87.     private void Start()
  88.     {
  89.         m_BRG = new BatchRendererGroup(this.OnPerformCulling, IntPtr.Zero);
  90.         m_MeshID = m_BRG.RegisterMesh(mesh);
  91.         m_MaterialID = m_BRG.RegisterMaterial(material);
  92.         AllocateInstanceDateBuffer();
  93.         PopulateInstanceDataBuffer();
  94.  
  95.         text.text = kNumInstances.ToString();
  96.         random = new Unity.Mathematics.Random(1);
  97.         m_TargetPoints = new float3[kNumInstances];
  98.         var offset = new Vector3(m_RowCount, 0, Mathf.CeilToInt(kNumInstances / (float)m_RowCount)) * 0.5f;
  99.         m_randomRange = new float4(-offset.x, offset.x, -offset.z, offset.z);
  100.         for (int i = 0; i < m_TargetPoints.Length; i++)
  101.         {
  102.             var newTargetPos = new float3();
  103.             newTargetPos.x = random.NextFloat(m_randomRange.x, m_randomRange.y);
  104.             newTargetPos.z = random.NextFloat(m_randomRange.z, m_randomRange.w);
  105.             m_TargetPoints[i] = newTargetPos;
  106.         }
  107.         
  108.     }
  109.  
  110.     float3[] m_TargetPoints;
  111.     Unity.Mathematics.Random random;
  112.     Vector4 m_randomRange;
  113.     private uint byteAddressObjectToWorld;
  114.     private uint byteAddressWorldToObject;
  115.     private uint byteAddressColor;
  116.  
  117.     private void Update()
  118.     {
  119.         NativeArray<Matrix4x4> tempMatrices = new NativeArray<Matrix4x4>(matrices, Allocator.TempJob);
  120.         NativeArray<float3> tempTargetPoints = new NativeArray<float3>(m_TargetPoints, Allocator.TempJob);//worldToObject
  121.         NativeArray<PackedMatrix> tempobjectToWorldArr = new NativeArray<PackedMatrix>(matrices.Length, Allocator.TempJob);
  122.         NativeArray<PackedMatrix> tempWorldToObjectArr = new NativeArray<PackedMatrix>(matrices.Length, Allocator.TempJob);
  123.         random = new Unity.Mathematics.Random((uint)Time.frameCount);
  124.         var moveJob = new RandomMoveJob
  125.         {
  126.             matrices = tempMatrices,
  127.             targetMovePoints = tempTargetPoints,
  128.             random = random,
  129.             m_DeltaTime = Time.deltaTime * 4f,
  130.             randomPostionRange = m_randomRange,
  131.             obj2WorldArr = tempobjectToWorldArr,
  132.             world2ObjArr = tempWorldToObjectArr
  133.         };
  134.         var moveJobHandle = moveJob.Schedule(tempMatrices.Length, 64);
  135.         moveJobHandle.Complete();
  136.         matrices = moveJob.matrices.ToArray();
  137.         m_TargetPoints = moveJob.targetMovePoints.ToArray();
  138.         m_InstanceData.SetData(moveJob.obj2WorldArr, 0, (int)(byteAddressObjectToWorld / kSizeOfPackedMatrix), objectToWorld.Length);
  139.         m_InstanceData.SetData(moveJob.world2ObjArr, 0, (int)(byteAddressWorldToObject / kSizeOfPackedMatrix), worldToObject.Length);
  140.         tempMatrices.Dispose();
  141.         tempTargetPoints.Dispose();
  142.         tempobjectToWorldArr.Dispose();
  143.         tempWorldToObjectArr.Dispose();
  144.  
  145.         workerCountText.text = $"JobWorkerCount:{JobsUtility.JobWorkerCount}";
  146.     }
  147.  
  148.     private void AllocateInstanceDateBuffer()
  149.     {
  150.         m_InstanceData = new GraphicsBuffer(GraphicsBuffer.Target.Raw,
  151.             BufferCountForInstances(kBytesPerInstance, kNumInstances, kExtraBytes),
  152.             sizeof(int));
  153.     }
  154.     private void RefreshData()
  155.     {
  156.         m_InstanceData.SetData(objectToWorld, 0, (int)(byteAddressObjectToWorld / kSizeOfPackedMatrix), objectToWorld.Length);
  157.         m_InstanceData.SetData(worldToObject, 0, (int)(byteAddressWorldToObject / kSizeOfPackedMatrix), worldToObject.Length);
  158.     }
  159.     private void PopulateInstanceDataBuffer()
  160.     {
  161.         // Place a zero matrix at the start of the instance data buffer, so loads from address 0 return zero.
  162.         var zero = new Matrix4x4[1] { Matrix4x4.zero };
  163.  
  164.         // Create transform matrices for three example instances.
  165.         matrices = new Matrix4x4[kNumInstances];
  166.         // Convert the transform matrices into the packed format that shaders expects.
  167.         objectToWorld = new PackedMatrix[kNumInstances];
  168.         // Also create packed inverse matrices.
  169.         worldToObject = new PackedMatrix[kNumInstances];
  170.         // Make all instances have unique colors.
  171.         colors = new Vector4[kNumInstances];
  172.  
  173.         var offset = new Vector3(m_RowCount, 0, Mathf.CeilToInt(kNumInstances / (float)m_RowCount)) * 0.5f;
  174.         for (int i = 0; i < kNumInstances; i++)
  175.         {
  176.             matrices[i] = Matrix4x4.Translate(new Vector3(i % m_RowCount, 0, i / m_RowCount) - offset);
  177.             objectToWorld[i] = new PackedMatrix(matrices[i]);
  178.             worldToObject[i] = new PackedMatrix(matrices[0].inverse);
  179.             colors[i] = UnityEngine.Random.ColorHSV();
  180.         }
  181.  
  182.         // In this simple example, the instance data is placed into the buffer like this:
  183.         // Offset | Description
  184.         //      0 | 64 bytes of zeroes, so loads from address 0 return zeroes
  185.         //     64 | 32 uninitialized bytes to make working with SetData easier, otherwise unnecessary
  186.         //     96 | unity_ObjectToWorld, three packed float3x4 matrices
  187.         //    240 | unity_WorldToObject, three packed float3x4 matrices
  188.         //    384 | _BaseColor, three float4s
  189.  
  190.         // Calculates start addresses for the different instanced properties. unity_ObjectToWorld starts at 
  191.         // address 96 instead of 64 which means 32 bits are left uninitialized. This is because the 
  192.         // computeBufferStartIndex parameter requires the start offset to be divisible by the size of the source
  193.         // array element type. In this case, it's the size of PackedMatrix, which is 48.
  194.         byteAddressObjectToWorld = kSizeOfPackedMatrix * 2;
  195.         byteAddressWorldToObject = byteAddressObjectToWorld + kSizeOfPackedMatrix * (uint)kNumInstances;
  196.         byteAddressColor = byteAddressWorldToObject + kSizeOfPackedMatrix * (uint)kNumInstances;
  197.  
  198.         // Upload the instance data to the GraphicsBuffer so the shader can load them.
  199.         m_InstanceData.SetData(zero, 0, 0, 1);
  200.         m_InstanceData.SetData(objectToWorld, 0, (int)(byteAddressObjectToWorld / kSizeOfPackedMatrix), objectToWorld.Length);
  201.         m_InstanceData.SetData(worldToObject, 0, (int)(byteAddressWorldToObject / kSizeOfPackedMatrix), worldToObject.Length);
  202.         m_InstanceData.SetData(colors, 0, (int)(byteAddressColor / kSizeOfFloat4), colors.Length);
  203.  
  204.         // Set up metadata values to point to the instance data. Set the most significant bit 0x80000000 in each
  205.         // which instructs the shader that the data is an array with one value per instance, indexed by the instance index.
  206.         // Any metadata values that the shader uses and not set here will be zero. When such a value is used with
  207.         // UNITY_ACCESS_DOTS_INSTANCED_PROP (i.e. without a default), the shader interprets the
  208.         // 0x00000000 metadata value and loads from the start of the buffer. The start of the buffer which is
  209.         // is a zero matrix so this sort of load is guaranteed to return zero, which is a reasonable default value.
  210.         var metadata = new NativeArray<MetadataValue>(3, Allocator.Temp);
  211.         metadata[0] = new MetadataValue { NameID = Shader.PropertyToID("unity_ObjectToWorld"), Value = 0x80000000 | byteAddressObjectToWorld, };
  212.         metadata[1] = new MetadataValue { NameID = Shader.PropertyToID("unity_WorldToObject"), Value = 0x80000000 | byteAddressWorldToObject, };
  213.         metadata[2] = new MetadataValue { NameID = Shader.PropertyToID("_BaseColor"), Value = 0x80000000 | byteAddressColor, };
  214.  
  215.         // Finally, create a batch for the instances, and make the batch use the GraphicsBuffer with the
  216.         // instance data, as well as the metadata values that specify where the properties are. 
  217.         m_BatchID = m_BRG.AddBatch(metadata, m_InstanceData.bufferHandle);
  218.     }
  219.  
  220.     // Raw buffers are allocated in ints. This is a utility method that calculates
  221.     // the required number of ints for the data.
  222.     int BufferCountForInstances(int bytesPerInstance, int numInstances, int extraBytes = 0)
  223.     {
  224.         // Round byte counts to int multiples
  225.         bytesPerInstance = (bytesPerInstance + sizeof(int) - 1) / sizeof(int) * sizeof(int);
  226.         extraBytes = (extraBytes + sizeof(int) - 1) / sizeof(int) * sizeof(int);
  227.         int totalBytes = bytesPerInstance * numInstances + extraBytes;
  228.         return totalBytes / sizeof(int);
  229.     }
  230.  
  231.  
  232.     private void OnDisable()
  233.     {
  234.         m_BRG.Dispose();
  235.     }
  236.  
  237.     public unsafe JobHandle OnPerformCulling(
  238.         BatchRendererGroup rendererGroup,
  239.         BatchCullingContext cullingContext,
  240.         BatchCullingOutput cullingOutput,
  241.         IntPtr userContext)
  242.     {
  243.         // UnsafeUtility.Malloc() requires an alignment, so use the largest integer type's alignment
  244.         // which is a reasonable default.
  245.         int alignment = UnsafeUtility.AlignOf<long>();
  246.  
  247.         // Acquire a pointer to the BatchCullingOutputDrawCommands struct so you can easily
  248.         // modify it directly.
  249.         var drawCommands = (BatchCullingOutputDrawCommands*)cullingOutput.drawCommands.GetUnsafePtr();
  250.         // Allocate memory for the output arrays. In a more complicated implementation, you would calculate
  251.         // the amount of memory to allocate dynamically based on what is visible.
  252.         // This example assumes that all of the instances are visible and thus allocates
  253.         // memory for each of them. The necessary allocations are as follows:
  254.         // - a single draw command (which draws kNumInstances instances)
  255.         // - a single draw range (which covers our single draw command)
  256.         // - kNumInstances visible instance indices.
  257.         // You must always allocate the arrays using Allocator.TempJob.
  258.         drawCommands->drawCommands = (BatchDrawCommand*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<BatchDrawCommand>(), alignment, Allocator.TempJob);
  259.         drawCommands->drawRanges = (BatchDrawRange*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<BatchDrawRange>(), alignment, Allocator.TempJob);
  260.         drawCommands->visibleInstances = (int*)UnsafeUtility.Malloc(kNumInstances * sizeof(int), alignment, Allocator.TempJob);
  261.         drawCommands->drawCommandPickingInstanceIDs = null;
  262.  
  263.         drawCommands->drawCommandCount = 1;
  264.         drawCommands->drawRangeCount = 1;
  265.         drawCommands->visibleInstanceCount = kNumInstances;
  266.  
  267.         // This example doens't use depth sorting, so it leaves instanceSortingPositions as null.
  268.         drawCommands->instanceSortingPositions = null;
  269.         drawCommands->instanceSortingPositionFloatCount = 0;
  270.  
  271.         // Configure the single draw command to draw kNumInstances instances
  272.         // starting from offset 0 in the array, using the batch, material and mesh
  273.         // IDs registered in the Start() method. It doesn't set any special flags.
  274.         drawCommands->drawCommands[0].visibleOffset = 0;
  275.         drawCommands->drawCommands[0].visibleCount = (uint)kNumInstances;
  276.         drawCommands->drawCommands[0].batchID = m_BatchID;
  277.         drawCommands->drawCommands[0].materialID = m_MaterialID;
  278.         drawCommands->drawCommands[0].meshID = m_MeshID;
  279.         drawCommands->drawCommands[0].submeshIndex = 0;
  280.         drawCommands->drawCommands[0].splitVisibilityMask = 0xff;
  281.         drawCommands->drawCommands[0].flags = 0;
  282.         drawCommands->drawCommands[0].sortingPosition = 0;
  283.  
  284.         // Configure the single draw range to cover the single draw command which
  285.         // is at offset 0.
  286.         drawCommands->drawRanges[0].drawCommandsBegin = 0;
  287.         drawCommands->drawRanges[0].drawCommandsCount = 1;
  288.  
  289.         // This example doesn't care about shadows or motion vectors, so it leaves everything
  290.         // at the default zero values, except the renderingLayerMask which it sets to all ones
  291.         // so Unity renders the instances regardless of mask settings.
  292.         drawCommands->drawRanges[0].filterSettings = new BatchFilterSettings { renderingLayerMask = 0xffffffff, };
  293.  
  294.         // Finally, write the actual visible instance indices to the array. In a more complicated
  295.         // implementation, this output would depend on what is visible, but this example
  296.         // assumes that everything is visible.
  297.         for (int i = 0; i < kNumInstances; ++i)
  298.             drawCommands->visibleInstances[i] = i;
  299.  
  300.         // This simple example doesn't use jobs, so it returns an empty JobHandle.
  301.         // Performance-sensitive applications are encouraged to use Burst jobs to implement
  302.         // culling and draw command output. In this case, this function returns a
  303.         // handle here that completes when the Burst jobs finish.
  304.         return new JobHandle();
  305.     }
  306. }
  307. [BurstCompile]
  308. partial struct RandomMoveJob : IJobParallelFor
  309. {
  310.     [ReadOnly]
  311.     public Unity.Mathematics.Random random;
  312.     [ReadOnly]
  313.     public float4 randomPostionRange;
  314.     [ReadOnly]
  315.     public float m_DeltaTime;
  316.  
  317.     public NativeArray<Matrix4x4> matrices;
  318.     public NativeArray<float3> targetMovePoints;
  319.     public NativeArray<PackedMatrix> obj2WorldArr;
  320.     public NativeArray<PackedMatrix> world2ObjArr;
  321.     [BurstCompile]
  322.     public void Execute(int index)
  323.     {
  324.         float3 curPos = matrices[index].GetPosition();
  325.         float3 dir = targetMovePoints[index] - curPos;
  326.         if (Unity.Mathematics.math.lengthsq(dir) < 0.4f)
  327.         {
  328.             var newTargetPos = targetMovePoints[index];
  329.             newTargetPos.x = random.NextFloat(randomPostionRange.x, randomPostionRange.y);
  330.             newTargetPos.z = random.NextFloat(randomPostionRange.z, randomPostionRange.w);
  331.             targetMovePoints[index] = newTargetPos;
  332.         }
  333.  
  334.         dir = math.normalizesafe(targetMovePoints[index] - curPos, Vector3.forward);
  335.         curPos += dir * m_DeltaTime;// math.lerp(curPos, targetMovePoints[index], m_DeltaTime);
  336.  
  337.         var mat = matrices[index];
  338.         mat.SetTRS(curPos, Quaternion.LookRotation(dir), Vector3.one);
  339.         matrices[index] = mat;
  340.         var item = obj2WorldArr[index];
  341.         item.SetData(mat);
  342.         obj2WorldArr[index] = item;
  343.  
  344.         item = world2ObjArr[index];
  345.         item.SetData(mat.inverse);
  346.         world2ObjArr[index] = item;
  347.     }
  348. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/86204
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号