Toqozz/Rope.cs Secret

## Rope.cs
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Profiling;

 namespace Rope {
     class VerletNode {
         public Vector2 position;
         public Vector2 oldPosition;

         public VerletNode(Vector2 position) {
             this.position = position;
             this.oldPosition = position;
         }
     }

     enum ColliderType {
         Circle,
         Box,
         None,
     }

     class CollisionInfo {
         public int id;

         public ColliderType colliderType;
         public Vector2 colliderSize;
         public Vector2 position;
         public Vector2 scale;
         public Matrix4x4 wtl;
         public Matrix4x4 ltw;
         public int numCollisions;
         public int[] collidingNodes;

         public CollisionInfo(int maxCollisions) {
             this.id = -1;
             this.colliderType = ColliderType.None;
             this.colliderSize = Vector2.zero;
             this.position = Vector2.zero;
             this.scale = Vector2.zero;
             this.wtl = Matrix4x4.zero;
             this.ltw = Matrix4x4.zero;

             this.numCollisions = 0;
             this.collidingNodes = new int[maxCollisions];
         }
     }

     public class Rope : MonoBehaviour {
         // Maximum number of colliders hitting the rope at once.
         private const int MAX_ROPE_COLLISIONS = 32;
         // Size of the collider buffer, also the maximum number of colliders that a single node can touch at once.
         private const int COLLIDER_BUFFER_SIZE = 8;
        // IF YOU CHANGE THIS, REMEMBER TO CHANGE IT IN THE SHADER AS WELL.
        private const int MAX_RENDER_POINTS = 256;
        // Number of triangles present in each line segment between nodes.
        // 4 = 2 per quad, one quad for the line and one for the start cap.
        private const int TRIANGLES_PER_NODE = 4;
        // Number of vertices present in each line segment between nodes.
        // 8 = 2 quads.
        private const int VERTICES_PER_NODE = 8;

         [Min(2)]
         public int totalNodes = 200;
         public int iterations = 80;
         public float nodeDistance = 0.1f;
         [Min(0.001f)]
         public float stepTime = 0.01f;
         public float maxStep = 0.1f;
         public float thickness;

         public float drawWidth = 0.025f;
         public Vector2 gravity = new Vector2(0, -20f);
         public float collisionRadius = 0.5f;    // Collision radius around each node.  Set high to avoid tunneling.

         private VerletNode[] nodes;
         private float timeAccum;
         private CollisionInfo[] collisionInfos;
         private int numCollisions;
         private bool shouldSnapshotCollision;

         private Camera cam;
         private Material material;
         private Collider2D[] colliderBuffer;

         private Vector4[] renderPositions;

         private void Awake() {
             if (totalNodes > MAX_RENDER_POINTS) {
                 Debug.LogError("Total nodes is more than MAX_RENDER_POINTS, so won't be able to render the entire rope.");
             }

             nodes = new VerletNode[totalNodes];
             collisionInfos = new CollisionInfo[MAX_ROPE_COLLISIONS];
             for (int i = 0; i < collisionInfos.Length; i++) {
                 collisionInfos[i] = new CollisionInfo(totalNodes);
             }

             // Buffer for OverlapCircleNonAlloc.
             colliderBuffer = new Collider2D[COLLIDER_BUFFER_SIZE];
             renderPositions = new Vector4[totalNodes];

             // Spawn nodes starting from the transform position and working down.
             Vector2 pos = transform.position;
             for (int i = 0; i < totalNodes; i++) {
                 nodes[i] = new VerletNode(pos);
                 renderPositions[i] = new Vector4(pos.x, pos.y, 1, 1);
                 pos.y -= nodeDistance;
             }

             // Mesh setup.
             Mesh mesh = new Mesh();
             {
                 Vector3[] vertices = new Vector3[totalNodes * VERTICES_PER_NODE];
                 int[] triangles = new int[totalNodes * TRIANGLES_PER_NODE * 3];

                 for (int i = 0; i < totalNodes; i++) {
                     // 4 triangles per node, 3 indices per triangle.
                     int idx = i * TRIANGLES_PER_NODE * 3;
                     // 8 vertices per node.
                     int vIdx = i * VERTICES_PER_NODE;

                     // Unity uses a CLOCKWISE WINDING ORDER -- clockwise tri indices are facing the camera.
                     triangles[idx + 0] = vIdx; // v1 top
                     triangles[idx + 1] = vIdx + 1; // v2 bottom
                     triangles[idx + 2] = vIdx + 2; // v1 bottom
                     triangles[idx + 3] = vIdx; // v1 top
                     triangles[idx + 4] = vIdx + 3; // v2 top
                     triangles[idx + 5] = vIdx + 1; // v2 bottom

                     triangles[idx + 6] = vIdx + 4; // tl
                     triangles[idx + 7] = vIdx + 7; // br
                     triangles[idx + 8] = vIdx + 6; // bl
                     triangles[idx + 9] = vIdx + 4; // tl
                     triangles[idx + 10] = vIdx + 5; // tr
                     triangles[idx + 11] = vIdx + 7; // br
                 }

                 // We only really care about the number of vertices, not what they actually are -- the positions aren't used.
                 mesh.vertices = vertices;
                 mesh.triangles = triangles;
                 // Since we pretty much want the rope to always render (it's always going to be on screen if it's active), we
                 // just set the bounds super large to avoid recalculating the bounds when the rope changes.
                 mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 100f);
             }
             GetComponent<MeshFilter>().mesh = mesh;
             material = GetComponent<MeshRenderer>().material;
             material.SetFloat("_Width", drawWidth);
         }

         private void Update() {
             if (shouldSnapshotCollision) {
                 SnapshotCollision();
             }

             // Fixed timestep.
             timeAccum += Time.deltaTime;
             timeAccum = Mathf.Min(timeAccum, maxStep);
             while (timeAccum >= stepTime) {
                 Simulate();

                 for (int i = 0; i < iterations; i++) {
                     ApplyConstraints();
                     AdjustCollisions();
                 }

                 timeAccum -= stepTime;
             }
         }

         private void LateUpdate() {
             for (int i = 0; i < nodes.Length; i++) {
                 renderPositions[i].w = 1;
                 Vector2 pos = nodes[i].position;
                 renderPositions[i].x = pos.x;
                 renderPositions[i].y = pos.y;
                 renderPositions[i].z = 1;
             }

             material.SetVectorArray("_Points", renderPositions);
         }

         private void FixedUpdate() {
             shouldSnapshotCollision = true;
         }

         private void SnapshotCollision() {
             Profiler.BeginSample("Snapshot");

             numCollisions = 0;
             // Loop through each node and get collisions within a radius.
             for (int i = 0; i < nodes.Length; i++) {
                 int collisions =
                     Physics2D.OverlapCircleNonAlloc(nodes[i].position, collisionRadius, colliderBuffer);

                 for (int j = 0; j < collisions; j++) {
                     Collider2D col = colliderBuffer[j];
                     int id = col.GetInstanceID();

                     int idx = -1;
                     for (int k = 0; k < numCollisions; k++) {
                         if (collisionInfos[k].id == id) {
                             idx = k;
                             break;
                         }
                     }

                     // If we didn't have the collider, we need to add it.
                     if (idx < 0) {
                         // Record all the data we need to use into our classes.
                         CollisionInfo ci = collisionInfos[numCollisions];
                         ci.id = id;
                         ci.wtl = col.transform.worldToLocalMatrix;
                         ci.ltw = col.transform.localToWorldMatrix;
                         ci.scale.x = ci.ltw.GetColumn(0).magnitude;
                         ci.scale.y = ci.ltw.GetColumn(1).magnitude;
                         ci.position = col.transform.position;
                         ci.numCollisions = 1; // 1 collision, this one.
                         ci.collidingNodes[0] = i;

                         switch (col) {
                             case CircleCollider2D c:
                                 ci.colliderType = ColliderType.Circle;
                                 ci.colliderSize.x = ci.colliderSize.y = c.radius;
                                 break;
                             case BoxCollider2D b:
                                 ci.colliderType = ColliderType.Box;
                                 ci.colliderSize = b.size;
                                 break;
                             default:
                                 ci.colliderType = ColliderType.None;
                                 break;
                         }

                         numCollisions++;
                         if (numCollisions >= MAX_ROPE_COLLISIONS) {
                             Profiler.EndSample();
                             return;
                         }

                         // If we found the collider, then we just have to increment the collisions and add our node.
                     } else {
                         CollisionInfo ci = collisionInfos[idx];
                         if (ci.numCollisions >= totalNodes) {
                             continue;
                         }

                         ci.collidingNodes[ci.numCollisions++] = i;
                     }
                 }
             }

             shouldSnapshotCollision = false;

             Profiler.EndSample();
         }

         private void Simulate() {
             for (int i = 0; i < nodes.Length; i++) {
                 VerletNode node = nodes[i];

                 Vector2 temp = node.position;
                 node.position += (node.position - node.oldPosition) + gravity * stepTime * stepTime;
                 node.oldPosition = temp;
             }
         }

         private void ApplyConstraints() {
             Profiler.BeginSample("Constraints");

             for (int i = 0; i < nodes.Length - 1; i++) {
                 VerletNode node1 = nodes[i];
                 VerletNode node2 = nodes[i + 1];

                 // First node follows the mouse, for debugging.
                 if (i == 0 && Input.GetMouseButton(0)) {
                     node1.position = Camera.main.ScreenToWorldPoint(Input.mousePosition);
                 }

                 // Current distance between rope nodes.
                 float diffX = node1.position.x - node2.position.x;
                 float diffY = node1.position.y - node2.position.y;
                 float dist = Vector2.Distance(node1.position, node2.position);
                 float difference = 0;
                 // Guard against divide by 0.
                 if (dist > 0) {
                     difference = (nodeDistance - dist) / dist;
                 }

                 Vector2 translate = new Vector2(diffX, diffY) * (.5f * difference);

                 node1.position += translate;
                 node2.position -= translate;
             }

             /*
             // Distance constraint which reduces iterations, but doesn't handle stretchyness in a natural way.
             VerletNode first = nodes[0];
             VerletNode last = nodes[nodes.Length-1];
             // Same distance calculation as above, but less optimal.
             float distance = Vector2.Distance(first.position, last.position);
             if (distance > 0 && distance > nodes.Length * nodeDistance) {
                 Vector2 dir = (last.position - first.position).normalized;
                 last.position = first.position + nodes.Length * nodeDistance * dir;
             }
             */

             Profiler.EndSample();
         }

         private void AdjustCollisions() {
             Profiler.BeginSample("Collision");

             for (int i = 0; i < numCollisions; i++) {
                 CollisionInfo ci = collisionInfos[i];

                 switch (ci.colliderType) {
                     case ColliderType.Circle: {
                         float radius = ci.colliderSize.x * Mathf.Max(ci.scale.x, ci.scale.y);

                         for (int j = 0; j < ci.numCollisions; j++) {
                             VerletNode node = nodes[ci.collidingNodes[j]];
                             float distance = Vector2.Distance(ci.position, node.position);

                             // Early out if we're not colliding.
                             if (distance - radius > thickness) {
                                 continue;
                             }

                             Vector2 dir = (node.position - ci.position).normalized;
                             Vector2 hitPos = ci.position + dir * (radius + thickness);
                             node.position = hitPos;
                         }
                     }
                         break;

                     case ColliderType.Box: {
                         for (int j = 0; j < ci.numCollisions; j++) {
                             VerletNode node = nodes[ci.collidingNodes[j]];
                             Vector2 localPoint = ci.wtl.MultiplyPoint(node.position);

                             // If distance from center is more than box "radius", then we can't be colliding.
                             Vector2 half = ci.colliderSize * .5f;
                             Vector2 scalar = ci.scale;
                             float dx = localPoint.x;
                             float px = half.x - Mathf.Abs(dx);
                             if (px <= 0) {
                                 continue;
                             }

                             float dy = localPoint.y;
                             float py = half.x - Mathf.Abs(dy);
                             if (py <= 0) {
                                 continue;
                             }

                             // Need to multiply distance by scale or we'll mess up on scaled box corners.
                             if (px * scalar.x < py * scalar.y) {
                                 float sx = Mathf.Sign(dx);
                                 localPoint.x = half.x * sx;
                             } else {
                                 float sy = Mathf.Sign(dy);
                                 localPoint.y = half.y * sy;
                             }

                             Vector2 hitPos = ci.ltw.MultiplyPoint(localPoint);
                             node.position = hitPos;
                         }
                     }
                         break;
                 }
             }


             Profiler.EndSample();
         }

         /*
         private void OnDrawGizmos() {
             if (!Application.isPlaying) {
                 return;
             }

             for (int i = 0; i < nodes.Length - 1; i++) {
                 if (i % 2 == 0) {
                     Gizmos.color = Color.green;
                 } else {
                     Gizmos.color = Color.white;
                 }

                 Gizmos.DrawLine(nodes[i].position, nodes[i + 1].position);
             }
         }
         */
     }
 }
	using System;
	using System.Collections;
	using System.Collections.Generic;
	using UnityEngine;
	using UnityEngine.Profiling;

	namespace Rope {
	class VerletNode {
	public Vector2 position;
	public Vector2 oldPosition;

	public VerletNode(Vector2 position) {
	this.position = position;
	this.oldPosition = position;
	}
	}

	enum ColliderType {
	Circle,
	Box,
	None,
	}

	class CollisionInfo {
	public int id;

	public ColliderType colliderType;
	public Vector2 colliderSize;
	public Vector2 position;
	public Vector2 scale;
	public Matrix4x4 wtl;
	public Matrix4x4 ltw;
	public int numCollisions;
	public int[] collidingNodes;

	public CollisionInfo(int maxCollisions) {
	this.id = -1;
	this.colliderType = ColliderType.None;
	this.colliderSize = Vector2.zero;
	this.position = Vector2.zero;
	this.scale = Vector2.zero;
	this.wtl = Matrix4x4.zero;
	this.ltw = Matrix4x4.zero;

	this.numCollisions = 0;
	this.collidingNodes = new int[maxCollisions];
	}
	}

	public class Rope : MonoBehaviour {
	// Maximum number of colliders hitting the rope at once.
	private const int MAX_ROPE_COLLISIONS = 32;
	// Size of the collider buffer, also the maximum number of colliders that a single node can touch at once.
	private const int COLLIDER_BUFFER_SIZE = 8;
	// IF YOU CHANGE THIS, REMEMBER TO CHANGE IT IN THE SHADER AS WELL.
	private const int MAX_RENDER_POINTS = 256;
	// Number of triangles present in each line segment between nodes.
	// 4 = 2 per quad, one quad for the line and one for the start cap.
	private const int TRIANGLES_PER_NODE = 4;
	// Number of vertices present in each line segment between nodes.
	// 8 = 2 quads.
	private const int VERTICES_PER_NODE = 8;

	[Min(2)]
	public int totalNodes = 200;
	public int iterations = 80;
	public float nodeDistance = 0.1f;
	[Min(0.001f)]
	public float stepTime = 0.01f;
	public float maxStep = 0.1f;
	public float thickness;

	public float drawWidth = 0.025f;
	public Vector2 gravity = new Vector2(0, -20f);
	public float collisionRadius = 0.5f; // Collision radius around each node. Set high to avoid tunneling.

	private VerletNode[] nodes;
	private float timeAccum;
	private CollisionInfo[] collisionInfos;
	private int numCollisions;
	private bool shouldSnapshotCollision;

	private Camera cam;
	private Material material;
	private Collider2D[] colliderBuffer;

	private Vector4[] renderPositions;

	private void Awake() {
	if (totalNodes > MAX_RENDER_POINTS) {
	Debug.LogError("Total nodes is more than MAX_RENDER_POINTS, so won't be able to render the entire rope.");
	}

	nodes = new VerletNode[totalNodes];
	collisionInfos = new CollisionInfo[MAX_ROPE_COLLISIONS];
	for (int i = 0; i < collisionInfos.Length; i++) {
	collisionInfos[i] = new CollisionInfo(totalNodes);
	}

	// Buffer for OverlapCircleNonAlloc.
	colliderBuffer = new Collider2D[COLLIDER_BUFFER_SIZE];
	renderPositions = new Vector4[totalNodes];

	// Spawn nodes starting from the transform position and working down.
	Vector2 pos = transform.position;
	for (int i = 0; i < totalNodes; i++) {
	nodes[i] = new VerletNode(pos);
	renderPositions[i] = new Vector4(pos.x, pos.y, 1, 1);
	pos.y -= nodeDistance;
	}

	// Mesh setup.
	Mesh mesh = new Mesh();
	{
	Vector3[] vertices = new Vector3[totalNodes * VERTICES_PER_NODE];
	int[] triangles = new int[totalNodes * TRIANGLES_PER_NODE * 3];

	for (int i = 0; i < totalNodes; i++) {
	// 4 triangles per node, 3 indices per triangle.
	int idx = i * TRIANGLES_PER_NODE * 3;
	// 8 vertices per node.
	int vIdx = i * VERTICES_PER_NODE;

	// Unity uses a CLOCKWISE WINDING ORDER -- clockwise tri indices are facing the camera.
	triangles[idx + 0] = vIdx; // v1 top
	triangles[idx + 1] = vIdx + 1; // v2 bottom
	triangles[idx + 2] = vIdx + 2; // v1 bottom
	triangles[idx + 3] = vIdx; // v1 top
	triangles[idx + 4] = vIdx + 3; // v2 top
	triangles[idx + 5] = vIdx + 1; // v2 bottom

	triangles[idx + 6] = vIdx + 4; // tl
	triangles[idx + 7] = vIdx + 7; // br
	triangles[idx + 8] = vIdx + 6; // bl
	triangles[idx + 9] = vIdx + 4; // tl
	triangles[idx + 10] = vIdx + 5; // tr
	triangles[idx + 11] = vIdx + 7; // br
	}

	// We only really care about the number of vertices, not what they actually are -- the positions aren't used.
	mesh.vertices = vertices;
	mesh.triangles = triangles;
	// Since we pretty much want the rope to always render (it's always going to be on screen if it's active), we
	// just set the bounds super large to avoid recalculating the bounds when the rope changes.
	mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 100f);
	}
	GetComponent<MeshFilter>().mesh = mesh;
	material = GetComponent<MeshRenderer>().material;
	material.SetFloat("_Width", drawWidth);
	}

	private void Update() {
	if (shouldSnapshotCollision) {
	SnapshotCollision();
	}

	// Fixed timestep.
	timeAccum += Time.deltaTime;
	timeAccum = Mathf.Min(timeAccum, maxStep);
	while (timeAccum >= stepTime) {
	Simulate();

	for (int i = 0; i < iterations; i++) {
	ApplyConstraints();
	AdjustCollisions();
	}

	timeAccum -= stepTime;
	}
	}

	private void LateUpdate() {
	for (int i = 0; i < nodes.Length; i++) {
	renderPositions[i].w = 1;
	Vector2 pos = nodes[i].position;
	renderPositions[i].x = pos.x;
	renderPositions[i].y = pos.y;
	renderPositions[i].z = 1;
	}

	material.SetVectorArray("_Points", renderPositions);
	}

	private void FixedUpdate() {
	shouldSnapshotCollision = true;
	}

	private void SnapshotCollision() {
	Profiler.BeginSample("Snapshot");

	numCollisions = 0;
	// Loop through each node and get collisions within a radius.
	for (int i = 0; i < nodes.Length; i++) {
	int collisions =
	Physics2D.OverlapCircleNonAlloc(nodes[i].position, collisionRadius, colliderBuffer);

	for (int j = 0; j < collisions; j++) {
	Collider2D col = colliderBuffer[j];
	int id = col.GetInstanceID();

	int idx = -1;
	for (int k = 0; k < numCollisions; k++) {
	if (collisionInfos[k].id == id) {
	idx = k;
	break;
	}
	}

	// If we didn't have the collider, we need to add it.
	if (idx < 0) {
	// Record all the data we need to use into our classes.
	CollisionInfo ci = collisionInfos[numCollisions];
	ci.id = id;
	ci.wtl = col.transform.worldToLocalMatrix;
	ci.ltw = col.transform.localToWorldMatrix;
	ci.scale.x = ci.ltw.GetColumn(0).magnitude;
	ci.scale.y = ci.ltw.GetColumn(1).magnitude;
	ci.position = col.transform.position;
	ci.numCollisions = 1; // 1 collision, this one.
	ci.collidingNodes[0] = i;

	switch (col) {
	case CircleCollider2D c:
	ci.colliderType = ColliderType.Circle;
	ci.colliderSize.x = ci.colliderSize.y = c.radius;
	break;
	case BoxCollider2D b:
	ci.colliderType = ColliderType.Box;
	ci.colliderSize = b.size;
	break;
	default:
	ci.colliderType = ColliderType.None;
	break;
	}

	numCollisions++;
	if (numCollisions >= MAX_ROPE_COLLISIONS) {
	Profiler.EndSample();
	return;
	}

	// If we found the collider, then we just have to increment the collisions and add our node.
	} else {
	CollisionInfo ci = collisionInfos[idx];
	if (ci.numCollisions >= totalNodes) {
	continue;
	}

	ci.collidingNodes[ci.numCollisions++] = i;
	}
	}
	}

	shouldSnapshotCollision = false;

	Profiler.EndSample();
	}

	private void Simulate() {
	for (int i = 0; i < nodes.Length; i++) {
	VerletNode node = nodes[i];

	Vector2 temp = node.position;
	node.position += (node.position - node.oldPosition) + gravity * stepTime * stepTime;
	node.oldPosition = temp;
	}
	}

	private void ApplyConstraints() {
	Profiler.BeginSample("Constraints");

	for (int i = 0; i < nodes.Length - 1; i++) {
	VerletNode node1 = nodes[i];
	VerletNode node2 = nodes[i + 1];

	// First node follows the mouse, for debugging.
	if (i == 0 && Input.GetMouseButton(0)) {
	node1.position = Camera.main.ScreenToWorldPoint(Input.mousePosition);
	}

	// Current distance between rope nodes.
	float diffX = node1.position.x - node2.position.x;
	float diffY = node1.position.y - node2.position.y;
	float dist = Vector2.Distance(node1.position, node2.position);
	float difference = 0;
	// Guard against divide by 0.
	if (dist > 0) {
	difference = (nodeDistance - dist) / dist;
	}

	Vector2 translate = new Vector2(diffX, diffY) * (.5f * difference);

	node1.position += translate;
	node2.position -= translate;
	}

	/*
	// Distance constraint which reduces iterations, but doesn't handle stretchyness in a natural way.
	VerletNode first = nodes[0];
	VerletNode last = nodes[nodes.Length-1];
	// Same distance calculation as above, but less optimal.
	float distance = Vector2.Distance(first.position, last.position);
	if (distance > 0 && distance > nodes.Length * nodeDistance) {
	Vector2 dir = (last.position - first.position).normalized;
	last.position = first.position + nodes.Length * nodeDistance * dir;
	}
	*/

	Profiler.EndSample();
	}

	private void AdjustCollisions() {
	Profiler.BeginSample("Collision");

	for (int i = 0; i < numCollisions; i++) {
	CollisionInfo ci = collisionInfos[i];

	switch (ci.colliderType) {
	case ColliderType.Circle: {
	float radius = ci.colliderSize.x * Mathf.Max(ci.scale.x, ci.scale.y);

	for (int j = 0; j < ci.numCollisions; j++) {
	VerletNode node = nodes[ci.collidingNodes[j]];
	float distance = Vector2.Distance(ci.position, node.position);

	// Early out if we're not colliding.
	if (distance - radius > thickness) {
	continue;
	}

	Vector2 dir = (node.position - ci.position).normalized;
	Vector2 hitPos = ci.position + dir * (radius + thickness);
	node.position = hitPos;
	}
	}
	break;

	case ColliderType.Box: {
	for (int j = 0; j < ci.numCollisions; j++) {
	VerletNode node = nodes[ci.collidingNodes[j]];
	Vector2 localPoint = ci.wtl.MultiplyPoint(node.position);

	// If distance from center is more than box "radius", then we can't be colliding.
	Vector2 half = ci.colliderSize * .5f;
	Vector2 scalar = ci.scale;
	float dx = localPoint.x;
	float px = half.x - Mathf.Abs(dx);
	if (px <= 0) {
	continue;
	}

	float dy = localPoint.y;
	float py = half.x - Mathf.Abs(dy);
	if (py <= 0) {
	continue;
	}

	// Need to multiply distance by scale or we'll mess up on scaled box corners.
	if (px * scalar.x < py * scalar.y) {
	float sx = Mathf.Sign(dx);
	localPoint.x = half.x * sx;
	} else {
	float sy = Mathf.Sign(dy);
	localPoint.y = half.y * sy;
	}

	Vector2 hitPos = ci.ltw.MultiplyPoint(localPoint);
	node.position = hitPos;
	}
	}
	break;
	}
	}


	Profiler.EndSample();
	}

	/*
	private void OnDrawGizmos() {
	if (!Application.isPlaying) {
	return;
	}

	for (int i = 0; i < nodes.Length - 1; i++) {
	if (i % 2 == 0) {
	Gizmos.color = Color.green;
	} else {
	Gizmos.color = Color.white;
	}

	Gizmos.DrawLine(nodes[i].position, nodes[i + 1].position);
	}
	}
	*/
	}
	}