GfxWrapGL.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef GFXWRAPGL__H_
#define GFXWRAPGL__H_
 
#include "GfxWrap.h"
 
#include "GL_API_Mappings.h"
 
#include "GUIImageDataGL.h"
#include "GUIConfigDebug.h"
 
#ifdef GUILIANI_GFXOGLDEBUG
#define CHECK_GL_ERROR(a)   CGfxWrapGL::CheckGLError(__FUNCTION__, a);
#else
#define CHECK_GL_ERROR(a)
#endif
 
class CGfxWrapGLShader
{
public:
    CGfxWrapGLShader();
 
    ~CGfxWrapGLShader();
 
    eC_Bool Load(const char* cVertexShader, const char* cFragmentShader);
 
    eC_UInt GetShaderID() const { return m_uiShaderProgramID; }
 
    void Activate() const;
 
private:
    eC_UInt m_uiVertexShaderHandle;
    eC_UInt m_uiFragmentShaderHandle;
    eC_UInt m_uiShaderProgramID;
};
 
 
class CGfxWrapGL : public CGfxWrap
{
    friend class CGUIBitmapPlane_GL; 
 
public:
    static const  eC_Value cvPixelCenterOffset;
 
    void CreateScreen(const eC_UInt &uiWidth, const eC_UInt &uiHeight);
 
    virtual eC_UInt GetVirtualScreenWidth();
    virtual eC_UInt GetPhysicalScreenWidth();
    virtual eC_UInt GetVirtualScreenHeight();
    virtual eC_UInt GetPhysicalScreenHeight();
    virtual void SetScreenSize(const eC_UInt &uiWidth, const eC_UInt &uiHeight);
 
    virtual void StoreWrapperState();
    virtual void RestoreWrapperState();
 
    virtual void SetForegroundColorImpl(
        const eC_UByte &ubRed,
        const eC_UByte &ubGreen,
        const eC_UByte &ubBlue,
        const eC_UByte& ubAlpha = 255);
 
    virtual eC_Value SetLineWidth(const eC_Value& vWidth);
 
    virtual void Line(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2);
 
    virtual void Rect(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2);
 
    virtual void FilledRect(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2);
 
    virtual void Ellipse(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2,
        const eC_Bool &bFilled);
 
    virtual void Arc(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2,
        const eC_Value& vStartAngle,
        const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool &bFilled);
 
    virtual void Ring(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2,
        const eC_Value& vRingWidth,
        const eC_Value& vStartAngle,
        const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool & bFilled);
 
    virtual void Polygon(
        eC_Value* pvPoints,
        const eC_UInt& uiCount,
        const eC_Bool& bFilled);
 
    // ---------------------------------------------------------------
    // Clipping and invalidated rectangles
    // ---------------------------------------------------------------
 
    virtual void SetCliprect(const CGUIRect &rkNewClipRect);
 
    virtual eC_Bool ImageExists(const ImageResource_t eID) const;
 
    CGUIImageDataGL* GetImageData(const ImageResource_t &eImageID);
 
    void Set2DView();
 
    void Set2DView(const eC_UInt uiWidth, const eC_UInt uiHeight);
 
    static eC_Bool CheckGLError(const eC_String& kCallingMethod, const eC_String& kFunction = "");
 
    virtual eC_Bool DrawToBitmap(GUIBitmapPlaneID_t uiBitmapID);
 
    virtual eC_Bool DrawToScreen();
 
    const eC_UInt GetTextureID(const ImageResource_t &eImageID);
 
    void SetPerspectiveProjection(
        const eC_Value& vFovy,
        const eC_Value& vAspect,
        const eC_Value& vNear,
        const eC_Value& vFar);
 
    virtual eC_Bool InitView();
 
    inline eC_UInt GetVBO() const
    {
        return m_uiVertexVBO;
    }
 
#if defined (GUILIANI_USE_OGL) && !defined (SYSTEM_NAME_DARWIN)
    static PFNGLBINDBUFFERPROC              glBindBuffer_Guiliani;
    static PFNGLBUFFERDATAPROC              glBufferData_Guiliani;
    static PFNGLGENBUFFERSPROC              glGenBuffers_Guiliani;
    static PFNGLDELETEBUFFERSPROC           glDeleteBuffers_Guiliani;
 
