MeshBase.h

/*
 * Fermat
 *
 * Copyright (c) 2008-2019, NVIDIA CORPORATION. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *    * Neither the name of the NVIDIA CORPORATION nor the
 *      names of its contributors may be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "MeshException.h"

#include <string>
#include <map>
#include <vector>

static const int MESH_ATTRIBUTE_NOT_PROVIDED = -1;


/* --------------------------------------------------------------------------------  
 * Materials
 */

// TODO: Revise these in an sutil-centric way, rather than a .obj-centric way
/* Mimics the shading type enum found in GLM for obj shading types */
enum {
  MESH_SHADING_NONE           = (0),
  MESH_SHADING_FLAT           = (1 << 0),
  MESH_SHADING_SMOOTH         = (1 << 1),
  MESH_SHADING_TEXTURE        = (1 << 2),
  MESH_SHADING_COLOR          = (1 << 3),
  MESH_SHADING_MATERIAL       = (1 << 4),
  MESH_SHADING_FLAT_SHADE     = (1 << 5),
  MESH_SHADING_SPECULAR_SHADE = (1 << 6)
};

class SUTILCLASSAPI MeshTextureMap {
public:

  SUTILAPI MeshTextureMap() { }
  SUTILAPI ~MeshTextureMap() { } // So the CRT deletes it on the correct heap

  std::string name;
  float       scaling[2];
};

class SUTILCLASSAPI MeshMaterialParams {
public:

  SUTILAPI MeshMaterialParams() { setToDefaultParams(); }
  SUTILAPI ~MeshMaterialParams() { } // To ensure it's del'ed on the correct heap

  SUTILAPI void setToDefaultParams();

  std::string name;

  float diffuse[4];
  float diffuse_trans[4];
  float ambient[4];
  float specular[4];
  float emissive[4];
  float phong_exponent;
  float index_of_refraction;
  float opacity;
  float reflectivity[4];
  
  int   flags;
  int   shading_type;

  /* Texture maps */
  MeshTextureMap ambient_map;
  MeshTextureMap diffuse_map;
  MeshTextureMap diffuse_trans_map;
  MeshTextureMap specular_map;
  MeshTextureMap emissive_map;
  MeshTextureMap opacity_map;
  MeshTextureMap bump_map;
};

typedef std::map<std::string, int> MeshMaterialNumbersMap;


/* --------------------------------------------------------------------------------
 * Groups
 */
class SUTILCLASSAPI MeshGroup {
public:

  SUTILAPI MeshGroup() :
    num_triangles( 0 ),
    vertex_indices( 0 ),
    normal_indices( 0 ),
    color_indices( 0 ),
    texture_coordinate_indices( 0 ),
    material_indices( 0 ),
    material_number( 0 )
  { }

  SUTILAPI ~MeshGroup() { } // So the CRT deletes it on the correct heap

  std::string name;

  int num_triangles;
  
  int* vertex_indices;
  int* normal_indices;
  int* color_indices;
  int* texture_coordinate_indices;
  int* material_indices;

  int material_number;
};

typedef std::map<std::string, MeshGroup> MeshGroupMap;

enum MeshGrouping {
    kMergeGroups   = 0,
    kKeepGroups    = 1,
    kKeepSubgroups = 2,
};

/* --------------------------------------------------------------------------------
 * MeshBase abstract class.
 *
 * Implements common functionality for concrete Mesh classes, and provides
 * interface for methods that all Meshes should implement.
 */
class MeshBase {
public:

  MeshBase();

  // This destructor handles no de-allocation of itself, since resource
  // allocation is delegated to subclasses
  virtual ~MeshBase();

  virtual void loadModel( const std::string& filename, bool insertDefaultMaterial = true, const MeshMaterialParams& defaultMaterial = MeshMaterialParams() );

  template <class Functor>
  void forEachGroup( Functor functor ) const;

  template <class Functor>
  void forEachGroup( Functor functor );

