/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef SCOPEDGLHELPERS_H_
#define SCOPEDGLHELPERS_H_
#include "GLDefs.h"
#include "mozilla/UniquePtr.h"
namespace mozilla {
namespace gl {
class GLContext;
#ifdef DEBUG
bool IsContextCurrent(GLContext* gl);
#endif
// Wraps glEnable/Disable.
struct ScopedGLState final {
private:
GLContext*
const mGL;
const GLenum mCapability;
bool mOldState;
public:
// Use |newState = true| to enable, |false| to disable.
ScopedGLState(GLContext* aGL, GLenum aCapability,
bool aNewState);
// variant that doesn't change state; simply records existing state to be
// restored by the destructor
ScopedGLState(GLContext* aGL, GLenum aCapability);
~ScopedGLState();
};
// Saves and restores with GetUserBoundFB and BindUserFB.
struct ScopedBindFramebuffer final {
private:
GLContext*
const mGL;
GLuint mOldReadFB;
GLuint mOldDrawFB;
void Init();
public:
explicit ScopedBindFramebuffer(GLContext* aGL);
ScopedBindFramebuffer(GLContext* aGL, GLuint aNewFB);
~ScopedBindFramebuffer();
};
struct ScopedBindTextureUnit final {
private:
GLContext*
const mGL;
GLenum mOldTexUnit;
public:
ScopedBindTextureUnit(GLContext* aGL, GLenum aTexUnit);
~ScopedBindTextureUnit();
};
struct ScopedTexture final {
private:
GLContext*
const mGL;
GLuint mTexture;
public:
explicit ScopedTexture(GLContext* aGL);
~ScopedTexture();
GLuint Texture()
const {
return mTexture; }
operator GLuint()
const {
return mTexture; }
};
struct ScopedFramebuffer final {
private:
GLContext*
const mGL;
GLuint mFB;
public:
explicit ScopedFramebuffer(GLContext* aGL);
~ScopedFramebuffer();
const auto& FB()
const {
return mFB; }
operator GLuint()
const {
return mFB; }
};
struct ScopedRenderbuffer final {
private:
GLContext*
const mGL;
GLuint mRB;
public:
explicit ScopedRenderbuffer(GLContext* aGL);
~ScopedRenderbuffer();
GLuint RB() {
return mRB; }
operator GLuint()
const {
return mRB; }
};
struct ScopedBindTexture final {
private:
GLContext*
const mGL;
const GLenum mTarget;
const GLuint mOldTex;
public:
ScopedBindTexture(GLContext* aGL, GLuint aNewTex,
GLenum aTarget = LOCAL_GL_TEXTURE_2D);
~ScopedBindTexture();
};
struct ScopedBindRenderbuffer final {
private:
GLContext*
const mGL;
GLuint mOldRB;
private:
void Init();
public:
explicit ScopedBindRenderbuffer(GLContext* aGL);
ScopedBindRenderbuffer(GLContext* aGL, GLuint aNewRB);
~ScopedBindRenderbuffer();
};
struct ScopedFramebufferForTexture final {
private:
GLContext*
const mGL;
bool mComplete;
// True if the framebuffer we create is complete.
GLuint mFB;
public:
ScopedFramebufferForTexture(GLContext* aGL, GLuint aTexture,
GLenum aTarget = LOCAL_GL_TEXTURE_2D);
~ScopedFramebufferForTexture();
bool IsComplete()
const {
return mComplete; }
GLuint FB()
const {
MOZ_GL_ASSERT(mGL, IsComplete());
return mFB;
}
};
struct ScopedFramebufferForRenderbuffer final {
private:
GLContext*
const mGL;
bool mComplete;
// True if the framebuffer we create is complete.
GLuint mFB;
public:
ScopedFramebufferForRenderbuffer(GLContext* aGL, GLuint aRB);
~ScopedFramebufferForRenderbuffer();
bool IsComplete()
const {
return mComplete; }
GLuint FB()
const {
MOZ_GL_ASSERT(mGL, IsComplete());
return mFB;
}
};
struct ScopedViewportRect final {
private:
GLContext*
const mGL;
GLint mSavedViewportRect[4];
public:
ScopedViewportRect(GLContext* aGL, GLint x, GLint y, GLsizei width,
GLsizei height);
~ScopedViewportRect();
};
struct ScopedScissorRect final {
private:
GLContext*
const mGL;
GLint mSavedScissorRect[4];
public:
ScopedScissorRect(GLContext* aGL, GLint x, GLint y, GLsizei width,
GLsizei height);
explicit ScopedScissorRect(GLContext* aGL);
~ScopedScissorRect();
};
struct ScopedVertexAttribPointer final {
private:
GLContext*
const mGL;
GLuint mAttribIndex;
GLint mAttribEnabled;
GLint mAttribSize;
GLint mAttribStride;
GLint mAttribType;
GLint mAttribNormalized;
GLint mAttribBufferBinding;
void* mAttribPointer;
GLuint mBoundBuffer;
public:
ScopedVertexAttribPointer(GLContext* aGL, GLuint index, GLint size,
GLenum type, realGLboolean normalized,
GLsizei stride, GLuint buffer,
const GLvoid* pointer);
explicit ScopedVertexAttribPointer(GLContext* aGL, GLuint index);
~ScopedVertexAttribPointer();
private:
void WrapImpl(GLuint index);
};
struct ScopedPackState final {
private:
GLContext*
const mGL;
GLint mAlignment;
GLuint mPixelBuffer;
GLint mRowLength;
GLint mSkipPixels;
GLint mSkipRows;
public:
explicit ScopedPackState(GLContext* gl);
~ScopedPackState();
// Returns whether the stride was handled successfully.
bool SetForWidthAndStrideRGBA(GLsizei aWidth, GLsizei aStride);
};
struct ResetUnpackState final {
private:
GLContext*
const mGL;
GLuint mAlignment;
GLuint mPBO;
GLuint mRowLength;
GLuint mImageHeight;
GLuint mSkipPixels;
GLuint mSkipRows;
GLuint mSkipImages;
public:
explicit ResetUnpackState(GLContext* gl);
~ResetUnpackState();
};
struct ScopedBindPBO final {
private:
GLContext*
const mGL;
const GLenum mTarget;
const GLuint mPBO;
public:
ScopedBindPBO(GLContext* gl, GLenum target);
~ScopedBindPBO();
};
}
/* namespace gl */
}
/* namespace mozilla */
#endif /* SCOPEDGLHELPERS_H_ */
