Max 5 API Reference

jit.gl.cache.c

/*
* jit.gl.cache.h
*
* Copyright 2001-2005 - Cycling '74
* Derek Gerstmann - derek@cycling74.com
*
* Internal data structure for storing cached geometric data.
*
*/

#include "jit.math.h"
#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"

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

t_symbol *ps_jit_gl_cache_none;
t_symbol *ps_jit_gl_cache_auto;
t_symbol *ps_jit_gl_cache_var;
t_symbol *ps_jit_gl_cache_vbo;
t_symbol *ps_jit_gl_cache_dl;
t_symbol *ps_jit_gl_cache_vertexarray;
t_symbol *ps_jit_gl_cache_vertexbuffer;
t_symbol *ps_jit_gl_cache_displaylist;

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

t_jit_err jit_gl_cache_init(void)
{
    // generate symbols
    ps_jit_gl_cache_none = gensym("none");
    ps_jit_gl_cache_auto = gensym("auto");
    ps_jit_gl_cache_var = gensym("var");
    ps_jit_gl_cache_vbo = gensym("vbo");
    ps_jit_gl_cache_dl = gensym("dl");
    ps_jit_gl_cache_vertexarray = gensym("vertexarray");
    ps_jit_gl_cache_vertexbuffer = gensym("vertexbuffer");
    ps_jit_gl_cache_displaylist = gensym("displaylist");
    return JIT_ERR_NONE;
}

t_jit_gl_cache * jit_gl_cache_new(long count, long coords, long datatype)
{
    long i;
    t_jit_gl_cache *x;

    if (x = (t_jit_gl_cache *)jit_getbytes(sizeof(t_jit_gl_cache)))
    {
        x->id = -1;
        x->data = NULL;
        x->used = FALSE;

        jit_gl_cache_reset(x);
        jit_gl_cache_resize(x, count, coords, datatype, FALSE);
        return x;
    }
    return NULL;
}

void jit_gl_cache_free(t_jit_gl_cache *x)
{
    if (!x)
        return ;

    jit_gl_cache_destroy(x);
}

