Max 5 API Reference

jit.gl.c

// jit.gl.c
//
//
// author: randall jones
// � 2002 cycling '74


#include "jit.common.h"
#include "jit.gl.h"
#include "jit.gl.ob3d.internal.h"
#include "trackball.h"
#include "jit.half.h"
#include "jit.vecmath.h"
#include <string.h> // for strstr

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

t_symbol *ps_setup,*ps_draw,*ps_drawto,*ps_ob3d_draw,*ps_get_ob3d,*ps_ob3d_ui;
t_symbol *ps_jit_gl_render,*ps_render_ptr,*ps_get_render_ptr,*ps_draw_chunk,*ps_get_chunk;
t_symbol *ps_ignore_textures,*ps_ignore_normals,*ps_ignore_colors,*ps_ignore_edges;
t_symbol *ps_getoffset,*ps_getoffsetcount,*ps_dest_closing;
t_symbol *ps_JIT_CLASS3D_FINDER,*ps_jit_gl_shader,*ps_jit_glchunk,*ps_rebuild_geometry;
t_symbol *ps_jit_gl_texture;
t_symbol *ps_jit_gl_cubemap;
t_symbol *ps_bind_texture;
t_symbol *ps_bind;
t_symbol *ps_unbind;
t_symbol *ps_begin_capture;
t_symbol *ps_end_capture;
t_symbol *ps_capture;
t_symbol *ps_none;
t_symbol *ps_capturing;
t_symbol *ps_shared_context;

void jit_gl_mesh_init();
void jit_gl_shader_init();
void jit_gl_texture_init();
void jit_gl_pbo_init();
void jit_gl_vbo_init();
void jit_gl_slab_init();
void jit_gl_readback_init();
// --------------------------------------------------------------------------------
// utility functions

void jit_gl_init(void)
{
    if (!jit_gl_available())
    {
        post("warning: OpenGL not available.");
    }
    
#ifdef MAC_VERSION
    aglInitEntryPoints();
#endif

    g_jit_gl_current_context = 0;
    g_jit_gl_current_ob3d = 0;

    jit_gl_mesh_init();
    jit_gl_shader_init();
    jit_gl_texture_init();
    jit_gl_pbo_init();
    jit_gl_vbo_init();

    // slab init *must* be after shader and texture
    jit_gl_slab_init();     
    jit_gl_readback_init();

    ps_setup            = gensym("setup");
    ps_draw             = gensym("draw");
    ps_drawto           = gensym("drawto");
    ps_ob3d_draw        = gensym("ob3d_draw");
    ps_get_ob3d         = gensym("get_ob3d");
    ps_ob3d_ui          = gensym("ob3d_ui");
    ps_jit_gl_render    = gensym("jit_gl_render");
    ps_render_ptr       = gensym("render_ptr");
    ps_get_render_ptr   = gensym("get_render_ptr");
    ps_draw_chunk       = gensym("draw_chunk");
    ps_get_chunk        = gensym("get_chunk");
    ps_ignore_textures  = gensym("ignore_textures");
    ps_ignore_normals   = gensym("ignore_normals");
    ps_ignore_colors    = gensym("ignore_colors");
    ps_ignore_edges     = gensym("ignore_edges");
    ps_getoffset        = gensym("getoffset");
    ps_getoffsetcount   = gensym("getoffsetcount");
    ps_dest_closing     = gensym("dest_closing");
    ps_jit_gl_texture   = gensym("jit_gl_texture");
    ps_jit_gl_cubemap   = gensym("jit_gl_cubemap");
    ps_bind_texture     = gensym("bind_texture");
    ps_none             = gensym("none");
    ps_capturing        = gensym("capturing");
    ps_shared_context   = gensym("shared_context");
    
    ps_bind             = gensym("bind");
    ps_unbind           = gensym("unbind");
    ps_begin_capture    = gensym("begin_capture");
    ps_end_capture      = gensym("end_capture");
    ps_capture          = gensym("capture");
    ps_JIT_CLASS3D_FINDER = gensym(JIT_CLASS3D_FINDER);
    ps_jit_gl_shader    = gensym("jit_gl_shader");
    ps_jit_glchunk      = gensym("jit_glchunk");
    ps_rebuild_geometry = gensym("rebuild_geometry");

}

long jit_gl_available(void)
{
#ifdef MAC_VERSION
    return ((Ptr) kUnresolvedCFragSymbolAddress != (Ptr) aglChoosePixelFormat);
#endif
#ifdef WIN_VERSION
    return TRUE; 
#endif
}

// set n floats given array ptr, number, and n values. 
// conversion to double has to take place for va_arg stuff. 
// so this routine isn't fast, but it's handy for new() methods. 
void jit_gl_set_floats(float *pf, int count, ...)
{
    va_list ap;
    double f;
    int i;

    va_start(ap, count);
    for (i = 0; i < count; i++) 
    {
        f = va_arg(ap, double);
        pf[i] = f;
    }
    va_end(ap); 
}