    static PFNGLGENFRAMEBUFFERSPROC         glGenFramebuffers_Guiliani;
    static PFNGLBINDFRAMEBUFFERPROC         glBindFramebuffer_Guiliani;
    static PFNGLFRAMEBUFFERTEXTURE2DPROC    glFramebufferTexture2D_Guiliani;
    static PFNGLCHECKFRAMEBUFFERSTATUSPROC  glCheckFramebufferStatus_Guiliani;
    static PFNGLDELETEFRAMEBUFFERSPROC      glDeleteFramebuffers_Guiliani;
 
#if GUILIANI_USE_GL_SHADERS == 1
    static PFNGLBLENDEQUATIONSEPARATEPROC   glBlendEquationSeparate_Guiliani;
    static PFNGLDRAWBUFFERSPROC             glDrawBuffers_Guiliani;
    static PFNGLSTENCILOPSEPARATEPROC       glStencilOpSeparate_Guiliani;
    static PFNGLSTENCILFUNCSEPARATEPROC     glStencilFuncSeparate_Guiliani;
    static PFNGLSTENCILMASKSEPARATEPROC     glStencilMaskSeparate_Guiliani;
    static PFNGLATTACHSHADERPROC            glAttachShader_Guiliani;
    static PFNGLBINDATTRIBLOCATIONPROC      glBindAttribLocation_Guiliani;
    static PFNGLCOMPILESHADERPROC           glCompileShader_Guiliani;
    static PFNGLCREATEPROGRAMPROC           glCreateProgram_Guiliani;
    static PFNGLCREATESHADERPROC            glCreateShader_Guiliani;
    static PFNGLDELETEPROGRAMPROC           glDeleteProgram_Guiliani;
    static PFNGLDELETESHADERPROC            glDeleteShader_Guiliani;
    static PFNGLDETACHSHADERPROC            glDetachShader_Guiliani;
    static PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray_Guiliani;
    static PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray_Guiliani;
    static PFNGLGETACTIVEATTRIBPROC         glGetActiveAttrib_Guiliani;
    static PFNGLGETACTIVEUNIFORMPROC        glGetActiveUniform_Guiliani;
    static PFNGLGETATTACHEDSHADERSPROC      glGetAttachedShaders_Guiliani;
    static PFNGLGETATTRIBLOCATIONPROC       glGetAttribLocation_Guiliani;
    static PFNGLGETPROGRAMIVPROC            glGetProgramiv_Guiliani;
    static PFNGLGETPROGRAMINFOLOGPROC       glGetProgramInfoLog_Guiliani;
    static PFNGLGETSHADERIVPROC             glGetShaderiv_Guiliani;
    static PFNGLGETSHADERINFOLOGPROC        glGetShaderInfoLog_Guiliani;
    static PFNGLGETSHADERSOURCEPROC         glGetShaderSource_Guiliani;
    static PFNGLGETUNIFORMLOCATIONPROC      glGetUniformLocation_Guiliani;
    static PFNGLGETUNIFORMFVPROC            glGetUniformfv_Guiliani;
    static PFNGLGETUNIFORMIVPROC            glGetUniformiv_Guiliani;
    static PFNGLGETVERTEXATTRIBDVPROC       glGetVertexAttribdv_Guiliani;
    static PFNGLGETVERTEXATTRIBFVPROC       glGetVertexAttribfv_Guiliani;
    static PFNGLGETVERTEXATTRIBIVPROC       glGetVertexAttribiv_Guiliani;
    static PFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv_Guiliani;
    static PFNGLISPROGRAMPROC               glIsProgram_Guiliani;
    static PFNGLISSHADERPROC                glIsShader_Guiliani;
    static PFNGLLINKPROGRAMPROC             glLinkProgram_Guiliani;
    static PFNGLSHADERSOURCEPROC            glShaderSource_Guiliani;
    static PFNGLUSEPROGRAMPROC              glUseProgram_Guiliani;
    static PFNGLUNIFORM1FPROC               glUniform1f_Guiliani;
    static PFNGLUNIFORM2FPROC               glUniform2f_Guiliani;
    static PFNGLUNIFORM3FPROC               glUniform3f_Guiliani;
    static PFNGLUNIFORM4FPROC               glUniform4f_Guiliani;
    static PFNGLUNIFORM1IPROC               glUniform1i_Guiliani;
    static PFNGLUNIFORM2IPROC               glUniform2i_Guiliani;
    static PFNGLUNIFORM3IPROC               glUniform3i_Guiliani;
    static PFNGLUNIFORM4IPROC               glUniform4i_Guiliani;
    static PFNGLUNIFORM1FVPROC              glUniform1fv_Guiliani;
    static PFNGLUNIFORM2FVPROC              glUniform2fv_Guiliani;
    static PFNGLUNIFORM3FVPROC              glUniform3fv_Guiliani;
    static PFNGLUNIFORM4FVPROC              glUniform4fv_Guiliani;
    static PFNGLUNIFORM1IVPROC              glUniform1iv_Guiliani;
    static PFNGLUNIFORM2IVPROC              glUniform2iv_Guiliani;
    static PFNGLUNIFORM3IVPROC              glUniform3iv_Guiliani;
    static PFNGLUNIFORM4IVPROC              glUniform4iv_Guiliani;
    static PFNGLUNIFORMMATRIX2FVPROC        glUniformMatrix2fv_Guiliani;
    static PFNGLUNIFORMMATRIX3FVPROC        glUniformMatrix3fv_Guiliani;
    static PFNGLUNIFORMMATRIX4FVPROC        glUniformMatrix4fv_Guiliani;
    static PFNGLVALIDATEPROGRAMPROC         glValidateProgram_Guiliani;
    static PFNGLVERTEXATTRIB1DPROC          glVertexAttrib1d_Guiliani;
    static PFNGLVERTEXATTRIB1DVPROC         glVertexAttrib1dv_Guiliani;
    static PFNGLVERTEXATTRIB1FPROC          glVertexAttrib1f_Guiliani;
    static PFNGLVERTEXATTRIB1FVPROC         glVertexAttrib1fv_Guiliani;
    static PFNGLVERTEXATTRIB1SPROC          glVertexAttrib1s_Guiliani;
    static PFNGLVERTEXATTRIB1SVPROC         glVertexAttrib1sv_Guiliani;
    static PFNGLVERTEXATTRIB2DPROC          glVertexAttrib2d_Guiliani;
    static PFNGLVERTEXATTRIB2DVPROC         glVertexAttrib2dv_Guiliani;
    static PFNGLVERTEXATTRIB2FPROC          glVertexAttrib2f_Guiliani;
    static PFNGLVERTEXATTRIB2FVPROC         glVertexAttrib2fv_Guiliani;
    static PFNGLVERTEXATTRIB2SPROC          glVertexAttrib2s_Guiliani;
    static PFNGLVERTEXATTRIB2SVPROC         glVertexAttrib2sv_Guiliani;
    static PFNGLVERTEXATTRIB3DPROC          glVertexAttrib3d_Guiliani;
    static PFNGLVERTEXATTRIB3DVPROC         glVertexAttrib3dv_Guiliani;
    static PFNGLVERTEXATTRIB3FPROC          glVertexAttrib3f_Guiliani;
    static PFNGLVERTEXATTRIB3FVPROC         glVertexAttrib3fv_Guiliani;
    static PFNGLVERTEXATTRIB3SPROC          glVertexAttrib3s_Guiliani;
    static PFNGLVERTEXATTRIB3SVPROC         glVertexAttrib3sv_Guiliani;
    static PFNGLVERTEXATTRIB4NBVPROC        glVertexAttrib4Nbv_Guiliani;
    static PFNGLVERTEXATTRIB4NIVPROC        glVertexAttrib4Niv_Guiliani;
    static PFNGLVERTEXATTRIB4NSVPROC        glVertexAttrib4Nsv_Guiliani;
    static PFNGLVERTEXATTRIB4NUBPROC        glVertexAttrib4Nub_Guiliani;
    static PFNGLVERTEXATTRIB4NUBVPROC       glVertexAttrib4Nubv_Guiliani;
    static PFNGLVERTEXATTRIB4NUIVPROC       glVertexAttrib4Nuiv_Guiliani;
    static PFNGLVERTEXATTRIB4NUSVPROC       glVertexAttrib4Nusv_Guiliani;
    static PFNGLVERTEXATTRIB4BVPROC         glVertexAttrib4bv_Guiliani;
    static PFNGLVERTEXATTRIB4DPROC          glVertexAttrib4d_Guiliani;
    static PFNGLVERTEXATTRIB4DVPROC         glVertexAttrib4dv_Guiliani;
    static PFNGLVERTEXATTRIB4FPROC          glVertexAttrib4f_Guiliani;
    static PFNGLVERTEXATTRIB4FVPROC         glVertexAttrib4fv_Guiliani;
    static PFNGLVERTEXATTRIB4IVPROC         glVertexAttrib4iv_Guiliani;
    static PFNGLVERTEXATTRIB4SPROC          glVertexAttrib4s_Guiliani;
    static PFNGLVERTEXATTRIB4SVPROC         glVertexAttrib4sv_Guiliani;
    static PFNGLVERTEXATTRIB4UBVPROC        glVertexAttrib4ubv_Guiliani;
    static PFNGLVERTEXATTRIB4UIVPROC        glVertexAttrib4uiv_Guiliani;
    static PFNGLVERTEXATTRIB4USVPROC        glVertexAttrib4usv_Guiliani;
    static PFNGLVERTEXATTRIBPOINTERPROC     glVertexAttribPointer_Guiliani;
#endif
 
#endif
 
