Combined the split API for upcoming features

Author: nomnomab

README.md

@@ -1,10 +1,10 @@
 # Raycast Visualization
 This asset allows users to view raycasts as the user fires them.
 
-## Usage
-Replace `Physics.` with `VisualPhysics.` when firing a raycast to get a visual. 
+Currently only supports the 3d physics API (The 2D api will be coming soon).
 
-This class is housed within the `Nomnom.RaycastVisualization` namespace.
+## Usage
+Replace `Physics.` with `VisualPhysics.` when firing a raycast to get a visual.
 
 ## Installation
 #### Using Unity Package Manager

Runtime/Shapes.meta

@@ -0,0 +1,43 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct Arrow {
+    public static Arrow Default => new Arrow {
+      headLength = 0.1f,
+      headAngle = 20f,
+      position = 1
+    };
+    
+    public Vector3 origin;
+    public Vector3 direction;
+    public float headLength;
+    public float headAngle;
+    public float position;
+    public bool overrideLength;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Draw(Color color) {
+      float headLength = this.headLength;
+      
+      if (!overrideLength) {
+        headLength = VisualPhysicsSettingsHandler.GetEditorSettings().RegularArrowLength;
+      }
+
+      Quaternion rot = direction == Vector3.zero ? Quaternion.identity : Quaternion.LookRotation(direction);
+      Vector3 backDir = Vector3.back * headLength;
+      Vector3 right = rot * Quaternion.Euler(headAngle, 0, 0) * backDir;
+      Vector3 left = rot * Quaternion.Euler(-headAngle, 0, 0) * backDir;
+      Vector3 up = rot * Quaternion.Euler(0, headAngle, 0) * backDir;
+      Vector3 down = rot * Quaternion.Euler(0, -headAngle, 0) * backDir;
+
+      Vector3 arrowTip = origin + direction * position;
+
+      Debug.DrawRay(origin, direction, color, 0, true);
+      Debug.DrawRay(arrowTip, right, color, 0, true);
+      Debug.DrawRay(arrowTip, left, color, 0, true);
+      Debug.DrawRay(arrowTip, up, color, 0, true);
+      Debug.DrawRay(arrowTip, down, color, 0, true);
+    }
+  }
+}

Runtime/Shapes/Arrow.cs

@@ -0,0 +1,39 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct Capsule {
+    public Vector3 from;
+    public Vector3 to;
+    public Vector3 direction;
+    public float radius;
+    public float maxDistance;
+    public RaycastHit hit;
+    public bool didHit;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Draw(Color color, float length) {
+      Vector3 dir = direction * length;
+      Vector3 point1Pos = from + dir;
+      Vector3 point2Pos = to + dir;
+      
+      Sphere sphere1 = new Sphere {
+        origin = point1Pos,
+        radius = radius
+      };
+        
+      Sphere sphere2 = new Sphere {
+        origin = point2Pos,
+        radius = radius
+      };
+      
+      Debug.DrawLine(point1Pos + Vector3.forward * radius, point2Pos + Vector3.forward * radius, color, 0, true);
+      Debug.DrawLine(point1Pos + Vector3.back * radius, point2Pos + Vector3.back * radius, color, 0, true);
+      Debug.DrawLine(point1Pos + Vector3.right * radius, point2Pos + Vector3.right * radius, color, 0, true);
+      Debug.DrawLine(point1Pos + Vector3.left * radius, point2Pos + Vector3.left * radius, color, 0, true);
+      
+      sphere1.Draw(color);
+      sphere2.Draw(color);
+    }
+  }
+}

Runtime/Shapes/Arrow.cs.meta

@@ -0,0 +1,46 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct Circle {
+    public static Circle Default => new Circle {
+      radius = 0.025f
+    };
+    
+    private static uint Iterations => VisualPhysicsSettingsHandler.GetEditorSettings().CircleResolution;
+    
+    public Vector3 origin;
+    public Vector3 upDirection;
+    public float radius;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Draw(Color color) {
+      float[] sinCache = Utils.Sin;
+      float[] cosCache = Utils.Cos;
+      
+      Vector3 lastPosition = Vector3.zero;
+      Vector3 cachePosition = Vector3.zero;
+
+      uint iterations = Iterations;
+      for (int i = 0; i <= iterations; i++) {
+        float sin = sinCache[i] * radius;
+        float cos = cosCache[i] * radius;
+
+        cachePosition.x = cos;
+        cachePosition.y = sin;
+        cachePosition.z = 0;
+
+        Quaternion rot = upDirection == Vector3.zero ? Quaternion.identity : Quaternion.LookRotation(upDirection);
+
+        cachePosition = rot * cachePosition;
+        cachePosition += origin;
+
+        if (i != 0) {
+          Debug.DrawLine(lastPosition, cachePosition, color, 0, true);
+        }
+
+        lastPosition = cachePosition;
+      }
+    }
+  }
+}

Runtime/Shapes/Capsule.cs

