C++ Vector Math and OpenGL compatible

Question

I've been doing lots of vector math stuff and wrote my own template for it.

My requirements are lots of vector maths (addition, subtraction, scale, cross prod, and dot prod) also I need to be able to pass my vector as a float[] so that openGL can make use of it.

I've been using this quite happily for sometime, today a lecturer saw it and groaned. There was two things he particularly hated (one of which I understand), my use of inheritance because it didn't seem to follow an is a style. And my casting (T*)this, of course he didn't have much in the way of a solution.

First: The inheritance, I need to be able to make use of vec2 to vec4's so I designed my vectors like this.

template<typename T>
Vector2D
{
 public:
 getX(), getY(), setX(), setY() ....
};

template<typename T>
Vector3D : public Vector2D<T>
{
 public:
 getZ(), setZ() ...
}

template<typename T>
Vector4D : public Vector3D<T>
{
 public:
 getW(), setW() ...
}

Why is this bad? and tbh I can't see how to improve it. I need(want) to be able to define type and have getters and setters of some sort. If I rearranged it like

template<typename T, int _size>
VectorT

I'd loose my .getX(), .setX() stuff and have to replace it with something like .at() or []. tbh I prefer the readability of .getX(), although it would make operator definitions easier.

Second: I can see why this is bad, but to make it so I can pass these vectors into openGL's method that expect a float array I've overloaded the splat operator

// Defined in Vector2D<T>
operator*() { return (T*)this; }

As I understand it, there is no guarantee that the compiler will put the member variables x,y,z,w at the beginning of the class, and if not careful I might end up passing the v-table instead. However I must admit I've had no problems so far.

The only way I can see around this is to maintain an array that gets returned. Which I suppose would be easier if I changed they way I deal with vectors in the first place.

Post more code. Where is `operator*` defined? Where are getX() and setX() methods? — BЈовић, Apr 06 '11 at 15:31

score 6 · Accepted Answer · answered Apr 06 '11 at 15:32

6

You may want to consider using GLM instead. It does all that you've described (though I found the documentation lacking) including integration with OpenGL.

answered Apr 06 '11 at 15:32

andand

17,134
11
53
79

Why did you find the documentation lacking? I agree on: no search function and guessing in what namespace it is in. – Marnix Apr 06 '11 at 15:36
1

@Marnix: The manual (http://glm.g-truc.net/glm-0.9.1.pdf) doesn't contain enough information about how to use all of the features, only the basic ones (e.g. no mention of using the templated versions of the vectors or matrices). The API Documentation (http://glm.g-truc.net/api-0.9.1/index.html) appears to have taken a minimalist approach to describing the function of arguments (e.g. what does 'm' do at http://glm.g-truc.net/api-0.9.1/a00237.html#ga48168ff70412019857ceb28b3b2b1f5e ?) – andand Apr 06 '11 at 15:48
1

I would actually recommend [vmmlib](http://vmmlib.sourceforge.net/) or [Eigen](http://eigen.tuxfamily.org/index.php?title=Main_Page) over GLM, personally. Both work easily with OpenGL, and are easy to use and well-documented. – greyfade Apr 06 '11 at 16:32

score 2 · Answer 2 · answered Apr 06 '11 at 15:41

You can listen to your teacher, and use partial specialization (warning : not tested) :

template<typename T, int size>
class Vector;

template< typename T >
class Vector< T, 2 >
{
  public :
    Vector() : data() {}

    T GetX() const { return data[0]; };
    T GetY() const { return data[1]; };

    void SetX( const T v ) const { data[0]=v; };
    void SetY( const T v ) const { data[1]=v; };

  private :
    T data[2];
};

template< typename T >
class Vector< T, 3 >
{
  public :
    Vector() : data() {}

    T GetX() const { return data[0]; };
    T GetY() const { return data[1]; };
    T GetZ() const { return data[2]; };

    void SetX( const T v ) const { data[0]=v; };
    void SetY( const T v ) const { data[1]=v; };
    void SetZ( const T v ) const { data[2]=v; };

  private :
    T data[3];
};

Probably want to use size_t (or some other unsigned integer type instead of a signed int) for the size type to guard against negative size template arguments. — andand, Apr 06 '11 at 16:20

score 1 · Answer 3 · answered Apr 06 '11 at 15:41

How about this:

template<class T, int _dim>
class Vector
{
    T v[_dim];
    operator*(){return v;}

friend T inner_product(Vector<T, _dim> const &v1, Vector<T, _dim> const &v2);
};

template<class T, int _dim>
T inner_product(Vector<T, _dim> const &v1, Vector<T, _dim> const &v2)
{
    T p = 0.;
    for(int i; i < _dim; i++)
        p += v1.v[i] * v2.v[i];
    return p;
}

template<class T>
class Vector2 : Vector<T, 2>
{
    float getX() const {return v[0];}
    float getS() const {return v[0];}

    float getY() const {return v[1];}
    float getT() const {return v[1];}
}

template<class T>
class Vector3 : Vector<T, 3>, Vector2<T>
{
    float getZ() const {return v[2];}
    float getR() const {return v[2];}
}

template<class T>
class Vector4 : Vector<T, 4>, Vector3<T>
{
    float getW() const {return v[3];}
    float getQ() const {return v[3];}
}

Note that making inner_product a friend, not being part of the class, allows you to use it for all derived types!

score 0 · Answer 4 · answered Apr 06 '11 at 15:34

Like you said, you are abusing the "is-a" nature of inheritance. The problem might arise if you wrote a function like this

float dotProduct(vector2D a, vector2D b);

You could pass in a 3D vector and get a scalar result when really the dot product of a 2d vector and a 3d vector is undefined and this is actually a bug which could lead to weird behavior. Granted this isn't a huge deal, but you are throwing away some of the type checking, and if you are going to deal with the pain of static typing you might as well gets its benefits when bugs like that arise.

Maintaining the array is definitely a superior solution, you don't want to rely on undefined behavior, because you never know when it's going to completely screw you over.

Ah I didn't think about what would happen if you passed in Vector2D's instead of 3's (or vise versa), thanks. — , Apr 06 '11 at 16:13

score 0 · Answer 5 · answered Apr 06 '11 at 15:35

I'd probably do something like this:

template<typename T>
class VectorT{
protected:
  T* m_data;
  int m_size;

public:
  VectorT(unsigned int size) 
  : m_size(size)
  {
    m_data=new T[size];
  }

  virtual ~VectorT()
  {
    delete[] m_data;
  }

  T* operator*() { return m_data; }
  T& operator[](int ii) { return m_data[ii]; }
}

template<typename T>
class Vector3 : public VectorT<T>
{
public:
  Vector3() : VectorT(3) {}
  T getX() { return m_data[0]; }
  T getY() { return m_data[1]; }
  T getZ() { return m_data[2]; }

  Vector3 crossP(const Vector3& vv) { ... }
}

score -1 · Answer 6 · answered Oct 25 '12 at 15:41

-1

Here is a complete OpenGL styled Math library ( open source ) for c++

http://glm.g-truc.net/

answered Oct 25 '12 at 15:41

hhamm

1,511
15
22

C++ Vector Math and OpenGL compatible

6 Answers6

Linked