    void InitGLProcs();
 
#if GUILIANI_USE_GL_SHADERS == 1
    eC_Bool InitShaders();
 
    void MultMatrix(const Matrix3D_t& avMatrix);
 
    void SetOrthoProjection(const eC_Value& vLeft, const eC_Value& vRight,
        const eC_Value& vBottom, const eC_Value& vTop,
        const eC_Value& vNear, const eC_Value& vFar);
 
    void SetFrustumProjection(const eC_Value& vLeft, const eC_Value& vRight,
        const eC_Value& vBottom, const eC_Value& vTop,
        const eC_Value& vNear, const eC_Value& vFar);
 
    void SetRotation(const eC_Value& vDegrees, eC_Value vX, eC_Value vY, eC_Value vZ);
 
    void SetTranslation(const eC_Value& vXTranslate, const eC_Value& vYTranslate, const eC_Value& vZTranslate);
 
    void SetScaling(const eC_Value& vXScale, const eC_Value vYScale, const eC_Value vZScale);
 
    void SetUniformScaling(const eC_Value& vScale);
 
    eC_UInt GetShaderID() const;
 
    void SetMatrix(const Matrix3D_t& avNewMatrix);
 
    const Matrix3D_t& GetMatrix() const;
 
    void PushMatrix();
 
