CGraphicsGL.hpp

Go to the documentation of this file.

#ifndef LIBS_OPENGL_CGRAPHICSGL_HPP_
#define LIBS_OPENGL_CGRAPHICSGL_HPP_
 
#include "core/types.hpp"
#include "resources/ImageResource.hpp"
#include "ui/cairo/CFontManagerCairo.hpp"
#include "ui/graphics/IGraphics.hpp"
#include "ui/graphics/Material.hpp"
#include "ui/openGL/CTextureGL.hpp"
 
#include <GL/glu.h>
#include <bits/stdint-uintn.h>
#include <list>
#include <map>
#include <string>
#include <utility>
 
class CGraphicsGL final : public IGraphics
{
public:
    CGraphicsGL();
    ~CGraphicsGL() override;
 
    void removeBlocksRegisters();
    void initImage(std::shared_ptr<IImageManager> &&imageManager);
 
    static void setModeTransparency();
    static void setModeOpaque();
 
private:
    void setBackGroundColor(iv::types::color rgb) override;
    void setClearColor() override;
    void initDevice() override;
 
    void initLight() override;
 
    void clear() override;
 
    void defineMaterial(const iv::ui::graphics::Material *material, const bool &isChanged) override;
    bool isDefinedMaterial(const std::string &materialName) override;
    void pushMaterial() override;
    void setMaterial(const std::string &materialName) override;
    void popMaterial() override;
 
    void setColorRGB(iv::types::color rgb) override;
    void setColorARGB(iv::types::color argb) override;
    void setLineWidth(float width) override;
    void setAlpha(float alpha) override;
    void resetAlpha() override;
 
    void setOnTexture(bool enableTexture) override;
    std::shared_ptr<iv::ui::graphics::Image> loadImage(const iv::ui::resources::ImageResource &resource) override;
 
    void appendMatrix(const CMatrix4x4 &matrix) override;
    void setModelMatrix(IGraphics::EMatrixModel matrixModel) override;
 
    void popTransformation() override;
    void pushTransformation() override;
    void resetTransformation() override;
 
    void defineLight(IGraphics::ELight light, IGraphics::ELightType lightType, double rColor, double gColor,
                     double bColor) override;
    void positionLight(IGraphics::ELight light, double x, double y, double z) override;
 
    void viewport(int32_t x, int32_t y, uint64_t sizeX, uint64_t sizeY) override;
 
    void definePerspective(double fovy, double ratioXForY, double zNear, double zFar) override;
    void defineOrthogonal(double xOrg, double yOrg, double zOrg, double xMin, double yMin, double zMin, double xMax,
                          double yMax, double zMax) override;
    void positionCamera(double eyeX, double eyeY, double eyeZ, double pointReferenceX, double pointReferenceY,
                        double pointReferenceZ, double upX, double upY, double upZ) override;
 
    void rotation(double angleDegrees, double Ux, double Uy, double Uz) override;
    void scale(double sx, double sy, double sz) override;
    void setNormal(double Nx, double Ny, double Nz) override;
    void translation(double tx, double ty, double tz) override;
 
    void drawContours(const std::vector<std::shared_ptr<std::vector<iv::math::geometry::Point3d>>> &contours) override;
    void drawFanTriangles(const float *points, const float *normals, const float *textureOpt, const float *rgbaOpt,
                          uint64_t numPoints, const uint32_t *indVertex, uint64_t numVertex) override;
    void drawImage(double x, double y, double width, double height,
                   const iv::ui::resources::ImageResource &resource) override;
    void drawImageRawSize(double x, double y, const iv::ui::resources::ImageResource &resource) override;
    void drawImageWithColor(double x, double y, iv::types::color colorRGB, double width, double height,
                            const iv::ui::resources::ImageResource &resource) override;
    void drawLine(double x1, double y1, double z1, double x2, double y2, double z2) override;
    void drawLineWithStyle(double x1, double y1, double z1, double x2, double y2, double z2,
                           IGraphics::EDashedLineType dashedLineType) override;
    void drawArc(double radiusMark, iv::types::radian angleInitial, iv::types::radian angleFinal, float thickness,
                 uint64_t kPrvNumPoints) override;
    void drawPolyline(const float *vertex, uint64_t numVertex) override;
    void drawPolylineFilled(const float *vertex, uint64_t numVertex) override;
    void drawPolylinesWithColors(const std::shared_ptr<std::vector<iv::math::geometry::Point2d>> &points,
                                 const std::vector<iv::math::geometry::Point3d> &rgb) override;
    void drawQuads(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3,
                   double x4, double y4, double z4) override;
    void drawRect(double x1, double y1, double x2, double y2) override;
    void drawRectFilled(double x1, double y1, double x2, double y2) override;
    void drawStripTriangles(const float *points, const float *normals, const float *textureOpt, const float *rgbaOpt,
                            uint64_t numPoints, const uint32_t *indVertex, uint64_t numVertex) override;
    void drawText(const std::string &text, double x, double y, double height, unsigned char justify) override;
    void drawTextWithDeviceHeight(const std::string &text, double x, double y, double height,
                                  unsigned char justify) override;
    void drawTriangle(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3,
                      double z3) override;
    void drawTriangles(const float *points, const float *normals, const float *textureOpt, const float *rgbaOpt,
                       uint64_t numPoints, const uint32_t *indVertex, uint64_t numVertex) override;
    void drawUnitCone(IGraphics::EDetailLevel detailLevel) override;
    void drawUnitCube() override;
    void drawUnitCylinder(IGraphics::EDetailLevel detailLevel) override;
    void drawUnitDisk(IGraphics::EDetailLevel detailLevel) override;
    void drawUnitSphere(IGraphics::EDetailLevel detailLevel) override;
    [[nodiscard]] bool hasDrawPolylineFilled() const override;
    void setModeDraw(IGraphics::EDrawSolidType drawSolidType) override;
 
