Max 5 API Reference

jit.gl.fbo.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Struct and associated methods for maintaining an offscreen OpenGL 
 * framebuffer object (fbo) with multiple attached image buffers 
 * (either textures or renderbuffers).
 *
 */

/****************************************************************************/

#include "jit.gl.fbo.h"
#include "jit.gl.texture.h"

/****************************************************************************/

t_jit_gl_fbo_attachment *jit_gl_fbo_attachment_new()
{
    t_jit_gl_fbo_attachment *x = NULL;

    if(x = jit_getbytes(sizeof(t_jit_gl_fbo_attachment)))
    {
        x->id = 0;
        jit_gl_fbo_attachment_reset(x);
    }

    return x;
}

void jit_gl_fbo_attachment_free(t_jit_gl_fbo_attachment *x)
{
    if(x)
    {
        jit_gl_fbo_attachment_destroy(x);
        jit_freebytes(x, sizeof(t_jit_gl_fbo_attachment));
    }
}

t_jit_err jit_gl_fbo_attachment_reset(t_jit_gl_fbo_attachment *x)
{
    t_jit_err err = JIT_ERR_NONE;

    if(x)
    {
        x->type = 0;
        x->target = 0;
        x->miplevel = 0;
        x->zslice = 0;
        x->id = 0;
    }

    return err;
}

t_jit_err jit_gl_fbo_attachment_destroy(t_jit_gl_fbo_attachment *x)
{
    t_jit_err err = JIT_ERR_NONE;

    if(x)
    {
        err = jit_gl_fbo_attachment_reset(x);
    }

    return err;
}

/****************************************************************************/

void *_jit_gl_fbo_class;


t_jit_err jit_gl_fbo_init(void)
{
    long attrflags=0;
    long ob3d_flags=0;
    void *attr;
    void *ob3d;

    // create class
    _jit_gl_fbo_class = jit_class_new("jit_gl_fbo",(method)jit_gl_fbo_new,(method)jit_gl_fbo_free,
        sizeof(t_jit_gl_fbo), A_DEFSYM, 0L);
    
    // set up object extension for 3d object, customized with flags
    ob3d_flags = JIT_OB3D_HAS_LIGHTS | JIT_OB3D_HAS_CAMERA | JIT_OB3D_IS_RENDERER;
    ob3d = jit_ob3d_setup(_jit_gl_fbo_class, calcoffset(t_jit_gl_fbo, ob3d), ob3d_flags);
    
    // add ob3d methods 
    jit_class_addmethod(_jit_gl_fbo_class, (method)jit_object_register, "register", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_fbo_class, (method)jit_gl_fbo_draw, "ob3d_draw", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_fbo_class, (method)jit_gl_fbo_dest_changed, "dest_changed", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_fbo_class, (method)jit_gl_fbo_dest_closing, "dest_closing", A_CANT, 0L);
    
    //add attributes
    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"color_attachment",_jit_sym_symbol,JIT_GL_FBO_MAX_COLOR_ATTACHMENTS,attrflags,
        (method)0L,(method)jit_gl_fbo_setattr_color_attachment,NULL,calcoffset(t_jit_gl_fbo,color_attachment));
    jit_class_addattr(_jit_gl_fbo_class,attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset, "depthtex", _jit_sym_symbol, attrflags,
        (method)0L, (method)jit_gl_fbo_attach_depthtex, calcoffset(t_jit_gl_fbo, depthtex));
    jit_class_addattr(_jit_gl_fbo_class, attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset, "depth", _jit_sym_long, attrflags,
        (method)0L, (method)jit_gl_fbo_attach_depth_image, calcoffset(t_jit_gl_fbo, depth));
    jit_class_addattr(_jit_gl_fbo_class, attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset, "stencil", _jit_sym_long, attrflags,
        (method)0L, (method)jit_gl_fbo_attach_stencil_image, calcoffset(t_jit_gl_fbo, stencil));
    jit_class_addattr(_jit_gl_fbo_class, attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset, "stencil", _jit_sym_long, attrflags,
        (method)0L, (method)jit_gl_fbo_attach_stencil_image, calcoffset(t_jit_gl_fbo, stencil));
    jit_class_addattr(_jit_gl_fbo_class, attr);
    
    attrflags = JIT_ATTR_SET_OPAQUE_USER;
    
    attr = jit_object_new(_jit_sym_jit_attr_offset, "attachedcount", _jit_sym_long, attrflags,
        (method)0L, (method)0L, calcoffset(t_jit_gl_fbo, attachedcount));
    jit_class_addattr(_jit_gl_fbo_class, attr);
    
    jit_class_register(_jit_gl_fbo_class);
    
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_setattr_color_attachment(t_jit_gl_fbo *x, void *attr, long argc, t_atom *argv)
{
    long i;
    t_symbol *name;
    t_jit_err err=JIT_ERR_NONE;
    
    if(argc) {
        name = jit_atom_getsym(argv);
        err = jit_gl_fbo_attach_tex_image(x, name, GL_COLOR_ATTACHMENT0_EXT, x->color_attachment);
    }
    
    return err;
}

