Max 5 API Reference

jit.gl.vbo.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Struct and associated methods for maintaining an OpenGL 
 * pixel buffer object (vbo).
 *
 */

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

#include "jit.gl.vbo.h"

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

void *_jit_gl_vbo_class;

t_jit_err jit_gl_vbo_init(void)
{
    void *attr;
    long attrflags;

    _jit_gl_vbo_class = jit_class_new("jit_gl_vbo", (method)jit_gl_vbo_new, (method)jit_gl_vbo_free,
        sizeof(t_jit_gl_vbo),A_DEFSYM,0L);
        
        
    //add methods
    jit_class_addmethod(_jit_gl_vbo_class, (method)jit_gl_vbo_create, "create", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_vbo_class, (method)jit_gl_vbo_bind, "bind", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_vbo_class, (method)jit_gl_vbo_unbind, "unbind", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_vbo_class, (method)jit_gl_vbo_destroy, "destroy", A_CANT, 0L);
    
    
    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW | JIT_ATTR_SET_OPAQUE;
    attr = jit_object_new(_jit_sym_jit_attr_offset, "id", _jit_sym_long, attrflags,
        (method)0L, (method)0L, calcoffset(t_jit_gl_vbo, id));
    jit_class_addattr(_jit_gl_vbo_class, attr);
    
    
    jit_class_register(_jit_gl_vbo_class);

    return JIT_ERR_NONE;
}

t_jit_gl_vbo *jit_gl_vbo_new()
{
    t_jit_gl_vbo *x = NULL;

    if(x = (t_jit_gl_vbo *)jit_object_alloc(_jit_gl_vbo_class))
    {
        jit_gl_vbo_reset(x);
    }

    return x;
}

void jit_gl_vbo_free(t_jit_gl_vbo *x)
{
    if(x) {
        jit_gl_vbo_destroy(x);
    }
}