    uint32_t blockTextWithModifiers(const std::string &text, const iv::ui::TextModifier &textModifier,
                                    double *widthText, double *heightTextOut) override;
    void drawBlockText(uint32_t idBlockText, double x, double y, double widthText, double heightText,
                       unsigned char justify) override;
    void endBlockText(uint32_t *idBlockText) override;
    [[nodiscard]] bool hasBlockText() const override;
 
    uint32_t beginBlock() override;
    void drawBlock(uint32_t idBlock) override;
    void endBlock(uint32_t idBlock) override;
    [[nodiscard]] bool hasManagerBlocks() const override;
    void removeBlock(uint32_t *idBlock) override;
 
    void beginStencilBuffer() override;
    void endStencilBuffer() override;
    void offStencilBuffer() override;
    void onStencilBuffer() override;
 
    void getCoordTextCornerLeftDown(const std::string &text, double x, double y, double heightCharacter,
                                    unsigned char justify, double *xCornerLeftDown, double *yCornerLeftDown,
                                    double *widthTextOpt, double *heightTextOpt) override;
    void getSizePixelToWorld(double sizePixelX, double sizePixelY, double *sizeWorldXOpt,
                             double *sizeWorldYOpt) override;
    void getSizeText(const std::string &text, double heightCharacter, double *widthText, double *heightText) override;
 
    void setBlend(bool isEnable) override;
    void setTestDepth(bool isEnable) override;
 
public:
    struct SPrvTextBlockGL
    {
        SPrvTextBlockGL(std::string text, double heightFont, iv::ui::eTextWeight weightFont, double widthText,
                        double heightText, uint32_t idB, uint64_t numR)
        {
            m_text = std::move(text);
            m_heightFont = heightFont;
            m_weightFont = weightFont;
            m_widthText = widthText;
            m_heightText = heightText;
            m_idBlock = idB;
            m_numRef = static_cast<uint32_t>(numR);
        }
 
        ~SPrvTextBlockGL()
        {
            CTextureGL::destroyTexture(&m_idBlock);
        }
 
        std::string m_text;
        double m_heightFont;
        iv::ui::eTextWeight m_weightFont;
 
        double m_widthText;
        double m_heightText;
        uint32_t m_idBlock;
        uint32_t m_numRef;
    };
 
private:
    struct SPrvColor
    {
        SPrvColor(const std::string &currentLayer, bool isColorByLayer, uint32_t currentColorARGB)
        {
            m_currentLayer = currentLayer;
            m_isColorByLayer = isColorByLayer;
            m_currentColorARGB = currentColorARGB;
        }
 
        explicit SPrvColor(const SPrvColor &color)
        {
            m_currentLayer = color.m_currentLayer;
            m_isColorByLayer = color.m_isColorByLayer;
            m_currentColorARGB = color.m_currentColorARGB;
        }
 
        ~SPrvColor() = default;
 
        std::string m_currentLayer;
        bool m_isColorByLayer;
        iv::types::color m_currentColorARGB;
    };
 
    struct SPrvImageLoaded
    {
        SPrvImageLoaded(const std::string &nameResource, uint32_t idTexture)
        {
            m_nameResource = nameResource;
            m_textureId = idTexture;
        }
 
        ~SPrvImageLoaded()
        {
            CTextureGL::destroyTexture(&m_textureId);
        }
 
        std::string m_nameResource;
        uint32_t m_textureId;
    };
 
public:
    struct SPrvLayer
    {
        SPrvLayer(iv::ui::graphics::Material **material_param, uint32_t idTexture_param);
        ~SPrvLayer();
 
        uint32_t m_textureId;
        iv::ui::graphics::Material *m_material;
    };
 
    struct TextureInfo
    {
        iv::types::width width {0};
        iv::types::height height {0};
 
        bool operator<(const TextureInfo &other) const
        {
            return width < other.width or (width == other.width and height < other.height);
        }
    };
 
private:
    void prvDrawImageWithColor(double xCornerLeftDown, double yCornerLeftDown, iv::types::color colorRGB,
                               std::optional<double> width, std::optional<double> height,
                               const iv::ui::resources::ImageResource &resource);
    bool prvExistImage(const iv::ui::resources::ImageResource &resource, uint64_t *ind) const;
 
    std::vector<std::shared_ptr<SPrvLayer>> m_layers;
    std::vector<std::shared_ptr<SPrvColor>> m_stackLayers;
    std::vector<std::shared_ptr<SPrvImageLoaded>> m_imagesLoaded;
    std::vector<std::shared_ptr<SPrvTextBlockGL>> m_textLoaded;
    std::shared_ptr<SPrvColor> m_currentColor;
 
    bool m_hasAlpha;
    float m_alphaCurrent;
 
    bool m_isCameraPositioned;
    bool m_activeLight0;
 
    bool m_isBeginStencil;
    uint16_t m_indActiveStencil;
 
    CFontManagerCairo *m_fontManager;
    std::shared_ptr<IImageManager> m_imageManager;
 
    GLUtesselator *m_tesselator;
    GLUquadricObj *m_quadruple;
 
    float m_rBackground;
    float m_bBackground;
    float m_gBackground;
    float m_aBackground;
 
    uint32_t m_idBlockCurrent;
    //std::vector<uint32_t> *m_idsBlocksRegisters; NO se usa realmente
 
    std::map<TextureInfo, std::list<iv::types::textureId>> m_unusedCreatedTexturesList;
    std::map<iv::types::textureId, TextureInfo> m_usingTextures;
 
    uint32_t m_idTextureText;
};
 
#endif /* LIBS_OPENGL_CGRAPHICSGL_HPP_ */