internal.h

Go to the documentation of this file.

//========================================================================
// GLFW 3.1 - www.glfw.org
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would
//    be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
//    be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
//    distribution.
//
//========================================================================

#ifndef _glfw3_internal_h_
#define _glfw3_internal_h_


#if defined(_GLFW_USE_CONFIG_H)
 #include "glfw_config.h"
#endif

#define _GLFW_VERSION_NUMBER "3.1.2"

#if defined(GLFW_INCLUDE_GLCOREARB) || \
    defined(GLFW_INCLUDE_ES1)       || \
    defined(GLFW_INCLUDE_ES2)       || \
    defined(GLFW_INCLUDE_ES3)       || \
    defined(GLFW_INCLUDE_NONE)      || \
    defined(GLFW_INCLUDE_GLEXT)     || \
    defined(GLFW_INCLUDE_GLU)       || \
    defined(GLFW_DLL)
 #error "You may not define any header option macros when compiling GLFW"
#endif

#if defined(_GLFW_USE_OPENGL)
 // This is the default for glfw3.h
#elif defined(_GLFW_USE_GLESV1)
 #define GLFW_INCLUDE_ES1
#elif defined(_GLFW_USE_GLESV2)
 #define GLFW_INCLUDE_ES2
#else
 #error "No supported client library selected"
#endif

// Disable the inclusion of the platform glext.h by gl.h to allow proper
// inclusion of our own, newer glext.h below
#define GL_GLEXT_LEGACY

#include "../include/GLFW/glfw3.h"

#if defined(_GLFW_USE_OPENGL)
 // This path may need to be changed if you build GLFW using your own setup
 // GLFW comes with its own copy of glext.h since it uses fairly new extensions
 // and not all development environments come with an up-to-date version
 #include "../deps/GL/glext.h"
#endif

typedef void (APIENTRY * PFNGLCLEARPROC)(GLbitfield);
typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGPROC)(GLenum);
typedef void (APIENTRY * PFNGLGETINTEGERVPROC)(GLenum,GLint*);

typedef struct _GLFWwndconfig   _GLFWwndconfig;
typedef struct _GLFWctxconfig   _GLFWctxconfig;
typedef struct _GLFWfbconfig    _GLFWfbconfig;
typedef struct _GLFWwindow      _GLFWwindow;
typedef struct _GLFWlibrary     _GLFWlibrary;
typedef struct _GLFWmonitor     _GLFWmonitor;
typedef struct _GLFWcursor      _GLFWcursor;

#if defined(_GLFW_COCOA)
 #include "cocoa_platform.h"
#elif defined(_GLFW_WIN32)
 #include "win32_platform.h"
#elif defined(_GLFW_X11)
 #include "x11_platform.h"
#elif defined(_GLFW_WAYLAND)
 #include "wl_platform.h"
#elif defined(_GLFW_MIR)
 #include "mir_platform.h"
#else
 #error "No supported window creation API selected"
#endif


//========================================================================
// Doxygen group definitions
//========================================================================

//========================================================================
// Helper macros
//========================================================================

// Checks for whether the library has been initialized
#define _GLFW_REQUIRE_INIT()                         \
    if (!_glfwInitialized)                           \
    {                                                \
        _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
        return;                                      \
    }
#define _GLFW_REQUIRE_INIT_OR_RETURN(x)              \
    if (!_glfwInitialized)                           \
    {                                                \
        _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
        return x;                                    \
    }

// Swaps the provided pointers
#define _GLFW_SWAP_POINTERS(x, y) \
    {                             \
        void* t;                  \
        t = x;                    \
        x = y;                    \
        y = t;                    \
    }


//========================================================================
// Platform-independent structures
//========================================================================

struct _GLFWwndconfig
{
    int           width;
    int           height;
    const char*   title;
    GLboolean     resizable;
    GLboolean     visible;
    GLboolean     decorated;
    GLboolean     focused;
    GLboolean     autoIconify;
    GLboolean     floating;
    _GLFWmonitor* monitor;
};


struct _GLFWctxconfig
{
    int           api;
    int           major;
    int           minor;
    GLboolean     forward;
    GLboolean     debug;
    int           profile;
    int           robustness;
    int           release;
    _GLFWwindow*  share;
};


