osgQ_QSection.h

Go to the documentation of this file.

#ifndef OSGQ_QSECTION
#define OSGQ_QSECTION

#include <osg/Shape>

namespace osgQ {

    class QSection;

    class QShapeVisitor
    {
    public:
        QShapeVisitor() {}
        virtual ~QShapeVisitor() {}
        virtual void apply(const QSection&) {}
    };


    class QConstShapeVisitor : public osg::ConstShapeVisitor
    {
    public:
        QConstShapeVisitor() {}
        virtual ~QConstShapeVisitor() {}
        virtual void apply(const QSection&) {}
    };

    class QSection : public osg::Shape
    {
        public:

            QSection():
                _center(0.0f,0.0f,0.0f),
                _outerRadius(1.0f),
                _innerRadius(0.5f),
                _angleFrom(osg::PI / 4.0f),
                _angleTo(osg::PI * 3.0f / 4.0f),
                _outerAngleAddition(0.0f),
                _height(1.0f) {}

            QSection(const osg::Vec3& center,float innerRadius,float outerRadius,
                float angleFrom,float angleTo,float outerAngleAddition,float height):
                _center(center),
                _outerRadius(outerRadius),
                _innerRadius(innerRadius),
                _angleFrom(angleFrom),
                _angleTo(angleTo),
                _outerAngleAddition(0.0f),
                _height(height) {}

            QSection(const QSection& qsection,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY): 
                osg::Shape(qsection,copyop),
                _center(qsection._center),
                _outerRadius(qsection._outerRadius),
                _innerRadius(qsection._innerRadius),
                _angleFrom(qsection._angleFrom),
                _angleTo(qsection._angleTo),
                _outerAngleAddition(qsection._outerAngleAddition),
                _height(qsection._height),
                _rotation(qsection._rotation) {}


            virtual osg::Object* cloneType() const { return new QSection(); }
            virtual osg::Object* clone(const osg::CopyOp& copyop) const { return new QSection (*this,copyop); }
            virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const QSection *>(obj)!=NULL; }
            virtual const char* libraryName() const { return "osgq"; }
            virtual const char* className() const { return "QSection"; }

            virtual void accept(osg::ShapeVisitor& sv) { (dynamic_cast<QShapeVisitor *>(&sv))->apply(*this); }
            virtual void accept(osg::ConstShapeVisitor& csv) const { (dynamic_cast<QConstShapeVisitor *>(&csv))->apply(*this); }

//          virtual void accept(QShapeVisitor& sv) { sv.apply(*this); }
//          virtual void accept(QConstShapeVisitor& csv) const { csv.apply(*this); }

            inline bool valid() const { return ((_innerRadius>=0.0f) && (_outerRadius >= _innerRadius) && (_angleFrom <= _angleTo)); }

            inline void set(const osg::Vec3& center,float outerRadius,float innerRadius,
                float angleFrom,float angleTo,float outerAngleAddition,float height)
            {
                _center = center;
                _outerRadius = outerRadius;
                _innerRadius = innerRadius;
                _angleFrom = angleFrom;
                _angleTo = angleTo;
                _outerAngleAddition = outerAngleAddition;
                _height = height;
            }

            inline void setCenter(const osg::Vec3& center) { _center = center; }
            inline const osg::Vec3& getCenter() const { return _center; }

            inline void setOuterRadius(float outerRadius) { _outerRadius = outerRadius; }
            inline float getOuterRadius() const { return _outerRadius; }

            inline void setInnerRadius(float innerRadius) { _innerRadius = innerRadius; }
            inline float getInnerRadius() const { return _innerRadius; }

            inline void setAngleFrom(float angleFrom) { _angleFrom = angleFrom; }
            inline float getAngleFrom() const { return _angleFrom; }

            inline void setAngleTo(float angleTo) { _angleTo = angleTo; }
            inline float getAngleTo() const { return _angleTo; }

            inline void setOuterAngleAddition(float outerAngleAddition) { _outerAngleAddition = outerAngleAddition; }
                // half of this addition will be added to [angleFrom] and half of it to [angleTo]
                // (only on the outer side of the section)
            inline float getOuterAngleAddition() const { return _outerAngleAddition; }

            inline void setHeight(float height) { _height = height; }
            inline float getHeight() const { return _height; }

            inline void setRotation(const osg::Quat& quat) { _rotation = quat; }
            inline const osg::Quat& getRotation() const { return _rotation; }
            inline osg::Matrix computeRotationMatrix() const { return osg::Matrix(_rotation); }
            bool zeroRotation() const { return _rotation.zeroRotation(); } 

            inline int computeNumberOfSegments() const;

        protected:      
            virtual ~QSection() {}

            osg::Vec3    _center;
            float   _outerRadius;
            float   _innerRadius;
            float   _angleFrom;
            float   _angleTo;
            float   _outerAngleAddition;
            float   _height;
            osg::Quat    _rotation;
    };


    int QSection::computeNumberOfSegments() const
    {
        int n = (int) (_outerRadius * (_angleTo - _angleFrom) * (20.0f / osg::PI));
        return (n < 0) ? 0 : n;
    }

}

#endif