/**
* \brief uninitialize OpenGL context, freeing textures, buffers etc.
*/
static void uninitGl(void) {
int i = 0;
if (DeletePrograms && fragprog)
DeletePrograms(1, &fragprog);
fragprog = 0;
while (default_texs[i] != 0)
i++;
if (i)
DeleteTextures(i, default_texs);
default_texs[0] = 0;
clearOSD();
clearEOSD();
if (largeeosdtex[0])
DeleteTextures(2, largeeosdtex);
largeeosdtex[0] = 0;
if (DeleteBuffers && gl_buffer)
DeleteBuffers(1, &gl_buffer);
gl_buffer = 0; gl_buffersize = 0;
gl_bufferptr = NULL;
if (DeleteBuffers && gl_buffer_uv[0])
DeleteBuffers(2, gl_buffer_uv);
gl_buffer_uv[0] = gl_buffer_uv[1] = 0; gl_buffersize_uv = 0;
gl_bufferptr_uv[0] = gl_bufferptr_uv[1] = 0;
#ifdef CONFIG_GL_X11
if (mesa_bufferptr)
FreeMemoryMESA(mDisplay, mScreen, mesa_bufferptr);
#endif
mesa_bufferptr = NULL;
err_shown = 0;
}
GrGLuint SkANGLEGLContext::eglImageToExternalTexture(GrEGLImage image) const {
GrGLClearErr(this->gl());
if (!this->gl()->hasExtension("GL_OES_EGL_image_external")) {
return 0;
}
GrGLEGLImageTargetTexture2DProc glEGLImageTargetTexture2D =
(GrGLEGLImageTargetTexture2DProc)eglGetProcAddress("glEGLImageTargetTexture2DOES");
if (!glEGLImageTargetTexture2D) {
return 0;
}
GrGLuint texID;
GR_GL_CALL(this->gl(), GenTextures(1, &texID));
if (!texID) {
return 0;
}
GR_GL_CALL(this->gl(), BindTexture(GR_GL_TEXTURE_EXTERNAL, texID));
if (GR_GL_GET_ERROR(this->gl()) != GR_GL_NO_ERROR) {
GR_GL_CALL(this->gl(), DeleteTextures(1, &texID));
return 0;
}
glEGLImageTargetTexture2D(GR_GL_TEXTURE_EXTERNAL, image);
if (GR_GL_GET_ERROR(this->gl()) != GR_GL_NO_ERROR) {
GR_GL_CALL(this->gl(), DeleteTextures(1, &texID));
return 0;
}
return texID;
}
/**
* \brief remove all OSD textures and display-lists, thus clearing it.
*/
static void clearOSD(void) {
int i;
if (!osdtexCnt)
return;
DeleteTextures(osdtexCnt, osdtex);
#ifndef FAST_OSD
DeleteTextures(osdtexCnt, osdatex);
for (i = 0; i < osdtexCnt; i++)
DeleteLists(osdaDispList[i], 1);
#endif
for (i = 0; i < osdtexCnt; i++)
DeleteLists(osdDispList[i], 1);
osdtexCnt = 0;
}
void
GrallocDeprecatedTextureHostOGL::SwapTexturesImpl(const SurfaceDescriptor& aImage,
nsIntRegion*)
{
MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TSurfaceDescriptorGralloc);
if (mBuffer) {
// only done for hacky fix in gecko 23 for bug 862324.
RegisterDeprecatedTextureHostAtGrallocBufferActor(nullptr, *mBuffer);
}
const SurfaceDescriptorGralloc& desc = aImage.get_SurfaceDescriptorGralloc();
mGraphicBuffer = GrallocBufferActor::GetFrom(desc);
mIsRBSwapped = desc.isRBSwapped();
mFormat = SurfaceFormatForAndroidPixelFormat(mGraphicBuffer->getPixelFormat(),
mIsRBSwapped);
mTextureTarget = TextureTargetForAndroidPixelFormat(mGraphicBuffer->getPixelFormat());
DeleteTextures();
// only done for hacky fix in gecko 23 for bug 862324.
// Doing this in SetBuffer is not enough, as DeprecatedImageHostBuffered::SwapTextures can
// change the value of *mBuffer without calling SetBuffer again.
RegisterDeprecatedTextureHostAtGrallocBufferActor(this, aImage);
}
//--------------------------------------------------------------------------------------
// Name: Destroy()
// Desc: Invoked when scene is destroyed.
//--------------------------------------------------------------------------------------
VOID CSample::Destroy()
{
// Release shaders
if( m_MultiSampleShaderProgram )
glDeleteProgram(m_MultiSampleShaderProgram);
// Release textures
if( m_pLogoTexture )
m_pLogoTexture->Release();
/* Release the vertex buffer object */
if (m_vbo_id != 0)
{
glDeleteBuffers(1, &m_vbo_id);
m_vbo_id = 0;
}
/* Release the framebuffer object */
if (m_fboId != 0)
{
glDeleteFramebuffers(1, &m_fboId);
m_fboId = 0;
}
DeleteTextures();
/* Release the vertex array object */
if (m_vao_id != 0)
{
glDeleteVertexArrays(1,
&m_vao_id);
m_vao_id = 0;
}
}
void GrallocDeprecatedTextureHostOGL::SetCompositor(Compositor* aCompositor)
{
CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
if (mCompositor && !glCompositor) {
DeleteTextures();
}
mCompositor = glCompositor;
}
void GLVec4ScalarBench::teardown(const GrGLInterface* gl) {
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fFboTextureId));
GR_GL_CALL(gl, DeleteProgram(fProgram));
GR_GL_CALL(gl, DeleteBuffers(1, &fVboId));
}
void
SurfaceStreamHostOGL::SetCompositor(Compositor* aCompositor)
{
CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
if (mGL && !glCompositor) {
DeleteTextures();
}
mGL = glCompositor ? glCompositor->gl() : nullptr;
}
void
TiledDeprecatedTextureHostOGL::SetCompositor(Compositor* aCompositor)
{
CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
if (mGL && !glCompositor) {
DeleteTextures();
}
mGL = glCompositor ? glCompositor->gl() : nullptr;
}
void GrGLTexture::onRelease() {
if (fInfo.fID) {
if (GrBackendObjectOwnership::kBorrowed != fTextureIDOwnership) {
GL_CALL(DeleteTextures(1, &fInfo.fID));
}
fInfo.fID = 0;
}
INHERITED::onRelease();
}
/**
* \brief remove textures, display list and free memory used by EOSD
*/
static void clearEOSD(void) {
if (eosdDispList)
DeleteLists(eosdDispList, 1);
eosdDispList = 0;
if (eosdtexCnt)
DeleteTextures(eosdtexCnt, eosdtex);
eosdtexCnt = 0;
free(eosdtex);
eosdtex = NULL;
}
void GLCpuPosInstancedArraysBench::teardown(const GrGLInterface* gl) {
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindVertexArray(0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fTexture));
GR_GL_CALL(gl, DeleteProgram(fProgram));
GR_GL_CALL(gl, DeleteBuffers(fBuffers.count(), fBuffers.begin()));
GR_GL_CALL(gl, DeleteVertexArrays(1, &fVAO));
fBuffers.reset();
}
GrallocDeprecatedTextureHostOGL::~GrallocDeprecatedTextureHostOGL()
{
DeleteTextures();
// only done for hacky fix in gecko 23 for bug 862324.
if (mBuffer) {
// make sure that if the GrallocBufferActor survives us, it doesn't keep a dangling
// pointer to us.
RegisterDeprecatedTextureHostAtGrallocBufferActor(nullptr, *mBuffer);
}
}
void
GL::DeleteTexture(GLuint aTextureId)
{
MOZ_ASSERT(IsCurrent());
DeleteTextures(1, &aTextureId);
if (mBoundTextureId == aTextureId) {
mBoundTextureId = 0;
}
}
void GLInstancedArraysBench::onPerCanvasPostDraw(SkCanvas* canvas) {
// This bench exclusively tests GL calls directly
const GrGLContext* ctx = get_gl_context(canvas);
if (!ctx) {
return;
}
const GrGLInterface* gl = ctx->interface();
// teardown
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindVertexArray(0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fTexture));
this->teardown(gl);
}
void SkNativeSharedGLContext::destroyGLResources() {
if (fGL) {
// We need this thread to grab the GLX context before we can make
// OpenGL calls. But glXMakeCurrent() will flush the old context,
// which might have been uninitialized. Calling with (None, NULL)
// first solves this problem (somehow).
glXMakeCurrent(fDisplay, None, NULL);
glXMakeCurrent(fDisplay, fGlxPixmap, fContext);
SK_GL_NOERRCHECK(*this, DeleteFramebuffers(1, &fFBO));
SK_GL_NOERRCHECK(*this, DeleteTextures(1, &fTextureID));
SK_GL_NOERRCHECK(*this, DeleteRenderbuffers(1, &fDepthStencilBufferID));
}
glXMakeCurrent(fDisplay, None, NULL);
glXDestroyGLXPixmap(fDisplay, fGlxPixmap);
fGlxPixmap = 0;
}
void ResetWorld( INDEX iWorld )
{
PWORLD world = GetSetMember( WORLD, &g.worlds, iWorld );
//SectorIDs = 0;
DeleteSectors( iWorld );// deletes walls also...
// should probably check that all walls are now now treferences...
DeleteSet( (PGENERICSET*)&world->walls );
// should probably check that all lines are now now treferences...
DeleteSet( (PGENERICSET*)&world->lines );
DeleteTextures( iWorld );
DeleteNames( iWorld );
//if( world->spacetree )
//{
// Log( "Spaces remained on the tree..." );
// DeleteSpaceTree( &world->spacetree );
//}
}
static void cleanup(SkGLContext* glctx0, GrGLuint texID0, SkGLContext* glctx1, GrContext* grctx1,
const GrGLTextureInfo* grbackendtex1, GrEGLImage image1) {
if (glctx1) {
glctx1->makeCurrent();
if (grctx1) {
if (grbackendtex1) {
GrGLGpu* gpu1 = static_cast<GrGLGpu*>(grctx1->getGpu());
GrBackendObject handle = reinterpret_cast<GrBackendObject>(grbackendtex1);
gpu1->deleteTestingOnlyBackendTexture(handle, false);
}
grctx1->unref();
}
if (GR_EGL_NO_IMAGE != image1) {
glctx1->destroyEGLImage(image1);
}
}
glctx0->makeCurrent();
if (texID0) {
GR_GL_CALL(glctx0->gl(), DeleteTextures(1, &texID0));
}
}
//--------------------------------------------------------------------------------------
// Name: InitTexture()
// Desc: Set up Texture
//--------------------------------------------------------------------------------------
BOOL CSample::InitTexture()
{
GLint n_max_color_texture_samples = 0;
DeleteTextures();
glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, 1, &n_max_color_texture_samples);
for (UINT32 n_texture = 0;n_texture < NO_MULTIMPLE_TEXTURES; ++n_texture)
{
UINT32 n_texture_samples = n_max_color_texture_samples * n_texture / (NO_MULTIMPLE_TEXTURES - 1);
if (n_texture_samples == 0)
{
/* Requesting zero samples is not permitted */
n_texture_samples = 1;
}
GLuint texture_id;
glGenTextures( 1, &texture_id );
g_textures[n_texture].n_samples = n_texture_samples;
g_textures[n_texture].texture = texture_id;
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE,
g_textures[n_texture].texture);
glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE,
n_texture_samples,
GL_RGBA8,
m_nWidth,
m_nHeight,
GL_FALSE); /* fixedsamplelocations */
} /* for (all multisample textures that need to be initialized) */
return TRUE;
}
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
sk_gpu_test::GLTestContext* glContext = ctxInfo.glContext();
static const int kWidth = 13;
static const int kHeight = 13;
GrColor pixels[kWidth * kHeight];
for (int y = 0; y < kHeight; ++y) {
for (int x = 0; x < kWidth; ++x) {
pixels[y * kWidth + x] = y * kWidth + x;
}
}
for (int origin = 0; origin < 2; ++origin) {
GrGLuint rectTexID = glContext->createTextureRectangle(kWidth, kHeight, GR_GL_RGBA,
GR_GL_RGBA, GR_GL_UNSIGNED_BYTE,
pixels);
if (!rectTexID) {
return;
}
// Let GrContext know that we messed with the GL context directly.
context->resetContext();
// Wrap the rectangle texture ID in a GrTexture
GrGLTextureInfo rectangleInfo;
rectangleInfo.fID = rectTexID;
rectangleInfo.fTarget = GR_GL_TEXTURE_RECTANGLE;
GrBackendTextureDesc rectangleDesc;
rectangleDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
rectangleDesc.fConfig = kRGBA_8888_GrPixelConfig;
rectangleDesc.fWidth = kWidth;
rectangleDesc.fHeight = kHeight;
rectangleDesc.fOrigin = origin ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
rectangleDesc.fTextureHandle = reinterpret_cast<GrBackendObject>(&rectangleInfo);
GrColor refPixels[kWidth * kHeight];
bool flipRef = rectangleDesc.fOrigin == kBottomLeft_GrSurfaceOrigin;
for (int y = 0; y < kHeight; ++y) {
for (int x = 0; x < kWidth; ++x) {
int y0 = flipRef ? kHeight - y - 1 : y;
refPixels[y * kWidth + x] = pixels[y0 * kWidth + x];
}
}
SkAutoTUnref<GrTexture> rectangleTexture(
context->textureProvider()->wrapBackendTexture(rectangleDesc));
if (!rectangleTexture) {
ERRORF(reporter, "Error wrapping rectangle texture in GrTexture.");
GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));
continue;
}
test_read_pixels(reporter, context, rectangleTexture, refPixels);
test_copy_surface_src(reporter, context, rectangleTexture, refPixels);
test_copy_surface_dst(reporter, context, rectangleTexture);
test_write_pixels(reporter, context, rectangleTexture);
test_clear(reporter, context, rectangleTexture);
GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));
}
}
TiledTextureHostOGL::~TiledTextureHostOGL()
{
DeleteTextures();
}
TiledDeprecatedTextureHostOGL::~TiledDeprecatedTextureHostOGL()
{
DeleteTextures();
}
/////////////////////////////////////////////////////////////////////////
//
// Function: Shutdown
//
// Last Modified: 03/08/2007
//
// Purpose: Initializes the TextureManager10 class
//
//////////////////////////////////////////////////////////////////////////
void CTextureManager10::Shutdown()
{
DeleteTextures();
}
GL_APICALL void GL_APIENTRY glDeleteTextures (GLsizei n, const GLuint* textures)
{
CONTEXT_EXEC(DeleteTextures(n,textures));
}
void GLInterfaceWrapper::DeleteTexture( GLuint& texture ) const {
DeleteTextures( 1, &texture );
texture = 0;
}
UIOpenGLTextures::~UIOpenGLTextures()
{
DeleteTextures();
}
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_gpu_test::GLTestContext* glContext = ctxInfo.glContext();
static const int kWidth = 13;
static const int kHeight = 13;
GrColor pixels[kWidth * kHeight];
for (int y = 0; y < kHeight; ++y) {
for (int x = 0; x < kWidth; ++x) {
pixels[y * kWidth + x] = y * kWidth + x;
}
}
for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
bool useBLOrigin = kBottomLeft_GrSurfaceOrigin == origin;
GrGLuint rectTexID = glContext->createTextureRectangle(kWidth, kHeight, GR_GL_RGBA,
GR_GL_RGBA, GR_GL_UNSIGNED_BYTE,
pixels);
if (!rectTexID) {
return;
}
// Let GrContext know that we messed with the GL context directly.
context->resetContext();
// Wrap the rectangle texture ID in a GrTexture
GrGLTextureInfo rectangleInfo;
rectangleInfo.fID = rectTexID;
rectangleInfo.fTarget = GR_GL_TEXTURE_RECTANGLE;
GrBackendTexture rectangleTex(kWidth, kHeight, kRGBA_8888_GrPixelConfig, rectangleInfo);
GrColor refPixels[kWidth * kHeight];
for (int y = 0; y < kHeight; ++y) {
for (int x = 0; x < kWidth; ++x) {
int y0 = useBLOrigin ? kHeight - y - 1 : y;
refPixels[y * kWidth + x] = pixels[y0 * kWidth + x];
}
}
sk_sp<GrTextureProxy> rectProxy = proxyProvider->wrapBackendTexture(rectangleTex, origin);
if (!rectProxy) {
ERRORF(reporter, "Error creating proxy for rectangle texture.");
GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));
continue;
}
SkASSERT(rectProxy->texPriv().doesNotSupportMipMaps());
SkASSERT(rectProxy->priv().peekTexture()->surfacePriv().doesNotSupportMipMaps());
SkASSERT(rectProxy->texPriv().isClampOnly());
SkASSERT(rectProxy->priv().peekTexture()->surfacePriv().isClampOnly());
test_basic_draw_as_src(reporter, context, rectProxy, refPixels);
// Test copy to both a texture and RT
test_copy_from_surface(reporter, context, rectProxy.get(), refPixels,
false, "RectangleTexture-copy-from");
sk_sp<GrSurfaceContext> rectContext = context->contextPriv().makeWrappedSurfaceContext(
std::move(rectProxy));
SkASSERT(rectContext);
test_read_pixels(reporter, rectContext.get(), refPixels, "RectangleTexture-read");
test_copy_to_surface(reporter, context->contextPriv().proxyProvider(),
rectContext.get(), "RectangleTexture-copy-to");
test_write_pixels(reporter, rectContext.get(), true, "RectangleTexture-write");
test_clear(reporter, rectContext.get());
GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));
}
}
