Displayable.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program 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
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#if !defined(DISPLAYABLE_H)
#define DISPLAYABLE_H

#include "FunctionParameter.h"
#include "FunctionFactory.h"
#include "DisplayableClass.h"

#include <vector>

namespace UI {
  class View;
}

namespace VecMath {
    template <unsigned D, typename N> class Rotation;
    template <unsigned D, typename N> class Vector;
    template <typename T, unsigned D> class MultiDimensionalVector;
}
class ParameterMap;



class Displayable {

    public:

        typedef void(*function_on_fourspace_vertex)(const VecMath::Vector<4, double> &);
        typedef void(*function_on_fourspace_and_transformed_vertex)(const VecMath::Vector<4, double> &,
                                                                    const VecMath::Vector<4, double> &);
        typedef void(*function_on_fourspace_transformed_and_projected_vertex)(const VecMath::Vector<4, double> &,
                                                                              const VecMath::Vector<4, double> &,
                                                                              const VecMath::Vector<3, double> &);
        typedef void(*function_on_projected_vertex)(const VecMath::Vector<3, double> &);

        Displayable();
        Displayable (ParameterMap parameters);
        virtual ~Displayable();

        virtual void Transform (const VecMath::Rotation<4, double> &R,
                                const VecMath::Vector<4, double> &T,
                                const VecMath::Vector<4, double> &scale = 1.) = 0;
        void resetTransform();
        virtual void Project (double ScrW, double CamW, bool DepthCue4D) = 0;

        virtual void Draw (UI::View *) = 0;

        virtual void ReInit(double _tmin, double _tmax, double _dt,
                            double _umin, double _umax, double _du,
                            double _vmin, double _vmax, double _dv) = 0;

        virtual void calibrateColors() = 0;

        virtual std::string getFunctionName() const = 0;

        virtual unsigned getDefinitionSpaceDimensions() = 0;

        virtual void SetParameters(const ParameterMap &);

        ParameterMap getParameters();

        FunctionParameter::parameter_ptr_type getParameter(const std::string &name);

        virtual unsigned getNumParameters();

        FunctionParameter::value_ptr_type getParameterValue(const std::string &name);


        template <typename T> void setParameter(const ParameterMap &parms,
                                                T &parm,
                                                const std::string &key);

        virtual void for_each_vertex(function_on_fourspace_vertex apply) = 0;

        virtual void for_each_vertex_transformed(function_on_fourspace_and_transformed_vertex apply);

        virtual void for_each_vertex_transformed_projected(function_on_fourspace_transformed_and_projected_vertex apply);
        virtual void for_each_projected(function_on_projected_vertex apply) = 0;

    protected:

        virtual VecMath::Vector<4> &operator () (double, double, double);


        virtual VecMath::MultiDimensionalVector< VecMath::Vector<4>, 1 > df (double, double, double);

        virtual void Initialize (void) = 0;

        virtual unsigned long MemRequired (void);


        template <typename T> void declareParameter(const std::string &,
                                                    const T &);

        template <typename T> void declareParameter(const std::string &,
                const T &, const T &);

    private:

      class Impl;
      Impl *pImpl_;

};

namespace {
  static const DisplayableClass &displayable_class_root = DisplayableClass::makeRootNode("Displayable", "Objects");
}

#endif