bgi_types.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <memory>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
 
#if defined(_WIN32)
#define BGI_API extern "C" __declspec(dllexport)
#else
#define BGI_API extern "C"
#endif
 
#if defined(_MSC_VER)
#define BGI_CALL __cdecl
#else
#define BGI_CALL
#endif
 
struct GLFWwindow;
 
typedef void (BGI_CALL *WxbgiKeyHook)(int key, int scancode, int action, int mods);
 
typedef void (BGI_CALL *WxbgiCharHook)(unsigned int codepoint);
 
typedef void (BGI_CALL *WxbgiCursorPosHook)(int x, int y);
 
typedef void (BGI_CALL *WxbgiMouseButtonHook)(int button, int action, int mods);
 
typedef void (BGI_CALL *WxbgiScrollHook)(double xoffset, double yoffset);
 
#define WXBGI_DEFAULT_KEY_QUEUE    0x01
#define WXBGI_DEFAULT_CURSOR_TRACK 0x02
#define WXBGI_DEFAULT_MOUSE_PICK   0x04
#define WXBGI_DEFAULT_SCROLL_ACCUM 0x08
#define WXBGI_DEFAULT_ALL          0x0F
#define WXBGI_DEFAULT_NONE         0x00
#define WXBGI_KEY_SPACE         32
#define WXBGI_KEY_APOSTROPHE    39
#define WXBGI_KEY_COMMA         44
#define WXBGI_KEY_MINUS         45
#define WXBGI_KEY_PERIOD        46
#define WXBGI_KEY_SLASH         47
#define WXBGI_KEY_SEMICOLON     59
#define WXBGI_KEY_EQUAL         61
#define WXBGI_KEY_LEFT_BRACKET  91
#define WXBGI_KEY_RIGHT_BRACKET 93
#define WXBGI_KEY_ESCAPE        256
#define WXBGI_KEY_ENTER         257
#define WXBGI_KEY_TAB           258
#define WXBGI_KEY_BACKSPACE     259
#define WXBGI_KEY_INSERT        260
#define WXBGI_KEY_DELETE        261
#define WXBGI_KEY_RIGHT         262
#define WXBGI_KEY_LEFT          263
#define WXBGI_KEY_DOWN          264
#define WXBGI_KEY_UP            265
#define WXBGI_KEY_PAGE_UP       266
#define WXBGI_KEY_PAGE_DOWN     267
#define WXBGI_KEY_HOME          268
#define WXBGI_KEY_END           269
#define WXBGI_KEY_F1            290
#define WXBGI_KEY_F2            291
#define WXBGI_KEY_F3            292
#define WXBGI_KEY_F4            293
#define WXBGI_KEY_F5            294
#define WXBGI_KEY_F6            295
#define WXBGI_KEY_F7            296
#define WXBGI_KEY_F8            297
#define WXBGI_KEY_F9            298
#define WXBGI_KEY_F10           299
#define WXBGI_KEY_F11           300
#define WXBGI_KEY_F12           301
namespace bgi
{
 
    constexpr int DETECT = 0;
    constexpr int kDefaultWidth = 960;
    constexpr int kDefaultHeight = 720;
    constexpr int kPaletteSize    = 16;   
    constexpr int kExtColorBase   = 16;   
    constexpr int kExtPaletteSize = 240;  
    constexpr int kSelectionOrangeColor = 252;  
    constexpr int kSelectionPurpleColor = 253;  
    constexpr int kPageCount = 2;
    constexpr int kPatternRows = 8;
    constexpr int kPatternCols = 8;
 
