/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2003  Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public

    License along with this library; if not, write to the Free

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

#include "SDL_QuartzVideo.h"

/*

 * GL_ARB_Multisample is supposed to be available in 10.1, according to Apple:

 *

 *   http://developer.apple.com/opengl/extensions.html#GL_ARB_multisample

 *

 *  ...but it isn't in the system headers, according to Sam:

 *

 *   http://www.libsdl.org/pipermail/sdl/2003-December/058335.html

 *

 * These are normally enums and not #defines in the system headers.

 *

 *   --ryan.

 */

#if (MAC_OS_X_VERSION_MAX_ALLOWED < 1020)

#define NSOpenGLPFASampleBuffers ((NSOpenGLPixelFormatAttribute) 55)

#define NSOpenGLPFASamples ((NSOpenGLPixelFormatAttribute) 56)

#endif

@implementation NSOpenGLContext (CGLContextAccess)

- (CGLContextObj) cglContext;

{

    return _contextAuxiliary;

}

@end

/* OpenGL helper functions (used internally) */

int QZ_SetupOpenGL (_THIS, int bpp, Uint32 flags) {

    NSOpenGLPixelFormatAttribute attr[32];

    NSOpenGLPixelFormat *fmt;

    int i = 0;

    int colorBits = bpp;

    /* if a GL library hasn't been loaded at this point, load the default. */

    if (!this->gl_config.driver_loaded) {

        if (QZ_GL_LoadLibrary(this, NULL) == -1)

            return 0;

    }

    if ( flags & SDL_FULLSCREEN ) {

        attr[i++] = NSOpenGLPFAFullScreen;

    }

    /* In windowed mode, the OpenGL pixel depth must match device pixel depth */

    else if ( colorBits != device_bpp ) {

        colorBits = device_bpp;

    }

    attr[i++] = NSOpenGLPFAColorSize;

    attr[i++] = colorBits;

    attr[i++] = NSOpenGLPFADepthSize;

    attr[i++] = this->gl_config.depth_size;

    if ( this->gl_config.double_buffer ) {

        attr[i++] = NSOpenGLPFADoubleBuffer;

    }

    if ( this->gl_config.stereo ) {

        attr[i++] = NSOpenGLPFAStereo;

    }

    if ( this->gl_config.stencil_size != 0 ) {

        attr[i++] = NSOpenGLPFAStencilSize;

        attr[i++] = this->gl_config.stencil_size;

    }

    if ( (this->gl_config.accum_red_size +

          this->gl_config.accum_green_size +

          this->gl_config.accum_blue_size +

          this->gl_config.accum_alpha_size) > 0 ) {

        attr[i++] = NSOpenGLPFAAccumSize;

        attr[i++] = this->gl_config.accum_red_size + this->gl_config.accum_green_size + this->gl_config.accum_blue_size + this->gl_config.accum_alpha_size;

    }

    if ( this->gl_config.multisamplebuffers != 0 ) {

        attr[i++] = NSOpenGLPFASampleBuffers;

        attr[i++] = this->gl_config.multisamplebuffers;

    }

    if ( this->gl_config.multisamplesamples != 0 ) {

        attr[i++] = NSOpenGLPFASamples;

        attr[i++] = this->gl_config.multisamplesamples;

        attr[i++] = NSOpenGLPFANoRecovery;

    }

    if ( this->gl_config.accelerated > 0 ) {

        attr[i++] = NSOpenGLPFAAccelerated;

    }

    attr[i++] = NSOpenGLPFAScreenMask;

    attr[i++] = CGDisplayIDToOpenGLDisplayMask (display_id);

    attr[i] = 0;

    fmt = [ [ NSOpenGLPixelFormat alloc ] initWithAttributes:attr ];

    if (fmt == nil) {

        SDL_SetError ("Failed creating OpenGL pixel format");

        return 0;

    }

    gl_context = [ [ NSOpenGLContext alloc ] initWithFormat:fmt

                                               shareContext:nil];

    [ fmt release ];

    if (gl_context == nil) {

        SDL_SetError ("Failed creating OpenGL context");

        return 0;

    }

    /* Synchronize QZ_GL_SwapBuffers() to vertical retrace.

     * (Apple's documentation is not completely clear about what this setting

     * exactly does, IMHO - for a detailed explanation see

     * http://lists.apple.com/archives/mac-opengl/2006/Jan/msg00080.html )

     */

    if ( this->gl_config.swap_control >= 0 ) {

        long value;

        value = this->gl_config.swap_control;

        [ gl_context setValues: &value forParameter: NSOpenGLCPSwapInterval ];

    }

    /*

     * Wisdom from Apple engineer in reference to UT2003's OpenGL performance:

     *  "You are blowing a couple of the internal OpenGL function caches. This

     *  appears to be happening in the VAO case.  You can tell OpenGL to up

     *  the cache size by issuing the following calls right after you create

     *  the OpenGL context.  The default cache size is 16."    --ryan.

     */

    #ifndef GLI_ARRAY_FUNC_CACHE_MAX

    #define GLI_ARRAY_FUNC_CACHE_MAX 284

    #endif

    #ifndef GLI_SUBMIT_FUNC_CACHE_MAX

    #define GLI_SUBMIT_FUNC_CACHE_MAX 280

    #endif

    {

        long cache_max = 64;

        CGLContextObj ctx = [ gl_context cglContext ];

        CGLSetParameter (ctx, GLI_SUBMIT_FUNC_CACHE_MAX, &cache_max);

        CGLSetParameter (ctx, GLI_ARRAY_FUNC_CACHE_MAX, &cache_max);

    }

    /* End Wisdom from Apple Engineer section. --ryan. */

    return 1;

}

