GLPrimitives.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. 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.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder 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 THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS 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.              *
 *                                                                           *
\*===========================================================================*/





//=============================================================================
//
//  CLASS GLPrimitive
//
//=============================================================================

#ifndef ACG_GLPRIMITIVES_HH
#define ACG_GLPRIMITIVES_HH


//== INCLUDES =================================================================


#include <ACG/Config/ACGDefines.hh>
#include <ACG/GL/GLState.hh>
#include <ACG/Math/VectorT.hh>
#include <ACG/GL/VertexDeclaration.hh>


//== NAMESPACES ===============================================================

namespace ACG {

//== CLASS DEFINITION =========================================================

  
class ACGDLLEXPORT GLPrimitive {
public:
  GLPrimitive();
  virtual ~GLPrimitive();

  // bind vbo + gl draw call (fixed function mode)
  // use this function in compatibility profile
  void draw_primitive();

  // activate vertex declaration + gl draw call  (shader mode)
  // _program may be nullptr, in that case the attribute locations are as follows.
  //  0 : float3 position
  //  1 : float3 normal
  //  2 : float2 texcoord
  void draw_primitive(GLSL::Program* _program);

  // add to deferred draw call to renderer
  void addToRenderer_primitive(class IRenderer* _renderer, struct RenderObject* _ro);

  // Triangle or line count must be known before updateVBO.
  // A GLPrimitive can consist of either only lines or only triangles.
  // If getNumTriangles returns nonzero, its assumed to consist of tris only.
  // Otherwise, getNumLines has to return nonzero and GLPrimitive is treated as a line-list.
  virtual int getNumTriangles() = 0;
  virtual int getNumLines() {return 0;}

  // get opengl vbo id
  unsigned int getVBO();

  const VertexDeclaration* getVertexDecl() const;

  enum NormalOrientation {OUTSIDE, INSIDE};

protected:

  // calls addTriangleToVBO to fill vertex buffer
  virtual void updateVBO() = 0;

  void addTriangleToVBO(const ACG::Vec3f* _p, const ACG::Vec3f* _n, const ACG::Vec2f* _tex);
  void addLineToVBO(const ACG::Vec3f* _p, const ACG::Vec3f* _n, const ACG::Vec2f* _tex);

  void bindVBO();

  bool checkVBO();

  void unBindVBO();

  bool vboDataInvalid_;

  NormalOrientation normalOrientation_;

private:

  void updateVBOData();

  int numTris_;
  int numLines_;
  float* vboData_;
  int curTriPtr_;

  VertexDeclaration vertexDecl_;

  unsigned int vbo_;
};

//------------------------------------------------------------------------

class ACGDLLEXPORT GLSphere: public GLPrimitive {
public:

  GLSphere(int _slices, int _stacks);
  ~GLSphere();

  void draw(GLState& _state, float _radius, const ACG::Vec3f& _center = ACG::Vec3f(0.0f, 0.0f, 0.0f));

  void addToRenderer(class IRenderer* _renderer, const struct RenderObject* _base, float _radius, const ACG::Vec3f& _center = ACG::Vec3f(0.0f, 0.0f, 0.0f));

  int getNumTriangles() override;

private:

  void updateVBO() override;

  void addTriangle(int sl0, int st0, int sl1, int st1, int sl2, int st2);

  ACG::Vec3f positionOnSphere(int _sliceNumber, int _stackNumber);
  ACG::Vec2f texCoordOnSphere(int _sliceNumber, int _stackNumber);

private:

  int slices_;
  int stacks_;

};

//------------------------------------------------------------------------

class ACGDLLEXPORT GLCone: public GLPrimitive {
public:

  GLCone(int _slices, int _stacks, float _bottomRadius, float _topRadius, bool _bottomCap_, bool _topCap);
  ~GLCone();

  void draw(
      GLState& _state,
      float _height,
      const ACG::Vec3f& _center = ACG::Vec3f(0.0f, 0.0f, 0.0f),
      ACG::Vec3f _upDir = ACG::Vec3f(0.0f, 0.0f, 1.0f));


  void addToRenderer(class IRenderer* _renderer, const struct RenderObject* _base, 
    float _height,
    const ACG::Vec3f& _center = ACG::Vec3f(0.0f, 0.0f, 0.0f),
    ACG::Vec3f _upDir = ACG::Vec3f(0.0f, 0.0f, 1.0f),
    float _radiusScale = 1.0f);