struct _GLFWfbconfig
{
    int         redBits;
    int         greenBits;
    int         blueBits;
    int         alphaBits;
    int         depthBits;
    int         stencilBits;
    int         accumRedBits;
    int         accumGreenBits;
    int         accumBlueBits;
    int         accumAlphaBits;
    int         auxBuffers;
    int         stereo;
    int         samples;
    int         sRGB;
    int         doublebuffer;

    // This is defined in the context API's context.h
    _GLFW_PLATFORM_FBCONFIG;
};


struct _GLFWwindow
{
    struct _GLFWwindow* next;

    // Window settings and state
    GLboolean           resizable;
    GLboolean           decorated;
    GLboolean           autoIconify;
    GLboolean           floating;
    GLboolean           closed;
    void*               userPointer;
    GLFWvidmode         videoMode;
    _GLFWmonitor*       monitor;
    _GLFWcursor*        cursor;

    // Window input state
    GLboolean           stickyKeys;
    GLboolean           stickyMouseButtons;
    double              cursorPosX, cursorPosY;
    int                 cursorMode;
    char                mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1];
    char                keys[GLFW_KEY_LAST + 1];

    // OpenGL extensions and context attributes
    struct {
        int             api;
        int             major, minor, revision;
        GLboolean       forward, debug;
        int             profile;
        int             robustness;
        int             release;
    } context;

#if defined(_GLFW_USE_OPENGL)
    PFNGLGETSTRINGIPROC GetStringi;
#endif
    PFNGLGETINTEGERVPROC GetIntegerv;
    PFNGLGETSTRINGPROC  GetString;
    PFNGLCLEARPROC      Clear;

    struct {
        GLFWwindowposfun        pos;
        GLFWwindowsizefun       size;
        GLFWwindowclosefun      close;
        GLFWwindowrefreshfun    refresh;
        GLFWwindowfocusfun      focus;
        GLFWwindowiconifyfun    iconify;
        GLFWframebuffersizefun  fbsize;
        GLFWmousebuttonfun      mouseButton;
        GLFWcursorposfun        cursorPos;
        GLFWcursorenterfun      cursorEnter;
        GLFWscrollfun           scroll;
        GLFWkeyfun              key;
        GLFWcharfun             character;
        GLFWcharmodsfun         charmods;
        GLFWdropfun             drop;
    } callbacks;

    // This is defined in the window API's platform.h
    _GLFW_PLATFORM_WINDOW_STATE;
    // This is defined in the context API's context.h
    _GLFW_PLATFORM_CONTEXT_STATE;
};


struct _GLFWmonitor
{
    char*           name;

    // Physical dimensions in millimeters.
    int             widthMM, heightMM;

    GLFWvidmode*    modes;
    int             modeCount;
    GLFWvidmode     currentMode;

    GLFWgammaramp   originalRamp;
    GLFWgammaramp   currentRamp;

    // This is defined in the window API's platform.h
    _GLFW_PLATFORM_MONITOR_STATE;
};


struct _GLFWcursor
{
    _GLFWcursor*    next;

    // This is defined in the window API's platform.h
    _GLFW_PLATFORM_CURSOR_STATE;
};

struct _GLFWlibrary
{
    struct {
        _GLFWfbconfig   framebuffer;
        _GLFWwndconfig  window;
        _GLFWctxconfig  context;
        int             refreshRate;
    } hints;

    double              cursorPosX, cursorPosY;

    _GLFWcursor*        cursorListHead;

    _GLFWwindow*        windowListHead;
    _GLFWwindow*        cursorWindow;

    _GLFWmonitor**      monitors;
    int                 monitorCount;

    struct {
        GLFWmonitorfun  monitor;
    } callbacks;

    // This is defined in the window API's platform.h
    _GLFW_PLATFORM_LIBRARY_WINDOW_STATE;
    // This is defined in the context API's context.h
    _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE;
    // This is defined in the platform's time.h
    _GLFW_PLATFORM_LIBRARY_TIME_STATE;
    // This is defined in the platform's joystick.h
    _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE;
    // This is defined in the platform's tls.h
    _GLFW_PLATFORM_LIBRARY_TLS_STATE;
};


