Visualizer.h

Go to the documentation of this file.

 
#ifndef HELIOS_VISUALIZER
#define HELIOS_VISUALIZER
 
#include "Context.h"
 
// GLM Libraries (math-related functions for graphics)
#define GLM_FORCE_RADIANS
#ifndef APIENTRY
#define APIENTRY
#endif
#include <GLFW/glfw3.h>
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "glm/gtx/transform.hpp"
 
#include "GeometryHandler.h"
 
class Visualizer;
 
 
bool validateTextureFile(const std::string &texture_file, bool pngonly = false);
 
void mouseCallback(GLFWwindow *window, int button, int action, int mods);
 
void cursorCallback(GLFWwindow *window, double x, double y);
 
void scrollCallback(GLFWwindow *window, double xoffset, double yoffset);
 
class Glyph {
public:
    Glyph() = default;
    Glyph(const helios::uint2 &size, const std::vector<std::vector<unsigned char>> &data) : size(size), data(data) {
    }
    helios::uint2 size;
    std::vector<std::vector<unsigned char>> data;
};
 
struct Shader {
 
    void disableTextures() const;
 
    void enableTextureMaps() const;
 
    void enableTextureMasks() const;
 
    void setTransformationMatrix(const glm::mat4 &matrix) const;
 
    void setViewMatrix(const glm::mat4 &matrix) const;
 
    void setProjectionMatrix(const glm::mat4 &matrix) const;
 
    void setDepthBiasMatrix(const glm::mat4 &matrix) const;
 
    void setLightDirection(const helios::vec3 &direction) const;
 
    void setLightingModel(uint lightingmodel) const;
 
    void setLightIntensity(float lightintensity) const;
 
    void useShader() const;
 
 
    void initialize(const char *vertex_shader_file, const char *fragment_shader_file, Visualizer *visualizer_ptr, const char *geometry_shader_file = nullptr);
 
    ~Shader();
 
    // Primary Shader
    uint shaderID;
    GLint textureUniform;
    GLint shadowmapUniform;
    GLint transformMatrixUniform;
    GLint viewMatrixUniform;
    GLint projectionMatrixUniform;
    GLint depthBiasUniform;
    GLint lightDirectionUniform;
    GLint lightingModelUniform;
    GLint RboundUniform;
    GLint lightIntensityUniform;
    std::vector<GLuint> vertex_array_IDs;
    GLint uvRescaleUniform;
 
    // Texture buffer uniform locations (cached to avoid glGetUniformLocation during rendering)
    GLint colorTextureObjectUniform;
    GLint normalTextureObjectUniform;
    GLint textureFlagTextureObjectUniform;
    GLint textureIDTextureObjectUniform;
    GLint coordinateFlagTextureObjectUniform;
    GLint skyGeometryFlagTextureObjectUniform;
    GLint hiddenFlagTextureObjectUniform;
 
    bool initialized = false;
};
 
struct Colormap {
 
    Colormap() : cmapsize(0), minval(0.0f), maxval(1.0f) {};
 
    Colormap(const std::vector<helios::RGBcolor> &ctable, const std::vector<float> &clocs, int size, float minval_, float maxval_) : cmapsize(size), minval(minval_), maxval(maxval_) {
        set(ctable, clocs, size, minval_, maxval_);
    }
 
    void set(const std::vector<helios::RGBcolor> &ctable, const std::vector<float> &clocs, int size, float a_minval, float a_maxval) {
        cmapsize = size;
        minval = a_minval;
        maxval = a_maxval;
 
        size_t Ncolors = ctable.size();
 
        assert(clocs.size() == Ncolors && minval < maxval);
 
        cmap.resize(Ncolors);
 
        std::vector<float> cinds;
        cinds.resize(Ncolors);
 
        for (uint i = 0; i < Ncolors; i++) {
            cinds.at(i) = clocs.at(i) * static_cast<float>(cmapsize - 1);
        }
 
        cmap.resize(cmapsize);
        for (uint c = 0; c < Ncolors - 1; c++) {
            float cmin = cinds.at(c);
            float cmax = cinds.at(c + 1);
 
            for (uint i = 0; i < cmapsize; i++) {
                auto i_f = static_cast<float>(i);
 
                if (i_f >= cmin && i_f <= cmax) {
                    cmap.at(i).r = ctable.at(c).r + (i_f - cmin) / (cmax - cmin) * (ctable.at(c + 1).r - ctable.at(c).r);
                    cmap.at(i).g = ctable.at(c).g + (i_f - cmin) / (cmax - cmin) * (ctable.at(c + 1).g - ctable.at(c).g);
                    cmap.at(i).b = ctable.at(c).b + (i_f - cmin) / (cmax - cmin) * (ctable.at(c + 1).b - ctable.at(c).b);
                }
            }
        }
    }
 
