用于存储顶点属性的数据结构

Question

I need to implement a structure which stores vertices by the attributes. For example every vertex has an attribute like "Normals" or "Position" "Colors" etc., and they can be accessed by their names.

VertexStructure vstruct;
AttribStream posStream = vstruct.CreateNewAttributeStream("Position",Vec3<double>);
posStream.push_back(Vec3<double>(23.5,12.5,11.3));

AttribStream normalStream = vstruct.CreateNewAttributeStream("Normals",Vec3<double>);
normalStream.push_back(Vec3<double>(0.03,0.02,0.18));

AttribStream indexStream = vstruct.CreateNewAttribStream("Indices",int);
indexStream.push_back(23);

std::cout << indexStream.size() << "," << normalStream.size() << posStream.size() << std::endl;

Now one easy way I can do it is to create an enum with pre-defined data types, like how OpenGL does it. Like:

enum {
 DOUBLE = 0,
 FLOAT,
 INT,
};

 AttribStream posStream = vstruct.CreateNewAttributeStream("Position",DOUBLE,3);
 posStream.push_back_vec3d(23.5,12.5,11.3);

But, it is very verbose and I have to create an enum for every possible data type and have separate functions for each data type to push back new elements.

Another possible way is using Abstract classes. But even that doesn't guarantee type-safety (unless using RTTI) and involves casting and also very hard to abstract it. Also, there is no way to create a generic 'push_back' , so I need to create specialized functions for every type.

class PX_STREAMBase
{
public:

    template <typename T>
    PX_STREAMBase( T val) : value_type(typeid(T)),
    value_size(sizeof(val))
    {};

    virtual size_t bytes() const = 0;
    virtual size_t size() const = 0;
    virtual const void* data() const = 0;

    const std::type_info& value_type;
    const std::size_t value_size;

private:


};

template<typename T, template <typename, typename> class Container =  std::vector> class PX_STREAM;
template<typename T, template <typename, typename> class Container>
class PX_STREAM : public PX_STREAMBase {
public:
    PX_STREAM() :
    PX_STREAMBase( T())
    {}

    size_t bytes() const {
        return vec.size() * value_size;
    }
    size_t size() const {
        return vec.size();
    }
    const void* data() const {
        return vec.data();
    }
private:


    Container<T, std::allocator<T> > vec;
};

Lastly, there is using a char array struct as described in this question So, what is the best way to create a structure that abstracts the vector and can hold an attribute stream of any type?

Answer 1

Okay, so this looks like you're trying to create a struct to store data for a 3D model. Vertex coordinates and normals. Honestly, I think you're just trying to make it to fancy. A struct with a pair vec3<double> s that store the positions and normals (actually, these should be floats if you want to use them in openGL as most graphics cards have terrible support for double precision floats), and then whatever other data your system is storing for it's models. You use a vector of this structure and it keeps all of the information for any given vertex together.

If you really need to keep all of the data separate, I've not seen a system that has such a need yet but my experience is still more limited than I would like, then create a struct or class that just has a number of vectors that each contains a vec3 or whatever datatype you need for that particular structure. Most systems know what kind of data they're going to be looking at for their models, so implementing these structures statically shouldn't be a problem. For the final vertex data, you just create a structure that contains a number of indices for the separate components that make up a particular vertex.

Is there a reason a much simpler system like:

class Model
{
private:
    //These vectors serve just to hold all of the data for all of your vertices
    vector<vec3<float> > positions;
    vector<vec3<float> > normals;
    vector<vec3<float> > colors;

    //This struct holds indices to the vectors above
    struct Vertex
    {
        int position;
        int normal;
        int color;
    };

    //Holds a list of all of your vertices, but allows you to pair different positions with different normals, etc...
    vector<Vertex> vertices;

    //Holds a list of indices from vertices that are your points to draw.
    vector<int> drawPoints;
public:
    //constructor, destructor, and accessors to add elements to your various elements.
};

wouldn't work?