int jit_gl_get_blend_mode(int index)
{
    int result;
    switch (index)
    {
        case 0: result = GL_ZERO; break;
        case 1: result = GL_ONE; break;
        case 2: result = GL_DST_COLOR; break;
        case 3: result = GL_SRC_COLOR; break;
        case 4: result = GL_ONE_MINUS_DST_COLOR; break;
        case 5: result = GL_ONE_MINUS_SRC_COLOR; break;
        case 6: result = GL_SRC_ALPHA; break;
        case 7: result = GL_ONE_MINUS_SRC_ALPHA; break;
        case 8: result = GL_DST_ALPHA; break;
        case 9: result = GL_ONE_MINUS_DST_ALPHA; break;
        case 10: result = GL_SRC_ALPHA_SATURATE; break;
        default: result = 0; break;
    }
    return result;
}

/**
 * Tests for OpenGL error and reports to Max window.
 *
 * @ingroup ob3dmod
 *
 * @param   prefix      prefix string
 *
 * @return  OpenGL error code
 *
 */
long jit_gl_report_error (char *prefix)
{
    GLenum err=GL_NO_ERROR;
    
    if (_jit_glerrorcheck) 
        err = glGetError();
 
    // useful place to query OpenGL state at diferent stages...leaving this texture matrix debugging code as an example
    if (_jit_glmatrixdebug)
    {
        int mode;
        
        post("BEGIN: %s",prefix);
        post("\tCONTEXT: %x",jit_gl_get_context()->context);

        glGetIntegerv(GL_MATRIX_MODE, (long *)&mode);
        
        if(mode == GL_TEXTURE)
            post("\tmode is GL_TEXTURE");
            
        glGetIntegerv(GL_TEXTURE_STACK_DEPTH, (long *)&mode);
        post("\tGL_TEXTURE_STACK_DEPTH: %d", mode);
        glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, (long *)&mode);
        post("\tGL_MODELVIEW_STACK_DEPTH: %d", mode);
        glGetIntegerv(GL_PROJECTION_STACK_DEPTH, (long *)&mode);
        post("\tGL_PROJECTION_STACK_DEPTH: %d", mode);
    }

    switch (err)
    {
        case GL_INVALID_ENUM:
            post ("%s: GL Error: Invalid enumeration", prefix);
            return err;
        case GL_INVALID_VALUE:
            post ("%s: GL Error: Invalid value", prefix);
            return err;
        case GL_INVALID_OPERATION:
            post ("%s: GL Error: Invalid operation", prefix);
            return err;
        case GL_STACK_OVERFLOW:
            post ("%s: GL Error: Stack overflow", prefix);
            return err;
        case GL_STACK_UNDERFLOW:
            post ("%s: GL Error: Stack underflow", prefix);
            return err;
        case GL_OUT_OF_MEMORY:
            post ("%s: GL Error: Out of memory", prefix);
            return err;
        case GL_NO_ERROR:
            return JIT_ERR_NONE;
    }
    
#ifdef WIN_VERSION
    {
        LPVOID msg;
        switch(err)
        {
        case ERROR_INVALID_PIXEL_FORMAT:
            error("%s : opengl error : invalid pixel format!", prefix); 
            return JIT_ERR_GENERIC;
        case ERROR_NO_SYSTEM_RESOURCES:
            error("%s : opengl error : no system resources!", prefix); 
            return JIT_ERR_GENERIC;
        case ERROR_INVALID_DATA:
            error("%s : opengl error : invalid data!", prefix); 
            return JIT_ERR_GENERIC;
        case ERROR_INVALID_WINDOW_HANDLE:
            error("%s : opengl error : invalid window handle!", prefix); 
            return JIT_ERR_GENERIC;
        case ERROR_RESOURCE_TYPE_NOT_FOUND:
            error("%s : opengl error : resource type not found!", prefix); 
            return JIT_ERR_GENERIC;
        case ERROR_SUCCESS:
            // no error
            return JIT_ERR_NONE;
        default:
            FormatMessage(
                FORMAT_MESSAGE_ALLOCATE_BUFFER |
                FORMAT_MESSAGE_FROM_SYSTEM |
                FORMAT_MESSAGE_IGNORE_INSERTS,
                NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
                (LPTSTR) &msg, 0, NULL);

            error("%s : opengl error %d : %s", prefix, err, msg); 
            LocalFree( msg );
            return JIT_ERR_GENERIC;
        }
        SetLastError(0);
    }
#endif // WIN_VERSION
     
#ifdef MAC_VERSION

    if (_jit_glerrorcheck)
        err = aglGetError();
    
    if (AGL_NO_ERROR != err) 
    {
        error("%s: opengl error : %s", prefix, aglErrorString(err));
    }
    
#endif // MAC_VERSION
        
    return (long) err;
}

