bgi_dds.h

Go to the documentation of this file.

#pragma once
 
#include "bgi_types.h"  // Camera3D, CoordSystem, WorldExtents, linesettingstype, …
 
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include <glm/glm.hpp>
 
namespace bgi
{
 
// =============================================================================
// Coordinate-space tag
// =============================================================================
 
enum class CoordSpace
{
    BgiPixel, 
    World3D,  
    UcsLocal, 
};
 
// =============================================================================
// Per-object style snapshot
// =============================================================================
 
struct DdsStyle
{
    int              color{0};
    linesettingstype lineStyle{};
    fillsettingstype fillStyle{};
    textsettingstype textStyle{};
    int              writeMode{0};
    int              bkColor{0};
};
 
struct DdsExternalAttributes
{
    std::unordered_map<std::string, std::string> values;
};
 
// =============================================================================
// Object type discriminator
// =============================================================================
 
enum class DdsObjectType
{
    // Scene-configuration objects ─────────────────────────────────────────────
    Camera,
    Ucs,
    WorldExtentsObj,
 
    // Retained composition objects ────────────────────────────────────────────
    Transform,
    SetUnion,
    SetIntersection,
    SetDifference,
 
    // Drawing-primitive objects ───────────────────────────────────────────────
    Point,
    Line,
    Circle,
    Arc,
    Ellipse,
    FillEllipse,
    PieSlice,
    Sector,
    Rectangle,
    Bar,
    Bar3D,
    Polygon,
    FillPoly,
    Text,
    Image,
 
    // Phase 4 — 3D Solid Primitives ──────────────────────────────────────────
    Box,
    Sphere,
    Cylinder,
    Cone,
    Torus,
 
    // Phase 5 — 3D Surfaces ──────────────────────────────────────────────────
    HeightMap,
    ParamSurface,
 
    // Phase 6 — 2D→3D Extrusion ──────────────────────────────────────────────
    Extrusion,
};
 
// =============================================================================
// Base class
// =============================================================================
 
class DdsObject
{
public:
    std::string   id;             
    std::string   label;          
    DdsObjectType type{DdsObjectType::Point};
    bool          visible{true};
    bool          deleted{false}; 
    DdsStyle      style;          
    DdsExternalAttributes externalAttributes; 
 
    virtual ~DdsObject() = default;
};
 
// =============================================================================
// Scene-configuration objects (DDS is the source of truth)
// =============================================================================
 
class DdsCamera : public DdsObject
{
public:
    std::string name;   
    Camera3D    camera; 
 
    DdsCamera() { type = DdsObjectType::Camera; }
};
 
class DdsUcs : public DdsObject
{
public:
    std::string name; 
    CoordSystem ucs;  
 
    DdsUcs() { type = DdsObjectType::Ucs; }
};
 
class DdsWorldExtentsObj : public DdsObject
{
public:
    WorldExtents extents;
 
    DdsWorldExtentsObj() { type = DdsObjectType::WorldExtentsObj; }
};
 
class DdsTransform : public DdsObject
{
public:
    glm::mat4                matrix{1.f};
    std::vector<std::string> children;
 
    DdsTransform() { type = DdsObjectType::Transform; }
};
 
class DdsSetUnion : public DdsObject
{
public:
    int                      drawMode{1};
    int                      edgeColor{15};
    int                      faceColor{7};
    std::vector<std::string> operands;
 
    DdsSetUnion() { type = DdsObjectType::SetUnion; }
};
 
class DdsSetIntersection : public DdsObject
{
public:
    int                      drawMode{1};
    int                      edgeColor{15};
    int                      faceColor{7};
    std::vector<std::string> operands;
 
    DdsSetIntersection() { type = DdsObjectType::SetIntersection; }
};
 
class DdsSetDifference : public DdsObject
{
public:
    int                      drawMode{1};
    int                      edgeColor{15};
    int                      faceColor{7};
    std::vector<std::string> operands;
 
    DdsSetDifference() { type = DdsObjectType::SetDifference; }
};
 
// =============================================================================
// Drawing-primitive objects
// =============================================================================
 
// All positions are stored as world-space glm::vec3.
// CoordSpace::BgiPixel objects record pixel integers cast to float with Z=0.
 
struct DdsPoint : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   pos{0.f, 0.f, 0.f};
    int         color{0};
 
    DdsPoint() { type = DdsObjectType::Point; }
};
 
struct DdsLine : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   p1{0.f, 0.f, 0.f};
    glm::vec3   p2{0.f, 0.f, 0.f};
 
    DdsLine() { type = DdsObjectType::Line; }
};
 
struct DdsCircle : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   centre{0.f, 0.f, 0.f};
    float       radius{0.f};
 
    DdsCircle() { type = DdsObjectType::Circle; }
};
 
struct DdsArc : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   centre{0.f, 0.f, 0.f};
    float       radius{0.f};
    float       startAngle{0.f};
    float       endAngle{0.f};
 
    DdsArc() { type = DdsObjectType::Arc; }
};
 