    [[nodiscard]] helios::RGBcolor query(float x) const {
        assert(cmapsize > 0 && !cmap.empty());
 
        helios::RGBcolor color;
 
        uint color_ind;
        if (minval == maxval) {
            color_ind = 0;
        } else {
            float normalized_pos = (x - minval) / (maxval - minval) * float(cmapsize - 1);
 
            // Handle values below minimum range
            if (normalized_pos < 0) {
                color_ind = 0;
            }
            // Handle values above maximum range
            else if (normalized_pos > float(cmapsize - 1)) {
                color_ind = cmapsize - 1;
            }
            // Handle values within range
            else {
                color_ind = std::round(normalized_pos);
            }
        }
 
        color.r = cmap.at(color_ind).r;
        color.g = cmap.at(color_ind).g;
        color.b = cmap.at(color_ind).b;
 
        return color;
    }
 
    void setRange(float min, float max) {
        minval = min;
        maxval = max;
    }
 
    [[nodiscard]] helios::vec2 getRange() const {
        return {minval, maxval};
    }
 
    [[nodiscard]] float getLowerLimit() const {
        return minval;
    }
 
    [[nodiscard]] float getUpperLimit() const {
        return maxval;
    }
 
private:
    std::vector<helios::RGBcolor> cmap;
    unsigned int cmapsize;
    float minval, maxval;
};
 
 
int read_JPEG_file(const char *filename, std::vector<unsigned char> &texture, uint &height, uint &width);
 
 
int write_JPEG_file(const char *filename, uint width, uint height, bool buffers_swapped_since_render, bool print_messages);
 
 
int write_JPEG_file(const char *filename, uint width, uint height, const std::vector<helios::RGBcolor> &data, bool print_messages);
 
 
int write_PNG_file(const char *filename, uint width, uint height, bool buffers_swapped_since_render, bool transparent_background, bool print_messages);
 
 
int write_PNG_file(const char *filename, uint width, uint height, const std::vector<helios::RGBAcolor> &data, bool print_messages);
 
 
void read_png_file(const char *filename, std::vector<unsigned char> &texture, uint &height, uint &width);
 
class Visualizer {
public:
    Visualizer() = delete;
 
 
    explicit Visualizer(uint Wdisplay);
 
 
    Visualizer(uint Wdisplay, uint Hdisplay);
 
 
    Visualizer(uint Wdisplay, uint Hdisplay, int aliasing_samples);
 
 
    Visualizer(uint Wdisplay, uint Hdisplay, int aliasing_samples, bool window_decorations, bool headless);
 
    ~Visualizer();
 
    static int selfTest(int argc = 0, char **argv = nullptr);
 
    void enableMessages();
 
    void disableMessages();
 
    enum CoordinateSystem {
        COORDINATES_WINDOW_NORMALIZED = 0,
 
        COORDINATES_CARTESIAN = 1
    };
 
    enum Ctable {
        COLORMAP_HOT = 0,
        COLORMAP_COOL = 1,
        COLORMAP_RAINBOW = 2,
        COLORMAP_LAVA = 3,
        COLORMAP_PARULA = 4,
        COLORMAP_GRAY = 5,
        COLORMAP_CUSTOM = 6,
        COLORMAP_LINES = 7
    };
 
 
    void setCameraPosition(const helios::vec3 &cameraPosition, const helios::vec3 &lookAt);
 
 
    void setCameraPosition(const helios::SphericalCoord &cameraAngle, const helios::vec3 &lookAt);
 
 
    void setCameraFieldOfView(float angle_FOV);
 
 
    void setLightDirection(const helios::vec3 &direction);
 
    enum LightingModel {
        LIGHTING_NONE = 0,
 
        LIGHTING_PHONG = 1,
 
        LIGHTING_PHONG_SHADOWED = 2
    };
 
 
    void setLightingModel(LightingModel lightingmodel);
 
 
    void setLightIntensityFactor(float lightintensityfactor);
 
    void setupOffscreenFramebuffer();
 
