Pattern.h

Go to the documentation of this file.

#pragma once

#include "types.h"
#include "Utils.h"

namespace APDYNAMICART
{

class Pattern : public osg::Referenced
{
public:
    virtual Vec3ArrayPtr generate(Vec3ArrayPtr left, Vec3ArrayPtr right) = 0;
    virtual std::string getName() = 0;
};

class PatternBase : public Pattern
{
public:
    PatternBase() : _array(NULL) {};

    virtual Vec3ArrayPtr generate(Vec3ArrayPtr left, Vec3ArrayPtr right)
    {         
        if(!_array.valid()) _array = new osg::Vec3Array;
        
        if(left->size() != right->size()) {
            err("Different size left/right array. Aborting generation"); return _array;
        }

        return compute(left, right); 
    }

    virtual std::string getName() = 0;

    Vec3ArrayPtr getVertexArray() const { return _array; }
    void setVertexArray(Vec3ArrayPtr val) { _array = val; }

protected:
    Vec3ArrayPtr _array;    
    virtual ~PatternBase() {};
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right ) = 0;
};

typedef osg::ref_ptr<PatternBase> PatternPtr;
typedef std::vector<PatternPtr> Patterns;

class PatternFactory
{
public:
    static std::vector<std::string> getAvaiablePatterns();
    static PatternPtr getPattern(const std::string& name);
};

class NullPattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right) 
    {
        dbg("PatternBase::generate() called on null object.");
        return new osg::Vec3Array;
    }

    virtual std::string getName() {
        return "NullPattern";
    }
};

class AcrossPattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Across";
    }
};

class CrissCrossPattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Criss-cross";
    }
};

class DoublePattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Double";
    }
};

class HyperbolicPattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Hyperbolic";
    }
};

class TopPattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Top";
    }
};

class TopReversePattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Top-Reverse";
    }
};

class StandardPattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Standard";
    }
};

class SplitPattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Split";
    }
};

class SplitReversePattern : public PatternBase
{
    virtual Vec3ArrayPtr compute( Vec3ArrayPtr left, Vec3ArrayPtr right);
    virtual std::string getName() {
        return "Split-Reverse";
    }
};

}