  int getNumTriangles() override;

  void updateVBO() override;
  void setBottomRadius(float _bottomRadius);
  void setTopRadius(float _topRadius);
  void setNormalOrientation(NormalOrientation orienation);

private:

  void addTriangle(int sl0, int st0, int sl1, int st1, int sl2, int st2);

  ACG::Vec3f positionOnCone(int _sliceNumber, int _stackNumber);
  ACG::Vec2f texCoordOnCone(int _sliceNumber, int _stackNumber);
  ACG::Vec3f normalOnCone(int _sliceNumber, int _stackNumber);

private:

  int slices_;
  int stacks_;

  float bottomRadius_;
  float topRadius_;

  bool bottomCap_;
  bool topCap_;

};

//------------------------------------------------------------------------

class ACGDLLEXPORT GLCylinder: public GLCone {
public:
  GLCylinder(int _slices, int _stacks, float _radius, bool _bottomCap, bool _topCap);
};

//------------------------------------------------------------------------

class ACGDLLEXPORT GLPartialDisk: public GLPrimitive {
public:
  GLPartialDisk(int _slices, int _loops, float _innerRadius, float _outerRadius, float _startAngle, float _sweepAngle);

  void setInnerRadius(float _innerRadius);
  void setOuterRadius(float _outerRadius);
  int getNumTriangles() override;

  void draw(
      GLState& _state,
      const ACG::Vec3f& _center = ACG::Vec3f(0.0f, 0.0f, 0.0f),
      ACG::Vec3f _upDir = ACG::Vec3f(0.0f, 0.0f, 1.0f));

protected:
  void updateVBO() override;

private:
  int slices_;
  int loops_;
  float innerRadius_;
  float outerRadius_;
  float startAngle_;
  float sweepAngle_;
};

//------------------------------------------------------------------------

class ACGDLLEXPORT GLDisk: public GLPartialDisk {
public:
  GLDisk(int _slices, int _loops, float _innerRadius, float _outerRadius);
};

//------------------------------------------------------------------------

// axis-aligned unit cube centered at origin
class ACGDLLEXPORT GLBox: public GLPrimitive {
public:

  GLBox();
  ~GLBox();

  int getNumTriangles() override;

private:

  void updateVBO() override;
};

//------------------------------------------------------------------------

// axis-aligned unit cube centered at origin,  only lines
class ACGDLLEXPORT GLLineBox: public GLPrimitive {
public:

  GLLineBox();
  ~GLLineBox();

  int getNumTriangles() override;
  int getNumLines() override;

private:

  void updateVBO() override;
};

//------------------------------------------------------------------------

// axis-aligned Dodecahedron centered at origin
class ACGDLLEXPORT GLDodecahedron: public GLPrimitive {
public:

  GLDodecahedron();
  ~GLDodecahedron();

  int getNumTriangles() override;

private:

  void updateVBO() override;
};

//------------------------------------------------------------------------

// axis-aligned Icosahedron centered at origin
class ACGDLLEXPORT GLIcosahedron: public GLPrimitive {
public:

  GLIcosahedron();
  ~GLIcosahedron();

  int getNumTriangles() override;

private:

  void updateVBO() override;
};

//------------------------------------------------------------------------

// axis-aligned Icosahedron centered at origin
class ACGDLLEXPORT GLOctahedron: public GLPrimitive {
public:

  GLOctahedron();
  ~GLOctahedron();

  int getNumTriangles() override;

private:

  void updateVBO() override;
};

//------------------------------------------------------------------------

// axis-aligned Icosahedron centered at origin
class ACGDLLEXPORT GLTetrahedron: public GLPrimitive {
public:

  GLTetrahedron();
  ~GLTetrahedron();

  int getNumTriangles() override;

private:

  void updateVBO() override;
};

//------------------------------------------------------------------------

// axis-aligned Torus centered at origin
class ACGDLLEXPORT GLTorus: public GLPrimitive {
public:

  GLTorus(GLdouble innerRadius,
          GLdouble outerRadius,
          GLint nsides, GLint rings);
  ~GLTorus();

  int getNumTriangles() override;

private:

  void updateVBO() override;

  int rings_;
  int nsides_;
  float innerRadius_;
  float outerRadius_;

};

//------------------------------------------------------------------------

} // namespace ACG

#endif // ACG_GLPRIMITIVES_HH defined