    constexpr int BLACK = 0;
    constexpr int BLUE = 1;
    constexpr int GREEN = 2;
    constexpr int CYAN = 3;
    constexpr int RED = 4;
    constexpr int MAGENTA = 5;
    constexpr int BROWN = 6;
    constexpr int LIGHTGRAY = 7;
    constexpr int DARKGRAY = 8;
    constexpr int LIGHTBLUE = 9;
    constexpr int LIGHTGREEN = 10;
    constexpr int LIGHTCYAN = 11;
    constexpr int LIGHTRED = 12;
    constexpr int LIGHTMAGENTA = 13;
    constexpr int YELLOW = 14;
    constexpr int WHITE = 15;
 
    constexpr int SOLID_LINE = 0;
    constexpr int DOTTED_LINE = 1;
    constexpr int CENTER_LINE = 2;
    constexpr int DASHED_LINE = 3;
    constexpr int USERBIT_LINE = 4;
 
    constexpr int NORM_WIDTH = 1;
    constexpr int THICK_WIDTH = 3;
 
    constexpr int EMPTY_FILL = 0;
    constexpr int SOLID_FILL = 1;
    constexpr int LINE_FILL = 2;
    constexpr int LTSLASH_FILL = 3;
    constexpr int SLASH_FILL = 4;
    constexpr int BKSLASH_FILL = 5;
    constexpr int LTBKSLASH_FILL = 6;
    constexpr int HATCH_FILL = 7;
    constexpr int XHATCH_FILL = 8;
    constexpr int INTERLEAVE_FILL = 9;
    constexpr int WIDE_DOT_FILL = 10;
    constexpr int CLOSE_DOT_FILL = 11;
    constexpr int USER_FILL = 12;
 
    constexpr int COPY_PUT = 0;
    constexpr int XOR_PUT = 1;
    constexpr int OR_PUT = 2;
    constexpr int AND_PUT = 3;
    constexpr int NOT_PUT = 4;
 
    constexpr int DEFAULT_FONT = 0;
    constexpr int TRIPLEX_FONT = 1;
    constexpr int SMALL_FONT = 2;
    constexpr int SANS_SERIF_FONT = 4;
    constexpr int GOTHIC_FONT = 8;
    constexpr int HORIZ_DIR = 0;
    constexpr int VERT_DIR = 1;
 
    constexpr int LEFT_TEXT = 0;
    constexpr int CENTER_TEXT = 1;
    constexpr int RIGHT_TEXT = 2;
    constexpr int BOTTOM_TEXT = 0;
    constexpr int TOP_TEXT = 2;
 
    enum GraphStatus
    {
        grOk = 0,
        grNoInitGraph = -1,
        grNotDetected = -2,
        grFileNotFound = -3,
        grInvalidDriver = -4,
        grNoLoadMem = -5,
        grNoScanMem = -6,
        grNoFloodMem = -7,
        grFontNotFound = -8,
        grNoFontMem = -9,
        grInvalidMode = -10,
        grError = -11,
        grIOerror = -12,
        grInvalidFont = -13,
        grInvalidFontNum = -14,
        grInvalidVersion = -18,
        grInitFailed = -19,
        grWindowClosed = -20,
        grInvalidInput = -21,
        grDuplicateName = -22, 
    };
 
    struct arccoordstype
    {
        int x;
        int y;
        int xstart;
        int ystart;
        int xend;
        int yend;
    };
 
    struct fillsettingstype
    {
        int pattern;
        int color;
    };
 
    struct linesettingstype
    {
        int linestyle;
        unsigned upattern;
        int thickness;
    };
 
    struct palettetype
    {
        std::uint8_t size;
        std::array<int, kPaletteSize> colors;
    };
 
    struct textsettingstype
    {
        int font;
        int direction;
        int charsize;
        int horiz;
        int vert;
    };
 
    struct viewporttype
    {
        int left;
        int top;
        int right;
        int bottom;
        int clip;
    };
 
    struct ColorRGB
    {
        std::uint8_t r;
        std::uint8_t g;
        std::uint8_t b;
    };
 
    using MouseHandler = void(BGI_CALL *)(int, int);
 
    struct MouseClickEvent
    {
        int kind;
        int x;
        int y;
    };
 
