DrawGL.h

// DrawGL.h: interface for the CDrawGL class.
//
// Copyright (c) 2008-2012, Larson Software Technology, Inc.

#if !defined(AFX_DRAWGL_H__56DE0244_F36F_49DC_A5CD_79388C983A87__INCLUDED_)
#define AFX_DRAWGL_H__56DE0244_F36F_49DC_A5CD_79388C983A87__INCLUDED_

#pragma once

//#define POLYGONTESSELATOR

#ifdef POLYGONTESSELATOR
#include "Utility/PolygonTesselator.h"
#endif

#ifdef WIN32
#include <windows.h>
#ifndef OpenGLESv2
#include <GL/gl.h>
#include <GL/glu.h>
#else
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
//#include <GL/glu.h>
#endif
#endif

#ifdef LINUX
#include <GL/glx.h>
typedef struct X11DisplayInfo {
                Display* display;
                Window window;
} X11DisplayInfo;
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>
#endif

#ifdef IOS
#include <OpenGLES/ES2/gl.h>
#include <OpenGLES/ES2/glext.h>
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#ifdef ANDROID
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
//#include <glu.h>
//#include <gluos.h>
#endif

#ifdef EMSCRIPTEN
#include <EGL/egl.h>
#include <GLES/gl.h>
#endif


#include "DrawBase.h"

namespace Larson
{


        class CDrawGL : public CDrawBase  
        {
        public:
#ifndef GLPOINTF
#define GLPOINTF
typedef struct { GLfloat x, y; } GLpointf;
#endif
                enum ExceptionCodes
                {
                        eChoosePixelFmtFailed = EXC_DRAWGL,
                        eSetPixelFormatFailed = EXC_DRAWGL + 1,
                        eCreateContextFailed = EXC_DRAWGL + 2,
                        eMakeCurrentFailed = EXC_DRAWGL + 3
                };
                CDrawGL();                                      
                virtual ~CDrawGL();                     

#ifdef EMSCRIPTEN
                GLuint loadShader(GLenum type, const char *source);
                GLuint buildProgram(GLuint vertexShader, GLuint fragmentShader, int index);
#endif

                void setWorkaround_GL_LINE_LOOP_bug(bool bValue);

                void drawVertexArray(GLenum mode, GLpointf *pPoints, long count);

                void setDisplay(void *pDisplay, void* pOther = 0);

                void open();                    

                void memoryOpen(long width, long height); 
                unsigned char* getBitmap(); 
                unsigned char* getBitmapAt(int x, int y, int w, int h); 

                void SelectRectangle(LPoint downPt, LPoint currPt, bool bDraw);
                void PanScreen(LPoint nOffset, bool bDragging);

                void PreProcess(CCgmObjects*, enum ProcessFlag);
                void PostProcess(CCgmObjects*, enum ProcessFlag);

                void setTransform(DRect *window, DRect *viewport, DRect* clientRect, double rotation, int originFlag);
                void clear();                   
                void flush();                   

                void close();                   

                //void drawRect(CCgmRect *pCgmRect);
                void drawText(CCgmText *pCgmText);
                void drawPoly(CCgmPoly *pCgmPoly);
                void drawCellArray(CCgmCellArray *pCCgmCellArray);
                void drawFigure(CCgmFigure *pCgmFigure);
                void drawPath(CCgmBaseObj *pCgmBaseObj, Path *pPath, bool fill);
                void eraseDCarea(DRect *rect);

        protected:
                void drawDCline(CCgmBaseObj *pCgmBaseObj, DPoint *pCa, long cnt, bool close);

                void drawDCfill(CCgmBaseObj *pCgmBaseObj, DPoint *pCa, long cnt);

                void drawDCdots(CCgmBaseObj *pCgmBaseObj, DPoint *pCa, long cnt);

                long setLineAttr(CCgmBaseObj* pCgmBaseObj);
                long setLineStipple(long width, GLushort pattern);
                long setFillAttr(CCgmBaseObj* pCgmBaseObj, unsigned long rgb);
                long setFillAttr(CCgmBaseObj* pCgmBaseObj);
                long setFillStipple(long flag, unsigned long *stipple = NULL, CColor fore = CColor(0,0,0,255), CColor back = CColor(0,0,0,0));

        public:
                void setColor(CColor color);

                void setMinVisibleText(double minHeight) { m_minVisibleText = minHeight; };

