---

glutm/shape.h

Go to the documentation of this file.

#ifndef GLUTM_SHAPE_H
#define GLUTM_SHAPE_H

/*

  GLT OpenGL C++ Toolkit (LGPL)
  Copyright (C) 2000-2002 Nigel Stewart  

  Email: nigels.com@gmail.com   
  WWW:   http://www.nigels.com/glt/

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include <glutm/config.h>

#include <node/shape.h>


class GlutSphere : public GltShape
{
public:
    GlutSphere(const bool solid = true,const GLdouble radius = 1.0,const GLint slices = 15,const GLint stacks = 15);
    ~GlutSphere();

    //

    virtual void     draw() const;
    virtual GLdouble volume() const;
    virtual bool     inside(const Vector &pos) const;
    virtual void     boundingBox(BoundingBox &box) const;
    virtual bool     povrayExport(std::ostream &os) const;

    //
    // Position
    //

    void position(const Vector &pos,const double radius);

    //
    // Get/set
    //

    GLdouble &radius();
    GLint    &slices();
    GLint    &stacks();

    const GLdouble &radius() const;
    const GLint    &slices() const;
    const GLint    &stacks() const;

private:

    GLdouble _radius;
    GLint    _slices;
    GLint    _stacks;
};


class GlutCube : public GltShape
{
public:
    GlutCube(const bool solid = true,const GLdouble size = 2.0);
    GlutCube(const bool solid       ,const Vector &min,const Vector &max);
    ~GlutCube();

    virtual void     draw() const;
    virtual GLdouble volume() const;
    virtual void     boundingBox(BoundingBox &box) const;
    virtual bool     povrayExport(std::ostream &os) const;

    //
    // Position
    //

    void position(const Vector &min,const Vector &max);
    void position(const Vector &pos,const real width,const real height,const real depth);

    //
    // Get/set
    //

          GLdouble &size();
    const GLdouble &size() const;

private:

    GLdouble    _size;
};


class GlutCylinder : public GltShape
{
public:
    GlutCylinder(const bool solid = true,const GLdouble radius = 1.0,const GLdouble height = 1.0,const GLint slices = 15,const GLint stacks = 10,const GLint loops = 5);
    ~GlutCylinder();

    virtual void     draw() const;
    virtual GLdouble volume() const;
    virtual void     boundingBox(BoundingBox &box) const;
    virtual bool     povrayExport(std::ostream &os) const;

    //
    // Position
    //

    void position(const Vector &begin,const Vector &end,const double radius);

    //
    // Get/Set
    //

    GLdouble &radius();
    GLdouble &height();
    GLint    &slices();
    GLint    &stacks();
    GLint    &loops();

    const GLdouble &radius() const;
    const GLdouble &height() const;
    const GLint    &slices() const;
    const GLint    &stacks() const;
    const GLint    &loops()  const;

private:

    GLdouble _radius;
    GLdouble _height;
    GLint    _slices;
    GLint    _stacks;
    GLint    _loops;
};


class GlutCone : public GltShape
{
public:
    GlutCone(const bool solid = true,const GLdouble base = 1.0,const GLdouble height = 1.0,const GLint slices = 15,const GLint stacks = 10);
    ~GlutCone();

    virtual void     draw() const;
    virtual GLdouble volume() const;
    virtual void     boundingBox(BoundingBox &box) const;

    GLdouble &base();
    GLdouble &height();
    GLint    &slices();
    GLint    &stacks();

    const GLdouble &base() const;
    const GLdouble &height() const;
    const GLint    &slices() const;
    const GLint    &stacks() const;

private:

    GLdouble _base;
    GLdouble _height;
    GLint    _slices;
    GLint    _stacks;
};


class GlutTorus : public GltShape
{
public:
    GlutTorus(const bool solid = true,const GLdouble innerRadius = 0.5,const GLdouble outerRadius = 1.0,const GLint nsides = 10,const GLint rings = 16);
    ~GlutTorus();

    virtual void draw() const;

    GLdouble &innerRadius();
    GLdouble &outerRadius();
    GLint    &nsides();
    GLint    &rings();

    const GLdouble &innerRadius() const;
    const GLdouble &outerRadius() const;
    const GLint    &nsides() const;
    const GLint    &rings() const;

private:

    GLdouble _innerRadius;
    GLdouble _outerRadius;
    GLint    _nsides;
    GLint    _rings;
};


class GlutDodecahedron : public GltShape
{
public:
    GlutDodecahedron(const bool solid = true);
    ~GlutDodecahedron();

    virtual void draw() const;
};


class GlutOctahedron : public GltShape
{
public:
    GlutOctahedron(const bool solid = true);
    ~GlutOctahedron();

    virtual void draw() const;
};


class GlutTetrahedron : public GltShape
{
public:
    GlutTetrahedron(const bool solid = true);
    ~GlutTetrahedron();

    virtual void draw() const;
};


class GlutIcosahedron : public GltShape
{
public:
    GlutIcosahedron(const bool solid = true);
    ~GlutIcosahedron();

    virtual void draw() const;
};


class GlutTeapot : public GltShape
{
public:
    GlutTeapot(const bool solid = true,const GLdouble size = 1.0);
    ~GlutTeapot();

    virtual void draw() const;

          GLdouble &size();
    const GLdouble &size() const;

private:

    GLdouble    _size;
};

#endif

---