    void PopMatrix();
 
    enum MatrixType_t
    {
        MT_PROJECTION,
        MT_MODELVIEW
    };
 
    inline void SetMatrixMode(const MatrixType_t& eNewActiveMatrix)
    {
        m_eActiveMatrix = eNewActiveMatrix;
    }
 
    void LoadIdentity();
 
#endif //#if GUILIANI_USE_GL_SHADERS == 1
 
    eC_Bool IsFBOSupported() const { return m_bFBOSupported; }
 
    void SetClientStates(
        const eC_Bool& bVertexEnabled,
        const eC_Bool& bTextureCoordsEnabled);
 
    void BindBuffer(const eC_UInt& eType, const eC_UInt& uiBuffer);
 
    void BindTexture(const eC_UInt& eType, const eC_UInt& uiTextureID);
 
    void SetTexturingActive(const eC_Bool& bTexturingActive);
 
    void SetMixTextureWithColor(const eC_Bool& bMixWithColor);
 
    eC_UInt CreateTexture();
 
    void DeleteTexture(const eC_UInt& uiTextureID);
 
    virtual void ReadTextureData(
        const eC_UInt& uiTexID,
        const eC_UInt& uiXPos, const eC_UInt& uiYPos,
        const eC_UInt& uiWidth, const eC_UInt& uiHeight, void* pkData) = 0;
 
    void EnableBlending();
 
    void DisableBlending();
 
protected:
    // ---------------------------------------------------------------
    // Construction / destruction
    // ---------------------------------------------------------------
 
    virtual ~CGfxWrapGL(void);
 
    CGfxWrapGL(void);
 
    virtual CGUIBitmapPlane* CreateGfxDependentBitmap(
        GUIBitmapPlaneID_t uiNewBitmapID,
        const CGUIObject& rkParentObject,
        const eC_Value& vWidth, const eC_Value& vHeight);
 
    virtual void RestoreBackBuffer(const eC_Value vWidth, const eC_Value vHeight);
 
    virtual void LoadImgImpl(const eC_String& psPath, const ImageResource_t &eID);
 
    virtual void LoadImgImpl(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& eImageType,
        const ImageResource_t &eID);
 
    virtual void UnloadImg(const ImageResource_t &eID);
 
    eC_Bool SetNOFImagesImpl(const eC_UInt uiNOFImages);
 
    virtual void BlitImgExtImpl(
        const ImageResource_t &eID,
        const eC_UInt &uiSrcX, const eC_UInt &uiSrcY,
        const eC_UInt &uiSrcWidth, const eC_UInt &uiSrcHeight,
        const eC_Value& vDestX, const eC_Value& vDestY,
        const eC_Value& vDestWidth, const eC_Value& vDestHeight,
        const eC_UByte &ubAlpha = 255,
        const eC_Value& vAngle = eC_FromFloat(0),
        const eC_Value& vRotCenterX = eC_FromFloat(0.5), const eC_Value& vRotCenterY = eC_FromFloat(0.5));
 
