jonvaldes/cpp_lexer.cpp

## cpp_lexer.cpp
// Parser for C(++) code, aimed at generating
// code instead of using C macros

typedef int i32;

typedef struct {
    const char *Code;
    i32 CodeLength;
    i32 CurrentLine;
} cpp_lexer;

cpp_lexer createLexer(const char *Code, i32 Length) {
    cpp_lexer Result;
    Result.Code = Code;
    Result.CodeLength = Length;
    Result.CurrentLine = 1;
    return Result;
}

#define TOKENS() TOK(TOKEN_EOF), TOK(TOKEN_ERROR), TOK(TOKEN_IDENTIFIER), TOK(TOKEN_NUMBER),                           \
                 TOK(TOKEN_OPEN_PARENS), TOK(TOKEN_CLOSE_PARENS), TOK(TOKEN_OPEN_BRACKETS), TOK(TOKEN_CLOSE_BRACKETS), \
                 TOK(TOKEN_OPEN_SQUARE_BRACKETS), TOK(TOKEN_CLOSE_SQUARE_BRACKETS),                                    \
                 TOK(TOKEN_SEMICOLON), TOK(TOKEN_COMMA), TOK(TOKEN_COLON), TOK(TOKEN_DOT),                             \
                 TOK(TOKEN_PLUS), TOK(TOKEN_MINUS), TOK(TOKEN_STAR), TOK(TOKEN_SLASH),                                 \
                 TOK(TOKEN_PLUS_EQUAL), TOK(TOKEN_MINUS_EQUAL), TOK(TOKEN_STAR_EQUAL), TOK(TOKEN_SLASH_EQUAL),         \
                 TOK(TOKEN_COMMENT), TOK(TOKEN_STRING), TOK(TOKEN_CHAR),                                               \
                 TOK(TOKEN_EQUAL), TOK(TOKEN_EQUALS),                                                                  \
                 TOK(TOKEN_LESS_THAN), TOK(TOKEN_LESS_EQUAL), TOK(TOKEN_LEFT_SHIFT),                                   \
                 TOK(TOKEN_MORE_THAN), TOK(TOKEN_MORE_EQUAL), TOK(TOKEN_RIGHT_SHIFT),                                  \
                 TOK(TOKEN_DEC),                                                                                       \
                 TOK(TOKEN_INC),                                                                                       \
                 TOK(TOKEN_ARROW),                                                                                     \
                 TOK(TOKEN_NOT_EQUAL),                                                                                 \
                 TOK(TOKEN_BIN_AND), TOK(TOKEN_BIN_OR), TOK(TOKEN_BIN_XOR), TOK(TOKEN_BIN_NOT),                        \
                 TOK(TOKEN_LOGIC_AND), TOK(TOKEN_LOGIC_OR), TOK(TOKEN_LOGIC_XOR), TOK(TOKEN_LOGIC_NOT),                \
                 TOK(TOKEN_AND_EQUALS), TOK(TOKEN_OR_EQUALS), TOK(TOKEN_XOR_EQUALS),                                   \
                 TOK(TOKEN_DIRECTIVE)

// ----------------

#define TOK(x) x
#define Assert(x)       \
    if(!(x)) {          \
        __debugbreak(); \
    }

typedef enum {
    TOKENS(),
    TOKENS_CNT
} token_type;

#undef TOK
#define TOK(x) #x
const char *TokenNames[] = {
    TOKENS(),
};
#undef TOK

typedef struct {
    token_type Type;
    const char *Text;
    i32 Length;
} token;