t_jit_err jit_gl_fbo_attach_depthtex(t_jit_gl_fbo *x, void *attr, long argc, t_atom *argv)
{
    t_symbol *name;
    t_jit_err err=JIT_ERR_NONE;
    
    if(argc) {
        name = jit_atom_getsym(argv);
        err = jit_gl_fbo_attach_tex_image(x, name, GL_DEPTH_ATTACHMENT_EXT, &(x->depthtex));
    }
    
    return err;
}

t_jit_gl_fbo * jit_gl_fbo_new(t_symbol * dest_name)
{
    GLuint i;
    t_jit_gl_fbo *x = NULL;

    if (x=(t_jit_gl_fbo *)jit_object_alloc(_jit_gl_fbo_class)) 
    {
        // create and attach ob3d
        jit_ob3d_new(x, dest_name);
        
        x->depthtex = _jit_sym_nothing;
        x->id = 0;
        x->attachedcount = 0;

        for(i = 0; i < JIT_GL_FBO_MAX_ATTACHMENTS; i++) {
            x->attached[i] = NULL;
            x->renderbuffers[i] = NULL;
        }

        jit_gl_fbo_reset(x);
    }

    return x;
}

void jit_gl_fbo_free(t_jit_gl_fbo *x)
{
    if(x)
    {
        jit_gl_fbo_destroy(x);
        jit_ob3d_free(x);
    }
}

t_jit_err jit_gl_fbo_create(t_jit_gl_fbo *x)
{
    t_jit_gl_context ctx = NULL;
    t_jit_err err;

    if(!x)
        return JIT_ERR_GENERIC;      

    // destroy the existing fbo
    jit_gl_fbo_destroy(x);
    
    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // generate a new fbo
    x->id = 0;
    glGenFramebuffersEXT(1, &x->id);
    
    // report errors
    err = jit_gl_report_error("jit.gl.fbo: error generating framebuffer object!");
    if(err) return err;

    return err;
}