@@ -0,0 +1,40 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct Cube {
+    public Vector3 origin;
+    public Vector3 size;
+    public Quaternion rotation;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Draw(Color color) {
+      Matrix4x4 matrix4X4 = Matrix4x4.TRS(origin, rotation, size);
+
+      Vector3 blF = matrix4X4.MultiplyPoint(new Vector3(-1, -1, 1));
+      Vector3 brF = matrix4X4.MultiplyPoint(new Vector3(1, -1, 1));
+      Vector3 tlF = matrix4X4.MultiplyPoint(new Vector3(-1, 1, 1));
+      Vector3 trF = matrix4X4.MultiplyPoint(new Vector3(1, 1, 1));
+
+      Vector3 blB = matrix4X4.MultiplyPoint(new Vector3(-1, -1, -1));
+      Vector3 brB = matrix4X4.MultiplyPoint(new Vector3(1, -1, -1));
+      Vector3 tlB = matrix4X4.MultiplyPoint(new Vector3(-1, 1, -1));
+      Vector3 trB = matrix4X4.MultiplyPoint(new Vector3(1, 1, -1));
+
+      Debug.DrawLine(blF, brF, color, 0, true);
+      Debug.DrawLine(brF, trF, color, 0, true);
+      Debug.DrawLine(trF, tlF, color, 0, true);
+      Debug.DrawLine(tlF, blF, color, 0, true);
+
+      Debug.DrawLine(blB, brB, color, 0, true);
+      Debug.DrawLine(brB, trB, color, 0, true);
+      Debug.DrawLine(trB, tlB, color, 0, true);
+      Debug.DrawLine(tlB, blB, color, 0, true);
+
+      Debug.DrawLine(blB, blF, color, 0, true);
+      Debug.DrawLine(brB, brF, color, 0, true);
+      Debug.DrawLine(trB, trF, color, 0, true);
+      Debug.DrawLine(tlB, tlF, color, 0, true);
+    }
+  }
+}

Runtime/Shapes/Capsule.cs.meta

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct Line {
+    public Vector3 from;
+    public Vector3 to;
+
+    public void Draw(Color color) {
+      Debug.DrawLine(from, to, color, 0, true);
+    }
+  }
+}

Runtime/Shapes/Circle.cs

@@ -0,0 +1,60 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct NormalCircle {
+    public static NormalCircle Default => new NormalCircle {
+      radius = 0.025f,
+      distance = 0.025f
+    };
+    
+    private static uint Iterations => VisualPhysicsSettingsHandler.GetEditorSettings().CircleResolution;
+    private static float CircleDistance => VisualPhysicsSettingsHandler.GetEditorSettings().CircleDistance;
+    private static float CircleLength => VisualPhysicsSettingsHandler.GetEditorSettings().ImpactCircleNormalArrowLength;
+    
+    public Vector3 origin;
+    public Vector3 upDirection;
+    public float radius;
+    public float distance;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Draw(Color color) {
+      float[] sinCache = Utils.Sin;
+      float[] cosCache = Utils.Cos;
+      
+      Vector3 lastPosition = Vector3.zero;
+      Vector3 cachePosition = Vector3.zero;
+
+      uint iterations = Iterations;
+      float distance = CircleDistance;
+      
+      for (int i = 0; i <= iterations; i++) {
+        float sin = sinCache[i] * radius;
+        float cos = cosCache[i] * radius;
+
+        cachePosition.x = cos;
+        cachePosition.y = sin;
+        cachePosition.z = 0;
+
+        Quaternion rot = upDirection == Vector3.zero ? Quaternion.identity : Quaternion.LookRotation(upDirection);
+
+        cachePosition = rot * cachePosition;
+        cachePosition += origin + upDirection * distance;
+
+        if (i != 0) {
+          Debug.DrawLine(lastPosition, cachePosition, color, 0, true);
+        }
+
+        lastPosition = cachePosition;
+      }
+      
+      Arrow arrow = Arrow.Default;
+      
+      arrow.origin = origin;
+      arrow.direction = upDirection.normalized * this.distance;
+      arrow.overrideLength = true;
+      arrow.headLength = CircleLength;
+      arrow.Draw(VisualUtils.GetDefaultColor());
+    }
+  }
+}

Runtime/Shapes/Circle.cs.meta

@@ -0,0 +1,14 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct Ray {
+    public Vector3 from;
+    public Vector3 direction;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Draw(Color color) {
+      Debug.DrawRay(from, direction, color, 0, true);
+    }
+  }
+}

Runtime/Shapes/Cube.cs

@@ -0,0 +1,40 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Nomnom.RaycastVisualization.Shapes {
+  internal struct Sphere {
+    private static uint Iterations => VisualPhysicsSettingsHandler.GetEditorSettings().CircleResolution;
+    
+    public Vector3 origin;
+    public float radius;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Draw(Color color) {
+      float[] sinCache = Utils.Sin;
+      float[] cosCache = Utils.Cos;
+      
+      Vector3 lastPositionHorizontal = default;
+      Vector3 lastPositionVertical = default;
+      Vector3 lastPositionVertical2 = default;
+
+      uint iterations = Iterations;
+      for (int i = 0; i <= iterations; i++) {
+        float sin = sinCache[i] * radius;
+        float cos = cosCache[i] * radius;
+        Vector3 horizontal = new Vector3(origin.x + cos, origin.y + sin, origin.z);
+        Vector3 vertical = new Vector3(origin.x + cos, origin.y, origin.z + sin);
+        Vector3 vertical2 = new Vector3(origin.x, origin.y + cos, origin.z + sin);
+
+        if (i != 0) {
+          Debug.DrawLine(lastPositionHorizontal, horizontal, color, 0, true);
+          Debug.DrawLine(lastPositionVertical, vertical, color, 0, true);
+          Debug.DrawLine(lastPositionVertical2, vertical2, color, 0, true);
+        }
+
+        lastPositionHorizontal = horizontal;
+        lastPositionVertical = vertical;
+        lastPositionVertical2 = vertical2;
+      }
+    }
+  }
+}