  int getNumVertices() const { return m_num_vertices; }
  int getNumNormals() const { return m_num_normals; }
  int getNumColors() const { return m_num_colors; }
  int getNumTextureCoordinates() const { return m_num_texture_coordinates; }

  int getNumTriangles() const { return m_num_triangles; }
  int getNumGroups() const { return (int)m_mesh_groups.size(); }

  float* getVertexData() { return m_vertex_data; }
  const float* getVertexData() const { return m_vertex_data; }

  float* getNormalData() { return m_normal_data; }
  const float* getNormalData() const { return m_normal_data; }
  
  unsigned char* getColorData() { return m_color_data; }
  const unsigned char* getColorData() const { return m_color_data; }
  
  float* getTextureCoordinateData() { return m_texture_coordinate_data; }
  const float* getTextureCoordinateData() const { return m_texture_coordinate_data; }

  int getVertexStride() const { return m_vertex_stride; }
  int getNormalStride() const { return m_normal_stride; }
  int getColorStride() const { return m_color_stride; }
  int getTextureCoordinateStride() const { return m_texture_coordinate_stride; }

  const float* getBBoxMin() const { return m_bbox_min; }
  const float* getBBoxMax() const { return m_bbox_max; }

  void updateBBox();

  const std::string& getMaterialLibraryName() const { return m_material_library_name; }

  MeshGroup& getMeshGroup(const std::string& group_name) {
    MeshGroupMap::iterator found = m_mesh_groups.find(group_name);
    if( found != m_mesh_groups.end() ) {
      return found->second;
    }
    else {
      throw MeshException( "Could not find group named '" + group_name + "'" );
    }
  }

  const MeshGroup& getMeshGroup(const std::string& group_name) const {
    MeshGroupMap::const_iterator found = m_mesh_groups.find(group_name);
    if( found != m_mesh_groups.end() ) {
      return found->second;
    }
    else {
      throw MeshException( "Could not find group named '" + group_name + "'" );
    }
  }

  size_t getMaterialCount() const { return m_material_params.size(); }

  void setMeshMaterialParams( int i, const MeshMaterialParams& params ) {
    m_material_params[i] = params;
  }
  
  MeshMaterialParams& getMeshMaterialParams( int i ) {
    return m_material_params[i];
  }
  
  const MeshMaterialParams& getMeshMaterialParams( int i ) const
  { 
    return m_material_params[i];
  }

  void          setMeshGrouping(MeshGrouping grouping)  { m_grouping = grouping; }
  MeshGrouping  getMeshGrouping() const                 { return m_grouping; }


  /*--------------------------------------------------------------------------------  
   * Load functions
   */
  void loadFromObj( const std::string& filename, bool insertDefaultMaterial, const MeshMaterialParams& defaultMaterial );

  void loadMaterials( const std::string& material_filename );

  void loadFromPly( const std::string& filename, bool insertDefaultMaterial, const MeshMaterialParams& defaultMaterial );

protected:

  void setVertexData( float* vertex_data ) { m_vertex_data = vertex_data; }
  void setNormalData( float* normal_data ) { m_normal_data = normal_data; }
  void setColorData( unsigned char* color_data ) { m_color_data = color_data; }
  void setTextureCoordinateData( float* texture_coordinate_data ) { m_texture_coordinate_data = texture_coordinate_data; }
  void setMaterialIndices(int* material_indices) { m_material_indices = material_indices; }

  void setVertexStride( int vertex_stride ) { m_vertex_stride = vertex_stride; }
  void setNormalStride( int normal_stride ) { m_normal_stride = normal_stride; }
  void setColorStride( int color_stride ) { m_color_stride = color_stride; }
  void setTextureCoordinateStride( int texture_coordinate_stride ) { m_texture_coordinate_stride = texture_coordinate_stride; }

  void setVertexIndexStride( int index_stride ) { m_vertex_index_stride = index_stride; }
  void setNormalIndexStride( int index_stride ) { m_normal_index_stride = index_stride; }
  void setColorIndexStride( int index_stride ) { m_color_index_stride = index_stride; }
  void setTextureIndexStride( int index_stride ) { m_texture_index_stride = index_stride; }

