Max 5 API Reference

jit.gl.sys.c

// jit.gl.sys.c
//
//
// author: joshua kit clayton
// Copyright 2001-2005 cycling '74
//

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

#include "jit.common.h"
#include "jit.gl.h"
#include "jit.gl.procs.h"
#include "jit.gl.pixelformat.h"
#include "ext_user.h" //for patcher testing

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

static long _jit_gl_sys_inited = 0;

// utilites for win jit_gl_create_context
#ifdef WIN_VERSION

// rbs -- if we ever want to subclass the window, here is the code. 
// it turned out we didn't need this complex stuff after all. 
#ifdef USE_SUBCLASS_HACK
#include "ext_obex.h"
#include <windowsx.h>       // for GET_X_LPARAM
#endif

#include "jit.wglext.h"
#include "jit.glext.h"

#define JIT_GL_WINDCLASSNAME    "Jitter Window"

static HINSTANCE _jit_gl_hinst = NULL;
static WNDCLASS _jit_gl_wc;

void copyDIBtoMatrix(t_jit_gl_context ctx);
HWND jit_gl_create_window(HWND hwnd, t_box *rect);
LRESULT CALLBACK jit_gl_windproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
PROC SpecialWglGetProcAddress(HWND hwnd, char *str);
long WGLisExtensionSupported(const char *extension);

#endif

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

#ifdef WIN_VERSION

#endif // WIN_VERSION

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

/*
 * TODO:
 *
 * Figure out how to eliminate need to use these functions since
 * they are not available in the same way on windows.
 * need the following for vram query, make it's own function
 *
 * vram_required
 * aglSetRendererInfo
 * aglQueryRendererInfo
 * aglDescribeRenderer
 * aglNextRendererInfo
 * aglDestroyRendererInfo
 *
 * In general, we need to add more renderer querying capabilities
 *
 * For pwindow on mac, should move the following code into jit.gl.sys.c:
 *
 * aglEnable (x->agl_context, AGL_CLIP_REGION);
 * aglSetInteger (x->agl_context, AGL_CLIP_REGION, (const GLint *)rgn2);
 *
 */

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

void jit_gl_sys_init(void)
{

    if (_jit_gl_sys_inited)
        return ;

#ifdef WIN_VERSION

    _jit_gl_hinst = GetModuleHandle(NULL); //is this right?
    memset(&_jit_gl_wc, 0, sizeof(WNDCLASS));
    _jit_gl_wc.style = CS_OWNDC;
    _jit_gl_wc.lpfnWndProc = jit_gl_windproc;
    _jit_gl_wc.hInstance = _jit_gl_hinst;
    _jit_gl_wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
    _jit_gl_wc.hCursor = LoadIcon(_jit_gl_hinst, IDC_ARROW);
    _jit_gl_wc.hbrBackground = NULL;
    _jit_gl_wc.lpszMenuName = NULL;
    _jit_gl_wc.lpszClassName = JIT_GL_WINDCLASSNAME;
    if (!RegisterClass(&_jit_gl_wc))
    {
        error("jit_gl_sys_init: RegisterClass %d", GetLastError());
    }

#endif
    _jit_gl_sys_inited = 1;
}

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

GLboolean jit_gl_context_swap_buffers(t_jit_gl_context ctx)
{
#ifdef MAC_VERSION

    if (ctx && ctx->context)
    {
        aglSwapBuffers(ctx->context);
#ifdef JIT_LITTLE_ENDIAN
        // byte swap, with temporary matrix
        if (ctx->targettype == JIT_GL_TARGET_MATRIX)
        {
            t_matrix_conv_info mcinfo;
            mcinfo.flags = 0;
            mcinfo.planemap[0] = 3;
            mcinfo.planemap[1] = 2;
            mcinfo.planemap[2] = 1;
            mcinfo.planemap[3] = 0;
            jit_object_method(ctx->auxdata,_jit_sym_frommatrix,ctx->target,&mcinfo);
        }
#endif
        return TRUE;
    }
    else
        return FALSE;

#endif
#ifdef WIN_VERSION

    GLboolean rv = FALSE;

    if (ctx)
    {
        if (ctx->drawable)
            rv = SwapBuffers((HDC)ctx->drawable);

        if (rv && (ctx->targettype == JIT_GL_TARGET_MATRIX))
            copyDIBtoMatrix(ctx);
    }

    return rv;
#endif
}

