InverseTransformPoint vs Vector3.Distance which is cheaper?

new, correct answer:

Vector3 v1 = t1.position;
Vector3 v2 = t2.position;
Vector3 vector = new Vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
result = (float)System.Math.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);

after all that was wrote here i made a simple test for calculation speed. here is results for 10M calculations:

 * Vector3.Dot | time taken (ms):2579.1475
 * InverseTransformPoint(...).z | time taken (ms):2239.1281
 * Vector3.Dot with RotatedForward | time taken (ms):2192.1254 (my optimization of Vector3.Dot)
 * (v1-v2).magnitude | time taken (ms):1461.0836
 * Vector3.Distance | time taken (ms):1393.0797
 * custom(above) | time taken (ms):1313.0751

i don't understand why sqrt is so fast... may be somebody want to repeat this test? below the script i used for test, all you need is attach it to camera in empty scene and run.

DistanceCalculatorCheck.cs

using UnityEngine; using System.Collections;

public class DistanceCalculatorCheck : MonoBehaviour { public int iterations = 10000000; void Start() { Transform t1 = GameObject.CreatePrimitive(PrimitiveType.Sphere).transform; Transform t2 = GameObject.CreatePrimitive(PrimitiveType.Sphere).transform; t1.position = Random.insideUnitSphere 1000f; t2.position = Random.insideUnitSphere 1000f; t1.LookAt(t2); //declare variables System.DateTime start; System.TimeSpan difference; float result = 0;

//begin test 1 start = System.DateTime.Now; for (int i = 0; i < iterations; i++) { result = Vector3.Distance(t1.position, t2.position); } difference = System.DateTime.Now - start; Debug.Log(string.Format("type:{0} | time taken (ms):{1} | result:{2}", "Vector3.Distance", difference.TotalMilliseconds, result));

//begin test 2 start = System.DateTime.Now; for (int i = 0; i < iterations; i++) { result = (t1.position - t2.position).magnitude; } difference = System.DateTime.Now - start; Debug.Log(string.Format("type:{0} | time taken (ms):{1} | result:{2}", "(v1-v2).magnitude", difference.TotalMilliseconds, result));

//begin test 3 start = System.DateTime.Now; for (int i = 0; i < iterations; i++) { result = t1.InverseTransformPoint(t2.transform.position).z; } difference = System.DateTime.Now - start; Debug.Log(string.Format("type:{0} | time taken (ms):{1} | result:{2}", "InverseTransformPoint.z", difference.TotalMilliseconds, result));

//begin test 4 start = System.DateTime.Now; for (int i = 0; i < iterations; i++) { result = Vector3.Dot(t2.position - t1.position, t1.forward); } difference = System.DateTime.Now - start; Debug.Log(string.Format("type:{0} | time taken (ms):{1} | result:{2}", "Vector3.Dot", difference.TotalMilliseconds, result));

//begin test 5 start = System.DateTime.Now; for (int i = 0; i < iterations; i++) { result = 2f * Vector3.Dot(t2.position - t1.position, RotatedForward(t1.rotation)); } difference = System.DateTime.Now - start; Debug.Log(string.Format("type:{0} | time taken (ms):{1} | result:{2}", "Vector3.Dot with RotatedForward", difference.TotalMilliseconds, result));

//begin test 6 start = System.DateTime.Now; for (int i = 0; i < iterations; i++) { Vector3 v1 = t1.position; Vector3 v2 = t2.position; Vector3 vector = new Vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); result = (float)System.Math.Sqrt(vector.x vector.x + vector.y vector.y + vector.z vector.z); } difference = System.DateTime.Now - start; Debug.Log(string.Format("type:{0} | time taken (ms):{1} | result:{2}", "custom", difference.TotalMilliseconds, result)); } public static Vector3 RotatedForward(Quaternion rotation) { return new Vector3( rotation.x rotation.z + rotation.w rotation.y, rotation.y rotation.z - rotation.w rotation.x, 0.5f - (rotation.x rotation.x + rotation.y * rotation.y)); } }

 Vector3.Dot                     | 5359.375
 InverseTransformPoint.z         | 4640.625
 Vector3.Dot with RotatedForward | 4265.625
 (v1-v2).magnitude               | 3109.375
 custom                          | 2921.875
 Vector3.Distance                | 2812.5

