Max 5 API Reference

jit.gl.pbuffer.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Struct and associated methods for maintaining an OpenGL 
 * pbuffer (offscreen drawable).
 *
 */

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

#include "jit.gl.pbuffer.h"
#include "jit.gl.texture.h"
#include "jit.gl.pixelformat.h"

#ifdef MAC_VERSION
GDHandle jit_gl_context_getdevice(t_jit_gl_context ctx);
#endif

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

t_jit_err jit_gl_pbuffer_create_attributes(
    t_jit_gl_pbuffer *x, t_jit_gl_pixelformat *pixelformat, 
    GLint **attributes, GLuint *acount);

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

t_jit_gl_pbuffer *jit_gl_pbuffer_new()
{
    t_jit_gl_pbuffer *x = NULL;

    if(x = jit_getbytes(sizeof(t_jit_gl_pbuffer)))
    {
        jit_gl_pbuffer_reset(x);
    }

    return x;
}

void jit_gl_pbuffer_free(t_jit_gl_pbuffer *x)
{
    if(x)
    {
        jit_gl_pbuffer_destroy(x);
        jit_freebytes(x, sizeof(t_jit_gl_pbuffer));
    }
}

t_jit_err jit_gl_pbuffer_create(
    t_jit_gl_pbuffer *x, t_symbol *colormode, t_symbol *datatype, long mode, long width, long height, 
    long target, long internal, long mipmap, long buffer,
    long share_lists, long copy_context, t_jit_gl_pixelformat *pixelformat)
{
    t_jit_gl_native_pixelformat pfnative = NULL; 
    t_jit_gl_native_drawable device = NULL;
    t_jit_gl_native_context context = NULL;
    t_jit_gl_native_pbuffer pbuffer = NULL;
    t_jit_gl_context ctx = NULL;
    GLenum glinternal, glformat, gltype;   
    GLuint pfcount = 0;
    GLint *attributes = NULL;
    GLuint acount = 0;
    GLint pf = 0;
    GLint w = 0;
    GLint h = 0;
    t_jit_err err;

    if(!x)
        return JIT_ERR_GENERIC;      

    // destroy the existing pbuffer
    jit_gl_pbuffer_destroy(x);
    
    // get the current opengl rendering context
    ctx = jit_gl_get_context();
    if (!ctx)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to get current render context!");
        return JIT_ERR_GENERIC;
    }

    // verify system support of pbuffers
    if(!ctx->support->pbuffer)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: hardware does not support pbuffers!");
        return JIT_ERR_GENERIC;
    }
    
    if(mode == JIT_GL_PBUFFER_MODE_CTT)
    {
        err = jit_gl_texture_choose_internal_format(
                colormode, datatype, gensym("static"),
                &glinternal, &glformat, &gltype, 0);
        if(err)
        {
            jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to find suitable internal format for copy to texture!"); 
            return JIT_ERR_GENERIC;
        }
    }

    // allocate context
    x->current = (t_jit_gl_context) jit_getbytes(sizeof(t_jit_gl_context_struct));
    if (!x->current)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create current render context: out of memory!");
        return JIT_ERR_GENERIC;
    }

    // allocate
    x->previous = (t_jit_gl_context) jit_getbytes(sizeof(t_jit_gl_context_struct));
    if (!x->previous)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create copy of current render context: out of memory!");
        return JIT_ERR_GENERIC;
    }
    
    // make a local copy of current context
    *(x->previous) = *(ctx);
    *(x->current) = *(ctx);

