mesh.h

Go to the documentation of this file.

/*
 This file is part of the MinGfx Project.
 
 Copyright (c) 2017,2018 Regents of the University of Minnesota.
 All Rights Reserved.
 
 Original Author(s) of this File:
    Dan Keefe, 2018, University of Minnesota
    
 Author(s) of Significant Updates/Modifications to the File:
    ...
 */
 
#ifndef SRC_MESH_H_
#define SRC_MESH_H_
 
 
 
#include "bvh.h"
#include "color.h"
#include "opengl_headers.h"
#include "point2.h"
#include "point3.h"
#include "vector3.h"
 
#include <vector>
 
 
namespace mingfx {
 
class Matrix4;
    
class Mesh {
public:
    Mesh();
    
    Mesh(const Mesh &other);
    
    virtual ~Mesh();
    
    
    void LoadFromOBJ(const std::string &filename);
    
    
    
    // ---- TRIANGLE LIST MODE ----
    // No indices are stored, each set of 3 vertices forms a triangle, and if the
    // triangles share vertices, those vertices need to be repeated.
    
    int AddTriangle(Point3 v1, Point3 v2, Point3 v3);
    
    void UpdateTriangle(int triangle_id, Point3 v1, Point3 v2, Point3 v3);
    
    void SetNormals(int triangle_id, Vector3 n1, Vector3 n2, Vector3 n3);
 
    void SetColors(int triangle_id, Color c1, Color c2, Color c3);
    
    void SetTexCoords(int triangle_id, int texture_unit, Point2 uv1, Point2 uv2, Point2 uv3);
    
    
 
    // ---- INDEXED TRIANGLES MODE ----
    // Vertices are stored in an array and indices are stored in a separate array
    // each set of 3 indices into the vertex array defines one triangle.  Here,
    // you cannot add one triangle at a time to the mesh.  Instead you must set
    // the arrays of indices, vertices, and other attributes for the mesh at
    // once.
    
    void SetVertices(const std::vector<Point3> &verts);
    
    void SetNormals(const std::vector<Vector3> &norms);
    
    void SetColors(const std::vector<Color> &colors);
    
    void SetTexCoords(int texture_unit, const std::vector<Point2> &tex_coords);
    
    void SetIndices(const std::vector<unsigned int> index_array);
    
    
    void SetInstanceTransforms(const std::vector<Matrix4> &xforms);
    
    
    // ---- These functions can be used instead of the above if you are working with
    // regular C-style arrays and floats rather than the higher level types like
    // Point3 and Vector3. ----
    
    void SetVertices(float *verts_array, int num_verts);
 
    void SetNormals(float *norms_array, int num_norms);
 
    void SetColors(float *colors_array, int num_colors);
 
    void SetTexCoords(int texture_unit, float *tex_coords_array, int num_tex_coords);
    
    void SetIndices(unsigned int *index_array, int num_indices);
 
    
    
    void UpdateGPUMemory();
    
    void Draw();
    
 
    
    void CalcPerFaceNormals();
    
    void CalcPerVertexNormals();
    
    
    void BuildBVH();
    
    BVH* bvh_ptr();
    
    // Access to properties indexed by vertex number
    
    int num_vertices() const;
    
    Point3 read_vertex_data(int vertex_id) const;
    
    Vector3 read_normal_data(int vertex_id) const;
    
    Color read_color_data(int vertex_id) const;
    
    Point2 read_tex_coords_data(int texture_unit, int vertex_id) const;
    
    
    // Access to triangles
    
    int num_triangles() const;
    
    // of unsigned ints.  Use the SetIndices() function to set (or edit) the indices for the mesh.
    std::vector<unsigned int> read_triangle_indices_data(int triangle_id) const;
    
   
private:
    std::vector<float> verts_;
    std::vector<float> norms_;
    std::vector<float> colors_;
    std::vector< std::vector<float> > tex_coords_;
    std::vector<unsigned int> indices_;
    std::vector<float> instance_xforms_;
    
    bool gpu_dirty_;
    GLuint vertex_buffer_;
    GLuint vertex_array_;
    GLuint element_buffer_;
    
    bool bvh_dirty_;
    BVH bvh_;
};
    
    
} // end namespace
 
 
#endif