Create and Iterate through an array of templated objects - c++

Question

I have create a C++ template define different data type 2D points, as a task to re-learn C++ in an OpenGL program.
template <typename T>
class Point2D {
public:
Point2D(const T& x, const T& y) {
_data[0] = x;
_data[1] = y;
}
const T & x() { return _data[0]; }
const T & y() { return _data[1]; }
private:
T _data[2];
};
I can create multiple named instances of the Point2D and store values and use them to draw basic shapes
Point2D <GLdouble> c0( 0.5, 0.5);
Point2D <GLdouble> c1(-0.5, 0.5);
then to draw a like I access the values in the points.
glBegin(GL_LINES);
glVertex2d(c0.x(), c0.y());
glVertex2d(c1.x(), c1.y());
glEnd();
However, I would like to create an array of Points2D objects of the same templated type (eg double) to represent a shape.
How do I create and array of templated Point2D represent more complex objects that I could draw in for loop array of templated objects.
glBegin(GL_POLYGON);
for (k = 0; k < 4; k++) {
glVertex2d( ????? [i].x(), ????? [i].x());
}
glEnd();
Could someone suggest a way I can do this?
Thanks
Stuart

Answer 1

To storing multiple points use a C array or even better std::vector container and then in loop enumerate points and call glVertex2d for each
#include <vector>
std::vector< Point2D <GLdouble> > points = {Point2D<GLdouble>(0.5, 0.5),
Point2D<GLdouble>(-0.5, 0.5)};
size_t size = points.size();
glBegin(GL_LINES);
for (size_t i = 0; i < size; ++i)
{
glVertex2d( points[i].x(), points[i].x());
}
glEnd();
But if you use OpenGL 1.1 or greater it is better to use vertex array buffer instead individual glVertex call. Try to modify your point class by adding method which return ponter to firts array element
template <typename T>
class Point2D {
public:
Point2D(const T& x, const T& y) {
_data[0] = x;
_data[1] = y;
}
const T & x() { return _data[0]; }
const T & y() { return _data[1]; }
T* data() const { return &_data[0]; }
private:
T _data[2];
};
then add points to container, create once vertex buffer then bind it and call function glVertexPointer. To draw elements use glDrawArrays
GLuint bufferId;
glGenBuffers(1, &bufferId);
std::vector< Point2D <GLdouble> > points = {Point2D<GLdouble>(0.5, 0.5),
Point2D<GLdouble>(-0.5, 0.5)};
size_t size = points.size();
glBindBuffer(GL_ARRAY_BUFFER, bufferId);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_DOUBLE, 0, (const GLvoid *)points[0].data()); // <= 2 - X and Y
glDrawArrays(GL_LINES, 0, points.size());

Answer 2

why don't you use the std::vector ? Something like :
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
class Point2D {
public:
Point2D(const T& x = T(), const T& y = T()) {
_data[0] = x; _data[1] = y;
}
const T & x() { return _data[0]; }
const T & y() { return _data[1]; }
private:
T _data[2];
};
int main()
{
vector<Point2D<double> > polygon(4);
for(int i=0;i < polygon.size(); ++i)
cout << "Point " << i << " = (" << polygon[i].x() << "," << polygon[i].y() << ")" << endl;
return 0;
}