        protected:
                bool applyClipping(CCgmBaseObj*, DRect*);
                void unApplyClipping(CCgmBaseObj*);

                double m_saveScalingFactor;
                double m_scalingFactor;

                double m_minVisibleText;

//              unsigned char* m_pCanvasImage;
                LRect m_selRect;

        public:
                unsigned char* m_mem_pBitmap;

#ifdef  WIN32
                void*           m_pRC;
# ifndef OpenGLESv2
        HDC             m_pDisplay;
# else
                HWND    m_pDisplay;
# endif
#endif
        
#ifdef LINUX
                X11DisplayInfo*         m_pDisplay;
                int   m_screen;
        int   m_depth;
        Visual* m_visual;
        GLXContext m_context;
#endif

#ifdef IOS
        // IOS
#endif

#if defined(EMSCRIPTEN) || defined(ANDROID) || defined(OpenGLESv2)
#  if defined(EMSCRIPTEN) || defined(ANDROID_GLES2) || defined(OpenGLESv2)

#       define SOLID_SHADER 0
#       define TEX_SHADER 1

#    if defined(ANDROID_ALLNATIVE) || defined(OpenGLESv2) || defined(EMSCRIPTEN)
                EGLint m_eglError;

                EGLDisplay m_eglDisplay;
            EGLContext m_eglContext;
                EGLSurface m_eglSurface;
            EGLint m_eglWidth;
                EGLint m_eglHeight;
#    endif

#  endif
                GLuint m_textures[1];
                GLfloat m_gl2Matrix[16];
                GLfloat m_gl2Color[4];
#endif

                bool m_bUseTexture;

                long m_tessFlag;
#ifndef ANDROID_GLUTESSELATOR_VOIDP
#ifdef POLYGONTESSELATOR
                void *m_tessObj;
#else
                GLUtesselator *m_tessObj;
#endif
#else
                void *m_tessObj;
#endif

                bool m_workaround_GL_LINE_LOOP_bug;

                long m_currentProgram;

                GLfloat m_psRange[2];
                GLfloat m_lwRange[2];

                int m_canvasWidth;
                int m_canvasHeight;
                int m_canvasID;

                GLsizei m_mem_glWidth;
                GLsizei m_mem_glHeight;
                GLuint m_mem_framebuffer;
                GLuint m_mem_colorRenderbuffer;
                GLuint m_mem_depthRenderbuffer;

#ifdef _DEBUG
                void checkGLError(char*, int, char*);
#endif

                int m_masterClipStatus; // -1 = not set, 0 = set, no valid intersection, 1 = set, valid intersection
                DRect m_masterClipRect;
        };

#if defined(ANDROID) && defined(WANT_C_API)
        extern "C" {
                typedef struct c_CDrawGL c_CDrawGL;

                inline CDrawGL* realCDrawGL(c_CDrawGL* p) { return (CDrawGL*)p; };

                c_CDrawGL* new_CDrawGL() { return (c_CDrawGL*)(new CDrawGL()); };

                void open_CDrawGL(c_CDrawGL* p) { realCDrawGL(p)->open(); };

                void bgColorFromObjects_CDrawBase(c_CDrawGL *p, c_CCgmObjects *pObj)
                { ((CDrawBase*)p)->m_backgroundColor = ((CCgmObjects*)pObj)->m_backgroundColor; };

                void clear_CDrawGL(c_CDrawGL* p) { realCDrawGL(p)->clear(); };

                void flush_CDrawGL(c_CDrawGL* p) { realCDrawGL(p)->flush(); };

                void close_CDrawGL(c_CDrawGL* p) { realCDrawGL(p)->close(); };

                void delete_CDrawGL(c_CDrawGL* p) { delete realCDrawGL(p); };

                void setTransform_CDrawGL(c_CDrawGL *p, c_DRect *window, c_DRect *viewport, c_DRect *clientRect,
                        double rotation, int originFlag)
                { realCDrawGL(p)->setTransform((DRect*)window, (DRect*)viewport, (DRect*)clientRect,
                        rotation, originFlag); };

                void setMinMarkerSize_CDrawGL(c_CDrawGL *p, double s)
                { realCDrawGL(p)->m_dMinMarkerSize = s; };
        };
#endif
};
#endif // !defined(AFX_DRAWGL_H__56DE0244_F36F_49DC_A5CD_79388C983A87__INCLUDED_)