WavySurfaceSlice.hh

#ifndef VTESTBED_GRAPHICS_WAVYSURFACESLICE_HH
#define VTESTBED_GRAPHICS_WAVYSURFACESLICE_HH

#include <functional>

#include <Magnum/GL/Buffer.h>
#include <Magnum/GL/Mesh.h>
#include <Magnum/GL/Texture.h>

#include <vtestbed/core/types.hh>
#include <vtestbed/graphics/SliceShader.hh>
#include <vtestbed/graphics/types.hh>

namespace vtb {

    namespace graphics {

        template <class T>
        class WavySurfaceSlice: public Object3D, public Drawable3D {

        public:
            using array2 = vtb::core::Array<T,2>;
            using array3 = vtb::core::Array<T,3>;
            using vec3 = vtb::core::Vector<T,3>;
            using vec2 = vtb::core::Vector<T,2>;
            using int2 = vtb::core::int2;
            using grid2 = vtb::core::Grid<T,2>;
            using grid3 = vtb::core::Grid<T,3>;
            using testbed_type = vtb::core::Testbed<T,3>;

        public:
            struct GridVertex {
                vec3 position;
                vec2 text;
                GridVertex() = default;
                GridVertex(vec3 p, vec2 t): position(p), text(t) {}
            };
            using grid_vertex_array = std::vector<GridVertex>;
            using vertex_matrix = vtb::core::Array<vec3,2>;
            using vertex_field = vtb::core::Array<vec3,3>;
            using interpolate_2d = std::function<T(const vec2&)>;
            using interpolate_3d = std::function<T(const vec3&)>;

        private:
            SliceShader _shader;
            Mesh _mesh;
            Buffer _indexBuffer, _vertexBuffer;
            Texture2D _texture;
            vec2 _slice{T{}};
            int _axis = 0;
            bool _show = false;

        public:

            inline explicit
            WavySurfaceSlice(int axis): Drawable3D{*this, nullptr}, _axis(axis) {}

            void step(const testbed_type& testbed);
            void step_regular(const testbed_type& testbed);
            void step_irregular(const testbed_type& testbed);

            inline void show(bool b) { this->_show = b; }
            inline void setSlice(const vec2& rhs) { this->_slice = rhs; }

        private:

            void draw(const Matrix4& transformation, Camera3D& camera) override;

            grid2 slice_grid(const grid3& gridZXY, int numPoints);

            void updateMesh(const grid_vertex_array& data, int numPoints);
            void updateTexture(const vertex_matrix& texture, const int2& size);

            void generateMesh(
                interpolate_2d zeta,
                Float z_min,
                const grid2& grid_xy
            );

            void generateTexture(
                interpolate_3d phi,
                Float phi_max,
                const grid3& phi_grid,
                const grid2& grid_xy
            );

            static array3 to_scalar_field(const vertex_field& field);

        };

    }

}

#endif // vim:filetype=cpp