struct DdsEllipse : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   centre{0.f, 0.f, 0.f};
    float       rx{0.f};
    float       ry{0.f};
    float       startAngle{0.f};
    float       endAngle{0.f};
 
    DdsEllipse() { type = DdsObjectType::Ellipse; }
};
 
struct DdsFillEllipse : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   centre{0.f, 0.f, 0.f};
    float       rx{0.f};
    float       ry{0.f};
 
    DdsFillEllipse() { type = DdsObjectType::FillEllipse; }
};
 
struct DdsPieSlice : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   centre{0.f, 0.f, 0.f};
    float       radius{0.f};
    float       startAngle{0.f};
    float       endAngle{0.f};
 
    DdsPieSlice() { type = DdsObjectType::PieSlice; }
};
 
struct DdsSector : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   centre{0.f, 0.f, 0.f};
    float       rx{0.f};
    float       ry{0.f};
    float       startAngle{0.f};
    float       endAngle{0.f};
 
    DdsSector() { type = DdsObjectType::Sector; }
};
 
struct DdsRectangle : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   p1{0.f, 0.f, 0.f};
    glm::vec3   p2{0.f, 0.f, 0.f};
 
    DdsRectangle() { type = DdsObjectType::Rectangle; }
};
 
struct DdsBar : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   p1{0.f, 0.f, 0.f};
    glm::vec3   p2{0.f, 0.f, 0.f};
 
    DdsBar() { type = DdsObjectType::Bar; }
};
 
struct DdsBar3D : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   p1{0.f, 0.f, 0.f};
    glm::vec3   p2{0.f, 0.f, 0.f};
    float       depth{0.f};
    bool        topFlag{true};
 
    DdsBar3D() { type = DdsObjectType::Bar3D; }
};
 
struct DdsPolygon : public DdsObject
{
    CoordSpace             coordSpace{CoordSpace::BgiPixel};
    std::string            ucsName;
    std::vector<glm::vec3> pts;
 
    DdsPolygon() { type = DdsObjectType::Polygon; }
};
 
struct DdsFillPoly : public DdsObject
{
    CoordSpace             coordSpace{CoordSpace::BgiPixel};
    std::string            ucsName;
    std::vector<glm::vec3> pts;
 
    DdsFillPoly() { type = DdsObjectType::FillPoly; }
};
 
struct DdsText : public DdsObject
{
    CoordSpace  coordSpace{CoordSpace::BgiPixel};
    std::string ucsName;
    glm::vec3   pos{0.f, 0.f, 0.f};
    std::string text;
 
    DdsText() { type = DdsObjectType::Text; }
};
 
struct DdsImage : public DdsObject
{
    CoordSpace           coordSpace{CoordSpace::BgiPixel};
    glm::vec3            pos{0.f, 0.f, 0.f};
    int                  width{0};
    int                  height{0};
    std::vector<uint8_t> pixels; 
 
    DdsImage() { type = DdsObjectType::Image; }
};
 
// =============================================================================
// Phase 4/5/6 — 3D Solid, Surface and Extrusion objects
// =============================================================================
 
enum class SolidDrawMode { Wireframe = 0, Flat = 1, Smooth = 2, Solid = 1 };
enum class ParamSurfaceFormula { Sphere = 0, Cylinder = 1, Torus = 2, Saddle = 3, Mobius = 4 };
 
struct DdsSolid3D : public DdsObject
{
    CoordSpace      coordSpace{CoordSpace::World3D};
    std::string     ucsName;
    glm::vec3       origin{0.f, 0.f, 0.f};
    SolidDrawMode   drawMode{SolidDrawMode::Wireframe};
    int             edgeColor{15};  
    int             faceColor{7};   
    int             slices{16};     
    int             stacks{8};      
};
 
struct DdsBox : public DdsSolid3D {
    float width{1.f};   
    float depth{1.f};   
    float height{1.f};  
    DdsBox() { type = DdsObjectType::Box; }
};
 
struct DdsSphere : public DdsSolid3D {
    float radius{1.f};
    DdsSphere() { type = DdsObjectType::Sphere; }
};
 
struct DdsCylinder : public DdsSolid3D {
    float radius{1.f};
    float height{1.f};
    int   caps{1};   
    DdsCylinder() { type = DdsObjectType::Cylinder; }
};
 
struct DdsCone : public DdsSolid3D {
    float radius{1.f};
    float height{1.f};
    int   cap{1};    
    DdsCone() { type = DdsObjectType::Cone; }
};
 
struct DdsTorus : public DdsSolid3D {
    float majorRadius{2.f};  
    float minorRadius{0.5f}; 
    // slices = segments around the main axis; stacks = segments of tube cross-section.
    DdsTorus() { type = DdsObjectType::Torus; }
};
 