t_jit_err jit_gl_fbo_bind(t_jit_gl_fbo *x)
{
    long i;
    GLuint id;
    GLint previous;
    t_jit_err err;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // only bind if current id is different than previous bound framebuffer
    glGetIntegerv( GL_FRAMEBUFFER_BINDING_EXT, &previous );
    x->previous = previous;
    if (x->id != x->previous) 
    {
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_TEXTURE_RECTANGLE_ARB);

        // perform bind
        id = x->id;
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, id);

        // report errors
        err = jit_gl_fbo_report_error(x, "jit.gl.fbo: error binding framebuffer to current!");
        if(err) return err;
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_unbind(t_jit_gl_fbo *x)
{
    t_jit_err err;
    t_jit_gl_context ctx = NULL;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // restore previous framebuffer
    if (x->previous != x->id) 
    {
        // perform restore
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, x->previous);

        // report errors
        err = jit_gl_fbo_report_error(x, "jit.gl.fbo: error restoring framebuffer to previous buffer!");
        if(err) return err;
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_disable(t_jit_gl_fbo *x)
{
    t_jit_err err;
    t_jit_gl_context ctx = NULL;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // disable all framebuffer usage
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

    // report errors
    err = jit_gl_fbo_report_error(x, "jit.gl.fbo: error disabling all framebuffer usage!");
    return err;
}

t_jit_err jit_gl_fbo_draw(t_jit_gl_fbo *x)
{
    //nothing yet
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_dest_changed(t_jit_gl_fbo *x)
{
    //nothing yet
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_dest_closing(t_jit_gl_fbo *x)
{
    //nothing yet
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_attach_tex_image(t_jit_gl_fbo *x, t_symbol *texname, GLenum attachment, t_symbol **attachment_name)
{
    long dim[3];
    GLuint id;
    long target;
    t_jit_err err=JIT_ERR_NONE;
    void *o;
    long adapt=1;
    t_jit_gl_texture *tex = NULL;
    
    if(x && texname) {
        o = jit_object_findregistered( texname );

        if(jit_object_classname(o) == gensym("jit_gl_texture")) {
            tex = (t_jit_gl_texture *)o;
            tex->fbocontext = x;
            tex->fboattachment = (unsigned long *)attachment;
            adapt = tex->adapt;
            tex->adapt = 0;
            *attachment_name = texname;

            if(x->id <= 0 ) {
                err = jit_gl_fbo_create(x);
                if(err) goto cleanup;
            }

            err = jit_gl_fbo_bind(x);
            if(err) goto cleanup;

            err = (t_jit_err)jit_object_method(o, gensym("begin_capture"), 1 /*JIT_GL_READBACK_MODE_FBO*/);
            if(err) goto cleanup;

            /*
            jit_object_post((t_object *)x,"dim: %d %d %d", tex->dim[0], tex->dim[1], tex->dim[2]);
            jit_object_post((t_object *)x,"target: %d", tex->target);
            jit_object_post((t_object *)x,"id: %d", tex->bindid);
            jit_object_post((t_object *)x,"attachmentname: %s", (*attachment_name)->s_name);
            */
            
            err = jit_gl_fbo_unbind(x);
            if(err) goto cleanup;
        }
    }
    
cleanup:
    
    if(err) {
        *attachment_name = _jit_sym_nothing;
        
        //maybe reset fbo_attachment at location?
        //if tex exists and there's an error, clean tha mutha up
        if(tex) {
            tex->fbocontext = NULL;
            tex->fboattachment = GL_NONE;
            jit_object_free(tex->readback);
            tex->readback = NULL;
            tex->adapt = adapt;
        }
    }
    else {
        tex->adapt = adapt;
    }
    
    return err;
}

t_jit_err jit_gl_fbo_attach_depth_image(t_jit_gl_fbo *x, void *attr, long argc, t_atom *argv)
{
    GLint index;
    GLint depth;
    GLenum depthtype;
    long dim[3];
    t_jit_err err;
    void *o;
    
    if(argc) {
        // get attachment index
        index = GL_DEPTH_ATTACHMENT_EXT - GL_COLOR_ATTACHMENT0_EXT;
        
        if(x->attached[index]) {
            jit_gl_fbo_detach(x, GL_DEPTH_ATTACHMENT_EXT);
        }
        
        depth = jit_atom_getlong(argv);
        
        // create an optional depth buffer
        if(depth > 0)
        {
            if(!x->renderbuffers[index])
            {
                // create a new renderbuffer object
                x->renderbuffers[index] = jit_gl_renderbuffer_new();
                if(!x->renderbuffers[index])
                    return JIT_ERR_INVALID_PTR;
            }

            switch(depth)
            {
                case(16):
                    depthtype = GL_DEPTH_COMPONENT16;
                    break;
                case(24):
                    depthtype = GL_DEPTH_COMPONENT24;
                    break;
                case(32):
                    depthtype = GL_DEPTH_COMPONENT32;
                    break;
                default:
                    depthtype = GL_DEPTH_COMPONENT24;
                    break;
            }

            if( o=jit_object_findregistered(x->color_attachment[0]) ) {
                jit_attr_getlong_array(o, gensym("dim"), 3, dim);
            }
            else {
                dim[0] = 256;
                dim[1] = 256;
                dim[2] = 1;
            }
            
        //  jit_object_post((t_object *)x,"dim: %d %d %d", dim[0], dim[1], dim[2]);
            
            // create the renderbuffer
            err = jit_gl_renderbuffer_create(x->renderbuffers[index], depthtype, dim[0], dim[1]);
            if(err) return err;

            // attach renderbuffer to fbo
            err = jit_gl_fbo_attach_renderbuffer(x, GL_DEPTH_ATTACHMENT_EXT, x->renderbuffers[index]->id);
            if(err) return err;
        }
    }
    
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_attach_stencil_image(t_jit_gl_fbo *x, void *attr, long argc, t_atom *argv)
{
    GLint index;
    GLint stencil;
    
    if(argc) {
        // get attachment index
        index = GL_STENCIL_ATTACHMENT_EXT - GL_COLOR_ATTACHMENT0_EXT;
        
        if(x->attached[index]) {
            jit_gl_fbo_detach(x, GL_STENCIL_ATTACHMENT_EXT);
        }
        
        stencil = jit_atom_getlong(argv);
        
        //have to crete a renderbuffer and attach it
    }
    
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_attach_texture(
    t_jit_gl_fbo *x, GLenum attachment, GLenum target, 
    GLuint id, GLint miplevel, GLint zslice)
{
    GLuint attached = 0;
    GLuint fboid;
    t_jit_err err = JIT_ERR_NONE;
    
    // bind the fbo
    //err = jit_gl_fbo_bind(x);
    //if(err) return err;
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_RECTANGLE_ARB);

    // perform bind
    fboid = x->id;
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboid);

    // check for current attached id via opengl (might be associated with another instance!)
    //err = jit_gl_fbo_query_attached_id(x, attachment, &attached);
    //if(err) return err;
    
    {
        GLint id = 0;
        GLint type = 0;
        t_jit_err err = JIT_ERR_NONE;
        // perform type query
        glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment,
                                                 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, &type);
    
        if(type != GL_NONE)
        {
            // perform name query
            glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment,
                                                     GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &id);
        }
        
        attached = id;
    }

    // attach the texture (right now doesn't check type...could be a renderbuffer 
    // in which case this test isn't enough)...also need to read spec as it might 
    // be beneficial to detach previously attached item anyway...in fact, we should notify any other texture
    // as it could cause problems
//  if( attached != id ) 
//  {
        switch(target)
        {
            case GL_TEXTURE_1D:
            {
                glFramebufferTexture1DEXT( GL_FRAMEBUFFER_EXT, attachment, target, id, miplevel );
                break;
            }
            case GL_TEXTURE_2D:
            case GL_TEXTURE_RECTANGLE_ARB:
            {
                glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, attachment, target, id, miplevel );
                break;
            }
            case GL_TEXTURE_3D:
            {
                glFramebufferTexture3DEXT( GL_FRAMEBUFFER_EXT, attachment, target, id, miplevel, zslice );
                break;
            }
            default:
            {
                jit_object_error((t_object *)x,"jit.gl.fbo: invalid texture target for framebuffer attachment!");
                err = JIT_ERR_GENERIC;
            }
        };

        // report fbo errors
        err = jit_gl_fbo_report_error(x, "jit.gl.fbo: error attaching texture to framebuffer!");

        // save attachment if successful
        if(!err)
        {
            // get attachment index
            GLint index = attachment - GL_COLOR_ATTACHMENT0_EXT;

            // create attachment if necessary
            if(!x->attached[index])
                x->attached[index] = jit_gl_fbo_attachment_new();

            // reset current attachment
            jit_gl_fbo_attachment_reset(x->attached[index]);
            
            // save attachment data
            x->attached[index]->id = id;
            x->attached[index]->target = target;
            x->attached[index]->miplevel = miplevel;
            x->attached[index]->zslice = zslice;
            x->attached[index]->type = attachment;
            x->attachedcount++;
        }
//  }

    // unbind the fbo
    jit_gl_fbo_unbind(x);
    return err;
}

t_jit_err jit_gl_fbo_attach_renderbuffer(t_jit_gl_fbo *x, GLenum attachment, GLuint id)
{
    GLuint attached = 0;
    t_jit_err err = JIT_ERR_NONE;
    
    // bind the fbo
    err = jit_gl_fbo_bind(x);
    if(err) return err;

    // check for current attached id via opengl (might be associated with another instance!)
    err = jit_gl_fbo_query_attached_id(x, attachment, &attached);
    if(err) return err;

    // attach the renderbuffer object
    if( attached != id ) 
    {
        // perform attachment
        glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, attachment, GL_RENDERBUFFER_EXT, id);

        // report errors
        err = jit_gl_report_error("jit.gl.fbo: error attaching renderbuffer to framebuffer!");

        // save attachment if successful
        if(!err)
        {
            // get attachment index
            GLint index = attachment - GL_COLOR_ATTACHMENT0_EXT;

            // create attachment if necessary
            if(!x->attached[index])
                x->attached[index] = jit_gl_fbo_attachment_new();

            // reset current attachment
            jit_gl_fbo_attachment_reset(x->attached[index]);
            
            // save attachment data
            x->attached[index]->id = id;
            x->attached[index]->type = attachment;
            x->attachedcount++;
        }
    }

    // unbind the fbo
    jit_gl_fbo_unbind(x);
    return err;
}