t_jit_err jit_gl_cache_clear(t_jit_gl_cache *x)
{
    t_jit_err err = JIT_ERR_NONE;

    if (!x)
        return JIT_ERR_INVALID_PTR;

    // destroy data managed by cache
    if (x->manage && x->data && x->bytes)
        jit_freebytes(x->data, x->bytes);

    // reset attributes
    x->data = NULL;
    x->bytes = 0;
    x->capacity = 0;
    x->count = 0;
    x->manage = FALSE;
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_cache_buffer_destroy(t_jit_gl_cache *x)
{
    if (!x)
        return JIT_ERR_INVALID_PTR;

    // delete the internal state for the cache type
    switch (x->type)
    {
    case JIT_GL_MESH_CACHE_DISPLAYLIST:
        {
            // destroy the entire display list
            return jit_gl_cache_delete_dl(x);
            break;
        }
    case JIT_GL_MESH_CACHE_VERTEXBUFFER:
        {
            // destroy just the vbo for this cache
            return jit_gl_cache_delete_vbo(x);
            break;
        }
    };
    return JIT_ERR_GENERIC;
}

t_jit_err jit_gl_cache_destroy(t_jit_gl_cache *x)
{
    if (!x)
        return JIT_ERR_INVALID_PTR;

    // destroy data managed by hardware
    jit_gl_cache_buffer_destroy(x);

    // destroy data managed by cache
    jit_gl_cache_clear(x);
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_cache_reset(t_jit_gl_cache *x)
{
    t_jit_err err = JIT_ERR_NONE;

    // safety
    if (!x)
        return JIT_ERR_INVALID_PTR;

    // destroy data managed by cache
    err = jit_gl_cache_destroy(x);

    // reset attributes
    x->data = NULL;
    x->bytes = 0;
    x->manage = FALSE;
    x->type = -1;
    x->buffertype = -1;
    x->buffersize = 0;
    x->datatype = -1;
    x->datasize = 0;
    x->capacity = 0;
    x->drawcount = 0;
    x->drawsize = 0;
    x->grow = JIT_GL_MESH_CACHE_DEFAULT_GROW;
    x->enumtype = -1;
    x->geomsize = 0;
    x->elements = 0;
    x->count = 0;
    x->coords = 0;
    x->stride = 0;
    x->start = 0;
    x->end = 0;
    x->mode = GL_STATIC_DRAW_ARB;
    x->used = FALSE;
    x->update = FALSE;
    x->id = -1;
    return err;
}

t_jit_err jit_gl_cache_grow(t_jit_gl_cache *x, long bytes, long copy)
{
    long i;
    char *data = 0;

    if (x)
    {
        bytes = x->bytes + bytes;
        data = (char *)jit_getbytes(bytes);
        if (!bytes)
            return JIT_ERR_INVALID_PTR;

        // copy
        if (copy)
        {
            for (i = 0; i < x->bytes && i < bytes; i++)
                data[i] = ((char*)x->data)[i];
        }

        // destroy
        jit_gl_cache_clear(x);

        // assign
        x->bytes = bytes;
        x->data = data;
        x->manage = TRUE;
        x->used = TRUE;
        x->update = TRUE;
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_cache_resize(t_jit_gl_cache *x, long count, long coords, long datatype, long copy)
{
    long i;
    t_jit_err err = JIT_ERR_NONE;
    long bytes = 0;
    long datasize = 0;

    if (x)
    {
        datasize = jit_gl_cache_datasize_from_datatype(datatype);
        if (!datasize)
            return JIT_ERR_MISMATCH_TYPE;

        // resize
        bytes = coords * count * datasize;
        err = jit_gl_cache_grow(x, bytes, copy);
        if (err)
            return err;

        // assign
        x->count = count;
        x->coords = coords;
        x->elements = x->count * x->coords;
        x->datatype = datatype;
        x->datasize = datasize;
        x->manage = TRUE;
        x->used = TRUE;
        x->update = TRUE;
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_cache_append(t_jit_gl_cache *x, char *data, long count, long coords, long datatype)
{
    long i = 0;
    long d = 0;
    long index;
    t_jit_err err = JIT_ERR_NONE;
    long datasize = jit_gl_cache_datasize_from_datatype(datatype);

    if (x)
    {
        if (x->datasize != datasize)
            return JIT_ERR_GENERIC;

        // resize
        index = x->count;
        if (x->bytes - (x->count * x->datasize) < (datasize * count))
        {
            err = jit_gl_cache_grow(x, datasize * count * x->grow, TRUE);
            if (err)
                return err;
        }

        // copy
        switch (datatype)
        {
        case GL_UNSIGNED_BYTE:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLubyte*)x->data)[i * coords + d] = ((GLubyte*)data)[d];
                    }
                }
                break;
            }
        case GL_UNSIGNED_INT:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLuint*)x->data)[i * coords + d] = ((GLuint*)data)[d];
                    }
                }
                break;
            }
        case GL_INT:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLint*)x->data)[i * coords + d] = ((GLint*)data)[d];
                    }
                }
                break;
            }
        case GL_FLOAT:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLfloat*)x->data)[i * coords + d] = ((GLfloat*)data)[d];
                    }
                }
                break;
            }
        case GL_DOUBLE:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLdouble*)x->data)[i * coords + d] = ((GLdouble*)data)[d];
                    }
                }
                break;
            }
        default:
            err = JIT_ERR_MISMATCH_TYPE;
            break;
        }
    }
    return err;
}

t_jit_err jit_gl_cache_replace(t_jit_gl_cache *x, long index, char *data, long count, long coords, long datatype)
{
    long i, d;
    t_jit_err err = JIT_ERR_NONE;
    long datasize = jit_gl_cache_datasize_from_datatype(datatype);
    long newsize = (index * coords * count);

    if (x)
    {
        if (x->datasize != datasize)
            return JIT_ERR_GENERIC;

        // resize
        if (newsize > x->count || newsize > x->capacity)
        {
            err = jit_gl_cache_grow(x, datasize * count * coords * x->grow, TRUE);
            if (err)
                return err;
        }

        switch (datatype)
        {
        case GL_UNSIGNED_BYTE:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLubyte*)x->data)[i * coords + d] = ((GLubyte*)data)[d];
                    }
                }
                break;
            }
        case GL_UNSIGNED_INT:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLuint*)x->data)[i * coords + d] = ((GLuint*)data)[d];
                    }
                }
                break;
            }
        case GL_INT:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLint*)x->data)[i * coords + d] = ((GLint*)data)[d];
                    }
                }
                break;
            }
        case GL_FLOAT:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLfloat*)x->data)[i * coords + d] = ((GLfloat*)data)[d];
                    }
                }
                break;
            }
        case GL_DOUBLE:
            {
                for (i = index; i < index + count; i++)
                {
                    for (d = 0; d < coords; d++)
                    {
                        ((GLdouble*)x->data)[i * coords + d] = ((GLdouble*)data)[d];
                    }
                }
                break;
            }
        default:
            err = JIT_ERR_MISMATCH_TYPE;
            break;
        }
    }
    return err;
}

#define COMP(A,B,EPSILON) (((A)>((B)-EPSILON)) && ((A)<((B)+EPSILON)))

