重新导入obi

Assets/Obi/Scripts/Common/Backends/Burst/Constraints/BurstConstraintsBatchImpl.cs

@@ -0,0 +1,109 @@
+#if (OBI_BURST && OBI_MATHEMATICS && OBI_COLLECTIONS)
+using UnityEngine;
+using Unity.Burst;
+using Unity.Jobs;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using Unity.Mathematics;
+using System.Collections;
+
+namespace Obi
+{
+    public abstract class BurstConstraintsBatchImpl : IConstraintsBatchImpl
+    {
+        protected IBurstConstraintsImpl m_Constraints;
+        protected Oni.ConstraintType m_ConstraintType;
+
+        protected bool m_Enabled = true;
+        protected int m_ConstraintCount = 0;
+
+        public Oni.ConstraintType constraintType
+        {
+            get { return m_ConstraintType; }
+        }
+
+        public bool enabled
+        {
+            set
+            {
+                if (m_Enabled != value)
+                    m_Enabled = value;
+            }
+            get { return m_Enabled; }
+        }
+
+        public IConstraints constraints
+        {
+            get { return m_Constraints; }
+        }
+
+        public ObiSolver solverAbstraction
+        {
+            get { return ((BurstSolverImpl)m_Constraints.solver).abstraction; }
+        }
+
+        public BurstSolverImpl solverImplementation
+        {
+            get { return (BurstSolverImpl)m_Constraints.solver; }
+        }
+
+        protected NativeArray<int> particleIndices;
+        protected NativeArray<float> lambdas;
+
+        public virtual JobHandle Initialize(JobHandle inputDeps, float substepTime)
+        {
+            if (lambdas.IsCreated)
+            {
+                // no need for jobs here, memclear is faster and we don't pay scheduling overhead.
+                unsafe
+                {
+                    UnsafeUtility.MemClear(NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(lambdas),
+                                           lambdas.Length * UnsafeUtility.SizeOf<float>());
+                }
+            }
+            return inputDeps;
+        }
+
+        // implemented by concrete constraint subclasses.
+        public abstract JobHandle Evaluate(JobHandle inputDeps, float stepTime, float substepTime, int substeps);
+        public abstract JobHandle Apply(JobHandle inputDeps, float substepTime);
+
+        public virtual void Destroy()
+        {
+            // clean resources allocated by the batch, no need for a default implementation.
+        }
+
+        public void SetConstraintCount(int constraintCount)
+        {
+            m_ConstraintCount = constraintCount;
+        }
+        public int GetConstraintCount()
+        {
+            return m_ConstraintCount;
+        }
+
+        public static void ApplyPositionDelta(int particleIndex, float sorFactor, ref NativeArray<float4> positions, ref NativeArray<float4> deltas, ref NativeArray<int> counts)
+        {
+            if (counts[particleIndex] > 0)
+            {
+                positions[particleIndex] += deltas[particleIndex] * sorFactor / counts[particleIndex];
+                deltas[particleIndex] = float4.zero;
+                counts[particleIndex] = 0;
+            }
+        }
+
+        public static void ApplyOrientationDelta(int particleIndex, float sorFactor, ref NativeArray<quaternion> orientations, ref NativeArray<quaternion> deltas, ref NativeArray<int> counts)
+        {
+            if (counts[particleIndex] > 0)
+            {
+                quaternion q = orientations[particleIndex];
+                q.value += deltas[particleIndex].value * sorFactor / counts[particleIndex];
+                orientations[particleIndex] = math.normalize(q);
+
+                deltas[particleIndex] = new quaternion(0, 0, 0, 0);
+                counts[particleIndex] = 0;
+            }
+        }
+    }
+}
+#endif