Die effizienteste Methode zum Konvertieren von Vector3 in Vector2

Was ist der effizienteste und schnellste Weg, um einen Vector3 in einen Vector2 umzuwandeln?

Casting:

Vector2 vector2 = (Vector2)vector3;

Initialisieren eines neuen Vektors2:

Vector2 vector2 = new Vector2(vector3.x, vector3.y);

Oder gibt es eine andere Methode, die ich nicht kenne?

Vector3 v3 = Vector3.one;
Vector2 v2 = v3;

Vector3s können implizit in Vector2 konvertiert werden (z wird verworfen).

http://docs.unity3d.com/ScriptReference/Vector2-operator_Vector3.html

Wenn Sie viele Konvertierungen vornehmen müssen, müssen Sie möglicherweise die Art und Weise ändern, wie Sie Ihre Vektoren verwenden. Machen Sie zwei Tests und messen Sie sie, um festzustellen, welcher für Sie funktioniert.

UPDATE MIT TESTS: Da Sie gefragt haben, welches das schnellste ist, habe ich einen Test erstellt, in dem jeweils 10000000 Conversions in Unity ausgeführt werden. In diesem Fall scheint die Initialisierungsversion am schnellsten zu sein. ABER du solltest immer die verwenden, die zu deinem eigenen Kontext passt, also rate ich dir, deine eigenen Tests in deinem Spiel durchzuführen.

TestConvertByOperation 10000000 Instanzen: 0.2714049s

TestConvertByCasting 10000000 Instanzen: 0.286027s

TestConvertByInitializing 10000000 Instanzen: 0.1458781s

using UnityEngine;

public class TestVector3Conversion : MonoBehaviour
{

    readonly int iterations = 10000000;
    Vector3 testVector = new Vector3(3f, 14f, 42f);

    void Start()
    {
        Debug.Log(string.Format("TestConvertByOperation {0} instances: {1}s", iterations, TestConvertByOperation()));
        Debug.Log(string.Format("TestConvertByCasting {0} instances: {1}s", iterations, TestConvertByCasting()));
        Debug.Log(string.Format("TestConvertByInitializing {0} instances: {1}s", iterations, TestConvertByInitializing()));
    }

    float TestConvertByOperation()
    {
        var timeStart = Time.realtimeSinceStartup;

        for (int i = 0; i < iterations; i++)
        {
            Vector2 v2 = testVector;
        }

        return Time.realtimeSinceStartup - timeStart;
    }

    float TestConvertByCasting()
    {
        var timeStart = Time.realtimeSinceStartup;

        for (int i = 0; i < iterations; i++)
        {
            Vector2 v2 = (Vector2)testVector;
        }

        return Time.realtimeSinceStartup - timeStart;
    }

    float TestConvertByInitializing()
    {
        var timeStart = Time.realtimeSinceStartup;

        for (int i = 0; i < iterations; i++)
        {
            Vector2 v2 = new Vector2(testVector.x, testVector.y);
        }

        return Time.realtimeSinceStartup - timeStart;
    }

}

Sowohl Vector2 als auch Vector3 sind eine Struktur in der Unity-Engine. Bei der Erstellung einer Struktur aus der anderen wird lediglich ein Speicher auf dem Stapel zugewiesen (es sei denn, das Ziel ist ein Attribut eines Klassenobjekts , mit dem dieser erste Schritt übersprungen werden kann.) und das Kopieren der beiden Komponentenwerte. Beide von Ihnen angegebenen Mechanismen sollten genau zu diesem IL-Code kompiliert werden.

Wenn bei einer Konvertierung dieses Typs ein Leistungsproblem auftritt , liegt wahrscheinlich ein Boxproblem vor , bei dem die Struktur in ein Klassenobjekt und dann von einem Klassenobjekt konvertiert wird. In diesem Fall sollten Sie untersuchen, ob, wann und wie das Boxen in leistungskritischen Teilen Ihres Codes vermieden werden kann.

Nach meinem Test ist es am besten, den Wert manuell selbst zuzuweisen.

Vector2 vector2;
vector2.x = vector3.x;
vector2.y = vector3.y;

Dies ist mein Ergebnis, das ich von Mattias ausgehe.

TestConvertByOperation 10000000-Instanzen: 0.3220527s

TestConvertByCasting 10000000 Instanzen: 0.3226218s

TestConvertByInitializing 10000000 Instanzen: 0.1916729s

TestConvertByManualAssign 10000000 Instanzen: 0.09500527s

using UnityEngine;

namespace myTest
{
    public class test: MonoBehaviour 
    {
        readonly int iterations = 10000000;
        Vector3 testVector = new Vector3(3f, 14f, 42f);

        void Start()
        {
            Debug.Log(string.Format("TestConvertByOperation {0} instances: {1}s", iterations, TestConvertByOperation()));
            Debug.Log(string.Format("TestConvertByCasting {0} instances: {1}s", iterations, TestConvertByCasting()));
            Debug.Log(string.Format("TestConvertByInitializing {0} instances: {1}s", iterations, TestConvertByInitializing()));
            Debug.Log(string.Format("TestConvertByManualAssign {0} instances: {1}s", iterations, TestConvertByManualAssign()));
        }

        float TestConvertByOperation()
        {
            var timeStart = Time.realtimeSinceStartup;
            Vector2 v2;
            for (int i = 0; i < iterations; i++)
            {
                v2 = testVector;
            }

            return Time.realtimeSinceStartup - timeStart;
        }

        float TestConvertByCasting()
        {
            var timeStart = Time.realtimeSinceStartup;
            Vector2 v2;
            for (int i = 0; i < iterations; i++)
            {
                v2 = (Vector2)testVector;
            }

            return Time.realtimeSinceStartup - timeStart;
        }

        float TestConvertByInitializing()
        {
            var timeStart = Time.realtimeSinceStartup;
            Vector2 v2;
            for (int i = 0; i < iterations; i++)
            {
                v2 = new Vector2(testVector.x, testVector.y);
            }

            return Time.realtimeSinceStartup - timeStart;
        }
        float TestConvertByManualAssign()
        {
            var timeStart = Time.realtimeSinceStartup;
            Vector2 v2;
            for (int i = 0; i < iterations; i++)
            {
                v2.x = testVector.x;
                v2.y = testVector.y;
            }

            return Time.realtimeSinceStartup - timeStart;
        }
    }
}

Bitte beachten Sie, dass ich es mit Unity Version 5.6.5 teste