/home/kitware/dashboards/avogadro/libavogadro/src/mesh.h

/**********************************************************************
  Mesh - Primitive class to encapsulate triangular meshes/

  Copyright (C) 2008 Marcus D. Hanwell

  This file is part of the Avogadro molecular editor project.
  For more information, see <http://avogadro.openmolecules.net/>

  Avogadro 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.

  Avogadro 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., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
 **********************************************************************/

#ifndef MESH_H
#define MESH_H

#include <avogadro/primitive.h>
#include <Eigen/Core>

#include <vector>

// Forward declarations
class QReadWriteLock;

namespace Avogadro {

  class Molecule;
  class Color3f;
  class MeshPrivate;
  class A_EXPORT Mesh : public Primitive
  {
    Q_OBJECT

  public:
    Mesh(QObject *parent=0);

    ~Mesh();

    bool reserve(unsigned int size, bool colors = false);

    void setStable(bool stable);

    bool stable();

    void setIsoValue(float value) { m_isoValue = value; }

    float isoValue() const { return m_isoValue; }

    void setOtherMesh(unsigned int other) { m_other = other; }

    unsigned int otherMesh() const { return m_other; }

    void setCube(unsigned int cube) { m_cube = cube; }

    unsigned int cube() const { return m_cube; }

    const std::vector<Eigen::Vector3f> & vertices() const;

    unsigned int numVertices() const { return m_vertices.size(); }

    const Eigen::Vector3f * vertex(int n) const;

    bool setVertices(const std::vector<Eigen::Vector3f> &values);

    bool addVertices(const std::vector<Eigen::Vector3f> &values);

    const std::vector<Eigen::Vector3f> & normals() const;

    unsigned int numNormals() const { return m_normals.size(); }


    const Eigen::Vector3f * normal(int n) const;

    bool setNormals(const std::vector<Eigen::Vector3f> &values);

    bool addNormals(const std::vector<Eigen::Vector3f> &values);

    const std::vector<Color3f> & colors() const;

    const Color3f * color(int n) const;

    bool setColors(const std::vector<Color3f> &values);

    bool addColors(const std::vector<Color3f> &values);

    bool valid() const;

    bool clear();

    Mesh& operator=(const Mesh& other);

    void setName(QString name) { m_name = name; }

    QString name() { return m_name; }

    QReadWriteLock *lock() const;

    friend class Molecule;

  protected:
    std::vector<Eigen::Vector3f> m_vertices;
    std::vector<Eigen::Vector3f> m_normals;
    std::vector<Color3f> m_colors;
    QString m_name;
    bool m_stable;
    float m_isoValue;
    unsigned int m_other; // Unique id of the other mesh if this is part of a pair
    unsigned int m_cube; // Unique id of the cube this mesh was generated from
    QReadWriteLock *m_lock;
    Q_DECLARE_PRIVATE(Mesh)
  };
} // End namespace Avogadro

 #endif