VertexData.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2009-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.

*/

#ifndef VERTEX_DATA_H
#define VERTEX_DATA_H

#include "RotopeInterface.h"
#include "Projector.h"

#include <typeinfo>


template <unsigned D>
    class VertexData: public RotopeInterface {


        static constexpr double PROJECTION_SCREEN_W = 2.;

        static constexpr double PROJECTION_CAMERA_W = 8.;

    public:

        virtual Realm &realm() { return _realm; }
        virtual const Realm &realm() const { return _realm; }

        const std::vector<VecMath::Vector<D> > &raw_vertices() const { return _raw_vertices; }
        virtual std::vector<VecMath::Vector<4> > projected_vertices();

        virtual unsigned dimension() const { return _dimension; }
        virtual unsigned &dimension() { return _dimension; }

        virtual std::string toString();


    protected:

        VertexData(): _dimension(0), _raw_vertices(), _transform() {
            raw_vertices().push_back(VecMath::Vector<D>());
        }

        virtual void addTransform(unsigned, const VecMath::RotationBase *);

        std::vector<VecMath::Vector<D> > &raw_vertices() { return _raw_vertices; }
        void set_raw_vertices(const std::vector<VecMath::Vector<D> > &new_vertices) {
            _raw_vertices = new_vertices;
        }

    private:

        unsigned _dimension;                    

        std::vector<VecMath::Vector<D> > _raw_vertices;    

        Realm _realm;

        std::vector<const VecMath::RotationBase *> _transform;


        class VertexDataPrinter {

            const static int PRINT_VERTICES_COLUMN_WIDTH = 40;
            const static int PRINT_VERTICES_NUM_COLUMNS = 2;

        public:

            VertexDataPrinter(VertexData *vertexData):
                _vertexData(vertexData) { }

            void printToStream(std::ostream &out) const;

        private:

            std::string verticesToString(unsigned num_columns) const;

            void printVertices(unsigned num_columns = PRINT_VERTICES_NUM_COLUMNS,
                               std::ostream &out = std::cout) const;


            std::string verticesToStringRow(unsigned base_index, unsigned num_columns) const;

            void printVerticesRow(unsigned base_index,
                                  unsigned num_columns = PRINT_VERTICES_NUM_COLUMNS,
                                  std::ostream &out = std::cout) const;

            VertexData *_vertexData;
        };

    friend class RotopeFactory;
    };

/*  You shouldn't use "using" directives in a header file, but the code gets
    nearly unreadable otherwise. I mean, just look at that:
    typename std::vector<VecMath::Vector<D> >::iterator i = _X.begin();
    And because I'm defining template classes here, code must be written in the
    header file anyway.
*/
using VecMath::Vector;
using std::vector;

#include "VertexDataPrinter.h"

template <unsigned D> std::string VertexData<D>::toString() {
    std::ostringstream o;
    VertexDataPrinter printer(this);
    printer.printToStream(o);
    o << std::ends;
    return o.str();
}


template <unsigned D>
    std::vector<VecMath::Vector<4> > VertexData<D>::projected_vertices() {
//        Transform(VecMath::Rotation<D>(), VecMath::Vector<D>());
        Projector<D, 4> p;
        return p(raw_vertices(), PROJECTION_SCREEN_W, PROJECTION_CAMERA_W);  
    }

template <unsigned D>
    void VertexData<D>::addTransform(unsigned d,
                                     const VecMath::RotationBase *R) {
    std::cerr << "vertex_data<" << D << ">::addTransform("
            << d << ", " << typeid(R).name() << ")\n";
    _transform.resize(d+1);
    _transform[d] = R;
}

#endif