mesh.h

Go to the documentation of this file.

#ifndef K3DSDK_MESH_H
#define K3DSDK_MESH_H

// K-3D
// Copyright (c) 1995-2009, Timothy M. Shead
//
// Contact: tshead@k-3d.com
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include <k3dsdk/bounding_box3.h>
#include <k3dsdk/named_arrays.h>
#include <k3dsdk/named_array_types.h>
#include <k3dsdk/named_tables.h>
#include <k3dsdk/pipeline_data.h>
#include <k3dsdk/table.h>
#include <k3dsdk/typed_array.h>
#include <k3dsdk/uint_t_array.h>

namespace k3d
{

class imaterial;
class mesh_selection;

// mesh

class mesh
{
public:
  mesh();

  typedef uint_t_array indices_t;
  typedef uint_t_array counts_t;
  typedef uint_t_array orders_t;
  typedef typed_array<double_t> weights_t;
  typedef typed_array<double_t> knots_t;
  typedef typed_array<double_t> selection_t;
  typedef typed_array<imaterial*> materials_t;
  typedef typed_array<bool_t> bools_t;
  typedef typed_array<color> colors_t;
  typedef typed_array<double_t> doubles_t;
  typedef typed_array<matrix4> matrices_t;
  typedef typed_array<normal3> normals_t;
  typedef typed_array<point2> points_2d_t;
  typedef typed_array<point3> points_t;
  typedef typed_array<string_t> strings_t;
  typedef typed_array<texture3> texture_coordinates_t;
  typedef typed_array<vector3> vectors_t;
  typedef k3d::named_arrays named_arrays_t;
  typedef k3d::table table_t;
  typedef k3d::named_tables named_tables_t;

  class primitive
  {
  public:
    primitive();
    primitive(const string_t& Type);

    string_t type;
    named_tables_t structure;
    named_tables_t attributes;

    void difference(const primitive& Other, difference::accumulator& Result) const;
  };

  class primitives_t :
    public std::vector<pipeline_data<primitive> >
  {
  public:
    primitive& create(const string_t& Type);
  };

  pipeline_data<points_t> points;
  pipeline_data<selection_t> point_selection;
  table_t point_attributes;
  primitives_t primitives;

  void difference(const mesh& Other, difference::accumulator& Result) const;

  static const bounding_box3 bounds(const mesh& Mesh);
  static const bounding_box3 bounds(const points_t& Points);

  static void create_index_removal_map(const mesh::bools_t& KeepIndices, mesh::indices_t& IndexMap);
  static void create_index_list(const mesh::bools_t& SelectedIndices, mesh::indices_t& IndexSet);
  static void lookup_unused_points(const mesh& Mesh, mesh::bools_t& UnusedPoints);
  static void remap_points(mesh& Mesh, const mesh::indices_t& PointMap);
  static void delete_points(mesh& Mesh, const mesh::bools_t& Points);
  static void delete_points(mesh& Mesh, const mesh::bools_t& Points, mesh::indices_t& PointMap);
  static void deep_copy(const mesh& From, mesh& To);

  template<typename FunctorT>
  static void visit_arrays(const mesh::primitive& Primitive, FunctorT Functor)
  {
    for(mesh::named_tables_t::const_iterator structure = Primitive.structure.begin(); structure != Primitive.structure.end(); ++structure)
    {
      for(mesh::table_t::const_iterator array = structure->second.begin(); array != structure->second.end(); ++array)
        Functor(structure->first, structure->second, array->first, array->second);
    }

    for(mesh::named_tables_t::const_iterator attributes = Primitive.attributes.begin(); attributes != Primitive.attributes.end(); ++attributes)
    {
      for(mesh::table_t::const_iterator array = attributes->second.begin(); array != attributes->second.end(); ++array)
        Functor(attributes->first, attributes->second, array->first, array->second);
    }
  }

  template<typename FunctorT>
  static void visit_arrays(mesh::primitive& Primitive, FunctorT Functor)
  {
    for(mesh::named_tables_t::iterator structure = Primitive.structure.begin(); structure != Primitive.structure.end(); ++structure)
    {
      for(mesh::named_arrays_t::iterator array = structure->second.begin(); array != structure->second.end(); ++array)
        Functor(structure->first, structure->second, array->first, array->second);
    }

    for(mesh::named_tables_t::iterator attributes = Primitive.attributes.begin(); attributes != Primitive.attributes.end(); ++attributes)
    {
      for(mesh::table_t::iterator array = attributes->second.begin(); array != attributes->second.end(); ++array)
        Functor(attributes->first, attributes->second, array->first, array->second);
    }
  }

  template<typename FunctorT>
  static void visit_arrays(const mesh& Mesh, FunctorT Functor)
  {
    for(mesh::primitives_t::const_iterator p = Mesh.primitives.begin(); p != Mesh.primitives.end(); ++p)
      visit_arrays(**p, Functor);
  }

  template<typename FunctorT>
  static void visit_arrays(mesh& Mesh, FunctorT Functor)
  {
    for(mesh::primitives_t::iterator p = Mesh.primitives.begin(); p != Mesh.primitives.end(); ++p)
      visit_arrays(p->writable(), Functor);
  }

  static void append(const mesh& Source, mesh& Target, uint_t* const PointBegin = 0, uint_t* const PointEnd = 0, uint_t* const PrimitiveBegin = 0, uint_t* const PrimitiveEnd = 0);
};

std::ostream& operator<<(std::ostream& Stream, const mesh& RHS);
std::ostream& operator<<(std::ostream& Stream, const mesh::primitive& RHS);

namespace difference
{

inline void test(const k3d::mesh& A, const k3d::mesh& B, accumulator& Result)
{
  A.difference(B, Result);
}

inline void test(const k3d::mesh::primitive& A, const k3d::mesh::primitive& B, accumulator& Result)
{
  A.difference(B, Result);
}

} // namespace difference

} // namespace k3d

#endif // !K3DSDK_MESH_H

---