BSP_TMesh.h

Go to the documentation of this file.

#ifndef BSP_TMesh_h
#define BSP_TMesh_h

#include "MT_Point3.h"
#include "MT_Vector3.h"
#include "MT_Transform.h"

#include "MEM_SmartPtr.h"

#include <vector>

#include "CSG_BooleanOps.h"

struct BSP_TVertex {
        MT_Point3 m_pos;
};

struct BSP_TFace {
        int m_verts[3];
        MT_Vector3 m_normal;
};


class BSP_TMesh {
public :

        std::vector<BSP_TVertex> m_verts;
        std::vector<BSP_TFace> m_faces;
        
        MT_Vector3 m_min,m_max;

                std::vector<BSP_TVertex> &
        VertexSet(
        ){
                return m_verts;
        }

                std::vector<BSP_TFace> &
        FaceSet(
        ) {
                return m_faces;
        }

                void
        AddFace(
                int *verts,
                int num_verts
        ){
                int i;
                for (i= 2; i <num_verts; i++) {
                        BSP_TFace f;
                        f.m_verts[0] = verts[0];
                        f.m_verts[1] = verts[i-1];
                        f.m_verts[2] = verts[i];

                        m_faces.push_back(f);

                        BuildNormal(m_faces.back());            
                }
        }

                void
        BuildNormal(
                BSP_TFace & f
        ) const {
                MT_Vector3 l1 = 
                        m_verts[f.m_verts[1]].m_pos - 
                        m_verts[f.m_verts[0]].m_pos;
                MT_Vector3 l2 = 
                        m_verts[f.m_verts[2]].m_pos - 
                        m_verts[f.m_verts[1]].m_pos;

                MT_Vector3 normal = l1.cross(l2);
                
                f.m_normal = normal.safe_normalized();
        }
                
};



struct VertexIt {
        BSP_TMesh * mesh;
        BSP_TVertex * pos;
        MT_Transform trans;
};


static
        void
VertexIt_Destruct(
        CSG_VertexIteratorDescriptor * iterator
) {
        delete ((VertexIt *)(iterator->it));
        iterator->it = NULL;
        delete(iterator);
};


static
        int
VertexIt_Done(
        CSG_IteratorPtr it
) {
        // assume CSG_IteratorPtr is of the correct type.
        VertexIt * vertex_it = (VertexIt *)it;

        if (vertex_it->pos < vertex_it->mesh->VertexSet().end()) return 0;
        return 1;
};

static
        void
VertexIt_Fill(
        CSG_IteratorPtr it,
        CSG_IVertex *vert
) {
        // assume CSG_IteratorPtr is of the correct type.
        VertexIt * vertex_it = (VertexIt *)it;
                        
        MT_Point3 p = vertex_it->pos->m_pos;
        p = vertex_it->trans * p;

        p.getValue(vert->position);
};

static
        void
VertexIt_Step(
        CSG_IteratorPtr it
) {
        // assume CSG_IteratorPtr is of the correct type.
        VertexIt * vertex_it = (VertexIt *)it;

        ++(vertex_it->pos);
};

static
        void
VertexIt_Reset(
        CSG_IteratorPtr it
) {
        // assume CSG_IteratorPtr is of the correct type.
        VertexIt * vertex_it = (VertexIt *)it;

        vertex_it->pos = vertex_it->mesh->VertexSet().begin();
};

static
        CSG_VertexIteratorDescriptor * 
VertexIt_Construct(
        BSP_TMesh *mesh,
        MT_Transform trans
){
        // user should have insured mesh is not equal to NULL.
        
        CSG_VertexIteratorDescriptor * output = new CSG_VertexIteratorDescriptor;
        if (output == NULL) return NULL;
        output->Done = VertexIt_Done;
        output->Fill = VertexIt_Fill;
        output->Step = VertexIt_Step;
        output->Reset = VertexIt_Reset;
        output->num_elements = mesh->VertexSet().size();
        
        VertexIt * v_it = new VertexIt;
        v_it->mesh = mesh;
        v_it->pos = mesh->VertexSet().begin();
        v_it->trans = trans;
        output->it = v_it;
        return output;
};                      


struct FaceIt {
        BSP_TMesh * mesh;
        BSP_TFace *pos;
};


static
        void
FaceIt_Destruct(
        CSG_FaceIteratorDescriptor * iterator
) {
        delete ((FaceIt *)(iterator->it));
        iterator->it = NULL;
        delete(iterator);
};


static
        int
FaceIt_Done(
        CSG_IteratorPtr it
) {
        // assume CSG_IteratorPtr is of the correct type.
        FaceIt * face_it = (FaceIt *)it;

        if (face_it->pos < face_it->mesh->FaceSet().end()) {
                return 0;
        }
        return 1;
};

static
        void
FaceIt_Fill(
        CSG_IteratorPtr it,
        CSG_IFace *face
){
        // assume CSG_IteratorPtr is of the correct type.
        FaceIt * face_it = (FaceIt *)it;                
        // essentially iterating through a triangle fan here.

        face->vertex_index[0] = int(face_it->pos->m_verts[0]);
        face->vertex_index[1] = int(face_it->pos->m_verts[1]);
        face->vertex_index[2] = int(face_it->pos->m_verts[2]);

        face->vertex_number = 3;
};

static
        void
FaceIt_Step(
        CSG_IteratorPtr it
) {
        // assume CSG_IteratorPtr is of the correct type.
        FaceIt * face_it = (FaceIt *)it;                

        face_it->pos ++;
};

static
        void
FaceIt_Reset(
        CSG_IteratorPtr it
) {
        // assume CSG_IteratorPtr is of the correct type.
        FaceIt * face_it = (FaceIt *)it;                

        face_it->pos = face_it->mesh->FaceSet().begin();
};

static
        CSG_FaceIteratorDescriptor * 
FaceIt_Construct(
        BSP_TMesh * mesh
) {
        CSG_FaceIteratorDescriptor * output = new CSG_FaceIteratorDescriptor;
        if (output == NULL) return NULL;

        output->Done = FaceIt_Done;
        output->Fill = FaceIt_Fill;
        output->Step = FaceIt_Step;
        output->Reset = FaceIt_Reset;

        output->num_elements = mesh->FaceSet().size();
        
        FaceIt * f_it = new FaceIt;
        f_it->mesh = mesh;
        f_it->pos = mesh->FaceSet().begin();

        output->it = f_it;

        return output;
};

static
        MEM_SmartPtr<BSP_TMesh>
BuildMesh(
        CSG_MeshPropertyDescriptor &props,
        CSG_FaceIteratorDescriptor &face_it,
        CSG_VertexIteratorDescriptor &vertex_it
) {
        MEM_SmartPtr<BSP_TMesh> mesh = new BSP_TMesh();

        CSG_IVertex vert;

        while (!vertex_it.Done(vertex_it.it)) {

                vertex_it.Fill(vertex_it.it,&vert);
        
                BSP_TVertex v;
                v.m_pos = MT_Point3(vert.position);
                mesh->VertexSet().push_back(v);

                vertex_it.Step(vertex_it.it);
        }

        
        CSG_IFace face;

        while (!face_it.Done(face_it.it)) {
                face_it.Fill(face_it.it,&face);

                BSP_TFace f;

                f.m_verts[0] = face.vertex_index[0],
                f.m_verts[1] = face.vertex_index[1],
                f.m_verts[2] = face.vertex_index[2],

                mesh->BuildNormal(f);

                mesh->FaceSet().push_back(f);

                face_it.Step(face_it.it);
        }

        return mesh;
};



        

        






        



        



















#endif