---

Mesh.h

/*
  File: Mesh.h

  Copyright(C) C. Kotterink, Computed Graphics
*/
#ifndef MESH_H
#define MESH_H

#include<Object.h>
#include<Material.h>
#include<AABoundingBox.h>
#include<RenderContext.h>

#include<vector>

class Matrix4;
class CollisionHull;

class Mesh : public Object
{
public:
    // Restriction: max vertex count == 65535
    typedef vector<Vertex3> VertexList;
    typedef vector<Vertex3> NormalList;
    typedef vector<uint16> FaceList;
    typedef vector<uint32> FaceIndexList;

    class TriangleIterator {
    public:
        TriangleIterator(const FaceList::iterator fb, bool strip)
            : face(fb), isStrip(strip), invert(false)
        {
            if (isStrip && (*face == *(face+2))) { // It's a swap
                ++face;
                invert = !invert;
            }
        }

        bool operator<(const FaceList::iterator end) {
            return (face+2 < end);
        }
        TriangleIterator &operator++() {
            if (isStrip) {
                invert = !invert;
                ++face;
                if (*face == *(face+2)) { // It's a swap
                    ++face;
                    invert = !invert;
                }
            } else {
                face += 3;
            }
            return *this;
        }
        uint16 a() { return (invert ? *(face+2) : *face); }
        uint16 b() { return *(face+1); }
        uint16 c() { return (invert ? *face : *(face+2)); }

    private:
        bool isStrip;
        bool invert;
        FaceList::iterator face;
    };

    Mesh();
    ~Mesh();

    int nFaces() {
        return n;
    }
    int nVertices() {
        return vertex.size();
    }
    int nStrips();
    VertexList &vertexArray() {
        return vertex;
    }
    FaceList &faceArray() {
        return face;
    }
    NormalList &normalArray() {
        return faceNormal;
    }
    RefMaterial &getMaterial() {
        return material;
    }
    void setMaterial(const RefMaterial &m) {
        material = m;
    }
    void setMaterial(Material *m) {
        material = m;
    }
    bool hasTriStrips();
    void generateVertexNormals(bool gen);

    void clear();
    void invertFace(unsigned int i);
    void startStrips();
    void endStrip();
    void deStripe();
    void calculate();
    void calculateFaces();
    
    void transform(Matrix4 &M);
    void renderSimple(RenderContext &rc, bool pushTriNames);

    // Object
    void render(
        RenderContext &rc,
        RenderContext::Visibility visibility = RenderContext::PartlyVisible);
    float collide(const CollisionHull &hull, Vertex3 &nearestIntersection);
    real intersect(const Ray &ray) const;
    void read(WDFFile &f);
    void write(WDFFile &f);
    void readChunk(WDFFile::Chunk &chunk, WDFFile &f);

private:
    typedef enum MeshBitTypes {
        NormalPerFace = 0x0001,     
        NormalPerVertex = 0x0002,   
        TriStrips = 0x0004,         
    };

void calculateBound();

    uint32 n;
    uint16 type;
    bool generateNormals;

    VertexList vertex;
    FaceList face;
    FaceIndexList faceIndex;
    NormalList faceNormal;
    NormalList vertexNormal;

    RefMaterial material;
};
#endif

---

This documentation was generated using doxygen. If you have any comments or additions please mail me.