    struct ImageHeader
    {
        std::uint32_t width;
        std::uint32_t height;
    };
 
    extern const ColorRGB kBgiPalette[kPaletteSize];
 
    // -------------------------------------------------------------------------
    // Camera system
    // -------------------------------------------------------------------------
 
    enum class CameraProjection
    {
        Orthographic = 0,
        Perspective  = 1,
    };
 
    struct Camera3D
    {
        // --- Eye/target/up (Z-up, right-handed) ---
        float eyeX{0.f},    eyeY{-10.f},  eyeZ{5.f};
        float targetX{0.f}, targetY{0.f}, targetZ{0.f};
        float upX{0.f},     upY{0.f},     upZ{1.f};  // Z is up
 
        // --- Projection ---
        CameraProjection projection{CameraProjection::Orthographic};
 
        float fovYDeg{45.f};
        float nearPlane{0.1f};
        float farPlane{10000.f};
 
        // Orthographic clip extents. All-zero triggers auto-fit via worldHeight2d.
        float orthoLeft{0.f},   orthoRight{0.f};
        float orthoBottom{0.f}, orthoTop{0.f};
 
        // --- Screen-space viewport override (pixels).
        //     All-zero means the full GLFW window. ---
        int vpX{0}, vpY{0}, vpW{0}, vpH{0};
 
        // --- 2-D convenience layer (active when is2D == true) ---
        bool  is2D{false};
        float pan2dX{0.f}, pan2dY{0.f};
        float zoom2d{1.f};
        float rot2dDeg{0.f};
        float worldHeight2d{2.f};
 
        // --- Per-camera visual overlay state (not serialised to DDS/DDJ) ---
 
        struct {
            bool  enabled     {false};
            int   count       {3};       
            float innerRadius {25.f};    
            float outerRadius {100.f};   
        } concentricOverlay;
 
        struct {
            bool  enabled     {false};
            int   sizePx      {8};       
            int   colorScheme {0};       
        } selCursorOverlay;
 
        // --- Scene assignment ---
        std::string assignedSceneName{"default"};
    };
 
    // -------------------------------------------------------------------------
    // User Coordinate System (UCS)
    // -------------------------------------------------------------------------
 
    struct CoordSystem
    {
        // Origin of this UCS in world space.
        float originX{0.f}, originY{0.f}, originZ{0.f};
 
        // Orthonormal axes expressed as world-space direction vectors.
        // These default to the world identity frame (Z-up, right-handed).
        float xAxisX{1.f}, xAxisY{0.f}, xAxisZ{0.f};
        float yAxisX{0.f}, yAxisY{1.f}, yAxisZ{0.f};
        float zAxisX{0.f}, zAxisY{0.f}, zAxisZ{1.f};
    };
 
    // -------------------------------------------------------------------------
    // Visual overlay state
    // -------------------------------------------------------------------------
 
    struct OverlayGridState
    {
        bool        enabled    {false};
        float       spacing    {25.f};   
        int         halfExtent {4};      
        int         xAxisColor {RED};    
        int         yAxisColor {GREEN};  
        int         gridColor  {DARKGRAY}; 
        std::string ucsName;             
    };
 
    struct OverlayUcsAxesState
    {
        bool  enabled    {false};
        bool  showWorld  {true};   
        bool  showActive {true};   
        float axisLength {80.f};   
    };
 
    // -------------------------------------------------------------------------
    // World extents
    // -------------------------------------------------------------------------
 
    struct WorldExtents
    {
        float minX{0.f}, minY{0.f}, minZ{0.f};
        float maxX{0.f}, maxY{0.f}, maxZ{0.f};
        bool  hasData{false};
    };
 
    struct LightState
    {
        // Primary (key) light direction — normalised, world-space by default.
        float dirX{ -0.577f}, dirY{ 0.577f}, dirZ{0.577f};
        bool  worldSpace{true};          
 
