refactor: b2GetSweepTransform(ref B2Sweep sweep, -> b2GetSweepTransform(in B2Sweep sweep

Author: ikpil

src/Box2D.NET.Samples/Samples/Collisions/TimeOfImpact.cs

@@ -81,7 +81,7 @@ public override void Draw()
         B2Vec2[] vertices = new B2Vec2[B2_MAX_POLYGON_VERTICES];
 
         // Draw A
-        B2Transform transformA = b2GetSweepTransform(ref _sweepA, 0.0f);
+        B2Transform transformA = b2GetSweepTransform(_sweepA, 0.0f);
         for (int i = 0; i < m_countA; ++i)
         {
             vertices[i] = b2TransformPoint(transformA, m_verticesA[i]);
@@ -90,7 +90,7 @@ public override void Draw()
         DrawPolygon(m_draw, vertices, m_countA, B2HexColor.b2_colorGray);
 
         // Draw B at t = 0
-        B2Transform transformB = b2GetSweepTransform(ref _sweepB, 0.0f);
+        B2Transform transformB = b2GetSweepTransform(_sweepB, 0.0f);
         for (int i = 0; i < m_countB; ++i)
         {
             vertices[i] = b2TransformPoint(transformB, m_verticesB[i]);
@@ -100,7 +100,7 @@ public override void Draw()
         // m_context.g_draw.DrawPolygon( vertices, m_countB, b2HexColor.b2_colorGreen );
 
         // Draw B at t = hit_time
-        transformB = b2GetSweepTransform(ref _sweepB, _output.fraction);
+        transformB = b2GetSweepTransform(_sweepB, _output.fraction);
         for (int i = 0; i < m_countB; ++i)
         {
             vertices[i] = b2TransformPoint(transformB, m_verticesB[i]);
@@ -109,7 +109,7 @@ public override void Draw()
         DrawPolygon(m_draw, vertices, m_countB, B2HexColor.b2_colorOrange);
 
         // Draw B at t = 1
-        transformB = b2GetSweepTransform(ref _sweepB, 1.0f);
+        transformB = b2GetSweepTransform(_sweepB, 1.0f);
         for (int i = 0; i < m_countB; ++i)
         {
             vertices[i] = b2TransformPoint(transformB, m_verticesB[i]);
@@ -123,8 +123,8 @@ public override void Draw()
             B2DistanceInput distanceInput = new B2DistanceInput();
             distanceInput.proxyA = _input.proxyA;
             distanceInput.proxyB = _input.proxyB;
-            distanceInput.transformA = b2GetSweepTransform(ref _sweepA, _output.fraction);
-            distanceInput.transformB = b2GetSweepTransform(ref _sweepB, _output.fraction);
+            distanceInput.transformA = b2GetSweepTransform(_sweepA, _output.fraction);
+            distanceInput.transformB = b2GetSweepTransform(_sweepB, _output.fraction);
             distanceInput.useRadii = false;
             B2SimplexCache cache = new B2SimplexCache();
             B2DistanceOutput distanceOutput = b2ShapeDistance(ref distanceInput, ref cache, null, 0);

src/Box2D.NET/B2Distances.cs

@@ -25,7 +25,7 @@ public static class B2Distances
 #endif
 
         /// Evaluate the transform sweep at a specific time.
-        public static B2Transform b2GetSweepTransform(ref B2Sweep sweep, float time)
+        public static B2Transform b2GetSweepTransform(in B2Sweep sweep, float time)
         {
             // https://fgiesen.wordpress.com/2012/08/15/linear-interpolation-past-present-and-future/
             B2Transform xf;
@@ -139,7 +139,7 @@ public static B2ShapeProxy b2MakeProxy(ReadOnlySpan<B2Vec2> points, int count, f
         }
 
         /// Make a proxy with a transform. This is a deep copy of the points.
-        public static B2ShapeProxy b2MakeOffsetProxy(ReadOnlySpan<B2Vec2> points, int count, float radius, B2Vec2 position, B2Rot rotation)
+        public static B2ShapeProxy b2MakeOffsetProxy(ReadOnlySpan<B2Vec2> points, int count, float radius, B2Vec2 position, in B2Rot rotation)
         {
             count = b2MinInt(count, B2_MAX_POLYGON_VERTICES);
             B2Transform transform = new B2Transform(position, rotation);
@@ -980,8 +980,8 @@ public static B2SeparationFunction b2MakeSeparationFunction(ref B2SimplexCache c
             f.sweepA = sweepA;
             f.sweepB = sweepB;
 
-            B2Transform xfA = b2GetSweepTransform(ref sweepA, t1);
-            B2Transform xfB = b2GetSweepTransform(ref sweepB, t1);
+            B2Transform xfA = b2GetSweepTransform(sweepA, t1);
+            B2Transform xfB = b2GetSweepTransform(sweepB, t1);
 
             if (count == 1)
             {
@@ -1049,8 +1049,8 @@ public static B2SeparationFunction b2MakeSeparationFunction(ref B2SimplexCache c
 
         internal static float b2FindMinSeparation(ref B2SeparationFunction f, ref int indexA, ref int indexB, float t)
         {
-            B2Transform xfA = b2GetSweepTransform(ref f.sweepA, t);
-            B2Transform xfB = b2GetSweepTransform(ref f.sweepB, t);
+            B2Transform xfA = b2GetSweepTransform(f.sweepA, t);
+            B2Transform xfB = b2GetSweepTransform(f.sweepB, t);
 
             switch (f.type)
             {
@@ -1117,8 +1117,8 @@ internal static float b2FindMinSeparation(ref B2SeparationFunction f, ref int in
         //
         static float b2EvaluateSeparation(B2SeparationFunction f, int indexA, int indexB, float t)
         {
-            B2Transform xfA = b2GetSweepTransform(ref f.sweepA, t);
-            B2Transform xfB = b2GetSweepTransform(ref f.sweepB, t);
+            B2Transform xfA = b2GetSweepTransform(f.sweepA, t);
+            B2Transform xfB = b2GetSweepTransform(f.sweepB, t);
 
             switch (f.type)
             {
@@ -1215,8 +1215,8 @@ public static B2TOIOutput b2TimeOfImpact(ref B2TOIInput input)
             // This loop terminates when an axis is repeated (no progress is made).
             for (;;)
             {
-                B2Transform xfA = b2GetSweepTransform(ref sweepA, t1);
-                B2Transform xfB = b2GetSweepTransform(ref sweepB, t1);
+                B2Transform xfA = b2GetSweepTransform(sweepA, t1);
+                B2Transform xfB = b2GetSweepTransform(sweepB, t1);
 
                 // Get the distance between shapes. We can also use the results
                 // to get a separating axis.