GLboolean jit_gl_configure(GLenum pname, GLuint param)
{
#ifdef MAC_VERSION
    return aglConfigure(pname, param);
#endif
#ifdef WIN_VERSION
    //WORK???no windows equivalent? we use this for AGL_RETAIN_RENDERERS_FLAG
    return TRUE;
#endif
}

long jit_gl_set_swap_interval(t_jit_gl_context ctx, long interval)
{
#ifdef MAC_VERSION

    GLint val = interval;
    if(!ctx)
        return FALSE;

    return aglSetInteger(ctx->context, AGL_SWAP_INTERVAL, &val);

#endif // MAC_VERSION

#ifdef WIN_VERSION

    static PROC _set_swap_interval = NULL;
    static init = 0;

    if(!ctx)
        return FALSE;

    if (!init)
    {
        jit_gl_set_context(ctx);
        _set_swap_interval = wglGetProcAddress("wglSwapIntervalEXT");
        init = 1;
    }

    if (_set_swap_interval)
        _set_swap_interval((int)interval);

    return TRUE;

#endif // WIN_VERSION

}

#ifdef WIN_VERSION

#ifdef USE_SUBCLASS_HACK
t_hashtab *s_patcherwind_to_windowdata; 

// We want to filter out WM_MOUSELEAVE messages to patcher 
// when mouse moves over a GL window.  
// For each patcher, we can have more than one GL HWND windows though. 
// So, we put each in a list, only subclass the first time, and unsubclass when
// the last window is destroyed. 
typedef struct _windowdata
{
    HWND        w_hwndPatcher; 
    WNDPROC     w_origProc; 
    BOOL        w_ateone;           // true if we ate a WM_MOUSELEAVE message
    t_linklist  *w_glwindows;       // list of jit.pwindwow GL HWNDs inside this patcher
} t_windowdata; 

LRESULT CALLBACK jit_gl_subclassproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
#endif

HWND jit_gl_create_window(HWND hwnd, t_box *box)
{
    method meth;

#ifdef USE_SUBCLASS_HACK
    if (!s_patcherwind_to_windowdata) {
        s_patcherwind_to_windowdata = hashtab_new(0); 
    }
#endif

    if(!box)
        return NULL;

    if (meth=zgetfn((t_object *)box,gensym("nativeparentwind"))) {
        double jr[4];
        HWND hWndNew; 

        //object_attr_getdouble_array((t_object *)box, gensym("patch_rect"), 4, jr);
        object_method((t_object *)box, gensym("patch_rect"), jr);
        // rbs -- WS_DISABLED is the key to letting mouse stuff go to our parent window
        // actually, with it, our WNDPROC is almost never called as the mouse stuff
        // goes straight to our parent. 
        hWndNew = CreateWindow(
                JIT_GL_WINDCLASSNAME, 
                JIT_GL_WINDCLASSNAME, 
                WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED,
                (int)jr[0], (int)jr[1], (int)jr[2], (int)jr[3],
                //0, 0, 320, 240,
                hwnd, NULL, _jit_gl_hinst, 0
        );
#ifdef USE_SUBCLASS_HACK
        if (hWndNew) {
            t_windowdata *wd = NULL;
            hashtab_lookup(s_patcherwind_to_windowdata, (t_symbol*) hwnd, (t_object**) &wd); 
            if (!wd) {
                // init this entry
                wd = (t_windowdata*) sysmem_newptr(sizeof(t_windowdata)); 
                wd->w_hwndPatcher = hwnd; 
                wd->w_origProc = (WNDPROC) GetWindowLongPtr(hwnd, GWL_WNDPROC); 
                wd->w_glwindows = linklist_new(); 
                wd->w_ateone = FALSE; 
                SetWindowLongPtr(hwnd, GWL_WNDPROC, (LONG_PTR) jit_gl_subclassproc); 
                hashtab_store(s_patcherwind_to_windowdata, (t_symbol*) hwnd, (t_object*) wd); 
            }
            if (wd) {
                linklist_append(wd->w_glwindows, (t_object*) hWndNew); 
            }
        }
#endif
        if(!hWndNew) {
            LPSTR lpMsgBuf;
            DWORD dw = GetLastError();
            FormatMessage(  FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                            FORMAT_MESSAGE_FROM_SYSTEM |
                            FORMAT_MESSAGE_IGNORE_INSERTS,
                            NULL,
                            dw,
                            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                            (LPSTR)&lpMsgBuf,
                            0, NULL);
            error("error jit_gl_create_window failed to create window: %s", (char *)lpMsgBuf);
        }
        return hWndNew; 
    }
    else {
        error("create window: not using Max 5");
        return 0;
    }
}

