Max 5 API Reference

jit.gl.chunk.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Randall Jones - rej@2uptech.com 
 *
 * OpenGL Chunk structure used to store one gl-command's-worth of data, 
 * in a format which can be passed easily to glDrawRangeElements
 */

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

#include "jit.gl.h"
#include "jit.gl.chunk.h"
#include "jit.gl.ob3d.h"
#include "jit.gl.ob3d.internal.h"

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


/**
 * Allocates and initializes a t_jit_glchunk struct.
 *
 * @ingroup ob3dmod
 *
 * @param   prim        drawing primitive name
 * @param   planes      number of planes to allocate in vertex matrix
 * @param   vertices    number of vertices to allocate in vertex matrix 
 * @param   indices     number of indices to allocate in index matrix, if used
 *
 * @return  t_jit_glchunk pointer
 *
 */
t_jit_glchunk * jit_glchunk_new(t_symbol * prim, int planes, int vertices, int indices)
{
    t_jit_matrix_info new_info;
    int OK = true;
    t_jit_glchunk * x = (t_jit_glchunk *)jit_getbytes(sizeof(t_jit_glchunk));
    if (x)
    {
        x->m_flags = 0;
        x->m_vertex = 0;
        x->m_index = 0;
        x->m_vertex_name = _jit_sym_nothing;
        x->m_index_name = _jit_sym_nothing;
        x->prim = prim;
        x->next_chunk = NULL;
        
        jit_matrix_info_default(&new_info);
        new_info.type = _jit_sym_float32;
        new_info.dimcount = 1;
        new_info.planecount = planes;
        new_info.dim[0] = vertices;     
        if (!(x->m_vertex = jit_object_new(_jit_sym_jit_matrix, &new_info))) OK = false;
        
        if (indices)
        {
            jit_matrix_info_default(&new_info);
            new_info.type = _jit_sym_long;
            new_info.dimcount = 1;
            new_info.planecount = 1;
            new_info.dim[0] = indices;
            if (!(x->m_index = jit_object_new(_jit_sym_jit_matrix, &new_info))) OK = false;
        }
        
        if (!OK)
        {
            jit_glchunk_delete(x);
            x = 0;  
        }
    }
    return x;
}

/**
 * Allocates and initializes a t_jit_glchunk struct with 2D grid matrix.
 *
 * @ingroup ob3dmod
 *
 * @param   prim        drawing primitive name
 * @param   planes      number of planes to allocate in vertex matrix
 * @param   width       width of vertex matrix to allocate
 * @param   height      height of vertex matrix to allocate
 *
 * @return  t_jit_glchunk pointer
 *
 */
t_jit_glchunk * jit_glchunk_grid_new(t_symbol * prim, int planes, int width, int height)
{
    t_jit_matrix_info new_info;
    int OK = true;
    t_jit_glchunk * x = (t_jit_glchunk *)jit_getbytes(sizeof(t_jit_glchunk));
    if (x)
    {
        x->m_flags = 0;
        x->m_vertex = 0;
        x->m_index = 0;
        x->m_vertex_name = _jit_sym_nothing;
        x->m_index_name = _jit_sym_nothing;
        x->prim = prim;
        x->next_chunk = NULL;
        
        jit_matrix_info_default(&new_info);
        new_info.type = _jit_sym_float32;
        new_info.dimcount = 2;
        new_info.planecount = planes;
        new_info.dim[0] = width;        
        new_info.dim[1] = height;       
        if (!(x->m_vertex = jit_object_new(_jit_sym_jit_matrix, &new_info))) OK = false;
                
        if (!OK)
        {
            jit_glchunk_delete(x);
            x = 0;  
        }
    }
    return x;
}

/**
 * Disposes t_jit_glchunk struct.
 *
 * @ingroup ob3dmod
 *
 * @param   x   t_jit_glchunk pointer       
 *
 */
void jit_glchunk_delete(t_jit_glchunk * x)
{
    if (x)
    {
        if (x->m_vertex) jit_object_free(x->m_vertex);
        if (x->m_index) jit_object_free(x->m_index);
        if (x->next_chunk) 
        {
            jit_glchunk_delete((t_jit_glchunk *)x->next_chunk);
            x->next_chunk = 0;
        }
        jit_freebytes(x, sizeof(t_jit_glchunk));
    }
}

/**
 * Allocates t_jit_glchunk struct, and copies from t_jit_gl_struct provided.
 *
 * @ingroup ob3dmod
 *
 * @param   new     pointer to new t_jit_glchunk pointer        
 * @param   orig    priginal t_jit_glchunk pointer      
 *
 * @return t_jit_err error code
 */
t_jit_err jit_glchunk_copy(t_jit_glchunk ** new, t_jit_glchunk * orig)
{
    t_jit_matrix_info orig_minfo;
    t_jit_glchunk * x = (t_jit_glchunk *)jit_getbytes(sizeof(t_jit_glchunk));
    t_jit_err err = JIT_ERR_NONE;
    t_jit_glchunk * next_new = NULL;
    
    if (x)
    {
        // copy flags
        x->m_flags = orig->m_flags;
        x->prim = orig->prim;
        x->m_vertex = NULL;
        x->m_index = NULL;
        x->m_vertex_name = _jit_sym_nothing;
        x->m_index_name = _jit_sym_nothing;
        x->next_chunk = NULL;
        
        // copy vertex matrix
        if (orig->m_vertex)
        {
            jit_object_method(orig->m_vertex, _jit_sym_getinfo, &orig_minfo);
            
            if (!(x->m_vertex = jit_object_new(_jit_sym_jit_matrix, &orig_minfo)))
            { 
                err = JIT_ERR_OUT_OF_MEM; 
                goto bail;
            }       
            jit_object_method(x->m_vertex, _jit_sym_frommatrix, orig->m_vertex, NULL);      
        }       
        
        // copy connection indices matrix
        if (orig->m_index)
        {
            jit_object_method(orig->m_index, _jit_sym_getinfo, &orig_minfo);
            
            if (!(x->m_index = jit_object_new(_jit_sym_jit_matrix, &orig_minfo)))
            { 
                err = JIT_ERR_OUT_OF_MEM; 
                goto bail;
            }       
            jit_object_method(x->m_index, _jit_sym_frommatrix, orig->m_index, NULL);        
        }       
        
        // recurse
        if (orig->next_chunk)
        {
            if (err == JIT_ERR_NONE)
            {
                if (JIT_ERR_NONE == jit_glchunk_copy(&next_new, orig->next_chunk));
                x->next_chunk = next_new;
            }
        }
    }
    
bail:
    if (err != JIT_ERR_NONE)
    {
        jit_glchunk_delete(x);
        x = 0;  
    }

    *new = x;       
    return err;
}

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

Copyright © 2008, Cycling '74