1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_GL_GL_CONTEXT_H_
#define UI_GL_GL_CONTEXT_H_
#include <string>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "ui/gl/gl_share_group.h"
#include "ui/gl/gl_state_restorer.h"
#include "ui/gl/gpu_preference.h"
namespace gfx {
class GLSurface;
class VirtualGLApi;
// Encapsulates an OpenGL context, hiding platform specific management.
class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
public:
explicit GLContext(GLShareGroup* share_group);
// Initializes the GL context to be compatible with the given surface. The GL
// context can be made with other surface's of the same type. The compatible
// surface is only needed for certain platforms like WGL, OSMesa and GLX. It
// should be specific for all platforms though.
virtual bool Initialize(
GLSurface* compatible_surface, GpuPreference gpu_preference) = 0;
// Destroys the GL context.
virtual void Destroy() = 0;
// Makes the GL context and a surface current on the current thread.
virtual bool MakeCurrent(GLSurface* surface) = 0;
// Releases this GL context and surface as current on the current thread.
virtual void ReleaseCurrent(GLSurface* surface) = 0;
// Returns true if this context and surface is current. Pass a null surface
// if the current surface is not important.
virtual bool IsCurrent(GLSurface* surface) = 0;
// Get the underlying platform specific GL context "handle".
virtual void* GetHandle() = 0;
// Gets the GLStateRestorer for the context.
GLStateRestorer* GetGLStateRestorer();
// Sets the GLStateRestorer for the context (takes ownership).
void SetGLStateRestorer(GLStateRestorer* state_restorer);
// Set swap interval. This context must be current.
virtual void SetSwapInterval(int interval) = 0;
// Returns space separated list of extensions. The context must be current.
virtual std::string GetExtensions();
// Returns in bytes the total amount of GPU memory for the GPU which this
// context is currently rendering on. Returns false if no extension exists
// to get the exact amount of GPU memory.
virtual bool GetTotalGpuMemory(size_t* bytes);
// Indicate that it is safe to force this context to switch GPUs, since
// transitioning can cause corruption and hangs (OS X only).
virtual void SetSafeToForceGpuSwitch();
// Indicate that the real context switches should unbind the FBO first
// (For an Android work-around only).
virtual void SetUnbindFboOnMakeCurrent();
// Returns whether the current context supports the named extension. The
// context must be current.
bool HasExtension(const char* name);
GLShareGroup* share_group();
// Create a GL context that is compatible with the given surface.
// |share_group|, if non-NULL, is a group of contexts which the
// internally created OpenGL context shares textures and other resources.
static scoped_refptr<GLContext> CreateGLContext(
GLShareGroup* share_group,
GLSurface* compatible_surface,
GpuPreference gpu_preference);
static bool LosesAllContextsOnContextLost();
// Returns the last GLContext made current, virtual or real.
static GLContext* GetCurrent();
virtual bool WasAllocatedUsingRobustnessExtension();
// Use this context for virtualization.
void SetupForVirtualization();
// Make this context current when used for context virtualization.
bool MakeVirtuallyCurrent(GLContext* virtual_context, GLSurface* surface);
// Notify this context that |virtual_context|, that was using us, is
// being released or destroyed.
void OnReleaseVirtuallyCurrent(GLContext* virtual_context);
protected:
virtual ~GLContext();
// Sets the GL api to the real hardware API (vs the VirtualAPI)
static void SetRealGLApi();
virtual void SetCurrent(GLSurface* surface);
// Initialize function pointers to extension functions in the GL
// implementation. Should be called immediately after this context is made
// current.
bool InitializeExtensionBindings();
// Returns the last real (non-virtual) GLContext made current.
static GLContext* GetRealCurrent();
private:
friend class base::RefCounted<GLContext>;
// For GetRealCurrent.
friend class VirtualGLApi;
scoped_refptr<GLShareGroup> share_group_;
scoped_ptr<VirtualGLApi> virtual_gl_api_;
scoped_ptr<GLStateRestorer> state_restorer_;
DISALLOW_COPY_AND_ASSIGN(GLContext);
};
class GL_EXPORT GLContextReal : public GLContext {
public:
explicit GLContextReal(GLShareGroup* share_group);
protected:
virtual ~GLContextReal();
virtual void SetCurrent(GLSurface* surface) OVERRIDE;
private:
DISALLOW_COPY_AND_ASSIGN(GLContextReal);
};
} // namespace gfx
#endif // UI_GL_GL_CONTEXT_H_
|