#ifdef USE_SUBCLASS_HACK
LRESULT CALLBACK jit_gl_subclassproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
    // we want to trap the WM_MOUSELEAVE messages if mouse is over our window
    t_windowdata *wd = NULL; 
    WNDPROC origproc; 
    hashtab_lookup(s_patcherwind_to_windowdata, (t_symbol*)hwnd, (t_object**) &wd); 
    if (wd) {
        origproc = wd->w_origProc; // in case we free it below
        if (message == WM_PARENTNOTIFY && (LOWORD(wparam) == WM_DESTROY)) {
            // remove from list and possibly unsubclass the window
            if (wd) {
                HWND glwind = (HWND)lparam; 
                int i, num=linklist_getsize(wd->w_glwindows); 
                for (i=num-1; i >= 0; i--) {    // top down for removal purposes
                    HWND h = (HWND) linklist_getindex(wd->w_glwindows, i); 
                    if (h == glwind) {
                        linklist_chuckindex(wd->w_glwindows, i); 
                    }
                }
                if (!linklist_getsize(wd->w_glwindows)) {
                    cpost("unsubclassing\n"); 
                    SetWindowLongPtr(hwnd, GWL_WNDPROC, (LONG_PTR) wd->w_origProc); 
                    linklist_chuck(wd->w_glwindows); 
                    hashtab_chuckkey(s_patcherwind_to_windowdata, (t_symbol*) hwnd);
                }
            }
        }
        else if ((message == WM_MOUSELEAVE) || ((wd->w_ateone && (message == WM_MOUSEMOVE)))) {
            // eat this if the mouse is over one of the GL windows
            int i, num = linklist_getsize(wd->w_glwindows); 
            DWORD pos = GetMessagePos(); 
            POINT point;
            HWND hwndMouseOver;
            BOOL overaglwind = FALSE;
            point.x = GET_X_LPARAM(pos); 
            point.y = GET_Y_LPARAM(pos); 
            hwndMouseOver = WindowFromPoint(point); 
            for (i=0; i < num; i++) {
                HWND glwnd = (HWND) linklist_getindex(wd->w_glwindows, i); 
                if (hwndMouseOver == glwnd) {
                    overaglwind = TRUE; 
                    break; 
                }
            }
            if (overaglwind && (message == WM_MOUSELEAVE)) {
                wd->w_ateone = TRUE; 
                cpost("eating one\n"); 
                return 0; 
            }
            if (!overaglwind && (message == WM_MOUSEMOVE)) {
                // since we ate one before we sign back up for the leave notification
                TRACKMOUSEEVENT tme;
                tme.cbSize = sizeof(tme); 
                tme.dwFlags = TME_LEAVE; 
                tme.hwndTrack = hwnd; 
                tme.dwHoverTime = 0; 
                TrackMouseEvent(&tme); 
                wd->w_ateone = FALSE;   // eat the next one
                cpost("signed up again\n"); 
            }
            if (message == WM_MOUSELEAVE)
                cpost("not eating it\n"); 
        }
        if (wd && (message == WM_DESTROY)) {
            linklist_chuck(wd->w_glwindows); 
            hashtab_chuckkey(s_patcherwind_to_windowdata, (t_symbol*) hwnd); 
        }
        // otherwise, just pass on
        CallWindowProc(origproc, hwnd, message, wparam, lparam); 
    }
    return DefWindowProc(hwnd, message, wparam, lparam); 
}
#endif