    virtual void BlitImgExtImpl(const CGUIImageData& kImageData, const eC_Value& vAbsDestX, const eC_Value& vAbsDestY) {}
 
    virtual void BlitImgNinePatch(
        const ImageResource_t &eID,
        const CGUIRect& kAbsRect,
        const eC_UInt uiTopBorder,
        const eC_UInt uiBottomBorder,
        const eC_UInt uiLeftBorder,
        const eC_UInt uiRightBorder,
        const eC_UByte &ubAlpha);
 
    void BlitNinePatchExt();
 
    virtual eC_UInt GetImgWidthImpl(const ImageResource_t &eID) const;
 
    virtual eC_UInt GetImgHeightImpl(const ImageResource_t &eID) const;
 
    virtual eC_UInt GetImageSize(const ImageResource_t& eID) const;
 
    void DrawRect(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2,
        const eC_Bool bFilled);
 
    void GenerateTexture(const ImageResource_t &eImageID);
 
    eC_Value GetZCorrection();
 
    void IncreaseZCorrection();
 
    void SetCliprect(const CGUIRect &rkNewClipRect, const eC_Bool &bRotate);
 
    void Init(void);
 
    void DeInit(void);
 
    void SetScissor(
        const eC_Bool& bEnabled,
        const eC_Int& iX = 0,
        const eC_Int& iY = 0,
        const eC_Int& iWidth = 0,
        const eC_Int& iHeight = 0
    );
 
protected:
    eC_Value m_vRed; 
    eC_Value m_vGreen; 
    eC_Value m_vBlue; 
    eC_Value m_vAlpha; 
 
    eC_TArray<CGUIImageDataGL*> m_apTextures; 
 
    eC_Value m_vDepthCorrection; 
 
    Matrix3D_t m_avTransMat;
 
    eC_Value m_vFovy; 
    eC_Value m_vAspect; 
    eC_Value m_vNear; 
    eC_Value m_vFar; 
 
    eC_UInt m_uiVertexVBO;
 
#if GUILIANI_USE_GL_SHADERS == 1
    Matrix3D_t m_avProjectionMatrix;
 
    Matrix3D_t m_avModelviewMatrix;
 
    eC_TListDoubleLinked<Matrix3D_t*> m_kModelviewMatrixStack;
 
    eC_TListDoubleLinked<Matrix3D_t*> m_kProjectionMatrixStack;
 
    CGfxWrapGLShader* m_pkShader;
 
    MatrixType_t m_eActiveMatrix;
 
    eC_Int m_iLocTextureEnvMode; 
    eC_Int m_iLocTexSampler; 
    eC_Int m_iLocModelViewMatrix; 
    eC_Int m_iLocProjectionMatrix; 
    eC_Int m_iLocMix; 
#endif //#if GUILIANI_USE_GL_SHADERS == 1
 
    eC_Bool m_bFBOSupported;
 
private:
    eC_Bool m_bVertexEnabled;
    eC_Bool m_bTextureCoordsEnabled;
 
    eC_UInt m_uiCurrentlyBoundBuffer;
 
    eC_UInt m_uiCurrentlyBoundTexture;
 
    eC_Bool m_bTexturingActive;
 
    struct BlitRecord_t
    {
        void Reset()
        {
            bActive = false;
        }
 
        eC_Bool bActive;
        eC_UInt uiSrcX;
        eC_UInt uiSrcY;
        eC_UInt uiSrcWidth;
        eC_UInt uiSrcHeight;
        eC_Value vDestX;
        eC_Value vDestY;
        eC_Value vDestWidth;
        eC_Value vDestHeight;
    };
 
    struct NinePatchBlit_t
    {
        void Reset()
        {
            eImageID = DUMMY_IMAGE;
            for (eC_UByte index = 0; index < 9; ++index)
                kCoords[index].Reset();
            ubAlpha = 0;
        }
 
        ImageResource_t eImageID;
        BlitRecord_t kCoords[9];
        eC_UByte ubAlpha;
    };
 
    NinePatchBlit_t m_kBlits;
 
    // scissoring
    eC_Bool m_bScissorEnabled;
    eC_Int m_iScissorX;
    eC_Int m_iScissorY;
    eC_Int m_iScissorWidth;
    eC_Int m_iScissorHeight;
};
 
#endif