#ifdef WIN_VERSION
{
    // default pixel format attributes
    static GLint s_jit_gl_pbuffer_default_attrib[] =
    {
        WGL_SUPPORT_OPENGL_ARB, TRUE,
        WGL_DRAW_TO_PBUFFER_ARB, TRUE,
        WGL_BIND_TO_TEXTURE_RGBA_ARB, TRUE,
        WGL_RED_BITS_ARB, 8,               
        WGL_GREEN_BITS_ARB, 8,             
        WGL_BLUE_BITS_ARB, 8,              
        WGL_ALPHA_BITS_ARB, 8,             
        WGL_DEPTH_BITS_ARB, 16,            
        WGL_DOUBLE_BUFFER_ARB, FALSE,
        0, 0               
    };

    // create a new pixel format
    if(pixelformat)
    {
        // create the native pixelformat
        pfnative = jit_gl_pixelformat_create_native(pixelformat, x->previous->drawable);
        if(!pfnative)
        {
            if(pixelformat)
                jit_gl_pixelformat_free(pixelformat);
            pixelformat = NULL;

            jit_gl_report_error("jit.gl.pbuffer: error creating native pixel format");
            jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to get a valid pixel format!");
            return JIT_ERR_GENERIC;
        }
    }
    else
    {
        // create the native pixelformat
        pfnative = jit_gl_pixelformat_create_native_from_attributes(s_jit_gl_pbuffer_default_attrib, x->previous->drawable);
        if(!pfnative)
        {
            jit_gl_report_error("jit.gl.pbuffer: error creating default pixel format");
            jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to get a valid pixel format!");
            return JIT_ERR_GENERIC;
        }
    }

    // create pbuffer attributes
    x->mode = mode;
    x->target = target;
    err = jit_gl_pbuffer_create_attributes(x, pixelformat, &attributes, &acount);
    if(err || !attributes || !acount)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create pbuffer attributes!");
        return JIT_ERR_GENERIC;
    }
    
    // create the pbuffer
    x->native = wglCreatePbufferARB(x->previous->drawable, *pfnative, width, height, attributes);
    jit_freebytes(attributes, acount * sizeof(GLint));
    attributes = NULL; acount = 0;

    // keep trying different float targets until one is found
    while(!x->native && pixelformat->pixel_float)
    {
        if(pixelformat->pixel_float_target == JIT_GL_PF_PIXEL_FLOAT_ARB)
        {
            pixelformat->pixel_float_target = JIT_GL_PF_PIXEL_FLOAT_NV;
        }
        else if(pixelformat->pixel_float_target == JIT_GL_PF_PIXEL_FLOAT_NV)
        {
            pixelformat->pixel_float_target = JIT_GL_PF_PIXEL_FLOAT_ATI;
        }
        else
        {
            pixelformat->pixel_float = 0;
            pixelformat->pixel_float_target = 0;    
            break;
        }

        // try again
        x->native = wglCreatePbufferARB(x->previous->drawable, *pfnative, width, height, attributes);
        jit_freebytes(attributes, acount * sizeof(GLint));
        attributes = NULL; acount = 0;
    }
    
    if (!x->native)
    {
        jit_gl_report_error("jit.gl.pbuffer: error creating pbuffer");
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create pbuffer!");
        return JIT_ERR_GENERIC;
    }

    // replace drawable with the pbuffer device context.
    x->current->drawable = wglGetPbufferDCARB(x->native);
    if ( !x->current->drawable )
    {
        jit_gl_report_error("jit.gl.pbuffer: error creating pbuffer device context");
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create pbuffer device context!");
        return JIT_ERR_GENERIC;
    }

    // copy or create a new gl rendering context for the pbuffer.
    if (copy_context && x->previous->context)
    {
        // use existing 
        wglCopyContext(x->previous->context, x->current->context, 0);
//      x->current->context = x->previous->context;
    }
    else
    {
        // create a new context
        x->current->context = wglCreateContext( x->current->drawable );
        if ( !x->current->context )
        {
            jit_gl_report_error("jit.gl.pbuffer: error creating pbuffer rendering context");
            jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create pbuffer rendering context!");
            return JIT_ERR_GENERIC;
        }
    }

    // share lists, texture objects, and program objects.
    if( share_lists && x->previous->context && x->current->context)
    {
        if(x->previous->context != x->current->context)
        {
            if( !wglShareLists(x->previous->context, x->current->context) )
            {
                jit_gl_report_error("jit.gl.pbuffer: error sharing existing objects");
                jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to share existing objects!");
                return JIT_ERR_GENERIC;
            }
        }
    }

    // determine the actual width and height we were able to create.
    wglQueryPbufferARB( x->native, WGL_PBUFFER_WIDTH_ARB, &w );
    wglQueryPbufferARB( x->native, WGL_PBUFFER_HEIGHT_ARB, &h );
    
    // save info
    x->width = w;
    x->height = h;
    x->type = datatype;
    x->mode = mode;
    x->target = target;
    x->internal = internal;
    x->mipmap = mipmap;
    x->buffer = buffer;
    x->buffertexid = -1;
    x->copy_context = copy_context;
    x->share_lists = share_lists;
    x->pixelformat = x->current->pixelformat = pfnative;
    x->bound = FALSE;

    // toggle the initialized flag
    x->initialized = FALSE;

    // enable the previous rendering context
    if(!jit_gl_set_context(x->previous))
    {
        jit_gl_report_error("jit.gl.pbuffer: error restoring previous context");
        return JIT_ERR_GENERIC;
    }

    // create a local texture for ctt/rtt
    //if(x->mode == JIT_GL_PBUFFER_MODE_CTT)
    {
        GLuint id;
        glGenTextures(1,&id);
        x->buffertexid = id;
        glBindTexture(x->target, id);

        switch(x->target)
        {
            case GL_TEXTURE_1D:
            {
                glTexImage1D(x->target, 0, glinternal, x->width, 0, glformat, gltype, NULL);
                break;
            }
            case GL_TEXTURE_2D:
            case GL_TEXTURE_RECTANGLE_ARB:  // same as EXT
            {
                glTexImage2D(x->target, 0, glinternal, x->width, x->height, 0, glformat, gltype, NULL);
                break;
            }
        };
    }

    return JIT_ERR_NONE;
}
#endif // WIN_VERSION