struct DdsHeightMap : public DdsSolid3D {
    int   rows{0};
    int   cols{0};
    float cellWidth{1.f};   
    float cellHeight{1.f};  
    std::vector<float> heights; 
    DdsHeightMap() { type = DdsObjectType::HeightMap; }
};
 
struct DdsParamSurface : public DdsSolid3D {
    ParamSurfaceFormula formula{ParamSurfaceFormula::Sphere};
    float param1{1.f};  
    float param2{0.5f}; 
    int   uSteps{20};
    int   vSteps{20};
    DdsParamSurface() { type = DdsObjectType::ParamSurface; }
};
 
struct DdsExtrusion : public DdsSolid3D {
    std::vector<glm::vec3> baseProfile; 
    glm::vec3 extrudeDir{0.f, 0.f, 1.f}; 
    int       capStart{1}; 
    int       capEnd{1};   
    DdsExtrusion() { type = DdsObjectType::Extrusion; }
};
 
// =============================================================================
// DdsScene — the scene container
// =============================================================================
 
class DdsScene
{
public:
    DdsScene() = default;
    ~DdsScene() = default;
 
    // Non-copyable (scene is always accessed through gState.dds)
    DdsScene(const DdsScene &) = delete;
    DdsScene &operator=(const DdsScene &) = delete;
 
    // -------------------------------------------------------------------------
    // Insert
    // -------------------------------------------------------------------------
 
    std::shared_ptr<DdsObject> append(std::shared_ptr<DdsObject> obj);
 
    std::shared_ptr<DdsObject> appendWithId(std::shared_ptr<DdsObject> obj);
 
    // -------------------------------------------------------------------------
    // Lookup
    // -------------------------------------------------------------------------
 
    std::shared_ptr<DdsObject> findById(const std::string &id) const;
 
    std::shared_ptr<DdsObject> findByLabel(const std::string &label) const;
 
    std::string findIdByLabel(const std::string &label) const;
 
    // -------------------------------------------------------------------------
    // Removal
    // -------------------------------------------------------------------------
 
    bool remove(const std::string &id);
 
    void clearDrawingObjects();
 
    void clearAll();
 
    void compact();
 
    // -------------------------------------------------------------------------
    // Introspection
    // -------------------------------------------------------------------------
 
    int count() const;
 
    int countDrawing() const;
 
    std::string idAt(int index) const;
 
    // -------------------------------------------------------------------------
    // Traversal
    // -------------------------------------------------------------------------
 
    template <typename Fn>
    void forEach(Fn &&fn) const
    {
        for (const auto &id : order)
        {
            auto it = index.find(id);
            if (it != index.end() && !it->second->deleted)
                fn(*it->second);
        }
    }
 
    template <typename Fn>
    void forEachDrawing(Fn &&fn) const
    {
        for (const auto &id : order)
        {
            auto it = index.find(id);
            if (it == index.end() || it->second->deleted)
                continue;
            const auto t = it->second->type;
            if (t == DdsObjectType::Camera || t == DdsObjectType::Ucs ||
                t == DdsObjectType::WorldExtentsObj)
                continue;
            fn(*it->second);
        }
    }
 
    template <typename Fn>
    void forEachRenderRoot(Fn &&fn) const
    {
        std::unordered_set<std::string> referenced;
        referenced.reserve(order.size());
 
        for (const auto &id : order)
        {
            auto it = index.find(id);
            if (it == index.end() || it->second->deleted)
                continue;
 
            const auto *children = [&]() -> const std::vector<std::string> * {
                switch (it->second->type)
                {
                case DdsObjectType::Transform:
                    return &static_cast<const DdsTransform &>(*it->second).children;
                case DdsObjectType::SetUnion:
                    return &static_cast<const DdsSetUnion &>(*it->second).operands;
                case DdsObjectType::SetIntersection:
                    return &static_cast<const DdsSetIntersection &>(*it->second).operands;
                case DdsObjectType::SetDifference:
                    return &static_cast<const DdsSetDifference &>(*it->second).operands;
                default:
                    return nullptr;
                }
            }();
 
            if (!children)
                continue;
            for (const auto &childId : *children)
                referenced.insert(childId);
        }
 
        for (const auto &id : order)
        {
            auto it = index.find(id);
            if (it == index.end() || it->second->deleted)
                continue;
            const auto t = it->second->type;
            if (t == DdsObjectType::Camera || t == DdsObjectType::Ucs ||
                t == DdsObjectType::WorldExtentsObj)
                continue;
            if (referenced.find(id) != referenced.end())
                continue;
            fn(*it->second);
        }
    }
 
    // -------------------------------------------------------------------------
    // Data members (public for direct access by bgi_state.cpp only)
    // -------------------------------------------------------------------------
    std::vector<std::string>                                    order;
    std::unordered_map<std::string, std::shared_ptr<DdsObject>> index;
    uint64_t                                                    nextId{1};
    uint64_t                                                    revision{1};
 
private:
    std::string genId() { return std::to_string(nextId++); }
};
 
} // namespace bgi