void ignoreSpaceCharacters(cpp_lexer *Lexer) {
    for(;;) {
        if(Lexer->CodeLength == 0) {
            break;
        }
        char c = *Lexer->Code;
        if(!((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n'))) {
            break;
        }
        Lexer->Code++;
        Lexer->CodeLength--;
        if(c == '\n') {
            Lexer->CurrentLine++;
        }
    }
}

bool getNextChar(cpp_lexer *Lexer, char *C) {
    if(Lexer->CodeLength == 0) {
        return false;
    }
    Lexer->CodeLength--;
    *C = *Lexer->Code++;
    if(*C == '\n') {
        Lexer->CurrentLine++;
    }
    return true;
}

void unreadChar(cpp_lexer *Lexer) {
    Lexer->Code--;
    Lexer->CodeLength++;
    if(*Lexer->Code == '\n') {
        Lexer->CurrentLine--;
    }
}

bool isNumeric(char C) { return (C >= '0' && C <= '9'); }

bool isAlphaNumeric(char C) {
    return (C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z') || (C == '_') || (C >= '0' && C <= '9');
}

token getNextToken(cpp_lexer *Lexer) {
    ignoreSpaceCharacters(Lexer);

    token Result;
    Result.Text = Lexer->Code;
    Result.Length = 1;

    char StartC;
    if(!getNextChar(Lexer, &StartC)) {
        Result.Type = TOKEN_EOF;
        Result.Length = 0;
        return Result;
    }

#define ONE_CHAR_TOKEN(c, toktype) \
    case c:                        \
        Result.Type = toktype;     \
        return Result

#define INIT_MULTICHAR_TOK(onechartok)     \
    do {                                   \
        Result.Type = onechartok;          \
        if(!getNextChar(Lexer, &StartC)) { \
            Result.Type = TOKEN_ERROR;     \
            return Result;                 \
        }                                  \
    } while(0, 0)

#define END_MULTICHAR_TOK() \
    unreadChar(Lexer);      \
    return Result

#define CHECK_ADDED_CHAR(chr, toktype) \
    do {                               \
        if(StartC == chr) {            \
            Result.Type = toktype;     \
            Result.Length++;           \
            return Result;             \
        }                              \
    } while(0, 0)

#define ERRTOK()               \
    Result.Type = TOKEN_ERROR; \
    return Result

    switch(StartC) {
        ONE_CHAR_TOKEN('(', TOKEN_OPEN_PARENS);
        ONE_CHAR_TOKEN(')', TOKEN_CLOSE_PARENS);
        ONE_CHAR_TOKEN('{', TOKEN_OPEN_BRACKETS);
        ONE_CHAR_TOKEN('}', TOKEN_CLOSE_BRACKETS);
        ONE_CHAR_TOKEN('[', TOKEN_OPEN_SQUARE_BRACKETS);
        ONE_CHAR_TOKEN(']', TOKEN_CLOSE_SQUARE_BRACKETS);
        ONE_CHAR_TOKEN(';', TOKEN_SEMICOLON);
        ONE_CHAR_TOKEN(',', TOKEN_COMMA);
        ONE_CHAR_TOKEN('.', TOKEN_DOT);
        ONE_CHAR_TOKEN(':', TOKEN_COLON);
        ONE_CHAR_TOKEN('~', TOKEN_BIN_NOT);

    case '+': {
        INIT_MULTICHAR_TOK(TOKEN_PLUS);
        CHECK_ADDED_CHAR('=', TOKEN_PLUS_EQUAL);
        CHECK_ADDED_CHAR('+', TOKEN_INC);
        END_MULTICHAR_TOK();
    }
    case '!': {
        INIT_MULTICHAR_TOK(TOKEN_LOGIC_NOT);
        CHECK_ADDED_CHAR('=', TOKEN_NOT_EQUAL);
        END_MULTICHAR_TOK();
    }
    case '-': {
        INIT_MULTICHAR_TOK(TOKEN_MINUS);
        CHECK_ADDED_CHAR('=', TOKEN_MINUS_EQUAL);
        CHECK_ADDED_CHAR('-', TOKEN_DEC);
        CHECK_ADDED_CHAR('>', TOKEN_ARROW);
        END_MULTICHAR_TOK();
    }
    case '*': {
        INIT_MULTICHAR_TOK(TOKEN_STAR);
        CHECK_ADDED_CHAR('=', TOKEN_STAR_EQUAL);
        END_MULTICHAR_TOK();
    }
    case '&': {
        INIT_MULTICHAR_TOK(TOKEN_BIN_AND);
        CHECK_ADDED_CHAR('&', TOKEN_LOGIC_AND);
        CHECK_ADDED_CHAR('=', TOKEN_AND_EQUALS);
        END_MULTICHAR_TOK();
    }
    case '|': {
        INIT_MULTICHAR_TOK(TOKEN_BIN_OR);
        CHECK_ADDED_CHAR('|', TOKEN_LOGIC_OR);
        CHECK_ADDED_CHAR('=', TOKEN_OR_EQUALS);
        END_MULTICHAR_TOK();
    }
    case '^': {
        INIT_MULTICHAR_TOK(TOKEN_BIN_XOR);
        CHECK_ADDED_CHAR('=', TOKEN_XOR_EQUALS);
        END_MULTICHAR_TOK();
    }
    case '<': {
        INIT_MULTICHAR_TOK(TOKEN_LESS_THAN);
        CHECK_ADDED_CHAR('<', TOKEN_LEFT_SHIFT);
        CHECK_ADDED_CHAR('=', TOKEN_LESS_EQUAL);
        END_MULTICHAR_TOK();
    }
    case '>': {
        INIT_MULTICHAR_TOK(TOKEN_MORE_THAN);
        CHECK_ADDED_CHAR('>', TOKEN_RIGHT_SHIFT);
        CHECK_ADDED_CHAR('=', TOKEN_MORE_EQUAL);
        END_MULTICHAR_TOK();
    }
    case '=': {
        INIT_MULTICHAR_TOK(TOKEN_EQUAL);
        CHECK_ADDED_CHAR('=', TOKEN_EQUALS);
        END_MULTICHAR_TOK();
    }
    case '\'': {
        Result.Type = TOKEN_CHAR;
        Result.Text++;
        if(!getNextChar(Lexer, &StartC)) {
            ERRTOK();
        }
        char NextC;
        if(!getNextChar(Lexer, &NextC)) {
            ERRTOK();
        }
        if(StartC == '\\') {
            if(!getNextChar(Lexer, &NextC) || NextC != '\'') {
                ERRTOK();
            }
            Result.Length = 2;
            return Result;
        }
        if(NextC != '\'') {
            ERRTOK();
        }
        return Result;
    }
    case '"': {
        Result.Type = TOKEN_STRING;
        char C = StartC;
        Result.Length = -1;
        Result.Text = Lexer->Code;
        do {
            Result.Length++;
            StartC = C;
            if(!getNextChar(Lexer, &C)) {
                ERRTOK();
            }
            // NOTE: This doesn't handle multiline strings properly
        } while(C != '"' || StartC == '\\');

        return Result;
    }

    case '#': {
        Result.Text = Lexer->Code;
        Result.Length = 0;
        Result.Type = TOKEN_DIRECTIVE;
        while(getNextChar(Lexer, &StartC) && StartC != '\r' && StartC != '\n') {
            Result.Length++;
        }
        return Result;
    }

    case '/': {
        char NextChar;
        if(!getNextChar(Lexer, &NextChar)) {
            Result.Type = TOKEN_SLASH;
            return Result;
        }
        if(NextChar == '=') { // a /= 2;
            Result.Length = 2;
            Result.Type = TOKEN_SLASH_EQUAL;
            return Result;
        }
        if(NextChar == '/') { // C++-style comment
            Result.Text = Lexer->Code;
            Result.Length = 0;
            Result.Type = TOKEN_COMMENT;
            while(getNextChar(Lexer, &NextChar) && NextChar != '\r' && NextChar != '\n') {
                Result.Length++;
            }
            return Result;
        }
        if(NextChar == '*') { // C-style comment
            Result.Type = TOKEN_COMMENT;
            Result.Text = Lexer->Code;
            Result.Length = 0;
            if(!getNextChar(Lexer, &StartC)) {
                ERRTOK();
            }
            for(;;) {
                if(!getNextChar(Lexer, &NextChar)) {
                    ERRTOK();
                }
                if(NextChar == '/' && StartC == '*') {
                    return Result;
                }
                Result.Length++;
                StartC = NextChar;
            }
        }

        // Roll back one char, it was just a slash
        unreadChar(Lexer);
        Result.Type = TOKEN_SLASH;
        return Result;
    }
    default: {
        if(isNumeric(StartC)) {
            Result.Type = TOKEN_NUMBER;

            while(Lexer->CodeLength > 0 && isNumeric(*Lexer->Code)) {
                Result.Length++;
                Lexer->Code++;
                Lexer->CodeLength--;
            }

            return Result;
        } else {
            Result.Type = TOKEN_IDENTIFIER;

            while(Lexer->CodeLength > 0 && isAlphaNumeric(*Lexer->Code)) {
                Result.Length++;
                Lexer->Code++;
                Lexer->CodeLength--;
            }

            return Result;
        }
    }
#undef ONE_CHAR_TOKEN
    }
}

// Returns next token, skipping over comments
token getNextSignficantToken(cpp_lexer *Lexer) {
    token T;
    do {
        T = getNextToken(Lexer);
    } while(T.Type == TOKEN_COMMENT);

    return T;
}

i32 StrLen(const char *Str) {
    i32 Result = 0;
    while(*Str++) {
        Result++;
    }
    return Result;
}

bool findIdentifier(cpp_lexer *Lexer, const char *Name, token *Token) {
    i32 NameLen = StrLen(Name);
    for(;;) {
        token T = getNextToken(Lexer);
        if(T.Type == TOKEN_EOF) {
            return false;
        }
        if(T.Type == TOKEN_IDENTIFIER && T.Length == NameLen) {
            bool AreEqual = true;
            for(int i = 0; i < NameLen; i++) {
                if(Name[i] != T.Text[i]) {
                    AreEqual = false;
                    break;
                }
            }
            if(AreEqual) {
                *Token = T;
                return true;
            }
        }
    }
}

## gl_metaprogrammer.cpp
#include "cpp_lexer.cpp"
#include <stdio.h>
#include <stdlib.h>

typedef unsigned char u8;

char *readFile(const char *Filename, i32 *FileSize) {
    FILE *fd = fopen(Filename, "r");
    if(!fd) {
        return NULL;
    }
    fseek(fd, 0, SEEK_END);
    int fileSize = ftell(fd);
    fseek(fd, 0, SEEK_SET);
    char *Data = (char *)malloc(fileSize);
    *FileSize = fread(Data, 1, fileSize, fd);
    fclose(fd);
    return Data;
}

void printLexerErr(cpp_lexer *Lexer) {
    printf("ERROR in line %d --", Lexer->CurrentLine);
}

void AssertNextToken(cpp_lexer *Lexer, token_type Type) {
    token Token = getNextToken(Lexer);
    if(Token.Type == TOKEN_EOF) {
        printLexerErr(Lexer);
        printf("Reached end of file while expecting a token of type %s\n", TokenNames[Type]);
        exit(1);
    }
    if(Token.Type != Type) {
        printLexerErr(Lexer);
        printf("Expected token of type %s, but got %s instead\n", TokenNames[Type], TokenNames[Token.Type]);
        exit(1);
    }
}

void AssertToken(token Token, token_type Type) {
    if(Token.Type != Type) {
        printf("Expected token of type %s, but got %s instead\n", TokenNames[Type], TokenNames[Token.Type]);
        exit(1);
    }
}

token getToken(cpp_lexer *Lexer) {
    token Token = getNextToken(Lexer);
    if(Token.Type == TOKEN_EOF) {
        printLexerErr(Lexer);
        printf("Unexpected end of file\n");
        exit(1);
    }
    return Token;
}

#define MAX_TOKENS 50

typedef struct {
    token Tokens[MAX_TOKENS];
    i32 TokenCnt;
} argument;

bool readMacroArguments(cpp_lexer *Lexer, i32 MaxArguments, argument *Arguments, int *ReadArguments) {
    for(int Arg = 0; Arg < MaxArguments; Arg++) {
        Arguments[Arg].TokenCnt = 0;
        for(int i = 0; i < MAX_TOKENS; i++) {
            token Token = getToken(Lexer);
            if(Token.Type == TOKEN_COMMA) {
                break;
            }

            if(Token.Type == TOKEN_CLOSE_PARENS) {
                *ReadArguments = Arg + 1;
                return true;
            }
            int TokenCnt = Arguments[Arg].TokenCnt;
            Arguments[Arg].Tokens[TokenCnt] = Token;
            Arguments[Arg].TokenCnt++;
        }
    }
    return false;
}

bool argumentIs(argument *Arg, const char *Text) {
    // Note: this doesn't support arguments with several tokens yet
    if(Arg->TokenCnt != 1) {
        return false;
    }
    if(StrLen(Text) != Arg->Tokens[0].Length) {
        return false;
    }
    for(int i = 0; i < Arg->Tokens[0].Length; i++) {
        if(Arg->Tokens[0].Text[i] != Text[i]) {
            return false;
        }
    }
    return true;
}

void printTokenContents(FILE *fd, token Tok) {
    for(int i = 0; i < Tok.Length; i++) {
        fprintf(fd, "%c", Tok.Text[i]);
    }
}
void printArgument(FILE *fd, argument *Arg) {
    for(int i = 0; i < Arg->TokenCnt; i++) {
        if(i != 0) {
            fprintf(fd, " ");
        }
        printTokenContents(fd, Arg->Tokens[i]);
    }
}

void print(FILE *fd, const char *S) {
    fprintf(fd, "%s", S);
}

void print(FILE *fd, argument *Arg) {
    printArgument(fd, Arg);
}

void print(FILE *fd, char c) {
    fprintf(fd, "%c", c);
}

template <typename T, typename... params>
void print(FILE *fd, T Arg1, params... ArgsN) {
    print(fd, Arg1);
    print(fd, ArgsN...);
}

// ---------------------------------------------------------------------------
//                   Actual metaprogramming functions
// ---------------------------------------------------------------------------

void generateGLFunctionWrappers() {

    // Generate function wrappers in glFuncs.cpp
    i32 FileSize;
    char *FileData = readFile("../src/glFuncs.cpp", &FileSize);
    if(!FileData) {
        printf("ERROR -- Could not open input file\n");
        exit(1);
    }

    FILE *fd = fopen("../src/generated/glFuncsImpl.cpp", "w");
    if(!fd) {
        printf("ERROR -- Could not open output file for writing\n");
        exit(1);
    }

    cpp_lexer Lexer = createLexer(FileData, FileSize);
    token Token;

    while(findIdentifier(&Lexer, "GLFUNC", &Token)) {
        AssertNextToken(&Lexer, TOKEN_OPEN_PARENS);

        argument Args[20];
        i32 ArgsCnt;
        if(!readMacroArguments(&Lexer, 20, Args, &ArgsCnt)) {
            printLexerErr(&Lexer);
            printf("GLFUNC macro has too many arguments, or EOF found in the middle of one\n");
            exit(1);
        }
        argument *ReturnType = &Args[1];
        argument *FunctionName = &Args[0];
        argument *FunctionArgs = &Args[2];
        i32 FunctionArgsCnt = ArgsCnt - 2;

        print(fd, "// ------ ", FunctionName, " ------\n");

        // Print function type typedef
        print(fd, "typedef ", ReturnType, " __stdcall ", FunctionName, "Func(");
        for(int i = 0; i < FunctionArgsCnt; i++) {
            print(fd, i == 0 ? "" : ", ", &FunctionArgs[i]);
        }
        print(fd, ");\n");
        // Print GL function pointer
        print(fd, FunctionName, "Func * _", FunctionName, ";\n\n");

        // Print wrapper function
        print(fd, ReturnType, " ", FunctionName, "(");
        for(int i = 0; i < FunctionArgsCnt; i++) {
            print(fd, i == 0 ? "" : ", ", &FunctionArgs[i], " arg", char('0' + i));
        }
        print(fd, "){\n\t");
        if(!argumentIs(ReturnType, "void")) {
            print(fd, ReturnType, " Result = ");
        }
        print(fd, "_", FunctionName, "(");
        for(int i = 0; i < FunctionArgsCnt; i++) {
            print(fd, i == 0 ? "" : ", ", "arg", char('0' + i));
        }
        print(fd, ");\n");
        if(!(
               // glGetError must not call itself!
               argumentIs(FunctionName, "glGetError") ||
               // Can't call glGetError inside a glBegin/glEnd block
               argumentIs(FunctionName, "glBegin") ||
               argumentIs(FunctionName, "glVertex2f") ||
               argumentIs(FunctionName, "glTexCoord2f") ||
               // wglCreateContextAttribsARB gives GL_INVALID_OPERATION until context is made current
               argumentIs(FunctionName, "wglCreateContextAttribsARB"))) {
            print(fd, "\tGLERR();\n");
        }

        if(!argumentIs(ReturnType, "void")) {
            print(fd, "\treturn Result;\n");
        }
        print(fd, "}\n\n");
    }
    fclose(fd);
    free(FileData);
}

int main() {
    generateGLFunctionWrappers();
}

## glFuncs.cpp
typedef u32 GLenum;
typedef u32 GLuint;
typedef i32 GLint;
typedef i32 GLsizei;
typedef void GLvoid;
typedef f32 GLfloat;
typedef f32 GLclampf;
typedef u32 GLbitfield;
typedef char GLchar;
typedef ptrdiff_t GLsizeiptr;
typedef u8 GLboolean;
typedef u8 GLubyte;

extern "C" {
#ifdef _WIN32
typedef PROC WINAPI wglGetProcAddressFunc(LPCSTR);
wglGetProcAddressFunc *_wglGetProcAddress;

typedef HGLRC WINAPI wglCreateContextFunc(HDC hdc);
wglCreateContextFunc *_wglCreateContext;

typedef BOOL WINAPI wglDeleteContextFunc(HGLRC hglrc);
wglDeleteContextFunc *_wglDeleteContext;

typedef BOOL WINAPI wglMakeCurrentFunc(HDC hdc, HGLRC hglrc);
wglMakeCurrentFunc *_wglMakeCurrent;

typedef BOOL WINAPI wglSwapLayerBuffersFunc(HDC hdc, UINT fuPlanes);
wglSwapLayerBuffersFunc *_wglSwapLayerBuffers;
}
global_var HMODULE g_OpenglLib;

#endif

// ---------------------------------------------------------------------------
#define GLFUNCS_LIST                                                                                          \
    GLFUNC(glGenTextures, void, GLsizei, GLuint *)                                                            \
    GLFUNC(glBindTexture, void, GLenum, GLuint)                                                               \
    GLFUNC(glTexImage2D, void, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) \
    GLFUNC(glTexParameteri, void, GLenum, GLenum, GLint)                                                      \
    GLFUNC(glGetError, GLenum)                                                                                \
    GLFUNC(glEnable, void, GLenum)                                                                            \
    GLFUNC(glDisable, void, GLenum)                                                                           \
    GLFUNC(glBegin, void, GLenum)                                                                             \
    GLFUNC(glEnd, void)                                                                                       \
    GLFUNC(glTexCoord2f, void, GLfloat, GLfloat)                                                              \
    GLFUNC(glVertex2f, void, GLfloat, GLfloat)                                                                \
    GLFUNC(glEnableClientState, void, GLenum)                                                                 \
    GLFUNC(glDisableClientState, void, GLenum)                                                                \
    GLFUNC(glVertexPointer, void, GLint, GLenum, GLsizei, const GLvoid *)                                     \
    GLFUNC(glTexCoordPointer, void, GLint, GLenum, GLsizei, const GLvoid *)                                   \
    GLFUNC(glColorPointer, void, GLint, GLenum, GLsizei, const GLvoid *)                                      \
    GLFUNC(glDrawArrays, void, GLenum, GLint, GLsizei)                                                        \
    GLFUNC(glClearColor, void, GLclampf, GLclampf, GLclampf, GLclampf)                                        \
    GLFUNC(glClear, void, GLbitfield)                                                                         \
    GLFUNC(glLinkProgram, void, GLuint)                                                                       \
    GLFUNC(glShaderSource, void, GLuint, GLsizei, const GLchar *const *, const GLint *)                       \
    GLFUNC(glUseProgram, void, GLuint)                                                                        \
    GLFUNC(glCompileShader, void, GLuint)                                                                     \
    GLFUNC(glCreateProgram, GLuint)                                                                           \
    GLFUNC(glCreateShader, GLuint, GLenum)                                                                    \
    GLFUNC(glGetShaderiv, void, GLuint, GLenum, GLint *)                                                      \
    GLFUNC(glGetShaderInfoLog, void, GLuint, GLsizei, GLsizei *, GLchar *)                                    \
    GLFUNC(glAttachShader, void, GLuint, GLuint)                                                              \
    GLFUNC(glGetProgramiv, void, GLuint, GLenum, GLint *)                                                     \
    GLFUNC(glGetProgramInfoLog, void, GLuint, GLsizei, GLsizei *, GLchar *)                                   \
    GLFUNC(glGetUniformLocation, GLint, GLuint, const GLchar *)                                               \
    GLFUNC(glUniform1i, void, GLint, GLint)                                                                   \
    GLFUNC(glGenBuffers, void, GLsizei, GLuint *)                                                             \
    GLFUNC(glBindBuffer, void, GLenum, GLuint)                                                                \
    GLFUNC(glBufferData, void, GLenum, GLsizeiptr, const void *, GLenum)                                      \
    GLFUNC(glVertexAttribPointer, void, GLuint, GLint, GLenum, GLboolean, GLsizei, const void *)              \
    GLFUNC(glEnableVertexAttribArray, void, GLuint)                                                           \
    GLFUNC(glUniformMatrix4fv, void, GLint, GLsizei, GLboolean, const GLfloat *)                              \
    GLFUNC(glDrawElements, void, GLenum, GLsizei, GLenum, const void *)                                       \
    GLFUNC(glDisableVertexAttribArray, void, GLuint)                                                          \
    GLFUNC(glGenFramebuffers, void, GLsizei, GLuint *)                                                        \
    GLFUNC(glBindFramebuffer, void, GLenum, GLuint)                                                           \
    GLFUNC(glFramebufferTexture2D, void, GLenum, GLenum, GLenum, GLuint, GLint)                               \
    GLFUNC(glCheckFramebufferStatus, GLenum, GLenum)                                                          \
    GLFUNC(glDeleteFramebuffers, void, GLsizei, const GLuint *)                                               \
    GLFUNC(glDeleteTextures, void, GLsizei, const GLuint *)                                                   \
    GLFUNC(glDrawBuffer, void, GLenum)                                                                        \
    GLFUNC(glBlendFunc, void, GLenum, GLenum)                                                                 \
    GLFUNC(glScissor, void, GLint, GLint, GLsizei, GLsizei)                                                   \
    GLFUNC(glViewport, void, GLint, GLint, GLsizei, GLsizei)                                                  \
    GLFUNC(glGetString, const GLubyte *, GLenum)                                                              \
    GLFUNC(glPolygonMode, void, GLenum, GLenum)                                                               \
    GLFUNC(wglChoosePixelFormatARB, BOOL, HDC, const int *, const FLOAT *, UINT, int *, UINT *)               \
    GLFUNC(wglCreateContextAttribsARB, HGLRC, HDC, HGLRC, const int *)                                        \
    GLFUNC(wglSwapIntervalEXT, BOOL, i32)

#define GLERR() checkGLErrFunc(__FILE__, __LINE__)

void checkGLErrFunc(const char *filename, int line);

#include "generated/glFuncsImpl.cpp"

// ---------------------------------------------------------------------------

void loadOpenGL() {
    g_OpenglLib = LoadLibrary("opengl32.dll");
    Assert(g_OpenglLib);

#define GET_WGLFUNC(name)                                       \
    _##name = (name##Func *)GetProcAddress(g_OpenglLib, #name); \
    Assert(_##name &&#name);

    GET_WGLFUNC(wglGetProcAddress);
    GET_WGLFUNC(wglCreateContext);
    GET_WGLFUNC(wglDeleteContext);
    GET_WGLFUNC(wglMakeCurrent);
    GET_WGLFUNC(wglSwapLayerBuffers);
#undef GET_WGLFUNC
}

void initGLFuncs() {
#ifdef _WIN32
#undef GLFUNC
#define GLFUNC(name, ...)                                               \
    do {                                                                \
        _##name = (name##Func *)_wglGetProcAddress(#name);              \
        if(!_##name) {                                                  \
            _##name = (name##Func *)GetProcAddress(g_OpenglLib, #name); \
        }                                                               \
        Assert(_##name);                                                \
    } while(0, 0);

#else
#error Dynamic library loading not implemented in this OS yet
#endif

    GLFUNCS_LIST

#undef GLFUNC
}

// ---------------------------------------------------------------------------
#define GL_INVALID_ENUM 0x0500
#define GL_TEXTURE_2D 0x0DE1
#define GL_RGBA 0x1908
#define GL_UNSIGNED_BYTE 0x1401
#define GL_TEXTURE_MAG_FILTER 0x2800
#define GL_TEXTURE_MIN_FILTER 0x2801
#define GL_NEAREST 0x2600
#define GL_LINEAR 0x2601
#define GL_TEXTURE_WRAP_S 0x2802
#define GL_TEXTURE_WRAP_T 0x2803
#define GL_CLAMP_TO_EDGE 0x812F
#define GL_DEPTH_TEST 0x0B71
#define GL_QUADS 0x0007
#define GL_TRIANGLES 0x0004
#define GL_VERTEX_ARRAY 0x8074
#define GL_TEXTURE_COORD_ARRAY 0x8078
#define GL_COLOR_ARRAY 0x8076
#define GL_FLOAT 0x1406
#define GL_SCISSOR_TEST 0x0C11
#define GL_COLOR_BUFFER_BIT 0x00004000
#define GL_DEPTH_BUFFER_BIT 0x00000100
#define GL_FRAGMENT_SHADER 0x8B30
#define GL_VERTEX_SHADER 0x8B31
#define GL_COMPILE_STATUS 0x8B81
#define GL_LINK_STATUS 0x8B82
#define GL_INFO_LOG_LENGTH 0x8B84
#define GL_ARRAY_BUFFER 0x8892
#define GL_STATIC_DRAW 0x88E4
#define GL_ELEMENT_ARRAY_BUFFER 0x8893
#define GL_UNSIGNED_INT 0x1405
#define GL_RED 0x1903
#define GL_RG 0x8227
#define GL_RGB 0x1907
#define GL_DEPTH_COMPONENT16 0x81A5
#define GL_DEPTH_COMPONENT 0x1902
#define GL_FRAMEBUFFER 0x8D40
#define GL_COLOR_ATTACHMENT0 0x8CE0
#define GL_DEPTH_ATTACHMENT 0x8D00
#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
#define GL_BACK 0x0405
#define GL_NONE 0
#define GL_BLEND 0x0BE2
#define GL_SRC_ALPHA 0x0302
#define GL_ONE_MINUS_SRC_ALPHA 0x0303
#define GL_MULTISAMPLE 0x809D
#define GL_VERSION 0x1F02
#define GL_VENDOR 0x1F00
#define GL_RENDERER 0x1F01
#define GL_FALSE 0
#define GL_TRUE 1
#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
#define GL_FRONT_AND_BACK 0x0408
#define GL_FILL 0x1B02
#define GL_LINE 0x1B01

#define GL_POLYGON_SMOOTH 0x0B41

#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
#define WGL_SUPPORT_OPENGL_ARB 0x2010
#define WGL_DRAW_TO_WINDOW_ARB 0x2001
#define WGL_ACCELERATION_ARB 0x2003
#define WGL_FULL_ACCELERATION_ARB 0x2027
#define WGL_COLOR_BITS_ARB 0x2014
#define WGL_ALPHA_BITS_ARB 0x201B
#define WGL_DEPTH_BITS_ARB 0x2022
#define WGL_STENCIL_BITS_ARB 0x2023
#define WGL_DOUBLE_BUFFER_ARB 0x2011
#define WGL_SAMPLE_BUFFERS_ARB 0x2041
#define WGL_SAMPLES_ARB 0x2042
#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
#define WGL_TYPE_RGBA_ARB 0x202B
#define WGL_PIXEL_TYPE_ARB 0x2013

const char *glErrNames[] = {
    "GL_INVALID_ENUM",
    "GL_INVALID_VALUE",
    "GL_INVALID_OPERATION",
    "###",
    "####",
    "GL_OUT_OF_MEMORY"};

void checkGLErrFunc(const char *filename, int line) {
    int e = glGetError();
    if(e) {
        const char *errName = glErrNames[e - GL_INVALID_ENUM];
        printf("Error %s (%d): %s, line %d\n", errName, e, filename, line);
        Assert(0);
    }
}

// ---------------------------------------------------------------------------

## glFuncsImpl.cpp
// ------ glGenTextures ------
typedef void __stdcall glGenTexturesFunc(GLsizei, GLuint *);
glGenTexturesFunc * _glGenTextures;

void glGenTextures(GLsizei arg0, GLuint * arg1){
	_glGenTextures(arg0, arg1);
	GLERR();
}

// ------ glBindTexture ------
typedef void __stdcall glBindTextureFunc(GLenum, GLuint);
glBindTextureFunc * _glBindTexture;

void glBindTexture(GLenum arg0, GLuint arg1){
	_glBindTexture(arg0, arg1);
	GLERR();
}

// ------ glTexImage2D ------
typedef void __stdcall glTexImage2DFunc(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
glTexImage2DFunc * _glTexImage2D;

void glTexImage2D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLsizei arg4, GLint arg5, GLenum arg6, GLenum arg7, const GLvoid * arg8){
	_glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
	GLERR();
}

// ------ glTexParameteri ------
typedef void __stdcall glTexParameteriFunc(GLenum, GLenum, GLint);
glTexParameteriFunc * _glTexParameteri;

void glTexParameteri(GLenum arg0, GLenum arg1, GLint arg2){
	_glTexParameteri(arg0, arg1, arg2);
	GLERR();
}

// ------ glGetError ------
typedef GLenum __stdcall glGetErrorFunc();
glGetErrorFunc * _glGetError;

GLenum glGetError(){
	GLenum Result = _glGetError();
	return Result;
}

// ------ glEnable ------
typedef void __stdcall glEnableFunc(GLenum);
glEnableFunc * _glEnable;

void glEnable(GLenum arg0){
	_glEnable(arg0);
	GLERR();
}

// ------ glDisable ------
typedef void __stdcall glDisableFunc(GLenum);
glDisableFunc * _glDisable;

void glDisable(GLenum arg0){
	_glDisable(arg0);
	GLERR();
}

// ------ glBegin ------
typedef void __stdcall glBeginFunc(GLenum);
glBeginFunc * _glBegin;

void glBegin(GLenum arg0){
	_glBegin(arg0);
}

// ------ glEnd ------
typedef void __stdcall glEndFunc();
glEndFunc * _glEnd;

void glEnd(){
	_glEnd();
	GLERR();
}

// ------ glTexCoord2f ------
typedef void __stdcall glTexCoord2fFunc(GLfloat, GLfloat);
glTexCoord2fFunc * _glTexCoord2f;

void glTexCoord2f(GLfloat arg0, GLfloat arg1){
	_glTexCoord2f(arg0, arg1);
}

// ------ glVertex2f ------
typedef void __stdcall glVertex2fFunc(GLfloat, GLfloat);
glVertex2fFunc * _glVertex2f;

void glVertex2f(GLfloat arg0, GLfloat arg1){
	_glVertex2f(arg0, arg1);
}

// ------ glEnableClientState ------
typedef void __stdcall glEnableClientStateFunc(GLenum);
glEnableClientStateFunc * _glEnableClientState;

void glEnableClientState(GLenum arg0){
	_glEnableClientState(arg0);
	GLERR();
}

// ------ glDisableClientState ------
typedef void __stdcall glDisableClientStateFunc(GLenum);
glDisableClientStateFunc * _glDisableClientState;

void glDisableClientState(GLenum arg0){
	_glDisableClientState(arg0);
	GLERR();
}

// ------ glVertexPointer ------
typedef void __stdcall glVertexPointerFunc(GLint, GLenum, GLsizei, const GLvoid *);
glVertexPointerFunc * _glVertexPointer;

void glVertexPointer(GLint arg0, GLenum arg1, GLsizei arg2, const GLvoid * arg3){
	_glVertexPointer(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glTexCoordPointer ------
typedef void __stdcall glTexCoordPointerFunc(GLint, GLenum, GLsizei, const GLvoid *);
glTexCoordPointerFunc * _glTexCoordPointer;

void glTexCoordPointer(GLint arg0, GLenum arg1, GLsizei arg2, const GLvoid * arg3){
	_glTexCoordPointer(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glColorPointer ------
typedef void __stdcall glColorPointerFunc(GLint, GLenum, GLsizei, const GLvoid *);
glColorPointerFunc * _glColorPointer;

void glColorPointer(GLint arg0, GLenum arg1, GLsizei arg2, const GLvoid * arg3){
	_glColorPointer(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glDrawArrays ------
typedef void __stdcall glDrawArraysFunc(GLenum, GLint, GLsizei);
glDrawArraysFunc * _glDrawArrays;

void glDrawArrays(GLenum arg0, GLint arg1, GLsizei arg2){
	_glDrawArrays(arg0, arg1, arg2);
	GLERR();
}

// ------ glClearColor ------
typedef void __stdcall glClearColorFunc(GLclampf, GLclampf, GLclampf, GLclampf);
glClearColorFunc * _glClearColor;

void glClearColor(GLclampf arg0, GLclampf arg1, GLclampf arg2, GLclampf arg3){
	_glClearColor(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glClear ------
typedef void __stdcall glClearFunc(GLbitfield);
glClearFunc * _glClear;

void glClear(GLbitfield arg0){
	_glClear(arg0);
	GLERR();
}

// ------ glLinkProgram ------
typedef void __stdcall glLinkProgramFunc(GLuint);
glLinkProgramFunc * _glLinkProgram;

void glLinkProgram(GLuint arg0){
	_glLinkProgram(arg0);
	GLERR();
}

// ------ glShaderSource ------
typedef void __stdcall glShaderSourceFunc(GLuint, GLsizei, const GLchar * const *, const GLint *);
glShaderSourceFunc * _glShaderSource;

void glShaderSource(GLuint arg0, GLsizei arg1, const GLchar * const * arg2, const GLint * arg3){
	_glShaderSource(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glUseProgram ------
typedef void __stdcall glUseProgramFunc(GLuint);
glUseProgramFunc * _glUseProgram;

void glUseProgram(GLuint arg0){
	_glUseProgram(arg0);
	GLERR();
}

// ------ glCompileShader ------
typedef void __stdcall glCompileShaderFunc(GLuint);
glCompileShaderFunc * _glCompileShader;

void glCompileShader(GLuint arg0){
	_glCompileShader(arg0);
	GLERR();
}

// ------ glCreateProgram ------
typedef GLuint __stdcall glCreateProgramFunc();
glCreateProgramFunc * _glCreateProgram;

GLuint glCreateProgram(){
	GLuint Result = _glCreateProgram();
	GLERR();
	return Result;
}

// ------ glCreateShader ------
typedef GLuint __stdcall glCreateShaderFunc(GLenum);
glCreateShaderFunc * _glCreateShader;

GLuint glCreateShader(GLenum arg0){
	GLuint Result = _glCreateShader(arg0);
	GLERR();
	return Result;
}

// ------ glGetShaderiv ------
typedef void __stdcall glGetShaderivFunc(GLuint, GLenum, GLint *);
glGetShaderivFunc * _glGetShaderiv;

void glGetShaderiv(GLuint arg0, GLenum arg1, GLint * arg2){
	_glGetShaderiv(arg0, arg1, arg2);
	GLERR();
}

// ------ glGetShaderInfoLog ------
typedef void __stdcall glGetShaderInfoLogFunc(GLuint, GLsizei, GLsizei *, GLchar *);
glGetShaderInfoLogFunc * _glGetShaderInfoLog;

void glGetShaderInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3){
	_glGetShaderInfoLog(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glAttachShader ------
typedef void __stdcall glAttachShaderFunc(GLuint, GLuint);
glAttachShaderFunc * _glAttachShader;

void glAttachShader(GLuint arg0, GLuint arg1){
	_glAttachShader(arg0, arg1);
	GLERR();
}

// ------ glGetProgramiv ------
typedef void __stdcall glGetProgramivFunc(GLuint, GLenum, GLint *);
glGetProgramivFunc * _glGetProgramiv;

void glGetProgramiv(GLuint arg0, GLenum arg1, GLint * arg2){
	_glGetProgramiv(arg0, arg1, arg2);
	GLERR();
}

// ------ glGetProgramInfoLog ------
typedef void __stdcall glGetProgramInfoLogFunc(GLuint, GLsizei, GLsizei *, GLchar *);
glGetProgramInfoLogFunc * _glGetProgramInfoLog;

void glGetProgramInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3){
	_glGetProgramInfoLog(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glGetUniformLocation ------
typedef GLint __stdcall glGetUniformLocationFunc(GLuint, const GLchar *);
glGetUniformLocationFunc * _glGetUniformLocation;

GLint glGetUniformLocation(GLuint arg0, const GLchar * arg1){
	GLint Result = _glGetUniformLocation(arg0, arg1);
	GLERR();
	return Result;
}

// ------ glUniform1i ------
typedef void __stdcall glUniform1iFunc(GLint, GLint);
glUniform1iFunc * _glUniform1i;

void glUniform1i(GLint arg0, GLint arg1){
	_glUniform1i(arg0, arg1);
	GLERR();
}

// ------ glGenBuffers ------
typedef void __stdcall glGenBuffersFunc(GLsizei, GLuint *);
glGenBuffersFunc * _glGenBuffers;

void glGenBuffers(GLsizei arg0, GLuint * arg1){
	_glGenBuffers(arg0, arg1);
	GLERR();
}

// ------ glBindBuffer ------
typedef void __stdcall glBindBufferFunc(GLenum, GLuint);
glBindBufferFunc * _glBindBuffer;

void glBindBuffer(GLenum arg0, GLuint arg1){
	_glBindBuffer(arg0, arg1);
	GLERR();
}

// ------ glBufferData ------
typedef void __stdcall glBufferDataFunc(GLenum, GLsizeiptr, const void *, GLenum);
glBufferDataFunc * _glBufferData;

void glBufferData(GLenum arg0, GLsizeiptr arg1, const void * arg2, GLenum arg3){
	_glBufferData(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glVertexAttribPointer ------
typedef void __stdcall glVertexAttribPointerFunc(GLuint, GLint, GLenum, GLboolean, GLsizei, const void *);
glVertexAttribPointerFunc * _glVertexAttribPointer;

void glVertexAttribPointer(GLuint arg0, GLint arg1, GLenum arg2, GLboolean arg3, GLsizei arg4, const void * arg5){
	_glVertexAttribPointer(arg0, arg1, arg2, arg3, arg4, arg5);
	GLERR();
}

// ------ glEnableVertexAttribArray ------
typedef void __stdcall glEnableVertexAttribArrayFunc(GLuint);
glEnableVertexAttribArrayFunc * _glEnableVertexAttribArray;

void glEnableVertexAttribArray(GLuint arg0){
	_glEnableVertexAttribArray(arg0);
	GLERR();
}

// ------ glUniformMatrix4fv ------
typedef void __stdcall glUniformMatrix4fvFunc(GLint, GLsizei, GLboolean, const GLfloat *);
glUniformMatrix4fvFunc * _glUniformMatrix4fv;

void glUniformMatrix4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3){
	_glUniformMatrix4fv(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glDrawElements ------
typedef void __stdcall glDrawElementsFunc(GLenum, GLsizei, GLenum, const void *);
glDrawElementsFunc * _glDrawElements;

void glDrawElements(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3){
	_glDrawElements(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glDisableVertexAttribArray ------
typedef void __stdcall glDisableVertexAttribArrayFunc(GLuint);
glDisableVertexAttribArrayFunc * _glDisableVertexAttribArray;

void glDisableVertexAttribArray(GLuint arg0){
	_glDisableVertexAttribArray(arg0);
	GLERR();
}

// ------ glGenFramebuffers ------
typedef void __stdcall glGenFramebuffersFunc(GLsizei, GLuint *);
glGenFramebuffersFunc * _glGenFramebuffers;

void glGenFramebuffers(GLsizei arg0, GLuint * arg1){
	_glGenFramebuffers(arg0, arg1);
	GLERR();
}

// ------ glBindFramebuffer ------
typedef void __stdcall glBindFramebufferFunc(GLenum, GLuint);
glBindFramebufferFunc * _glBindFramebuffer;

void glBindFramebuffer(GLenum arg0, GLuint arg1){
	_glBindFramebuffer(arg0, arg1);
	GLERR();
}

// ------ glFramebufferTexture2D ------
typedef void __stdcall glFramebufferTexture2DFunc(GLenum, GLenum, GLenum, GLuint, GLint);
glFramebufferTexture2DFunc * _glFramebufferTexture2D;

void glFramebufferTexture2D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4){
	_glFramebufferTexture2D(arg0, arg1, arg2, arg3, arg4);
	GLERR();
}

// ------ glCheckFramebufferStatus ------
typedef GLenum __stdcall glCheckFramebufferStatusFunc(GLenum);
glCheckFramebufferStatusFunc * _glCheckFramebufferStatus;

GLenum glCheckFramebufferStatus(GLenum arg0){
	GLenum Result = _glCheckFramebufferStatus(arg0);
	GLERR();
	return Result;
}

// ------ glDeleteFramebuffers ------
typedef void __stdcall glDeleteFramebuffersFunc(GLsizei, const GLuint *);
glDeleteFramebuffersFunc * _glDeleteFramebuffers;

void glDeleteFramebuffers(GLsizei arg0, const GLuint * arg1){
	_glDeleteFramebuffers(arg0, arg1);
	GLERR();
}

// ------ glDeleteTextures ------
typedef void __stdcall glDeleteTexturesFunc(GLsizei, const GLuint *);
glDeleteTexturesFunc * _glDeleteTextures;

void glDeleteTextures(GLsizei arg0, const GLuint * arg1){
	_glDeleteTextures(arg0, arg1);
	GLERR();
}

// ------ glDrawBuffer ------
typedef void __stdcall glDrawBufferFunc(GLenum);
glDrawBufferFunc * _glDrawBuffer;

void glDrawBuffer(GLenum arg0){
	_glDrawBuffer(arg0);
	GLERR();
}

// ------ glBlendFunc ------
typedef void __stdcall glBlendFuncFunc(GLenum, GLenum);
glBlendFuncFunc * _glBlendFunc;

void glBlendFunc(GLenum arg0, GLenum arg1){
	_glBlendFunc(arg0, arg1);
	GLERR();
}

// ------ glScissor ------
typedef void __stdcall glScissorFunc(GLint, GLint, GLsizei, GLsizei);
glScissorFunc * _glScissor;

void glScissor(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3){
	_glScissor(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glViewport ------
typedef void __stdcall glViewportFunc(GLint, GLint, GLsizei, GLsizei);
glViewportFunc * _glViewport;

void glViewport(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3){
	_glViewport(arg0, arg1, arg2, arg3);
	GLERR();
}

// ------ glGetString ------
typedef const GLubyte * __stdcall glGetStringFunc(GLenum);
glGetStringFunc * _glGetString;

const GLubyte * glGetString(GLenum arg0){
	const GLubyte * Result = _glGetString(arg0);
	GLERR();
	return Result;
}

// ------ glPolygonMode ------
typedef void __stdcall glPolygonModeFunc(GLenum, GLenum);
glPolygonModeFunc * _glPolygonMode;

void glPolygonMode(GLenum arg0, GLenum arg1){
	_glPolygonMode(arg0, arg1);
	GLERR();
}

// ------ wglChoosePixelFormatARB ------
typedef BOOL __stdcall wglChoosePixelFormatARBFunc(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
wglChoosePixelFormatARBFunc * _wglChoosePixelFormatARB;

BOOL wglChoosePixelFormatARB(HDC arg0, const int * arg1, const FLOAT * arg2, UINT arg3, int * arg4, UINT * arg5){
	BOOL Result = _wglChoosePixelFormatARB(arg0, arg1, arg2, arg3, arg4, arg5);
	GLERR();
	return Result;
}

// ------ wglCreateContextAttribsARB ------
typedef HGLRC __stdcall wglCreateContextAttribsARBFunc(HDC, HGLRC, const int *);
wglCreateContextAttribsARBFunc * _wglCreateContextAttribsARB;

HGLRC wglCreateContextAttribsARB(HDC arg0, HGLRC arg1, const int * arg2){
	HGLRC Result = _wglCreateContextAttribsARB(arg0, arg1, arg2);
	return Result;
}

// ------ wglSwapIntervalEXT ------
typedef BOOL __stdcall wglSwapIntervalEXTFunc(i32);
wglSwapIntervalEXTFunc * _wglSwapIntervalEXT;

BOOL wglSwapIntervalEXT(i32 arg0){
	BOOL Result = _wglSwapIntervalEXT(arg0);
	GLERR();
	return Result;
}
	// Parser for C(++) code, aimed at generating
	// code instead of using C macros

	typedef int i32;

	typedef struct {
	const char *Code;
	i32 CodeLength;
	i32 CurrentLine;
	} cpp_lexer;

	cpp_lexer createLexer(const char *Code, i32 Length) {
	cpp_lexer Result;
	Result.Code = Code;
	Result.CodeLength = Length;
	Result.CurrentLine = 1;
	return Result;
	}

	#define TOKENS() TOK(TOKEN_EOF), TOK(TOKEN_ERROR), TOK(TOKEN_IDENTIFIER), TOK(TOKEN_NUMBER), \
	TOK(TOKEN_OPEN_PARENS), TOK(TOKEN_CLOSE_PARENS), TOK(TOKEN_OPEN_BRACKETS), TOK(TOKEN_CLOSE_BRACKETS), \
	TOK(TOKEN_OPEN_SQUARE_BRACKETS), TOK(TOKEN_CLOSE_SQUARE_BRACKETS), \
	TOK(TOKEN_SEMICOLON), TOK(TOKEN_COMMA), TOK(TOKEN_COLON), TOK(TOKEN_DOT), \
	TOK(TOKEN_PLUS), TOK(TOKEN_MINUS), TOK(TOKEN_STAR), TOK(TOKEN_SLASH), \
	TOK(TOKEN_PLUS_EQUAL), TOK(TOKEN_MINUS_EQUAL), TOK(TOKEN_STAR_EQUAL), TOK(TOKEN_SLASH_EQUAL), \
	TOK(TOKEN_COMMENT), TOK(TOKEN_STRING), TOK(TOKEN_CHAR), \
	TOK(TOKEN_EQUAL), TOK(TOKEN_EQUALS), \
	TOK(TOKEN_LESS_THAN), TOK(TOKEN_LESS_EQUAL), TOK(TOKEN_LEFT_SHIFT), \
	TOK(TOKEN_MORE_THAN), TOK(TOKEN_MORE_EQUAL), TOK(TOKEN_RIGHT_SHIFT), \
	TOK(TOKEN_DEC), \
	TOK(TOKEN_INC), \
	TOK(TOKEN_ARROW), \
	TOK(TOKEN_NOT_EQUAL), \
	TOK(TOKEN_BIN_AND), TOK(TOKEN_BIN_OR), TOK(TOKEN_BIN_XOR), TOK(TOKEN_BIN_NOT), \
	TOK(TOKEN_LOGIC_AND), TOK(TOKEN_LOGIC_OR), TOK(TOKEN_LOGIC_XOR), TOK(TOKEN_LOGIC_NOT), \
	TOK(TOKEN_AND_EQUALS), TOK(TOKEN_OR_EQUALS), TOK(TOKEN_XOR_EQUALS), \
	TOK(TOKEN_DIRECTIVE)

	// ----------------

	#define TOK(x) x
	#define Assert(x) \
	if(!(x)) { \
	__debugbreak(); \
	}

	typedef enum {
	TOKENS(),
	TOKENS_CNT
	} token_type;

	#undef TOK
	#define TOK(x) #x
	const char *TokenNames[] = {
	TOKENS(),
	};
	#undef TOK

	typedef struct {
	token_type Type;
	const char *Text;
	i32 Length;
	} token;

	void ignoreSpaceCharacters(cpp_lexer *Lexer) {
	for(;;) {
	if(Lexer->CodeLength == 0) {
	break;
	}
	char c = *Lexer->Code;
	if(!((c == ' ') \|\| (c == '\t') \|\| (c == '\r') \|\| (c == '\n'))) {
	break;
	}
	Lexer->Code++;
	Lexer->CodeLength--;
	if(c == '\n') {
	Lexer->CurrentLine++;
	}
	}
	}

	bool getNextChar(cpp_lexer Lexer, char C) {
	if(Lexer->CodeLength == 0) {
	return false;
	}
	Lexer->CodeLength--;
	C = Lexer->Code++;
	if(*C == '\n') {
	Lexer->CurrentLine++;
	}
	return true;
	}

	void unreadChar(cpp_lexer *Lexer) {
	Lexer->Code--;
	Lexer->CodeLength++;
	if(*Lexer->Code == '\n') {
	Lexer->CurrentLine--;
	}
	}

	bool isNumeric(char C) { return (C >= '0' && C <= '9'); }

	bool isAlphaNumeric(char C) {
	return (C >= 'a' && C <= 'z') \|\| (C >= 'A' && C <= 'Z') \|\| (C == '_') \|\| (C >= '0' && C <= '9');
	}

	token getNextToken(cpp_lexer *Lexer) {
	ignoreSpaceCharacters(Lexer);

	token Result;
	Result.Text = Lexer->Code;
	Result.Length = 1;

	char StartC;
	if(!getNextChar(Lexer, &StartC)) {
	Result.Type = TOKEN_EOF;
	Result.Length = 0;
	return Result;
	}

	#define ONE_CHAR_TOKEN(c, toktype) \
	case c: \
	Result.Type = toktype; \
	return Result

	#define INIT_MULTICHAR_TOK(onechartok) \
	do { \
	Result.Type = onechartok; \
	if(!getNextChar(Lexer, &StartC)) { \
	Result.Type = TOKEN_ERROR; \
	return Result; \
	} \
	} while(0, 0)

	#define END_MULTICHAR_TOK() \
	unreadChar(Lexer); \
	return Result

	#define CHECK_ADDED_CHAR(chr, toktype) \
	do { \
	if(StartC == chr) { \
	Result.Type = toktype; \
	Result.Length++; \
	return Result; \
	} \
	} while(0, 0)

	#define ERRTOK() \
	Result.Type = TOKEN_ERROR; \
	return Result

	switch(StartC) {
	ONE_CHAR_TOKEN('(', TOKEN_OPEN_PARENS);
	ONE_CHAR_TOKEN(')', TOKEN_CLOSE_PARENS);
	ONE_CHAR_TOKEN('{', TOKEN_OPEN_BRACKETS);
	ONE_CHAR_TOKEN('}', TOKEN_CLOSE_BRACKETS);
	ONE_CHAR_TOKEN('[', TOKEN_OPEN_SQUARE_BRACKETS);
	ONE_CHAR_TOKEN(']', TOKEN_CLOSE_SQUARE_BRACKETS);
	ONE_CHAR_TOKEN(';', TOKEN_SEMICOLON);
	ONE_CHAR_TOKEN(',', TOKEN_COMMA);
	ONE_CHAR_TOKEN('.', TOKEN_DOT);
	ONE_CHAR_TOKEN(':', TOKEN_COLON);
	ONE_CHAR_TOKEN('~', TOKEN_BIN_NOT);

	case '+': {
	INIT_MULTICHAR_TOK(TOKEN_PLUS);
	CHECK_ADDED_CHAR('=', TOKEN_PLUS_EQUAL);
	CHECK_ADDED_CHAR('+', TOKEN_INC);
	END_MULTICHAR_TOK();
	}
	case '!': {
	INIT_MULTICHAR_TOK(TOKEN_LOGIC_NOT);
	CHECK_ADDED_CHAR('=', TOKEN_NOT_EQUAL);
	END_MULTICHAR_TOK();
	}
	case '-': {
	INIT_MULTICHAR_TOK(TOKEN_MINUS);
	CHECK_ADDED_CHAR('=', TOKEN_MINUS_EQUAL);
	CHECK_ADDED_CHAR('-', TOKEN_DEC);
	CHECK_ADDED_CHAR('>', TOKEN_ARROW);
	END_MULTICHAR_TOK();
	}
	case '*': {
	INIT_MULTICHAR_TOK(TOKEN_STAR);
	CHECK_ADDED_CHAR('=', TOKEN_STAR_EQUAL);
	END_MULTICHAR_TOK();
	}
	case '&': {
	INIT_MULTICHAR_TOK(TOKEN_BIN_AND);
	CHECK_ADDED_CHAR('&', TOKEN_LOGIC_AND);
	CHECK_ADDED_CHAR('=', TOKEN_AND_EQUALS);
	END_MULTICHAR_TOK();
	}
	case '\|': {
	INIT_MULTICHAR_TOK(TOKEN_BIN_OR);
	CHECK_ADDED_CHAR('\|', TOKEN_LOGIC_OR);
	CHECK_ADDED_CHAR('=', TOKEN_OR_EQUALS);
	END_MULTICHAR_TOK();
	}
	case '^': {
	INIT_MULTICHAR_TOK(TOKEN_BIN_XOR);
	CHECK_ADDED_CHAR('=', TOKEN_XOR_EQUALS);
	END_MULTICHAR_TOK();
	}
	case '<': {
	INIT_MULTICHAR_TOK(TOKEN_LESS_THAN);
	CHECK_ADDED_CHAR('<', TOKEN_LEFT_SHIFT);
	CHECK_ADDED_CHAR('=', TOKEN_LESS_EQUAL);
	END_MULTICHAR_TOK();
	}
	case '>': {
	INIT_MULTICHAR_TOK(TOKEN_MORE_THAN);
	CHECK_ADDED_CHAR('>', TOKEN_RIGHT_SHIFT);
	CHECK_ADDED_CHAR('=', TOKEN_MORE_EQUAL);
	END_MULTICHAR_TOK();
	}
	case '=': {
	INIT_MULTICHAR_TOK(TOKEN_EQUAL);
	CHECK_ADDED_CHAR('=', TOKEN_EQUALS);
	END_MULTICHAR_TOK();
	}
	case '\'': {
	Result.Type = TOKEN_CHAR;
	Result.Text++;
	if(!getNextChar(Lexer, &StartC)) {
	ERRTOK();
	}
	char NextC;
	if(!getNextChar(Lexer, &NextC)) {
	ERRTOK();
	}
	if(StartC == '\\') {
	if(!getNextChar(Lexer, &NextC) \|\| NextC != '\'') {
	ERRTOK();
	}
	Result.Length = 2;
	return Result;
	}
	if(NextC != '\'') {
	ERRTOK();
	}
	return Result;
	}
	case '"': {
	Result.Type = TOKEN_STRING;
	char C = StartC;
	Result.Length = -1;
	Result.Text = Lexer->Code;
	do {
	Result.Length++;
	StartC = C;
	if(!getNextChar(Lexer, &C)) {
	ERRTOK();
	}
	// NOTE: This doesn't handle multiline strings properly
	} while(C != '"' \|\| StartC == '\\');

	return Result;
	}

	case '#': {
	Result.Text = Lexer->Code;
	Result.Length = 0;
	Result.Type = TOKEN_DIRECTIVE;
	while(getNextChar(Lexer, &StartC) && StartC != '\r' && StartC != '\n') {
	Result.Length++;
	}
	return Result;
	}

	case '/': {
	char NextChar;
	if(!getNextChar(Lexer, &NextChar)) {
	Result.Type = TOKEN_SLASH;
	return Result;
	}
	if(NextChar == '=') { // a /= 2;
	Result.Length = 2;
	Result.Type = TOKEN_SLASH_EQUAL;
	return Result;
	}
	if(NextChar == '/') { // C++-style comment
	Result.Text = Lexer->Code;
	Result.Length = 0;
	Result.Type = TOKEN_COMMENT;
	while(getNextChar(Lexer, &NextChar) && NextChar != '\r' && NextChar != '\n') {
	Result.Length++;
	}
	return Result;
	}
	if(NextChar == '*') { // C-style comment
	Result.Type = TOKEN_COMMENT;
	Result.Text = Lexer->Code;
	Result.Length = 0;
	if(!getNextChar(Lexer, &StartC)) {
	ERRTOK();
	}
	for(;;) {
	if(!getNextChar(Lexer, &NextChar)) {
	ERRTOK();
	}
	if(NextChar == '/' && StartC == '*') {
	return Result;
	}
	Result.Length++;
	StartC = NextChar;
	}
	}

	// Roll back one char, it was just a slash
	unreadChar(Lexer);
	Result.Type = TOKEN_SLASH;
	return Result;
	}
	default: {
	if(isNumeric(StartC)) {
	Result.Type = TOKEN_NUMBER;

	while(Lexer->CodeLength > 0 && isNumeric(*Lexer->Code)) {
	Result.Length++;
	Lexer->Code++;
	Lexer->CodeLength--;
	}

	return Result;
	} else {
	Result.Type = TOKEN_IDENTIFIER;

	while(Lexer->CodeLength > 0 && isAlphaNumeric(*Lexer->Code)) {
	Result.Length++;
	Lexer->Code++;
	Lexer->CodeLength--;
	}

	return Result;
	}
	}
	#undef ONE_CHAR_TOKEN
	}
	}

	// Returns next token, skipping over comments
	token getNextSignficantToken(cpp_lexer *Lexer) {
	token T;
	do {
	T = getNextToken(Lexer);
	} while(T.Type == TOKEN_COMMENT);

	return T;
	}

	i32 StrLen(const char *Str) {
	i32 Result = 0;
	while(*Str++) {
	Result++;
	}
	return Result;
	}

	bool findIdentifier(cpp_lexer Lexer, const char Name, token *Token) {
	i32 NameLen = StrLen(Name);
	for(;;) {
	token T = getNextToken(Lexer);
	if(T.Type == TOKEN_EOF) {
	return false;
	}
	if(T.Type == TOKEN_IDENTIFIER && T.Length == NameLen) {
	bool AreEqual = true;
	for(int i = 0; i < NameLen; i++) {
	if(Name[i] != T.Text[i]) {
	AreEqual = false;
	break;
	}
	}
	if(AreEqual) {
	*Token = T;
	return true;
	}
	}
	}
	}
	#include "cpp_lexer.cpp"
	#include <stdio.h>
	#include <stdlib.h>

	typedef unsigned char u8;

	char readFile(const char Filename, i32 *FileSize) {
	FILE *fd = fopen(Filename, "r");
	if(!fd) {
	return NULL;
	}
	fseek(fd, 0, SEEK_END);
	int fileSize = ftell(fd);
	fseek(fd, 0, SEEK_SET);
	char Data = (char )malloc(fileSize);
	*FileSize = fread(Data, 1, fileSize, fd);
	fclose(fd);
	return Data;
	}

	void printLexerErr(cpp_lexer *Lexer) {
	printf("ERROR in line %d --", Lexer->CurrentLine);
	}

	void AssertNextToken(cpp_lexer *Lexer, token_type Type) {
	token Token = getNextToken(Lexer);
	if(Token.Type == TOKEN_EOF) {
	printLexerErr(Lexer);
	printf("Reached end of file while expecting a token of type %s\n", TokenNames[Type]);
	exit(1);
	}
	if(Token.Type != Type) {
	printLexerErr(Lexer);
	printf("Expected token of type %s, but got %s instead\n", TokenNames[Type], TokenNames[Token.Type]);
	exit(1);
	}
	}

	void AssertToken(token Token, token_type Type) {
	if(Token.Type != Type) {
	printf("Expected token of type %s, but got %s instead\n", TokenNames[Type], TokenNames[Token.Type]);
	exit(1);
	}
	}

	token getToken(cpp_lexer *Lexer) {
	token Token = getNextToken(Lexer);
	if(Token.Type == TOKEN_EOF) {
	printLexerErr(Lexer);
	printf("Unexpected end of file\n");
	exit(1);
	}
	return Token;
	}

	#define MAX_TOKENS 50

	typedef struct {
	token Tokens[MAX_TOKENS];
	i32 TokenCnt;
	} argument;

	bool readMacroArguments(cpp_lexer Lexer, i32 MaxArguments, argument Arguments, int *ReadArguments) {
	for(int Arg = 0; Arg < MaxArguments; Arg++) {
	Arguments[Arg].TokenCnt = 0;
	for(int i = 0; i < MAX_TOKENS; i++) {
	token Token = getToken(Lexer);
	if(Token.Type == TOKEN_COMMA) {
	break;
	}

	if(Token.Type == TOKEN_CLOSE_PARENS) {
	*ReadArguments = Arg + 1;
	return true;
	}
	int TokenCnt = Arguments[Arg].TokenCnt;
	Arguments[Arg].Tokens[TokenCnt] = Token;
	Arguments[Arg].TokenCnt++;
	}
	}
	return false;
	}

	bool argumentIs(argument Arg, const char Text) {
	// Note: this doesn't support arguments with several tokens yet
	if(Arg->TokenCnt != 1) {
	return false;
	}
	if(StrLen(Text) != Arg->Tokens[0].Length) {
	return false;
	}
	for(int i = 0; i < Arg->Tokens[0].Length; i++) {
	if(Arg->Tokens[0].Text[i] != Text[i]) {
	return false;
	}
	}
	return true;
	}

	void printTokenContents(FILE *fd, token Tok) {
	for(int i = 0; i < Tok.Length; i++) {
	fprintf(fd, "%c", Tok.Text[i]);
	}
	}
	void printArgument(FILE fd, argument Arg) {
	for(int i = 0; i < Arg->TokenCnt; i++) {
	if(i != 0) {
	fprintf(fd, " ");
	}
	printTokenContents(fd, Arg->Tokens[i]);
	}
	}

	void print(FILE fd, const char S) {
	fprintf(fd, "%s", S);
	}

	void print(FILE fd, argument Arg) {
	printArgument(fd, Arg);
	}

	void print(FILE *fd, char c) {
	fprintf(fd, "%c", c);
	}

	template <typename T, typename... params>
	void print(FILE *fd, T Arg1, params... ArgsN) {
	print(fd, Arg1);
	print(fd, ArgsN...);
	}

	// ---------------------------------------------------------------------------
	// Actual metaprogramming functions
	// ---------------------------------------------------------------------------

	void generateGLFunctionWrappers() {

	// Generate function wrappers in glFuncs.cpp
	i32 FileSize;
	char *FileData = readFile("../src/glFuncs.cpp", &FileSize);
	if(!FileData) {
	printf("ERROR -- Could not open input file\n");
	exit(1);
	}

	FILE *fd = fopen("../src/generated/glFuncsImpl.cpp", "w");
	if(!fd) {
	printf("ERROR -- Could not open output file for writing\n");
	exit(1);
	}

	cpp_lexer Lexer = createLexer(FileData, FileSize);
	token Token;

	while(findIdentifier(&Lexer, "GLFUNC", &Token)) {
	AssertNextToken(&Lexer, TOKEN_OPEN_PARENS);

	argument Args[20];
	i32 ArgsCnt;
	if(!readMacroArguments(&Lexer, 20, Args, &ArgsCnt)) {
	printLexerErr(&Lexer);
	printf("GLFUNC macro has too many arguments, or EOF found in the middle of one\n");
	exit(1);
	}
	argument *ReturnType = &Args[1];
	argument *FunctionName = &Args[0];
	argument *FunctionArgs = &Args[2];
	i32 FunctionArgsCnt = ArgsCnt - 2;

	print(fd, "// ------ ", FunctionName, " ------\n");

	// Print function type typedef
	print(fd, "typedef ", ReturnType, " __stdcall ", FunctionName, "Func(");
	for(int i = 0; i < FunctionArgsCnt; i++) {
	print(fd, i == 0 ? "" : ", ", &FunctionArgs[i]);
	}
	print(fd, ");\n");
	// Print GL function pointer
	print(fd, FunctionName, "Func * _", FunctionName, ";\n\n");

	// Print wrapper function
	print(fd, ReturnType, " ", FunctionName, "(");
	for(int i = 0; i < FunctionArgsCnt; i++) {
	print(fd, i == 0 ? "" : ", ", &FunctionArgs[i], " arg", char('0' + i));
	}
	print(fd, "){\n\t");
	if(!argumentIs(ReturnType, "void")) {
	print(fd, ReturnType, " Result = ");
	}
	print(fd, "_", FunctionName, "(");
	for(int i = 0; i < FunctionArgsCnt; i++) {
	print(fd, i == 0 ? "" : ", ", "arg", char('0' + i));
	}
	print(fd, ");\n");
	if(!(
	// glGetError must not call itself!
	argumentIs(FunctionName, "glGetError") \|\|
	// Can't call glGetError inside a glBegin/glEnd block
	argumentIs(FunctionName, "glBegin") \|\|
	argumentIs(FunctionName, "glVertex2f") \|\|
	argumentIs(FunctionName, "glTexCoord2f") \|\|
	// wglCreateContextAttribsARB gives GL_INVALID_OPERATION until context is made current
	argumentIs(FunctionName, "wglCreateContextAttribsARB"))) {
	print(fd, "\tGLERR();\n");
	}

	if(!argumentIs(ReturnType, "void")) {
	print(fd, "\treturn Result;\n");
	}
	print(fd, "}\n\n");
	}
	fclose(fd);
	free(FileData);
	}

	int main() {
	generateGLFunctionWrappers();
	}
	typedef u32 GLenum;
	typedef u32 GLuint;
	typedef i32 GLint;
	typedef i32 GLsizei;
	typedef void GLvoid;
	typedef f32 GLfloat;
	typedef f32 GLclampf;
	typedef u32 GLbitfield;
	typedef char GLchar;
	typedef ptrdiff_t GLsizeiptr;
	typedef u8 GLboolean;
	typedef u8 GLubyte;

	extern "C" {
	#ifdef _WIN32
	typedef PROC WINAPI wglGetProcAddressFunc(LPCSTR);
	wglGetProcAddressFunc *_wglGetProcAddress;

	typedef HGLRC WINAPI wglCreateContextFunc(HDC hdc);
	wglCreateContextFunc *_wglCreateContext;

	typedef BOOL WINAPI wglDeleteContextFunc(HGLRC hglrc);
	wglDeleteContextFunc *_wglDeleteContext;

	typedef BOOL WINAPI wglMakeCurrentFunc(HDC hdc, HGLRC hglrc);
	wglMakeCurrentFunc *_wglMakeCurrent;

	typedef BOOL WINAPI wglSwapLayerBuffersFunc(HDC hdc, UINT fuPlanes);
	wglSwapLayerBuffersFunc *_wglSwapLayerBuffers;
	}
	global_var HMODULE g_OpenglLib;

	#endif

	// ---------------------------------------------------------------------------
	#define GLFUNCS_LIST \
	GLFUNC(glGenTextures, void, GLsizei, GLuint *) \
	GLFUNC(glBindTexture, void, GLenum, GLuint) \
	GLFUNC(glTexImage2D, void, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) \
	GLFUNC(glTexParameteri, void, GLenum, GLenum, GLint) \
	GLFUNC(glGetError, GLenum) \
	GLFUNC(glEnable, void, GLenum) \
	GLFUNC(glDisable, void, GLenum) \
	GLFUNC(glBegin, void, GLenum) \
	GLFUNC(glEnd, void) \
	GLFUNC(glTexCoord2f, void, GLfloat, GLfloat) \
	GLFUNC(glVertex2f, void, GLfloat, GLfloat) \
	GLFUNC(glEnableClientState, void, GLenum) \
	GLFUNC(glDisableClientState, void, GLenum) \
	GLFUNC(glVertexPointer, void, GLint, GLenum, GLsizei, const GLvoid *) \
	GLFUNC(glTexCoordPointer, void, GLint, GLenum, GLsizei, const GLvoid *) \
	GLFUNC(glColorPointer, void, GLint, GLenum, GLsizei, const GLvoid *) \
	GLFUNC(glDrawArrays, void, GLenum, GLint, GLsizei) \
	GLFUNC(glClearColor, void, GLclampf, GLclampf, GLclampf, GLclampf) \
	GLFUNC(glClear, void, GLbitfield) \
	GLFUNC(glLinkProgram, void, GLuint) \
	GLFUNC(glShaderSource, void, GLuint, GLsizei, const GLchar const , const GLint *) \
	GLFUNC(glUseProgram, void, GLuint) \
	GLFUNC(glCompileShader, void, GLuint) \
	GLFUNC(glCreateProgram, GLuint) \
	GLFUNC(glCreateShader, GLuint, GLenum) \
	GLFUNC(glGetShaderiv, void, GLuint, GLenum, GLint *) \
	GLFUNC(glGetShaderInfoLog, void, GLuint, GLsizei, GLsizei , GLchar ) \
	GLFUNC(glAttachShader, void, GLuint, GLuint) \
	GLFUNC(glGetProgramiv, void, GLuint, GLenum, GLint *) \
	GLFUNC(glGetProgramInfoLog, void, GLuint, GLsizei, GLsizei , GLchar ) \
	GLFUNC(glGetUniformLocation, GLint, GLuint, const GLchar *) \
	GLFUNC(glUniform1i, void, GLint, GLint) \
	GLFUNC(glGenBuffers, void, GLsizei, GLuint *) \
	GLFUNC(glBindBuffer, void, GLenum, GLuint) \
	GLFUNC(glBufferData, void, GLenum, GLsizeiptr, const void *, GLenum) \
	GLFUNC(glVertexAttribPointer, void, GLuint, GLint, GLenum, GLboolean, GLsizei, const void *) \
	GLFUNC(glEnableVertexAttribArray, void, GLuint) \
	GLFUNC(glUniformMatrix4fv, void, GLint, GLsizei, GLboolean, const GLfloat *) \
	GLFUNC(glDrawElements, void, GLenum, GLsizei, GLenum, const void *) \
	GLFUNC(glDisableVertexAttribArray, void, GLuint) \
	GLFUNC(glGenFramebuffers, void, GLsizei, GLuint *) \
	GLFUNC(glBindFramebuffer, void, GLenum, GLuint) \
	GLFUNC(glFramebufferTexture2D, void, GLenum, GLenum, GLenum, GLuint, GLint) \
	GLFUNC(glCheckFramebufferStatus, GLenum, GLenum) \
	GLFUNC(glDeleteFramebuffers, void, GLsizei, const GLuint *) \
	GLFUNC(glDeleteTextures, void, GLsizei, const GLuint *) \
	GLFUNC(glDrawBuffer, void, GLenum) \
	GLFUNC(glBlendFunc, void, GLenum, GLenum) \
	GLFUNC(glScissor, void, GLint, GLint, GLsizei, GLsizei) \
	GLFUNC(glViewport, void, GLint, GLint, GLsizei, GLsizei) \
	GLFUNC(glGetString, const GLubyte *, GLenum) \
	GLFUNC(glPolygonMode, void, GLenum, GLenum) \
	GLFUNC(wglChoosePixelFormatARB, BOOL, HDC, const int , const FLOAT , UINT, int , UINT ) \
	GLFUNC(wglCreateContextAttribsARB, HGLRC, HDC, HGLRC, const int *) \
	GLFUNC(wglSwapIntervalEXT, BOOL, i32)

	#define GLERR() checkGLErrFunc(__FILE__, __LINE__)

	void checkGLErrFunc(const char *filename, int line);

	#include "generated/glFuncsImpl.cpp"

	// ---------------------------------------------------------------------------

	void loadOpenGL() {
	g_OpenglLib = LoadLibrary("opengl32.dll");
	Assert(g_OpenglLib);

	#define GET_WGLFUNC(name) \
	_##name = (name##Func *)GetProcAddress(g_OpenglLib, #name); \
	Assert(_##name &&#name);

	GET_WGLFUNC(wglGetProcAddress);
	GET_WGLFUNC(wglCreateContext);
	GET_WGLFUNC(wglDeleteContext);
	GET_WGLFUNC(wglMakeCurrent);
	GET_WGLFUNC(wglSwapLayerBuffers);
	#undef GET_WGLFUNC
	}

	void initGLFuncs() {
	#ifdef _WIN32
	#undef GLFUNC
	#define GLFUNC(name, ...) \
	do { \
	_##name = (name##Func *)_wglGetProcAddress(#name); \
	if(!_##name) { \
	_##name = (name##Func *)GetProcAddress(g_OpenglLib, #name); \
	} \
	Assert(_##name); \
	} while(0, 0);

	#else
	#error Dynamic library loading not implemented in this OS yet
	#endif

	GLFUNCS_LIST

	#undef GLFUNC
	}

	// ---------------------------------------------------------------------------
	#define GL_INVALID_ENUM 0x0500
	#define GL_TEXTURE_2D 0x0DE1
	#define GL_RGBA 0x1908
	#define GL_UNSIGNED_BYTE 0x1401
	#define GL_TEXTURE_MAG_FILTER 0x2800
	#define GL_TEXTURE_MIN_FILTER 0x2801
	#define GL_NEAREST 0x2600
	#define GL_LINEAR 0x2601
	#define GL_TEXTURE_WRAP_S 0x2802
	#define GL_TEXTURE_WRAP_T 0x2803
	#define GL_CLAMP_TO_EDGE 0x812F
	#define GL_DEPTH_TEST 0x0B71
	#define GL_QUADS 0x0007
	#define GL_TRIANGLES 0x0004
	#define GL_VERTEX_ARRAY 0x8074
	#define GL_TEXTURE_COORD_ARRAY 0x8078
	#define GL_COLOR_ARRAY 0x8076
	#define GL_FLOAT 0x1406
	#define GL_SCISSOR_TEST 0x0C11
	#define GL_COLOR_BUFFER_BIT 0x00004000
	#define GL_DEPTH_BUFFER_BIT 0x00000100
	#define GL_FRAGMENT_SHADER 0x8B30
	#define GL_VERTEX_SHADER 0x8B31
	#define GL_COMPILE_STATUS 0x8B81
	#define GL_LINK_STATUS 0x8B82
	#define GL_INFO_LOG_LENGTH 0x8B84
	#define GL_ARRAY_BUFFER 0x8892
	#define GL_STATIC_DRAW 0x88E4
	#define GL_ELEMENT_ARRAY_BUFFER 0x8893
	#define GL_UNSIGNED_INT 0x1405
	#define GL_RED 0x1903
	#define GL_RG 0x8227
	#define GL_RGB 0x1907
	#define GL_DEPTH_COMPONENT16 0x81A5
	#define GL_DEPTH_COMPONENT 0x1902
	#define GL_FRAMEBUFFER 0x8D40
	#define GL_COLOR_ATTACHMENT0 0x8CE0
	#define GL_DEPTH_ATTACHMENT 0x8D00
	#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
	#define GL_BACK 0x0405
	#define GL_NONE 0
	#define GL_BLEND 0x0BE2
	#define GL_SRC_ALPHA 0x0302
	#define GL_ONE_MINUS_SRC_ALPHA 0x0303
	#define GL_MULTISAMPLE 0x809D
	#define GL_VERSION 0x1F02
	#define GL_VENDOR 0x1F00
	#define GL_RENDERER 0x1F01
	#define GL_FALSE 0
	#define GL_TRUE 1
	#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
	#define GL_FRONT_AND_BACK 0x0408
	#define GL_FILL 0x1B02
	#define GL_LINE 0x1B01

	#define GL_POLYGON_SMOOTH 0x0B41

	#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
	#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
	#define WGL_SUPPORT_OPENGL_ARB 0x2010
	#define WGL_DRAW_TO_WINDOW_ARB 0x2001
	#define WGL_ACCELERATION_ARB 0x2003
	#define WGL_FULL_ACCELERATION_ARB 0x2027
	#define WGL_COLOR_BITS_ARB 0x2014
	#define WGL_ALPHA_BITS_ARB 0x201B
	#define WGL_DEPTH_BITS_ARB 0x2022
	#define WGL_STENCIL_BITS_ARB 0x2023
	#define WGL_DOUBLE_BUFFER_ARB 0x2011
	#define WGL_SAMPLE_BUFFERS_ARB 0x2041
	#define WGL_SAMPLES_ARB 0x2042
	#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
	#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
	#define WGL_TYPE_RGBA_ARB 0x202B
	#define WGL_PIXEL_TYPE_ARB 0x2013

	const char *glErrNames[] = {
	"GL_INVALID_ENUM",
	"GL_INVALID_VALUE",
	"GL_INVALID_OPERATION",
	"###",
	"####",
	"GL_OUT_OF_MEMORY"};

	void checkGLErrFunc(const char *filename, int line) {
	int e = glGetError();
	if(e) {
	const char *errName = glErrNames[e - GL_INVALID_ENUM];
	printf("Error %s (%d): %s, line %d\n", errName, e, filename, line);
	Assert(0);
	}
	}

	// ---------------------------------------------------------------------------
	// ------ glGenTextures ------
	typedef void __stdcall glGenTexturesFunc(GLsizei, GLuint *);
	glGenTexturesFunc * _glGenTextures;

	void glGenTextures(GLsizei arg0, GLuint * arg1){
	_glGenTextures(arg0, arg1);
	GLERR();
	}

	// ------ glBindTexture ------
	typedef void __stdcall glBindTextureFunc(GLenum, GLuint);
	glBindTextureFunc * _glBindTexture;

	void glBindTexture(GLenum arg0, GLuint arg1){
	_glBindTexture(arg0, arg1);
	GLERR();
	}

	// ------ glTexImage2D ------
	typedef void __stdcall glTexImage2DFunc(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
	glTexImage2DFunc * _glTexImage2D;

	void glTexImage2D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLsizei arg4, GLint arg5, GLenum arg6, GLenum arg7, const GLvoid * arg8){
	_glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
	GLERR();
	}

	// ------ glTexParameteri ------
	typedef void __stdcall glTexParameteriFunc(GLenum, GLenum, GLint);
	glTexParameteriFunc * _glTexParameteri;

	void glTexParameteri(GLenum arg0, GLenum arg1, GLint arg2){
	_glTexParameteri(arg0, arg1, arg2);
	GLERR();
	}

	// ------ glGetError ------
	typedef GLenum __stdcall glGetErrorFunc();
	glGetErrorFunc * _glGetError;

	GLenum glGetError(){
	GLenum Result = _glGetError();
	return Result;
	}

	// ------ glEnable ------
	typedef void __stdcall glEnableFunc(GLenum);
	glEnableFunc * _glEnable;

	void glEnable(GLenum arg0){
	_glEnable(arg0);
	GLERR();
	}

	// ------ glDisable ------
	typedef void __stdcall glDisableFunc(GLenum);
	glDisableFunc * _glDisable;

	void glDisable(GLenum arg0){
	_glDisable(arg0);
	GLERR();
	}

	// ------ glBegin ------
	typedef void __stdcall glBeginFunc(GLenum);
	glBeginFunc * _glBegin;

	void glBegin(GLenum arg0){
	_glBegin(arg0);
	}

	// ------ glEnd ------
	typedef void __stdcall glEndFunc();
	glEndFunc * _glEnd;

	void glEnd(){
	_glEnd();
	GLERR();
	}

	// ------ glTexCoord2f ------
	typedef void __stdcall glTexCoord2fFunc(GLfloat, GLfloat);
	glTexCoord2fFunc * _glTexCoord2f;

	void glTexCoord2f(GLfloat arg0, GLfloat arg1){
	_glTexCoord2f(arg0, arg1);
	}

	// ------ glVertex2f ------
	typedef void __stdcall glVertex2fFunc(GLfloat, GLfloat);
	glVertex2fFunc * _glVertex2f;

	void glVertex2f(GLfloat arg0, GLfloat arg1){
	_glVertex2f(arg0, arg1);
	}

	// ------ glEnableClientState ------
	typedef void __stdcall glEnableClientStateFunc(GLenum);
	glEnableClientStateFunc * _glEnableClientState;

	void glEnableClientState(GLenum arg0){
	_glEnableClientState(arg0);
	GLERR();
	}

	// ------ glDisableClientState ------
	typedef void __stdcall glDisableClientStateFunc(GLenum);
	glDisableClientStateFunc * _glDisableClientState;

	void glDisableClientState(GLenum arg0){
	_glDisableClientState(arg0);
	GLERR();
	}

	// ------ glVertexPointer ------
	typedef void __stdcall glVertexPointerFunc(GLint, GLenum, GLsizei, const GLvoid *);
	glVertexPointerFunc * _glVertexPointer;

	void glVertexPointer(GLint arg0, GLenum arg1, GLsizei arg2, const GLvoid * arg3){
	_glVertexPointer(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glTexCoordPointer ------
	typedef void __stdcall glTexCoordPointerFunc(GLint, GLenum, GLsizei, const GLvoid *);
	glTexCoordPointerFunc * _glTexCoordPointer;

	void glTexCoordPointer(GLint arg0, GLenum arg1, GLsizei arg2, const GLvoid * arg3){
	_glTexCoordPointer(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glColorPointer ------
	typedef void __stdcall glColorPointerFunc(GLint, GLenum, GLsizei, const GLvoid *);
	glColorPointerFunc * _glColorPointer;

	void glColorPointer(GLint arg0, GLenum arg1, GLsizei arg2, const GLvoid * arg3){
	_glColorPointer(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glDrawArrays ------
	typedef void __stdcall glDrawArraysFunc(GLenum, GLint, GLsizei);
	glDrawArraysFunc * _glDrawArrays;

	void glDrawArrays(GLenum arg0, GLint arg1, GLsizei arg2){
	_glDrawArrays(arg0, arg1, arg2);
	GLERR();
	}

	// ------ glClearColor ------
	typedef void __stdcall glClearColorFunc(GLclampf, GLclampf, GLclampf, GLclampf);
	glClearColorFunc * _glClearColor;

	void glClearColor(GLclampf arg0, GLclampf arg1, GLclampf arg2, GLclampf arg3){
	_glClearColor(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glClear ------
	typedef void __stdcall glClearFunc(GLbitfield);
	glClearFunc * _glClear;

	void glClear(GLbitfield arg0){
	_glClear(arg0);
	GLERR();
	}

	// ------ glLinkProgram ------
	typedef void __stdcall glLinkProgramFunc(GLuint);
	glLinkProgramFunc * _glLinkProgram;

	void glLinkProgram(GLuint arg0){
	_glLinkProgram(arg0);
	GLERR();
	}

	// ------ glShaderSource ------
	typedef void __stdcall glShaderSourceFunc(GLuint, GLsizei, const GLchar * const , const GLint );
	glShaderSourceFunc * _glShaderSource;

	void glShaderSource(GLuint arg0, GLsizei arg1, const GLchar * const * arg2, const GLint * arg3){
	_glShaderSource(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glUseProgram ------
	typedef void __stdcall glUseProgramFunc(GLuint);
	glUseProgramFunc * _glUseProgram;

	void glUseProgram(GLuint arg0){
	_glUseProgram(arg0);
	GLERR();
	}

	// ------ glCompileShader ------
	typedef void __stdcall glCompileShaderFunc(GLuint);
	glCompileShaderFunc * _glCompileShader;

	void glCompileShader(GLuint arg0){
	_glCompileShader(arg0);
	GLERR();
	}

	// ------ glCreateProgram ------
	typedef GLuint __stdcall glCreateProgramFunc();
	glCreateProgramFunc * _glCreateProgram;

	GLuint glCreateProgram(){
	GLuint Result = _glCreateProgram();
	GLERR();
	return Result;
	}

	// ------ glCreateShader ------
	typedef GLuint __stdcall glCreateShaderFunc(GLenum);
	glCreateShaderFunc * _glCreateShader;

	GLuint glCreateShader(GLenum arg0){
	GLuint Result = _glCreateShader(arg0);
	GLERR();
	return Result;
	}

	// ------ glGetShaderiv ------
	typedef void __stdcall glGetShaderivFunc(GLuint, GLenum, GLint *);
	glGetShaderivFunc * _glGetShaderiv;

	void glGetShaderiv(GLuint arg0, GLenum arg1, GLint * arg2){
	_glGetShaderiv(arg0, arg1, arg2);
	GLERR();
	}

	// ------ glGetShaderInfoLog ------
	typedef void __stdcall glGetShaderInfoLogFunc(GLuint, GLsizei, GLsizei , GLchar );
	glGetShaderInfoLogFunc * _glGetShaderInfoLog;

	void glGetShaderInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3){
	_glGetShaderInfoLog(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glAttachShader ------
	typedef void __stdcall glAttachShaderFunc(GLuint, GLuint);
	glAttachShaderFunc * _glAttachShader;

	void glAttachShader(GLuint arg0, GLuint arg1){
	_glAttachShader(arg0, arg1);
	GLERR();
	}

	// ------ glGetProgramiv ------
	typedef void __stdcall glGetProgramivFunc(GLuint, GLenum, GLint *);
	glGetProgramivFunc * _glGetProgramiv;

	void glGetProgramiv(GLuint arg0, GLenum arg1, GLint * arg2){
	_glGetProgramiv(arg0, arg1, arg2);
	GLERR();
	}

	// ------ glGetProgramInfoLog ------
	typedef void __stdcall glGetProgramInfoLogFunc(GLuint, GLsizei, GLsizei , GLchar );
	glGetProgramInfoLogFunc * _glGetProgramInfoLog;

	void glGetProgramInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3){
	_glGetProgramInfoLog(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glGetUniformLocation ------
	typedef GLint __stdcall glGetUniformLocationFunc(GLuint, const GLchar *);
	glGetUniformLocationFunc * _glGetUniformLocation;

	GLint glGetUniformLocation(GLuint arg0, const GLchar * arg1){
	GLint Result = _glGetUniformLocation(arg0, arg1);
	GLERR();
	return Result;
	}

	// ------ glUniform1i ------
	typedef void __stdcall glUniform1iFunc(GLint, GLint);
	glUniform1iFunc * _glUniform1i;

	void glUniform1i(GLint arg0, GLint arg1){
	_glUniform1i(arg0, arg1);
	GLERR();
	}

	// ------ glGenBuffers ------
	typedef void __stdcall glGenBuffersFunc(GLsizei, GLuint *);
	glGenBuffersFunc * _glGenBuffers;

	void glGenBuffers(GLsizei arg0, GLuint * arg1){
	_glGenBuffers(arg0, arg1);
	GLERR();
	}

	// ------ glBindBuffer ------
	typedef void __stdcall glBindBufferFunc(GLenum, GLuint);
	glBindBufferFunc * _glBindBuffer;

	void glBindBuffer(GLenum arg0, GLuint arg1){
	_glBindBuffer(arg0, arg1);
	GLERR();
	}

	// ------ glBufferData ------
	typedef void __stdcall glBufferDataFunc(GLenum, GLsizeiptr, const void *, GLenum);
	glBufferDataFunc * _glBufferData;

	void glBufferData(GLenum arg0, GLsizeiptr arg1, const void * arg2, GLenum arg3){
	_glBufferData(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glVertexAttribPointer ------
	typedef void __stdcall glVertexAttribPointerFunc(GLuint, GLint, GLenum, GLboolean, GLsizei, const void *);
	glVertexAttribPointerFunc * _glVertexAttribPointer;

	void glVertexAttribPointer(GLuint arg0, GLint arg1, GLenum arg2, GLboolean arg3, GLsizei arg4, const void * arg5){
	_glVertexAttribPointer(arg0, arg1, arg2, arg3, arg4, arg5);
	GLERR();
	}

	// ------ glEnableVertexAttribArray ------
	typedef void __stdcall glEnableVertexAttribArrayFunc(GLuint);
	glEnableVertexAttribArrayFunc * _glEnableVertexAttribArray;

	void glEnableVertexAttribArray(GLuint arg0){
	_glEnableVertexAttribArray(arg0);
	GLERR();
	}

	// ------ glUniformMatrix4fv ------
	typedef void __stdcall glUniformMatrix4fvFunc(GLint, GLsizei, GLboolean, const GLfloat *);
	glUniformMatrix4fvFunc * _glUniformMatrix4fv;

	void glUniformMatrix4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3){
	_glUniformMatrix4fv(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glDrawElements ------
	typedef void __stdcall glDrawElementsFunc(GLenum, GLsizei, GLenum, const void *);
	glDrawElementsFunc * _glDrawElements;

	void glDrawElements(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3){
	_glDrawElements(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glDisableVertexAttribArray ------
	typedef void __stdcall glDisableVertexAttribArrayFunc(GLuint);
	glDisableVertexAttribArrayFunc * _glDisableVertexAttribArray;

	void glDisableVertexAttribArray(GLuint arg0){
	_glDisableVertexAttribArray(arg0);
	GLERR();
	}

	// ------ glGenFramebuffers ------
	typedef void __stdcall glGenFramebuffersFunc(GLsizei, GLuint *);
	glGenFramebuffersFunc * _glGenFramebuffers;

	void glGenFramebuffers(GLsizei arg0, GLuint * arg1){
	_glGenFramebuffers(arg0, arg1);
	GLERR();
	}

	// ------ glBindFramebuffer ------
	typedef void __stdcall glBindFramebufferFunc(GLenum, GLuint);
	glBindFramebufferFunc * _glBindFramebuffer;

	void glBindFramebuffer(GLenum arg0, GLuint arg1){
	_glBindFramebuffer(arg0, arg1);
	GLERR();
	}

	// ------ glFramebufferTexture2D ------
	typedef void __stdcall glFramebufferTexture2DFunc(GLenum, GLenum, GLenum, GLuint, GLint);
	glFramebufferTexture2DFunc * _glFramebufferTexture2D;

	void glFramebufferTexture2D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4){
	_glFramebufferTexture2D(arg0, arg1, arg2, arg3, arg4);
	GLERR();
	}

	// ------ glCheckFramebufferStatus ------
	typedef GLenum __stdcall glCheckFramebufferStatusFunc(GLenum);
	glCheckFramebufferStatusFunc * _glCheckFramebufferStatus;

	GLenum glCheckFramebufferStatus(GLenum arg0){
	GLenum Result = _glCheckFramebufferStatus(arg0);
	GLERR();
	return Result;
	}

	// ------ glDeleteFramebuffers ------
	typedef void __stdcall glDeleteFramebuffersFunc(GLsizei, const GLuint *);
	glDeleteFramebuffersFunc * _glDeleteFramebuffers;

	void glDeleteFramebuffers(GLsizei arg0, const GLuint * arg1){
	_glDeleteFramebuffers(arg0, arg1);
	GLERR();
	}

	// ------ glDeleteTextures ------
	typedef void __stdcall glDeleteTexturesFunc(GLsizei, const GLuint *);
	glDeleteTexturesFunc * _glDeleteTextures;

	void glDeleteTextures(GLsizei arg0, const GLuint * arg1){
	_glDeleteTextures(arg0, arg1);
	GLERR();
	}

	// ------ glDrawBuffer ------
	typedef void __stdcall glDrawBufferFunc(GLenum);
	glDrawBufferFunc * _glDrawBuffer;

	void glDrawBuffer(GLenum arg0){
	_glDrawBuffer(arg0);
	GLERR();
	}

	// ------ glBlendFunc ------
	typedef void __stdcall glBlendFuncFunc(GLenum, GLenum);
	glBlendFuncFunc * _glBlendFunc;

	void glBlendFunc(GLenum arg0, GLenum arg1){
	_glBlendFunc(arg0, arg1);
	GLERR();
	}

	// ------ glScissor ------
	typedef void __stdcall glScissorFunc(GLint, GLint, GLsizei, GLsizei);
	glScissorFunc * _glScissor;

	void glScissor(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3){
	_glScissor(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glViewport ------
	typedef void __stdcall glViewportFunc(GLint, GLint, GLsizei, GLsizei);
	glViewportFunc * _glViewport;

	void glViewport(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3){
	_glViewport(arg0, arg1, arg2, arg3);
	GLERR();
	}

	// ------ glGetString ------
	typedef const GLubyte * __stdcall glGetStringFunc(GLenum);
	glGetStringFunc * _glGetString;

	const GLubyte * glGetString(GLenum arg0){
	const GLubyte * Result = _glGetString(arg0);
	GLERR();
	return Result;
	}

	// ------ glPolygonMode ------
	typedef void __stdcall glPolygonModeFunc(GLenum, GLenum);
	glPolygonModeFunc * _glPolygonMode;

	void glPolygonMode(GLenum arg0, GLenum arg1){
	_glPolygonMode(arg0, arg1);
	GLERR();
	}

	// ------ wglChoosePixelFormatARB ------
	typedef BOOL __stdcall wglChoosePixelFormatARBFunc(HDC, const int , const FLOAT , UINT, int , UINT );
	wglChoosePixelFormatARBFunc * _wglChoosePixelFormatARB;

	BOOL wglChoosePixelFormatARB(HDC arg0, const int * arg1, const FLOAT * arg2, UINT arg3, int * arg4, UINT * arg5){
	BOOL Result = _wglChoosePixelFormatARB(arg0, arg1, arg2, arg3, arg4, arg5);
	GLERR();
	return Result;
	}

	// ------ wglCreateContextAttribsARB ------
	typedef HGLRC __stdcall wglCreateContextAttribsARBFunc(HDC, HGLRC, const int *);
	wglCreateContextAttribsARBFunc * _wglCreateContextAttribsARB;

	HGLRC wglCreateContextAttribsARB(HDC arg0, HGLRC arg1, const int * arg2){
	HGLRC Result = _wglCreateContextAttribsARB(arg0, arg1, arg2);
	return Result;
	}

	// ------ wglSwapIntervalEXT ------
	typedef BOOL __stdcall wglSwapIntervalEXTFunc(i32);
	wglSwapIntervalEXTFunc * _wglSwapIntervalEXT;

	BOOL wglSwapIntervalEXT(i32 arg0){
	BOOL Result = _wglSwapIntervalEXT(arg0);
	GLERR();
	return Result;
	}