//========================================================================
// Global state shared between compilation units of GLFW
//========================================================================

extern GLboolean _glfwInitialized;

extern _GLFWlibrary _glfw;


//========================================================================
// Platform API functions
//========================================================================

int _glfwPlatformInit(void);

void _glfwPlatformTerminate(void);

const char* _glfwPlatformGetVersionString(void);

void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos);

void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos);

void _glfwPlatformApplyCursorMode(_GLFWwindow* window);

_GLFWmonitor** _glfwPlatformGetMonitors(int* count);

GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second);

void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos);

GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count);

void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);

void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);

void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);

void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string);

const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);

int _glfwPlatformJoystickPresent(int joy);

const float* _glfwPlatformGetJoystickAxes(int joy, int* count);

const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count);

const char* _glfwPlatformGetJoystickName(int joy);

double _glfwPlatformGetTime(void);

void _glfwPlatformSetTime(double time);

int _glfwPlatformCreateWindow(_GLFWwindow* window,
                              const _GLFWwndconfig* wndconfig,
                              const _GLFWctxconfig* ctxconfig,
                              const _GLFWfbconfig* fbconfig);

void _glfwPlatformDestroyWindow(_GLFWwindow* window);

void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);

void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos);

void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos);

void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height);

void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height);

void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height);

void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window, int* left, int* top, int* right, int* bottom);

void _glfwPlatformIconifyWindow(_GLFWwindow* window);

void _glfwPlatformRestoreWindow(_GLFWwindow* window);

void _glfwPlatformShowWindow(_GLFWwindow* window);

void _glfwPlatformUnhideWindow(_GLFWwindow* window);

void _glfwPlatformHideWindow(_GLFWwindow* window);

int _glfwPlatformWindowFocused(_GLFWwindow* window);

int _glfwPlatformWindowIconified(_GLFWwindow* window);

int _glfwPlatformWindowVisible(_GLFWwindow* window);

void _glfwPlatformPollEvents(void);

void _glfwPlatformWaitEvents(void);

void _glfwPlatformPostEmptyEvent(void);

void _glfwPlatformMakeContextCurrent(_GLFWwindow* window);

_GLFWwindow* _glfwPlatformGetCurrentContext(void);

void _glfwPlatformSwapBuffers(_GLFWwindow* window);

void _glfwPlatformSwapInterval(int interval);

int _glfwPlatformExtensionSupported(const char* extension);

GLFWglproc _glfwPlatformGetProcAddress(const char* procname);

int _glfwPlatformCreateCursor(_GLFWcursor* cursor, const GLFWimage* image, int xhot, int yhot);

int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape);

void _glfwPlatformDestroyCursor(_GLFWcursor* cursor);

void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);


//========================================================================
// Event API functions
//========================================================================

void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused);

void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);

void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);

void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);

void _glfwInputWindowIconify(_GLFWwindow* window, int iconified);

void _glfwInputWindowDamage(_GLFWwindow* window);

void _glfwInputWindowCloseRequest(_GLFWwindow* window);

void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods);

void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, int plain);

void _glfwInputScroll(_GLFWwindow* window, double x, double y);

void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods);

void _glfwInputCursorMotion(_GLFWwindow* window, double x, double y);

void _glfwInputCursorEnter(_GLFWwindow* window, int entered);

void _glfwInputMonitorChange(void);

void _glfwInputError(int error, const char* format, ...);

void _glfwInputDrop(_GLFWwindow* window, int count, const char** names);


//========================================================================
// Utility functions
//========================================================================

const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
                                        const GLFWvidmode* desired);

int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second);

void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);

int _glfwStringInExtensionString(const char* string, const char* extensions);

const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
                                         const _GLFWfbconfig* alternatives,
                                         unsigned int count);

GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig);

GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);

GLboolean _glfwIsValidContext(const _GLFWctxconfig* ctxconfig);

void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);

void _glfwFreeGammaArrays(GLFWgammaramp* ramp);

_GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM);

void _glfwFreeMonitor(_GLFWmonitor* monitor);

void _glfwFreeMonitors(_GLFWmonitor** monitors, int count);

#endif // _glfw3_internal_h_