AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert of Make the Sk GL context class an abstract base class (patchset #4 id:60001 of https://codereview.chromium.org/630843002/)

Browse Source 
Reason for revert:
nanobech failing on Android

Original issue's description:
> Make the Sk GL context class an abstract base class
>
> Make the Sk GL context class, SkGLNativeContext, an abstract base class. Before,
> it depended on ifdefs to implement the platform dependent polymorphism.  Move
> the logic to subclasses of the various platform implementations.
>
> This a step to enable Skia embedders to compile dm and bench_pictures. The
> concrete goal is to support running these test apps with Chromium command buffer.
>
> With this change, Chromium can implement its own version of SkGLNativeContext
> that uses command buffer, and host the implementation in its own repository.
>
> Implements the above by renaming the SkGLContextHelper to SkGLContext and
> removing the unneeded SkGLNativeContext. Also removes
> SkGLNativeContext::AutoRestoreContext functionality, it appeared to be unused:
> no use in Skia code, and no tests.
>
> BUG=skia:2992
>
> Committed: https://skia.googlesource.com/skia/+/a90ed4e83897b45d6331ee4c54e1edd4054de9a8

TBR=kkinnunen@nvidia.com
NOTREECHECKS=true
NOTRY=true
BUG=skia:2992

Review URL: https://codereview.chromium.org/639793002
This commit is contained in:
bsalomon 2014-10-08 04:45:09 -07:00 committed by Commit bot
parent a5ee45ce9d
commit 10805961ce
29 changed files with 351 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
bench/nanobench.cpp
View File

@ -84,7 +84,7 @@ static SkString humanize(double ms) {
}
#define HUMANIZE(ms) humanize(ms).c_str()
static double time(int loops, Benchmark* bench, SkCanvas* canvas, SkGLContext* gl) {
static double time(int loops, Benchmark* bench, SkCanvas* canvas, SkGLContextHelper* gl) {
if (canvas) {
canvas->clear(SK_ColorWHITE);
}
@ -203,7 +203,7 @@ static int cpu_bench(const double overhead, Benchmark* bench, SkCanvas* canvas,
}
#if SK_SUPPORT_GPU
static int gpu_bench(SkGLContext* gl,
static int gpu_bench(SkGLContextHelper* gl,
Benchmark* bench,
SkCanvas* canvas,
double* samples) {
@ -274,7 +274,7 @@ struct Target {
const Config config;
SkAutoTDelete<SkSurface> surface;
#if SK_SUPPORT_GPU
SkGLContext* gl;
SkGLContextHelper* gl;
#endif
};
@ -389,7 +389,7 @@ static void create_targets(SkTDArray<Target*>* targets, Benchmark* b,
}
#if SK_SUPPORT_GPU
static void fill_gpu_options(ResultsWriter* log, SkGLContext* ctx) {
static void fill_gpu_options(ResultsWriter* log, SkGLContextHelper* ctx) {
const GrGLubyte* version;
SK_GL_RET(*ctx, version, GetString(GR_GL_VERSION));
log->configOption("GL_VERSION", (const char*)(version));

17
gyp/gpu.gypi
View File

@ -279,7 +279,7 @@
'<(skia_include_path)/gpu/SkGrPixelRef.h',
'<(skia_include_path)/gpu/SkGrTexturePixelRef.h',
'<(skia_include_path)/gpu/gl/SkGLContext.h',
'<(skia_include_path)/gpu/gl/SkGLContextHelper.h',
'<(skia_src_path)/gpu/SkGpuDevice.cpp',
'<(skia_src_path)/gpu/SkGpuDevice.h',
@ -290,7 +290,7 @@
'<(skia_src_path)/image/SkImage_Gpu.cpp',
'<(skia_src_path)/image/SkSurface_Gpu.cpp',
'<(skia_src_path)/gpu/gl/SkGLContext.cpp'
'<(skia_src_path)/gpu/gl/SkGLContextHelper.cpp'
],
'skgpu_native_gl_sources': [
'<(skia_src_path)/gpu/gl/GrGLDefaultInterface_native.cpp',
@ -302,12 +302,13 @@
'<(skia_src_path)/gpu/gl/android/GrGLCreateNativeInterface_android.cpp',
# Sk files
'<(skia_src_path)/gpu/gl/mac/SkCreatePlatformGLContext_mac.cpp',
'<(skia_src_path)/gpu/gl/nacl/SkCreatePlatformGLContext_nacl.cpp',
'<(skia_src_path)/gpu/gl/win/SkCreatePlatformGLContext_win.cpp',
'<(skia_src_path)/gpu/gl/glx/SkCreatePlatformGLContext_glx.cpp',
'<(skia_src_path)/gpu/gl/egl/SkCreatePlatformGLContext_egl.cpp',
'<(skia_src_path)/gpu/gl/iOS/SkCreatePlatformGLContext_iOS.mm',
'<(skia_include_path)/gpu/gl/SkNativeGLContext.h',
'<(skia_src_path)/gpu/gl/mac/SkNativeGLContext_mac.cpp',
'<(skia_src_path)/gpu/gl/nacl/SkNativeGLContext_nacl.cpp',
'<(skia_src_path)/gpu/gl/win/SkNativeGLContext_win.cpp',
'<(skia_src_path)/gpu/gl/glx/SkNativeGLContext_glx.cpp',
'<(skia_src_path)/gpu/gl/egl/SkNativeGLContext_egl.cpp',
'<(skia_src_path)/gpu/gl/iOS/SkNativeGLContext_iOS.mm',
],
'skgpu_mesa_gl_sources': [
'<(skia_src_path)/gpu/gl/mesa/GrGLCreateMesaInterface.cpp',

3
gyp/public_headers.gypi
View File

@ -183,8 +183,9 @@
'gpu/gl/GrGLInterface.h',
'gpu/gl/SkANGLEGLContext.h',
'gpu/gl/SkDebugGLContext.h',
'gpu/gl/SkGLContextHelper.h',
'gpu/gl/SkMesaGLContext.h',
'gpu/gl/SkGLContext.h',
'gpu/gl/SkNativeGLContext.h',
'gpu/gl/SkNullGLContext.h',
'images/SkForceLinking.h',
'images/SkMovie.h',

10
include/gpu/GrContextFactory.h
View File

@ -15,7 +15,7 @@
#if SK_MESA
#include "gl/SkMesaGLContext.h"
#endif
#include "gl/SkGLContext.h"
#include "gl/SkNativeGLContext.h"
#include "gl/SkNullGLContext.h"
#include "GrContext.h"
@ -130,12 +130,12 @@ public:
return fContexts[i].fGrContext;
}
}
SkAutoTUnref<SkGLContext> glCtx;
SkAutoTUnref<SkGLContextHelper> glCtx;
SkAutoTUnref<GrContext> grCtx;
switch (type) {
case kNVPR_GLContextType: // fallthru
case kNative_GLContextType:
glCtx.reset(SkCreatePlatformGLContext());
glCtx.reset(SkNEW(SkNativeGLContext));
break;
#ifdef SK_ANGLE
case kANGLE_GLContextType:
@ -192,7 +192,7 @@ public:
// Returns the GLContext of the given type. If it has not been created yet,
// NULL is returned instead.
SkGLContext* getGLContext(GLContextType type) {
SkGLContextHelper* getGLContext(GLContextType type) {
for (int i = 0; i < fContexts.count(); ++i) {
if (fContexts[i].fType == type) {
return fContexts[i].fGLContext;
@ -207,7 +207,7 @@ public:
private:
struct GPUContext {
GLContextType fType;
SkGLContext* fGLContext;
SkGLContextHelper* fGLContext;
GrContext* fGrContext;
};
SkTArray<GPUContext, true> fContexts;

15
include/gpu/gl/SkANGLEGLContext.h
View File

@ -10,12 +10,12 @@
#if SK_ANGLE
#include "SkGLContext.h"
#include "SkGLContextHelper.h"
#include <GLES2/gl2.h>
#include <EGL/egl.h>
class SkANGLEGLContext : public SkGLContext {
class SkANGLEGLContext : public SkGLContextHelper {
public:
SkANGLEGLContext();
@ -24,6 +24,17 @@ public:
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
class AutoContextRestore {
public:
AutoContextRestore();
~AutoContextRestore();
private:
EGLContext fOldEGLContext;
EGLDisplay fOldDisplay;
EGLSurface fOldSurface;
};
protected:
virtual const GrGLInterface* createGLContext(
GrGLStandard forcedGpuAPI) SK_OVERRIDE;

4
include/gpu/gl/SkDebugGLContext.h
View File

@ -8,9 +8,9 @@
#ifndef SkDebugGLContext_DEFINED
#define SkDebugGLContext_DEFINED
#include "SkGLContext.h"
#include "SkGLContextHelper.h"
class SkDebugGLContext : public SkGLContext {
class SkDebugGLContext : public SkGLContextHelper {
public:
SkDebugGLContext() {}

20
include/gpu/gl/SkGLContext.h → include/gpu/gl/SkGLContextHelper.h
View File

@ -5,8 +5,8 @@
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkGLContext_DEFINED
#define SkGLContext_DEFINED
#ifndef SkGLContextHelper_DEFINED
#define SkGLContextHelper_DEFINED
#include "GrGLInterface.h"
@ -15,12 +15,12 @@
* Provides a GrGLInterface struct of function pointers for the context.
*/
class SK_API SkGLContext : public SkRefCnt {
class SK_API SkGLContextHelper : public SkRefCnt {
public:
SK_DECLARE_INST_COUNT(SkGLContext)
SK_DECLARE_INST_COUNT(SkGLContextHelper)
SkGLContext();
virtual ~SkGLContext();
SkGLContextHelper();
virtual ~SkGLContextHelper();
/**
* Initializes the context and makes it current.
@ -81,14 +81,6 @@ private:
typedef SkRefCnt INHERITED;
};
/** Creates platform-dependent GL context object
* Note: If Skia embedder needs a custom GL context that sets up the GL
* interface, this function should be implemented by the embedder.
* Otherwise, the default implementation for the platform should be compiled in
* the library.
*/
SK_API SkGLContext* SkCreatePlatformGLContext();
/**
* Helper macros for using the GL context through the GrGLInterface. Example:
* SK_GL(glCtx, GenTextures(1, &texID));

17
include/gpu/gl/SkMesaGLContext.h
View File

@ -8,11 +8,11 @@
#ifndef SkMesaGLContext_DEFINED
#define SkMesaGLContext_DEFINED
#include "SkGLContext.h"
#include "SkGLContextHelper.h"
#if SK_MESA
class SkMesaGLContext : public SkGLContext {
class SkMesaGLContext : public SkGLContextHelper {
private:
typedef intptr_t Context;
@ -24,6 +24,19 @@ public:
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
class AutoContextRestore {
public:
AutoContextRestore();
~AutoContextRestore();
private:
Context fOldContext;
GrGLint fOldWidth;
GrGLint fOldHeight;
GrGLint fOldFormat;
void* fOldImage;
};
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;

111
include/gpu/gl/SkNativeGLContext.h Normal file
View File

@ -0,0 +1,111 @@
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkNativeGLContext_DEFINED
#define SkNativeGLContext_DEFINED
#include "SkGLContextHelper.h"
/* This struct is taken from a mesa demo. Please update as required */
static const struct { int major, minor; } gl_versions[] = {
{1, 0},
{1, 1},
{1, 2},
{1, 3},
{1, 4},
{1, 5},
{2, 0},
{2, 1},
{3, 0},
{3, 1},
{3, 2},
{3, 3},
{4, 0},
{4, 1},
{4, 2},
{4, 3},
{4, 4},
{0, 0} /* end of list */
};
#define NUM_GL_VERSIONS SK_ARRAY_COUNT(gl_versions)
#if defined(SK_BUILD_FOR_MAC)
#include <OpenGL/OpenGL.h>
#elif SK_EGL
#include <GLES2/gl2.h>
#include <EGL/egl.h>
#elif defined(SK_BUILD_FOR_UNIX)
#include <X11/Xlib.h>
#include <GL/glx.h>
#elif defined(SK_BUILD_FOR_WIN32)
#include <windows.h>
#include <GL/GL.h>
#include "SkWGL.h"
#endif
class SkNativeGLContext : public SkGLContextHelper {
public:
SkNativeGLContext();
virtual ~SkNativeGLContext();
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
class AutoContextRestore {
public:
AutoContextRestore();
~AutoContextRestore();
private:
#if defined(SK_BUILD_FOR_MAC)
CGLContextObj fOldCGLContext;
#elif SK_EGL
EGLContext fOldEGLContext;
EGLDisplay fOldDisplay;
EGLSurface fOldSurface;
#elif defined(SK_BUILD_FOR_UNIX)
GLXContext fOldGLXContext;
Display* fOldDisplay;
GLXDrawable fOldDrawable;
#elif defined(SK_BUILD_FOR_WIN32)
HDC fOldHDC;
HGLRC fOldHGLRC;
#elif defined(SK_BUILD_FOR_IOS)
void* fEAGLContext;
#endif
};
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;
private:
#if defined(SK_BUILD_FOR_MAC)
CGLContextObj fContext;
#elif SK_EGL
EGLContext fContext;
EGLDisplay fDisplay;
EGLSurface fSurface;
#elif defined(SK_BUILD_FOR_UNIX)
GLXContext fContext;
Display* fDisplay;
Pixmap fPixmap;
GLXPixmap fGlxPixmap;
#elif defined(SK_BUILD_FOR_WIN32)
HWND fWindow;
HDC fDeviceContext;
HGLRC fGlRenderContext;
static ATOM gWC;
SkWGLPbufferContext* fPbufferContext;
#elif defined(SK_BUILD_FOR_IOS)
void* fEAGLContext;
#endif
};
#endif

4
include/gpu/gl/SkNullGLContext.h
View File

@ -8,9 +8,9 @@
#ifndef SkNullGLContext_DEFINED
#define SkNullGLContext_DEFINED
#include "SkGLContext.h"
#include "SkGLContextHelper.h"
class SK_API SkNullGLContext : public SkGLContext {
class SK_API SkNullGLContext : public SkGLContextHelper {
public:
SkNullGLContext() {};

10
src/gpu/gl/SkGLContext.cpp → src/gpu/gl/SkGLContextHelper.cpp
View File

@ -5,17 +5,17 @@
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/SkGLContext.h"
#include "gl/SkGLContextHelper.h"
#include "GrGLUtil.h"
SkGLContext::SkGLContext()
SkGLContextHelper::SkGLContextHelper()
: fFBO(0)
, fColorBufferID(0)
, fDepthStencilBufferID(0)
, fGL(NULL) {
}
SkGLContext::~SkGLContext() {
SkGLContextHelper::~SkGLContextHelper() {
if (fGL) {
// TODO: determine why DeleteFramebuffers is generating a GL error in tests
@ -27,7 +27,7 @@ SkGLContext::~SkGLContext() {
SkSafeUnref(fGL);
}
bool SkGLContext::init(GrGLStandard forcedGpuAPI, int width,
bool SkGLContextHelper::init(GrGLStandard forcedGpuAPI, int width,
int height) {
if (fGL) {
fGL->unref();
@ -135,7 +135,7 @@ bool SkGLContext::init(GrGLStandard forcedGpuAPI, int width,
return false;
}
void SkGLContext::testAbandon() {
void SkGLContextHelper::testAbandon() {
if (fGL) {
fGL->abandon();
}

15
src/gpu/gl/angle/SkANGLEGLContext.cpp
View File

@ -8,6 +8,21 @@
#include "gl/SkANGLEGLContext.h"
SkANGLEGLContext::AutoContextRestore::AutoContextRestore() {
fOldEGLContext = eglGetCurrentContext();
fOldDisplay = eglGetCurrentDisplay();
fOldSurface = eglGetCurrentSurface(EGL_DRAW);
}
SkANGLEGLContext::AutoContextRestore::~AutoContextRestore() {
if (fOldDisplay) {
eglMakeCurrent(fOldDisplay, fOldSurface, fOldSurface, fOldEGLContext);
}
}
///////////////////////////////////////////////////////////////////////////////
SkANGLEGLContext::SkANGLEGLContext()
: fContext(EGL_NO_CONTEXT)
, fDisplay(EGL_NO_DISPLAY)

2
src/gpu/gl/debug/GrGLCreateDebugInterface.cpp
View File

@ -819,7 +819,7 @@ public:
// The solution to this is probably to alter SkDebugGlContext's
// "makeCurrent" method to make a call like "makeCurrent(this)" to
// the debug GL interface (assuming that the application will create
// multiple SkGLContext's) to let it switch between the active
// multiple SkGLContextHelper's) to let it switch between the active
// context. Everything in the GrDebugGL object would then need to be
// moved to a GrContextObj and the GrDebugGL object would just switch
// between them. Note that this approach would also require that

51
src/gpu/gl/egl/SkCreatePlatformGLContext_egl.cpp → src/gpu/gl/egl/SkNativeGLContext_egl.cpp
View File

@ -5,42 +5,34 @@
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/SkGLContext.h"
#include "gl/SkNativeGLContext.h"
#include <GLES2/gl2.h>
#include <EGL/egl.h>
SkNativeGLContext::AutoContextRestore::AutoContextRestore() {
fOldEGLContext = eglGetCurrentContext();
fOldDisplay = eglGetCurrentDisplay();
fOldSurface = eglGetCurrentSurface(EGL_DRAW);
namespace {
}
class EGLGLContext : public SkGLContext {
public:
EGLGLContext();
SkNativeGLContext::AutoContextRestore::~AutoContextRestore() {
if (fOldDisplay) {
eglMakeCurrent(fOldDisplay, fOldSurface, fOldSurface, fOldEGLContext);
}
}
virtual ~EGLGLContext();
///////////////////////////////////////////////////////////////////////////////
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;
private:
EGLContext fContext;
EGLDisplay fDisplay;
EGLSurface fSurface;
};
EGLGLContext::EGLGLContext()
SkNativeGLContext::SkNativeGLContext()
: fContext(EGL_NO_CONTEXT)
, fDisplay(EGL_NO_DISPLAY)
, fSurface(EGL_NO_SURFACE) {
}
EGLGLContext::~EGLGLContext() {
SkNativeGLContext::~SkNativeGLContext() {
this->destroyGLContext();
}
void EGLGLContext::destroyGLContext() {
void SkNativeGLContext::destroyGLContext() {
if (fDisplay) {
eglMakeCurrent(fDisplay, 0, 0, 0);
@ -59,7 +51,7 @@ void EGLGLContext::destroyGLContext() {
}
}
const GrGLInterface* EGLGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
const GrGLInterface* SkNativeGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
static const EGLint kEGLContextAttribsForOpenGL[] = {
EGL_NONE
};
@ -177,21 +169,14 @@ const GrGLInterface* EGLGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
return interface;
}
void EGLGLContext::makeCurrent() const {
void SkNativeGLContext::makeCurrent() const {
if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
SkDebugf("Could not set the context.\n");
}
}
void EGLGLContext::swapBuffers() const {
void SkNativeGLContext::swapBuffers() const {
if (!eglSwapBuffers(fDisplay, fSurface)) {
SkDebugf("Could not complete eglSwapBuffers.\n");
}
}
} // anonymous namespace
SkGLContext* CreatePlatformGLContext() {
return SkNEW(EGLGLContext);
}

78
src/gpu/gl/glx/SkCreatePlatformGLContext_glx.cpp → src/gpu/gl/glx/SkNativeGLContext_glx.cpp
View File

@ -5,38 +5,25 @@
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/SkGLContext.h"
#include "gl/SkNativeGLContext.h"
#include <X11/Xlib.h>
#include <GL/glx.h>
#include <GL/glu.h>
namespace {
/* Note: Skia requires glx 1.3 or newer */
/* This struct is taken from a mesa demo. Please update as required */
static const struct { int major, minor; } gl_versions[] = {
{1, 0},
{1, 1},
{1, 2},
{1, 3},
{1, 4},
{1, 5},
{2, 0},
{2, 1},
{3, 0},
{3, 1},
{3, 2},
{3, 3},
{4, 0},
{4, 1},
{4, 2},
{4, 3},
{4, 4},
{0, 0} /* end of list */
};
#define NUM_GL_VERSIONS SK_ARRAY_COUNT(gl_versions)
SkNativeGLContext::AutoContextRestore::AutoContextRestore() {
fOldGLXContext = glXGetCurrentContext();
fOldDisplay = glXGetCurrentDisplay();
fOldDrawable = glXGetCurrentDrawable();
}
SkNativeGLContext::AutoContextRestore::~AutoContextRestore() {
if (fOldDisplay) {
glXMakeCurrent(fOldDisplay, fOldDrawable, fOldGLXContext);
}
}
///////////////////////////////////////////////////////////////////////////////
static bool ctxErrorOccurred = false;
static int ctxErrorHandler(Display *dpy, XErrorEvent *ev) {
@ -44,37 +31,18 @@ static int ctxErrorHandler(Display *dpy, XErrorEvent *ev) {
return 0;
}
class GLXGLContext : public SkGLContext {
public:
GLXGLContext();
virtual ~GLXGLContext();
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;
private:
GLXContext fContext;
Display* fDisplay;
Pixmap fPixmap;
GLXPixmap fGlxPixmap;
};
GLXGLContext::GLXGLContext()
SkNativeGLContext::SkNativeGLContext()
: fContext(NULL)
, fDisplay(NULL)
, fPixmap(0)
, fGlxPixmap(0) {
}
GLXGLContext::~GLXGLContext() {
SkNativeGLContext::~SkNativeGLContext() {
this->destroyGLContext();
}
void GLXGLContext::destroyGLContext() {
void SkNativeGLContext::destroyGLContext() {
if (fDisplay) {
glXMakeCurrent(fDisplay, 0, 0);
@ -98,7 +66,7 @@ void GLXGLContext::destroyGLContext() {
}
}
const GrGLInterface* GLXGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
const GrGLInterface* SkNativeGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
fDisplay = XOpenDisplay(0);
if (!fDisplay) {
@ -309,18 +277,12 @@ const GrGLInterface* GLXGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
return interface;
}
void GLXGLContext::makeCurrent() const {
void SkNativeGLContext::makeCurrent() const {
if (!glXMakeCurrent(fDisplay, fGlxPixmap, fContext)) {
SkDebugf("Could not set the context.\n");
}
}
void GLXGLContext::swapBuffers() const {
void SkNativeGLContext::swapBuffers() const {
glXSwapBuffers(fDisplay, fGlxPixmap);
}
} // anonymous namespace
SkGLContext* SkCreatePlatformGLContext() {
return SkNEW(GLXGLContext);
}

50
src/gpu/gl/iOS/SkCreatePlatformGLContext_iOS.mm → src/gpu/gl/iOS/SkNativeGLContext_iOS.mm
View File

@ -6,38 +6,36 @@
* found in the LICENSE file.
*/
#include "gl/SkGLContext.h"
#include "gl/SkNativeGLContext.h"
#import <OpenGLES/EAGL.h>
#define EAGLCTX ((EAGLContext*)(fEAGLContext))
namespace {
SkNativeGLContext::AutoContextRestore::AutoContextRestore() {
fEAGLContext = [EAGLContext currentContext];
if (EAGLCTX) {
[EAGLCTX retain];
}
}
class IOSNativeGLContext : public SkNativeGLContext {
public:
IOSNativeGLContext();
SkNativeGLContext::AutoContextRestore::~AutoContextRestore() {
if (EAGLCTX) {
[EAGLContext setCurrentContext:EAGLCTX];
[EAGLCTX release];
}
}
virtual ~IOSNativeGLContext();
///////////////////////////////////////////////////////////////////////////////
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;
private:
void* fEAGLContext;
};
IOSNativeGLContext::IOSNativeGLContext()
SkNativeGLContext::SkNativeGLContext()
: fEAGLContext(NULL) {
}
IOSNativeGLContext::~IOSNativeGLContext() {
SkNativeGLContext::~SkNativeGLContext() {
this->destroyGLContext();
}
void IOSNativeGLContext::destroyGLContext() {
void SkNativeGLContext::destroyGLContext() {
if (fEAGLContext) {
if ([EAGLContext currentContext] == EAGLCTX) {
[EAGLContext setCurrentContext:nil];
@ -47,7 +45,7 @@ void IOSNativeGLContext::destroyGLContext() {
}
}
const GrGLInterface* IOSNativeGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
const GrGLInterface* SkNativeGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
if (kGL_GrGLStandard == forcedGpuAPI) {
return NULL;
}
@ -64,18 +62,10 @@ const GrGLInterface* IOSNativeGLContext::createGLContext(GrGLStandard forcedGpuA
return interface;
}
void IOSNativeGLContext::makeCurrent() const {
void SkNativeGLContext::makeCurrent() const {
if (![EAGLContext setCurrentContext:EAGLCTX]) {
SkDebugf("Could not set the context.\n");
}
}
void IOSNativeGLContext::swapBuffers() const { }
} // anonymous namespace
SkNativeGLContext* SkCreatePlatformGLContext() {
return SkNEW(IOSNativeGLContext);
}
void SkNativeGLContext::swapBuffers() const { }

43
src/gpu/gl/mac/SkCreatePlatformGLContext_mac.cpp → src/gpu/gl/mac/SkNativeGLContext_mac.cpp
View File

@ -5,43 +5,34 @@
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/SkGLContext.h"
#include "gl/SkNativeGLContext.h"
#include "AvailabilityMacros.h"
#include <OpenGL/OpenGL.h>
SkNativeGLContext::AutoContextRestore::AutoContextRestore() {
fOldCGLContext = CGLGetCurrentContext();
}
namespace {
class MacGLContext : public SkGLContext {
public:
MacGLContext();
SkNativeGLContext::AutoContextRestore::~AutoContextRestore() {
CGLSetCurrentContext(fOldCGLContext);
}
virtual ~MacGLContext();
///////////////////////////////////////////////////////////////////////////////
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;
private:
CGLContextObj fContext;
};
MacGLContext::MacGLContext()
SkNativeGLContext::SkNativeGLContext()
: fContext(NULL) {
}
MacGLContext::~MacGLContext() {
SkNativeGLContext::~SkNativeGLContext() {
this->destroyGLContext();
}
void MacGLContext::destroyGLContext() {
void SkNativeGLContext::destroyGLContext() {
if (fContext) {
CGLReleaseContext(fContext);
}
}
const GrGLInterface* MacGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
const GrGLInterface* SkNativeGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
SkASSERT(NULL == fContext);
if (kGLES_GrGLStandard == forcedGpuAPI) {
return NULL;
@ -84,16 +75,10 @@ const GrGLInterface* MacGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
return interface;
}
void MacGLContext::makeCurrent() const {
void SkNativeGLContext::makeCurrent() const {
CGLSetCurrentContext(fContext);
}
void MacGLContext::swapBuffers() const {
void SkNativeGLContext::swapBuffers() const {
CGLFlushDrawable(fContext);
}
} // anonymous namespace
SkGLContext* SkCreatePlatformGLContext() {
return SkNEW(MacGLContext);
}

18
src/gpu/gl/mesa/SkMesaGLContext.cpp
View File

@ -11,6 +11,24 @@
#include "gl/SkMesaGLContext.h"
#include "gl/GrGLDefines.h"
SkMesaGLContext::AutoContextRestore::AutoContextRestore() {
fOldContext = (Context)OSMesaGetCurrentContext();
if (fOldContext) {
OSMesaGetColorBuffer((OSMesaContext)fOldContext,
&fOldWidth, &fOldHeight,
&fOldFormat, &fOldImage);
}
}
SkMesaGLContext::AutoContextRestore::~AutoContextRestore() {
if (fOldContext) {
OSMesaMakeCurrent((OSMesaContext)fOldContext, fOldImage,
fOldFormat, fOldWidth, fOldHeight);
}
}
///////////////////////////////////////////////////////////////////////////////
SkMesaGLContext::SkMesaGLContext()
: fContext(static_cast<Context>(NULL))
, fImage(NULL) {

60
src/gpu/gl/nacl/SkCreatePlatformGLContext_nacl.cpp
View File

@ -1,60 +0,0 @@
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/SkGLContext.h"
#include <GLES2/gl2.h>
#include <EGL/egl.h>
namespace {
class NACLGLContext : public SkGLContext {
public:
SkGLContextEGL();
virtual ~NACLGLContext();
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;
private:
EGLContext fContext;
EGLDisplay fDisplay;
EGLSurface fSurface;
};
NACLGLContext::NACLGLContext()
: fContext(NULL)
, fDisplay(NULL)
{
}
NACLGLContext::~NACLGLContext() {
this->destroyGLContext();
}
void NACLGLContext::destroyGLContext() {
}
const GrGLInterface* NACLGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
return NULL;
}
void NACLGLContext::makeCurrent() const {
}
void NACLGLContext::swapBuffers() const {
}
} // anonymous namespace
NACLGLContext* SkCreatePlatformGLContext() {
return SkNEW(NACLGLContext);
}

37
src/gpu/gl/nacl/SkNativeGLContext_nacl.cpp Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/SkNativeGLContext.h"
SkNativeGLContext::AutoContextRestore::AutoContextRestore() {
}
SkNativeGLContext::AutoContextRestore::~AutoContextRestore() {
}
SkNativeGLContext::SkNativeGLContext()
: fContext(NULL)
, fDisplay(NULL)
{
}
SkNativeGLContext::~SkNativeGLContext() {
this->destroyGLContext();
}
void SkNativeGLContext::destroyGLContext() {
}
const GrGLInterface* SkNativeGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
return NULL;
}
void SkNativeGLContext::makeCurrent() const {
}
void SkNativeGLContext::swapBuffers() const {
}

54
src/gpu/gl/win/SkCreatePlatformGLContext_win.cpp → src/gpu/gl/win/SkNativeGLContext_win.cpp
View File

@ -6,51 +6,36 @@
* found in the LICENSE file.
*/
#include "gl/SkGLContext.h"
#include <windows.h>
#include <GL/GL.h>
#include "SkWGL.h"
#include "gl/SkNativeGLContext.h"
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
namespace {
SkNativeGLContext::AutoContextRestore::AutoContextRestore() {
fOldHGLRC = wglGetCurrentContext();
fOldHDC = wglGetCurrentDC();
}
class WinGLContext : public SkGLContext {
public:
WinGLContext();
SkNativeGLContext::AutoContextRestore::~AutoContextRestore() {
wglMakeCurrent(fOldHDC, fOldHGLRC);
}
virtual ~WinGLContext();
///////////////////////////////////////////////////////////////////////////////
virtual void makeCurrent() const SK_OVERRIDE;
virtual void swapBuffers() const SK_OVERRIDE;
protected:
virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
virtual void destroyGLContext() SK_OVERRIDE;
ATOM SkNativeGLContext::gWC = 0;
private:
HWND fWindow;
HDC fDeviceContext;
HGLRC fGlRenderContext;
static ATOM gWC;
SkWGLPbufferContext* fPbufferContext;
};
ATOM WinGLContext::gWC = 0;
WinGLContext::WinGLContext()
SkNativeGLContext::SkNativeGLContext()
: fWindow(NULL)
, fDeviceContext(NULL)
, fGlRenderContext(0)
, fPbufferContext(NULL) {
}
WinGLContext::~WinGLContext() {
SkNativeGLContext::~SkNativeGLContext() {
this->destroyGLContext();
}
void WinGLContext::destroyGLContext() {
void SkNativeGLContext::destroyGLContext() {
SkSafeSetNull(fPbufferContext);
if (fGlRenderContext) {
wglDeleteContext(fGlRenderContext);
@ -66,7 +51,7 @@ void WinGLContext::destroyGLContext() {
}
}
const GrGLInterface* WinGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
const GrGLInterface* SkNativeGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
if (!gWC) {
@ -149,7 +134,7 @@ const GrGLInterface* WinGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
return interface;
}
void WinGLContext::makeCurrent() const {
void SkNativeGLContext::makeCurrent() const {
HDC dc;
HGLRC glrc;
@ -166,7 +151,7 @@ void WinGLContext::makeCurrent() const {
}
}
void WinGLContext::swapBuffers() const {
void SkNativeGLContext::swapBuffers() const {
HDC dc;
if (NULL == fPbufferContext) {
@ -178,10 +163,3 @@ void WinGLContext::swapBuffers() const {
SkDebugf("Could not complete SwapBuffers.\n");
}
}
} // anonymous namespace
SkGLContext* SkCreatePlatformGLContext() {
return SkNEW(WinGLContext);
}

10
tests/GLInterfaceValidationTest.cpp
View File

@ -17,20 +17,20 @@ DEF_GPUTEST(GLInterfaceValidation, reporter, factory) {
GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType)i;
// this forces the factory to make the context if it hasn't yet
factory->get(glCtxType);
SkGLContext* glCtx = factory->getGLContext(glCtxType);
SkGLContextHelper* glCtxHelper = factory->getGLContext(glCtxType);
// We're supposed to fail the NVPR context type when we the native context that does not
// support the NVPR extension.
if (GrContextFactory::kNVPR_GLContextType == glCtxType &&
factory->getGLContext(GrContextFactory::kNative_GLContextType) &&
!factory->getGLContext(GrContextFactory::kNative_GLContextType)->hasExtension("GL_NV_path_rendering")) {
REPORTER_ASSERT(reporter, NULL == glCtx);
REPORTER_ASSERT(reporter, NULL == glCtxHelper);
continue;
}
REPORTER_ASSERT(reporter, glCtx);
if (glCtx) {
const GrGLInterface* interface = glCtx->gl();
REPORTER_ASSERT(reporter, glCtxHelper);
if (glCtxHelper) {
const GrGLInterface* interface = glCtxHelper->gl();
REPORTER_ASSERT(reporter, interface->validate());
}
}

2
tests/Test.cpp
View File

@ -15,7 +15,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "gl/SkGLContext.h"
#include "gl/SkNativeGLContext.h"
#else
class GrContext;
#endif

4
tools/PictureRenderer.cpp
View File

@ -228,7 +228,7 @@ void PictureRenderer::buildBBoxHierarchy() {
void PictureRenderer::resetState(bool callFinish) {
#if SK_SUPPORT_GPU
SkGLContext* glContext = this->getGLContext();
SkGLContextHelper* glContext = this->getGLContext();
if (NULL == glContext) {
SkASSERT(kBitmap_DeviceType == fDeviceType);
return;
@ -248,7 +248,7 @@ void PictureRenderer::purgeTextures() {
pool->dumpPool();
#if SK_SUPPORT_GPU
SkGLContext* glContext = this->getGLContext();
SkGLContextHelper* glContext = this->getGLContext();
if (NULL == glContext) {
SkASSERT(kBitmap_DeviceType == fDeviceType);
return;

4
tools/PictureRenderer.h
View File

@ -30,7 +30,7 @@
class SkBitmap;
class SkCanvas;
class SkGLContext;
class SkGLContextHelper;
class SkThread;
namespace sk_tools {
@ -369,7 +369,7 @@ public:
}
}
SkGLContext* getGLContext() {
SkGLContextHelper* getGLContext() {
GrContextFactory::GLContextType glContextType
= GrContextFactory::kNull_GLContextType;
switch(fDeviceType) {

4
tools/timer/GpuTimer.cpp
View File

@ -6,10 +6,10 @@
* found in the LICENSE file.
*/
#include "GpuTimer.h"
#include "gl/SkGLContext.h"
#include "gl/SkGLContextHelper.h"
#include "gl/GrGLUtil.h"
GpuTimer::GpuTimer(const SkGLContext* glctx) : fContext(glctx) {
GpuTimer::GpuTimer(const SkGLContextHelper* glctx) : fContext(glctx) {
if (fContext) {
fContext->ref();
fContext->makeCurrent();

6
tools/timer/GpuTimer.h
View File

@ -7,18 +7,18 @@
#ifndef GpuTimer_DEFINED
#define GpuTimer_DEFINED
class SkGLContext;
class SkGLContextHelper;
class GpuTimer {
public:
GpuTimer(const SkGLContext*);
GpuTimer(const SkGLContextHelper*);
~GpuTimer();
void start();
double end();
private:
unsigned fQuery;
int fStarted;
const SkGLContext* fContext;
const SkGLContextHelper* fContext;
bool fSupported;
};

2
tools/timer/Timer.cpp
View File

@ -6,7 +6,7 @@
*/
#include "Timer.h"
Timer::Timer(SkGLContext* gl)
Timer::Timer(SkGLContextHelper* gl)
: fCpu(-1.0)
, fWall(-1.0)
, fTruncatedCpu(-1.0)

4
tools/timer/Timer.h
View File

@ -21,7 +21,7 @@
#include "GpuTimer.h"
#endif
class SkGLContext;
class SkGLContextHelper;
/**
* SysTimers and GpuTimers are implemented orthogonally.
@ -34,7 +34,7 @@ class SkGLContext;
*/
class Timer {
public:
explicit Timer(SkGLContext* gl = NULL);
explicit Timer(SkGLContextHelper* gl = NULL);
void start();
void truncatedEnd();