Is it possible to make a struct that "inherits" from vector2?

Unity Engine
,
1

basically I want a vector2 struct

the only difference is that i want the fields to be (x,z) instead of (x,y)

so I would do vec.x and vec.z

I could just make a custom struct

but I have realized that i suddenly lose all the convenient method calls like, .normalize, and worse, Vector2.dot, Vector2.Perpendicular and all this stuff

should I just live with it and use vec.y and a normal vector2 or is there a simple way to workaround this without making code spagetti?

Basically my reason for this is that the directions of movement in my game are X,Z and I want to make the code easy to understand and do pos.z + vec.z instead of pos.z + vec.y

I understand I could just work around everything by casting the struct everytime back to a normal vector2 but that would just make the code a mess, which is what im trying to avoid

any advice would be appreciated, thanks

2

struct cannot be inherited from.

You could make an extension method named z (or GetZ() to be in line with naming conventions) which simply redirects to/from y.

What I often do in such cases is to create an extension method Vector3 ToVector3(this Vector2 v2) which simply does: return new Vector3(v2.x, 0f, v2.y);

3

I haven’t made an extension method for a structure but I think it would work:

public static class Vector2Extensions

{

    public static float z(this Vector2 v)

    {

        return v.y;

    }

}

It wouldn’t support v2.z = something; but otherwise should function the same.

4

This would be spiffy but again it puts you close to some very mysterious potential failures.

Image if you could make a C# extension property that maps Vector2.z to Vector2.y

You blaze ahead and make lots of code using this.

Somewhere deep in that code you inadvertently type Vector3 on one of your variable declarations, then use this Vector3 variable by implicit cast of a Vector2, either going into or out of it.

For that variable only, suddenly your .z extension method would be returning the true .z…

Veeeeeery subtle and baffling bugs could ensue, especially if that was deep inside some other calculation chain.

5

What you need is very common and your only mistake was to rely on automatic conversions along the way (which were a huge mistake by Unity to make these in the first place, especially the implicit ones, I can’t stress that enough).

CodeSmile (and others) already pointed out that extensions exist. But it is not necessary to do this via extensions, in fact, I’d argue it’s better to do this in situ (unless you’re sure you’re going to repeat this all over the place).

You should not remap one component to another, instead you remap one vector to another. Typically, you need this when you work in 2D space and then want to translate this into 3D and vice versa.

static public class MyVectorExtensions {

  static public Vector3 toXY(this Vector2 v) => new(v.x, v.y, 0f);
  static public Vector3 toXZ(this Vector2 v) => new(v.x, 0f, v.y);

  static public Vector2 fromXY(this Vector3 v) => new(v.x, v.y);
  static public Vector2 fromXZ(this Vector3 v) => new(v.x, v.z);

}

You can use these in a couple of ways

Vector2 myVector = Vector2.up;
drawCircle(myVector.toXZ(), 5f);

// or
drawCircle(MyVectorExtensions.toXZ(myVector), 5f);

I always write these things locally, or I make a project-wide static class for all kinds of utilities.
In the latter case, I remove the need for having to prefix everything with ClassName. by stating the following in the using block

using static MyVectorExtensions;

then the 2nd example becomes

drawCircle(toXZ(myVector), 5f);

Also check my tutorials (look in the signature) where you can find well articulated code examples where I regularly employ the local static functions technique (not the extensions). I have zillions of good reasons why this is a good practice, I’ve even named the most of them in one of the tutorials (I think it’s the intercepting one).

You could make a custom struct but because Unity can’t use that natively, you’d have to write explicit (or implicit) conversions between the types.

public struct MyVector2 {

  public float x, y;
 
  public MyVector2(float x, float y) {
    this.x = x;
    this.y = y;
  }

  // here go all kinds of functionalities one would expect from 2D vector

  // this is an implicit casting between types
  static public implicit operator UnityEngine.Vector2(MyVector2 v) => new(v.x, v.y);

  // and the other way
  static public implicit operator MyVector(UnityEngine.Vector2 v) => new(v.x, v.y);

}

Now you can do

MyVector2 myVector = new MyVector2(0f, 1f);
drawCircle(myVector, 5f); // this is what implicit means, the conversion happens without you asking for it

// where
// void drawCircle(Vector2 center, float radius) {}

However, I would advise you against this if you don’t have much experience, doing this might open a Pandora’s box of weird stuff. And if you’re not on top of these techniques, please do avoid implicit casting like a plague, because you’re likely to turn everything into a very complicated mess of unfixable code.

This is how explicit casting expression looks

MyVector2 myVector = (MyVector2)unityVector;

And btw if you want to go down this route and learn how to implement your own vectors and other value types, make sure to learn the following areas of C# before that

  • reference vs value types
  • implicit vs explicit casting
  • IEquatable interface (and value type equality in general)
  • IComparable interface
  • custom operators (including casting operators, but also ==, !=, +, -, *, /)
  • hash codes and their purpose

That’s the bare minimum, imo, but you can very well make even a more robust and faster implementation of vectors and such. Heck you can even implement custom swizzling!

Or you can use (or peek into) Unity.Mathematics which does all of this already and has everything that you need (more or less). But if you go ahead and use float2 and float3, you still have this problem of converting that to comply with the traditional API.

6

Here’s taste of a proper custom Vector btw

using System;

public struct Vector2 : IEquatable<Vector2> {

  static readonly Vector2 _right = new(1f, 0f);
  static public Vector2 right => _right;
    
  static readonly Vector2 _up = new(0f, 1f);
  static public Vector2 up => _up;
    
  static readonly Vector2 _left = -right;
  static public Vector2 left => _left;
    
  static readonly Vector2 _down = -up;
  static public Vector2 down => _down;
    
  public float x, y;
    
  public Vector2(float x, float y) => (this.x, this.y) = (x, y);
    
  public float sqrMagnitude => Dot(this, this);
  public float magnitude => MathF.Sqrt(sqrMagnitude);
  public Vector2 normalized => this / magnitude;

  public void Normalize() {
    var m = magnitude;
    x /= m;
    y /= m;
  }
    
  static public float Distance(Vector2 a, Vector2 b) => (b - a).magnitude;
  static public float Dot(Vector2 a, Vector2 b) => a.x * b.x + a.y * b.y;
    
  public override bool Equals(object obj)
    => obj switch {
      Vector2 vec2 => Equals(vec2),
      {} => false
    };
    
  public bool Equals(Vector2 other) => x.Equals(other.x) && y.Equals(other.y);
    
  static public bool operator ==(Vector2 a, Vector2 b) => a.Equals(b);
  static public bool operator !=(Vector2 a, Vector2 b) => !(a == b);

  public override int GetHashCode() {
    var hash = new HashCode();
    hash.Add(x);
    hash.Add(y);
    return hash.ToHashCode();
  }

  public override string ToString() => ToString("F2");
    
  public string ToString(string format) => $"({x.ToString(format)}, {y.ToString(format)})";
    
  static public Vector2 operator -(Vector2 v) => new(-v.x, -v.y);
  static public Vector2 operator +(Vector2 a, Vector2 b) => new(a.x + b.x, a.y + b.y);
  static public Vector2 operator -(Vector2 a, Vector2 b) => a + (-b);
  static public Vector2 operator *(float s, Vector2 v) => new(s * v.x, s * v.y);
  static public Vector2 operator *(Vector2 v, float s) => s * v;
  static public Vector2 operator /(Vector2 v, float s) => new(v.x / s, v.y / s);
    
}