#ifdef MAC_VERSION
{
    // default attributes
    static GLint s_jit_gl_pbuffer_default_attrib[] = { AGL_RGBA, AGL_DEPTH_SIZE, 16, AGL_NONE };

    if(copy_context)
    {
        // use existing pixelformat
        pfnative = x->previous->pixelformat;
    } 
    else if(pixelformat)
    {
        GDHandle dev;
        GDHandle *pdev=NULL;
        
        // create a new native pixelformat 
        if ((share_lists)&&(dev=jit_gl_context_getdevice(x->previous)))
            pdev = &dev;
        
        pfnative = jit_gl_pixelformat_create_native(pixelformat,pdev);
    }
    else
    {
        // create a default pixelformat 
        pfnative = aglChoosePixelFormat(NULL, 0, s_jit_gl_pbuffer_default_attrib);
    }

    if(!pfnative)
    {
        jit_gl_report_error("jit.gl.pbuffer: error creating pixel format");
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to get a valid pixel format!");
        return JIT_ERR_GENERIC;
    }

    // copy context state
    if(share_lists)
    {
        // create a new clean context
        x->current->context = aglCreateContext(pfnative, x->previous->context);
        if (!x->current->context)
        {
            // attempt to fall back on said format (can probably remove this case now, but leaving in for safety's sake)
            x->current->context = aglCreateContext(x->previous->pixelformat, x->previous->context);
            if (!x->current->context) {
                jit_gl_report_error("jit.gl.pbuffer: error creating pbuffer context");
                jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create pbuffer context!");
                jit_object_error((t_object *)x,"jit.gl.pbuffer: may have more success using jitter glreadback fbo.");
                return JIT_ERR_GENERIC;
            } else {
                pfnative = x->previous->pixelformat;
                copy_context = 1;
                if((datatype!=_jit_sym_char)&&(datatype!=gensym("auto"))) {
                    jit_object_post((t_object *)x,"jit.gl.pbuffer: falling back on master context pixelformat with datatype=%s",datatype->s_name);
                    jit_object_post((t_object *)x,"jit.gl.pbuffer: may have more success using jitter glreadback fbo.");
                }
            }
        }
    }
    else
    {
        // create a new clean context
        x->current->context = aglCreateContext(pfnative, NULL);
        if (!x->current->context)
        {
            jit_gl_report_error("jit.gl.pbuffer: error creating pbuffer context");
            jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create pbuffer context!");
            return JIT_ERR_GENERIC;
        }
    }

    // create the pbuffer
    if (!aglCreatePBuffer(width, height, target, internal, mipmap, &(x->native)))
    {
        jit_gl_report_error("jit.gl.pbuffer: error creating pbuffer");
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to create pbuffer!");
        return JIT_ERR_GENERIC;
    }
    jit_gl_report_error("jit.gl.pbuffer: error after creating pbuffer");

    // save info
    x->width = width;
    x->height = height;
    x->mode = mode;
    x->type = datatype; 
    x->target = target;
    x->internal = internal;
    x->mipmap = mipmap;
    x->buffer = buffer;
    x->buffertexid = -1;
    x->copy_context = copy_context;
    x->share_lists = share_lists;
    x->pixelformat = pfnative;
    x->bound = FALSE;

    // toggle the initialized flag
    x->initialized = FALSE;

    // create a local texture for ctt/rtt
    {
        GLuint id;
        glGenTextures(1,&id);
        x->buffertexid = id;
        glBindTexture(x->target, id);

        if(x->mode == JIT_GL_PBUFFER_MODE_CTT)
        {
            switch(x->target)
            {
                case GL_TEXTURE_1D:
                {
                    glTexImage1D(x->target, 0, glinternal, x->width, 0, glformat, gltype, NULL);
                    break;
                }
                case GL_TEXTURE_2D:
                case GL_TEXTURE_RECTANGLE_ARB:  // same as EXT
                {
                    glTexImage2D(x->target, 0, glinternal, x->width, x->height, 0, glformat, gltype, NULL);
                    break;
                }
            };
        }
    }
    
    jit_gl_report_error("jit.gl.pbuffer: attaching texture");

    return JIT_ERR_NONE;
}
#endif // MAC_VERSION

}

