Prism/Prism-ScriptCore/Src/Prism/Math/Vec4.cs

using System.Runtime.InteropServices;

namespace Prism
{
    [StructLayout(LayoutKind.Sequential)]
    public struct Vec4
    {
        public float X;
        public float Y;
        public float Z;
        public float W;

        public Vec4(float scalar)
        {
            X = Y = Z = W =scalar;
        }

        public Vec4(float x, float y, float z, float w)
        {
            X = x;
            Y = y;
            Z = z;
            W = w;
        }

        public static Vec4 operator+(Vec4 left, Vec4 right)
        {
            return new Vec4(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
        }

        public static Vec4 operator-(Vec4 left, Vec4 right)
        {
            return new Vec4(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
        }

        public static Vec4 operator*(Vec4 left, Vec4 right)
        {
            return new Vec4(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
        }

        public static Vec4 operator *(Vec4 left, float scalar)
        {
            return new Vec4(left.X * scalar, left.Y * scalar, left.Z * scalar, left.W * scalar);
        }

        public static Vec4 operator *(float scalar, Vec4 right)
        {
            return new Vec4(scalar * right.X, scalar * right.Y, scalar * right.Z, scalar * right.W);
        }

        public static Vec4 operator/(Vec4 left, Vec4 right)
        {
            return new Vec4(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
        }

        public static Vec4 operator /(Vec4 left, float scalar)
        {
            return new Vec4(left.X / scalar, left.Y / scalar, left.Z / scalar, left.W / scalar);
        }

        public static Vec4 Lerp(Vec4 a, Vec4 b, float t)
        {
            if (t < 0.0f) t = 0.0f;
            if (t > 1.0f) t = 1.0f;
            return (1.0f - t) * a + t * b;
        }

    }
}