bool end()
{
glDeleteBuffers(1, &BufferName);
glDeleteProgram(ProgramName);
glDeleteTextures(1, &TextureName);
glDeleteSamplers(1, &SamplerAName);
glDeleteSamplers(1, &SamplerBName);
glDeleteVertexArrays(1, &VertexArrayName);
return true;
}
bool end()
{
glDeleteBuffers(1, &BufferName);
glDeleteProgram(ProgramName);
glDeleteTextures(1, &TextureName);
glDeleteSamplers(1, &SamplerAName);
glDeleteSamplers(1, &SamplerBName);
glDeleteVertexArrays(1, &VertexArrayName);
return glf::checkError("end");
}
GLTextureSamplerObject::~GLTextureSamplerObject()
{
if (mGLSampObj != 0)
{
glDeleteSamplers(1, &mGLSampObj);
}
}
/*-----------------------------------------------------------------------------------------------
Description:
Cleans up GPU memory. This might happen when the processes die, but be a good memory steward
and clean up properly.
Note: A big program would have the textures, program IDs, buffers, and other things
encapsulated somewhere, and each other those would do the cleanup, but in this barebones
demo, I can just clean up everything here.
Parameters: None
Returns: None
Exception: Safe
Creator: John Cox (2-13-2016)
-----------------------------------------------------------------------------------------------*/
void CleanupAll()
{
glDeleteProgram(gProgramId);
// these deletion functions need the buffer ID, but they take a (void *) for the second
// argument in the event that the user has an array of IDs (legacy OpenGL stuff that isn't
// used much anymore, if at all), so pass in the buffer ID's address and tell it to delete 1
// Note: The second argument is treated like an array, so if I were to pass in the address
// of a single GLuint and tell it to delete 2, then it will either (1) blow up or
// (2) silently delete something I didn't want. Both are bad, so treat it nice.
// Also Note: If I attempt to delete an ID that has already been deleted, that is ok. OpenGL
// will silently swallow that.
glDeleteBuffers(1, &gTriangle._arrayBufferId);
glDeleteBuffers(1, &gTriangle._elementBufferId);
glDeleteVertexArrays(1, &gTriangle._vaoId);
glDeleteBuffers(1, &gBox._arrayBufferId);
glDeleteBuffers(1, &gBox._elementBufferId);
glDeleteVertexArrays(1, &gBox._vaoId);
glDeleteBuffers(1, &gCircle._arrayBufferId);
glDeleteBuffers(1, &gCircle._elementBufferId);
glDeleteVertexArrays(1, &gCircle._vaoId);
glDeleteTextures(1, &gTexture1Id);
glDeleteTextures(1, &gTexture2Id);
glDeleteTextures(1, &gTexture3Id);
glDeleteSamplers(1, &gSamplerId);
}
Ground::~Ground() {
glDeleteVertexArrays(1, &vertexArrayID);
glDeleteBuffers(1, &hmdataVertexBufferID);
glDeleteBuffers(1, &indexVertexBufferID);
glDeleteTextures(1, &textureID);
glDeleteSamplers(1, &samplerID);
}
SamplerStateGL4::~SamplerStateGL4()
{
if (samplerObject) {
glDeleteSamplers(1, samplerObject->Data());
POMDOG_CHECK_ERROR_GL4("glDeleteSamplers");
}
}
void GLTexture::deleteTexture(void)
{
// Deletes the texture object from GPU memory if it ever existed.
if(sampler != 0) glDeleteSamplers(1, &sampler);
// Deletes the sampler object from GPU memory if it ever existed.
if(texture != 0) glDeleteTextures(1, &texture);
}
void SamplerCache::Clear()
{
for (auto& p : m_cache)
{
glDeleteSamplers(1, &p.second.sampler_id);
}
m_cache.clear();
}
void SamplerCache::Clear()
{
for (auto& p : m_cache)
glDeleteSamplers(1, &p.second);
for (auto& p : m_active_samplers)
p.second = 0;
m_cache.clear();
}
OpenGLSamplerState::~OpenGLSamplerState()
{
if (mSamplerOGL)
{
glDeleteSamplers(1, &mSamplerOGL);
mSamplerOGL = 0;
}
}
HdSimpleTextureResource::~HdSimpleTextureResource()
{
if (!_isPtex) {
if (!glDeleteSamplers) { // GL initialization guard for headless unit test
return;
}
glDeleteSamplers(1, &_sampler);
}
}
void wined3d_sampler_destroy(struct wined3d_sampler *sampler)
{
struct wined3d_context *context = context_acquire(sampler->device, NULL);
const struct wined3d_gl_info *gl_info = context->gl_info;
GL_EXTCALL(glDeleteSamplers(1, &sampler->name));
context_release(context);
HeapFree(GetProcessHeap(), 0, sampler);
}
MeshComponent::~MeshComponent()
{
glDeleteVertexArrays(1, &vertexArray);
glDeleteBuffers(1, &m_vertexBuffer);
if(glIsTexture(meshTexture) == GL_TRUE)
glDeleteTextures(1, &meshTexture);
if(glIsSampler(meshSampler) == GL_TRUE)
glDeleteSamplers(1, &meshSampler);
}
Clouds::~Clouds()
{
glDeleteFramebuffers(1, &fourierOpacityMap_FBO[0]);
glDeleteFramebuffers(1, &fourierOpacityMap_FBO[1]);
glDeleteTextures(2, fourierOpacityMap_Textures[0]);
glDeleteTextures(2, fourierOpacityMap_Textures[1]);
glDeleteSamplers(1, &linearSampler_noMipMaps);
glDeleteSamplers(1, &linearSampler_MipMaps);
glDeleteVertexArrays(1, &vao_cloudParticleBuffer_Read);
glDeleteVertexArrays(1, &vao_cloudParticleBuffer_Write);
glDeleteBuffers(1, &vbo_cloudParticleBuffer_Read[0]);
glDeleteBuffers(1, &vbo_cloudParticleBuffer_Write[0]);
glDeleteBuffers(1, &vbo_cloudParticleBuffer_Read[1]);
glDeleteBuffers(1, &vbo_cloudParticleBuffer_Write[1]);
glDeleteBuffers(1, &vbo_cloudParticleBuffer_Read[2]);
glDeleteBuffers(1, &vbo_cloudParticleBuffer_Write[2]);
glDeleteBuffers(1, &ibo_cloudParticleRendering);
glDeleteBuffers(1, &noiseTexture);
}
bool end()
{
glDeleteBuffers(buffer::MAX, BufferName);
glDeleteProgram(ProgramName);
glDeleteTextures(texture::MAX, TextureName);
glDeleteSamplers(1, &SamplerName);
glDeleteVertexArrays(1, &VertexArrayName);
return this->checkError("end");
}
void font_impl::destroyGLResources()
{
if (mIsFontLoaded) {
if (mProgram) glDeleteProgram(mProgram);
if (mVBO) glDeleteBuffers(1, &mVBO);
glDeleteTextures(NUM_CHARS, mCharTextures);
}
if (mProgram) glDeleteProgram(mProgram);
if (mSampler) glDeleteSamplers(1, &mSampler);
}
//---------------------------------------------------------------------------//
void TextureSamplerGL4::destroy()
{
if (m_uHandleGL != GLUINT_HANDLE_INVALID)
{
glDeleteSamplers(1u, &m_uHandleGL);
m_uHandleGL = GLUINT_HANDLE_INVALID;
m_properties = TextureSamplerDesc();
}
}
bool end()
{
glDeleteSamplers(viewport::MAX, SamplerName);
glDeleteBuffers(1, &BufferName);
glDeleteProgram(ProgramName);
glDeleteTextures(1, &Texture2DName);
glDeleteVertexArrays(1, &VertexArrayName);
return this->checkError("end");
}
CompositeFBOQuad::~CompositeFBOQuad(void)
{
// Delete the shaders and shader program to clear up GPU memory.
vert.deleteShader();
frag.deleteShader();
shaderProgram.deleteProgram();
glDeleteVertexArrays(1, &vertexArray);
glDeleteBuffers(2, vboHandles);
glDeleteSamplers(1, &sampler);
}
static void
hash_table_free_gl_cb(void *key, void *value, void *user_data)
{
cg_device_t *dev = user_data;
cg_sampler_cache_entry_t *entry = value;
if (_cg_has_private_feature(dev, CG_PRIVATE_FEATURE_SAMPLER_OBJECTS))
GE(dev, glDeleteSamplers(1, &entry->sampler_object));
c_slice_free(cg_sampler_cache_entry_t, entry);
}
bool end()
{
glDeleteBuffers(buffer::MAX, &BufferName[0]);
glDeleteProgram(ProgramName);
glDeleteTextures(texture::MAX, &TextureName[0]);
glDeleteFramebuffers(framebuffer::MAX, &FramebufferName[0]);
glDeleteVertexArrays(1, &VertexArrayName);
glDeleteSamplers(1, &SamplerName);
return true;
}
bool end()
{
glDeleteVertexArrays(PROGRAM_MAX, VertexArrayName);
glDeleteBuffers(BUFFER_MAX, BufferName);
glDeleteTextures(1, &TextureColorbufferName);
glDeleteFramebuffers(1, &FramebufferName);
glDeleteProgram(ProgramName[IMAGE_2D]);
glDeleteProgram(ProgramName[LAYERING]);
glDeleteSamplers(1, &SamplerName);
return glf::checkError("end");
}
bool end()
{
glDeleteSamplers(pipeline::MAX, &SamplerName[0]);
glDeleteProgramPipelines(pipeline::MAX, &PipelineName[0]);
glDeleteProgram(ProgramName[pipeline::SPLASH]);
glDeleteProgram(ProgramName[pipeline::RENDER]);
glDeleteFramebuffers(framebuffer::MAX, &FramebufferName[0]);
glDeleteTextures(texture::MAX, &TextureName[0]);
glDeleteVertexArrays(pipeline::MAX, &VertexArrayName[0]);
return true;
}
bool end()
{
glDeleteTextures(texture::MAX, &TextureName[0]);
glDeleteFramebuffers(1, &FramebufferName);
glDeleteProgram(ProgramName[program::BLIT]);
glDeleteProgram(ProgramName[program::UPDATE]);
glDeleteVertexArrays(1, &VertexArrayName);
glDeleteSamplers(1, &SamplerName);
glDeleteProgramPipelines(pipeline::MAX, &PipelineName[0]);
return true;
}
extern void
free_sampler(SAMPLER *sampler) {
assert(sampler != NULL);
#ifndef GL_ES_VERSION_2_0
if(glIsSampler(sampler->id))
glDeleteSamplers(1, &sampler->id);
#endif // NO GL_ES_VERSION_2_0
sampler->id = 0;
sampler->usage = 0;
}
bool end()
{
glDeleteVertexArrays(PIPELINE_MAX, VertexArrayName);
glDeleteBuffers(BUFFER_MAX, BufferName);
glDeleteTextures(1, &TextureColorbufferName);
glDeleteFramebuffers(1, &FramebufferName);
glDeleteProgram(ProgramName[VIEWPORT]);
glDeleteProgram(ProgramName[LAYERING]);
glDeleteSamplers(1, &SamplerName);
return true;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
bool pass = true;
GLuint tex, sampler, fb;
const float tex_data[16] = {0, 1, 0, 0,
1, 0, 0, 0,
1, 0, 0, 0,
1, 0, 0, 0};
const float *green = tex_data;
glClearColor(0, 0, 1, 0);
glClear(GL_COLOR_BUFFER_BIT);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 2, 2, 0,
GL_RGBA, GL_FLOAT, tex_data);
glGenFramebuffers(1, &fb);
glBindFramebuffer(GL_FRAMEBUFFER, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
glGenSamplers(1, &sampler);
glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindSampler(0, sampler);
glBindFramebuffer(GL_READ_FRAMEBUFFER, fb);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, piglit_winsys_fbo);
glBlitFramebuffer(0, 0, 1, 1,
0, 0, piglit_width, piglit_height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_FRAMEBUFFER, piglit_winsys_fbo);
pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green);
piglit_present_results();
glDeleteSamplers(1, &sampler);
glDeleteTextures(1, &tex);
glDeleteFramebuffers(1, &fb);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
bool end()
{
bool Validated(true);
glDeleteProgramPipelines(pipeline::MAX, &PipelineName[0]);
glDeleteProgram(ProgramName[pipeline::SPLASH]);
glDeleteBuffers(buffer::MAX, BufferName);
glDeleteSamplers(1, &SamplerName);
glDeleteTextures(texture::MAX, &TextureName[0]);
glDeleteVertexArrays(1, &VertexArrayName);
return Validated;
}
bool end()
{
glDeleteProgramPipelines(program::MAX, PipelineName);
glDeleteBuffers(buffer::MAX, BufferName);
glDeleteSamplers(1, &SamplerName);
glDeleteTextures(texture::MAX, TextureName);
glDeleteFramebuffers(1, &FramebufferName);
glDeleteVertexArrays(1, &VertexArrayName);
for(int i = 0; i < program::MAX; ++i)
glDeleteProgram(ProgramName[i]);
return true;
}
bool end()
{
glDeleteBuffers(1, &BufferName);
for(int i = 0; i < program::MAX; ++i)
glDeleteProgram(ProgramName[i]);
glDeleteSamplers(1, &SamplerName);
glDeleteTextures(renderbuffer::MAX, RenderbufferName);
glDeleteTextures(texture::MAX, TextureName);
glDeleteFramebuffers(1, &FramebufferName);
glDeleteVertexArrays(1, &VertexArrayName);
return this->checkError("end");
}