LRESULT CALLBACK jit_gl_windproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
    HWND parent;
    WINDOWINFO pwinfo;
    RECT prect;
    RECT crect;
    short xpos, ypos;

    parent = GetParent(hwnd);

    switch (message)
    {

        case WM_LBUTTONDOWN:

        case WM_MBUTTONDOWN:
        case WM_RBUTTONDOWN:
        case WM_LBUTTONUP:
        case WM_MBUTTONUP:
        case WM_RBUTTONUP:
        case WM_MOUSEMOVE:
        {
            GetWindowInfo(parent, &pwinfo);
            prect = pwinfo.rcClient;
            GetWindowRect(hwnd, &crect);
            xpos = ((int)(short)LOWORD(lparam)) + (crect.left - prect.left);
            ypos = ((int)(short)HIWORD(lparam)) + (crect.top - prect.top);
            lparam = MAKELPARAM(xpos, ypos);
        }
        case WM_KEYDOWN:
        case WM_KEYUP:
        case WM_SYSKEYDOWN:
        case WM_SYSKEYUP:
        case WM_CHAR:
        {
            //always a child for now
            return SendMessage(parent, message, wparam, lparam);
        }
        default:
        {
            return DefWindowProc(hwnd, message, wparam, lparam);
        }
    }
}

long WGLisExtensionSupported(const char *extension)
{
    const size_t extlen = strlen(extension);
    char *supported = NULL;
    char* p = NULL;
    PROC wglGetExtString;

    // Try To Use wglGetExtensionStringARB On Current DC, If Possible
    wglGetExtString = wglGetProcAddress("wglGetExtensionsStringARB");

    if (wglGetExtString)
        supported = ((char * (__stdcall*)(HDC))wglGetExtString)(wglGetCurrentDC());

    // If That Failed, Try Standard Opengl Extensions String
    if (supported == NULL)
        supported = (char*)glGetString(GL_EXTENSIONS);

    // If That Failed Too, Must Be No Extensions Supported
    if (supported == NULL)
        return FALSE;

    // Begin Examination At Start Of String, Increment By 1 On False Match
    for (p = supported; ; p++)
    {
        // Advance p Up To The Next Possible Match
        p = strstr(p, extension);

        if (p == NULL)
            return FALSE;                       // No Match

        // Make Sure That Match Is At The Start Of The String Or That
        // The Previous Char Is A Space, Or Else We Could Accidentally
        // Match "wglFunkywglExtension" With "wglExtension"

        // Also, Make Sure That The Following Character Is Space Or NULL
        // Or Else "wglExtensionTwo" Might Match "wglExtension"
        if ((p == supported || p[ -1] == ' ') && (p[extlen] == '\0' || p[extlen] == ' '))
            return TRUE;                        // Match
    }
}

