WavySurfaceObject.hh

#ifndef VTESTBED_GRAPHICS_WAVYSURFACEOBJECT_HH
#define VTESTBED_GRAPHICS_WAVYSURFACEOBJECT_HH

#include <blitz/array.h>

#include <vtestbed/core/types.hh>
#include <vtestbed/graphics/AxisSurface.hh>
#include <vtestbed/graphics/GerstnerSurface.hh>
#include <vtestbed/graphics/WavySurface.hh>
#include <vtestbed/graphics/WavySurfaceSlice.hh>
#include <vtestbed/graphics/types.hh>

namespace vtb {

    namespace graphics {

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

        public:
            using array2 = vtb::core::Array2<T>;
            using array3 = vtb::core::Array3<T>;
            using array4 = vtb::core::Array4<T>;
            using grid2 = vtb::core::Grid<T,2>;
            using grid3 = vtb::core::Grid<T,3>;
            using grid4 = vtb::core::Grid<T,4>;
            using int2 = vtb::core::int2;
            using vec2 = vtb::core::Vector2<T>;
            using vec3 = vtb::core::Vector3<T>;
            using gerstner_type = vtb::core::Array2<vec3>;
            using testbed_type = vtb::core::Testbed<T,3>;

        private:
            DrawableGroup3D _drawables;
            AxisSurface _axis;
            WavySurface<T> _regularSurface;
            GerstnerSurface<T> _irregularSurface;
            WavySurfaceSlice<T> _sliceXZ{0}, _sliceYZ{1};
            bool _show = true;
            bool _showSurface = true;
            bool _irregular = true;

        public:

            WavySurfaceObject();

            void draw(const Matrix4& m, Camera3D& camera) override;
            void step(const testbed_type& testbed);
            void step_irregular(const testbed_type& testbed);
            void step_regular(const testbed_type& testbed);
            void init(const testbed_type& testbed);

            inline void show(bool b) { this->_show = b; }
            inline void showAxes(bool b) { _axis.show(b); }

            inline void
            showWavySurface(bool b) {
                if (_irregular) {
                    this->_irregularSurface.show(b);
                } else {
                    this->_regularSurface.show(b);
                }
            }

            inline void
            showVelocityPotential(bool b) {
                if (_irregular) {
                    this->_irregularSurface.showSlice(b);
                } else {
                    this->_regularSurface.showSlice(b);
                }
                this->_sliceXZ.show(b);
                this->_sliceYZ.show(b);
            }

        };

    }

}

#endif // vim:filetype=cpp