        // Fill (secondary) light — softens shadows.
        float fillX{0.f}, fillY{-1.f}, fillZ{0.f};
        float fillStrength{0.30f};
 
        // Phong material intensities.
        float ambient  {0.20f};
        float diffuse  {0.70f};
        float specular {0.30f};
        float shininess{32.f};
    };
 
    // -------------------------------------------------------------------------
    // GL pass geometry buffers (populated by wxbgi_render_dds; consumed by
    // renderSolidsGLPass / renderWorldLinesGLPass with the GL context current).
    // -------------------------------------------------------------------------
 
    struct GlVertex
    {
        float px, py, pz;    
        float nx, ny, nz;    
        float r,  g,  b;     
    };
 
    struct GlLineVertex
    {
        float px, py, pz;    
        float r,  g,  b;     
    };
 
    struct PendingGlRender
    {
        std::vector<GlVertex>     solidVerts;     
        std::vector<GlVertex>     smoothVerts;    
        std::vector<GlVertex>     wireTriVerts;   
        std::vector<GlLineVertex> wireLineVerts;  
        std::vector<GlLineVertex> lineVerts;      
 
        bool hasSolids()    const { return !solidVerts.empty() || !smoothVerts.empty(); }
        bool hasWireframe() const { return !wireTriVerts.empty(); }
        bool hasLines()     const { return !lineVerts.empty(); }
        bool hasPending()   const { return hasSolids() || hasWireframe() || hasLines(); }
        void clear()
        {
            solidVerts.clear(); smoothVerts.clear();
            wireTriVerts.clear(); wireLineVerts.clear();
            lineVerts.clear();
        }
    };
 
    struct PendingGlFrame
    {
        PendingGlRender geometry;
        float           viewProj[16]{};  
        float           eyeX{0}, eyeY{0}, eyeZ{0};
        LightState      light;
        int camVpX{0}, camVpY{0}, camVpW{0}, camVpH{0};
    };
 
    // -------------------------------------------------------------------------
    // Forward declarations for DDS types (full definitions in bgi_dds.h).
    // These let BgiState hold shared_ptr<DdsCamera>, the ddsRegistry map, and
    // a raw DdsScene* shortcut without creating a circular include between
    // bgi_types.h and bgi_dds.h.
    // -------------------------------------------------------------------------
    class DdsCamera;
    class DdsUcs;
    class DdsScene;
 
    struct BgiState
    {
        GLFWwindow *window{nullptr};
        int width{kDefaultWidth};
        int height{kDefaultHeight};
        int graphDriver{DETECT};
        int graphMode{0};
        int currentColor{WHITE};
        int bkColor{BLACK};
        int fillPattern{SOLID_FILL};
        int fillColor{WHITE};
        std::array<std::uint8_t, kPatternRows> fillMask{};
        bool userFillPatternEnabled{false};
        int lastResult{grNoInitGraph};
        bool glfwInitialized{false};
        viewporttype viewport{0, 0, kDefaultWidth - 1, kDefaultHeight - 1, 1};
        int currentX{0};
        int currentY{0};
        linesettingstype lineSettings{SOLID_LINE, 0xFFFFU, NORM_WIDTH};
        textsettingstype textSettings{DEFAULT_FONT, HORIZ_DIR, 1, LEFT_TEXT, TOP_TEXT};
        int userCharSizeXNum{1};
        int userCharSizeXDen{1};
        int userCharSizeYNum{1};
        int userCharSizeYDen{1};
        int aspectX{1};
        int aspectY{1};
        int writeMode{COPY_PUT};
        arccoordstype lastArc{0, 0, 0, 0, 0, 0};
        palettetype defaultPalette{};
        palettetype activePalette{};
        std::array<ColorRGB, kPaletteSize>    palette{};
        std::array<ColorRGB, kExtPaletteSize> extPalette{};  
        int extColorNext{kExtColorBase};                      
        unsigned graphBufSize{0U};
        int activePage{0};
        int visualPage{0};
        std::vector<std::vector<std::uint8_t>> pageBuffers;
        std::string windowTitle{"BGI OpenGL Wrapper"};
        bool doubleBuffered{false};
        std::queue<int> keyQueue;
        std::array<std::uint8_t, 512> keyDown{};
        int mouseX{0};
        int mouseY{0};
        bool mouseMoved{false}; 
 