t_jit_err jit_gl_fbo_detach(t_jit_gl_fbo *x, GLenum attachment)
{
    GLuint id;
    GLenum type;
    GLint index;
    t_jit_err err = JIT_ERR_NONE;

    // get attachment index
    index = attachment - GL_COLOR_ATTACHMENT0_EXT;

    // bind the fbo
    err = jit_gl_fbo_bind(x);
    if(err) return err;

    // get attached type
    err = jit_gl_fbo_query_attached_type(x, attachment, &type);
    if(err) return err;

    // detach
    switch(type) 
    {
        case GL_NONE:
        {
            err = JIT_ERR_NONE;
            break;
        }
        case GL_RENDERBUFFER_EXT:
        {
            // reset renderbuffer attachment using invalid id (zero)
            err = jit_gl_fbo_attach_renderbuffer( x, attachment, 0 /* invalid id */);
            jit_gl_report_error("jit.gl.fbo: error detaching renderbuffer!");
            break;
        }
        case GL_TEXTURE:
        {
            // reset texture attachment using invalid id (zero)
            err = jit_gl_fbo_attach_texture( x, attachment, GL_TEXTURE_2D, 0 /* invalid id */, 0, 0 );              
            jit_gl_report_error("jit.gl.fbo: error detaching texture!");
            break;
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl.fbo: invalid resource type for detaching from framebuffer!");
            err = JIT_ERR_GENERIC;
            break;
        }
    };

    // destroy attachment if necessary
    if(x->attached[index])
        jit_gl_fbo_attachment_free(x->attached[index]);
    x->attached[index] = NULL;
    x->attachedcount--;

    // unbind the fbo
    jit_gl_fbo_unbind(x);
    return err;
}