  const std::string& getFilename() const { return m_filename; }
  const std::string& getPathName() const { return m_pathname; }

  //virtual int addMaterial(MeshMaterialParams& params) = 0;

  virtual int getVertexTriangleSize() const = 0;
  virtual int getNormalTriangleSize() const = 0;
  virtual int getTextureTriangleSize() const = 0;

  virtual void preProcess() = 0;

  virtual void allocateData() = 0;
 
  virtual void startWritingData() = 0;

  virtual void postProcess() = 0;

  virtual void finishWritingData() = 0;
  
  /* -------------------------------------------------------------------------------- 
   * Utility functions
   */
  void computeAabb();

private:
  /*--------------------------------------------------------------------------------  
   * Load functions
   */

  void loadInfoFromObj( const std::string& filename, bool insertDefaultMaterial, const MeshMaterialParams& defaultMaterial );

  void loadDataFromObj( const std::string& filename, bool insertDefaultMaterial, const MeshMaterialParams& defaultMaterial );

  void loadInfoFromPly( const std::string& filename, bool insertDefaultMaterial );

  void loadDataFromPly( const std::string& filename );

  // For loaders that only use a single group, initializes m_mesh_groups with that
  // one group.
  void initSingleGroup();  

  // Return a reference to the first group found in m_mesh_groups; mostly useful for
  // loaders that only use a single group.  Throws if m_mesh_groups is empty.
  MeshGroup& getFirstGroup();

  MeshGroup& getOrAddGroup( const std::string& name );

  std::string m_filename;
  std::string m_pathname;

  int m_num_vertices;
  int m_num_normals;
  int m_num_colors;
  int m_num_texture_coordinates;

  /* If any of these are 0, then load() won't bother write to the
   * array for that attribute, and it won't write indices for that attribute in
   * any of the groups.
   *
   * It is up to sub classes to implement their own logic for whether data are
   * allocated or not.
   */
  float*         m_vertex_data;
  float*         m_normal_data;
  unsigned char* m_color_data;
  float*         m_texture_coordinate_data;
  int*           m_material_indices;

  /* Measured in 'floats'.  0 indicates compacted data, equivalent to '2' for
   * texture_coordinates and '3' for the others.
   */
  int m_vertex_stride;
  int m_normal_stride;
  int m_color_stride;
  int m_texture_coordinate_stride;

  /* Measured in 'ints' per triangle.  0 indicates compacted data, equivalent to '3'.
   */
  int m_vertex_index_stride;
  int m_normal_index_stride;
  int m_color_index_stride;
  int m_texture_index_stride;

  int m_num_triangles;

  MeshGrouping                      m_grouping;
  MeshGroupMap                      m_mesh_groups;
  MeshMaterialNumbersMap            m_material_numbers_by_name; // TODO: replace these two lines with a map from name to material parameters
  std::vector<MeshMaterialParams>   m_material_params;

  std::string m_material_library_name;

  float m_bbox_min[3];
  float m_bbox_max[3];
};


template <class Functor>
void MeshBase::forEachGroup( Functor functor ) const
{
  MeshGroupMap::const_iterator groups_end = m_mesh_groups.end();
  for( MeshGroupMap::const_iterator groups_iter = m_mesh_groups.begin();
       groups_iter != groups_end; )
  {
    functor( (groups_iter++)->second );
      // The post-increment ++ ensures the iterator is updated before functor()
      // runs, since functor may invalidate the iterator
  }
}

template <class Functor>
void MeshBase::forEachGroup( Functor functor ) 
{
  MeshGroupMap::iterator groups_end = m_mesh_groups.end();
  for( MeshGroupMap::iterator groups_iter = m_mesh_groups.begin();
       groups_iter != groups_end; )
  {
    functor( (groups_iter++)->second );
      // The post-increment ++ ensures the iterator is updated before functor()
      // runs, since functor may invalidate the iterator
  }
}