SphereSegment.h

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * 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
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSGSIM_SPHERESEGMENT
#define OSGSIM_SPHERESEGMENT 1

#include <osgSim/Export>

#include <osg/Vec3>
#include <osg/Vec4>
#include <osg/Geode>
#include <osg/Matrixd>
#include <osg/BlendFunc>

namespace osgSim{

class OSGSIM_EXPORT SphereSegment: public osg::Geode
{
public:

    enum DrawMask{
        SURFACE =   0x00000001, 
        SPOKES =    0x00000002, 
        EDGELINE =  0x00000008, 
        SIDES =     0x00000010, 
        ALL =       0x7fffffff  
    };


    SphereSegment():osg::Geode(),
                    _centre(0.0f,0.0f,0.0f), _radius(1.0f),
                    _azMin(0.0f), _azMax(osg::PI/2.0f),
                    _elevMin(0.0f), _elevMax(osg::PI/2.0f),
                    _density(10),
                    _drawMask(DrawMask(ALL))
    {
        init();
    }

    SphereSegment(const osg::Vec3& centre, float radius, float azMin, float azMax,
                    float elevMin, float elevMax, int density):
        osg::Geode(),
        _centre(centre), _radius(radius),
        _azMin(azMin), _azMax(azMax),
        _elevMin(elevMin), _elevMax(elevMax),
        _density(density),
        _drawMask(DrawMask(ALL))
    {
        init();
    }

    SphereSegment(const osg::Vec3& centre, float radius, const osg::Vec3& vec, float azRange,
                    float elevRange, int density);

    SphereSegment(const SphereSegment& rhs, const osg::CopyOp& co):
        osg::Geode(rhs,co),
        _centre(rhs._centre), _radius(rhs._radius),
        _azMin(rhs._azMin), _azMax(rhs._azMax),
        _elevMin(rhs._elevMin), _elevMax(rhs._elevMax),
        _density(rhs._density),
        _drawMask(rhs._drawMask)
    {
        init();
    }

    void setCentre(const osg::Vec3& c);

    const osg::Vec3& getCentre() const;

    void setRadius(float r);

    float getRadius() const;

    void setArea(const osg::Vec3& vec, float azRange, float elevRange);

    void getArea(osg::Vec3& vec, float& azRange, float& elevRange) const;

    void setArea(float azMin, float azMax, float elevMin, float elevMax);

    void getArea(float &azMin, float &azMax, float &elevMin, float &elevMax) const;

    void setDensity(int d);

    int getDensity() const;

    void setDrawMask(int dm);

    int getDrawMask() const { return _drawMask; }

    void setSurfaceColor(const osg::Vec4& c);

    const osg::Vec4& getSurfaceColor() const { return _surfaceColor; }

    void setSpokeColor(const osg::Vec4& c);

    const osg::Vec4& getSpokeColor() const { return _spokeColor; }

    void setEdgeLineColor(const osg::Vec4& c);

    const osg::Vec4& getEdgeLineColor() const { return _edgeLineColor; }

    void setSideColor(const osg::Vec4& c);

    const osg::Vec4& getSideColor() const { return _planeColor; }

    void setAllColors(const osg::Vec4& c);

    META_Node(osgSim, SphereSegment);

    typedef std::vector< osg::ref_ptr<osg::Vec3Array> > LineList;

    LineList computeIntersection(const osg::Matrixd& matrix, osg::Node* subgraph);

    LineList computeIntersection(const osg::Matrixd& matrix, osg::Drawable* drawable);

    osg::Node* computeIntersectionSubgraph(const osg::Matrixd& matrix, osg::Node* subgraph);

    osg::Node* computeIntersectionSubgraph(const osg::Matrixd& matrix, osg::Drawable* drawable);


private:

    void init();    // Shared constructor code, generates the drawables

    void dirtyAllDrawableDisplayLists();    // Force re-calling of gl functions
    void dirtyAllDrawableBounds();          // Force recalculation of bound geometry

    // SphereSegment is actually made up of a number of Drawable classes,
    // all of which are nested private classes, as declared below. These
    // classes are defined in the .cpp for minimum visibility and physical
    // coupling. (Reduces time spent compiling! :-)
    //
    // Each of the nested classes holds a pointer to the SphereSegment
    // 'parent', which stores the geometry details, and performs any
    // work required. The nested classes are lightweight objects which
    // just pass the work on.
    //
    // Why are things done with these sub-Drawables? Alpha-blended
    // Drawables need to be drawn last, depth sorted, and the various
    // components of a SphereSegment also need to be depth sorted
    // against one another (they may all be drawn with alpha blending).
    // Making these Drawables allows us to get the OSG to depth sort
    // for us.

    class Surface;
    friend class Surface;
    bool Surface_computeBound(osg::BoundingBox&) const;
    void Surface_drawImplementation(osg::State&) const;

    class EdgeLine;
    friend class EdgeLine;
    bool EdgeLine_computeBound(osg::BoundingBox&) const;
    void EdgeLine_drawImplementation(osg::State&) const;

    enum BoundaryAngle{MIN,MAX};        // Why here and not in Side class? Because we can't forward
    enum SideOrientation{AZIM,ELEV};   // declare enums, Side is in the .cpp, and this is tidier...
    class Side;
    friend class Side;
    bool Side_computeBound(osg::BoundingBox&, SideOrientation, BoundaryAngle) const;
    void Side_drawImplementation(osg::State&, SideOrientation, BoundaryAngle) const;

    class Spoke;
    friend class Spoke;
    bool Spoke_computeBound(osg::BoundingBox&, BoundaryAngle, BoundaryAngle) const;
    void Spoke_drawImplementation(osg::State&, BoundaryAngle, BoundaryAngle) const;

    // Sphere segment geometry details
    osg::Vec3 _centre;
    float _radius;
    float _azMin, _azMax, _elevMin, _elevMax;
    int _density;

    // Draw details
    int         _drawMask;
    osg::Vec4   _surfaceColor;
    osg::Vec4   _spokeColor;
    osg::Vec4   _edgeLineColor;
    osg::Vec4   _planeColor;
};

}

#endif