t_jit_err jit_gl_fbo_update_attached(t_jit_gl_fbo *x)
{
    GLuint i;
    GLenum type;
    GLenum attachment;
    GLint index;
    t_jit_err err = JIT_ERR_NONE;

    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // free all attachments
    for(i = 0; i < JIT_GL_FBO_MAX_ATTACHMENTS; i++)
    {
        if(x->attached[i])
        {
            attachment = x->attached[i]->type;

            // get attached type
            err = jit_gl_fbo_query_attached_type(x, attachment, &type);
            if(err) return err;

            switch(type) 
            {
                case GL_RENDERBUFFER_EXT:
                {
                    // reset renderbuffer attachment using invalid id (zero)
                    err = jit_gl_fbo_attach_renderbuffer( x, attachment, x->attached[i]->id);
                    jit_gl_report_error("jit.gl.fbo: error updating renderbuffer!");
                    break;
                }
                case GL_TEXTURE:
                {
                    // reset texture attachment using invalid id (zero)
                    err = jit_gl_fbo_attach_texture( x, attachment, x->attached[i]->target, x->attached[i]->id, x->attached[i]->miplevel, x->attached[i]->zslice );
                    jit_gl_report_error("jit.gl.fbo: error updating texture!");
                    break;
                }
            };
        }

        // report fbo errors
        err = jit_gl_fbo_report_error(x, "jit.gl.fbo: error updating framebuffer attachment!");
    }

    return err;
}