        // --- Camera registry (DdsCamera is the source of truth) ---
        // shared_ptr<DdsCamera> maps are indexes into the DDS; Camera3D data
        // lives inside each DdsCamera object.  Forward declaration keeps this
        // header free of the full bgi_dds.h include.
        std::unordered_map<std::string, std::shared_ptr<DdsCamera>> cameras;
        std::string activeCamera{"default"};
 
        // --- UCS registry (DdsUcs is the source of truth) ---
        std::unordered_map<std::string, std::shared_ptr<DdsUcs>> ucsSystems;
        std::string activeUcs{"world"};
 
        // --- World drawing extents (AABB in world space) ---
        WorldExtents worldExtents;
 
        // --- Drawing Description Data Structure (DDS) scene graph registry ---
        //
        // ddsRegistry owns all named scene graphs. The "default" scene is
        // created at startup and cannot be destroyed.
        //
        // dds is a non-owning raw-pointer shortcut that always points to
        // ddsRegistry[activeDdsName].get(). All legacy gState.dds->foo() call
        // sites continue to work without modification because both unique_ptr
        // and raw pointer support operator->. The shortcut is updated whenever
        // activeDdsName changes (wxbgi_dds_scene_set_active / resetStateForWindow).
        std::unordered_map<std::string, std::unique_ptr<DdsScene>> ddsRegistry;
        std::string activeDdsName{"default"};
        DdsScene   *dds{nullptr};   
 
        // --- 3D Solid / Surface / Extrusion defaults ---
        int solidDrawMode{0};         
        int solidEdgeColor{15};       
        int solidFaceColor{7};        
        int solidColorOverride{-1};   
 
        // --- Global visual overlays (not serialised) ---
        OverlayGridState    overlayGrid;
        OverlayUcsAxesState overlayUcsAxes;
 
        // --- DDS Object Selection state (not serialised) ---
        std::vector<std::string> selectedObjectIds;   
        int selectionFlashScheme {0};                 
        int selectionPickRadiusPx{16};                
 
        // --- User input hooks ---
        WxbgiKeyHook          userKeyHook{nullptr};
        WxbgiCharHook         userCharHook{nullptr};
        WxbgiCursorPosHook   userCursorPosHook{nullptr}; 
        WxbgiMouseButtonHook  userMouseButtonHook{nullptr};
        WxbgiScrollHook       userScrollHook{nullptr};
        double scrollDeltaX{0.0}; 
        double scrollDeltaY{0.0}; 
 
        // --- Input default behavior flags ---
        int inputDefaultFlags{WXBGI_DEFAULT_ALL}; 
 
        // --- wx-embedded mode flag ---
        bool wxEmbedded{false}; 
        bool shouldClose{false}; 
        bool inCrtMode{false};  
        void (*wxPollCallback)(){nullptr};
 
        // --- GL rendering mode ---
        bool legacyGlRender{false}; 
        LightState lightState;       
        PendingGlRender pendingGl;   
        std::vector<PendingGlFrame> pendingGlQueue;
        std::string pendingOverlayCam{};
 
        // Constructor/destructor defined in bgi_state.cpp (where bgi_dds.h is
        // included) so DdsScene is fully defined when the ddsRegistry map's
        // unique_ptr destructors are generated.
        BgiState();
        ~BgiState();
        BgiState(const BgiState &) = delete;
        BgiState &operator=(const BgiState &) = delete;
    };
 
} // namespace bgi