Max 5 API Reference

jit.gl.mesh.c

#include "jit.gl.mesh.h"
#include "jit.gl.cache.h"
#include "jit.gl.cache.dl.h"
#include "jit.gl.cache.var.h"
#include "jit.gl.cache.vbo.h"
#include "jit.gl.mesh.index.h"
#include "jit.gl.mesh.colors.h"
#include "jit.gl.mesh.normals.h"
#include "jit.gl.mesh.tangents.h"

// --------------------------------------------------------------------------

t_symbol *ps_jit_gl_mesh_index;
t_symbol *ps_jit_gl_mesh_vertex;
t_symbol *ps_jit_gl_mesh_position;
t_symbol *ps_jit_gl_mesh_normal;
t_symbol *ps_jit_gl_mesh_texcoord;
t_symbol *ps_jit_gl_mesh_color;
t_symbol *ps_jit_gl_mesh_diffuse;
t_symbol *ps_jit_gl_mesh_specular;
t_symbol *ps_jit_gl_mesh_edgeflag;
t_symbol *ps_jit_gl_mesh_tangent;
t_symbol *ps_jit_gl_mesh_bitangent;
t_symbol *ps_jit_gl_mesh_index_matrix;
t_symbol *ps_jit_gl_mesh_vertex_matrix;
t_symbol *ps_jit_gl_mesh_normal_matrix;
t_symbol *ps_jit_gl_mesh_texcoord_matrix;
t_symbol *ps_jit_gl_mesh_color_matrix;
t_symbol *ps_jit_gl_mesh_specular_matrix;
t_symbol *ps_jit_gl_mesh_edgeflag_matrix;
t_symbol *ps_jit_gl_mesh_tangent_matrix;
t_symbol *ps_jit_gl_mesh_bitangent_matrix;
t_symbol *ps_jit_gl_mesh_vertex_attr_matrix;
t_symbol *ps_jit_gl_mesh_none;

t_symbol *ps_jit_gl_mesh_shader_attribute_position;
t_symbol *ps_jit_gl_mesh_shader_attribute_normal;
t_symbol *ps_jit_gl_mesh_shader_attribute_tangent;
t_symbol *ps_jit_gl_mesh_shader_attribute_bitangent;
t_symbol *ps_jit_gl_mesh_shader_attribute_texcoord;
t_symbol *ps_jit_gl_mesh_shader_attribute_vertex_attr;

t_symbol *ps_jit_gl_mesh_lines_adjacency;
t_symbol *ps_jit_gl_mesh_line_strip_adjacency;
t_symbol *ps_jit_gl_mesh_triangles_adjacency;
t_symbol *ps_jit_gl_mesh_triangle_strip_adjacency;

// --------------------------------------------------------------------------

void *_jit_gl_mesh_class;

// --------------------------------------------------------------------------

t_jit_err jit_gl_mesh_init(void)
{
    long attrflags = 0;
    long ob3d_flags = 0;
    void *mop, *attr;
    void *ob3d;

    // create class
    _jit_gl_mesh_class = jit_class_new("jit_gl_mesh",(method)jit_gl_mesh_new, (method)jit_gl_mesh_free,
                            sizeof(t_jit_gl_mesh), A_DEFSYM, 0L);

    // set up object extension for 3d object, customized with flags
    ob3d = jit_ob3d_setup(_jit_gl_mesh_class,
                          calcoffset(t_jit_gl_mesh, ob3d), ob3d_flags);

    // user transparent attributes
    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
    attr = jit_object_new(_jit_sym_jit_attr_offset, "cache_mode", _jit_sym_symbol, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_cache_mode, calcoffset(t_jit_gl_mesh, cache_mode));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "draw_mode", _jit_sym_symbol, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_draw_mode, calcoffset(t_jit_gl_mesh, draw_mode));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "auto_normals", _jit_sym_long, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_auto_normals, calcoffset(t_jit_gl_mesh, auto_normals));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "auto_colors", _jit_sym_long, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_auto_colors, calcoffset(t_jit_gl_mesh, auto_colors));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "color_mode", _jit_sym_symbol, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_color_mode, calcoffset(t_jit_gl_mesh, color_mode));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "auto_tangents", _jit_sym_long, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_auto_tangents, calcoffset(t_jit_gl_mesh, auto_tangents));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "auto_bitangents", _jit_sym_long, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_auto_bitangents, calcoffset(t_jit_gl_mesh, auto_bitangents));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);
    
    
    // ...

    // user opaque attributes
    attrflags = JIT_ATTR_GET_OPAQUE_USER | JIT_ATTR_SET_OPAQUE_USER;
    attr = jit_object_new(_jit_sym_jit_attr_offset, "input_type", _jit_sym_long, attrflags,
                          (method)0L, (method)jit_gl_mesh_setattr_input_type, calcoffset(t_jit_gl_mesh, input_type));
    jit_class_addattr(_jit_gl_mesh_class, (t_jit_object*)attr);

    // add ob3d methods
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_object_register, "register", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_draw, "ob3d_draw", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_dest_changed, "dest_changed", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_dest_closing, "dest_closing", A_CANT, 0L);

    // add matrix methods
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "jit_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "index_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "vertex_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "normal_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "texcoord_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "color_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "specular_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "edgeflag_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "tangent_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "bitangent_matrix", A_GIMME, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_jit_matrix, "vertex_attr_matrix", A_GIMME, 0L);

    // add geometry methods
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_reset, "reset", A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_bind, "bind", A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_unbind, "unbind", A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_get_cache_by_name, "get_cache", A_DEFER_LOW, 0L);
    
    jit_class_addmethod(_jit_gl_mesh_class,
                        (method)jit_gl_mesh_rebuild, "rebuild", A_CANT, 0L);

    // register class
    jit_class_register(_jit_gl_mesh_class);

    // init cache
    jit_gl_cache_init();

    // generate symbols
    ps_jit_gl_mesh_index = gensym("index");
    ps_jit_gl_mesh_position = gensym("position");
    ps_jit_gl_mesh_vertex = gensym("vertex");
    ps_jit_gl_mesh_normal = gensym("normal");
    ps_jit_gl_mesh_texcoord = gensym("texcoord");
    ps_jit_gl_mesh_color = gensym("color");
    ps_jit_gl_mesh_diffuse = gensym("diffuse");
    ps_jit_gl_mesh_specular = gensym("specular");
    ps_jit_gl_mesh_edgeflag = gensym("edgeflag");
    ps_jit_gl_mesh_tangent = gensym("tangent");
    ps_jit_gl_mesh_bitangent = gensym("bitangent");
    ps_jit_gl_mesh_index_matrix = gensym("index_matrix");
    ps_jit_gl_mesh_vertex_matrix = gensym("vertex_matrix");
    ps_jit_gl_mesh_normal_matrix = gensym("normal_matrix");
    ps_jit_gl_mesh_texcoord_matrix = gensym("texcoord_matrix");
    ps_jit_gl_mesh_color_matrix = gensym("color_matrix");
    ps_jit_gl_mesh_specular_matrix = gensym("specular_matrix");
    ps_jit_gl_mesh_edgeflag_matrix = gensym("edgeflag_matrix");
    ps_jit_gl_mesh_tangent_matrix = gensym("tangent_matrix");
    ps_jit_gl_mesh_bitangent_matrix = gensym("bitangent_matrix");
    ps_jit_gl_mesh_vertex_attr_matrix = gensym("vertex_attr_matrix");
    ps_jit_gl_mesh_none = gensym("none");
    
    ps_jit_gl_mesh_shader_attribute_position = gensym("POSITION");
    ps_jit_gl_mesh_shader_attribute_normal = gensym("NORMAL");
    ps_jit_gl_mesh_shader_attribute_tangent = gensym("TANGENT");
    ps_jit_gl_mesh_shader_attribute_bitangent = gensym("BITANGENT");
    ps_jit_gl_mesh_shader_attribute_texcoord = gensym("TEXCOORD");
    ps_jit_gl_mesh_shader_attribute_vertex_attr = gensym("VERTEX_ATTR");
    
    ps_jit_gl_mesh_lines_adjacency = gensym("lines_adjacency");
    ps_jit_gl_mesh_line_strip_adjacency = gensym("line_strip_adjacency");
    ps_jit_gl_mesh_triangles_adjacency = gensym("triangles_adjacency");
    ps_jit_gl_mesh_triangle_strip_adjacency = gensym("triangle_strip_adjacency");
    
    return JIT_ERR_NONE;
}