void QZ_TearDownOpenGL (_THIS) {

    [ NSOpenGLContext clearCurrentContext ];

    [ gl_context clearDrawable ];

    [ gl_context release ];

}

/* SDL OpenGL functions */

static const char *DEFAULT_OPENGL_LIB_NAME =

    "/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib";

int    QZ_GL_LoadLibrary    (_THIS, const char *location) {

    if ( gl_context != NULL ) {

        SDL_SetError("OpenGL context already created");

        return -1;

    }

    if (opengl_library != NULL)

        SDL_UnloadObject(opengl_library);

    if (location == NULL)

        location = DEFAULT_OPENGL_LIB_NAME;

    opengl_library = SDL_LoadObject(location);

    if (opengl_library != NULL) {

        this->gl_config.driver_loaded = 1;

        return 0;

    }

    this->gl_config.driver_loaded = 0;

    return -1;

}

void*  QZ_GL_GetProcAddress (_THIS, const char *proc) {

    return SDL_LoadFunction(opengl_library, proc);

}

int    QZ_GL_GetAttribute   (_THIS, SDL_GLattr attrib, int* value) {

    GLenum attr = 0;

    QZ_GL_MakeCurrent (this);

    switch (attrib) {

        case SDL_GL_RED_SIZE: attr = GL_RED_BITS;   break;

        case SDL_GL_BLUE_SIZE: attr = GL_BLUE_BITS;  break;

        case SDL_GL_GREEN_SIZE: attr = GL_GREEN_BITS; break;

        case SDL_GL_ALPHA_SIZE: attr = GL_ALPHA_BITS; break;

        case SDL_GL_DOUBLEBUFFER: attr = GL_DOUBLEBUFFER; break;

        case SDL_GL_DEPTH_SIZE: attr = GL_DEPTH_BITS;  break;

        case SDL_GL_STENCIL_SIZE: attr = GL_STENCIL_BITS; break;

        case SDL_GL_ACCUM_RED_SIZE: attr = GL_ACCUM_RED_BITS; break;

        case SDL_GL_ACCUM_GREEN_SIZE: attr = GL_ACCUM_GREEN_BITS; break;

        case SDL_GL_ACCUM_BLUE_SIZE: attr = GL_ACCUM_BLUE_BITS; break;

        case SDL_GL_ACCUM_ALPHA_SIZE: attr = GL_ACCUM_ALPHA_BITS; break;

        case SDL_GL_STEREO: attr = GL_STEREO; break;

        case SDL_GL_MULTISAMPLEBUFFERS: attr = GL_SAMPLE_BUFFERS_ARB; break;

        case SDL_GL_MULTISAMPLESAMPLES: attr = GL_SAMPLES_ARB; break;

        case SDL_GL_BUFFER_SIZE:

        {

            GLint bits = 0;

            GLint component;

            /* there doesn't seem to be a single flag in OpenGL for this! */

            glGetIntegerv (GL_RED_BITS, &component);   bits += component;

            glGetIntegerv (GL_GREEN_BITS,&component);  bits += component;

            glGetIntegerv (GL_BLUE_BITS, &component);  bits += component;

            glGetIntegerv (GL_ALPHA_BITS, &component); bits += component;

            *value = bits;

            return 0;

        }

        case SDL_GL_ACCELERATED_VISUAL:

        {

            long val;

	    /* FIXME: How do we get this information here?

            [fmt getValues: &val forAttribute: NSOpenGLPFAAccelerated attr forVirtualScreen: 0];

	    */

	    val = (this->gl_config.accelerated != 0);;

            *value = val;

            return 0;

        }

        case SDL_GL_SWAP_CONTROL:

        {

            long val;

            [ gl_context getValues: &val forParameter: NSOpenGLCPSwapInterval ];

            *value = val;

            return 0;

        }

    }

    glGetIntegerv (attr, (GLint *)value);

    return 0;

}

int    QZ_GL_MakeCurrent    (_THIS) {

    [ gl_context makeCurrentContext ];

    return 0;

}

void   QZ_GL_SwapBuffers    (_THIS) {

    [ gl_context flushBuffer ];

}