// this is super lame. with wgl, we need to create a context before we can
// query the renderer to get the renderer's entry points, which is a pain for fsaa.
PROC SpecialWglGetProcAddress(HWND hwnd, char *str)
{
    GLboolean ok = FALSE;
    long fmt = 0;
    HDC hdc = NULL;
    HGLRC ctx = NULL;
    PIXELFORMATDESCRIPTOR pfd;
    PROC p;

    if (!hwnd || !str)
        return NULL;

    //create a dummy sub window + context
    hwnd = CreateWindow(JIT_GL_WINDCLASSNAME, JIT_GL_WINDCLASSNAME, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                        0, 0, 32, 32, hwnd, NULL, _jit_gl_hinst, 0);

    if (!hwnd)
    {
        //post ("SpecialWglGetProcAddress: could not create window for new gl context!");
        return NULL;
    }

    //ShowWindow(hwnd,SW_SHOWNORMAL);
    hdc = GetDC(hwnd);

    if (!hdc)
    {
        //post ("SpecialWglGetProcAddress: no device for new gl context!");
        return NULL;
    }

    memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));

    pfd.nSize   = sizeof(PIXELFORMATDESCRIPTOR);
    pfd.nVersion    = 1;
    pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
    pfd.iPixelType  = PFD_TYPE_RGBA;
    pfd.cColorBits  = 32;
    pfd.iLayerType  = PFD_MAIN_PLANE;

    fmt = ChoosePixelFormat(hdc, &pfd);

    ok = SetPixelFormat(hdc, fmt, &pfd);

    if (!ok)
    {
        //post("SpecialWglGetProcAddress: SetPixelFormat failed - %d", GetLastError());
        goto out;
    }

    // Create GL context
    ctx = wglCreateContext(hdc);

    if (ctx == NULL)
    {
        //post("SpecialWglGetProcAddress: wglCreateContext failed - %d", GetLastError());
        goto out;
    }

    // Make the context the current context
    SelectClipRgn(hdc, NULL);

    ok = wglMakeCurrent(hdc, ctx);

    if (!ok)
    {
        //post("SpecialWglGetProcAddress: wglMakeCurrent failed - %d", GetLastError());
        goto out;
    }

    p = wglGetProcAddress(str);

out:

    if (ctx)
    {
        wglDeleteContext(ctx);
        ctx = NULL;
    }

    if (hdc)
    {
        ReleaseDC(hwnd, hdc);
    }

    if (hwnd)
        DestroyWindow(hwnd);

    //post("SpecialWglGetProcAddress: %s is %x",str,p);
    return p;
}

#endif

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

#ifdef WIN_VERSION

void copyDIBtoMatrix(t_jit_gl_context ctx)
{
    HBITMAP hbm;
    DIBSECTION dib;
    void *matrix;
    long width = 0;
    long height = 0;
    t_jit_matrix_info info;
    long i, j, src_rowstride, dst_rowstride;
    unsigned char *src_bp, *dst_bp;
    unsigned long tmp, *src, *dst;

    if ((matrix = ctx->target) && (hbm = ctx->auxdata))
    {
        if (!GetObject(hbm, sizeof(DIBSECTION), &dib))
        {
            error("copyDIBtoMatrix: GetObject %d", GetLastError());
            return ;
        }

        jit_object_method(matrix, _jit_sym_getinfo, &info);

        if (info.type != _jit_sym_char)
        {
            error("copyDIBtoMatrix: invalid matrix type");
            return ;
        }

        if (info.planecount != 4)
        {
            error("copyDIBtoMatrix: invalid matrix planecount");
            return ;
        }

        width = MIN(dib.dsBm.bmWidth, info.dim[0]);
        height = MIN(dib.dsBm.bmHeight, info.dim[1]);
        src_rowstride = dib.dsBm.bmWidthBytes;
        dst_rowstride = info.dimstride[1];
        src_bp = dib.dsBm.bmBits;
        jit_object_method(matrix, _jit_sym_getdata, &dst_bp);

        if (!src_bp || !dst_bp)
        {
            error("copyDIBtoMatrix: invalid pointer");
            return ;
        }

        for (i = 0;i < height;i++)
        {
            src = (unsigned long *)(src_bp + src_rowstride * (height - 1 - i)); //bottom to top layout
            dst = (unsigned long *)(dst_bp + dst_rowstride * i);

            for (j = 0;j < width;j++)
            {
                tmp = *src++;
                *dst++ = SWAP32(tmp);
            }
        }
    }
}

#endif //WIN_VERSION

Copyright © 2008, Cycling '74