SectorColorGen.h

Go to the documentation of this file.

#pragma once
#include "ColorGen.h"
#include <osg\BoundsChecking>
#include <osg\BufferObject>



struct Sector : public osg::Referenced
{
    enum Direction
    {
        SD_REVERSE,
        SD_FORWARD
    };

    const unsigned int ID;
    double start;
    double end;
    osg::Vec4 color;
    Direction direction;

    Sector() : ID(counter++) { set(0.0, 0.0, osg::Vec4(1,0,0,1)); }
    Sector(double start, double end, const osg::Vec4& color, Direction direction = SD_FORWARD) : ID(counter++)
    { set(start, end, color, direction); }

    typedef std::pair<double, double> DoublePair;
    DoublePair getSectorRange(unsigned int arraySize) { return DoublePair(start * arraySize, end * arraySize); }

    void set(double start, double end, const osg::Vec4& color, Direction direction = SD_FORWARD) {
        this->start = osg::clampBetween(start, 0.0, 1.0);
        this->end = osg::clampBetween(end, 0.0, 1.0);
        this->color = color;
        this->direction = direction;
    }

protected:        
    static unsigned int counter;
    virtual ~Sector() {};
};

typedef osg::ref_ptr<Sector> SectorPtr;
typedef std::vector<SectorPtr> SectorArray;

class SectorColorGen : public ColorGen
{
public:
    SectorColorGen(const osg::Vec4& defaultColor)
        : _defaultColor(defaultColor) { _dirty = true; };

    META_DAObject(SectorColorGen, "Sector Color");

    virtual Vec4ArrayPtr getColors( unsigned int leadSplineSize, unsigned int crossSectionSize )
    {
        _dirty = false;

        Vec4ArrayPtr result = new osg::Vec4Array;
        unsigned int arraySize = leadSplineSize * crossSectionSize;

        result->reserve(arraySize);
        result->assign(arraySize, _defaultColor);

        for (auto it = _sectors.begin(); it != _sectors.end(); ++it)
        {
            unsigned int sectorStart = int((*it)->start * leadSplineSize) * crossSectionSize;
            unsigned int sectorEnd = int((*it)->end * leadSplineSize) * crossSectionSize;

            if(sectorStart == sectorEnd) continue;

            if(sectorEnd < sectorStart) sectorEnd += arraySize;

            double step = 1.0 / (sectorEnd - sectorStart);
            double counter = (*it)->direction == Sector::SD_FORWARD ? 0.0 : 1.0;

            for (unsigned int i = sectorStart; i < sectorEnd; ++i)
            {
                (*result)[i % arraySize] = osg::Vec4(counter, 1.0 - counter, 0, 1.0);
                counter += (*it)->direction == Sector::SD_FORWARD ? step : -step;
            }
        }

        return result;
    }

    const osg::Vec4& getDefaultColor() const { return _defaultColor; }
    void setDefaultColor(osg::Vec4 val) { _dirty = true; _defaultColor = val; }

    void addSector(SectorPtr sector) { _dirty = true; _sectors.push_back(sector); }
    void setSector(unsigned int i, SectorPtr val) { _dirty = true; _sectors[i] = val; }
    const SectorPtr getSector(unsigned int i) { return _sectors[i]; }
    int getNumSectors() { return _sectors.size(); }
    void removeSectors(unsigned int i, int numSectorsToRemove = 1) { 
        _dirty = true; 
        osg::clampLEQUAL(i, _sectors.size(), "i");
        _sectors.erase(_sectors.begin() + i, _sectors.begin() + i + numSectorsToRemove); 
    }

protected:
    SectorArray   _sectors;
    osg::Vec4     _defaultColor;

};

typedef osg::ref_ptr<SectorColorGen> SectorColorGenPtr;