VRS - The Virtual Rendering System

version 3.3

analyticshapegenerators.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2004 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * 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 FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: analyticshapegenerators.h 4160 2004-06-28 09:40:11Z kirsch $
// $Date: 2004-06-28 11:40:11 +0200 (Mon, 28 Jun 2004) $
// $Revision: 4160 $
// $State$
// $Author: kirsch $
//
// $Log$
// Revision 1.2  2004/06/28 09:40:11  kirsch
// inverted mesh orientation and documented it
//
// Revision 1.1  2004/05/28 11:06:03  kirsch
// added PolygonSetBuilder
//

#ifndef VRS_ANALYTICSHAPEGENERATORS_H
#define VRS_ANALYTICSHAPEGENERATORS_H

#include <vrs/vertexattributegenerator.h>
#include <vrs/vector.h>
#include <vrs/matrix.h>

namespace VRS {

    class Box;
    class Cone;
    class Cylinder;
    class Disc;
    class Hyperboloid;
    class Knot;
    class Paraboloid;
    class Sphere;
    class SuperQuad;
    class Torus;

    class BoxSideGenerator : public VertexAttributeGenerator {
    public:
        BoxSideGenerator(const Box*, unsigned int nx, unsigned int ny);

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);
        virtual Matrix getTransform(unsigned int side) const; // does not overload getTransform()!

    private:
        const Vector llf_;
        const Vector urb_;
        const Vector dim_;
    }; // class BoxSideGenerator

    class ConeGenerator : public VertexAttributeGenerator {
    public:
        ConeGenerator(const Cone*, unsigned int nx, unsigned int ny);
        virtual ~ConeGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);
        virtual Matrix getTransform() const;

    private:
        double topRadius_;
        double bottomRadius_;
        double height_;
        double theta_;

        double da_;
        double ds_;
        double dt_;
        double dr_;
        Vector normal_;
        Matrix thetaTf_;

        double* sin_a_;
        double* cos_a_;
    }; // class ConeGenerator

    class CylinderGenerator : public VertexAttributeGenerator {
    public:
        CylinderGenerator(const Cylinder*, unsigned int nx, unsigned int ny);
        virtual ~CylinderGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);
        virtual Matrix getTransform() const;

    private:
        double theta_;
        Vector topPoint_;
        Vector bottomPoint_;
        double height_;
        double da_;
        double dy_;
        double ds_;
        Matrix thetaTf_;

        double* sin_a_;
        double* cos_a_;
    }; // class DiscGenerator

    class DiscGenerator : public VertexAttributeGenerator {
    public:
        DiscGenerator(const Disc*, unsigned int nx, unsigned int ny);
        virtual ~DiscGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);
        virtual Matrix getTransform() const;

    private:
        double theta_;
        double radius_;
        double deltaTheta_;
        double deltaR_;
        double di_;
        double dj_;
        Matrix tf_;

        double* sin_p_;
        double* cos_p_;
    }; // class DiscGenerator

    class HyperboloidGenerator:public VertexAttributeGenerator {
    public:
        HyperboloidGenerator(const Hyperboloid*, unsigned int nx, unsigned int ny);
        virtual ~HyperboloidGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);

    private:
        Vector mid_;
        double midx_;
        double midy_;
        double midz_;

        double theta_;

        double deltaTheta_;
        double intervalmin_;
        double deltaY_;

        double* sin_theta_;
        double* cos_theta_;

        double di_;
        double dj_;
    }; // class HyperboloidGenerator

    class KnotGenerator : public VertexAttributeGenerator {
    public:
        KnotGenerator(const Knot*, unsigned int nx, unsigned int ny);
        virtual ~KnotGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);

    private:
        double rc_;
        double rt_;
        double thick_;
        double pn_;
        double qn_;

        Vector mid_;
        double midx_;
        double midy_;
        double midz_;

        double pmin_;
        double pmax_;
        double theta_;

        double deltaPhi_;
        double deltaRho_;

        double di_;
        double dj_;
    }; // class KnotGenerator

    class ParaboloidGenerator : public VertexAttributeGenerator {
    public:
        ParaboloidGenerator(const Paraboloid*, unsigned int nx, unsigned int ny);
        virtual ~ParaboloidGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);

    private:
        double top_;
        double bottom_;
        double radius_;
        double k_;
        double theta_;

        double dt;
        double di;
        double dj;

        double* sin_t_;
        double* cos_t_;
    }; // class ParaboloidGenerator

    class SphereGenerator : public VertexAttributeGenerator {
    public:
        SphereGenerator(const Sphere*, unsigned int nx, unsigned int ny);
        virtual ~SphereGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType);
        virtual Matrix getTransform() const;

    private:
        const Vector c_;
        const double r_;

        const double ymin_;
        const double ymax_;
        const double theta_;
        const double phimin_;
        const double phimax_;

        const double dphi_;
        const double da_;
        const double ds_;
        const double dt_;

        double* sin_a_;
        double* cos_a_;
    }; // class SphereGenerator

    class SuperQuadGenerator : public VertexAttributeGenerator {
    public:
        SuperQuadGenerator(const SuperQuad*, unsigned int nx, unsigned int ny);
        virtual ~SuperQuadGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType); 

    private:        
      const double a; 
      const double ns;
      const double ew;

      const double ds;
      const double dt;
      const double du;
      double dv;
        
      double v0;

      double* signpow_sinv;
      double* signpow_cosv;
      double* inv_signpow_sinv;
      double* inv_signpow_cosv;
    }; // class SuperQuadGenerator

    class TorusGenerator : public VertexAttributeGenerator {
    public:
        TorusGenerator(const Torus*, unsigned int nx, unsigned int ny);
        virtual ~TorusGenerator();

        virtual Iterator<Vector>* calcVertexData(const ID& vertexDataType); 

    private:        
        double rc_;
        double rt_;
        Vector mid_;
        double midx_;
        double midy_;
        double midz_;

        double pmin_;
        double pmax_;
        double theta_;

        double dp_;
        double da_;
        double di_;
        double dj_;

        double* sin_p_;
        double* cos_p_;
        double* sin_a_;
        double* cos_a_;
    }; // class TorusGenerator

} // namespace VRS

#endif // VRS_ANALYTICSHAPEGENERATORS_H

---

Generated on Mon May 20 06:00:19 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact