ShipHullObject.hh

#ifndef VTESTBED_GRAPHICS_SHIPHULLOBJECT_HH
#define VTESTBED_GRAPHICS_SHIPHULLOBJECT_HH

#include <Magnum/GL/Buffer.h>
#include <Magnum/GL/Mesh.h>
#include <Magnum/Shaders/Phong.h>

#include <vtestbed/core/types.hh>
#include <vtestbed/core/testbed.hh>
#include <vtestbed/geometry/polyhedron.hh>
#include <vtestbed/graphics/IndexBuffer.hh>
#include <vtestbed/graphics/ShipShader.hh>
#include <vtestbed/graphics/VertexBuffer.hh>
#include <vtestbed/graphics/types.hh>

namespace vtb {

    namespace graphics {

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

        public:
            using vec3 = vtb::core::Vector3<T>;
            using mask_array = vtb::core::mask_array;
            using polyhedron_type = vtb::geometry::Polyhedron<T>;
            using testbed_type = vtb::core::Testbed<T,3>;

        private:
            struct Spherlet {
                union {
                    Vector3 position;
                    vec3 position0;
                };
                union {
                    Vector3 color;
                    vec3 color0;
                };
                inline explicit Spherlet(Vector3 p, Vector3 c): position(p), color(c) {}
                inline explicit Spherlet(vec3 p, vec3 c): position0(p), color0(c) {}
                inline Spherlet(const Spherlet& rhs): position(rhs.position), color(rhs.color) {}
                inline Spherlet() = default;
                inline ~Spherlet() {}
            };

        private:
            Magnum::GL::Mesh _mesh{Magnum::GL::MeshPrimitive::Triangles};
            Mesh _mesh_center;
            ShipShader _shader;
            Magnum::Shaders::Phong _phongShader;
            VertexBuffer _vertices;
            VertexBuffer _normals;
            VertexBuffer _wet;
            IndexBuffer _indices;
            VertexBuffer _verticies_center;
            IndexBuffer _indicies_center;;
            Vector3 _ambientColor{0.2f, 0.2f, 0.2f};
            Vector3 _diffuseColor{0.184, 0.513, 0.8};
            Vector3 _specularColor{0.517333f, 0.142002f, 0.0818566f};
            Float _shininess{80.0f};
            bool _show = true;
            bool _transparency = true;
            std::vector<Spherlet> _centres;

        public:

            ShipHullObject();

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

            void setWettedPanels(const mask_array& mask);
            void setHull(const polyhedron_type& hull);
            void clear();
            void step(const testbed_type& testbed);
            void init(const testbed_type& testbed);

            inline void
            setColor(const vec3& color) {
                this->_diffuseColor[0] = color(0);
                this->_diffuseColor[1] = color(1);
                this->_diffuseColor[2] = color(2);
            }

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

            inline void
            transparency(bool b) {
                this->_transparency = b;
            }

            inline void
            addCenter() {
                _centres.emplace_back(Vector3{0.0f, 0.0f, 0.0f}, Color3{0.0f, 0.0f, 0.0f});
            }

            inline void
            setCenter(Vector3& pos, int num) {
                _centres[num].position = pos;
            }

            inline void
            setColor(Color3& color, int num) {
                _centres[num].color = color;
            }

            inline Vector3&
            diffuseColor() {
                return this->_diffuseColor;
            }

        };

    }

}

#endif // vim:filetype=cpp