Max 5 API Reference

jit.agl.c

#include "jit.common.h"
#include "jit.agl.h"

#ifdef MAC_VERSION

CFBundleRef gBundleRefOpenGL = NULL;
CFBundleRef gBundleRefAGL = NULL;

CFBundleRef OpenFrameworkRef (const unsigned char *frameworkName, OSStatus *err);

OSStatus aglInitEntryPoints (void)
{
    OSStatus err = noErr;
    const Str255 frameworkNameOGL = "\pOpenGL.framework";
    const Str255 frameworkNameAGL = "\pAGL.framework";
    
    gBundleRefOpenGL = OpenFrameworkRef((const unsigned char *)frameworkNameOGL,&err);
    gBundleRefAGL = OpenFrameworkRef((const unsigned char *)frameworkNameAGL,&err);
        
    return err;
}

CFBundleRef OpenFrameworkRef (const unsigned char *frameworkName, OSStatus *err)
{
    FSRefParam fileRefParam;
    FSRef fileRef;
    CFURLRef bundleURLOpenGL;
    CFBundleRef bundleRef=NULL;

    *err = noErr;

    setmem(&fileRefParam, sizeof(fileRefParam), 0);
    setmem(&fileRef, sizeof(fileRef), 0);

    fileRefParam.ioNamePtr  = frameworkName;
    fileRefParam.newRef = &fileRef;

    // find frameworks directory/folder
    *err = FindFolder (kSystemDomain, kFrameworksFolderType, false,
                      &fileRefParam.ioVRefNum, &fileRefParam.ioDirID);
    if (noErr != *err) {
        error("jit.gl: could not find frameworks folder for AGL");
        *err = paramErr;
        return NULL;
    }
    
    // make FSRef for folder
    *err = PBMakeFSRefSync (&fileRefParam); 
    if (noErr != *err) 
    {
        error("jit.gl: could not make FSref to frameworks folder for AGL");
        return NULL;
    }
    
    // create URL to folder
    bundleURLOpenGL = CFURLCreateFromFSRef (kCFAllocatorDefault, &fileRef);
    if (!bundleURLOpenGL) 
    {
        error("jit.gl: could not create OpenGL Framework bundle URL for AGL");
        *err = paramErr;
        return NULL;
    }
    
    // create ref to GL's bundle
    bundleRef = CFBundleCreate (kCFAllocatorDefault, bundleURLOpenGL);
    if (!bundleRef) 
    {
        error("jit.gl: could not create OpenGL Framework bundle for AGL");
        *err = paramErr;
        return NULL;
    }

    // release created bundle
    CFRelease (bundleURLOpenGL); 
    
    // if the code was successfully loaded, look for our function.
    if (!CFBundleLoadExecutable (bundleRef)) 
    {
        error("jit.gl: could not load MachO executable for AGL");
        *err = paramErr;
        return NULL;
    }
        
    return bundleRef;
}


void aglDellocEntryPoints (void)
{
    if (gBundleRefOpenGL != NULL) 
    {
        // unload the bundle's code.
        CFBundleUnloadExecutable (gBundleRefOpenGL);
        CFRelease (gBundleRefOpenGL);
        gBundleRefOpenGL = NULL;
    }
    if (gBundleRefAGL != NULL) 
    {
        // unload the bundle's code.
        CFBundleUnloadExecutable (gBundleRefAGL);
        CFRelease (gBundleRefAGL);
        gBundleRefAGL = NULL;
    }
}

void * aglGetProcAddress (char * pszProc)
{
    void *rv;
    
    rv = CFBundleGetFunctionPointerForName (gBundleRefAGL,
                CFStringCreateWithCStringNoCopy (NULL,
                     pszProc, CFStringGetSystemEncoding (), NULL));
    if (!rv) {
        rv = CFBundleGetFunctionPointerForName (gBundleRefOpenGL,
                CFStringCreateWithCStringNoCopy (NULL,
                     pszProc, CFStringGetSystemEncoding (), NULL));
    }
    if (!rv)
        error("%s: NULL (FrameworkRef=%x)",pszProc,gBundleRefOpenGL);
    return rv;
}

#endif

Copyright © 2008, Cycling '74