/**
 * Retrieves OpenGL vendor string.
 * Equivalent to glGetString(GL_VENDOR). Assumes a valid context has been set.
 *
 * @ingroup ob3dmod
 *
 * @return  OpenGL vendor string
 *
 */
const char* jit_gl_get_vendor()
{
    return (const char*)glGetString(GL_VENDOR);
}

/**
 * Retrieves OpenGL renderer string.
 * Equivalent to glGetString(GL_RENDERER). Assumes a valid context has been set.
 *
 * @ingroup ob3dmod
 *
 * @return  OpenGL renderer string
 *
 */
const char* jit_gl_get_renderer()
{
    return (const char*)glGetString(GL_RENDERER);
}

/**
 * Retrieves OpenGL version string.
 * Equivalent to glGetString(GL_VERSION).  Assumes a valid context has been set.
 *
 * @ingroup ob3dmod
 *
 * @return  OpenGL version string
 *
 */
const char* jit_gl_get_version()
{
    return (const char*)glGetString(GL_VERSION);
}

/**
 * Retrieves OpenGL GL Utilities version string.
 * Equivalent to glGetString(GL_GLU_VERSION).  Assumes a valid context has been set.
 *
 * @ingroup ob3dmod
 *
 * @return  OpenGL GL Utilities version string
 *
 */
const char* jit_gl_get_glu_version()
{
    return (const char*)glGetString((GLenum)GLU_VERSION);
}

/**
 * Retrieves OpenGL extensions string.
 * Equivalent to glGetString(GL_EXTENSIONS).  Assumes a valid context has been set.
 *
 * @ingroup ob3dmod
 *
 * @return  OpenGL GL extensions string
 *
 */
const char* jit_gl_get_extensions()
{
    return (const char*)glGetString(GL_EXTENSIONS);
}

/**
 * Tests current OpenGL version to be greater than or equal to the version provided.
 * Assumes a valid context has been set.
 *
 * @ingroup ob3dmod
 *
 * @param   major       major version number
 * @param   minor       minor version number
 * @param   release     release version number
 *
 * @return  1 if true, 0 if false.
 *
 */
char jit_gl_is_min_version(int major, int minor, int release)
{
    int sysmajor = 0, sysminor = 0, sysrelease = 0;
    sscanf(jit_gl_get_version(),"%d.%d.%d",&sysmajor,&sysminor,&sysrelease);

     if ( sysmajor < major )
        return FALSE;

    if ( sysmajor > major )
        return TRUE;

    if ( sysminor < minor )
        return FALSE;

    if ( sysminor > minor )
        return TRUE;

    if ( sysrelease < release )
        return FALSE;

    return TRUE;
}

#define GL_IS_SEP(c) (((c)=='\n')||((c)=='\r')||((c)=='\t')||((c)==' '))

/**
 * Given a t_jit_gl_context pointer, checks to see if it suppports the provided extension.
 * Equivalent to testing for the substring within the 
 * string returned by glGetString(GL_EXTENSIONS). 
 *
 * @ingroup ob3dmod
 *
 * @param   ctx     t_jit_gl_context pointer
 * @param   ext     extension string
 *
 * @return  1 if true, 0 if false.
 *
 */
char jit_gl_is_extension_supported(t_jit_gl_context ctx, const char* ext)
{
    long i;
    long pos;
    long maxpos;
    long len;
    const char *other;

    if ( !ext || ext[0] == 0 || !ctx || !ctx->extensions)
        return FALSE;
    
    pos = 0;
    len = strlen(ctx->extensions);
    maxpos = strlen(ext) - 1;
    
    for (i=0; i<len; i++)
    {
        if ((i==0) || ((i>1) && GL_IS_SEP(ctx->extensions[i-1])))
         {
            other = &ctx->extensions[i];
            pos = 0;
            
            while ((i<len)&&(!GL_IS_SEP(ctx->extensions[i])))
            {
                if (pos <= maxpos && ctx->extensions[i] == ext[pos]) 
                    pos++;
                
                if ((pos > maxpos) && GL_IS_SEP(ctx->extensions[i+1])) 
                    return TRUE;
                i++;
            }
        }
    }
    return FALSE;
} 

long jit_gl_get_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_UNSIGNED_SHORT_8_8_APPLE:
    case GL_UNSIGNED_SHORT_8_8_REV_APPLE:
        {
            return sizeof(GLushort);
        }
    case GL_UNSIGNED_INT_8_8_8_8:
    case GL_UNSIGNED_INT_8_8_8_8_REV:
        {
            return sizeof(GLubyte); // datatype in our code assumes we have prim type here, not packed type
        }
    case GL_HALF_APPLE:
        {
            return sizeof(half);
        }
    case GL_FLOAT:
        {
            return sizeof(GLfloat);
        }
    case GL_DOUBLE:
        {
            return sizeof(GLdouble);
        }
    }
    return sizeof(GLfloat);
}

Copyright © 2008, Cycling '74