t_jit_err jit_gl_vbo_create(
    t_jit_gl_vbo *x, long type, long mode, long datatype, long coords, long stride, long size, void *data)
{
    GLuint id;
    long buffer;
    t_jit_err err;

    if(!x || !data)
        return JIT_ERR_GENERIC;

    // destroy any existing buffer
    if( x->id > 0 )
    {
        err = jit_gl_vbo_destroy(x);
        if(err) return err;
    }
    
    // get the buffer type
    if(type == JIT_GL_VBO_TYPE_INDEX)
    {
        buffer = GL_ELEMENT_ARRAY_BUFFER_ARB;
    }
    else
    {
        buffer = GL_ARRAY_BUFFER_ARB;
    }

    // create buffer
    x->handle = data;
    glGenBuffersARB((GLsizei)1, &id);
    glBindBufferARB(buffer, id);
    glBufferDataARB(buffer, size, x->handle, mode);

    // *must* clear data
    x->handle = NULL;

    // check for errors
    if(jit_gl_report_error("jit.gl: error creating vertex buffer object!"))
    {
        return JIT_ERR_GENERIC;
    }
    
    // save data
    x->id = id;
    x->coords = coords;
    x->size = size;
    x->type = type;
    x->mode = mode;
    x->datatype = datatype;
    x->stride = stride;
    x->buffer = buffer;
    x->handle = NULL;
    
    jit_gl_report_error("jit.gl: error creating vertex buffer object!");
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_vbo_bind(t_jit_gl_vbo *x)
{
    GLint id;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // check for existing id
    if( x->id > 0 && x->size > 0 && x->type > 0)
    {
        // bind the buffer
        id = x->id;
        glBindBufferARB(x->buffer, id);
        jit_gl_report_error("jit.gl: error binding vertex buffer object");
    }
    else
    {
        jit_object_error((t_object *)x,"jit.gl: cannot bind vertex buffer object: not initialized!");
        return JIT_ERR_GENERIC;
    }
    
    switch(x->type)
    {
        case JIT_GL_VBO_TYPE_INDEX:
        {
            glEnableClientState(GL_INDEX_ARRAY);
            glIndexPointer(x->datatype, x->stride, x->handle);
            break;
        }
        case JIT_GL_VBO_TYPE_VERTEX:
        {
            glEnableClientState(GL_VERTEX_ARRAY);
            glVertexPointer(x->coords, x->datatype, x->stride, x->handle);
            break;
        }
        case JIT_GL_VBO_TYPE_TEXCOORD:
        {
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
            glTexCoordPointer(x->coords, x->datatype, x->stride, x->handle);
            break;
        }
        case JIT_GL_VBO_TYPE_NORMAL:
        {
            glEnableClientState(GL_NORMAL_ARRAY);
            glNormalPointer(x->datatype, x->stride, x->handle);
            break;
        }
        case JIT_GL_VBO_TYPE_COLOR:
        {
            glEnableClientState(GL_COLOR_ARRAY);
            glColorPointer(x->coords, x->datatype, x->stride, x->handle);
            break;
        }
        case JIT_GL_VBO_TYPE_EDGEFLAG:
        {
            glEnableClientState(GL_EDGE_FLAG_ARRAY);
            glEdgeFlagPointer(x->stride, x->handle);
            break;
        }
        case JIT_GL_VBO_TYPE_TANGENT:
        {
            // TODO
            break;
        }
        case JIT_GL_VBO_TYPE_BINORMAL:
        {
            // TODO
            break;
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl: invalid vertex buffer object type!");
            return JIT_ERR_GENERIC;
        }
    };

    jit_gl_report_error("jit.gl: error enabling vertex buffer object");
    return JIT_ERR_NONE;      
}

t_jit_err jit_gl_vbo_unbind(t_jit_gl_vbo *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;

    // clear binding 
    glBindBufferARB(x->buffer, 0);
    jit_gl_report_error("jit.gl: error unbinding vertex buffer object");
    
    // disable client state   
    switch(x->type)
    {
        case JIT_GL_VBO_TYPE_INDEX:
        {
            glDisableClientState(GL_INDEX_ARRAY);
            break;
        }
        case JIT_GL_VBO_TYPE_VERTEX:
        {
            glDisableClientState(GL_VERTEX_ARRAY);
            break;
        }
        case JIT_GL_VBO_TYPE_TEXCOORD:
        {
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
            break;
        }
        case JIT_GL_VBO_TYPE_NORMAL:
        {
            glDisableClientState(GL_NORMAL_ARRAY);
            break;
        }
        case JIT_GL_VBO_TYPE_COLOR:
        {
            glDisableClientState(GL_COLOR_ARRAY);
            break;
        }
        case JIT_GL_VBO_TYPE_EDGEFLAG:
        {
            glDisableClientState(GL_EDGE_FLAG_ARRAY);
            break;
        }
        case JIT_GL_VBO_TYPE_TANGENT:
        {
            // TODO
            break;
        }
        case JIT_GL_VBO_TYPE_BINORMAL:
        {
            // TODO
            break;
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl: invalid vertex buffer object type!");
            return JIT_ERR_GENERIC;
        }
    };

    jit_gl_report_error("jit.gl: error disabling vertex buffer object");
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_vbo_destroy(t_jit_gl_vbo *x)
{
    GLuint id;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    if(x->id > 0)
    {
        id = x->id;
        glDeleteBuffersARB(1, &id);
        x->id = -1;
    }

    x->id = -1;
    x->coords = 0;
    x->size = 0;
    x->type = -1;
    x->mode = -1;
    x->stride = 0;
    x->buffer = 0;
    x->handle = NULL;
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_vbo_reset(t_jit_gl_vbo *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;

    x->id = -1;
    x->coords = 0;
    x->size = 0;
    x->type = -1;
    x->mode = -1;
    x->stride = 0;
    x->buffer = 0;
    x->handle = NULL;
    return JIT_ERR_NONE;
}
/****************************************************************************/

Copyright © 2008, Cycling '74