tmj merge

scenenode.h

@@ -0,0 +1,318 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+#include <vector>
+
+#include "material.h"
+#include "vertex.h"
+#include "openglgeometrybank.h"
+#include "parser.h"
+#include "Model3d.h"
+
+struct lighting_data {
+
+    glm::vec4 diffuse  { 0.8f, 0.8f, 0.8f, 1.0f };
+    glm::vec4 ambient  { 0.2f, 0.2f, 0.2f, 1.0f };
+    glm::vec4 specular { 0.0f, 0.0f, 0.0f, 1.0f };
+};
+
+inline
+bool
+operator==( lighting_data const &Left, lighting_data const &Right ) {
+    return ( ( Left.diffuse  == Right.diffuse )
+          && ( Left.ambient  == Right.ambient )
+          && ( Left.specular == Right.specular ) ); }
+
+inline
+bool
+operator!=( lighting_data const &Left, lighting_data const &Right ) {
+    return !( Left == Right ); }
+
+namespace scene {
+
+struct bounding_area {
+
+    glm::dvec3 center; // mid point of the rectangle
+    float radius { -1.0f }; // radius of the bounding sphere
+
+    bounding_area() = default;
+    bounding_area( glm::dvec3 Center, float Radius ) :
+        center( Center ),
+        radius( Radius )
+        {}
+};
+/*
+enum nodetype {
+
+    unknown,
+    model,
+    triangles,
+    lines,
+    dynamic,
+    track,
+    traction,
+    powersource,
+    sound,
+    memorycell,
+    eventlauncher
+};
+
+class node_manager {
+
+};
+*/
+
+struct node_data {
+
+    double range_min { 0.0 };
+    double range_max { std::numeric_limits<double>::max() };
+    std::string name;
+    std::string type;
+};
+
+// holds unique piece of geometry, covered with single material
+class shape_node {
+
+    friend class basic_region; // region might want to modify node content when it's being inserted
+
+public:
+// types
+    struct shapenode_data {
+        // placement and visibility
+        scene::bounding_area area; // bounding area, in world coordinates
+        bool visible { true }; // visibility flag
+        double rangesquared_min { 0.0 }; // visibility range, min
+        double rangesquared_max { 0.0 }; // visibility range, max
+        // material data
+        material_handle material { 0 };
+        lighting_data lighting;
+        bool translucent { false }; // whether opaque or translucent
+        // geometry data
+        std::vector<world_vertex> vertices; // world space source data of the geometry
+        glm::dvec3 origin; // world position of the relative coordinate system origin
+        geometry_handle geometry { 0, 0 }; // relative origin-centered chunk of geometry held by gfx renderer
+    };
+
+// methods
+    // restores content of the node from provded input stream
+    shape_node &
+        deserialize( cParser &Input, scene::node_data const &Nodedata );
+    // imports data from provided submodel
+    shape_node &
+        convert( TSubModel const *Submodel );
+    // adds content of provided node to already enclosed geometry. returns: true if merge could be performed
+    bool
+        merge( shape_node &Shape );
+    // generates renderable version of held non-instanced geometry in specified geometry bank
+    void
+        create_geometry( geometrybank_handle const &Bank );
+    // calculates shape's bounding radius
+    void
+        compute_radius();
+    // set visibility
+    void
+        visible( bool State ) {
+            m_data.visible = State; }
+    // set origin point
+    void
+        origin( glm::dvec3 Origin ) {
+            m_data.origin = Origin; }
+    // data access
+    shapenode_data const &
+        data() const {
+            return m_data; }
+
+private:
+// members
+    std::string m_name;
+    shapenode_data m_data;
+};
+
+// holds a group of untextured lines
+class lines_node {
+
+    friend class basic_region; // region might want to modify node content when it's being inserted
+
+public:
+// types
+    struct linesnode_data {
+        // placement and visibility
+        scene::bounding_area area; // bounding area, in world coordinates
+        bool visible { true }; // visibility flag
+        double rangesquared_min { 0.0 }; // visibility range, min
+        double rangesquared_max { 0.0 }; // visibility range, max
+        // material data
+        lighting_data lighting;
+        float line_width; // thickness of stored lines
+        // geometry data
+        std::vector<world_vertex> vertices; // world space source data of the geometry
+        glm::dvec3 origin; // world position of the relative coordinate system origin
+        geometry_handle geometry { 0, 0 }; // relative origin-centered chunk of geometry held by gfx renderer
+    };
+
+// methods
+    // restores content of the node from provded input stream
+    lines_node &
+        deserialize( cParser &Input, scene::node_data const &Nodedata );
+    // adds content of provided node to already enclosed geometry. returns: true if merge could be performed
+    bool
+        merge( lines_node &Lines );
+    // generates renderable version of held non-instanced geometry in specified geometry bank
+    void
+        create_geometry( geometrybank_handle const &Bank );
+    // calculates shape's bounding radius
+    void
+        compute_radius();
+    // set visibility
+    void
+        visible( bool State ) {
+            m_data.visible = State; }
+    // set origin point
+    void
+        origin( glm::dvec3 Origin ) {
+            m_data.origin = Origin; }
+    // data access
+    linesnode_data const &
+        data() const {
+            return m_data; }
+
+private:
+// members
+    std::string m_name;
+    linesnode_data m_data;
+};
+
+/*
+// holds geometry for specific piece of track/road/waterway
+class path_node {
+
+    friend class basic_region; // region might want to modify node content when it's being inserted
+
+public:
+// types
+    // TODO: enable after track class refactoring
+    struct pathnode_data {
+        // placement and visibility
+        bounding_area area; // bounding area, in world coordinates
+        bool visible { true }; // visibility flag
+        // material data
+        material_handle material_1 { 0 };
+        material_handle material_2 { 0 };
+        lighting_data lighting;
+        TEnvironmentType environment { e_flat };
+        // geometry data
+        std::vector<world_vertex> vertices; // world space source data of the geometry
+        glm::dvec3 origin; // world position of the relative coordinate system origin
+        using geometryhandle_sequence = std::vector<geometry_handle>;
+        geometryhandle_sequence geometry_1; // geometry chunks textured with texture 1
+        geometryhandle_sequence geometry_2; // geometry chunks textured with texture 2
+    };
+// methods
+    // restores content of the node from provded input stream
+    // TODO: implement
+    path_node &
+        deserialize( cParser &Input, node_data const &Nodedata );
+    // binds specified track to the node
+    // TODO: remove after track class refactoring
+    void
+        path( TTrack *Path ) {
+            m_path = Path; }
+    TTrack *
+        path() {
+            return m_path; }
+
+private:
+// members
+
+//    // TODO: enable after track class refactoring
+//    pathnode_data m_data;
+
+    TTrack * m_path;
+};
+*/
+/*
+// holds reference to memory cell
+class memorycell_node {
+
+    friend class basic_region; // region might want to modify node content when it's being inserted
+
+public:
+// types
+    struct memorynode_data {
+        // placement and visibility
+        bounding_area area; // bounding area, in world coordinates
+        bool visible { false }; // visibility flag
+    };
+// methods
+    // restores content of the node from provded input stream
+    // TODO: implement
+    memory_node &
+        deserialize( cParser &Input, node_data const &Nodedata );
+    void
+        cell( TMemCell *Cell ) {
+            m_memorycell = Cell; }
+    TMemCell *
+        cell() {
+            return m_memorycell; }
+
+private:
+// members
+    memorynode_data m_data;
+    TMemCell * m_memorycell;
+};
+*/
+} // scene
+
+namespace editor {
+
+// base interface for nodes which can be actvated in scenario editor
+struct basic_node {
+
+public:
+// constructor
+    basic_node() = default; // TODO: remove after refactor
+    basic_node( scene::node_data const &Nodedata );
+// destructor
+    virtual ~basic_node() = default;
+// methods
+    std::string const &
+        name() const {
+            return m_name; }
+    void
+        location( glm::dvec3 const Location ) {
+            m_area.center = Location; }
+    glm::dvec3 const &
+        location() const {
+            return m_area.center; };
+    float const &
+        radius();
+    void
+        visible( bool const Visible ) {
+            m_visible = Visible; }
+    bool
+        visible() const {
+            return m_visible; }
+
+protected:
+// methods
+    // radius() subclass details, calculates node's bounding radius
+    virtual void radius_();
+// members
+    scene::bounding_area m_area;
+    bool m_visible { true };
+    double m_rangesquaredmin { 0.0 }; // visibility range, min
+    double m_rangesquaredmax { 0.0 }; // visibility range, max
+    std::string m_name;
+};
+
+} // editor
+
+//---------------------------------------------------------------------------