ObjectImplementations.h

/* 
 * File:   ObjectImplementations.h
 * Author: lene
 *
 * Created on December 18, 2011, 5:43 PM
 */

#ifndef OBJECTIMPLEMENTATIONS_H
#define OBJECTIMPLEMENTATIONS_H

#include "Object.h"
#include "FacePolygon.h"


class Hypercube: public Object {
public:
    Hypercube (double a = 1.,
               const VecMath::Vector<4> &_center = VecMath::Vector<4>(0., 0., 0., 0.));
    virtual ~Hypercube() { }

    virtual std::string getFunctionName() const { return "Tesseract"; }

    virtual void SetParameters(const ParameterMap &parms) {
#       if 1
            for (ParameterMap::const_iterator i = parms.begin();
                 i != parms.end(); ++i) {
                if (i->second->getName() == "Size") _a = i->second->toDouble();
            }
#       else
            setParameter(parms, this->a, "Size");
#       endif
    }

    virtual std::string description () {
        std::ostringstream out;
        out << "Tesseract of edge length " << _a << std::ends;
        return out.str ();
    }
#   if !USE_INT_INDICES

      virtual void Draw (UI::View *view);

#   endif
  protected:
    virtual void Initialize();
    void DeclareSquare (unsigned, unsigned, unsigned, unsigned, unsigned, unsigned = 0);

    double _a;                  
    VecMath::Vector<4> _center; 

    static constexpr unsigned num_vertices = 16;
    static constexpr unsigned num_faces = 24;

#   if !USE_INT_INDICES
      surface_vec_type Surface;
#   endif
};

namespace {
    Displayable *createHypercube() { return new Hypercube; }
    const bool registeredH = TheFunctionFactory::Instance().registerFunction(createHypercube, "Object");
}



class Pyramid: public Object {
public:
    Pyramid ();
    Pyramid (double _a,
             const VecMath::Vector<4> &_Center = VecMath::Vector<4> (0., 0., 0., 0.));
    virtual ~Pyramid() { }

    virtual std::string getFunctionName() const { return "Pentachoron"; }

    virtual void SetParameters(const ParameterMap &parms) {
#       if 1
        for (ParameterMap::const_iterator i = parms.begin();
             i != parms.end(); ++i) {
                 if (i->second->getName() == "Size") a = i->second->toDouble();
             }
#       else
             setParameter(parms, this->a, "Size");
#       endif
    }

protected:

    static constexpr unsigned num_vertices = 5;
    static constexpr unsigned num_faces = 10;

    virtual void Initialize();
    void DeclareTriangle (unsigned, unsigned, unsigned, unsigned);

    VecMath::Vector<4> center;  
    double a;                   
};

namespace {
    Displayable *createPyramid() { return new Pyramid(); }
    const bool registeredP =
            TheFunctionFactory::Instance().registerFunction(createPyramid, "Object");
}



class Gasket: public Pyramid {
    public:
        Gasket (unsigned level = 1, double rad = 1,
                VecMath::Vector<4> Center = VecMath::Vector<4> (0., 0.,0., 0.));
        virtual ~Gasket() { }

        virtual std::string getFunctionName() const { return "4D Sierpinski Gasket"; }

        virtual void Transform (const VecMath::Rotation<4> &R,
                                const VecMath::Vector<4> &T,
                                const VecMath::Vector<4> &scale);
        virtual void Project (double ScrW, double CamW, bool DepthCue4D);
        virtual void Draw (UI::View *view);

        virtual void SetParameters(const ParameterMap &parms) {
#       if 1
            for (ParameterMap::const_iterator i = parms.begin();
                 i != parms.end(); ++i) {
                if (i->second->getName() == "Level")
                    Level = i->second->toUnsigned();
                if (i->second->getName() == "Size")
                    rad = i->second->toDouble();
            }
#       else
            setParameter(parms, this->Phase, "Phase");
#       endif
        }

        virtual void ReInit (double, double, double,
                             double, double, double,
                             double, double, double) {
            List.clear();
            Object::ReInit(0,0,0,0,0,0,0,0,0);
        }

    protected:
        virtual void Initialize();
        virtual unsigned long MemRequired (void);
        unsigned Level;                 
        std::vector<Pyramid *> List;    
        double rad;                     
        VecMath::Vector<4> center;
};

namespace {
    Displayable *createGasket() { return new Gasket(); }
    const bool registeredG =
            TheFunctionFactory::Instance().registerFunction(createGasket, "Object");
}


#endif  /* OBJECTIMPLEMENTATIONS_H */