t_jit_err jit_gl_pbuffer_bind(t_jit_gl_pbuffer *x, t_symbol *s, int argc, t_atom *argv)
{
    GLint src = -1;
    t_jit_err err;
    t_jit_gl_context ctx = NULL;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    if(!x->native || !x->current || !x->previous)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: error binding invalid pbuffer!");
        return JIT_ERR_GENERIC;
    }

    // make the pbuffers rendering context current.
    if(!jit_gl_set_context(x->current))
    {
        jit_gl_report_error("jit.gl.pbuffer: error setting pbuffer context");
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to set current pbuffer context!");
    }
    
#ifdef MAC_VERSION

    // get the active screen (0 on a single-monitor system)
    src = aglGetVirtualScreen(x->previous->context);
    err = jit_gl_report_error("jit.gl.pbuffer: error setting target context");
    if(src < 0)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to set the target context!");
        return JIT_ERR_GENERIC;
    }
    
    // set the source
    if (x->source != src) 
    {
        // set the pbuffer and source
        x->source = src;
        if (!aglSetPBuffer(x->current->context, x->native, 0, 0, x->source)) 
        {       
            // handle error
            x->source = -1; 
            jit_gl_report_error("jit.gl.pbuffer: error setting active pbuffer");
            jit_object_error((t_object *)x,"jit.gl.pbuffer: unable to activate the pbuffer!");
            return JIT_ERR_GENERIC;
        }
        jit_gl_report_error("jit.gl.pbuffer: error after setting active pbuffer");
    }

