Home | History | Annotate | Download | only in gl 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef UI_GL_GL_SURFACE_EGL_H_
      6 #define UI_GL_GL_SURFACE_EGL_H_
      7 
      8 #if defined(OS_WIN)
      9 #include <windows.h>
     10 #endif
     11 
     12 #include <string>
     13 
     14 #include "base/compiler_specific.h"
     15 #include "base/time/time.h"
     16 #include "ui/gfx/size.h"
     17 #include "ui/gfx/vsync_provider.h"
     18 #include "ui/gl/gl_bindings.h"
     19 #include "ui/gl/gl_surface.h"
     20 
     21 namespace gfx {
     22 
     23 // Get default EGL display for GLSurfaceEGL (differs by platform).
     24 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay();
     25 
     26 // Interface for EGL surface.
     27 class GL_EXPORT GLSurfaceEGL : public GLSurface {
     28  public:
     29   GLSurfaceEGL();
     30 
     31   // Implement GLSurface.
     32   virtual EGLDisplay GetDisplay() OVERRIDE;
     33 
     34   static bool InitializeOneOff();
     35   static EGLDisplay GetHardwareDisplay();
     36   static EGLNativeDisplayType GetNativeDisplay();
     37 
     38   // These aren't particularly tied to surfaces, but since we already
     39   // have the static InitializeOneOff here, it's easiest to reuse its
     40   // initialization guards.
     41   static const char* GetEGLExtensions();
     42   static bool HasEGLExtension(const char* name);
     43   static bool IsCreateContextRobustnessSupported();
     44   static bool IsEGLSurfacelessContextSupported();
     45 
     46  protected:
     47   virtual ~GLSurfaceEGL();
     48 
     49  private:
     50   DISALLOW_COPY_AND_ASSIGN(GLSurfaceEGL);
     51 };
     52 
     53 // Encapsulates an EGL surface bound to a view.
     54 class GL_EXPORT NativeViewGLSurfaceEGL : public GLSurfaceEGL {
     55  public:
     56   explicit NativeViewGLSurfaceEGL(EGLNativeWindowType window);
     57 
     58   // Implement GLSurface.
     59   virtual EGLConfig GetConfig() OVERRIDE;
     60   virtual bool Initialize() OVERRIDE;
     61   virtual void Destroy() OVERRIDE;
     62   virtual bool Resize(const gfx::Size& size) OVERRIDE;
     63   virtual bool Recreate() OVERRIDE;
     64   virtual bool IsOffscreen() OVERRIDE;
     65   virtual bool SwapBuffers() OVERRIDE;
     66   virtual gfx::Size GetSize() OVERRIDE;
     67   virtual EGLSurface GetHandle() OVERRIDE;
     68   virtual bool SupportsPostSubBuffer() OVERRIDE;
     69   virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
     70   virtual VSyncProvider* GetVSyncProvider() OVERRIDE;
     71 
     72   // Create a NativeViewGLSurfaceEGL with an externally provided VSyncProvider.
     73   // Takes ownership of the VSyncProvider.
     74   virtual bool Initialize(scoped_ptr<VSyncProvider> sync_provider);
     75 
     76  protected:
     77   virtual ~NativeViewGLSurfaceEGL();
     78   void SetHandle(EGLSurface surface);
     79 
     80  private:
     81   EGLNativeWindowType window_;
     82   EGLSurface surface_;
     83   bool supports_post_sub_buffer_;
     84   EGLConfig config_;
     85   gfx::Size size_;
     86 
     87   scoped_ptr<VSyncProvider> vsync_provider_;
     88 
     89   DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceEGL);
     90 };
     91 
     92 // Encapsulates a pbuffer EGL surface.
     93 class GL_EXPORT PbufferGLSurfaceEGL : public GLSurfaceEGL {
     94  public:
     95   explicit PbufferGLSurfaceEGL(const gfx::Size& size);
     96 
     97   // Implement GLSurface.
     98   virtual EGLConfig GetConfig() OVERRIDE;
     99   virtual bool Initialize() OVERRIDE;
    100   virtual void Destroy() OVERRIDE;
    101   virtual bool IsOffscreen() OVERRIDE;
    102   virtual bool SwapBuffers() OVERRIDE;
    103   virtual gfx::Size GetSize() OVERRIDE;
    104   virtual bool Resize(const gfx::Size& size) OVERRIDE;
    105   virtual EGLSurface GetHandle() OVERRIDE;
    106   virtual void* GetShareHandle() OVERRIDE;
    107 
    108  protected:
    109   virtual ~PbufferGLSurfaceEGL();
    110 
    111  private:
    112   gfx::Size size_;
    113   EGLSurface surface_;
    114 
    115   DISALLOW_COPY_AND_ASSIGN(PbufferGLSurfaceEGL);
    116 };
    117 
    118 // SurfacelessEGL is used as Offscreen surface when platform supports
    119 // KHR_surfaceless_context and GL_OES_surfaceless_context. This would avoid the
    120 // need to create a dummy EGLsurface in case we render to client API targets.
    121 class GL_EXPORT SurfacelessEGL : public GLSurfaceEGL {
    122  public:
    123   explicit SurfacelessEGL(const gfx::Size& size);
    124 
    125   // Implement GLSurface.
    126   virtual EGLConfig GetConfig() OVERRIDE;
    127   virtual bool Initialize() OVERRIDE;
    128   virtual void Destroy() OVERRIDE;
    129   virtual bool IsOffscreen() OVERRIDE;
    130   virtual bool SwapBuffers() OVERRIDE;
    131   virtual gfx::Size GetSize() OVERRIDE;
    132   virtual bool Resize(const gfx::Size& size) OVERRIDE;
    133   virtual EGLSurface GetHandle() OVERRIDE;
    134   virtual void* GetShareHandle() OVERRIDE;
    135 
    136  protected:
    137   virtual ~SurfacelessEGL();
    138 
    139  private:
    140   gfx::Size size_;
    141   DISALLOW_COPY_AND_ASSIGN(SurfacelessEGL);
    142 };
    143 
    144 }  // namespace gfx
    145 
    146 #endif  // UI_GL_GL_SURFACE_EGL_H_
    147