 Vector3.Dot                     | 5171.875
 InverseTransformPoint.z         | 4593.75
 Vector3.Dot with RotatedForward | 4281.25
 (v1-v2).magnitude               | 3125
 custom                          | 2875
 Vector3.Distance                | 2859.375

public static float Distance(Vector3 a, Vector3 b)
{
    Vector3 vector = new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
    return $$anonymous$$athf.Sqrt(((vector.x * vector.x) + (vector.y * vector.y)) + (vector.z * vector.z));
}

public static float Sqrt(float f)
{
    return (float) $$anonymous$$ath.Sqrt((double) f);
}

more accuracy:

 Vector3.Dot(target.position - myTransform.position, myTransform.forward);

dot product for two Vector3 is x1x2+y1y2+z1z2

---

less accuracy and needs check for x!=0:

 (target.position - myTransform.position).x / myTransform.forward.x;

---

hardcode and hardcore

let's try to optimize this:

Vector3.Dot(target.position - myTransform.position, myTransform.forward);

transform.forward is

public Vector3 forward
{
    get
    {
        return (Vector3) (this.rotation * Vector3.forward);
    }
    set...
}

so, distance is

Vector3.Dot(target.position - myTransform.position, myTransform.rotation * Vector3.forward);

now, what is Quaternion * Vector3:

public static Vector3 operator *(Quaternion rotation, Vector3 point)
{
    Vector3 vector;
    float num = rotation.x * 2f;
    float num2 = rotation.y * 2f;
    float num3 = rotation.z * 2f;
    float num4 = rotation.x * num;
    float num5 = rotation.y * num2;
    float num6 = rotation.z * num3;
    float num7 = rotation.x * num2;
    float num8 = rotation.x * num3;
    float num9 = rotation.y * num3;
    float num10 = rotation.w * num;
    float num11 = rotation.w * num2;
    float num12 = rotation.w * num3;
    vector.x = (((1f - (num5 + num6)) * point.x) + ((num7 - num12) * point.y)) + ((num8 + num11) * point.z);
    vector.y = (((num7 + num12) * point.x) + ((1f - (num4 + num6)) * point.y)) + ((num9 - num10) * point.z);
    vector.z = (((num8 - num11) * point.x) + ((num9 + num10) * point.y)) + ((1f - (num4 + num5)) * point.z);
    return vector;
}

we have vector3 (0,0,1), so we can optimize it to:

public static Vector3 RotatedForward(Quaternion rotation)
{
    return 2f * new Vector3(
        rotation.x * rotation.z + rotation.w * rotation.y,
        rotation.y * rotation.z - rotation.w * rotation.x,
        0.5f - (rotation.x * rotation.x + rotation.y * rotation.y));
}

and now really fastest distance calculator is:

Vector3.Dot(target.position - myTransform.position, RotatedForward(myTransform.rotation));

absolutely unclear to understand, but really fast 8)

addon:

remove '2f*' from RotatedForward method and multiply to 2f final Vector3.Dot result. this will save 2 more multiplications

I suppose that the fastest alternative is none of above:

   distance = (target.position - myTransform.position).magnitude;

Unity does a vector subtraction and calculates the magnitude of the result, which requires 3 subtractions, 3 multiplications, 2 additions and a square root. Vector3.Distance does about the same thing, but is a little slower, according to some users that tested it. The other alternative, InverseTransformPoint(...).z, doesn't give the same result: it measures the distance strictly in the forward direction - if the target is at 45 degrees, for instance, the value returned will be 0.707 times the actual distance. This operation also requires a 4x4 matrix multiplication, which means lots of multiplications and additions - probably taking way more time than a single square root in any machine.
CONCLUSION: If you want to measure the distance of something strictly in the object's forward direction, use InverseTransformPoint(...).z. If you want the actual distance calculated in the fastest way, use the (pointA - pointB).magnitude alternative (also recommended when you need to calculate the direction vector pointB->pointA or pointA->pointB for other purposes too). If you prefer to write a more self documented code, use Vector3.Distance(pointA, pointB).

EDITED: @Scroodge won the prize: the dot product method is the best one to find distance in the forward direction, with 3 subtractions, 3 multiplications, 2 additions and NO square root. By the way, I missed the "already have an object looking at something" part of the question.

     x2 = number * 0.5F;
     y  = number;
     i  = * ( long * ) &y;                       // evil floating point bit level hacking
     i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
     y  = * ( float * ) &i;
     y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration

     return y;

 Vector3 vector = new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
 return $$anonymous$$athf.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);