t_jit_err jit_gl_fbo_update_attachment(t_jit_gl_fbo *x, GLenum attachment)
{
    GLint index;
    t_jit_err err = JIT_ERR_NONE;

    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // get attachment index
    index = attachment - GL_COLOR_ATTACHMENT0_EXT;

    // draw to attached buffer
    if(x->attached[index])
    {
        // draw to attached buffer
        // glDrawBuffer(x->attached[index]->type);

        // report fbo errors
        err = jit_gl_fbo_report_error(x, "jit.gl.fbo: error updating framebuffer attachment!");
        if(err) return err;

        // report errors
        err = jit_gl_report_error("jit.gl.fbo: error updating framebuffer attachment!");
        if(err) return err;
    }

    return err;
}

t_jit_err jit_gl_fbo_destroy(t_jit_gl_fbo *x)
{
    GLuint i;
    t_jit_err err = JIT_ERR_NONE;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // disable fbo
    err = jit_gl_fbo_unbind(x);
    if(err) return err;

    // free all attachments
    for(i = 0; i < JIT_GL_FBO_MAX_ATTACHMENTS; i++)
    {
        if(x->attached[i])
        {
//          jit_gl_fbo_detach(x, x->attached[i]->type);
            jit_gl_renderbuffer_free(x->renderbuffers[i]);
            jit_gl_fbo_attachment_free(x->attached[i]);
        }

        x->attached[i] = NULL;
    }
    x->attachedcount = 0;

    // destroy the frambuffer object
    if(x->id)
    {
        glDeleteFramebuffersEXT(1, &x->id);
        x->id = 0;

        // report errors
        jit_gl_report_error("jit.gl.fbo: error deleting framebuffer object!");
    }

    jit_gl_fbo_reset(x);
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_reset(t_jit_gl_fbo *x)
{
    GLint i;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    x->id = 0;
    x->previous = 0;
    x->attachedcount = 0;

    for(i = 0; i < JIT_GL_FBO_MAX_ATTACHMENTS; i++)
    {
        jit_gl_fbo_attachment_free(x->attached[i]);
        x->attached[i] = NULL;
    }
    
    return JIT_ERR_NONE;
}

/****************************************************************************/

t_jit_err jit_gl_fbo_verify_support(t_jit_gl_fbo *x)
{
    t_jit_gl_support *support = NULL;

    // get opengl support capabilities
    support = jit_gl_get_support();
    if(!support || !support->initialized || !support->fbo)
    {
        jit_object_error((t_object *)x,"jit.gl.fbo: unable to verify hardware support for framebuffer objects!");
        return JIT_ERR_GENERIC;
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_report_error(t_jit_gl_fbo *x, const char *prefix)
{
    t_jit_err err = JIT_ERR_NONE;
    GLenum status;
    
    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // perform query
    status = (GLenum) glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
    switch(status) 
    {
        case GL_FRAMEBUFFER_COMPLETE_EXT:
        {
            // no error!
            err = JIT_ERR_NONE;
            break;
        }
        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
        {
            // no error!
            err = JIT_ERR_NONE;
            break;
        }
        case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
        {
            jit_object_error((t_object *)x,"jit.gl.fbo: unsupported framebuffer format!");
            err = JIT_ERR_GENERIC;
            break;
        }
        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
        {
            jit_object_error((t_object *)x,"jit.gl.fbo: framebuffer incomplete, missing attachments!");
            err = JIT_ERR_GENERIC;
            break;
        }
        case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
        {
            jit_object_error((t_object *)x,"jit.gl.fbo: framebuffer incomplete, attachments must have same dimensions!");
            err = JIT_ERR_GENERIC;
            break;
        }
        case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
        {
            jit_object_error((t_object *)x,"jit.gl.fbo: framebuffer incomplete, attachments must be the same format!");
            err = JIT_ERR_GENERIC;
            break;
        }
        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
        {
            jit_object_error((t_object *)x,"jit.gl.fbo: framebuffer incomplete, missing draw buffer!");
            err = JIT_ERR_GENERIC;
            break;
        }
        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
        {
            jit_object_error((t_object *)x,"jit.gl.fbo: framebuffer incomplete, missing read buffer!");
            err = JIT_ERR_GENERIC;
            break;
        }
    }
    if (err&&prefix)
        jit_object_error((t_object *)x,(char *)prefix);
    return err;
}

t_jit_err jit_gl_fbo_query_max_color_attachments(t_jit_gl_fbo *x, GLint *value)
{
    GLint max = 0;
    t_jit_err err = JIT_ERR_NONE;

    // verify hw support for fbo
    err = jit_gl_fbo_verify_support(x);
    if(err) return err;

    // perform query
    glGetIntegerv( GL_MAX_COLOR_ATTACHMENTS_EXT, &max );

    // report errors
    jit_gl_report_error("jit.gl.fbo: error querying framebuffer max color attachments!");
    
    // save value
    *value = max;
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_fbo_query_attached_type(t_jit_gl_fbo *x, GLenum attachment, GLenum *value )
{
    GLint type = 0;
    t_jit_err err = JIT_ERR_NONE;

    // bind fbo
    err = jit_gl_fbo_bind(x);
    if(err) return err;

    // perform query
    glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment,
                                             GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, &type);
    // unbind fbo
    err = jit_gl_fbo_unbind(x);
    if(err) return err;

    // save value
    *value = (GLenum)type;
    return err;
}

t_jit_err jit_gl_fbo_query_attached_id(t_jit_gl_fbo *x, GLenum attachment, GLuint *value )
{
    GLint id = 0;
    GLint type = 0;
    t_jit_err err = JIT_ERR_NONE;

    // bind fbo
    err = jit_gl_fbo_bind(x);
    if(err) return err;

    // perform type query
    glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment,
                                             GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, &type);

    if(type != GL_NONE)
    {
        // perform name query
        glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment,
                                                 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &id);
    }

    // report errors
    err = jit_gl_report_error("jit.gl.fbo: error querying framebuffer attachment id!");

    // unbind fbo
    err = jit_gl_fbo_unbind(x);
    if(err) return err;

    // save value
    *value = (GLuint)id;
    return err;
}

t_jit_err jit_gl_fbo_query_attached_miplevel(t_jit_gl_fbo *x, GLenum attachment, GLint *value )
{
    GLint level = 0;
    t_jit_err err = JIT_ERR_NONE;

    // bind fbo
    err = jit_gl_fbo_bind(x);
    if(err) return err;

    // perform query
    glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment,
                                             GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &level);
    // report errors
    jit_gl_report_error("jit.gl.fbo: error querying framebuffer attachment mipmap level!");

    // unbind fbo
    err = jit_gl_fbo_unbind(x);
    if(err) return err;

    // save value
    *value = level;
    return err;
}

t_jit_err jit_gl_fbo_query_attached_zslice(t_jit_gl_fbo *x, GLenum attachment, GLint *value )
{
    GLint slice = 0;
    t_jit_err err = JIT_ERR_NONE;

    // bind fbo
    err = jit_gl_fbo_bind(x);
    if(err) return err;

    // perfom query
    glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment,
                                             GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT, &slice);

    // report errors
    jit_gl_report_error("jit.gl.fbo: error querying framebuffer attachment z-slice!");

    // unbind fbo
    err = jit_gl_fbo_unbind(x);
    if(err) return err;
    
    // save value
    *value = slice;
    return err;
}

Copyright © 2008, Cycling '74