    void cleanupOffscreenFramebuffer();
 
 
    void renderToOffscreenBuffer();
 
 
    void setBackgroundColor(const helios::RGBcolor &color);
 
 
    void setBackgroundTransparent();
 
 
    void setBackgroundImage(const char *texture_file);
 
 
    void setBackgroundSkyTexture(const char *texture_file = nullptr, uint Ndivisions = 50);
 
 
    size_t addRectangleByCenter(const helios::vec3 &center, const helios::vec2 &size, const helios::SphericalCoord &rotation, const helios::RGBcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByCenter(const helios::vec3 &center, const helios::vec2 &size, const helios::SphericalCoord &rotation, const helios::RGBAcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByCenter(const helios::vec3 &center, const helios::vec2 &size, const helios::SphericalCoord &rotation, const char *texture_file, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByCenter(const helios::vec3 &center, const helios::vec2 &size, const helios::SphericalCoord &rotation, const helios::RGBcolor &color, const char *texture_file, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByCenter(const helios::vec3 &center, const helios::vec2 &size, const helios::SphericalCoord &rotation, const helios::RGBcolor &color, const Glyph *glyph, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const helios::RGBcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const helios::RGBAcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const char *texture_file, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const char *texture_file, const std::vector<helios::vec2> &uvs, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const helios::RGBcolor &color, const char *texture_file, const std::vector<helios::vec2> &uvs, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const helios::RGBcolor &color, const char *texture_file, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const helios::RGBcolor &color, const Glyph *glyph, CoordinateSystem coordFlag);
 
 
    size_t addRectangleByVertices(const std::vector<helios::vec3> &vertices, const helios::RGBAcolor &color, const Glyph *glyph, CoordinateSystem coordFlag);
 
 
    size_t addTriangle(const helios::vec3 &vertex0, const helios::vec3 &vertex1, const helios::vec3 &vertex2, const helios::RGBcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addTriangle(const helios::vec3 &vertex0, const helios::vec3 &vertex1, const helios::vec3 &vertex2, const helios::RGBAcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addTriangle(const helios::vec3 &vertex0, const helios::vec3 &vertex1, const helios::vec3 &vertex2, const char *texture_file, const helios::vec2 &uv0, const helios::vec2 &uv1, const helios::vec2 &uv2, CoordinateSystem coordFlag);
 
 
    size_t addTriangle(const helios::vec3 &vertex0, const helios::vec3 &vertex1, const helios::vec3 &vertex2, const char *texture_file, const helios::vec2 &uv0, const helios::vec2 &uv1, const helios::vec2 &uv2, const helios::RGBAcolor &color,
                       CoordinateSystem coordFlag);
 
 
    std::vector<size_t> addVoxelByCenter(const helios::vec3 &center, const helios::vec3 &size, const helios::SphericalCoord &rotation, const helios::RGBcolor &color, CoordinateSystem coordFlag);
 
 
    std::vector<size_t> addVoxelByCenter(const helios::vec3 &center, const helios::vec3 &size, const helios::SphericalCoord &rotation, const helios::RGBAcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addLine(const helios::vec3 &start, const helios::vec3 &end, const helios::RGBcolor &color, CoordinateSystem coordinate_system);
 
 
    size_t addLine(const helios::vec3 &start, const helios::vec3 &end, const helios::RGBAcolor &color, CoordinateSystem coordFlag);
 
 
    size_t addLine(const helios::vec3 &start, const helios::vec3 &end, const helios::RGBcolor &color, float line_width, CoordinateSystem coordinate_system);
 
 
    size_t addLine(const helios::vec3 &start, const helios::vec3 &end, const helios::RGBAcolor &color, float line_width, CoordinateSystem coordFlag);
 
 
    size_t addPoint(const helios::vec3 &position, const helios::RGBcolor &color, float pointsize, CoordinateSystem coordinate_system);
 
 
    size_t addPoint(const helios::vec3 &position, const helios::RGBAcolor &color, float pointsize, CoordinateSystem coordinate_system);
 
 
    std::vector<size_t> addSphereByCenter(float radius, const helios::vec3 &center, uint Ndivisions, const helios::RGBcolor &color, CoordinateSystem coordinate_system);
 
 
    std::vector<size_t> addSphereByCenter(float radius, const helios::vec3 &center, uint Ndivisions, const helios::RGBAcolor &color, CoordinateSystem coordinate_system);
 
 
    [[deprecated]]
    std::vector<size_t> addSkyDomeByCenter(float radius, const helios::vec3 &center, uint Ndivisions, const char *texture_file);
 
 
    [[deprecated]]
    void addSkyDomeByCenter(float radius, const helios::vec3 &center, uint Ndivisions, const char *texture_file, int layer);
 
 
    std::vector<size_t> addTextboxByCenter(const char *textstring, const helios::vec3 &center, const helios::SphericalCoord &rotation, const helios::RGBcolor &fontcolor, uint fontsize, const char *fontname, CoordinateSystem coordinate_system);
 
 
    void deleteGeometry(size_t geometry_id);
 
 
    [[nodiscard]] std::vector<helios::vec3> getGeometryVertices(size_t geometry_id) const;
 
 
    void setGeometryVertices(size_t geometry_id, const std::vector<helios::vec3> &vertices);
 
    void addCoordinateAxes();
 
 
    void addCoordinateAxes(const helios::vec3 &origin, const helios::vec3 &length, const std::string &sign);
 
    void disableCoordinateAxes();
 
 
    void addGridWireFrame(const helios::vec3 &center, const helios::vec3 &size, const helios::int3 &subdiv);
 
    void enableColorbar();
 
    void disableColorbar();
 
 
    void setColorbarPosition(helios::vec3 position);
 
 
    void setColorbarSize(helios::vec2 size);
 
 
    void setColorbarRange(float cmin, float cmax);
 
 
    void setColorbarTicks(const std::vector<float> &ticks);
 
 
    void setColorbarTitle(const char *title);
 
 
    void setColorbarFontColor(helios::RGBcolor color);
 
 
    void setColorbarFontSize(uint font_size);
 
 
    void setColormap(Ctable colormap_name);
 
 
    void setColormap(const std::vector<helios::RGBcolor> &colors, const std::vector<float> &divisions);
 
    [[nodiscard]] Colormap getCurrentColormap() const;
 
 
    static double niceNumber(double value, bool round);
 
 
    static std::string formatTickLabel(double value, double spacing, bool isIntegerData);
 
 
    static std::vector<float> generateNiceTicks(float dataMin, float dataMax, bool isIntegerData, int targetTicks = 5);
 
 
    void buildContextGeometry(helios::Context *context_ptr);
 
 
    void buildContextGeometry(helios::Context *context_ptr, const std::vector<uint> &UUIDs);
 
 
    void updateContextPrimitiveColors();
 
 
    void colorContextPrimitivesByData(const char *data_name);
 
 
    void colorContextPrimitivesByData(const char *data_name, const std::vector<uint> &UUIDs);
 
 
    void colorContextPrimitivesByObjectData(const char *data_name);
 
 
    void colorContextPrimitivesByObjectData(const char *data_name, const std::vector<uint> &ObjIDs);
 
 
    void colorContextPrimitivesRandomly(const std::vector<uint> &UUIDs);
 
 
    void colorContextPrimitivesRandomly();
 
 
    void colorContextObjectsRandomly(const std::vector<uint> &ObjIDs);
 
 
    void colorContextObjectsRandomly();
 
    void hideWatermark();
 
    void showWatermark();
 
    void updateWatermark();
 
    void hideNavigationGizmo();
 
    void showNavigationGizmo();
 
 
    void handleGizmoClick(double screen_x, double screen_y);
 
 
    void handleGizmoHover(double screen_x, double screen_y);
 
    std::vector<helios::vec3> plotInteractive();
 
 
    void plotOnce(bool getKeystrokes);
 
 
    void plotDepthMap();
 
    void plotUpdate();
 
 
    void plotUpdate(bool hide_window);
 
    void printWindow();
 
 
    void printWindow(const char *outfile, const std::string &image_format = "jpeg");
 
    void displayImage(const std::vector<unsigned char> &pixel_data, uint width_pixels, uint height_pixels);
 
    void displayImage(const std::string &file_name);
 
 
    void getWindowPixelsRGB(uint *buffer) const;
 
 
    [[deprecated]]
    void getDepthMap(float *buffer);
 
    void getDepthMap(std::vector<float> &depth_pixels, uint &width_pixels, uint &height_pixels);
 
 
    void getWindowSize(uint &width, uint &height) const;
 
 
    void getFramebufferSize(uint &width, uint &height) const;
 
    void clearGeometry();
 
    void clearContextGeometry();
 
    void closeWindow() const;
 
    [[nodiscard]] helios::RGBcolor getBackgroundColor() const;
 
    [[nodiscard]] std::vector<helios::vec3> getCameraPosition() const;
 
    void clearColor();
 
    [[nodiscard]] void *getWindow() const;
 
    [[nodiscard]] glm::mat4 getPerspectiveTransformationMatrix() const;
 
 
    void setPointCullingEnabled(bool enabled);
 
    void setPointCullingThreshold(size_t threshold);
 
    void setPointMaxRenderDistance(float distance);
 
    void setPointLODFactor(float factor);
 
    void getPointRenderingMetrics(size_t &total_points, size_t &rendered_points, float &culling_time_ms) const;
 
private:
    [[nodiscard]] std::vector<uint> getFrameBufferSize() const;
 
    std::vector<helios::RGBcolor> readOffscreenPixels() const;
 
 
    std::vector<helios::RGBAcolor> readOffscreenPixelsRGBA(bool read_alpha) const;
 
    void setFrameBufferSize(int width, int height);
 
    [[nodiscard]] Shader getPrimaryShader() const;
 
    [[nodiscard]] glm::mat4 getViewMatrix() const;
 
    [[nodiscard]] LightingModel getPrimaryLightingModel();
 
    [[nodiscard]] uint getDepthTexture() const;
 
    void openWindow();
 
    void createOffscreenContext();
 
    void removeBackgroundRectangle();
 
    void setBackgroundGradient();
 
    static void framebufferResizeCallback(GLFWwindow *window, int width, int height);
 
    static void windowResizeCallback(GLFWwindow *window, int width, int height);
 
    void initialize(uint window_width_pixels, uint window_height_pixels, int aliasing_samples, bool window_decorations, bool headless_mode);
 
    void render(bool shadow) const;
 
    void transferBufferData();
 
    void transferTextureData();
 
    [[nodiscard]] uint registerTextureImage(const std::string &texture_file);
 
    [[nodiscard]] uint registerTextureImage(const std::vector<unsigned char> &texture_data, const helios::uint2 &image_resolution);
 
    [[nodiscard]] uint registerTextureTransparencyMask(const std::string &texture_file);
 
    [[nodiscard]] uint registerTextureGlyph(const Glyph *glyph);
 
    [[nodiscard]] helios::uint2 getTextureResolution(uint textureID) const;
 
    //~~~~~~~~~~~~~~~~ Primitives ~~~~~~~~~~~~~~~~~~~~//
 
    std::string colorPrimitivesByObjectData, colorPrimitivesByData;
    std::map<uint, uint> colorPrimitives_UUIDs, colorPrimitives_objIDs;
 
    std::vector<uint> contextUUIDs_build;
 
    std::vector<float> depth_buffer_data;
 
    void getViewKeystrokes(helios::vec3 &eye, helios::vec3 &center);
 
    std::vector<size_t> addColorbarByCenter(const char *title, const helios::vec2 &size, const helios::vec3 &center, const helios::RGBcolor &font_color, const Colormap &colormap);
 
    void updateDepthBuffer();
 
    uint Wdisplay;
    uint Hdisplay;
 
    uint Wframebuffer;
    uint Hframebuffer;
 
    helios::uint2 shadow_buffer_size;
 
    uint frame_counter;
 
    bool buffers_swapped_since_render;
 
 
    void *window;
 
    helios::vec3 camera_lookat_center;
 
    helios::vec3 camera_eye_location;
 
    float minimum_view_radius;
 
    Shader primaryShader;
 
    Shader depthShader;
 
    Shader lineShader;
 
    Shader *currentShader;
 
    uint framebufferID;
    uint depthTexture;
 
    // Offscreen rendering support for CI testing
    uint offscreenFramebufferID;
    uint offscreenColorTexture;
    uint offscreenDepthTexture;
 
    LightingModel primaryLightingModel;
 
    float lightintensity = 1.f;
 
    bool isWatermarkVisible;
 
    size_t watermark_ID;
 
    helios::RGBcolor backgroundColor;
 
    bool background_is_transparent;
 
    bool watermark_was_visible_before_transparent;
 
    bool navigation_gizmo_was_enabled_before_image_display;
 
    size_t background_rectangle_ID;
    std::vector<size_t> background_sky_IDs;
 
    helios::vec3 light_direction;
 
    std::vector<size_t> coordinate_axes_IDs;
 
    bool navigation_gizmo_enabled;
 
    helios::vec3 previous_camera_eye_location;
 
    helios::vec3 previous_camera_lookat_center;
 
    std::vector<size_t> navigation_gizmo_IDs;
 
    int hovered_gizmo_bubble;
 
 
    uint colorbar_flag;
 
    std::string colorbar_title;
 
    uint colorbar_fontsize;
 
    float point_width;
 
    bool point_culling_enabled;
    size_t point_culling_threshold;
    float point_max_render_distance;
    float point_lod_factor;
 
    mutable size_t points_total_count;
    mutable size_t points_rendered_count;
    mutable float last_culling_time_ms;
 
    helios::RGBcolor colorbar_fontcolor;
 
    helios::vec3 colorbar_position;
 
    helios::vec2 colorbar_size;
 
    float colorbar_intended_aspect_ratio;
 
    std::vector<size_t> colorbar_IDs;
 
    std::vector<GLuint> face_index_buffer, vertex_buffer, uv_buffer;
    std::vector<GLuint> color_buffer, normal_buffer, texture_flag_buffer, texture_ID_buffer, coordinate_flag_buffer, sky_geometry_flag_buffer, hidden_flag_buffer;
    std::vector<GLuint> color_texture_object, normal_texture_object, texture_flag_texture_object, texture_ID_texture_object, coordinate_flag_texture_object, sky_geometry_flag_texture_object, hidden_flag_texture_object;
 
    GLuint uv_rescale_buffer;
    GLuint uv_rescale_texture_object;
 
    std::vector<GLint> rectangle_vertex_group_firsts;
    std::vector<GLint> rectangle_vertex_group_counts;
 
    [[nodiscard]] glm::mat4 computeShadowDepthMVP() const;
 
    void updatePerspectiveTransformation(bool shadow);
 
    void cullPointsByFrustum();
    void cullPointsByDistance(float maxDistance, float lodFactor);
    void updatePointCulling();
    std::vector<glm::vec4> extractFrustumPlanes() const;
 
    glm::mat4 perspectiveTransformationMatrix;
 
    glm::mat4 cameraViewMatrix;
    glm::mat4 cameraProjectionMatrix;
 
    void updateCustomTransformation(const glm::mat4 &matrix);
 
    glm::mat4 customTransformationMatrix;
 
    float camera_FOV;
 
    bool build_all_context_geometry = false;
 
    bool primitiveColorsNeedUpdate;
 
    helios::Context *context;
 
    void buildContextGeometry_private();
 
    void updateNavigationGizmo();
 
    void updateColorbar();
 
 
    [[nodiscard]] bool testGizmoBubbleHit(const helios::vec2 &normalized_pos, int bubble_index) const;
 
 
    void reorientCameraToAxis(int axis_index);
 
    [[nodiscard]] bool cameraHasChanged() const;
 
    float colorbar_min;
    float colorbar_max;
    std::vector<float> colorbar_ticks;
    bool colorbar_integer_data;
 
    Colormap colormap_current;
 
    Colormap colormap_hot;
 
    Colormap colormap_cool;
 
    Colormap colormap_lava;
 
    Colormap colormap_rainbow;
 
    Colormap colormap_parula;
 
    Colormap colormap_gray;
 
    Colormap colormap_lines;
 
    bool message_flag;
 
    bool headless;
 
    GeometryHandler geometry_handler;
 
    GLuint texArray;
    size_t texture_array_layers;
    bool textures_dirty;
 
    helios::uint2 maximum_texture_size;
 
    const glm::mat4 biasMatrix = {0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.5, 0.5, 0.5, 1.0};
 
    struct Texture {
 
        explicit Texture(const std::string &texture_file, uint textureID, const helios::uint2 &maximum_texture_size, bool loadalphaonly = false);
 
        explicit Texture(const Glyph *glyph_ptr, uint textureID, const helios::uint2 &maximum_texture_size);
 
        explicit Texture(const std::vector<unsigned char> &pixel_data, uint textureID, const helios::uint2 &image_resolution, const helios::uint2 &maximum_texture_size);
 
        std::string texture_file;
        Glyph glyph;
        helios::uint2 texture_resolution;
        uint textureID;
        std::vector<unsigned char> texture_data;
        unsigned char num_channels;
 
        void resizeTexture(const helios::uint2 &new_image_resolution);
    };
 
    std::unordered_map<uint, Texture> texture_manager;
 
    friend struct Shader;
    friend struct Texture;
};
 
inline glm::vec3 glm_vec3(const helios::vec3 &v) {
    return {v.x, v.y, v.z};
}
 
 
int checkerrors();
 
void check_opengl_errors_safe(const std::string &context);
 
 
#endif