LayerManagerPlugins/Renderers/Graphic/include/GraphicSystems/GLESGraphicSystem.h

   1 /***************************************************************************
   2  *
   3  * Copyright 2010,2011 BMW Car IT GmbH
   4  * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
   5  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   6  *
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *        http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  ****************************************************************************/
  21
  22 #ifndef _GLESGRAPHICSYSTEM_H_
  23 #define _GLESGRAPHICSYSTEM_H_
  24
  25 #include "GraphicSystems/BaseGraphicSystem.h"
  26 #include "ShaderProgramFactory.h"
  27 #include "EGL/egl.h"
  28 #include "Log.h"
  29 #include "Shader.h"
  30
  31 class IlmMatrix;
  32
  33 struct MultiSurfaceRegion
  34 {
  35     FloatRectangle m_rect;
  36     SurfaceList m_surfaces;
  37 };
  38
  39 class GLESGraphicsystem : public BaseGraphicSystem<EGLNativeDisplayType, EGLNativeWindowType>
  40 {
  41 public:
  42
  43     GLESGraphicsystem(int windowHeight, int windowWidth,
  44             PfnShaderProgramCreator shaderProgram);
  45
  46     ~GLESGraphicsystem();
  47
  48     virtual bool init(EGLNativeDisplayType display, EGLNativeWindowType window);
  49
  50     virtual void clearBackground();
  51
  52     virtual void activateGraphicContext();
  53     virtual void releaseGraphicContext();
  54
  55     virtual void swapBuffers();
  56
  57     virtual void beginLayer(Layer* layer);
  58     virtual void endLayer();
  59
  60     virtual bool needsRedraw(Layer *layer);
  61     virtual bool needsRedraw(LayerList layers);
  62     virtual void renderSWLayer(Layer* layer, bool clear);
  63     virtual void renderSWLayers(LayerList layers, bool clear);
  64
  65     virtual bool initOpenGLES(EGLint displayWidth, EGLint displayHeight);
  66     virtual void resize(EGLint displayWidth, EGLint displayHeight);
  67
  68     virtual void saveScreenShotOfFramebuffer(std::string fileToSave);
  69     virtual bool setOptimizationMode(OptimizationType id, OptimizationModeType mode);
  70     virtual bool getOptimizationMode(OptimizationType id, OptimizationModeType *mode);
  71
  72     virtual EGLDisplay getEGLDisplay()
  73     {
  74         return m_eglDisplay;
  75     }
  76
  77     virtual void renderSurface(Surface* surface);
  78     virtual Shader *pickOptimizedShader(SurfaceList surfaces, bool needsBlend);
  79     virtual void applyLayerMatrix(IlmMatrix& matrix);
  80
  81     virtual bool needsBlending(SurfaceList surfaces);
  82     virtual unsigned shaderKey(int numSurfaces,
  83                                 int needsBlend,
  84                                 int hasTransparency1, int hasAlphaChannel1, int hasChromakey1,
  85                                 int hasTransparency2, int hasAlphaChannel2, int hasChromakey2,
  86                                 int hasTransparency3, int hasAlphaChannel3, int hasChromakey3,
  87                                 int hasTransparency4, int hasAlphaChannel4, int hasChromakey4);
  88     virtual void debugShaderKey(unsigned key);
  89 protected:
  90
  91     virtual bool setupTextureForChromaKey();
  92     virtual void createPbufferSurface();
  93     virtual void createTempTexture();
  94     virtual void renderTempTexture();
  95     virtual void destroyTempTexture();
  96
  97 protected:
  98     virtual std::list<MultiSurfaceRegion*> computeRegions(LayerList layers, bool clear);
  99     virtual void renderRegion(MultiSurfaceRegion* region, bool blend);
 100     virtual bool renderSurfaces(SurfaceList surfaces, FloatRectangle targetDestination, bool blend);
 101
 102     virtual bool canMultitexture(LayerList layers);
 103     virtual bool useMultitexture();
 104     virtual bool canSkipClear();
 105     virtual bool useSkipClear(LayerList layers);
 106
 107     int m_windowWidth;
 108     int m_windowHeight;
 109     EGLNativeDisplayType m_nativeDisplay;
 110     EGLNativeWindowType m_nativeWindow;
 111     PfnShaderProgramCreator m_shaderCreatorFunc;
 112     EGLConfig m_eglConfig;
 113     EGLContext m_eglContext;
 114     EGLSurface m_eglSurface;
 115     EGLSurface m_eglPbufferSurface;
 116     EGLDisplay m_eglDisplay;
 117     uint m_vbo;
 118     EGLint m_displayWidth;
 119     EGLint m_displayHeight;
 120     EGLBoolean m_blendingStatus;
 121     Shader* m_defaultShaderClear;
 122     Shader* m_defaultShader;
 123     Shader* m_defaultShaderNoBlend;
 124     Shader* m_defaultShaderNoUniformAlpha;
 125
 126     Shader* m_defaultShaderAddUniformChromaKey;
 127
 128     Shader* m_defaultShaderNoUniformAlphaNoBlend;
 129     Shader* m_defaultShader2surf;
 130     Shader* m_defaultShader2surfNoBlend;
 131     Shader* m_defaultShader2surfNoUniformAlpha;
 132     Shader* m_defaultShader2surfNoUniformAlphaNoBlend;
 133     Shader* m_defaultShader2surfNoUniformAlpha0;
 134     Shader* m_defaultShader2surfNoUniformAlpha0NoBlend;
 135     Shader* m_defaultShader2surfNoUniformAlpha1;
 136     Shader* m_defaultShader2surfNoUniformAlpha1NoBlend;
 137     std::map<int, Shader*> m_shaders;
 138
 139     Layer* m_currentLayer;
 140     uint m_texId;
 141
 142     OptimizationModeType m_optimizations[OPT_COUNT];
 143 private:
 144     void saveScreenShot();
 145 };
 146
 147 #endif /* _GLESGRAPHICSYSTEM_H_ */