Benefit of using Vector2 data type over separate x & y variables

Question

I'm really curious about why a lot of people and game engines use Vector2 as its coordinate system instead of the traditional x and y value.

Is there any benefit to this?

I feel like it's just slow me down and barely has any benefit other than organizing your code.

Answer 1

First of all, it's way less clutter. If you have a position, a velocity and an acceleration, that's already 6 variables you have to deal with, 9 in 3d.

Secondly, and this is the most important part, it grants you access to many ways to use or change them. For instance, getting the length of the vector, normalizing it, adding them together, dot product, cross product in 3d, etc. It's possible to do this using separate variables too, but it's much easier using vectors and follows the DRY principle much better.

As for slowing you down, I'm not sure why this would do that. Apart from having to create a new Vector instead of just 2 variables, you only have to pay attention to using vector.x and vector.y, which shouldn't be that hard and isn't much worse, than vectorX and vectorY

Answer 2

Compare the function signatures of both RotatePoints versions.

Lone variables:

void RotatePoints(
   float *out_x, 
   int x_interleave_out,
   const float *in_x, 
   int x_interleave_in,
   float *out_y, 
   int y_interleave_out, 
   const float *in_y, 
   int y_interleave_in,
   float angle, 
   int count
) 
{
  float s = sinf(angle);
  float c = cosf(angle);

  while(count--){
    *out_x = *in_x * c + *in_y * -s;
    *out_y = *in_x * s + *in_y * c;
    out_x += x_interleave_out;
    out_y += y_interleave_out;
    in_x += x_interleave_in;
    in_x += y_interleave_in;
  }
}

Compared to using structures/classes:

void RotatePoints(
  Vector2 *out, 
  const Vector2 *in, 
  float angle, 
  int count)
{
   Matrix2x2 rotation;
   rotation.SetRotation(angle);

   while(count--){
     *out++ = *in++ * rotation;
   }
}

You need to tell the first version if your x and y arrays are interleaved or separate:

float all_together[200]; // x0,y0,x1,y1,x2,y2...

Or:

float x[100];
float y[100];

It's a lot less messy to just have a Vector2 array and pass that and the inner code is more readable too.

And the more complex the math the messier and hairier it gets if you're not using Vector and Matrix classes;

Answer 3

Readability > Writeability

I feel like it's just slow me down and barely has any benefit other than organizing your code.

You are correct in that it (slightly) slows you down writing that code. However, you write it once in the beginning and from then on everytime you come back you are going to read it. So optimizing the reading speed will do much more good that optimizing the writing speed.

Naming things

Now, you might have difficulties seeing how draw_rect(Vector2(x, y), Vector2(width, height)) is supposed to be more readable than draw_rect(x, y, width, height), but to be honest, they both aren't as readable as they could be.

Look at this pseudocode:

position = Vector2(x, y)
size = Vector2(width, height)
draw_rect(position, size)

Yes, this takes 2 lines more and in the beginning I also thought that was bad. It isn't though. Giving things names makes this take less brain power to read, which you will be very thankful for as soon as the program gets more complex. Especially when you're debugging it. Naming things well will also improve other things and make you faster in the long run.

The still very short, but slightly longer run

You mentioned Object.x += 1 vs Object.pos += Vector2(1, 0) Again you're right, your way is faster for this (a single line). But let's just look at a minimally more complex class, you can have:

position;
velocity;

void UpdatePosition(){
    position += velocity;
}

Compare with:

xPosition;
yPosition;
xVelocity;
yVelocity;


void UpdatePosition(){
    xPosition += xVelocity;
    yPosition += xVelocity;
}

That is faster to read and to write. By the way, with such a small example it's not suuuper hidden, but did you notice the typo in the second version? That's easy to overlook, especially if the class is more complex than this unrealistically small example (There's a theme here...). It's one bug that can't happen when using Vector2.

IDEs

you cant shorten it by using something like Vec2 = Vector2

You might be working on a school assignment where you aren't allowed to use an IDE. If you don't, use one and look up the autocomplete shortcut (most of the time it's Ctrl+Space).

Then you can write "Vec" and use that shortcut and the IDE will show you a list of all classes that start with "Vec". I don't think any professional coder works without this, because this is so much faster. The alternative is to learn every class by heart, with correct typing down to the single character. Ain't nobody got time for that, especially in the business world where time is money.

Answer 4

Operator overloading.

Vector v3 = v2 + v1;

There is now only one place in your code where you have to write, test and debug vector addition, as opposed to tens, hundreds or thousands.

Obviously vector addition is an overly simplistic example, but there are more complex vector operations and the same applies to those too.

Answer 5

Using structures & classes in place of a pile of primitive variables allows us to focus more of our attention on the higher levels of problem solving.

As taken from Code Complete:

Reduce Complexity - A primary goal of software design and construction is conquering complexity. The motivation behind many programming practices is to reduce a program’s complexity, and reducing complexity is arguably the most important key to being an effective programmer.

Program in Terms of the Problem Domain - Another specific method of dealing with complexity is to work at the highest possible level of abstraction. One way of working at a high level of abstraction is to work in terms of the programming problem rather than the computer science solution.

Using a vector class / struct plays to both these points.

Answer 6

The same reasons that primitive obsession is a code smell apply to using a vector instead of separate variables. Vector2D/3D is just a special case of avoiding primitives.

Answer 7

Mathematically a vector is a point in a vector space. That's something with real physical relevance – the space we live in is basically a vector space.

The individual components x and y are not. They depend on a choice of coordinate frame, and generally there is no clear reason why some particular coordinate frame should be used. It's an implementation detail, so it's best encapsulated in an opaque type. Indeed, you'll mostly access individual components in very simple applications like 2D platformers, but in anything with somewhat serious physics handling you'll much more typically have offsets pointing in some direction that's unrelated to the coordinate axes. Doing that with coordinates would always require basically duplicating each calculation.