t_jit_gl_mesh *jit_gl_mesh_new(t_symbol * dest_name)
{
    long i;
    t_jit_gl_mesh *x;

    if (x = (t_jit_gl_mesh *)jit_object_alloc(_jit_gl_mesh_class))
    {

        // create and attach ob3d
        jit_ob3d_new(x, dest_name);

        x->update = TRUE;
        x->mode = JIT_GL_MESH_CACHE_NONE;
        x->cache_mode = ps_jit_gl_cache_auto;
        x->draw_mode = _jit_sym_gl_tri_grid;
        x->optimize = FALSE;
        x->id = -1;
        x->epsilon = 0.0001;

        x->input_type = JIT_GL_MESH_VERTEX;

        x->auto_index = FALSE;
        x->auto_normals = FALSE;
        x->auto_tangents = FALSE;
        x->auto_bitangents = FALSE;
        x->auto_colors = FALSE;
        x->color_mode = _jit_sym_nothing;

        // allocate cache
        x->cache = (t_jit_gl_cache**)jit_getbytes(JIT_GL_MESH_MAX_INPUTCOUNT * sizeof(t_jit_gl_cache*));
        if (!x->cache)
            return NULL;

        // init cache
        for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
        {
            x->cache[i] = jit_gl_cache_new(0, 0, 0);
            if (!x->cache[i])
                return NULL;
        }

        // allocate matrices
        x->input = (t_jit_object **)jit_getbytes(JIT_GL_MESH_MAX_INPUTCOUNT * sizeof(t_jit_object*));
        if (!x->input)
            return NULL;

        // init matrices
        for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
        {
            x->input[i] = NULL;
        }

    }
    else
    {
        x = NULL;
    }
    return x;
}

void jit_gl_mesh_free(t_jit_gl_mesh *x)
{
    long i;

    if (jit_ob3d_set_context(x) == JIT_ERR_NONE)
    {
        // jit_gl_mesh_destroy(x);
    }

    if (x->cache)
    {
        for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
        {
            jit_gl_cache_free(x->cache[i]);
        }
        jit_freebytes(x->cache, JIT_GL_MESH_MAX_INPUTCOUNT * sizeof(t_jit_gl_cache*));
        x->cache = NULL;
    }

    if (x->input)
    {
        for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
        {
            jit_object_free(x->input[i]);
            x->input[i] = NULL;
        }
        jit_freebytes(x->input, JIT_GL_MESH_MAX_INPUTCOUNT * sizeof(t_jit_object*));
        x->input = NULL;
    }

    jit_ob3d_free(x);
}

// --------------------------------------------------------------------------


t_jit_err jit_gl_mesh_dest_closing(t_jit_gl_mesh *x)
{
    long i;

    // destroy buffer, keep cache data
    for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
    {
        jit_gl_cache_buffer_destroy(x->cache[i]);
    }
    
    return JIT_ERR_NONE;
}


t_jit_err jit_gl_mesh_draw(t_jit_gl_mesh *x)
{
    t_jit_err result = JIT_ERR_NONE;

    if (x->update)
    {
        jit_gl_mesh_recalc(x);
    }

    if (!jit_attr_getlong(x, gensym("matrixoutput")))
    {
        jit_gl_mesh_draw_cache(x);
    }
    else
    {
        // setup output matrix

        //result = jit_ob3d_draw_chunk(x->ob3d, x->chunk); //output matrix
    }

    return result;
}

t_jit_err jit_gl_mesh_dest_changed(t_jit_gl_mesh *x)
{
    x->update = TRUE;
    return JIT_ERR_NONE;
}

t_jit_gl_cache *jit_gl_mesh_get_cache_by_name(t_jit_gl_mesh *x, t_symbol *name)
{
    long i;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        if (name == ps_jit_gl_mesh_vertex ||
            name == ps_jit_gl_mesh_position || 
            name == ps_jit_gl_mesh_shader_attribute_position)
        {
            return x->cache[JIT_GL_MESH_VERTEX];
        }
        else if(name == ps_jit_gl_mesh_texcoord ||
                name == ps_jit_gl_mesh_shader_attribute_texcoord)
        {
            return x->cache[JIT_GL_MESH_TEXCOORD];
        }
        else if(name == ps_jit_gl_mesh_normal ||
                name == ps_jit_gl_mesh_shader_attribute_normal)
        {
            return x->cache[JIT_GL_MESH_NORMAL];
        }
        else if(name == ps_jit_gl_mesh_tangent ||
                name == ps_jit_gl_mesh_shader_attribute_tangent)
        {
            return x->cache[JIT_GL_MESH_TANGENT];
        }
        else if(name == ps_jit_gl_mesh_bitangent ||
                name == ps_jit_gl_mesh_shader_attribute_bitangent)
        {
            return x->cache[JIT_GL_MESH_BITANGENT];
        }
        else if(name == ps_jit_gl_mesh_edgeflag)
        {
            return x->cache[JIT_GL_MESH_EDGEFLAG];
        }
        else if(name == ps_jit_gl_mesh_vertex_attr_matrix ||
                name == ps_jit_gl_mesh_shader_attribute_vertex_attr)
        {
            return x->cache[JIT_GL_MESH_VERTEX_ATTR];
        }
    }
    
    return NULL;
}

// --------------------------------------------------------------------------

