void fini_brush(int i)
{
struct brush *b = get_brush(i);
if (b->state == 1)
{
/* Finalize any vertex and fragment shader objects. */
if (GL_has_shader_objects)
{
if (b->shad_prog) glDeleteObjectARB(b->shad_prog);
if (b->vert_shad) glDeleteObjectARB(b->vert_shad);
if (b->frag_shad) glDeleteObjectARB(b->frag_shad);
}
/* Finalize any vertex and fragment programs. */
if (GL_has_vertex_program)
if (glIsProgramARB(b->vert_prog))
glDeleteProgramsARB(1, &b->vert_prog);
if (GL_has_fragment_program)
if (glIsProgramARB(b->frag_prog))
glDeleteProgramsARB(1, &b->frag_prog);
b->vert_shad = 0;
b->frag_shad = 0;
b->shad_prog = 0;
b->vert_prog = 0;
b->frag_prog = 0;
b->state = 0;
}
}
void ARBDepthFillProgram::destroy()
{
glDeleteProgramsARB(1, &m_vertex_program);
glDeleteProgramsARB(1, &m_fragment_program);
GlobalOpenGL().assertNoErrors();
}
static void
arbfvp_delete_shaders(trixel_state t)
{
struct arbfvp_shaders * shaders = ARBFVP(t);
if(shaders) {
glDeleteProgramsARB(1, &shaders->vertex_program);
glDeleteProgramsARB(1, &shaders->fragment_program);
free(shaders);
}
}
void PixelShaderCache::Shutdown()
{
glDeleteProgramsARB(1, &s_ColorMatrixProgram);
s_ColorMatrixProgram = 0;
glDeleteProgramsARB(1, &s_DepthMatrixProgram);
s_DepthMatrixProgram = 0;
PSCache::iterator iter = PixelShaders.begin();
for (; iter != PixelShaders.end(); iter++)
iter->second.Destroy();
PixelShaders.clear();
}
void ATITShader::kill()
{
glDeleteProgramsARB(1, &mVertexProgram);
glDeleteProgramsARB(1, &mFragmentProgram);
for(U32 i = 0; i < mParameters.size(); i++)
{
delete mParameters[i];
}
mParameters.clear();
dFree(mPixelSourceString);
dFree(mVertexSourceString);
}
Shader::~Shader() {
if(vertex_target == GL_VERTEX_PROGRAM_ARB) {
if(vertex_id) glDeleteProgramsARB(1,&vertex_id);
}
if(fragment_target == GL_FRAGMENT_PROGRAM_ARB) {
if(fragment_id) glDeleteProgramsARB(1,&fragment_id);
} else if(fragment_target == GL_FRAGMENT_PROGRAM_NV) {
if(fragment_id) glDeleteProgramsNV(1,&fragment_id);
} else if(fragment_target == GL_COMBINE) {
glDeleteLists(fragment_id,1);
}
}
ModelDrawer::~ModelDrawer ()
{
if (s3oFP) glDeleteProgramsARB( 1, &s3oFP );
if (s3oVP) glDeleteProgramsARB( 1, &s3oVP );
if (s3oFPunlit) glDeleteProgramsARB( 1, &s3oFPunlit );
if (s3oVPunlit) glDeleteProgramsARB( 1, &s3oVPunlit );
if (skyboxTexture)
glDeleteTextures(1,&skyboxTexture);
if (sphereList)
glDeleteLists (sphereList,1);
}
void
CFrameBufferObject::freeResources()
{
if (m_fboData.fb) glDeleteFramebuffersEXT( 1, &m_fboData.fb);
if (m_fboData.resolveFB) glDeleteFramebuffersEXT( 1, &m_fboData.resolveFB);
if (m_fboData.colorRB) glDeleteRenderbuffersEXT( 1, &m_fboData.colorRB);
if (m_fboData.depthRB) glDeleteRenderbuffersEXT( 1, &m_fboData.depthRB);
if (m_fboData.colorTex) glDeleteTextures( 1, &m_fboData.colorTex);
if (m_fboData.depthTex) glDeleteTextures( 1, &m_fboData.depthTex);
glDeleteProgramsARB(1, &m_textureProgram);
glDeleteProgramsARB(1, &m_overlayProgram);
}
static void Key( unsigned char key, int x, int y )
{
(void) x;
(void) y;
switch (key) {
case 27:
glDeleteProgramsARB(1, &VertProg);
glDeleteProgramsARB(1, &FragProg);
glutDestroyWindow(Win);
exit(0);
break;
}
glutPostRedisplay();
}
void cleanup()
{
sdkDeleteTimer(&timer);
sdkDeleteTimer(&kernel_timer);
if (h_img)
{
free(h_img);
h_img=NULL;
}
if (d_img)
{
cudaFree(d_img);
d_img=NULL;
}
if (d_temp)
{
cudaFree(d_temp);
d_temp=NULL;
}
// Refer to boxFilter_kernel.cu for implementation
freeTextures();
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffersARB(1, &pbo);
glDeleteTextures(1, &texid);
glDeleteProgramsARB(1, &shader);
}
CAdvWater::~CAdvWater()
{
glDeleteTextures (1, &reflectTexture);
glDeleteTextures (1, &bumpTexture);
glDeleteTextures (4, rawBumpTexture);
glDeleteProgramsARB( 1, &waterFP );
}
void ResourceManager::recover()
{
if (sTextureList.size())
glDeleteTextures( (GLsizei) sTextureList.size(), &(*sTextureList.begin()));
if (sAsmProgramList.size())
glDeleteProgramsARB( (GLsizei) sAsmProgramList.size(), &(*sAsmProgramList.begin()));
for (std::vector<GLuint>::iterator it=sProgramList.begin(); it<sProgramList.end(); it++) {
glDeleteObject( *it);
}
{
for (std::vector<GLuint>::iterator it=sShaderList.begin(); it<sShaderList.end(); it++) {
glDeleteObject( *it);
}
}
sTextureList.clear();
sAsmProgramList.clear();
sProgramList.clear();
sShaderList.clear();
GL_CHECK;
}
PaletteRenderer::DataItem::~DataItem(void)
{
if(renderingPath==FragmentProgram)
glDeleteProgramsARB(1,&fragmentProgramId);
if(renderingPath==FragmentProgram||renderingPath==TextureShader)
glDeleteTextures(1,&paletteTextureObjectId);
}
void glSafeDeleteProgram(GLuint program)
{
if (!GLEW_ARB_vertex_program || (program == 0)) {
return;
}
glDeleteProgramsARB(1, &program);
}
/**
* The GL_ARB_fragment_shader spec, issue 23 says:
* (23) What is the result of a sample from an incomplete texture?
* The definition of texture completeness can be found in section 3.8.9
* of the core GL spec.
*
* RESOLVED: The result of a sample from an incomplete texture is the
* constant vector (0,0,0,1).
*
* In this test we swizzle RGBA->ABGR so we don't need to worry if the
* framebuffer has an alpha channel.
*/
GLboolean
test_arb_fp(void)
{
static const char *fragProgramText =
"!!ARBfp1.0\n"
"TEMP t1;\n"
"TEX t1, fragment.texcoord[0], texture[0], 2D;\n"
"MOV result.color, t1.abgr;\n"
"END\n";
static const GLfloat expected[4] = { 1.0, 0.0, 0.0, 0.0 };
int pos = 1;
GLboolean p;
GLuint prog;
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(fragProgramText),
(const GLubyte *) fragProgramText);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glColor3f(0, 1, 0);
draw_rect(1);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDeleteProgramsARB(1, &prog);
p = probe_pos(pos, expected);
if (!p)
printf(" Testing ARB fragment program\n");
return p;
}
GLuint HCoreLoadFragmentProgramOpenGL_ASM(const char *filename)
{
char filename_fullpath[256];
sprintf(filename_fullpath, "%s%s", HCoreGetShaderPath(), filename);
unsigned int size = 0;
unsigned char *buffer = (unsigned char *) HCoreLoadBinaryStream(filename_fullpath, &size);
if ( buffer==NULL )
{
return 0;
}
GLuint shader_id = 0;
glGenProgramsARB(1, &shader_id);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader_id );
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, size, buffer);
if ( GL_INVALID_OPERATION == glGetError() )
{
GLint errPos;
glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
GLubyte *errString = (GLubyte *) glGetString(GL_PROGRAM_ERROR_STRING_ARB);
fprintf( stderr, "error at position: %d\n%s\n", errPos, errString );
glDeleteProgramsARB(1, &shader_id);
shader_id = 0;
}
HCoreReleaseBinaryStream(buffer);
return shader_id;
}
static GLuint
_arb_program_from_string(GLenum kind, int shader_flags, char const * source, size_t source_length, char * * out_error_message)
{
GLuint program;
glGenProgramsARB(1, &program);
glBindProgramARB(kind, program);
glProgramStringARB(kind, GL_PROGRAM_FORMAT_ASCII_ARB, source_length, source);
GLint error_position;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_position);
if(error_position >= 0) {
const GLubyte * error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
asprintf(out_error_message, "Error in program at position %d: %s", error_position, error_string);
goto error;
}
glBindProgramARB(kind, 0);
return program;
error:
glBindProgramARB(kind, 0);
glDeleteProgramsARB(1, &program);
return 0;
}
void cleanup()
{
sdkDeleteTimer(&timer);
sdkDeleteTimer(&kernel_timer);
if (hImage)
{
free(hImage);
}
freeTextures();
//DEPRECATED: checkCudaErrors(cudaGLUnregisterBufferObject(pbo));
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffersARB(1, &pbo);
glDeleteTextures(1, &texid);
glDeleteProgramsARB(1, &shader);
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
}
void cleanup()
{
cutilCheckError( cutDeleteTimer( timer));
if(h_img)cutFree(h_img);
cutilSafeCall(cudaFree(d_img));
cutilSafeCall(cudaFree(d_temp));
// Refer to boxFilter_kernel.cu for implementation
freeTextures();
//DEPRECATED: cutilSafeCall(cudaGLUnregisterBufferObject(pbo));
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffersARB(1, &pbo);
glDeleteTextures(1, &texid);
glDeleteProgramsARB(1, &shader);
if (g_CheckRender) {
delete g_CheckRender;
g_CheckRender = NULL;
}
if (g_FrameBufferObject) {
delete g_FrameBufferObject;
g_FrameBufferObject = NULL;
}
}
enum piglit_result
piglit_display(void)
{
static const char *fp_source =
"!!ARBfp1.0\n"
"TEX result.color, fragment.texcoord[0], texture[1], 2D;\n"
"END\n";
bool pass = true;
GLuint tex;
GLuint prog;
texrect_w = piglit_width / 4 / 2;
texrect_h = piglit_height / 2;
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(fp_source),
(const GLubyte *) fp_source);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glActiveTexture(GL_TEXTURE1);
tex = piglit_rgbw_texture(GL_RGBA, 2, 2, false, false,
GL_UNSIGNED_NORMALIZED);
/* Given that the failure mode we had that led to this test
* being written was that the sampler state read was
* pseudo-random, go through several statechanges on the
* sampler to make sure we're reliably getting our sampler
* state.
*/
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(-1, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
piglit_draw_rect_tex(-0.5, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(0, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
piglit_draw_rect_tex(0.5, -1, 0.5, 2,
0, 0, 1, 1);
pass = pass && test_nearest(piglit_width * 0 / 4);
pass = pass && test_linear(piglit_width * 1 / 4);
pass = pass && test_nearest(piglit_width * 2 / 4);
pass = pass && test_linear(piglit_width * 3 / 4);
piglit_present_results();
glDeleteTextures(1, &tex);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDeleteProgramsARB(1, &prog);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
CVertexProgram::~CVertexProgram( )
{
if (m_uiProgram)
{
glDeleteProgramsARB(1, &m_uiProgram);
m_uiProgram = 0;
}
}
Program::~Program()
{
if (glLinkProgram != nullptr)
GLCHECK(glDeleteProgram(this->_program));
else if (glLinkProgramARB != nullptr)
GLCHECK(glDeleteProgramsARB(1, &this->_program));
else
throw std::runtime_error("glDeleteProgram unsupported");
}
static void set_blur_width(float w) {
static GLfloat blur_width = -1 ;
if(!glut_viewer_is_enabled(GLUT_VIEWER_HDR)) { return ; }
if(blur_width == w) { return ; }
blur_width = w ;
int blur_w = the_framebuffer_shrink.width ;
int blur_h = the_framebuffer_shrink.height ;
// delete old programs
if (blurh_fprog != 0) { glDeleteProgramsARB(1, &blurh_fprog); }
if (blurv_fprog != 0) { glDeleteProgramsARB(1, &blurv_fprog); }
unsigned char* blur_code = generateBlurCodeARBfp(blur_width, false, true, blur_w, blur_h) ;
blurh_fprog = loadProgramARB(GL_FRAGMENT_PROGRAM_ARB, blur_code) ;
blur_code = generateBlurCodeARBfp(blur_width, true, true, blur_w, blur_h);
blurv_fprog = loadProgramARB(GL_FRAGMENT_PROGRAM_ARB, blur_code);
}
void Viewer::onShutdown()
{
delete m_calHardwareModel;
delete m_calModel;
delete m_calCoreModel;
glDeleteProgramsARB(1, &m_vertexProgramId);
glDeleteBuffersARB(6, m_bufferObject);
}
void deleteprog(int progid)
{
#if defined(GL_ARB_vertex_program) && defined(GL_ARB_fragment_program)
if (progid!=0)
{
GLuint id=progid;
glDeleteProgramsARB(1,&id);
}
#endif
}
void GPUProgram::deletePrograms(int num, unsigned int* id) const {
switch (extension) {
case NVIDIA:
glDeleteProgramsNV(num, id);
break;
case ARB:
glDeleteProgramsARB(num, id);
break;
}
}
ImageGL::~ImageGL()
{
int nFrames = bVsync_ ? 3 : 1;
for (int n=0; n < nFrames; n++)
{
unregisterAsCudaResource(n);
}
glDeleteBuffersARB(nFrames, gl_pbo_);
glDeleteTextures(nFrames, gl_texid_);
glDeleteProgramsARB(1, &gl_shader_);
}
void cleanup()
{
cutilCheckError( cutDeleteTimer( hTimer));
glDeleteProgramsARB(1, &shader);
if (g_CheckRender) {
delete g_CheckRender; g_CheckRender = NULL;
}
if (g_FrameBufferObject) {
delete g_FrameBufferObject; g_FrameBufferObject = NULL;
}
}
void cleanup()
{
freeTexture();
checkCudaErrors(cudaGraphicsUnregisterResource(cuda_pbo_resource));
glDeleteBuffersARB(1, &pbo);
#if USE_BUFFER_TEX
glDeleteTextures(1, &bufferTex);
glDeleteProgramsARB(1, &fprog);
#else
glDeleteTextures(1, &displayTex);
#endif
}
void cleanup()
{
free(h_Src);
checkCudaErrors(CUDA_FreeArray());
checkCudaErrors(cudaGraphicsUnregisterResource(cuda_pbo_resource));
glDeleteProgramsARB(1, &shader);
sdkDeleteTimer(&timer);
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
}