long jit_gl_cache_compare(t_jit_gl_cache *x, long a, long b, double epsilon)
{
    long i;
    long dupe = FALSE;
    GLubyte *glub, glubeps;
    GLuint *glui, gluieps;
    GLint *gli, glieps;
    GLfloat *glf, glfeps;
    GLdouble *gld, gldeps;

    if (!x || !x->data)
        return FALSE;

    switch (x->datatype)
    {
    case GL_UNSIGNED_BYTE:
        {
            glub = (GLubyte*)x->data;
            glubeps = (GLubyte)epsilon;
            for (i = 0; i < x->coords; i++)
            {
                dupe = COMP(glub[a * x->coords + i], glub[b * x->coords + i], glubeps);
                if (!dupe)
                    break;
            }
            break;
        }
    case GL_UNSIGNED_INT:
        {
            glui = (GLuint*)x->data;
            gluieps = (GLuint)epsilon;
            for (i = 0; i < x->coords; i++)
            {
                dupe = COMP(glui[a * x->coords + i], glui[b * x->coords + i], gluieps);
                if (!dupe)
                    break;
            }
            break;
        }
    case GL_INT:
        {
            gli = (GLint*)x->data;
            glieps = (GLint)epsilon;
            for (i = 0; i < x->coords; i++)
            {
                dupe = COMP(gli[a * x->coords + i], gli[b * x->coords + i], glieps);
                if (!dupe)
                    break;
            }
            break;
        }
    case GL_FLOAT:
        {
            glf = (GLfloat*)x->data;
            glfeps = (GLfloat)epsilon;
            for (i = 0; i < x->coords; i++)
            {
                dupe = COMP(glf[a * x->coords + i], glf[b * x->coords + i], glfeps);
                if (!dupe)
                    break;
            }
            break;
        }
    case GL_DOUBLE:
        {
            gld = (GLdouble*)x->data;
            gldeps = (GLdouble)epsilon;
            for (i = 0; i < x->coords; i++)
            {
                dupe = COMP(gld[a * x->coords + i], gld[b * x->coords + i], gldeps);
                if (!dupe)
                    break;
            }
            break;
        }
    default:
        dupe = FALSE;
        break;
    };

    return dupe;
}

t_jit_err jit_gl_cache_weld(t_jit_gl_cache *x, double epsilon)
{
    long i, j, k;
    long unique = 1;
    long dupe = FALSE;
    t_jit_err err = JIT_ERR_NONE;
    t_jit_gl_cache welded;
    t_jit_gl_cache index;

    GLubyte *glub, glubeps = (GLubyte)epsilon;
    GLuint *glui, gluieps = (GLuint)epsilon;
    GLfloat *glf, glfeps = (GLfloat)epsilon;
    GLdouble *gld, gldeps = (GLdouble)epsilon;

    // resize and copy into temp cache
    err = jit_gl_cache_resize(&welded, x->count, x->coords, x->datatype, TRUE);
    if (err)
        return err;

    // find unique members
    switch (x->datatype)
    {
    case GL_FLOAT:
        {
            glf = (GLfloat*)x->data;
            for (i = 0; i < x->count; i++)
            {
                for (j = 1; j <= unique; j++)
                {
                    dupe = TRUE;
                    for (k = 0; k < x->coords; k++)
                    {
                        dupe = dupe && (glf[x->coords * i + k] - glf[x->coords * j + k] < epsilon);
                    }
                    if (dupe)
                    {
                        goto glfdupe;
                    }
                }

                for (k = 0; k < x->coords; k++)
                    ((GLfloat*)welded.data)[x->coords * unique + 0] = glf[x->coords * i + 0];

                j = unique;
                unique++;

glfdupe:
                continue;
            }
            break;
        }
    }

    // resize and copy back into cache
    err = jit_gl_cache_resize(x, unique, x->coords, x->datatype, TRUE);
    if (err)
        return err;

    return JIT_ERR_NONE;
}

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


GLenum jit_gl_cache_datatype_from_symbol(t_symbol *s)
{
    if (s == _jit_sym_char)
    {
        return GL_UNSIGNED_BYTE;
    }
    else if (s == _jit_sym_long)
    {
        return GL_UNSIGNED_INT;
    }
    else if (s == _jit_sym_float32)
    {
        return GL_FLOAT;
    }
    else if (s == _jit_sym_float64)
    {
        return GL_DOUBLE;
    }
    return GL_FLOAT;
}

long jit_gl_cache_datasize_from_datatype(GLenum e)
{
    switch (e)
    {
    case GL_UNSIGNED_BYTE:
        {
            return sizeof(GLubyte);
        }
    case GL_UNSIGNED_INT:
        {
            return sizeof(GLuint);
        }
    case GL_INT:
        {
            return sizeof(GLint);
        }
    case GL_FLOAT:
        {
            return sizeof(GLfloat);
        }
    case GL_DOUBLE:
        {
            return sizeof(GLdouble);
        }
    };
    return sizeof(GLfloat);
}

Copyright © 2008, Cycling '74