#endif // MAC_VERSION
   
    if (!x->initialized)
    {
        x->initialized = TRUE;
    }       
    
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbuffer_unbind(t_jit_gl_pbuffer *x, t_symbol *s, int argc, t_atom *argv)
{
    t_jit_err err = JIT_ERR_NONE;
    t_jit_gl_context ctx = NULL;
    
    if(!x)
        return JIT_ERR_INVALID_PTR;
    
    if(!x->native || !x->current || !x->previous)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: error unbinding invalid pbuffer!");
        return JIT_ERR_GENERIC;
    }

    if(x->mode == JIT_GL_PBUFFER_MODE_CTT)
    {
        // texture should be bound and active prior to this call
        GLuint id = x->buffertexid;
        glBindTexture(x->target, id);
        
        switch(x->target)
        {
            case GL_TEXTURE_1D:
            {
                glCopyTexSubImage1D(x->target, 0, 0, 0, 0, x->width);
                break;
            }
            case GL_TEXTURE_2D:
            case GL_TEXTURE_RECTANGLE_ARB:  // same as EXT
            {
                glCopyTexSubImage2D(x->target, 0, 0, 0, 0, 0, x->width, x->height);
                break;
            }
        };
        
        jit_gl_report_error("jit.gl.pbuffer: error updating bound texture");
    }

    // debug copy to matrix in patcher
//  jit_gl_pbuffer_readpixels(x,gensym("slurp"));

#ifdef MAC_VERSION

    // disable drawing to the pbuffer context
    if(!aglSetCurrentContext(NULL))
    {
        jit_gl_report_error("jit.gl.pbuffer: error clearing context");
        return JIT_ERR_GENERIC;
    }

#endif

    // enable the previous rendering context
    if(!jit_gl_set_context(x->previous))
    {
        jit_gl_report_error("jit.gl.pbuffer: error restoring previous context");
        return JIT_ERR_GENERIC;
    }

#ifdef MAC_VERSION
    // enable the previous render target
    if(!jit_gl_set_target(x->previous, x->previous->target, x->previous->targettype))
    {
        jit_gl_report_error("jit.gl.pbuffer: error restoring previous target");
        return JIT_ERR_GENERIC;
    }