t_jit_err jit_gl_mesh_recalc(t_jit_gl_mesh *x)
{
    t_jit_err err;

    x->enumtype = jit_gl_mesh_enumtype_from_sym(x->draw_mode);
    x->grid = (x->draw_mode == _jit_sym_gl_tri_grid) || (x->draw_mode == _jit_sym_gl_quad_grid);

    err = jit_gl_mesh_rebuild(x);
    if (err)
        return err;

    if (x->optimize)
    {
        err = jit_gl_mesh_optimize(x);
        if (err)
            return err;
    }

    x->update = FALSE;
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_mesh_setattr_input_type(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    long v;

    if (x)
    {
        v = jit_atom_getlong(argv);
        if (x->input_type != v)
        {
            x->input_type = v;
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_cache_mode(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    t_symbol *v;
    t_symbol *old;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getsym(argv);
        if (x->cache_mode != v)
        {
            x->cache_mode = v;
            
            // reset cache
            for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
            {
                err = jit_gl_cache_reset(x->cache[i]);
                if (err)
                    return err;
            }
            jit_gl_mesh_recalc(x);
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_color_mode(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    t_symbol *v;
    t_symbol *old;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getsym(argv);
        if (x->color_mode != v)
        {
            if (    v == ps_jit_gl_mesh_vertex ||
                    v == ps_jit_gl_mesh_position ||
                    v == ps_jit_gl_mesh_texcoord ||
                    v == ps_jit_gl_mesh_normal ||
                    v == ps_jit_gl_mesh_tangent ||
                    v == ps_jit_gl_mesh_bitangent ||
                    v == ps_jit_gl_mesh_edgeflag )
            {
                x->color_mode = v;
                jit_gl_mesh_recalc(x);
            }
            else
            {
                jit_object_error((t_object *)x,"jit.gl.mesh: invalid color mode: '%s'", JIT_SYM_SAFECSTR(v));
            }
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_draw_mode(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    t_symbol *v;
    t_symbol *old;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getsym(argv);
        if (x->draw_mode != v)
        {
            x->draw_mode = v;
            x->grid = (x->draw_mode == _jit_sym_gl_tri_grid) || (x->draw_mode == _jit_sym_gl_quad_grid);
            jit_gl_mesh_recalc(x);
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_auto_index(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    long v;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getlong(argv);
        if (x->auto_index != v)
        {
            x->auto_index = v;
            jit_gl_mesh_recalc(x);
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_auto_colors(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    long v;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getlong(argv);
        if (x->auto_colors != v)
        {
            x->auto_colors = v;
            jit_gl_mesh_recalc(x);
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_auto_normals(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    long v;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getlong(argv);
        if (x->auto_normals != v)
        {
            x->auto_normals = v;
            jit_gl_mesh_recalc(x);
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_auto_tangents(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    long v;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getlong(argv);
        if (x->auto_tangents != v)
        {
            x->auto_tangents = v;
            jit_gl_mesh_recalc(x);
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_mesh_setattr_auto_bitangents(t_jit_gl_mesh *x, void *attr, long argc, t_atom *argv)
{
    long i;
    long v;
    t_jit_err err = JIT_ERR_NONE;

    if (x)
    {
        v = jit_atom_getlong(argv);
        if (x->auto_bitangents != v)
        {
            x->auto_bitangents = v;
            jit_gl_mesh_recalc(x);
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

// --------------------------------------------------------------------------

t_jit_err jit_gl_mesh_reset(t_jit_gl_mesh *x, t_symbol *s, int argc, t_atom *argv)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_mesh_jit_matrix(t_jit_gl_mesh *x, t_symbol *s, int argc, t_atom *argv)
{
    t_jit_object *matrix;
    t_jit_err err = JIT_ERR_NONE;
    t_jit_matrix_info info;
    char *bp = NULL;
    t_jit_gl_cache *cache = NULL;
    t_symbol *matrix_name = jit_atom_getsym(argv);

    
    if (s != _jit_sym_jit_matrix) {
        if (s == ps_jit_gl_mesh_vertex_matrix) {
            x->input_type = JIT_GL_MESH_VERTEX;
        } else if (s == ps_jit_gl_mesh_texcoord_matrix) {
            x->input_type = JIT_GL_MESH_TEXCOORD;
        } else if (s == ps_jit_gl_mesh_normal_matrix) {
            x->input_type = JIT_GL_MESH_NORMAL;
        } else if (s == ps_jit_gl_mesh_color_matrix) {
            x->input_type = JIT_GL_MESH_COLOR;
        } else if (s == ps_jit_gl_mesh_specular_matrix) {
            x->input_type = JIT_GL_MESH_SPECULAR;
        } else if (s == ps_jit_gl_mesh_edgeflag_matrix) {
            x->input_type = JIT_GL_MESH_EDGEFLAG;
        } else if (s == ps_jit_gl_mesh_tangent_matrix) {
            x->input_type = JIT_GL_MESH_TANGENT;
        } else if (s == ps_jit_gl_mesh_bitangent_matrix) {
            x->input_type = JIT_GL_MESH_BITANGENT;
        } else if (s == ps_jit_gl_mesh_index_matrix) {
            x->input_type = JIT_GL_MESH_INDEX;
        } else if (s == ps_jit_gl_mesh_vertex_attr_matrix) {
            x->input_type = JIT_GL_MESH_VERTEX_ATTR;
        }
        // strip if user passes extra "jit_matrix" symbol
        if ((matrix_name == _jit_sym_jit_matrix) && (argc > 1)) {
            matrix_name = jit_atom_getsym(argv+1);
        }
    }
    
    if (matrix_name)
    {
        matrix = (t_jit_object*)jit_object_findregistered(matrix_name);
        if (!matrix)
        {
            post ("jit.gl.mesh: couldn't get matrix object!");
            return JIT_ERR_GENERIC;
        }

        // get matrix info
        jit_object_method(matrix, _jit_sym_getinfo, &info);

        if (x->input_type == JIT_GL_MESH_VERTEX && info.planecount >= 4 )
        {
            // handle combined matrix formats on next recalc
            info.type = _jit_sym_float32;
            x->update = TRUE;
        }
        else
        {
            // get associated cache
            cache = jit_gl_mesh_get_cache_for_input(x, x->input_type);
            if (!cache)
                return JIT_ERR_INVALID_PTR;

            // reset the cache
            err = jit_gl_cache_reset(cache);
            if (err)
                return err;

            // convert input to conform to cache datatypes
            switch (x->input_type)
            {
            case JIT_GL_MESH_INDEX:
                {
                    // supports datatypes: ubyte/ushort/uint
                    if (info.type == _jit_sym_char)
                    {
                        cache->datatype = GL_UNSIGNED_BYTE;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_UNSIGNED_INT;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_UNSIGNED_INT;
                        info.type = _jit_sym_long;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_UNSIGNED_INT;
                        info.type = _jit_sym_long;
                    }

                    // supports planes/coords: 1
                    info.planecount = 1;
                    break;
                }
            case JIT_GL_MESH_VERTEX:
                {
                    // supports datatypes: short/int/float/double
                    if (info.type == _jit_sym_char)
                    {
                        cache->datatype = GL_INT;
                        info.type = _jit_sym_long;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_INT;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_FLOAT;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_DOUBLE;
                    }

                    // supports planes/coords: 2/3/4
                    info.planecount = JIT_MATH_CLAMP(info.planecount, 2, 3);
                    break;
                }
            case JIT_GL_MESH_TEXCOORD:
                {
                    // supports datatypes: short/int/float/double
                    if (info.type == _jit_sym_char)
                    {
                        cache->datatype = GL_INT;
                        info.type = _jit_sym_long;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_INT;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_FLOAT;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_DOUBLE;
                    }

                    // supports planes/coords: 1/2/3/4
                    info.planecount = JIT_MATH_CLAMP(info.planecount, 1, 4);
                    break;
                }
            case JIT_GL_MESH_NORMAL:
                {
                    // supports datatypes: byte/short/int/float/double
                    if (info.type == _jit_sym_char)
                    {
                        // jitter chars are always unsigned which won't fit in a GL_BYTE -- convert to long
                        cache->datatype = GL_INT;
                        info.type = _jit_sym_long;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_INT;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_FLOAT;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_DOUBLE;
                    }

                    // supports planes/coords: 3
                    info.planecount = 3;
                    break;
                }
            case JIT_GL_MESH_COLOR:
                {
                    // supports datatypes: byte/ubyte/short/ushort/int/uint/float/double
                    if (info.type == _jit_sym_char)
                    {
                        cache->datatype = GL_UNSIGNED_BYTE;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_INT;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_FLOAT;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_DOUBLE;
                    }

                    // supports planes/coords: 3/4
                    info.planecount = JIT_MATH_CLAMP(info.planecount, 3, 4);
                    break;
                }
            case JIT_GL_MESH_EDGEFLAG:
                {
                    // supports datatypes: bool
                    cache->datatype = GL_BOOLEAN;
                    info.type = _jit_sym_long;  // convert to bool later

                    // supports planes/coords: 1
                    info.planecount = 1;
                    break;
                }
            case JIT_GL_MESH_TANGENT:
                {
                    // supports datatypes: float/double
                    if (info.type == _jit_sym_char)
                    {
                        cache->datatype = GL_FLOAT;
                        info.type = _jit_sym_float32;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_FLOAT;
                        info.type = _jit_sym_float32;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_FLOAT;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_DOUBLE;
                    }

                    // supports planes/coords: 4
                    info.planecount = 4;
                    break;
                }
            case JIT_GL_MESH_BITANGENT:
                {
                    // supports datatypes: float/double
                    if (info.type == _jit_sym_char)
                    {
                        cache->datatype = GL_FLOAT;
                        info.type = _jit_sym_float32;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_FLOAT;
                        info.type = _jit_sym_float32;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_FLOAT;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_DOUBLE;
                    }

                    // supports planes/coords: 4
                    info.planecount = 4;
                    break;
                }
            case JIT_GL_MESH_VERTEX_ATTR:
                {
                    // supports datatypes: byte/ubyte/short/ushort/int/uint/float/double
                    if (info.type == _jit_sym_char)
                    {
                        cache->datatype = GL_UNSIGNED_BYTE;
                    }
                    else if (info.type == _jit_sym_long)
                    {
                        cache->datatype = GL_INT;
                    }
                    else if (info.type == _jit_sym_float32)
                    {
                        cache->datatype = GL_FLOAT;
                    }
                    else if (info.type == _jit_sym_float64)
                    {
                        cache->datatype = GL_DOUBLE;
                    }

                    // supports any planecount
                    break;
                }
            default:
                jit_object_error((t_object *)x,"jit.gl.mesh: invalid input type");
                err = JIT_ERR_GENERIC;
                break;
            };
        }

        if (!err)
        {
            // restrict dimcount
            if (info.dimcount > 2)
                info.dimcount = 2;

            if (!x->input[x->input_type])
            {
                x->input[x->input_type] = (t_jit_object*)jit_object_new(gensym("jit_matrix"), NULL);
                if (!x->input[x->input_type])
                    return JIT_ERR_INVALID_PTR;
            }

            // copy incoming matrix to local input cache
            jit_object_method(x->input[x->input_type], _jit_sym_setinfo, &info);
            jit_object_method(x->input[x->input_type], _jit_sym_frommatrix, matrix, NULL);

            // toggle update and used flags for cache
            if (cache)
            {
                cache->update = TRUE;
                cache->used = TRUE;
            }
            x->update = TRUE;
        }
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_mesh_determine_mode(t_jit_gl_mesh *x)
{
    t_jit_err err = JIT_ERR_NONE;

    if (!x)
        return JIT_ERR_INVALID_PTR;

    // get cache type from symbol
    x->mode = jit_gl_mesh_mode_from_sym(x->cache_mode);

    // test system support for indicated cache type
    switch (x->mode)
    {
    case JIT_GL_MESH_CACHE_AUTO:
    case JIT_GL_MESH_CACHE_VERTEXBUFFER:
        {
            // verify system support for vertex buffer objects
            err = jit_gl_mesh_verify_extensions(x, pb_jit_gl_cache_vbo_required_ext);
            if (!err)
            {
                // use vertex buffer objects
                x->mode = JIT_GL_MESH_CACHE_VERTEXBUFFER;
            }
            else
            {
                // fallback to uncached vertex arrays
                x->mode = JIT_GL_MESH_CACHE_VERTEXARRAY;
            }
            break;
        }
    case JIT_GL_MESH_CACHE_VERTEXARRAY:
    case JIT_GL_MESH_CACHE_NONE:
        {
            // use uncached vertex arrays
            x->mode = JIT_GL_MESH_CACHE_VERTEXARRAY;
            break;
        }
    case JIT_GL_MESH_CACHE_DISPLAYLIST:
        {
            // use uncached vertex arrays
            x->mode = JIT_GL_MESH_CACHE_DISPLAYLIST;
            break;
        }
    default:
        {
            jit_object_error((t_object *)x,"jit.gl.mesh: invalid cache type");
            err = JIT_ERR_GENERIC;
        }
    }
    
    
    if(jit_gl_get_context())
        err = jit_gl_mesh_init_cache(x);
        
    return err;
}

t_jit_err jit_gl_mesh_draw_cache(t_jit_gl_mesh *x)
{
    long i;
    long mode = 0;
    t_jit_err error = JIT_ERR_NONE;

    if (!x->cache[JIT_GL_MESH_VERTEX]->used)
        return JIT_ERR_NONE;

    /*
        // debug drawing in immediate mode
        glBegin(x->enumtype);
        for(i = 0; i < x->cache[JIT_GL_MESH_VERTEX]->elements; i++)
            glVertex3fv(&((float*)x->cache[JIT_GL_MESH_VERTEX]->data)[i * 3]);
        glEnd();
        return JIT_ERR_NONE;
    */

    switch (x->mode)
    {
    case JIT_GL_MESH_CACHE_AUTO:
        {
            // get best mode for system
            error = jit_gl_mesh_determine_mode(x);
            if (error)
                return error;

            // try again
            return jit_gl_mesh_draw(x);
        }
    case JIT_GL_MESH_CACHE_DISPLAYLIST:
        error = jit_gl_cache_draw_dl(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXBUFFER:
        error = jit_gl_cache_draw_vbo(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXARRAY:
    case JIT_GL_MESH_CACHE_NONE:
    default:
        error = jit_gl_cache_draw_var(x);
        break;
    };

    jit_gl_report_error("jit.gl.mesh: drawing geometry");
    return error;
}

t_jit_err jit_gl_mesh_init_cache(t_jit_gl_mesh *x)
{
    long i;
    long mode = 0;
    t_jit_err error = JIT_ERR_NONE;

    switch (x->mode)
    {
    case JIT_GL_MESH_CACHE_AUTO:
        {
            // get best mode for system
            error = jit_gl_mesh_determine_mode(x);
            if (error)
                return error;

            // try again
            return jit_gl_mesh_init_cache(x);
        }
    case JIT_GL_MESH_CACHE_DISPLAYLIST:
        error = jit_gl_cache_init_dl(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXBUFFER:
        error = jit_gl_cache_init_vbo(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXARRAY:
    case JIT_GL_MESH_CACHE_NONE:
    default:
        error = jit_gl_cache_init_var(x);
        break;
    };

    jit_gl_report_error("jit.gl.mesh: initializing geometry cache");
    return error;
}

t_jit_err jit_gl_mesh_bind(t_jit_gl_mesh *x, t_symbol *s, int argc, t_atom *argv)
{
    long i;
    long mode = 0;
    t_jit_err error = JIT_ERR_NONE;

    switch (x->mode)
    {
    case JIT_GL_MESH_CACHE_AUTO:
        {
            // get best mode for system
            error = jit_gl_mesh_determine_mode(x);
            if (error)
                return error;

            // try again
            return jit_gl_mesh_bind(x, s, argc, argv);
        }
    case JIT_GL_MESH_CACHE_DISPLAYLIST:
        error = jit_gl_cache_bind_dl(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXBUFFER:
        error = jit_gl_cache_bind_vbo(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXARRAY:
    case JIT_GL_MESH_CACHE_NONE:
    default:
        error = jit_gl_cache_bind_var(x);
        break;
    };

    jit_gl_report_error("jit.gl.mesh: binding geometry");
    return error;
}

t_jit_err jit_gl_mesh_unbind(t_jit_gl_mesh *x, t_symbol *s, int argc, t_atom *argv)
{
    long i;
    t_jit_err error = JIT_ERR_NONE;

    switch (x->mode)
    {
    case JIT_GL_MESH_CACHE_AUTO:
        {
            // get best mode for system
            error = jit_gl_mesh_determine_mode(x);
            if (error)
                return error;

            // try again
            return jit_gl_mesh_unbind(x, s, argc, argv);
        }
    case JIT_GL_MESH_CACHE_DISPLAYLIST:
        error = jit_gl_cache_unbind_dl(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXBUFFER:
        error = jit_gl_cache_unbind_vbo(x);
        break;
    case JIT_GL_MESH_CACHE_VERTEXARRAY:
    case JIT_GL_MESH_CACHE_NONE:
    default:
        error = jit_gl_cache_unbind_var(x);
        break;
    };

    jit_gl_report_error("jit.gl.mesh: unbinding geometry");
    return error;
}

t_jit_gl_cache* jit_gl_mesh_get_cache_for_input(t_jit_gl_mesh *x, long input)
{
    switch (input)
    {
    case JIT_GL_MESH_INDEX:
    case JIT_GL_MESH_VERTEX:
    case JIT_GL_MESH_TEXCOORD:
    case JIT_GL_MESH_NORMAL:
    case JIT_GL_MESH_DIFFUSE:
    case JIT_GL_MESH_SPECULAR:
    case JIT_GL_MESH_EDGEFLAG:
    case JIT_GL_MESH_TANGENT:
    case JIT_GL_MESH_BITANGENT:
    case JIT_GL_MESH_VERTEX_ATTR:
        {
            return x->cache[input];
        }
    default:
        {
            jit_object_error((t_object *)x,"jit.gl.mesh: no cache associated with given input type!");
            return NULL;
        }
    };

    return NULL;
}

t_jit_err jit_gl_mesh_destroy(t_jit_gl_mesh *x)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_mesh_rebuild(t_jit_gl_mesh *x)
{
    long i;
    GLuint id, s, e;
    char *bp = NULL;
    t_jit_gl_cache *vertexcache = NULL;
    t_jit_gl_cache *cache = NULL;
    long buffer, buffertype, type, typesize;
    long offset, stride, width, height, coords, count;
    long colstride, rowstride, iters, size;


    GLubyte *glub;
    GLuint *glui;

    t_jit_err err = JIT_ERR_NONE;

    t_jit_object *matrix;
    t_jit_matrix_info info;

    if (!x)
        return JIT_ERR_GENERIC;

    for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
    {
        // set the buffer index
        buffer = i;

        // get the next input matrix
        matrix = x->input[i];
        if (!matrix)
            continue;

        x->enumtype = jit_gl_mesh_enumtype_from_sym(x->draw_mode);
        x->grid = (x->draw_mode == _jit_sym_gl_tri_grid) || (x->draw_mode == _jit_sym_gl_quad_grid);

        // get the matrix data and info
        jit_object_method(matrix, _jit_sym_getinfo, &info);
        jit_object_method(matrix, _jit_sym_getdata, &bp);

        // skip any invalid data
        if (!bp)
            return JIT_ERR_INVALID_PTR;

        // process each cache
        if (i == JIT_GL_MESH_VERTEX && info.planecount >= 4 )
        {
            // handle combined matrix formats
            err = jit_gl_mesh_from_matrix(x, matrix);
            if (err)
                return err;
        }
        else
        {
            // get the cache for this input
            cache = x->cache[i];

            // skip any unused cache
            if (!cache->used)
                continue;

            // init from matrix info
            err = jit_gl_mesh_init_cache_from_matrix_info(x, cache, &info);
            if (err)
                return err;

            // fill cache
            err = jit_gl_mesh_fill_cache(x, cache, &info, bp, 0, info.planecount, TRUE);
            if (err)
                return err;
        }
    }

    // generate requested data
    if (!x->optimize && x->cache[JIT_GL_MESH_VERTEX]->used && x->cache[JIT_GL_MESH_VERTEX]->elements)
    {
        if (x->auto_index)
        {
//            err = jit_gl_mesh_generate_indices(x);
            if (err)
            {
                jit_object_error((t_object *)x,"jit.gl.mesh: failed to auto generate indices!");
            }
        }
        if(x->auto_normals)
        {
            err = jit_gl_mesh_generate_normals(x);
            if (err)
            {
                jit_object_error((t_object *)x,"jit.gl.mesh: failed to auto generate normals!");
            }
        }
        if (x->auto_tangents || x->auto_bitangents)
        {
            err = jit_gl_mesh_generate_tangentspace(x, x->auto_tangents, x->auto_bitangents, FALSE);
            if (err)
            {
                jit_object_error((t_object *)x,"jit.gl.mesh: failed to auto generate tangents!");
            }
        }
        if (x->auto_colors)
        {
            err = jit_gl_mesh_generate_colors(x);
            if (err)
            {
                jit_object_error((t_object *)x,"jit.gl.mesh: failed to auto generate colors!");
            }
        }
    }
    x->update = FALSE;
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_mesh_optimize(t_jit_gl_mesh *x)
{
/*
    long grid = 0;
    t_jit_err err = JIT_ERR_NONE;

    long nvcount = 0;
    unsigned short nvprimcount = 0;
    unsigned short *nvindex = NULL;
    PrimitiveGroup *nvprims = NULL;

    t_jit_gl_cache *indexcache = x->cache[JIT_GL_MESH_INDEX];
    t_jit_gl_cache *vertexcache = x->cache[JIT_GL_MESH_VERTEX];
    t_jit_gl_cache *normalcache = x->cache[JIT_GL_MESH_NORMAL];
    t_jit_gl_cache *texcoordcache = x->cache[JIT_GL_MESH_TEXCOORD];
    t_jit_gl_cache *tangentcache = x->cache[JIT_GL_MESH_TANGENT];
    t_jit_gl_cache *bitangentcache = x->cache[JIT_GL_MESH_BITANGENT];

    // determine grid mode
    if ((x->draw_mode == _jit_sym_gl_tri_grid) || (x->draw_mode == _jit_sym_gl_quad_grid))
    {
        grid = 1;
    }
    else
    {
        grid = 0;
    }

    // do optimization
    if( vertexcache->used && vertexcache->data && texcoordcache->used && texcoordcache->data)
    {
        // generate indices
        if(!indexcache || !indexcache->used)
            jit_gl_mesh_generate_indices(x);

        // create a new mesh object
        t_jit_gl_mesh *mesh = jit_gl_mesh_new();
        if(!mesh) return JIT_ERR_GENERIC;

        // generate connectivity
        jit_gl_mesh_build(mesh, (float*)vertexcache->data, vertexcache->count, (long*)indexcache->data, indexcache->count); 

        // reorder index cache
        for (long i = 0; i < indexcache->count / 3; i++)
        {
            if (indexcache->datatype == GL_UNSIGNED_BYTE)
            {
                ((GLubyte*)indexcache->data)[i + 0] = mesh->triangle[i].v[0];
                ((GLubyte*)indexcache->data)[i + 1] = mesh->triangle[i].v[1];
                ((GLubyte*)indexcache->data)[i + 2] = mesh->triangle[i].v[2];
            }
            else if (indexcache->datatype == GL_UNSIGNED_INT)
            {
                ((GLuint*)indexcache->data)[i + 0] = mesh->triangle[i].v[0];
                ((GLuint*)indexcache->data)[i + 1] = mesh->triangle[i].v[1];
                ((GLuint*)indexcache->data)[i + 2] = mesh->triangle[i].v[2];
            }

        }

        // generate the tristrip index
        nvcount = indexcache->count;
        nvindex = (unsigned short*)jit_getbytes(indexcache->count * sizeof(unsigned short));
        if (!nvindex)
        {
            jit_object_error((t_object *)x,"jit.gl.mesh: optimization failed -- out of memory!");
            return JIT_ERR_INVALID_PTR;
        }

        for (long i = 0; i < indexcache->count; i++)
        {
            unsigned short index = 0;
            if (indexcache->datatype == GL_UNSIGNED_BYTE)
            {
                index = ((GLubyte*)indexcache->data)[i];
            }
            else if (indexcache->datatype == GL_UNSIGNED_INT)
            {
                index = ((GLuint*)indexcache->data)[i];
            }

            // clamp the index
            index = JIT_MATH_CLAMP(index, 0, vertexcache->count);
            nvindex[i] = index;
        }

        // generate tri stips
        bool status = GenerateStrips(nvindex, nvcount, &nvprims, &nvprimcount, true);
        if (!status)
        {
            jit_object_error((t_object *)x,"jit.gl.mesh: optimization failed -- unable to generate tri strips!");
            return JIT_ERR_GENERIC;
        }

        // fill optimizer
        MeshMender optimizer;
        std::vector< MeshMender::Vertex > vertices;
        std::vector< unsigned int > indices;
        std::vector< unsigned int > results;

        for (long i = 0; i < vertexcache->count; i++)
        {
            MeshMender::Vertex v;

            // get the vertex position
            if (vertexcache->datatype == GL_INT)
            {
                for (long d = 0; d < 3 && d < vertexcache->coords; d++)
                    v.pos[d] = ((GLint*)vertexcache->data)[i * vertexcache->coords + d];
            }
            else if (vertexcache->datatype == GL_FLOAT)
            {
                for (long d = 0; d < 3 && d < vertexcache->coords; d++)
                    v.pos[d] = ((GLfloat*)vertexcache->data)[i * vertexcache->coords + d];
            }
            else if (vertexcache->datatype == GL_DOUBLE)
            {
                for (long d = 0; d < 3 && d < vertexcache->coords; d++)
                    v.pos[d] = ((GLdouble*)vertexcache->data)[i * vertexcache->coords + d];
            }

            // get the texture coordinates
            if (texcoordcache && texcoordcache->used && i < texcoordcache->count)
            {
                if (texcoordcache->datatype == GL_INT)
                {
                    v.s = ((GLint*)texcoordcache->data)[i * texcoordcache->coords + 0];
                    v.t = ((GLint*)texcoordcache->data)[i * texcoordcache->coords + 1];
                }
                else if (texcoordcache->datatype == GL_FLOAT)
                {
                    v.s = ((GLfloat*)texcoordcache->data)[i * texcoordcache->coords + 0];
                    v.t = ((GLfloat*)texcoordcache->data)[i * texcoordcache->coords + 1];
                }
                else if (texcoordcache->datatype == GL_DOUBLE)
                {
                    v.s = ((GLdouble*)texcoordcache->data)[i * texcoordcache->coords + 0];
                    v.t = ((GLdouble*)texcoordcache->data)[i * texcoordcache->coords + 1];
                }
            }

            // get the vertex position
            if (normalcache && normalcache->used && i < normalcache->count)
            {
                if (normalcache->datatype == GL_INT)
                {
                    for (long d = 0; d < 3 && d < normalcache->coords; d++)
                        v.normal[d] = ((GLint*)normalcache->data)[i * normalcache->coords + d];
                }
                else if (normalcache->datatype == GL_FLOAT)
                {
                    for (long d = 0; d < 3 && d < normalcache->coords; d++)
                        v.normal[d] = ((GLfloat*)normalcache->data)[i * normalcache->coords + d];
                }
                else if (normalcache->datatype == GL_DOUBLE)
                {
                    for (long d = 0; d < 3 && d < normalcache->coords; d++)
                        v.normal[d] = ((GLdouble*)normalcache->data)[i * normalcache->coords + d];
                }
            }

            // add vertex to list
            vertices.push_back(v);

        }

        for (unsigned short i = 0; i < nvprimcount; i++)
        {
            for (unsigned short j = 0; j < nvprims[i].numIndices; j++)
            {
                indices.push_back(nvprims[i].indices[j]);
            }
        }
                // get the index if specified
                if(indexcache && indexcache->used)
                {
                    for(long i = 0; i < vertexcache->count; i++)
                    {
                        long index = i;
                        if(indexcache->datatype == GL_UNSIGNED_BYTE)
                        {
                            index = ((GLubyte*)indexcache->data)[i];
                        }
                        else if(indexcache->datatype == GL_UNSIGNED_INT)
                        {
                            index = ((GLuint*)indexcache->data)[i];
                        }
         
                        // clamp the index
                        index = JIT_MATH_CLAMP(index, 0, vertexcache->count);
                        indices.push_back(index);
                    }
         
                }
                else
                {
                    for(long i = 0; i < vertexcache->count - 2; i++)
                    {
                        if(grid && (i & 0x1))
                        {
                            indices.push_back(i + 0);
                            indices.push_back(i + 2);
                            indices.push_back(i + 1);
                        }
                        else
                        {
                            indices.push_back(i + 0);
                            indices.push_back(i + 1);
                            indices.push_back(i + 2);
                        }
                    }
                }

        // perform the optimization
        optimizer.Mend( vertices, indices, results, x->smooth_normals, x->smooth_tangents, x->smooth_bitangents, x->weight_normals,
                        x->auto_normals ? MeshMender::CALCULATE_NORMALS : MeshMender::DONT_CALCULATE_NORMALS,
                        x->auto_split ? MeshMender::DONT_RESPECT_SPLITS : MeshMender::RESPECT_SPLITS,
                        x->fix_cylindrical ? MeshMender::FIX_CYLINDRICAL : MeshMender::DONT_FIX_CYLINDRICAL);

        // destroy all existing cache data
        for (long i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
        {
            if (i != JIT_GL_MESH_COLOR)
            {
                jit_gl_cache_buffer_destroy(x->cache[i]);
            }

            // get the buffer type
            if (i == JIT_GL_MESH_INDEX)
            {
                x->cache[i]->buffertype = GL_ELEMENT_ARRAY_BUFFER_ARB;
            }
            else
            {
                x->cache[i]->buffertype = GL_ARRAY_BUFFER_ARB;
            }
        }

                // vertices
                err = jit_gl_cache_resize(vertexcache, vertices.size() * 3, 
                        vertexcache->coords, vertexcache->datatype, FALSE);
                if(err) return err;     
                
                // texcoords
                err = jit_gl_cache_resize(texcoordcache, vertices.size() * 2, 2, GL_FLOAT, FALSE);
                if(err) return err;     
         
                // indices
                if(x->auto_index)
                {
                    err = jit_gl_cache_resize(indexcache, results.size() * 1, 1, 
                            (results.size() < 255) ? GL_UNSIGNED_BYTE : GL_UNSIGNED_INT, FALSE);
                    if(err) return err;
                }
         
                // normals
                if(x->auto_normals)
                {
                    err = jit_gl_cache_resize(normalcache, vertices.size() * 3, 3, GL_FLOAT, FALSE);
                    if(err) return err;
                }
            
                // tangents
                if(x->auto_tangents)
                {
                    err = jit_gl_cache_resize(tangentcache, vertices.size() * 3, 3, GL_FLOAT, FALSE);
                    if(err) return err;
                }
            
                // bitangents
                if(x->auto_bitangents)
                {
                    err = jit_gl_cache_resize(bitangentcache, vertices.size() * 3, 3, GL_FLOAT, FALSE);
                    if(err) return err;
                }

        // reorder vertex positions
        for (unsigned long i = 0; i < results.size(); i++)
        {
            long index = results[i];
            MeshMender::Vertex v = vertices[index];

            // indices
            if (indexcache->used)
            {
                if (indexcache->datatype == GL_UNSIGNED_BYTE)
                {
                    ((GLubyte*)indexcache->data)[i] = index % 255;
                }
                else if (indexcache->datatype == GL_UNSIGNED_INT)
                {
                    ((GLuint*)indexcache->data)[i] = index;
                }
            }

            // vertex positions
            if (vertexcache->used)
            {
                if (vertexcache->datatype == GL_INT)
                {
                    for (long d = 0; d < 3 && d < vertexcache->coords; d++)
                        ((GLint*)vertexcache->data)[i * vertexcache->coords + d] = (GLint)v.pos[d];
                }
                else if (vertexcache->datatype == GL_FLOAT)
                {
                    for (long d = 0; d < 3 && d < vertexcache->coords; d++)
                        ((GLfloat*)vertexcache->data)[i * vertexcache->coords + d] = (GLfloat)v.pos[d];
                }
                else if (vertexcache->datatype == GL_DOUBLE)
                {
                    for (long d = 0; d < 3 && d < vertexcache->coords; d++)
                        ((GLdouble*)vertexcache->data)[i * vertexcache->coords + d] = (GLdouble)v.pos[d];
                }
            }

            // texcoord
            if (texcoordcache->used)
            {
                if (texcoordcache->datatype == GL_INT)
                {
                    for (long d = 0; d < 2 && d < texcoordcache->coords; d++)
                        ((GLint*)texcoordcache->data)[i * texcoordcache->coords + d] = (GLint)((d == 0) ? v.s : v.t);
                }
                else if (texcoordcache->datatype == GL_FLOAT)
                {
                    for (long d = 0; d < 2 && d < texcoordcache->coords; d++)
                        ((GLfloat*)texcoordcache->data)[i * texcoordcache->coords + d] = (GLfloat)((d == 0) ? v.s : v.t);
                }
                else if (texcoordcache->datatype == GL_DOUBLE)
                {
                    for (long d = 0; d < 2 && d < texcoordcache->coords; d++)
                        ((GLdouble*)texcoordcache->data)[i * texcoordcache->coords + d] = (GLdouble)((d == 0) ? v.s : v.t);
                }
            }

            // normals
            if (normalcache->used)
            {
                if (normalcache->datatype == GL_INT)
                {
                    for (long d = 0; d < 3 && d < normalcache->coords; d++)
                        ((GLint*)normalcache->data)[i * normalcache->coords + d] = (GLint)v.normal[d];
                }
                else if (normalcache->datatype == GL_FLOAT)
                {
                    for (long d = 0; d < 3 && d < normalcache->coords; d++)
                        ((GLfloat*)normalcache->data)[i * normalcache->coords + d] = (GLfloat)v.normal[d];
                }
                else if (normalcache->datatype == GL_DOUBLE)
                {
                    for (long d = 0; d < 3 && d < normalcache->coords; d++)
                        ((GLdouble*)normalcache->data)[i * normalcache->coords + d] = (GLdouble)v.normal[d];
                }
            }

            // tangents
            if (tangentcache->used)
            {
                if (tangentcache->datatype == GL_FLOAT)
                {
                    for (long d = 0; d < 3 && d < tangentcache->coords; d++)
                        ((GLfloat*)tangentcache->data)[i * tangentcache->coords + d] = (GLfloat)v.tangent[d];
                }
                else if (tangentcache->datatype == GL_DOUBLE)
                {
                    for (long d = 0; d < 3 && d < tangentcache->coords; d++)
                        ((GLdouble*)tangentcache->data)[i * tangentcache->coords + d] = (GLdouble)v.tangent[d];
                }
            }

            // bitangents
            if (bitangentcache->used)
            {
                if (bitangentcache->datatype == GL_FLOAT)
                {
                    for (long d = 0; d < 3 && d < bitangentcache->coords; d++)
                        ((GLfloat*)bitangentcache->data)[i * bitangentcache->coords + d] = (GLfloat)v.bitangent[d];
                }
                else if (bitangentcache->datatype == GL_DOUBLE)
                {
                    for (long d = 0; d < 3 && d < bitangentcache->coords; d++)
                        ((GLdouble*)bitangentcache->data)[i * bitangentcache->coords + d] = (GLdouble)v.bitangent[d];
                }
            }
        }
    }
*/
    return JIT_ERR_NONE;
}

// --------------------------------------------------------------------------

t_jit_err jit_gl_mesh_init_cache_from_matrix_info(
    t_jit_gl_mesh *x, t_jit_gl_cache *cache, t_jit_matrix_info *info)
{
    long orient = 0;
    
    t_jit_gl_cache *vertexcache = x->cache[JIT_GL_MESH_VERTEX];

    if (!cache || !info)
        return JIT_ERR_INVALID_PTR;
    
    // get matrix info
    cache->coords = cache->coords ? cache->coords : info->planecount;
    cache->elements = 0;
    cache->used = FALSE;

    // get the buffer type
    if (cache->type == JIT_GL_MESH_INDEX)
    {
        cache->buffertype = GL_ELEMENT_ARRAY_BUFFER_ARB;  
    }
    else
    {
        cache->buffertype = GL_ARRAY_BUFFER_ARB;
    }

    cache->datatype = jit_gl_cache_datatype_from_symbol(info->type);
    cache->datasize = jit_gl_cache_datasize_from_datatype(cache->datatype);

    // set geometry dependent values
    cache->enumtype = x->enumtype;
    cache->geomsize = jit_gl_mesh_geomsize_from_enumtype(x->enumtype);
    cache->stride = 0;
    cache->start = 0;
    cache->end = cache->count;

    if (cache->data && cache->bytes)
        jit_freebytes(cache->data, cache->bytes);
    cache->data = NULL;
    cache->bytes = 0;

    // set byte count for grid and non-grid modes
    if ((x->draw_mode == _jit_sym_gl_tri_grid) || (x->draw_mode == _jit_sym_gl_quad_grid))
    {
        // for degenerate triangles connecting each row
        // cache->count = 2 * (JIT_MATH_MAX(info->dim[1], info->dim[0]) + 1) * (JIT_MATH_MIN(info->dim[1], info->dim[0]) - 1);
        //cache->count = cache->coords * 2 * (JIT_MATH_MAX(info->dim[1], info->dim[0])) * (JIT_MATH_MIN(info->dim[1], info->dim[0]) - 1);
        cache->count = cache->coords * 2 * (info->dim[0] * info->dim[1]); //should be able to elinate 1 from height, btu let's just pad a tad extra
    }
    else
    {
        cache->count = cache->coords * info->dim[0] * info->dim[1];
    }

    // force the same size on all cache objects
    if(cache != vertexcache)
    {
        if(cache->count < vertexcache->count)
            cache->count = vertexcache->count;
    }

    cache->bytes = cache->count * cache->datasize;
    cache->data = jit_getbytes(cache->bytes);
    if (!cache->data)
    {
        jit_object_error((t_object *)x,"jit.gl.mesh: unable to initialize cache -- out of memory!");
        cache->bytes = 0;
        return JIT_ERR_INVALID_PTR;
    }
    
    

    return JIT_ERR_NONE;
}

#define _I_X    0
#define _I_Y    1
#define _I_Z    2
#define _I_S    3
#define _I_T    4
#define _I_NX   5
#define _I_NY   6
#define _I_NZ   7
#define _I_R    8
#define _I_G    9
#define _I_B    10
#define _I_A    11
#define _I_E    12

t_jit_err jit_gl_mesh_from_matrix(t_jit_gl_mesh *x, t_jit_object *matrix)
{
    float *p, *p2;
    char *bp = NULL;
    long size, type, datatype, datasize, planestart, planeend;
    long i, j, rowstride, width, height, planecount, up = 0;
    t_jit_matrix_info info;
    t_jit_err err;

    GLfloat *gledgeflag = NULL;
    GLfloat *glnormal = NULL;
    GLfloat *glcolor = NULL;
    GLfloat *gltexcoord = NULL;
    GLfloat *glvertex = NULL;

    t_jit_gl_cache *edgeflagcache = x->cache[JIT_GL_MESH_EDGEFLAG];
    t_jit_gl_cache *normalcache = x->cache[JIT_GL_MESH_NORMAL];
    t_jit_gl_cache *colorcache = x->cache[JIT_GL_MESH_COLOR];
    t_jit_gl_cache *texcoordcache = x->cache[JIT_GL_MESH_TEXCOORD];
    t_jit_gl_cache *vertexcache = x->cache[JIT_GL_MESH_VERTEX];

    if (!matrix)
        return JIT_ERR_INVALID_PTR;

    jit_object_method(matrix, _jit_sym_getinfo, &info);
    jit_object_method(matrix, _jit_sym_getdata, &bp);

    if (!bp)
        return JIT_ERR_INVALID_PTR;

    // later add support for other types
    if (info.type != _jit_sym_float32)
        return JIT_ERR_MISMATCH_TYPE;

    planecount = info.planecount;
    rowstride = info.dimstride[1];
    height = info.dim[1] - 1;
    width = info.dim[0];
    size = width * height * 3;
    datatype = GL_FLOAT;
    datasize = sizeof(GLfloat);

    // destroy all existing cache data
    for (i = 0; i < JIT_GL_MESH_MAX_INPUTCOUNT; i++)
    {
        err = jit_gl_cache_reset(x->cache[i]);
        if (err)
            return err;
    }

    // init cache size
    switch (planecount)
    {
    case 16:
    case 15:
    case 14:
    case 13:
        {
            // vertex
            vertexcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, vertexcache, &info, bp, _I_X, _I_Z + 1, TRUE);
            if (err)
                return err;
            glvertex = (GLfloat*)vertexcache->data;

            // texcoord
            texcoordcache->coords = 2;
            err = jit_gl_mesh_fill_cache(x, texcoordcache, &info, bp, _I_S, _I_T + 1, TRUE);
            if (err)
                return err;
            gltexcoord = (GLfloat*)texcoordcache->data;

            // normal
            normalcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, normalcache, &info, bp, _I_NX, _I_NZ + 1, TRUE);
            if (err)
                return err;
            glnormal = (GLfloat*)normalcache->data;

            // color
            colorcache->coords = 4;
            err = jit_gl_mesh_fill_cache(x, colorcache, &info, bp, _I_R, _I_A + 1, TRUE);
            if (err)
                return err;
            glcolor = (GLfloat*)colorcache->data;

            // edgeflag
            edgeflagcache->coords = 1;
            err = jit_gl_mesh_fill_cache(x, edgeflagcache, &info, bp, _I_E, _I_E + 1, TRUE);
            if (err)
                return err;
            gledgeflag = (GLfloat*)edgeflagcache->data;
            break;
        }
    case 12:
        {
            //vertex
            vertexcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, vertexcache, &info, bp, _I_X, _I_Z + 1, TRUE);
            if (err)
                return err;
            glvertex = (GLfloat*)vertexcache->data;

            // texcoord
            texcoordcache->coords = 2;
            err = jit_gl_mesh_fill_cache(x, texcoordcache, &info, bp, _I_S, _I_T + 1, TRUE);
            if (err)
                return err;
            gltexcoord = (GLfloat*)texcoordcache->data;

            // normal
            normalcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, normalcache, &info, bp, _I_NX, _I_NZ + 1, TRUE);
            if (err)
                return err;
            glnormal = (GLfloat*)normalcache->data;

            // color
            colorcache->coords = 4;
            err = jit_gl_mesh_fill_cache(x, colorcache, &info, bp, _I_R, _I_A + 1, TRUE);
            if (err)
                return err;
            glcolor = (GLfloat*)colorcache->data;
            break;
        }
    case 11:
    case 10:
    case 9:
    case 8:
        {
            // vertex
            vertexcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, vertexcache, &info, bp, _I_X, _I_Z + 1, TRUE);
            if (err)
                return err;
            glvertex = (GLfloat*)vertexcache->data;

            // texcoord
            texcoordcache->coords = 2;
            err = jit_gl_mesh_fill_cache(x, texcoordcache, &info, bp, _I_S, _I_T + 1, TRUE);
            if (err)
                return err;
            gltexcoord = (GLfloat*)texcoordcache->data;

            // normal
            normalcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, normalcache, &info, bp, _I_NX, _I_NZ + 1, TRUE);
            if (err)
                return err;
            glnormal = (GLfloat*)normalcache->data;
            break;
        }
    case 7:
    case 6:
    case 5:
        {
            // vertex
            vertexcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, vertexcache, &info, bp, _I_X, _I_Z + 1, TRUE);
            if (err)
                return err;
            glvertex = (GLfloat*)vertexcache->data;

            // texcoord
            texcoordcache->coords = 2;
            err = jit_gl_mesh_fill_cache(x, texcoordcache, &info, bp, _I_S, _I_T + 1, TRUE);
            if (err)
                return err;
            gltexcoord = (GLfloat*)texcoordcache->data;
            break;
        }
    case 4:
    case 3:
        {
            // vertex
            vertexcache->coords = 3;
            err = jit_gl_mesh_fill_cache(x, vertexcache, &info, bp, _I_X, _I_Z + 1, TRUE);
            if (err)
                return err;
            glvertex = (GLfloat*)vertexcache->data;
            break;
        }
    };

    return JIT_ERR_NONE;
}

t_jit_err jit_gl_mesh_fill_cache(
    t_jit_gl_mesh *x, t_jit_gl_cache *cache,
    t_jit_matrix_info *info, char *bp,
    long planestart, long planeend, long allocate)
{
    t_jit_err err;
    long i, j, k, c;
    long grid = 0;
    long orient = 0;
    long planejump;
    long planecount;
    long rowstride;
    long height;
    long width;

    GLboolean *glb;
    GLubyte *glub;
    GLuint *glui;
    GLint *gli;
    GLfloat *glf;
    GLdouble *gld;

    if (!x || !cache || !info || !bp)
        return JIT_ERR_INVALID_PTR;

    // allocate
    if (allocate)
    {
        err = jit_gl_mesh_init_cache_from_matrix_info(x, cache, info);
        if (err)
            return err;
    }

    if (!cache->data)
    {
        cache->data = NULL;
        cache->bytes = 0;

        jit_object_error((t_object *)x,"jit.gl.mesh: unable to fill geometry cache -- out of memory!");
        return JIT_ERR_INVALID_PTR;
    }
    cache->manage = TRUE;
    cache->elements = 0;
    cache->used = FALSE;

    // clear cache
    setmem(cache->data, 0, cache->bytes);        

    // check to see if we are in grid mode
    if ((x->draw_mode == _jit_sym_gl_tri_grid) || (x->draw_mode == _jit_sym_gl_quad_grid))
    {
        grid = 1;
    }
    else
    {
        grid = 0;
    }

    // check for the current orientation based on dims
    if ((info->dim[1] <= 1 ) && (info->dim[0] > info->dim[1]))
    {
        // force row major
        orient = 0;
    }
    else if (( info->dim[0] <= 1 ) && (info->dim[1] > info->dim[0]))
    {
        // force column major
        orient = 1;
    }

    if (grid)
    {
        planejump = info->planecount;
        planecount = info->planecount;
        rowstride = info->dimstride[1];
        height = info->dim[1] - 1;
        width = info->dim[0];
//        jit_object_post((t_object *)x,"jit.gl.geom: grid");

        if (width <= 1 && height <= 0)
        {
            return JIT_ERR_GENERIC;
        }
    }
    else
    {
        if (orient)
        {
            // column major
            planejump = info->dimstride[1] / jit_matrix_info_typesize(info);
            planecount = info->planecount;
            rowstride = info->dimstride[0];
            height = info->dim[0];
            width = info->dim[1];
        }
        else
        {
            // row major
            planejump = info->planecount;
            planecount = info->planecount;
            rowstride = info->dimstride[1];
            height = info->dim[1];
            width = info->dim[0];
        }
    }

    cache->drawcount = height;
    cache->drawsize = grid ? width * 2 : width;
    planestart = JIT_MATH_CLAMP(planestart, 0, planecount);
    planeend = JIT_MATH_CLAMP(planeend, planestart, planecount);

//    jit_object_post((t_object *)x,"jit.gl.geom: w[%d] h[%d] p[%d][%d][%d] j[%d] rst[%d]",
//         width, height, planestart, planeend, planecount, planejump, rowstride);

    // convert to gl native datatypes
    if (info->type == _jit_sym_long && cache->datatype == GL_BOOLEAN)
    {
        long *p, *p2;
        glb = (GLboolean*)cache->data;

        for (i = 0; i < height; i++)
        {
            // get current row and next row
            p = (long *)(bp + i * rowstride);
            p2 = (long *)(bp + (i + 1) * rowstride);

            // iterate across the current data row adding vertex positions
            for (j = 0; j < width; j++)
            {
                for (k = planestart; k < planeend; k++)
                {
                    *glb = p[k] > 0 ? TRUE : FALSE;
                    glb++;
                }
                cache->elements++;
                p += planejump;

                // grids: skip to next row and add lower vertex
                if (grid)
                {
                    for (k = planestart; k < planeend; k++)
                    {
                        *glb = p[k] > 0 ? TRUE : FALSE;
                        glb++;
                    }
                    cache->elements++;
                    p2 += planejump;
                }
            }
        }
    }
    else if (info->type == _jit_sym_char && cache->datatype == GL_UNSIGNED_BYTE)
    {
        unsigned char *p, *p2;
        glub = (GLubyte*)cache->data;

        for (i = 0; i < height; i++)
        {
            // get current row and next row
            p = (unsigned char *)(bp + i * rowstride);
            p2 = (unsigned char *)(bp + (i + 1) * rowstride);

            // iterate across the current data row adding vertex positions
            for (j = 0; j < width; j++)
            {
                for (k = planestart; k < planeend; k++)
                {
                    *glub = p[k];
                    glub++;
                }
                cache->elements++;
                p += planejump;

                // grids: skip to next row and add lower vertex
                if (grid)
                {
                    for (k = planestart; k < planeend; k++)
                    {
                        *glub = p2[k];
                        glub++;
                    }
                    cache->elements++;
                    p2 += planejump;
                }
            }
        }
    }
    else if (info->type == _jit_sym_long && cache->datatype == GL_UNSIGNED_INT)
    {
        long *p, *p2;
        glui = (GLuint*)cache->data;

        for (i = 0; i < height; i++)
        {
            // get current row and next row
            p = (long *)(bp + i * rowstride);
            p2 = (long *)(bp + (i + 1) * rowstride);

            // iterate across the current data row adding vertex positions
            for (j = 0; j < width; j++)
            {
                for (k = planestart; k < planeend; k++)
                {
                    *glui = p[k];
                    glui++;
                }
                cache->elements++;
                p += planejump;

                // grids: skip to next row and add lower vertex
                if (grid)
                {
                    for (k = planestart; k < planeend; k++)
                    {
                        *glui = p2[k];
                        glui++;
                    }
                    cache->elements++;
                    p2 += planejump;
                }
            }
        }
    }
    else if (info->type == _jit_sym_long && cache->datatype == GL_INT)
    {
        long *p, *p2;
        gli = (GLint*)cache->data;

        for (i = 0; i < height; i++)
        {
            // get current row and next row
            p = (long *)(bp + i * rowstride);
            p2 = (long *)(bp + (i + 1) * rowstride);

            // iterate across the current data row adding vertex positions
            for (j = 0; j < width; j++)
            {
                for (k = planestart; k < planeend; k++)
                {
                    *gli = p[k];
                    gli++;
                }
                cache->elements++;
                p += planejump;

                // grids: skip to next row and add lower vertex
                if (grid)
                {
                    for (k = planestart; k < planeend; k++)
                    {
                        *gli = p2[k];
                        gli++;
                    }
                    cache->elements++;
                    p2 += planejump;
                }
            }
        }
    }
    else if (info->type == _jit_sym_float32 && cache->datatype == GL_FLOAT)
    {
        float *p, *p2;
        float v;
        glf = (GLfloat*)cache->data;

        for (i = 0; i < height; i++)
        {
            // get current row and next row
            p = (float *)(bp + i * rowstride);
            p2 = (float *)(bp + (i + 1) * rowstride);

            // iterate across the current data row adding vertex positions
            for (j = 0; j < width; j++)
            {
                for (k = planestart; k < planeend; k++)
                {
                    *glf = p[k];
                    glf++;
                }
                cache->elements++;
                p += planejump;

                // grids: skip to next row and add lower vertex
                if (grid)
                {
                    for (k = planestart; k < planeend; k++)
                    {
                        *glf = p2[k];
                        glf++;
                    }
                    cache->elements++;
                    p2 += planejump;
                }
            }
        }
    }
    else if (info->type == _jit_sym_float64 && cache->datatype == GL_DOUBLE)
    {
        double *p, *p2;
        gld = (GLdouble*)cache->data;

        for (i = 0; i < height; i++)
        {
            // get current row and next row
            p = (double *)(bp + i * rowstride);
            p2 = (double *)(bp + (i + 1) * rowstride);

            // iterate across the current data row adding vertex positions
            for (j = 0; j < width; j++)
            {
                for (k = planestart; k < planeend; k++)
                {
                    *gld = p[k];
                    gld++;
                }
                cache->elements++;
                p += planejump;

                // grids: skip to next row and add lower vertex
                if (grid)
                {
                    for (k = planestart; k < planeend; k++)
                    {
                        *gld = p2[k];
                        gld++;
                    }
                    cache->elements++;
                    p2 += planejump;
                }
            }
        }
    }
    else
    {
        jit_object_error((t_object *)x,"jit.gl.mesh: unable to fill cache -- cannot convert data!");
        return JIT_ERR_GENERIC;
    }
    
    if(cache->elements > 0)
        cache->used = TRUE;

    return JIT_ERR_NONE;
}

// --------------------------------------------------------------------------

t_jit_err jit_gl_mesh_verify_extensions(t_jit_gl_mesh *x, const char **extensions)
{
    long i = 0;
    const char *ext = 0;
    char supported = TRUE;

    // check for system support for glsl
    while ((ext = extensions[i++]) != 0)
    {
        if (jit_gl_is_extension_supported(jit_gl_get_context(), ext) == GL_FALSE)
        {
            supported = FALSE;
        }
    }

    if (!supported)
    {
        return JIT_ERR_HW_UNAVAILABLE;
    }

    return JIT_ERR_NONE;
}

// --------------------------------------------------------------------------

long jit_gl_mesh_elements_from_enumtype(long enumtype, long count)
{
    switch (enumtype)
    {
    case GL_POINTS:
        {
            return count;
        }
    case GL_LINES:
        {
            return count / 2;
        }
    case GL_LINE_STRIP:
        {
            return count - 1;
        }
    case GL_LINE_LOOP:
        {
            return count;
        }
    case GL_TRIANGLES:
        {
            return count / 3;
        }
    case GL_TRIANGLE_STRIP:
        {
            return count - 2;
        }
    case GL_TRIANGLE_FAN:
        {
            return count - 2;
        }
    case GL_QUADS:
        {
            return count / 4;
        }
    case GL_QUAD_STRIP:
        {
            return count / 2 - 1;
        }
    case GL_POLYGON:
        {
            return 1;
        }
    default:
        {
            return 1;
        }
    }
    return 1;
}

long jit_gl_mesh_geomsize_from_enumtype(long enumtype)
{
    switch (enumtype)
    {
    case GL_POINTS:
        {
            return 1;
        }
    case GL_LINES:
        {
            return 2;
        }
    case GL_LINE_STRIP:
        {
            return 1;
        }
    case GL_LINE_LOOP:
        {
            return 1;
        }
    case GL_TRIANGLES:
        {
            return 3;
        }
    case GL_TRIANGLE_STRIP:
        {
            return 1;
        }
    case GL_TRIANGLE_FAN:
        {
            return 1;
        }
    case GL_QUADS:
        {
            return 3;
        }
    case GL_QUAD_STRIP:
        {
            return 2;
        }
    case GL_POLYGON:
        {
            return 1;
        }
    default:
        {
            return 1;
        }
    }
    return 1;
}

GLenum jit_gl_mesh_enumtype_from_sym(t_symbol *s)
{
    if (s == _jit_sym_gl_quad_grid)
    {
        return GL_QUAD_STRIP;
    }
    else if (s == _jit_sym_gl_tri_grid)
    {
        return GL_TRIANGLE_STRIP;
    }
    else if (s == _jit_sym_gl_points)
    {
        return GL_POINTS;
    }
    else if (s == _jit_sym_gl_lines)
    {
        return GL_LINES;
    }
    else if (s == _jit_sym_gl_line_strip)
    {
        return GL_LINE_STRIP;
    }
    else if (s == _jit_sym_gl_line_loop)
    {
        return GL_LINE_LOOP;
    }
    else if (s == _jit_sym_gl_triangles)
    {
        return GL_TRIANGLES;
    }
    else if (s == _jit_sym_gl_tri_strip)
    {
        return GL_TRIANGLE_STRIP;
    }
    else if (s == _jit_sym_gl_tri_fan)
    {
        return GL_TRIANGLE_FAN;
    }
    else if (s == _jit_sym_gl_quads)
    {
        return GL_QUADS;
    }
    else if (s == _jit_sym_gl_quad_strip)
    {
        return GL_QUAD_STRIP;
    }
    else if (s == _jit_sym_gl_polygon)
    {
        return GL_POLYGON;
    }
    else if (s == ps_jit_gl_mesh_lines_adjacency)
    {
        return GL_LINES_ADJACENCY_EXT;
    }
    else if (s == ps_jit_gl_mesh_line_strip_adjacency)
    {
        return GL_LINE_STRIP_ADJACENCY_EXT;
    }
    else if (s == ps_jit_gl_mesh_triangles_adjacency)
    {
        return GL_TRIANGLES_ADJACENCY_EXT;
    }
    else if (s == ps_jit_gl_mesh_triangle_strip_adjacency)
    {
        return GL_TRIANGLE_STRIP_ADJACENCY_EXT;
    }
    else
    {
        return GL_LINES;
    }
}

long jit_gl_mesh_mode_from_sym(t_symbol *s)
{
    if (s == ps_jit_gl_cache_auto)
    {
        return JIT_GL_MESH_CACHE_AUTO;
    }
    else if (s == ps_jit_gl_cache_none)
    {
        // draw via uncached vertex arrays
        return JIT_GL_MESH_CACHE_VERTEXARRAY;
    }
    else if (s == ps_jit_gl_cache_displaylist)
    {
        return JIT_GL_MESH_CACHE_DISPLAYLIST;
    }
    else if (s == ps_jit_gl_cache_dl)
    {
        return JIT_GL_MESH_CACHE_DISPLAYLIST;
    }
    else if (s == ps_jit_gl_cache_vertexbuffer)
    {
        return JIT_GL_MESH_CACHE_VERTEXBUFFER;
    }
    else if (s == ps_jit_gl_cache_vbo)
    {
        return JIT_GL_MESH_CACHE_VERTEXBUFFER;
    }
    else if (s == ps_jit_gl_cache_vertexarray)
    {
        return JIT_GL_MESH_CACHE_VERTEXARRAY;
    }
    else if (s == ps_jit_gl_cache_var)
    {
        return JIT_GL_MESH_CACHE_VERTEXARRAY;
    }
    else
    {
        return JIT_GL_MESH_CACHE_AUTO;
    }
}

// --------------------------------------------------------------------------

Copyright © 2008, Cycling '74