Streamlines.h

Go to the documentation of this file.

#ifndef GlobeEngine_Streamlines_h
#define GlobeEngine_Streamlines_h

#include "Composition.h"
#include "Texture.h"
#include <vmmlib/vmmlib.hpp>
#include "PlanetaryViewerSceneBlueprint.h"
#include "MultiLineObject.h"
#include "Polyline.h"

namespace ge {
    
    class Streamlines : public ge::Composition
    {
        
    public:
        Streamlines();
        ~Streamlines() {};
        
        void loadTextures(std::vector<std::vector<std::string>> _fileList, vmml::Vector3s _dim);
        
        std::vector<std::vector<std::shared_ptr<Texture3Drgb>>> getStreamlinesTextures() {
            return this->streamlineTextures;
        }
        
        void setTextureHandle(int _i, int _j) {
            this->Composition::setTextureHandle(0, this->streamlineTextures[_i][_j]);
        }
        
        void setInteractionInfo(gePlanetaryViewer::StreamlinesInteractionInfo _info) {
            this->streamlineInteractionInfo = _info;
        }
        
        std::shared_ptr<geData::MultiLineObject> getMultilineGeometry() {
            return this->multilineGeometry;
        }
        
        void updatePolylines();
        
    protected:
        void drawFrame(std::shared_ptr<ge::Camera> _cam);
        
    private:
        
        float* dataU;
        float* dataV;
        float* dataW;
        
        std::vector<std::vector<std::shared_ptr<Texture3Drgb>>> streamlineTextures;
        
        std::shared_ptr<geData::MultiLineObject> multilineGeometry;
        std::shared_ptr<ge::Shader> programForMultiLineObject;
        
        bool cmpf(float A, float B, float epsilon = 0.005f)
        {
            return (fabs(A - B) < epsilon);
        }
        
        int round(float f)
        {
            return floor(f + 0.5);
        }
        
        int getIndex(vmml::Vector3f pos)
        {
            int dim_x = this->dimensions.x();
            int dim_y = this->dimensions.y();
            int dim_z = this->dimensions.z();
            
            int x = round(pos.x());
            int y = round(pos.y());
            int z = round(pos.z());
            
            int index;
            if (x < 0 || x > dim_x - 1 || y < 0 || y > dim_y - 1 || z < 0 || z > dim_z - 1)
            {
                index = -1;
            }
            else
            {
                index = x + dim_x * (y + dim_y * z);
            }
            
            return index;
        }
        
        vmml::Vector3f map (vmml::Vector3f val)
        {
            float x = -18.0 + (val.x() * 36.0) / float(this->dimensions.x() - 1);
            float y = -18.0 + (val.y() * 36.0) / float(this->dimensions.y() - 1);
            float z =   4.0 - (val.z() *  8.0) / float(this->dimensions.z() - 1);
            return vmml::Vector3f(x, z, y);
        }
        
        float euclideanDistance(vmml::Vector3f _point1, vmml::Vector3f _point2)
        {
            float x = std::pow(_point1.x() - _point2.x(), 2);
            float y = std::pow(_point1.y() - _point2.y(), 2);
            float z = std::pow(_point1.z() - _point2.z(), 2);
            return std::sqrt(x + y + z);
        }
        
        gePlanetaryViewer::StreamlinesInteractionInfo streamlineInteractionInfo;
        
        vmml::Vector3s dimensions;
    };
}
#endif