/*
 * Copyright (c) 2013, NVIDIA CORPORATION.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and/or associated documentation files (the
 * "Materials"), to deal in the Materials without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Materials, and to
 * permit persons to whom the Materials are furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * unaltered in all copies or substantial portions of the Materials.
 * Any additions, deletions, or changes to the original source files
 * must be clearly indicated in accompanying documentation.
 *
 * If only executable code is distributed, then the accompanying
 * documentation must state that "this software is based in part on the
 * work of the Khronos Group."
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */

#include <GL/glx.h>
#include <GL/gl.h>
#include <stdio.h>
#include <stdlib.h>

typedef __GLXextFuncPtr (* pfn_glXGetProcAddress) (const GLubyte *procName);
static pfn_glXGetProcAddress ptr_glXGetProcAddress;

typedef void (* pfn_glXWaitGL) (void);
static pfn_glXWaitGL ptr_glXWaitGL;

typedef void (* pfn_glVertex3fv) (const GLfloat *v);
static pfn_glVertex3fv ptr_glVertex3fv;

typedef void (* pfn_glXExampleExtensionFunction) (Display *dpy, int screen, int *retval);
static pfn_glXExampleExtensionFunction ptr_glXExampleExtensionFunction;

typedef void (* pfn_glBogusFunc1) (int a, int b, int c);
static pfn_glBogusFunc1 ptr_glBogusFunc1;

typedef void (* pfn_glBogusFunc2) (int a, int b, int c);
static pfn_glBogusFunc2 ptr_glBogusFunc2;

static void *LoadFunction(const char *name);

int main(int argc, char **argv)
{
    Display *dpy = NULL;
    int retval = 0;

    /*
     * Try GetProcAddress on different classes of API functions, and bogus
     * functions. The API library should return entry point addresses for
     * any function beginning with gl*(), though bogus functions will resolve
     * to no-ops.
     */

    dpy = XOpenDisplay(NULL);
    if (dpy == NULL) {
        printf("Can't open display\n");
        return 1;
    }

    /*
     * Load the function addresses up front. Note that in order to test GLX
     * entrypoint generation, we have to load the functions early, before
     * libGLX.so loads the vendor library.
     */
    ptr_glXGetProcAddress = (pfn_glXGetProcAddress)
        LoadFunction("glXGetProcAddress");
    ptr_glXWaitGL = (pfn_glXWaitGL) LoadFunction("glXWaitGL");
    ptr_glXExampleExtensionFunction = (pfn_glXExampleExtensionFunction)
        LoadFunction("glXExampleExtensionFunction");
    ptr_glVertex3fv = (pfn_glVertex3fv) LoadFunction("glVertex3fv");
    ptr_glBogusFunc1 = (pfn_glBogusFunc1) LoadFunction("glBogusFunc1");
    ptr_glBogusFunc2 = (pfn_glBogusFunc2) LoadFunction("glBogusFunc2");

    /*
     * Test core GLX dispatch functions implemented by API library. This
     * simply returns the symbol exported by libGLX.
     */
    ptr_glXGetProcAddress((const GLubyte *) "glBogusFunc1");
    ptr_glXWaitGL();

    // Call glXGetClientString to force libGLX to load the vendor library.
    glXGetClientString(dpy, GLX_EXTENSIONS);

    /*
     * Test a "GLX extension" function with a vendor-neutral dispatcher
     * implemented by the vendor library (in this case, libGLX_dummy).  If we
     * successfully used libGLX_dummy's dispatcher, retval should be non-zero
     * (a zero value indicates we might be calling into a no-op stub generated
     * by libGLdispatch).
     */
    ptr_glXExampleExtensionFunction(dpy, 0, &retval);
    if (!retval) {
        printf("Unexpected glXExampleExtensionFunction() return value!\n");
        return 1;
    }

    /*
     * Try getting the address of the core GL function glVertex3fv().
     * This retrieves a static stub from glapi.
     * Note calling this function with a NULL pointer is fine since this is a
     * no-op function while there is no context current.
     */
    ptr_glVertex3fv(NULL);

    /*
     * These are bogus functions, but will get a valid entry point since they
     * are prefixed with "gl". The first GetProcAddress() will early out since
     * there should be a cached copy from the explicit call made above, but
     * the second one will go through glapi's dynamic stub generation path.
     *
     * Again, calling these functions should be a no-op.
     */
    ptr_glBogusFunc1(0, 0, 0);
    ptr_glBogusFunc2(1, 1, 1);

    // Success!
    return 0;
}

static void *LoadFunction(const char *name)
{
    __GLXextFuncPtr func = glXGetProcAddress((const GLubyte *) name);
    if (func == NULL) {
        printf("failed to get %s!\n", name);
        exit(1);
    }

    return (void *) func;
}