#endif

    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbuffer_bind_texture(t_jit_gl_pbuffer *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;
    
    if(!x->native || !x->current || !x->previous)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: error binding texture for invalid pbuffer!");
        return JIT_ERR_GENERIC;
    }

    // render to the binded texture
    if (x->mode == JIT_GL_PBUFFER_MODE_RTT && !x->bound)
    {

#ifdef WIN_VERSION
        if (!wglBindTexImageARB(x->native, x->buffer))
        {
            jit_gl_report_error("jit.gl.pbuffer: error binding texture");
            return JIT_ERR_GENERIC;
        }
        jit_gl_report_error("jit.gl.pbuffer: error after binding texture");
#endif 
#ifdef MAC_VERSION

        // grab the current context in which the texture should be used, not necessarily the same as x->previous->context
        AGLContext current = aglGetCurrentContext();
        if (!aglTexImagePBuffer(current, x->native, x->buffer))
        {
            jit_gl_report_error("jit.gl.pbuffer: error binding texture");
            return JIT_ERR_GENERIC;
        }
        jit_gl_report_error("jit.gl.pbuffer: error after binding texture");
#endif
        x->bound = TRUE;
    }
    else if(x->mode == JIT_GL_PBUFFER_MODE_CTT)
    {
        GLuint id;
        id = x->buffertexid;
        glEnable(x->target);
        // glBindTexture(x->target, id);
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbuffer_unbind_texture(t_jit_gl_pbuffer *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;
    
    if(!x->native || !x->current || !x->previous)
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: error unbinding texture for invalid pbuffer!");
        return JIT_ERR_GENERIC;
    }

    // release render to texture related resources
    if (x->mode == JIT_GL_PBUFFER_MODE_RTT)
    {       
        // release the pbuffer from the render texture object
        if (x->bound)
        {
#ifdef WIN_VERSION
            if (!wglReleaseTexImageARB(x->native, x->buffer))
            {
                jit_gl_report_error("jit.gl.pbuffer: error releasing bound texture");
                return JIT_ERR_GENERIC;
            }
#endif
            x->bound = FALSE;
        }
    }
    else if(x->mode == JIT_GL_PBUFFER_MODE_CTT)
    {
//      glDisable(x->target);
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbuffer_destroy_native(t_jit_gl_native_pbuffer x, t_jit_gl_native_drawable device)
{
#ifdef WIN_VERSION

    // release the native device
    if(x && device)
        wglReleasePbufferDCARB(x, device);

    // destroy the native pbuffer
    if(x)
        wglDestroyPbufferARB(x);

#endif 

#ifdef MAC_VERSION
    if(x)
        aglDestroyPBuffer(x);
#endif

    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbuffer_destroy(t_jit_gl_pbuffer *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;

    if(/*x->mode == JIT_GL_PBUFFER_MODE_CTT &&*/ x->buffertexid > 0)
    {
        GLuint id = x->buffertexid;
        glDeleteTextures(1, &id);
        x->buffertexid = -1;
    }

#ifdef WIN_VERSION
    // destroy the native context
    if(x->current)
        jit_gl_destroy_native_context(x->current->context);

    // destroy the pbuffer
    if(x->native && x->current)
        jit_gl_pbuffer_destroy_native(x->native, x->current->drawable);
    x->native = NULL;

    // destroy the native pixelformat
    if(x->pixelformat)
        jit_gl_pixelformat_destroy_native(x->pixelformat);
    x->pixelformat = NULL;

#endif 

#ifdef MAC_VERSION

    // destroy the pbuffer
    if(x->native)
        jit_gl_pbuffer_destroy_native(x->native, NULL);
    x->native = NULL;

    // destroy the native context
    if(x->current)
        jit_gl_destroy_native_context(x->current->context);
    
    // destroy the native pixelformat
    if(!x->copy_context && x->pixelformat)
        jit_gl_pixelformat_destroy_native(x->pixelformat);
    x->pixelformat = NULL;

#endif

    // free existing previous copy
    if(x->current)
    {
        jit_freebytes(x->current, sizeof(t_jit_gl_context_struct));
        x->current = NULL;
    }

    // free existing previous copy
    if(x->previous)
    {
        jit_freebytes(x->previous, sizeof(t_jit_gl_context_struct));
        x->previous = NULL;
    }

    x->bound = FALSE;
    jit_gl_pbuffer_reset(x);
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbuffer_reset(t_jit_gl_pbuffer *x)
{
    x->initialized = FALSE;
    x->mode = JIT_GL_PBUFFER_MODE_DRAW;
    x->bound = FALSE;
    x->source = -1;
    x->type = NULL;
    x->native = NULL;       
    x->previous = NULL;
    x->current = NULL;
    x->width = 0;
    x->height = 0;
    x->target = -1;
    x->internal = -1;
    x->mipmap = FALSE;
    x->share_lists = FALSE;
    x->copy_context = FALSE;
    x->buffer = GL_FRONT;
    x->pixelformat = NULL;
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbuffer_create_attributes(
    t_jit_gl_pbuffer *x, t_jit_gl_pixelformat *pixelformat, GLint **attributes, GLuint *acount)
{
    GLint attrib[JIT_GL_PF_MAX_ATTRIBCOUNT];
    GLuint ac = 0;
    long i = 0;
    t_jit_gl_context ctx = NULL;

    if(!x || !attributes || !acount)
        return JIT_ERR_GENERIC;      

// only needed for win
#ifdef WIN_VERSION

    // get current render context
    ctx = jit_gl_get_context();
    if(!ctx) return JIT_ERR_INVALID_PTR;

    // allocate largest available pbuffer upto width + height
    attrib[ac++] = WGL_PBUFFER_LARGEST_ARB;
    attrib[ac++] = GL_TRUE;

    // setup pixel buffer attributes    
    if(x->mode == JIT_GL_PBUFFER_MODE_RTT)
    {
        if(ctx->support->pbuffer_rtt)
        {
            // choose texture target (ARB enum value same as NV, EXT)
            if (x->target == GL_TEXTURE_RECTANGLE_ARB && ctx->support->pbuffer_rtt_rect)
            {
                attrib[ac++] = WGL_TEXTURE_TARGET_ARB;
                attrib[ac++] = ctx->support->pbuffer_rtt_rect_target;
            }
            else
            {
                attrib[ac++] = WGL_TEXTURE_TARGET_ARB;
                attrib[ac++] = WGL_TEXTURE_2D_ARB;

                // choose mipmaps for non-rect targets
                if (x->mipmap)
                {
                    attrib[ac++] = WGL_MIPMAP_TEXTURE_ARB;
                    attrib[ac++] = TRUE;
                }
            }
                
            // choose special float texture format
            if (pixelformat && pixelformat->pixel_float && 
                pixelformat->pixel_float_target == JIT_GL_PF_PIXEL_FLOAT_NV && 
                ctx->support->pbuffer_float)
            {
                if(pixelformat->pixel_type == JIT_GL_PF_PIXELTYPE_R)
                {
                    attrib[ac++] = WGL_TEXTURE_FORMAT_ARB;
                    attrib[ac++] = WGL_TEXTURE_FLOAT_R_NV;
                }
                else if(pixelformat->pixel_type == JIT_GL_PF_PIXELTYPE_RG)
                {           
                    attrib[ac++] = WGL_TEXTURE_FORMAT_ARB;
                    attrib[ac++] = WGL_TEXTURE_FLOAT_RG_NV;
                }
                else if(pixelformat->pixel_type == JIT_GL_PF_PIXELTYPE_RGB)
                {           
                    attrib[ac++] = WGL_TEXTURE_FORMAT_ARB;
                    attrib[ac++] = WGL_TEXTURE_FLOAT_RGB_NV;
                }
                else if(pixelformat->pixel_type == JIT_GL_PF_PIXELTYPE_RGBA)
                {           
                    attrib[ac++] = WGL_TEXTURE_FORMAT_ARB;
                    attrib[ac++] = WGL_TEXTURE_FLOAT_RGBA_NV;
                }
            }
            else if (pixelformat)
            {
                if(pixelformat->pixel_type == JIT_GL_PF_PIXELTYPE_RGBA)
                {
                    attrib[ac++] = WGL_TEXTURE_FORMAT_ARB;
                    attrib[ac++] = WGL_TEXTURE_RGBA_ARB;
                }
                else 
                {
                    attrib[ac++] = WGL_TEXTURE_FORMAT_ARB;
                    attrib[ac++] = WGL_TEXTURE_RGB_ARB;
                }
            }        
        } 

        // choose special depth texture format
        if (pixelformat && GET_FLAG(pixelformat->flags, JIT_GL_PF_FLAG_TEXTURE_DEPTH) && 
            ctx->support->pbuffer_rtt_depth)
        {  
            if (x->target == GL_TEXTURE_RECTANGLE_ARB && ctx->support->pbuffer_rtt_rect)
            {
                attrib[ac++] = WGL_DEPTH_TEXTURE_FORMAT_NV;
                attrib[ac++] = WGL_TEXTURE_DEPTH_COMPONENT_NV;
            }
            else 
            {
                attrib[ac++] = WGL_DEPTH_TEXTURE_FORMAT_NV;
                attrib[ac++] = WGL_TEXTURE_DEPTH_COMPONENT_NV;
            }
        }

        // choose default format
        if(!pixelformat)
        {
            attrib[ac++] = WGL_TEXTURE_FORMAT_ARB;
            attrib[ac++] = WGL_TEXTURE_RGBA_ARB;
        }
    }

    // terminate
    attrib[ac++] = 0;
    attrib[ac++] = 0;

    // allocate attribute array
    *attributes = NULL;
    *attributes = jit_getbytes(ac * sizeof(GLint));
    if(!(*attributes))
    {
        jit_object_error((t_object *)x,"jit.gl.pbuffer: error creating pbuffer attributes: out of memory!");
        return JIT_ERR_INVALID_PTR;
    }

    // copy to attribute array
    *acount = ac;
    for(i = 0; i < (long)ac; i++)
        (*attributes)[i] = attrib[i];

#endif // WIN_VERSION

    return JIT_ERR_NONE;
}

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

Copyright © 2008, Cycling '74