IndexedFaceSet.h

Go to the documentation of this file.

/*
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#pragma once
 
#include <memory.h>
#include <stdio.h>
 
#include "Rep.h"
 
#include "../system/FreestyleConfig.h"
 
namespace Freestyle {
 
class IndexedFaceSet : public Rep {
 public:
  enum TRIANGLES_STYLE {
    TRIANGLE_STRIP,
    TRIANGLE_FAN,
    TRIANGLES,
  };
 
  /* XXX Why in hell not use an enum here too? */
  typedef unsigned char FaceEdgeMark;
  static const FaceEdgeMark FACE_MARK = 1 << 0;
  static const FaceEdgeMark EDGE_MARK_V1V2 = 1 << 1;
  static const FaceEdgeMark EDGE_MARK_V2V3 = 1 << 2;
  static const FaceEdgeMark EDGE_MARK_V3V1 = 1 << 3;
 
  IndexedFaceSet();
 
  IndexedFaceSet(float *iVertices,
                 unsigned iVSize,
                 float *iNormals,
                 unsigned iNSize,
                 FrsMaterial **iMaterials,
                 unsigned iMSize,
                 float *iTexCoords,
                 unsigned iTSize,
                 unsigned iNumFaces,
                 unsigned *iNumVertexPerFace,
                 TRIANGLES_STYLE *iFaceStyle,
                 FaceEdgeMark *iFaceEdgeMarks,
                 unsigned *iVIndices,
                 unsigned iVISize,
                 unsigned *iNIndices,
                 unsigned iNISize,
                 unsigned *iMIndices,
                 unsigned iMISize,
                 unsigned *iTIndices,
                 unsigned iTISize,
                 unsigned iCopy = 1);
 
  IndexedFaceSet(const IndexedFaceSet &iBrother);
 
  void swap(IndexedFaceSet &ioOther)
  {
    std::swap(_Vertices, ioOther._Vertices);
    std::swap(_Normals, ioOther._Normals);
    std::swap(_FrsMaterials, ioOther._FrsMaterials);
    std::swap(_TexCoords, ioOther._TexCoords);
    std::swap(_FaceEdgeMarks, ioOther._FaceEdgeMarks);
 
    std::swap(_VSize, ioOther._VSize);
    std::swap(_NSize, ioOther._NSize);
    std::swap(_MSize, ioOther._MSize);
    std::swap(_TSize, ioOther._TSize);
 
    std::swap(_NumFaces, ioOther._NumFaces);
    std::swap(_NumVertexPerFace, ioOther._NumVertexPerFace);
    std::swap(_FaceStyle, ioOther._FaceStyle);
 
    std::swap(_VIndices, ioOther._VIndices);
    std::swap(_NIndices, ioOther._NIndices);
    std::swap(_MIndices, ioOther._MIndices);  // Material Indices
    std::swap(_TIndices, ioOther._TIndices);
 
    std::swap(_VISize, ioOther._VISize);
    std::swap(_NISize, ioOther._NISize);
    std::swap(_MISize, ioOther._MISize);
    std::swap(_TISize, ioOther._TISize);
 
    Rep::swap(ioOther);
  }
 
  IndexedFaceSet &operator=(const IndexedFaceSet &iBrother)
  {
    IndexedFaceSet tmp(iBrother);
    swap(tmp);
    return *this;
  }
 
  virtual ~IndexedFaceSet();
 
  virtual void accept(SceneVisitor &v);
 
  virtual void ComputeBBox();
 
  virtual const float *vertices() const
  {
    return _Vertices;
  }
 
  virtual const float *normals() const
  {
    return _Normals;
  }
 
  virtual const FrsMaterial *const *frs_materials() const
  {
    return _FrsMaterials;
  }
 
  virtual const float *texCoords() const
  {
    return _TexCoords;
  }
 
  virtual const unsigned vsize() const
  {
    return _VSize;
  }
 
  virtual const unsigned nsize() const
  {
    return _NSize;
  }
 
  virtual const unsigned msize() const
  {
    return _MSize;
  }
 
  virtual const unsigned tsize() const
  {
    return _TSize;
  }
 
  virtual const unsigned numFaces() const
  {
    return _NumFaces;
  }
 
  virtual const unsigned *numVertexPerFaces() const
  {
    return _NumVertexPerFace;
  }
 
  virtual const TRIANGLES_STYLE *trianglesStyle() const
  {
    return _FaceStyle;
  }
 
  virtual const unsigned char *faceEdgeMarks() const
  {
    return _FaceEdgeMarks;
  }
 
  virtual const unsigned *vindices() const
  {
    return _VIndices;
  }
 
  virtual const unsigned *nindices() const
  {
    return _NIndices;
  }
 
  virtual const unsigned *mindices() const
  {
    return _MIndices;
  }
 
  virtual const unsigned *tindices() const
  {
    return _TIndices;
  }
 
  virtual const unsigned visize() const
  {
    return _VISize;
  }
 
  virtual const unsigned nisize() const
  {
    return _NISize;
  }
 
  virtual const unsigned misize() const
  {
    return _MISize;
  }
 
  virtual const unsigned tisize() const
  {
    return _TISize;
  }
 
 protected:
  float *_Vertices;
  float *_Normals;
  FrsMaterial **_FrsMaterials;
  float *_TexCoords;
 
  unsigned _VSize;
  unsigned _NSize;
  unsigned _MSize;
  unsigned _TSize;
 
  unsigned _NumFaces;
  unsigned *_NumVertexPerFace;
  TRIANGLES_STYLE *_FaceStyle;
  FaceEdgeMark *_FaceEdgeMarks;
 
  unsigned *_VIndices;
  unsigned *_NIndices;
  unsigned *_MIndices;  // Material Indices
  unsigned *_TIndices;  // Texture coordinates Indices
 
  unsigned _VISize;
  unsigned _NISize;
  unsigned _MISize;
  unsigned _TISize;
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:IndexedFaceSet")
#endif
};
 
} /* namespace Freestyle */