vino/rocket
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added glfw 2.7.7

Browse Source
This commit is contained in:
Daniel Collin 2012-11-23 17:49:44 +01:00
parent 081cb8cd3e
commit 1e63fbb9f2
65 changed files with 22112 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

518
ogl_editor/src/External/glfw/include/GL/glfw.h vendored Normal file
View File

@ -0,0 +1,518 @@
/************************************************************************
* GLFW - An OpenGL framework
* API version: 2.7
* WWW: http://www.glfw.org/
*------------------------------------------------------------------------
* Copyright (c) 2002-2006 Marcus Geelnard
* Copyright (c) 2006-2010 Camilla Berglund
*
* 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 __glfw_h_
#define __glfw_h_
#ifdef __cplusplus
extern "C" {
#endif
/*************************************************************************
* Global definitions
*************************************************************************/
/* We need a NULL pointer from time to time */
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif /* NULL */
/* ------------------- BEGIN SYSTEM/COMPILER SPECIFIC -------------------- */
/* Please report any probles that you find with your compiler, which may
* be solved in this section! There are several compilers that I have not
* been able to test this file with yet.
*
* First: If we are we on Windows, we want a single define for it (_WIN32)
* (Note: For Cygwin the compiler flag -mwin32 should be used, but to
* make sure that things run smoothly for Cygwin users, we add __CYGWIN__
* to the list of "valid Win32 identifiers", which removes the need for
* -mwin32)
*/
#if !defined(_WIN32) && (defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__))
#define _WIN32
#endif /* _WIN32 */
/* In order for extension support to be portable, we need to define an
* OpenGL function call method. We use the keyword APIENTRY, which is
* defined for Win32. (Note: Windows also needs this for <GL/gl.h>)
*/
#ifndef APIENTRY
#ifdef _WIN32
#define APIENTRY __stdcall
#else
#define APIENTRY
#endif
#define GL_APIENTRY_DEFINED
#endif /* APIENTRY */
/* The following three defines are here solely to make some Windows-based
* <GL/gl.h> files happy. Theoretically we could include <windows.h>, but
* it has the major drawback of severely polluting our namespace.
*/
/* Under Windows, we need WINGDIAPI defined */
#if !defined(WINGDIAPI) && defined(_WIN32)
#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__POCC__)
/* Microsoft Visual C++, Borland C++ Builder and Pelles C */
#define WINGDIAPI __declspec(dllimport)
#elif defined(__LCC__)
/* LCC-Win32 */
#define WINGDIAPI __stdcall
#else
/* Others (e.g. MinGW, Cygwin) */
#define WINGDIAPI extern
#endif
#define GL_WINGDIAPI_DEFINED
#endif /* WINGDIAPI */
/* Some <GL/glu.h> files also need CALLBACK defined */
#if !defined(CALLBACK) && defined(_WIN32)
#if defined(_MSC_VER)
/* Microsoft Visual C++ */
#if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
#define CALLBACK __stdcall
#else
#define CALLBACK
#endif
#else
/* Other Windows compilers */
#define CALLBACK __stdcall
#endif
#define GLU_CALLBACK_DEFINED
#endif /* CALLBACK */
/* Microsoft Visual C++, Borland C++ and Pelles C <GL*glu.h> needs wchar_t */
#if defined(_WIN32) && (defined(_MSC_VER) || defined(__BORLANDC__) || defined(__POCC__)) && !defined(_WCHAR_T_DEFINED)
typedef unsigned short wchar_t;
#define _WCHAR_T_DEFINED
#endif /* _WCHAR_T_DEFINED */
/* ---------------- GLFW related system specific defines ----------------- */
#if defined(_WIN32) && defined(GLFW_BUILD_DLL)
/* We are building a Win32 DLL */
#define GLFWAPI __declspec(dllexport)
#define GLFWAPIENTRY __stdcall
#define GLFWCALL __stdcall
#elif defined(_WIN32) && defined(GLFW_DLL)
/* We are calling a Win32 DLL */
#if defined(__LCC__)
#define GLFWAPI extern
#else
#define GLFWAPI __declspec(dllimport)
#endif
#define GLFWAPIENTRY __stdcall
#define GLFWCALL __stdcall
#else
/* We are either building/calling a static lib or we are non-win32 */
#define GLFWAPIENTRY
#define GLFWAPI
#define GLFWCALL
#endif
/* -------------------- END SYSTEM/COMPILER SPECIFIC --------------------- */
/* Include standard OpenGL headers: GLFW uses GL_FALSE/GL_TRUE, and it is
* convenient for the user to only have to include <GL/glfw.h>. This also
* solves the problem with Windows <GL/gl.h> and <GL/glu.h> needing some
* special defines which normally requires the user to include <windows.h>
* (which is not a nice solution for portable programs).
*/
#if defined(__APPLE_CC__)
#if defined(GLFW_INCLUDE_GL3)
#include <OpenGL/gl3.h>
#else
#define GL_GLEXT_LEGACY
#include <OpenGL/gl.h>
#endif
#ifndef GLFW_NO_GLU
#include <OpenGL/glu.h>
#endif
#else
#if defined(GLFW_INCLUDE_GL3)
#include <GL3/gl3.h>
#else
#include <GL/gl.h>
#endif
#ifndef GLFW_NO_GLU
#include <GL/glu.h>
#endif
#endif
/*************************************************************************
* GLFW version
*************************************************************************/
#define GLFW_VERSION_MAJOR 2
#define GLFW_VERSION_MINOR 7
#define GLFW_VERSION_REVISION 7
/*************************************************************************
* Input handling definitions
*************************************************************************/
/* Key and button state/action definitions */
#define GLFW_RELEASE 0
#define GLFW_PRESS 1
/* Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used
* for printable keys (such as A-Z, 0-9 etc), and values above 256
* represent special (non-printable) keys (e.g. F1, Page Up etc).
*/
#define GLFW_KEY_UNKNOWN -1
#define GLFW_KEY_SPACE 32
#define GLFW_KEY_SPECIAL 256
#define GLFW_KEY_ESC (GLFW_KEY_SPECIAL+1)
#define GLFW_KEY_F1 (GLFW_KEY_SPECIAL+2)
#define GLFW_KEY_F2 (GLFW_KEY_SPECIAL+3)
#define GLFW_KEY_F3 (GLFW_KEY_SPECIAL+4)
#define GLFW_KEY_F4 (GLFW_KEY_SPECIAL+5)
#define GLFW_KEY_F5 (GLFW_KEY_SPECIAL+6)
#define GLFW_KEY_F6 (GLFW_KEY_SPECIAL+7)
#define GLFW_KEY_F7 (GLFW_KEY_SPECIAL+8)
#define GLFW_KEY_F8 (GLFW_KEY_SPECIAL+9)
#define GLFW_KEY_F9 (GLFW_KEY_SPECIAL+10)
#define GLFW_KEY_F10 (GLFW_KEY_SPECIAL+11)
#define GLFW_KEY_F11 (GLFW_KEY_SPECIAL+12)
#define GLFW_KEY_F12 (GLFW_KEY_SPECIAL+13)
#define GLFW_KEY_F13 (GLFW_KEY_SPECIAL+14)
#define GLFW_KEY_F14 (GLFW_KEY_SPECIAL+15)
#define GLFW_KEY_F15 (GLFW_KEY_SPECIAL+16)
#define GLFW_KEY_F16 (GLFW_KEY_SPECIAL+17)
#define GLFW_KEY_F17 (GLFW_KEY_SPECIAL+18)
#define GLFW_KEY_F18 (GLFW_KEY_SPECIAL+19)
#define GLFW_KEY_F19 (GLFW_KEY_SPECIAL+20)
#define GLFW_KEY_F20 (GLFW_KEY_SPECIAL+21)
#define GLFW_KEY_F21 (GLFW_KEY_SPECIAL+22)
#define GLFW_KEY_F22 (GLFW_KEY_SPECIAL+23)
#define GLFW_KEY_F23 (GLFW_KEY_SPECIAL+24)
#define GLFW_KEY_F24 (GLFW_KEY_SPECIAL+25)
#define GLFW_KEY_F25 (GLFW_KEY_SPECIAL+26)
#define GLFW_KEY_UP (GLFW_KEY_SPECIAL+27)
#define GLFW_KEY_DOWN (GLFW_KEY_SPECIAL+28)
#define GLFW_KEY_LEFT (GLFW_KEY_SPECIAL+29)
#define GLFW_KEY_RIGHT (GLFW_KEY_SPECIAL+30)
#define GLFW_KEY_LSHIFT (GLFW_KEY_SPECIAL+31)
#define GLFW_KEY_RSHIFT (GLFW_KEY_SPECIAL+32)
#define GLFW_KEY_LCTRL (GLFW_KEY_SPECIAL+33)
#define GLFW_KEY_RCTRL (GLFW_KEY_SPECIAL+34)
#define GLFW_KEY_LALT (GLFW_KEY_SPECIAL+35)
#define GLFW_KEY_RALT (GLFW_KEY_SPECIAL+36)
#define GLFW_KEY_TAB (GLFW_KEY_SPECIAL+37)
#define GLFW_KEY_ENTER (GLFW_KEY_SPECIAL+38)
#define GLFW_KEY_BACKSPACE (GLFW_KEY_SPECIAL+39)
#define GLFW_KEY_INSERT (GLFW_KEY_SPECIAL+40)
#define GLFW_KEY_DEL (GLFW_KEY_SPECIAL+41)
#define GLFW_KEY_PAGEUP (GLFW_KEY_SPECIAL+42)
#define GLFW_KEY_PAGEDOWN (GLFW_KEY_SPECIAL+43)
#define GLFW_KEY_HOME (GLFW_KEY_SPECIAL+44)
#define GLFW_KEY_END (GLFW_KEY_SPECIAL+45)
#define GLFW_KEY_KP_0 (GLFW_KEY_SPECIAL+46)
#define GLFW_KEY_KP_1 (GLFW_KEY_SPECIAL+47)
#define GLFW_KEY_KP_2 (GLFW_KEY_SPECIAL+48)
#define GLFW_KEY_KP_3 (GLFW_KEY_SPECIAL+49)
#define GLFW_KEY_KP_4 (GLFW_KEY_SPECIAL+50)
#define GLFW_KEY_KP_5 (GLFW_KEY_SPECIAL+51)
#define GLFW_KEY_KP_6 (GLFW_KEY_SPECIAL+52)
#define GLFW_KEY_KP_7 (GLFW_KEY_SPECIAL+53)
#define GLFW_KEY_KP_8 (GLFW_KEY_SPECIAL+54)
#define GLFW_KEY_KP_9 (GLFW_KEY_SPECIAL+55)
#define GLFW_KEY_KP_DIVIDE (GLFW_KEY_SPECIAL+56)
#define GLFW_KEY_KP_MULTIPLY (GLFW_KEY_SPECIAL+57)
#define GLFW_KEY_KP_SUBTRACT (GLFW_KEY_SPECIAL+58)
#define GLFW_KEY_KP_ADD (GLFW_KEY_SPECIAL+59)
#define GLFW_KEY_KP_DECIMAL (GLFW_KEY_SPECIAL+60)
#define GLFW_KEY_KP_EQUAL (GLFW_KEY_SPECIAL+61)
#define GLFW_KEY_KP_ENTER (GLFW_KEY_SPECIAL+62)
#define GLFW_KEY_KP_NUM_LOCK (GLFW_KEY_SPECIAL+63)
#define GLFW_KEY_CAPS_LOCK (GLFW_KEY_SPECIAL+64)
#define GLFW_KEY_SCROLL_LOCK (GLFW_KEY_SPECIAL+65)
#define GLFW_KEY_PAUSE (GLFW_KEY_SPECIAL+66)
#define GLFW_KEY_LSUPER (GLFW_KEY_SPECIAL+67)
#define GLFW_KEY_RSUPER (GLFW_KEY_SPECIAL+68)
#define GLFW_KEY_MENU (GLFW_KEY_SPECIAL+69)
#define GLFW_KEY_LAST GLFW_KEY_MENU
/* Mouse button definitions */
#define GLFW_MOUSE_BUTTON_1 0
#define GLFW_MOUSE_BUTTON_2 1
#define GLFW_MOUSE_BUTTON_3 2
#define GLFW_MOUSE_BUTTON_4 3
#define GLFW_MOUSE_BUTTON_5 4
#define GLFW_MOUSE_BUTTON_6 5
#define GLFW_MOUSE_BUTTON_7 6
#define GLFW_MOUSE_BUTTON_8 7
#define GLFW_MOUSE_BUTTON_LAST GLFW_MOUSE_BUTTON_8
/* Mouse button aliases */
#define GLFW_MOUSE_BUTTON_LEFT GLFW_MOUSE_BUTTON_1
#define GLFW_MOUSE_BUTTON_RIGHT GLFW_MOUSE_BUTTON_2
#define GLFW_MOUSE_BUTTON_MIDDLE GLFW_MOUSE_BUTTON_3
/* Joystick identifiers */
#define GLFW_JOYSTICK_1 0
#define GLFW_JOYSTICK_2 1
#define GLFW_JOYSTICK_3 2
#define GLFW_JOYSTICK_4 3
#define GLFW_JOYSTICK_5 4
#define GLFW_JOYSTICK_6 5
#define GLFW_JOYSTICK_7 6
#define GLFW_JOYSTICK_8 7
#define GLFW_JOYSTICK_9 8
#define GLFW_JOYSTICK_10 9
#define GLFW_JOYSTICK_11 10
#define GLFW_JOYSTICK_12 11
#define GLFW_JOYSTICK_13 12
#define GLFW_JOYSTICK_14 13
#define GLFW_JOYSTICK_15 14
#define GLFW_JOYSTICK_16 15
#define GLFW_JOYSTICK_LAST GLFW_JOYSTICK_16
/*************************************************************************
* Other definitions
*************************************************************************/
/* glfwOpenWindow modes */
#define GLFW_WINDOW 0x00010001
#define GLFW_FULLSCREEN 0x00010002
/* glfwGetWindowParam tokens */
#define GLFW_OPENED 0x00020001
#define GLFW_ACTIVE 0x00020002
#define GLFW_ICONIFIED 0x00020003
#define GLFW_ACCELERATED 0x00020004
#define GLFW_RED_BITS 0x00020005
#define GLFW_GREEN_BITS 0x00020006
#define GLFW_BLUE_BITS 0x00020007
#define GLFW_ALPHA_BITS 0x00020008
#define GLFW_DEPTH_BITS 0x00020009
#define GLFW_STENCIL_BITS 0x0002000A
/* The following constants are used for both glfwGetWindowParam
* and glfwOpenWindowHint
*/
#define GLFW_REFRESH_RATE 0x0002000B
#define GLFW_ACCUM_RED_BITS 0x0002000C
#define GLFW_ACCUM_GREEN_BITS 0x0002000D
#define GLFW_ACCUM_BLUE_BITS 0x0002000E
#define GLFW_ACCUM_ALPHA_BITS 0x0002000F
#define GLFW_AUX_BUFFERS 0x00020010
#define GLFW_STEREO 0x00020011
#define GLFW_WINDOW_NO_RESIZE 0x00020012
#define GLFW_FSAA_SAMPLES 0x00020013
#define GLFW_OPENGL_VERSION_MAJOR 0x00020014
#define GLFW_OPENGL_VERSION_MINOR 0x00020015
#define GLFW_OPENGL_FORWARD_COMPAT 0x00020016
#define GLFW_OPENGL_DEBUG_CONTEXT 0x00020017
#define GLFW_OPENGL_PROFILE 0x00020018
/* GLFW_OPENGL_PROFILE tokens */
#define GLFW_OPENGL_CORE_PROFILE 0x00050001
#define GLFW_OPENGL_COMPAT_PROFILE 0x00050002
/* glfwEnable/glfwDisable tokens */
#define GLFW_MOUSE_CURSOR 0x00030001
#define GLFW_STICKY_KEYS 0x00030002
#define GLFW_STICKY_MOUSE_BUTTONS 0x00030003
#define GLFW_SYSTEM_KEYS 0x00030004
#define GLFW_KEY_REPEAT 0x00030005
#define GLFW_AUTO_POLL_EVENTS 0x00030006
/* glfwWaitThread wait modes */
#define GLFW_WAIT 0x00040001
#define GLFW_NOWAIT 0x00040002
/* glfwGetJoystickParam tokens */
#define GLFW_PRESENT 0x00050001
#define GLFW_AXES 0x00050002
#define GLFW_BUTTONS 0x00050003
/* glfwReadImage/glfwLoadTexture2D flags */
#define GLFW_NO_RESCALE_BIT 0x00000001 /* Only for glfwReadImage */
#define GLFW_ORIGIN_UL_BIT 0x00000002
#define GLFW_BUILD_MIPMAPS_BIT 0x00000004 /* Only for glfwLoadTexture2D */
#define GLFW_ALPHA_MAP_BIT 0x00000008
/* Time spans longer than this (seconds) are considered to be infinity */
#define GLFW_INFINITY 100000.0
/*************************************************************************
* Typedefs
*************************************************************************/
/* The video mode structure used by glfwGetVideoModes() */
typedef struct {
int Width, Height;
int RedBits, BlueBits, GreenBits;
} GLFWvidmode;
/* Image/texture information */
typedef struct {
int Width, Height;
int Format;
int BytesPerPixel;
unsigned char *Data;
} GLFWimage;
/* Thread ID */
typedef int GLFWthread;
/* Mutex object */
typedef void * GLFWmutex;
/* Condition variable object */
typedef void * GLFWcond;
/* Function pointer types */
typedef void (GLFWCALL * GLFWwindowsizefun)(int,int);
typedef int (GLFWCALL * GLFWwindowclosefun)(void);
typedef void (GLFWCALL * GLFWwindowrefreshfun)(void);
typedef void (GLFWCALL * GLFWmousebuttonfun)(int,int);
typedef void (GLFWCALL * GLFWmouseposfun)(int,int);
typedef void (GLFWCALL * GLFWmousewheelfun)(int);
typedef void (GLFWCALL * GLFWkeyfun)(int,int);
typedef void (GLFWCALL * GLFWcharfun)(int,int);
typedef void (GLFWCALL * GLFWthreadfun)(void *);
/*************************************************************************
* Prototypes
*************************************************************************/
/* GLFW initialization, termination and version querying */
GLFWAPI int GLFWAPIENTRY glfwInit( void );
GLFWAPI void GLFWAPIENTRY glfwTerminate( void );
GLFWAPI void GLFWAPIENTRY glfwGetVersion( int *major, int *minor, int *rev );
/* Window handling */
GLFWAPI int GLFWAPIENTRY glfwOpenWindow( int width, int height, int redbits, int greenbits, int bluebits, int alphabits, int depthbits, int stencilbits, int mode );
GLFWAPI void GLFWAPIENTRY glfwOpenWindowHint( int target, int hint );
GLFWAPI void GLFWAPIENTRY glfwCloseWindow( void );
GLFWAPI void GLFWAPIENTRY glfwSetWindowTitle( const char *title );
GLFWAPI void GLFWAPIENTRY glfwGetWindowSize( int *width, int *height );
GLFWAPI void GLFWAPIENTRY glfwSetWindowSize( int width, int height );
GLFWAPI void GLFWAPIENTRY glfwSetWindowPos( int x, int y );
GLFWAPI void GLFWAPIENTRY glfwIconifyWindow( void );
GLFWAPI void GLFWAPIENTRY glfwRestoreWindow( void );
GLFWAPI void GLFWAPIENTRY glfwSwapBuffers( void );
GLFWAPI void GLFWAPIENTRY glfwSwapInterval( int interval );
GLFWAPI int GLFWAPIENTRY glfwGetWindowParam( int param );
GLFWAPI void GLFWAPIENTRY glfwSetWindowSizeCallback( GLFWwindowsizefun cbfun );
GLFWAPI void GLFWAPIENTRY glfwSetWindowCloseCallback( GLFWwindowclosefun cbfun );
GLFWAPI void GLFWAPIENTRY glfwSetWindowRefreshCallback( GLFWwindowrefreshfun cbfun );
/* Video mode functions */
GLFWAPI int GLFWAPIENTRY glfwGetVideoModes( GLFWvidmode *list, int maxcount );
GLFWAPI void GLFWAPIENTRY glfwGetDesktopMode( GLFWvidmode *mode );
/* Input handling */
GLFWAPI void GLFWAPIENTRY glfwPollEvents( void );
GLFWAPI void GLFWAPIENTRY glfwWaitEvents( void );
GLFWAPI int GLFWAPIENTRY glfwGetKey( int key );
GLFWAPI int GLFWAPIENTRY glfwGetMouseButton( int button );
GLFWAPI void GLFWAPIENTRY glfwGetMousePos( int *xpos, int *ypos );
GLFWAPI void GLFWAPIENTRY glfwSetMousePos( int xpos, int ypos );
GLFWAPI int GLFWAPIENTRY glfwGetMouseWheel( void );
GLFWAPI void GLFWAPIENTRY glfwSetMouseWheel( int pos );
GLFWAPI void GLFWAPIENTRY glfwSetKeyCallback( GLFWkeyfun cbfun );
GLFWAPI void GLFWAPIENTRY glfwSetCharCallback( GLFWcharfun cbfun );
GLFWAPI void GLFWAPIENTRY glfwSetMouseButtonCallback( GLFWmousebuttonfun cbfun );
GLFWAPI void GLFWAPIENTRY glfwSetMousePosCallback( GLFWmouseposfun cbfun );
GLFWAPI void GLFWAPIENTRY glfwSetMouseWheelCallback( GLFWmousewheelfun cbfun );
/* Joystick input */
GLFWAPI int GLFWAPIENTRY glfwGetJoystickParam( int joy, int param );
GLFWAPI int GLFWAPIENTRY glfwGetJoystickPos( int joy, float *pos, int numaxes );
GLFWAPI int GLFWAPIENTRY glfwGetJoystickButtons( int joy, unsigned char *buttons, int numbuttons );
/* Time */
GLFWAPI double GLFWAPIENTRY glfwGetTime( void );
GLFWAPI void GLFWAPIENTRY glfwSetTime( double time );
GLFWAPI void GLFWAPIENTRY glfwSleep( double time );
/* Extension support */
GLFWAPI int GLFWAPIENTRY glfwExtensionSupported( const char *extension );
GLFWAPI void* GLFWAPIENTRY glfwGetProcAddress( const char *procname );
GLFWAPI void GLFWAPIENTRY glfwGetGLVersion( int *major, int *minor, int *rev );
/* Threading support */
GLFWAPI GLFWthread GLFWAPIENTRY glfwCreateThread( GLFWthreadfun fun, void *arg );
GLFWAPI void GLFWAPIENTRY glfwDestroyThread( GLFWthread ID );
GLFWAPI int GLFWAPIENTRY glfwWaitThread( GLFWthread ID, int waitmode );
GLFWAPI GLFWthread GLFWAPIENTRY glfwGetThreadID( void );
GLFWAPI GLFWmutex GLFWAPIENTRY glfwCreateMutex( void );
GLFWAPI void GLFWAPIENTRY glfwDestroyMutex( GLFWmutex mutex );
GLFWAPI void GLFWAPIENTRY glfwLockMutex( GLFWmutex mutex );
GLFWAPI void GLFWAPIENTRY glfwUnlockMutex( GLFWmutex mutex );
GLFWAPI GLFWcond GLFWAPIENTRY glfwCreateCond( void );
GLFWAPI void GLFWAPIENTRY glfwDestroyCond( GLFWcond cond );
GLFWAPI void GLFWAPIENTRY glfwWaitCond( GLFWcond cond, GLFWmutex mutex, double timeout );
GLFWAPI void GLFWAPIENTRY glfwSignalCond( GLFWcond cond );
GLFWAPI void GLFWAPIENTRY glfwBroadcastCond( GLFWcond cond );
GLFWAPI int GLFWAPIENTRY glfwGetNumberOfProcessors( void );
/* Enable/disable functions */
GLFWAPI void GLFWAPIENTRY glfwEnable( int token );
GLFWAPI void GLFWAPIENTRY glfwDisable( int token );
/* Image/texture I/O support */
GLFWAPI int GLFWAPIENTRY glfwReadImage( const char *name, GLFWimage *img, int flags );
GLFWAPI int GLFWAPIENTRY glfwReadMemoryImage( const void *data, long size, GLFWimage *img, int flags );
GLFWAPI void GLFWAPIENTRY glfwFreeImage( GLFWimage *img );
GLFWAPI int GLFWAPIENTRY glfwLoadTexture2D( const char *name, int flags );
GLFWAPI int GLFWAPIENTRY glfwLoadMemoryTexture2D( const void *data, long size, int flags );
GLFWAPI int GLFWAPIENTRY glfwLoadTextureImage2D( GLFWimage *img, int flags );
#ifdef __cplusplus
}
#endif
#endif /* __glfw_h_ */

170
ogl_editor/src/External/glfw/lib/carbon/Makefile.carbon vendored Normal file
View File

@ -0,0 +1,170 @@
##########################################################################
# Makefile for GLFW on Mac OS X using GCC (Apple SDK).
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# make -f Makefile.carbon
##########################################################################
##########################################################################
# Installation prefix (default to /usr/local)
##########################################################################
PREFIX ?= /usr/local
##########################################################################
# Default: Build GLFW static and shared library
##########################################################################
all: libglfw.a libglfw.dylib
##########################################################################
# Compiler settings
##########################################################################
CC = gcc
CFLAGS = -c -I. -I.. -Wall -O2 -fno-common -g -m32
##########################################################################
# Library builder settings
##########################################################################
AR = ar
SED = sed
INSTALL = install
ARFLAGS = -rcs
RANLIB = ranlib
DYLIBFLAGS = -framework AGL -framework Carbon -framework OpenGL \
-dynamiclib -Wl,-single_module -compatibility_version 1 \
-current_version 1 -install_name @executable_path/libglfw.dylib -m32
##########################################################################
# Install GLFW header and static library
##########################################################################
install: libglfw.a libglfw.pc
$(INSTALL) -d $(PREFIX)/lib
$(INSTALL) -c -m 644 libglfw.a $(PREFIX)/lib/libglfw.a
$(RANLIB) $(PREFIX)/lib/libglfw.a
$(INSTALL) -d $(PREFIX)/include/GL
$(INSTALL) -c -m 644 ../../include/GL/glfw.h $(PREFIX)/include/GL/glfw.h
$(INSTALL) -d $(PREFIX)/lib/pkgconfig
$(INSTALL) -c -m 644 libglfw.pc $(PREFIX)/lib/pkgconfig/libglfw.pc
##########################################################################
# Object files for the GLFW library
##########################################################################
OBJS = \
enable.o \
fullscreen.o \
glext.o \
image.o \
init.o \
input.o \
joystick.o \
stream.o \
tga.o \
thread.o \
time.o \
window.o \
carbon_enable.o \
carbon_fullscreen.o \
carbon_glext.o \
carbon_init.o \
carbon_joystick.o \
carbon_thread.o \
carbon_time.o \
carbon_window.o
##########################################################################
# Rule for building libglfw.pc
##########################################################################
libglfw.pc: libglfw.pc.in
$(SED) -e 's,\@PREFIX\@,$(PREFIX),' libglfw.pc.in > libglfw.pc
##########################################################################
# Rule for building static library
##########################################################################
libglfw.a: $(OBJS)
$(AR) $(ARFLAGS) $@ $(OBJS)
$(RANLIB) $@
##########################################################################
# Rule for building shared library
##########################################################################
libglfw.dylib: $(OBJS)
$(CC) -o $@ $(DYLIBFLAGS) $(OBJS)
##########################################################################
# Rule for cleaning up generated files
##########################################################################
clean:
@rm -f *.o libglfw.a libglfw.dylib libglfw.pc
##########################################################################
# Rules for building library object files
##########################################################################
enable.o: ../enable.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../enable.c
fullscreen.o: ../fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../fullscreen.c
glext.o: ../glext.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../glext.c
image.o: ../image.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../image.c
init.o: ../init.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../init.c
input.o: ../input.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../input.c
joystick.o: ../joystick.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../joystick.c
stream.o: ../stream.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../stream.c
tga.o: ../tga.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../tga.c
thread.o: ../thread.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../thread.c
time.o: ../time.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../time.c
window.o: ../window.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../window.c
carbon_enable.o: carbon_enable.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_enable.c
carbon_fullscreen.o: carbon_fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_fullscreen.c
carbon_glext.o: carbon_glext.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_glext.c
carbon_init.o: carbon_init.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_init.c
carbon_joystick.o: carbon_joystick.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_joystick.c
carbon_thread.o: carbon_thread.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_thread.c
carbon_time.o: carbon_time.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_time.c
carbon_window.o: carbon_window.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_window.c

163
ogl_editor/src/External/glfw/lib/carbon/Makefile.carbon.universal vendored Normal file
View File

@ -0,0 +1,163 @@
##########################################################################
# Makefile for GLFW on Mac OS X using GCC (Apple SDK).
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# make -f Makefile.carbon.universal
##########################################################################
##########################################################################
# Installation prefix (default to /usr/local)
##########################################################################
PREFIX ?= /usr/local
##########################################################################
# Default: Build GLFW static library
##########################################################################
all: libglfw.a
##########################################################################
# Compiler settings
##########################################################################
CC = gcc
FATFLAGS = -isysroot /Developer/SDKs/MacOSX10.4u.sdk \
-mmacosx-version-min=10.4 -arch ppc -arch i386
CFLAGS = -c -I. -I.. -Wall -O2 -fno-common $(FATFLAGS)
##########################################################################
# Library builder settings
##########################################################################
SED = sed
INSTALL = install
MKLIB = ar
LIBFLAGS = -rcs
RANLIB = ranlib
##########################################################################
# Install GLFW header and static library
##########################################################################
install: libglfw.a libglfw.pc
$(INSTALL) -d $(PREFIX)/lib
$(INSTALL) -c -m 644 libglfw.a $(PREFIX)/lib/libglfw.a
$(RANLIB) $(PREFIX)/lib/libglfw.a
$(INSTALL) -d $(PREFIX)/include/GL
$(INSTALL) -c -m 644 ../../include/GL/glfw.h $(PREFIX)/include/GL/glfw.h
$(INSTALL) -d $(PREFIX)/lib/pkgconfig
$(INSTALL) -c -m 644 libglfw.pc $(PREFIX)/lib/pkgconfig/libglfw.pc
##########################################################################
# Rule for cleaning up generated files
##########################################################################
clean:
rm -f *.o libglfw.a libglfw.pc
##########################################################################
# Object files which are part of the GLFW library
##########################################################################
OBJS = \
enable.o \
fullscreen.o \
glext.o \
image.o \
init.o \
input.o \
joystick.o \
stream.o \
tga.o \
thread.o \
time.o \
window.o \
carbon_enable.o \
carbon_fullscreen.o \
carbon_glext.o \
carbon_init.o \
carbon_joystick.o \
carbon_thread.o \
carbon_time.o \
carbon_window.o
##########################################################################
# Rule for building libglfw.pc
##########################################################################
libglfw.pc: libglfw.pc.in
$(SED) -e 's,\@PREFIX\@,$(PREFIX),' libglfw.pc.in > libglfw.pc
##########################################################################
# Rule for building library
##########################################################################
libglfw.a: $(OBJS)
rm -f $@
$(MKLIB) $(LIBFLAGS) $@ $(OBJS)
$(RANLIB) $@
##########################################################################
# Rules for building library object files
##########################################################################
enable.o: ../enable.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../enable.c
fullscreen.o: ../fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../fullscreen.c
glext.o: ../glext.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../glext.c
image.o: ../image.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../image.c
init.o: ../init.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../init.c
input.o: ../input.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../input.c
joystick.o: ../joystick.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../joystick.c
stream.o: ../stream.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../stream.c
tga.o: ../tga.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../tga.c
thread.o: ../thread.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../thread.c
time.o: ../time.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../time.c
window.o: ../window.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../window.c
carbon_enable.o: carbon_enable.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_enable.c
carbon_fullscreen.o: carbon_fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_fullscreen.c
carbon_glext.o: carbon_glext.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_glext.c
carbon_init.o: carbon_init.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_init.c
carbon_joystick.o: carbon_joystick.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_joystick.c
carbon_thread.o: carbon_thread.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_thread.c
carbon_time.o: carbon_time.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_time.c
carbon_window.o: carbon_window.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ carbon_window.c

56
ogl_editor/src/External/glfw/lib/carbon/carbon_enable.c vendored Normal file
View File

@ -0,0 +1,56 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-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.
//
//========================================================================
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Enable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys( void )
{
// Nothing to do; event handling code checks the status of
// _glfwWin.sysKeysDisabled to ensure this behavior.
}
//========================================================================
// Disable system keys
//========================================================================
void _glfwPlatformDisableSystemKeys( void )
{
// Nothing to do; event handling code checks the status of
// _glfwWin.sysKeysDisabled to ensure this behavior.
}

133
ogl_editor/src/External/glfw/lib/carbon/carbon_fullscreen.c vendored Normal file
View File

@ -0,0 +1,133 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-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.
//
//========================================================================
#include "internal.h"
//========================================================================
// Compares two video modes
//========================================================================
static int _glfwVideoModesEqual( GLFWvidmode* first,
GLFWvidmode* second )
{
if( first->Width != second->Width )
return 0;
if( first->Height != second->Height )
return 0;
if( first->RedBits + first->GreenBits + first->BlueBits !=
second->RedBits + second->GreenBits + second->BlueBits )
return 0;
return 1;
}
//========================================================================
// Converts a CG mode to a GLFW mode
//========================================================================
static void _glfwCGToGLFWVideoMode( CFDictionaryRef cgMode,
GLFWvidmode* glfwMode )
{
int bitsPerSample;
CFNumberGetValue( CFDictionaryGetValue( cgMode, kCGDisplayWidth ),
kCFNumberIntType,
&(glfwMode->Width) );
CFNumberGetValue( CFDictionaryGetValue( cgMode, kCGDisplayHeight ),
kCFNumberIntType,
&(glfwMode->Height) );
CFNumberGetValue( CFDictionaryGetValue( cgMode, kCGDisplayBitsPerSample ),
kCFNumberIntType,
&bitsPerSample );
glfwMode->RedBits = bitsPerSample;
glfwMode->GreenBits = bitsPerSample;
glfwMode->BlueBits = bitsPerSample;
}
//========================================================================
// Get a list of available video modes
//========================================================================
int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )
{
int i, j, maxModes, numModes;
GLFWvidmode mode;
CFArrayRef availableModes = CGDisplayAvailableModes( kCGDirectMainDisplay );
CFIndex numberOfAvailableModes = CFArrayGetCount( availableModes );
numModes = 0;
maxModes = ( numberOfAvailableModes < maxcount ?
numberOfAvailableModes :
maxcount );
for( i = 0; i < maxModes; ++i )
{
_glfwCGToGLFWVideoMode( CFArrayGetValueAtIndex( availableModes, i ),
&mode );
// Is it a valid mode? (only list depths >= 15 bpp)
if( mode.RedBits + mode.GreenBits + mode.BlueBits < 15 )
{
continue;
}
// Check for duplicate of current mode in target list
for( j = 0; j < numModes; ++j )
{
if( _glfwVideoModesEqual( &mode, &(list[j]) ) )
{
break;
}
}
// If empty list or no match found
if( numModes == 0 || j == numModes )
{
list[numModes++] = mode;
}
}
return numModes;
}
//========================================================================
// Get the desktop video mode
//========================================================================
void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )
{
_glfwCGToGLFWVideoMode( CGDisplayCurrentMode( kCGDirectMainDisplay ), mode );
}

65
ogl_editor/src/External/glfw/lib/carbon/carbon_glext.c vendored Normal file
View File

@ -0,0 +1,65 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Check if an OpenGL extension is available at runtime
//========================================================================
int _glfwPlatformExtensionSupported( const char *extension )
{
// There are no AGL, CGL or NSGL extensions.
return GL_FALSE;
}
//========================================================================
// Get the function pointer to an OpenGL function
//========================================================================
void * _glfwPlatformGetProcAddress( const char *procname )
{
CFStringRef symbolName = CFStringCreateWithCString( kCFAllocatorDefault,
procname,
kCFStringEncodingASCII );
void *symbol = CFBundleGetFunctionPointerForName( _glfwLibrary.Libs.OpenGLFramework,
symbolName );
CFRelease( symbolName );
return symbol;
}

193
ogl_editor/src/External/glfw/lib/carbon/carbon_init.c vendored Normal file
View File

@ -0,0 +1,193 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-2010 Camilla Berglund <elmindreda@elmindreda.org>
// Copyright (c) 2006-2007 Robin Leffmann
//
// 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.
//
//========================================================================
#include "internal.h"
#include <unistd.h>
//========================================================================
// Global variables
//========================================================================
// KCHR resource pointer for keycode translation
void *KCHRPtr;
//========================================================================
// Terminate GLFW when exiting application
//========================================================================
static void glfw_atexit( void )
{
glfwTerminate();
}
//========================================================================
// Initialize GLFW thread package
//========================================================================
static void _glfwInitThreads( void )
{
// Initialize critical section handle
(void) pthread_mutex_init( &_glfwThrd.CriticalSection, NULL );
// The first thread (the main thread) has ID 0
_glfwThrd.NextID = 0;
// Fill out information about the main thread (this thread)
_glfwThrd.First.ID = _glfwThrd.NextID ++;
_glfwThrd.First.Function = NULL;
_glfwThrd.First.PosixID = pthread_self();
_glfwThrd.First.Previous = NULL;
_glfwThrd.First.Next = NULL;
}
#define NO_BUNDLE_MESSAGE \
"Working in unbundled mode. " \
"You should build a .app wrapper for your Mac OS X applications.\n"
#define UNBUNDLED \
fprintf(stderr, NO_BUNDLE_MESSAGE); \
_glfwLibrary.Unbundled = 1; \
return
//========================================================================
// Changes the current directory to the Resources directory of the bundle
// we're in, or leaves it alone if we're not inside a bundle
//========================================================================
void _glfwChangeToResourcesDirectory( void )
{
CFBundleRef mainBundle = CFBundleGetMainBundle();
if( mainBundle == NULL )
{
UNBUNDLED;
}
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL( mainBundle );
char resourcesPath[ _GLFW_MAX_PATH_LENGTH ];
CFStringRef lastComponent = CFURLCopyLastPathComponent( resourcesURL );
if( kCFCompareEqualTo != CFStringCompare(
CFSTR( "Resources" ),
lastComponent,
0 ) )
{
UNBUNDLED;
}
CFRelease( lastComponent );
if( !CFURLGetFileSystemRepresentation( resourcesURL,
TRUE,
(UInt8*)resourcesPath,
_GLFW_MAX_PATH_LENGTH ) )
{
CFRelease( resourcesURL );
UNBUNDLED;
}
CFRelease( resourcesURL );
if( chdir( resourcesPath ) != 0 )
{
UNBUNDLED;
}
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Initialize various GLFW state
//========================================================================
int _glfwPlatformInit( void )
{
struct timeval tv;
UInt32 nullDummy = 0;
_glfwWin.window = NULL;
_glfwWin.aglContext = NULL;
_glfwWin.cglContext = NULL;
_glfwWin.windowUPP = NULL;
_glfwInput.Modifiers = 0;
_glfwLibrary.Unbundled = 0;
_glfwLibrary.Libs.OpenGLFramework =
CFBundleGetBundleWithIdentifier( CFSTR( "com.apple.opengl" ) );
if( _glfwLibrary.Libs.OpenGLFramework == NULL )
{
fprintf( stderr, "glfwInit failing because you aren't linked to OpenGL\n" );
return GL_FALSE;
}
_glfwPlatformGetDesktopMode( &_glfwLibrary.desktopMode );
// Install atexit routine
atexit( glfw_atexit );
_glfwInitThreads();
_glfwChangeToResourcesDirectory();
// Ugly hack to reduce the nasty jump that occurs at the first non-
// sys keypress, caused by OS X loading certain meta scripts used
// for lexical- and raw keycode translation - instead of letting
// this happen while our application is running, we do some blunt
// function calls in advance just to get the script caching out of
// the way BEFORE our window/screen is opened. These calls might
// generate err return codes, but we don't care in this case.
// NOTE: KCHRPtr is declared globally, because we need it later on.
KCHRPtr = (void *)GetScriptVariable( smCurrentScript, smKCHRCache );
KeyTranslate( KCHRPtr, 0, &nullDummy );
UppercaseText( (char *)&nullDummy, 0, smSystemScript );
gettimeofday( &tv, NULL );
_glfwLibrary.Timer.t0 = tv.tv_sec + (double) tv.tv_usec / 1000000.0;
return GL_TRUE;
}
//========================================================================
// Close window and kill all threads
//========================================================================
int _glfwPlatformTerminate( void )
{
return GL_TRUE;
}

67
ogl_editor/src/External/glfw/lib/carbon/carbon_joystick.c vendored Normal file
View File

@ -0,0 +1,67 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-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.
//
//========================================================================
#include "internal.h"
// TO DO: use HID manager to implement joystick support.
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Determine joystick capabilities
//========================================================================
int _glfwPlatformGetJoystickParam( int joy, int param )
{
// GL_FALSE == 0
return 0;
}
//========================================================================
// Get joystick axis positions
//========================================================================
int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )
{
return 0;
}
//========================================================================
// Get joystick button states
//========================================================================
int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons, int numbuttons )
{
return 0;
}

410
ogl_editor/src/External/glfw/lib/carbon/carbon_thread.c vendored Normal file
View File

@ -0,0 +1,410 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// This is simply a "wrapper" for calling the user thread function.
//========================================================================
void * _glfwNewThread( void * arg )
{
GLFWthreadfun threadfun;
_GLFWthread *t;
// Get pointer to thread information for current thread
t = _glfwGetThreadPointer( glfwGetThreadID() );
if( t == NULL )
{
return 0;
}
// Get user thread function pointer
threadfun = t->Function;
// Call the user thread function
threadfun( arg );
// Remove thread from thread list
ENTER_THREAD_CRITICAL_SECTION
_glfwRemoveThread( t );
LEAVE_THREAD_CRITICAL_SECTION
// When the thread function returns, the thread will die...
return NULL;
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Create a new thread
//========================================================================
GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )
{
GLFWthread ID;
_GLFWthread *t;
int result;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Create a new thread information memory area
t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );
if( t == NULL )
{
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Get a new unique thread id
ID = _glfwThrd.NextID ++;
// Store thread information in the thread list
t->Function = fun;
t->ID = ID;
// Create thread
result = pthread_create(
&t->PosixID, // Thread handle
NULL, // Default thread attributes
_glfwNewThread, // Thread function (a wrapper function)
(void *)arg // Argument to thread is user argument
);
// Did the thread creation fail?
if( result != 0 )
{
free( (void *) t );
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Append thread to thread list
_glfwAppendThread( t );
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the GLFW thread ID
return ID;
}
//========================================================================
// Kill a thread. NOTE: THIS IS A VERY DANGEROUS OPERATION, AND SHOULD NOT
// BE USED EXCEPT IN EXTREME SITUATIONS!
//========================================================================
void _glfwPlatformDestroyThread( GLFWthread ID )
{
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return;
}
// Simply murder the process, no mercy!
pthread_kill( t->PosixID, SIGKILL );
// Remove thread from thread list
_glfwRemoveThread( t );
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
}
//========================================================================
// Wait for a thread to die
//========================================================================
int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )
{
pthread_t thread;
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
// Is the thread already dead?
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return GL_TRUE;
}
// If got this far, the thread is alive => polling returns FALSE
if( waitmode == GLFW_NOWAIT )
{
LEAVE_THREAD_CRITICAL_SECTION
return GL_FALSE;
}
// Get thread handle
thread = t->PosixID;
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Wait for thread to die
(void) pthread_join( thread, NULL );
return GL_TRUE;
}
//========================================================================
// Return the thread ID for the current thread
//========================================================================
GLFWthread _glfwPlatformGetThreadID( void )
{
_GLFWthread *t;
GLFWthread ID = -1;
pthread_t posixID;
// Get current thread ID
posixID = pthread_self();
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Loop through entire list of threads to find the matching POSIX
// thread ID
for( t = &_glfwThrd.First; t != NULL; t = t->Next )
{
if( t->PosixID == posixID )
{
ID = t->ID;
break;
}
}
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the found GLFW thread identifier
return ID;
}
//========================================================================
// Create a mutual exclusion object
//========================================================================
GLFWmutex _glfwPlatformCreateMutex( void )
{
pthread_mutex_t *mutex;
// Allocate memory for mutex
mutex = (pthread_mutex_t *) malloc( sizeof( pthread_mutex_t ) );
if( !mutex )
{
return NULL;
}
// Initialise a mutex object
(void) pthread_mutex_init( mutex, NULL );
// Cast to GLFWmutex and return
return (GLFWmutex) mutex;
}
//========================================================================
// Destroy a mutual exclusion object
//========================================================================
void _glfwPlatformDestroyMutex( GLFWmutex mutex )
{
// Destroy the mutex object
pthread_mutex_destroy( (pthread_mutex_t *) mutex );
// Free memory for mutex object
free( (void *) mutex );
}
//========================================================================
// Request access to a mutex
//========================================================================
void _glfwPlatformLockMutex( GLFWmutex mutex )
{
// Wait for mutex to be released
(void) pthread_mutex_lock( (pthread_mutex_t *) mutex );
}
//========================================================================
// Release a mutex
//========================================================================
void _glfwPlatformUnlockMutex( GLFWmutex mutex )
{
// Release mutex
pthread_mutex_unlock( (pthread_mutex_t *) mutex );
}
//========================================================================
// Create a new condition variable object
//========================================================================
GLFWcond _glfwPlatformCreateCond( void )
{
pthread_cond_t *cond;
// Allocate memory for condition variable
cond = (pthread_cond_t *) malloc( sizeof(pthread_cond_t) );
if( !cond )
{
return NULL;
}
// Initialise condition variable
(void) pthread_cond_init( cond, NULL );
// Cast to GLFWcond and return
return (GLFWcond) cond;
}
//========================================================================
// Destroy a condition variable object
//========================================================================
void _glfwPlatformDestroyCond( GLFWcond cond )
{
// Destroy the condition variable object
(void) pthread_cond_destroy( (pthread_cond_t *) cond );
// Free memory for condition variable object
free( (void *) cond );
}
//========================================================================
// Wait for a condition to be raised
//========================================================================
void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex,
double timeout )
{
struct timeval currenttime;
struct timespec wait;
long dt_sec, dt_usec;
// Select infinite or timed wait
if( timeout >= GLFW_INFINITY )
{
// Wait for condition (infinite wait)
(void) pthread_cond_wait( (pthread_cond_t *) cond,
(pthread_mutex_t *) mutex );
}
else
{
// Set timeout time, relatvie to current time
gettimeofday( &currenttime, NULL );
dt_sec = (long) timeout;
dt_usec = (long) ((timeout - (double)dt_sec) * 1000000.0);
wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;
if( wait.tv_nsec > 1000000000L )
{
wait.tv_nsec -= 1000000000L;
dt_sec ++;
}
wait.tv_sec = currenttime.tv_sec + dt_sec;
// Wait for condition (timed wait)
(void) pthread_cond_timedwait( (pthread_cond_t *) cond,
(pthread_mutex_t *) mutex, &wait );
}
}
//========================================================================
// Signal a condition to one waiting thread
//========================================================================
void _glfwPlatformSignalCond( GLFWcond cond )
{
// Signal condition
(void) pthread_cond_signal( (pthread_cond_t *) cond );
}
//========================================================================
// Broadcast a condition to all waiting threads
//========================================================================
void _glfwPlatformBroadcastCond( GLFWcond cond )
{
// Broadcast condition
(void) pthread_cond_broadcast( (pthread_cond_t *) cond );
}
//========================================================================
// Return the number of processors in the system.
//========================================================================
int _glfwPlatformGetNumberOfProcessors( void )
{
int n;
// Get number of processors online
_glfw_numprocessors( n );
return n;
}

113
ogl_editor/src/External/glfw/lib/carbon/carbon_time.c vendored Normal file
View File

@ -0,0 +1,113 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Return timer value in seconds
//========================================================================
double _glfwPlatformGetTime( void )
{
struct timeval tv;
gettimeofday( &tv, NULL );
return tv.tv_sec + (double) tv.tv_usec / 1000000.0 - _glfwLibrary.Timer.t0;
}
//========================================================================
// Set timer value in seconds
//========================================================================
void _glfwPlatformSetTime( double time )
{
struct timeval tv;
gettimeofday( &tv, NULL );
_glfwLibrary.Timer.t0 = tv.tv_sec + (double) tv.tv_usec / 1000000.0 - time;
}
//========================================================================
// Put a thread to sleep for a specified amount of time
//========================================================================
void _glfwPlatformSleep( double time )
{
if( time == 0.0 )
{
sched_yield();
return;
}
struct timeval currenttime;
struct timespec wait;
pthread_mutex_t mutex;
pthread_cond_t cond;
long dt_sec, dt_usec;
// Not all pthread implementations have a pthread_sleep() function. We
// do it the portable way, using a timed wait for a condition that we
// will never signal. NOTE: The unistd functions sleep/usleep suspends
// the entire PROCESS, not a signle thread, which is why we can not
// use them to implement glfwSleep.
// Set timeout time, relatvie to current time
gettimeofday( &currenttime, NULL );
dt_sec = (long) time;
dt_usec = (long) ((time - (double)dt_sec) * 1000000.0);
wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;
if( wait.tv_nsec > 1000000000L )
{
wait.tv_nsec -= 1000000000L;
dt_sec ++;
}
wait.tv_sec = currenttime.tv_sec + dt_sec;
// Initialize condition and mutex objects
pthread_mutex_init( &mutex, NULL );
pthread_cond_init( &cond, NULL );
// Do a timed wait
pthread_mutex_lock( &mutex );
pthread_cond_timedwait( &cond, &mutex, &wait );
pthread_mutex_unlock( &mutex );
// Destroy condition and mutex objects
pthread_mutex_destroy( &mutex );
pthread_cond_destroy( &cond );
}

1276
ogl_editor/src/External/glfw/lib/carbon/carbon_window.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

11
ogl_editor/src/External/glfw/lib/carbon/libglfw.pc.in vendored Normal file
View File

@ -0,0 +1,11 @@
prefix=@PREFIX@
exec_prefix=@PREFIX@
libdir=@PREFIX@/lib
includedir=@PREFIX@/include
Name: GLFW
Description: A portable framework for OpenGL development
Version: 2.7
URL: http://www.glfw.org/
Libs: -L${libdir} -lglfw -framework AGL -framework OpenGL -framework Carbon
Cflags: -I${includedir}

336
ogl_editor/src/External/glfw/lib/carbon/platform.h vendored Normal file
View File

@ -0,0 +1,336 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Carbon/AGL/CGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2003 Keith Bauer
// Copyright (c) 2003-2010 Camilla Berglund <elmindreda@elmindreda.org>
// Copyright (c) 2006-2007 Robin Leffmann
//
// 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 _platform_h_
#define _platform_h_
// This is the Mac OS X version of GLFW
#define _GLFW_MAC_OS_X
#include <Carbon/Carbon.h>
#include <OpenGL/OpenGL.h>
#include <AGL/agl.h>
#include <sched.h>
#include <pthread.h>
#include <sys/sysctl.h>
#include "../../include/GL/glfw.h"
#if MACOSX_DEPLOYMENT_TARGET < MAC_OS_X_VERSION_10_3
#ifndef kCGLNoError
#define kCGLNoError 0
#endif
#endif
#ifndef GL_VERSION_3_0
typedef const GLubyte * (APIENTRY *PFNGLGETSTRINGIPROC) (GLenum, GLuint);
#endif /*GL_VERSION_3_0*/
//========================================================================
// Defines
//========================================================================
#define _GLFW_MAX_PATH_LENGTH (8192)
#define MAC_KEY_ENTER 0x24
#define MAC_KEY_RETURN 0x34
#define MAC_KEY_ESC 0x35
#define MAC_KEY_F1 0x7A
#define MAC_KEY_F2 0x78
#define MAC_KEY_F3 0x63
#define MAC_KEY_F4 0x76
#define MAC_KEY_F5 0x60
#define MAC_KEY_F6 0x61
#define MAC_KEY_F7 0x62
#define MAC_KEY_F8 0x64
#define MAC_KEY_F9 0x65
#define MAC_KEY_F10 0x6D
#define MAC_KEY_F11 0x67
#define MAC_KEY_F12 0x6F
#define MAC_KEY_F13 0x69
#define MAC_KEY_F14 0x6B
#define MAC_KEY_F15 0x71
#define MAC_KEY_UP 0x7E
#define MAC_KEY_DOWN 0x7D
#define MAC_KEY_LEFT 0x7B
#define MAC_KEY_RIGHT 0x7C
#define MAC_KEY_TAB 0x30
#define MAC_KEY_BACKSPACE 0x33
#define MAC_KEY_HELP 0x72
#define MAC_KEY_DEL 0x75
#define MAC_KEY_PAGEUP 0x74
#define MAC_KEY_PAGEDOWN 0x79
#define MAC_KEY_HOME 0x73
#define MAC_KEY_END 0x77
#define MAC_KEY_KP_0 0x52
#define MAC_KEY_KP_1 0x53
#define MAC_KEY_KP_2 0x54
#define MAC_KEY_KP_3 0x55
#define MAC_KEY_KP_4 0x56
#define MAC_KEY_KP_5 0x57
#define MAC_KEY_KP_6 0x58
#define MAC_KEY_KP_7 0x59
#define MAC_KEY_KP_8 0x5B
#define MAC_KEY_KP_9 0x5C
#define MAC_KEY_KP_DIVIDE 0x4B
#define MAC_KEY_KP_MULTIPLY 0x43
#define MAC_KEY_KP_SUBTRACT 0x4E
#define MAC_KEY_KP_ADD 0x45
#define MAC_KEY_KP_DECIMAL 0x41
#define MAC_KEY_KP_EQUAL 0x51
#define MAC_KEY_KP_ENTER 0x4C
#define MAC_KEY_NUMLOCK 0x47
//========================================================================
// GLFW platform specific types
//========================================================================
//------------------------------------------------------------------------
// Pointer length integer
//------------------------------------------------------------------------
typedef intptr_t GLFWintptr;
//------------------------------------------------------------------------
// Window structure
//------------------------------------------------------------------------
typedef struct _GLFWwin_struct _GLFWwin;
struct _GLFWwin_struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// User callback functions
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWmousewheelfun mouseWheelCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
// User selected window settings
int fullscreen; // Fullscreen flag
int mouseLock; // Mouse-lock flag
int autoPollEvents; // Auto polling flag
int sysKeysDisabled; // System keys disabled flag
int windowNoResize; // Resize- and maximize gadgets disabled flag
int refreshRate; // Vertical monitor refresh rate
// Window status & parameters
int opened; // Flag telling if window is opened or not
int active; // Application active flag
int iconified; // Window iconified flag
int width, height; // Window width and heigth
int accelerated; // GL_TRUE if window is HW accelerated
// Framebuffer attributes
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;
// OpenGL extensions and context attributes
int has_GL_SGIS_generate_mipmap;
int has_GL_ARB_texture_non_power_of_two;
int glMajor, glMinor, glRevision;
int glForward, glDebug, glProfile;
PFNGLGETSTRINGIPROC GetStringi;
// ========= PLATFORM SPECIFIC PART ======================================
WindowRef window;
AGLContext aglContext;
AGLPixelFormat aglPixelFormat;
CGLContextObj cglContext;
CGLPixelFormatObj cglPixelFormat;
EventHandlerUPP windowUPP;
EventHandlerUPP mouseUPP;
EventHandlerUPP commandUPP;
EventHandlerUPP keyboardUPP;
};
GLFWGLOBAL _GLFWwin _glfwWin;
//------------------------------------------------------------------------
// User input status (some of this should go in _GLFWwin)
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Mouse status
int MousePosX, MousePosY;
int WheelPos;
char MouseButton[ GLFW_MOUSE_BUTTON_LAST + 1 ];
// Keyboard status
char Key[ GLFW_KEY_LAST + 1 ];
int LastChar;
// User selected settings
int StickyKeys;
int StickyMouseButtons;
int KeyRepeat;
// ========= PLATFORM SPECIFIC PART ======================================
UInt32 Modifiers;
} _glfwInput;
//------------------------------------------------------------------------
// Thread information
//------------------------------------------------------------------------
typedef struct _GLFWthread_struct _GLFWthread;
// Thread record (one for each thread)
struct _GLFWthread_struct {
// Pointer to previous and next threads in linked list
_GLFWthread *Previous, *Next;
// GLFW user side thread information
GLFWthread ID;
GLFWthreadfun Function;
// System side thread information
pthread_t PosixID;
};
// General thread information
GLFWGLOBAL struct {
// Critical section lock
pthread_mutex_t CriticalSection;
// Next thread ID to use (increments for every created thread)
GLFWthread NextID;
// First thread in linked list (always the main thread)
_GLFWthread First;
} _glfwThrd;
//------------------------------------------------------------------------
// Library global data
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Window opening hints
_GLFWhints hints;
// Initial desktop mode
GLFWvidmode desktopMode;
// ========= PLATFORM SPECIFIC PART ======================================
// Timer data
struct {
double t0;
} Timer;
struct {
// Bundle for dynamically-loading extension function pointers
CFBundleRef OpenGLFramework;
} Libs;
int Unbundled;
} _glfwLibrary;
//========================================================================
// Macros for encapsulating critical code sections (i.e. making parts
// of GLFW thread safe)
//========================================================================
// Define so we can use the same thread code as X11
#define _glfw_numprocessors(n) { \
int mib[2], ncpu; \
size_t len = 1; \
mib[0] = CTL_HW; \
mib[1] = HW_NCPU; \
n = 1; \
if( sysctl( mib, 2, &ncpu, &len, NULL, 0 ) != -1 ) \
{ \
if( len > 0 ) \
{ \
n = ncpu; \
} \
} \
}
// Thread list management
#define ENTER_THREAD_CRITICAL_SECTION \
pthread_mutex_lock( &_glfwThrd.CriticalSection );
#define LEAVE_THREAD_CRITICAL_SECTION \
pthread_mutex_unlock( &_glfwThrd.CriticalSection );
//========================================================================
// Prototypes for platform specific internal functions
//========================================================================
void _glfwChangeToResourcesDirectory( void );
void _glfwSaveDesktopMode( void );
#endif // _platform_h_

179
ogl_editor/src/External/glfw/lib/cocoa/Makefile.cocoa vendored Normal file
View File

@ -0,0 +1,179 @@
##########################################################################
# Makefile for GLFW on Cocoa on Mac OS X using Apple GCC
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# make -f Makefile.cocoa
##########################################################################
##########################################################################
# Installation prefix (default to /usr/local)
##########################################################################
PREFIX ?= /usr/local
##########################################################################
# Default: Build GLFW static and shared library
##########################################################################
all: libglfw.a libglfw.dylib
##########################################################################
# Compiler settings
##########################################################################
CC ?= cc
CFLAGS ?= -O2 -g
CFLAGS += -c -I. -I.. -Wall -fno-common
##########################################################################
# Library builder settings
##########################################################################
AR = ar
SED = sed
INSTALL = install
ARFLAGS = -rcs
RANLIB = ranlib
DYLIBFLAGS = -framework Cocoa -framework OpenGL -framework IOKit \
-dynamiclib -Wl,-single_module -compatibility_version 1 \
-current_version 1 -install_name @executable_path/libglfw.dylib
HEADERS = ../../include/GL/glfw.h ../internal.h platform.h
##########################################################################
# Install GLFW header and static library
##########################################################################
install: libglfw.a libglfw.pc
$(INSTALL) -d $(PREFIX)/lib
$(INSTALL) -c -m 644 libglfw.a $(PREFIX)/lib/libglfw.a
$(RANLIB) $(PREFIX)/lib/libglfw.a
$(INSTALL) -d $(PREFIX)/include/GL
$(INSTALL) -c -m 644 ../../include/GL/glfw.h $(PREFIX)/include/GL/glfw.h
$(INSTALL) -d $(PREFIX)/lib/pkgconfig
$(INSTALL) -c -m 644 libglfw.pc $(PREFIX)/lib/pkgconfig/libglfw.pc
##########################################################################
# Install GLFW header and static and dynamic libraries
##########################################################################
dist-install: libglfw.dylib install
$(INSTALL) -c -m 644 libglfw.dylib $(PREFIX)/lib/libglfw.dylib
##########################################################################
# Object files for the GLFW library
##########################################################################
OBJS = \
enable.o \
fullscreen.o \
glext.o \
image.o \
init.o \
input.o \
joystick.o \
stream.o \
tga.o \
thread.o \
time.o \
window.o \
cocoa_enable.o \
cocoa_fullscreen.o \
cocoa_glext.o \
cocoa_init.o \
cocoa_joystick.o \
cocoa_thread.o \
cocoa_time.o \
cocoa_window.o
##########################################################################
# Rule for building libglfw.pc
##########################################################################
libglfw.pc: libglfw.pc.in
$(SED) -e 's,\@PREFIX\@,$(PREFIX),' libglfw.pc.in > libglfw.pc
##########################################################################
# Rule for building static library
##########################################################################
libglfw.a: $(OBJS)
$(AR) $(ARFLAGS) $@ $(OBJS)
$(RANLIB) $@
##########################################################################
# Rule for building shared library
##########################################################################
libglfw.dylib: $(OBJS)
$(CC) -o $@ $(DYLIBFLAGS) $(OBJS)
##########################################################################
# Rule for cleaning up generated files
##########################################################################
clean:
rm -f $(OBJS) libglfw.a libglfw.dylib libglfw.pc
##########################################################################
# Rules for building library object files
##########################################################################
enable.o: ../enable.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../enable.c
fullscreen.o: ../fullscreen.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../fullscreen.c
glext.o: ../glext.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../glext.c
image.o: ../image.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../image.c
init.o: ../init.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../init.c
input.o: ../input.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../input.c
joystick.o: ../joystick.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../joystick.c
stream.o: ../stream.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../stream.c
tga.o: ../tga.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../tga.c
thread.o: ../thread.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../thread.c
time.o: ../time.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../time.c
window.o: ../window.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../window.c
cocoa_enable.o: cocoa_enable.m $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_enable.m
cocoa_fullscreen.o: cocoa_fullscreen.m $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_fullscreen.m
cocoa_glext.o: cocoa_glext.m $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_glext.m
cocoa_init.o: cocoa_init.m $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_init.m
cocoa_joystick.o: cocoa_joystick.m $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_joystick.m
cocoa_thread.o: cocoa_thread.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_thread.c
cocoa_time.o: cocoa_time.m $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_time.m
cocoa_window.o: cocoa_window.m $(HEADERS)
$(CC) $(CFLAGS) -o $@ cocoa_window.m

51
ogl_editor/src/External/glfw/lib/cocoa/cocoa_enable.m vendored Normal file
View File

@ -0,0 +1,51 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Enable and disable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys( void )
{
// This is checked in macosx_window.m; we take no action here
}
void _glfwPlatformDisableSystemKeys( void )
{
// This is checked in macosx_window.m; we take no action here
// I don't think it's really possible to disable stuff like Exposé
// except in full-screen mode.
}

104
ogl_editor/src/External/glfw/lib/cocoa/cocoa_fullscreen.m vendored Normal file
View File

@ -0,0 +1,104 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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.
//
//========================================================================
#include "internal.h"
//========================================================================
// Check whether the display mode should be included in enumeration
//========================================================================
static BOOL modeIsGood( NSDictionary *mode )
{
// This is a bit controversial, if you've got something other than an
// LCD computer monitor as an output device you might not want these
// checks. You might also want to reject modes which are interlaced,
// or TV out. There is no one-size-fits-all policy that can work here.
// This seems like a decent compromise, but certain applications may
// wish to patch this...
return [[mode objectForKey:(id)kCGDisplayBitsPerPixel] intValue] >= 15 &&
[mode objectForKey:(id)kCGDisplayModeIsSafeForHardware] != nil &&
[mode objectForKey:(id)kCGDisplayModeIsStretched] == nil;
}
//========================================================================
// Convert Core Graphics display mode to GLFW video mode
//========================================================================
static GLFWvidmode vidmodeFromCGDisplayMode( NSDictionary *mode )
{
unsigned int width = [[mode objectForKey:(id)kCGDisplayWidth] unsignedIntValue];
unsigned int height = [[mode objectForKey:(id)kCGDisplayHeight] unsignedIntValue];
unsigned int bps = [[mode objectForKey:(id)kCGDisplayBitsPerSample] unsignedIntValue];
GLFWvidmode result;
result.Width = width;
result.Height = height;
result.RedBits = bps;
result.GreenBits = bps;
result.BlueBits = bps;
return result;
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Get a list of available video modes
//========================================================================
int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )
{
NSArray *modes = (NSArray *)CGDisplayAvailableModes( CGMainDisplayID() );
unsigned int i, j = 0, n = [modes count];
for( i = 0; i < n && j < (unsigned)maxcount; i++ )
{
NSDictionary *mode = [modes objectAtIndex:i];
if( modeIsGood( mode ) )
{
list[j++] = vidmodeFromCGDisplayMode( mode );
}
}
return j;
}
//========================================================================
// Get the desktop video mode
//========================================================================
void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )
{
*mode = vidmodeFromCGDisplayMode( CGDisplayCurrentMode( CGMainDisplayID() ) );
}

64
ogl_editor/src/External/glfw/lib/cocoa/cocoa_glext.m vendored Normal file
View File

@ -0,0 +1,64 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Check if an OpenGL extension is available at runtime
//========================================================================
int _glfwPlatformExtensionSupported( const char *extension )
{
// There are no AGL, CGL or NSGL extensions.
return GL_FALSE;
}
//========================================================================
// Get the function pointer to an OpenGL function
//========================================================================
void * _glfwPlatformGetProcAddress( const char *procname )
{
CFStringRef symbolName = CFStringCreateWithCString( kCFAllocatorDefault,
procname,
kCFStringEncodingASCII );
void *symbol = CFBundleGetFunctionPointerForName( _glfwLibrary.OpenGLFramework,
symbolName );
CFRelease( symbolName );
return symbol;
}

195
ogl_editor/src/External/glfw/lib/cocoa/cocoa_init.m vendored Normal file
View File

@ -0,0 +1,195 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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.
//
//========================================================================
#include <sys/param.h>
#include "internal.h"
@interface GLFWThread : NSThread
@end
@implementation GLFWThread
- (void)main
{
}
@end
//========================================================================
// Change to our application bundle's resources directory, if present
//========================================================================
static void changeToResourcesDirectory( void )
{
char resourcesPath[MAXPATHLEN];
CFBundleRef bundle = CFBundleGetMainBundle();
if( !bundle )
return;
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL( bundle );
CFStringRef last = CFURLCopyLastPathComponent( resourcesURL );
if( CFStringCompare( CFSTR( "Resources" ), last, 0 ) != kCFCompareEqualTo )
{
CFRelease( last );
CFRelease( resourcesURL );
return;
}
CFRelease( last );
if( !CFURLGetFileSystemRepresentation( resourcesURL,
true,
(UInt8*) resourcesPath,
MAXPATHLEN) )
{
CFRelease( resourcesURL );
return;
}
CFRelease( resourcesURL );
chdir( resourcesPath );
}
//========================================================================
// Terminate GLFW when exiting application
//========================================================================
static void glfw_atexit( void )
{
glfwTerminate();
}
//========================================================================
// Initialize GLFW thread package
//========================================================================
static void initThreads( void )
{
// Initialize critical section handle
(void) pthread_mutex_init( &_glfwThrd.CriticalSection, NULL );
// The first thread (the main thread) has ID 0
_glfwThrd.NextID = 0;
// Fill out information about the main thread (this thread)
_glfwThrd.First.ID = _glfwThrd.NextID ++;
_glfwThrd.First.Function = NULL;
_glfwThrd.First.PosixID = pthread_self();
_glfwThrd.First.Previous = NULL;
_glfwThrd.First.Next = NULL;
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Initialize the GLFW library
//========================================================================
int _glfwPlatformInit( void )
{
_glfwLibrary.autoreleasePool = [[NSAutoreleasePool alloc] init];
_glfwLibrary.OpenGLFramework =
CFBundleGetBundleWithIdentifier( CFSTR( "com.apple.opengl" ) );
if( _glfwLibrary.OpenGLFramework == NULL )
{
return GL_FALSE;
}
GLFWThread* thread = [[GLFWThread alloc] init];
[thread start];
[thread release];
changeToResourcesDirectory();
_glfwPlatformGetDesktopMode( &_glfwLibrary.desktopMode );
// Install atexit routine
atexit( glfw_atexit );
initThreads();
_glfwInitTimer();
_glfwInitJoysticks();
_glfwLibrary.eventSource = CGEventSourceCreate( kCGEventSourceStateHIDSystemState );
if( !_glfwLibrary.eventSource )
{
return GL_FALSE;
}
CGEventSourceSetLocalEventsSuppressionInterval( _glfwLibrary.eventSource,
0.0 );
_glfwPlatformSetTime( 0.0 );
return GL_TRUE;
}
//========================================================================
// Close window, if open, and shut down GLFW
//========================================================================
int _glfwPlatformTerminate( void )
{
if( pthread_self() != _glfwThrd.First.PosixID )
{
return GL_FALSE;
}
glfwCloseWindow();
// TODO: Kill all non-main threads?
// TODO: Probably other cleanup
if( _glfwLibrary.eventSource )
{
CFRelease( _glfwLibrary.eventSource );
_glfwLibrary.eventSource = NULL;
}
_glfwTerminateJoysticks();
[_glfwLibrary.autoreleasePool release];
_glfwLibrary.autoreleasePool = nil;
return GL_TRUE;
}

648
ogl_editor/src/External/glfw/lib/cocoa/cocoa_joystick.m vendored Normal file
View File

@ -0,0 +1,648 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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.
//
//========================================================================
#include "internal.h"
#include <unistd.h>
#include <ctype.h>
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOCFPlugIn.h>
#include <IOKit/hid/IOHIDLib.h>
#include <IOKit/hid/IOHIDKeys.h>
#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
//------------------------------------------------------------------------
// Joystick state
//------------------------------------------------------------------------
typedef struct
{
int present;
char product[256];
IOHIDDeviceInterface** interface;
int numAxes;
int numButtons;
int numHats;
CFMutableArrayRef axes;
CFMutableArrayRef buttons;
CFMutableArrayRef hats;
} _glfwJoystick;
static _glfwJoystick _glfwJoysticks[GLFW_JOYSTICK_LAST + 1];
typedef struct
{
IOHIDElementCookie cookie;
long value;
long min;
long max;
long minReport;
long maxReport;
} _glfwJoystickElement;
void GetElementsCFArrayHandler( const void* value, void* parameter );
//========================================================================
// Adds an element to the specified joystick
//========================================================================
static void addJoystickElement( _glfwJoystick* joystick, CFTypeRef refElement )
{
long elementType, usagePage, usage;
CFTypeRef refElementType, refUsagePage, refUsage;
refElementType = CFDictionaryGetValue( refElement, CFSTR( kIOHIDElementTypeKey ) );
refUsagePage = CFDictionaryGetValue( refElement, CFSTR( kIOHIDElementUsagePageKey ) );
refUsage = CFDictionaryGetValue( refElement, CFSTR( kIOHIDElementUsageKey ) );
CFMutableArrayRef elementsArray = NULL;
CFNumberGetValue( refElementType, kCFNumberLongType, &elementType );
CFNumberGetValue( refUsagePage, kCFNumberLongType, &usagePage );
CFNumberGetValue( refUsage, kCFNumberLongType, &usage );
if( elementType == kIOHIDElementTypeInput_Axis ||
elementType == kIOHIDElementTypeInput_Button ||
elementType == kIOHIDElementTypeInput_Misc )
{
switch( usagePage ) /* only interested in kHIDPage_GenericDesktop and kHIDPage_Button */
{
case kHIDPage_GenericDesktop:
{
switch( usage )
{
case kHIDUsage_GD_X:
case kHIDUsage_GD_Y:
case kHIDUsage_GD_Z:
case kHIDUsage_GD_Rx:
case kHIDUsage_GD_Ry:
case kHIDUsage_GD_Rz:
case kHIDUsage_GD_Slider:
case kHIDUsage_GD_Dial:
case kHIDUsage_GD_Wheel:
joystick->numAxes++;
elementsArray = joystick->axes;
break;
case kHIDUsage_GD_Hatswitch:
joystick->numHats++;
elementsArray = joystick->hats;
break;
}
break;
}
case kHIDPage_Button:
joystick->numButtons++;
elementsArray = joystick->buttons;
break;
default:
break;
}
if( elementsArray )
{
long number;
CFTypeRef refType;
_glfwJoystickElement* element = (_glfwJoystickElement*) malloc( sizeof( _glfwJoystickElement ) );
CFArrayAppendValue( elementsArray, element );
refType = CFDictionaryGetValue( refElement, CFSTR( kIOHIDElementCookieKey ) );
if( refType && CFNumberGetValue( refType, kCFNumberLongType, &number ) )
{
element->cookie = (IOHIDElementCookie) number;
}
refType = CFDictionaryGetValue( refElement, CFSTR( kIOHIDElementMinKey ) );
if( refType && CFNumberGetValue( refType, kCFNumberLongType, &number ) )
{
element->minReport = element->min = number;
}
refType = CFDictionaryGetValue( refElement, CFSTR( kIOHIDElementMaxKey ) );
if( refType && CFNumberGetValue( refType, kCFNumberLongType, &number ) )
{
element->maxReport = element->max = number;
}
}
}
else
{
CFTypeRef refElementTop = CFDictionaryGetValue( refElement, CFSTR( kIOHIDElementKey ) );
if( refElementTop )
{
CFTypeID type = CFGetTypeID( refElementTop );
if( type == CFArrayGetTypeID() ) /* if element is an array */
{
CFRange range = { 0, CFArrayGetCount( refElementTop ) };
CFArrayApplyFunction( refElementTop, range, GetElementsCFArrayHandler, joystick );
}
}
}
}
//========================================================================
// Adds an element to the specified joystick
//========================================================================
void GetElementsCFArrayHandler( const void* value, void* parameter )
{
if( CFGetTypeID( value ) == CFDictionaryGetTypeID() )
{
addJoystickElement( (_glfwJoystick*) parameter, (CFTypeRef) value );
}
}
//========================================================================
// Returns the value of the specified element of the specified joystick
//========================================================================
static long getElementValue( _glfwJoystick* joystick, _glfwJoystickElement* element )
{
IOReturn result = kIOReturnSuccess;
IOHIDEventStruct hidEvent;
hidEvent.value = 0;
if( joystick && element && joystick->interface )
{
result = (*(joystick->interface))->getElementValue( joystick->interface,
element->cookie,
&hidEvent );
if( kIOReturnSuccess == result )
{
/* record min and max for auto calibration */
if( hidEvent.value < element->minReport )
{
element->minReport = hidEvent.value;
}
if( hidEvent.value > element->maxReport )
{
element->maxReport = hidEvent.value;
}
}
}
/* auto user scale */
return (long) hidEvent.value;
}
//========================================================================
// Removes the specified joystick
//========================================================================
static void removeJoystick( _glfwJoystick* joystick )
{
int i;
if( joystick->present )
{
joystick->present = GL_FALSE;
for( i = 0; i < joystick->numAxes; i++ )
{
_glfwJoystickElement* axes =
(_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick->axes, i );
free( axes );
}
CFArrayRemoveAllValues( joystick->axes );
joystick->numAxes = 0;
for( i = 0; i < joystick->numButtons; i++ )
{
_glfwJoystickElement* button =
(_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick->buttons, i );
free( button );
}
CFArrayRemoveAllValues( joystick->buttons );
joystick->numButtons = 0;
for( i = 0; i < joystick->numHats; i++ )
{
_glfwJoystickElement* hat =
(_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick->hats, i );
free( hat );
}
CFArrayRemoveAllValues( joystick->hats );
joystick->hats = 0;
(*(joystick->interface))->close( joystick->interface );
(*(joystick->interface))->Release( joystick->interface );
joystick->interface = NULL;
}
}
//========================================================================
// Callback for user-initiated joystick removal
//========================================================================
static void removalCallback( void* target, IOReturn result, void* refcon, void* sender )
{
removeJoystick( (_glfwJoystick*) refcon );
}
//========================================================================
// Polls for joystick events and updates GFLW state
//========================================================================
static void pollJoystickEvents( void )
{
int i;
CFIndex j;
for( i = 0; i < GLFW_JOYSTICK_LAST + 1; i++ )
{
_glfwJoystick* joystick = &_glfwJoysticks[i];
if( joystick->present )
{
for( j = 0; j < joystick->numButtons; j++ )
{
_glfwJoystickElement* button =
(_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick->buttons, j );
button->value = getElementValue( joystick, button );
}
for( j = 0; j < joystick->numAxes; j++ )
{
_glfwJoystickElement* axes =
(_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick->axes, j );
axes->value = getElementValue( joystick, axes );
}
for( j = 0; j < joystick->numHats; j++ )
{
_glfwJoystickElement* hat =
(_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick->hats, j );
hat->value = getElementValue( joystick, hat );
}
}
}
}
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Initialize joystick interface
//========================================================================
void _glfwInitJoysticks( void )
{
int deviceCounter = 0;
IOReturn result = kIOReturnSuccess;
mach_port_t masterPort = 0;
io_iterator_t objectIterator = 0;
CFMutableDictionaryRef hidMatchDictionary = NULL;
io_object_t ioHIDDeviceObject = 0;
result = IOMasterPort( bootstrap_port, &masterPort );
hidMatchDictionary = IOServiceMatching( kIOHIDDeviceKey );
if( kIOReturnSuccess != result || !hidMatchDictionary )
{
if( hidMatchDictionary )
{
CFRelease( hidMatchDictionary );
}
return;
}
result = IOServiceGetMatchingServices( masterPort,
hidMatchDictionary,
&objectIterator );
if( result != kIOReturnSuccess )
{
return;
}
if( !objectIterator ) /* there are no joysticks */
{
return;
}
while( ( ioHIDDeviceObject = IOIteratorNext( objectIterator ) ) )
{
CFMutableDictionaryRef hidProperties = 0;
kern_return_t result;
CFTypeRef refCF = 0;
IOCFPlugInInterface** ppPlugInInterface = NULL;
HRESULT plugInResult = S_OK;
SInt32 score = 0;
long usagePage, usage;
result = IORegistryEntryCreateCFProperties( ioHIDDeviceObject,
&hidProperties,
kCFAllocatorDefault,
kNilOptions );
if( result != kIOReturnSuccess )
{
continue;
}
/* Check device type */
refCF = CFDictionaryGetValue( hidProperties, CFSTR( kIOHIDPrimaryUsagePageKey ) );
if( refCF )
{
CFNumberGetValue( refCF, kCFNumberLongType, &usagePage );
if( usagePage != kHIDPage_GenericDesktop )
{
/* We are not interested in this device */
continue;
}
}
refCF = CFDictionaryGetValue( hidProperties, CFSTR( kIOHIDPrimaryUsageKey ) );
if( refCF )
{
CFNumberGetValue( refCF, kCFNumberLongType, &usage );
if( usage != kHIDUsage_GD_Joystick &&
usage != kHIDUsage_GD_GamePad &&
usage != kHIDUsage_GD_MultiAxisController )
{
/* We are not interested in this device */
continue;
}
}
_glfwJoystick* joystick = &_glfwJoysticks[deviceCounter];
joystick->present = GL_TRUE;
result = IOCreatePlugInInterfaceForService( ioHIDDeviceObject,
kIOHIDDeviceUserClientTypeID,
kIOCFPlugInInterfaceID,
&ppPlugInInterface,
&score );
if( kIOReturnSuccess != result )
{
return;
}
plugInResult = (*ppPlugInInterface)->QueryInterface( ppPlugInInterface,
CFUUIDGetUUIDBytes( kIOHIDDeviceInterfaceID ),
(void *) &(joystick->interface) );
if( plugInResult != S_OK )
{
return;
}
(*ppPlugInInterface)->Release( ppPlugInInterface );
(*(joystick->interface))->open( joystick->interface, 0 );
(*(joystick->interface))->setRemovalCallback( joystick->interface,
removalCallback,
joystick,
joystick );
/* Get product string */
refCF = CFDictionaryGetValue( hidProperties, CFSTR( kIOHIDProductKey ) );
if( refCF )
{
CFStringGetCString( refCF,
(char*) &(joystick->product),
256,
CFStringGetSystemEncoding() );
}
joystick->numAxes = 0;
joystick->numButtons = 0;
joystick->numHats = 0;
joystick->axes = CFArrayCreateMutable( NULL, 0, NULL );
joystick->buttons = CFArrayCreateMutable( NULL, 0, NULL );
joystick->hats = CFArrayCreateMutable( NULL, 0, NULL );
CFTypeRef refTopElement = CFDictionaryGetValue( hidProperties,
CFSTR( kIOHIDElementKey ) );
CFTypeID type = CFGetTypeID( refTopElement );
if( type == CFArrayGetTypeID() )
{
CFRange range = { 0, CFArrayGetCount( refTopElement ) };
CFArrayApplyFunction( refTopElement,
range,
GetElementsCFArrayHandler,
(void*) joystick);
}
deviceCounter++;
}
}
//========================================================================
// Close all opened joystick handles
//========================================================================
void _glfwTerminateJoysticks( void )
{
int i;
for( i = 0; i < GLFW_JOYSTICK_LAST + 1; i++ )
{
_glfwJoystick* joystick = &_glfwJoysticks[i];
removeJoystick( joystick );
}
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Determine joystick capabilities
//========================================================================
int _glfwPlatformGetJoystickParam( int joy, int param )
{
if( !_glfwJoysticks[joy].present )
{
// TODO: Figure out if this is an error
return GL_FALSE;
}
switch( param )
{
case GLFW_PRESENT:
return GL_TRUE;
case GLFW_AXES:
return (int) CFArrayGetCount( _glfwJoysticks[joy].axes );
case GLFW_BUTTONS:
return (int) CFArrayGetCount( _glfwJoysticks[joy].buttons ) +
((int) CFArrayGetCount( _glfwJoysticks[joy].hats )) * 4;
default:
break;
}
return GL_FALSE;
}
//========================================================================
// Get joystick axis positions
//========================================================================
int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )
{
int i;
if( joy < GLFW_JOYSTICK_1 || joy > GLFW_JOYSTICK_LAST )
{
return 0;
}
_glfwJoystick joystick = _glfwJoysticks[joy];
if( !joystick.present )
{
// TODO: Figure out if this is an error
return 0;
}
numaxes = numaxes < joystick.numAxes ? numaxes : joystick.numAxes;
// Update joystick state
pollJoystickEvents();
for( i = 0; i < numaxes; i++ )
{
_glfwJoystickElement* axes =
(_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick.axes, i );
long readScale = axes->maxReport - axes->minReport;
if( readScale == 0 )
{
pos[i] = axes->value;
}
else
{
pos[i] = (2.0f * (axes->value - axes->minReport) / readScale) - 1.0f;
}
//printf("%ld, %ld, %ld\n", axes->value, axes->minReport, axes->maxReport);
if( i & 1 )
{
pos[i] = -pos[i];
}
}
return numaxes;
}
//========================================================================
// Get joystick button states
//========================================================================
int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons, int numbuttons )
{
int i, j, button;
if( joy < GLFW_JOYSTICK_1 || joy > GLFW_JOYSTICK_LAST )
{
return 0;
}
_glfwJoystick joystick = _glfwJoysticks[joy];
if( !joystick.present )
{
// TODO: Figure out if this is an error
return 0;
}
// Update joystick state
pollJoystickEvents();
for( button = 0; button < numbuttons && button < joystick.numButtons; button++ )
{
_glfwJoystickElement* element = (_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick.buttons, button );
buttons[button] = element->value ? GLFW_PRESS : GLFW_RELEASE;
}
// Virtual buttons - Inject data from hats
// Each hat is exposed as 4 buttons which exposes 8 directions with concurrent button presses
const int directions[9] = { 1, 3, 2, 6, 4, 12, 8, 9, 0 }; // Bit fields of button presses for each direction, including nil
for( i = 0; i < joystick.numHats; i++ )
{
_glfwJoystickElement* hat = (_glfwJoystickElement*) CFArrayGetValueAtIndex( joystick.hats, i );
int value = hat->value;
if( value < 0 || value > 8 )
{
value = 8;
}
for( j = 0; j < 4 && button < numbuttons; j++ )
{
buttons[button++] = directions[value] & (1 << j) ? GLFW_PRESS : GLFW_RELEASE;
}
}
return button;
}

414
ogl_editor/src/External/glfw/lib/cocoa/cocoa_thread.c vendored Normal file
View File

@ -0,0 +1,414 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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.
//
//========================================================================
#include "internal.h"
#include <sys/time.h>
#include <sys/sysctl.h>
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// _glfwNewThread() - This is simply a "wrapper" for calling the user
// thread function.
//========================================================================
void * _glfwNewThread( void * arg )
{
GLFWthreadfun threadfun;
_GLFWthread *t;
// Get pointer to thread information for current thread
t = _glfwGetThreadPointer( glfwGetThreadID() );
if( t == NULL )
{
return 0;
}
// Get user thread function pointer
threadfun = t->Function;
// Call the user thread function
threadfun( arg );
// Remove thread from thread list
ENTER_THREAD_CRITICAL_SECTION
_glfwRemoveThread( t );
LEAVE_THREAD_CRITICAL_SECTION
// When the thread function returns, the thread will die...
return NULL;
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// _glfwPlatformCreateThread() - Create a new thread
//========================================================================
GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )
{
GLFWthread ID;
_GLFWthread *t;
int result;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Create a new thread information memory area
t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );
if( t == NULL )
{
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Get a new unique thread id
ID = _glfwThrd.NextID ++;
// Store thread information in the thread list
t->Function = fun;
t->ID = ID;
// Create thread
result = pthread_create(
&t->PosixID, // Thread handle
NULL, // Default thread attributes
_glfwNewThread, // Thread function (a wrapper function)
(void *)arg // Argument to thread is user argument
);
// Did the thread creation fail?
if( result != 0 )
{
free( (void *) t );
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Append thread to thread list
_glfwAppendThread( t );
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the GLFW thread ID
return ID;
}
//========================================================================
// _glfwPlatformDestroyThread() - Kill a thread. NOTE: THIS IS A VERY
// DANGEROUS OPERATION, AND SHOULD NOT BE USED EXCEPT IN EXTREME
// SITUATIONS!
//========================================================================
void _glfwPlatformDestroyThread( GLFWthread ID )
{
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return;
}
// Simply murder the process, no mercy!
pthread_kill( t->PosixID, SIGKILL );
// Remove thread from thread list
_glfwRemoveThread( t );
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
}
//========================================================================
// _glfwPlatformWaitThread() - Wait for a thread to die
//========================================================================
int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )
{
pthread_t thread;
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
// Is the thread already dead?
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return GL_TRUE;
}
// If got this far, the thread is alive => polling returns FALSE
if( waitmode == GLFW_NOWAIT )
{
LEAVE_THREAD_CRITICAL_SECTION
return GL_FALSE;
}
// Get thread handle
thread = t->PosixID;
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Wait for thread to die
(void) pthread_join( thread, NULL );
return GL_TRUE;
}
//========================================================================
// _glfwPlatformGetThreadID() - Return the thread ID for the current
// thread
//========================================================================
GLFWthread _glfwPlatformGetThreadID( void )
{
_GLFWthread *t;
GLFWthread ID = -1;
pthread_t posixID;
// Get current thread ID
posixID = pthread_self();
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Loop through entire list of threads to find the matching POSIX
// thread ID
for( t = &_glfwThrd.First; t != NULL; t = t->Next )
{
if( t->PosixID == posixID )
{
ID = t->ID;
break;
}
}
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the found GLFW thread identifier
return ID;
}
//========================================================================
// _glfwPlatformCreateMutex() - Create a mutual exclusion object
//========================================================================
GLFWmutex _glfwPlatformCreateMutex( void )
{
pthread_mutex_t *mutex;
// Allocate memory for mutex
mutex = (pthread_mutex_t *) malloc( sizeof( pthread_mutex_t ) );
if( !mutex )
{
return NULL;
}
// Initialise a mutex object
(void) pthread_mutex_init( mutex, NULL );
// Cast to GLFWmutex and return
return (GLFWmutex) mutex;
}
//========================================================================
// _glfwPlatformDestroyMutex() - Destroy a mutual exclusion object
//========================================================================
void _glfwPlatformDestroyMutex( GLFWmutex mutex )
{
// Destroy the mutex object
pthread_mutex_destroy( (pthread_mutex_t *) mutex );
// Free memory for mutex object
free( (void *) mutex );
}
//========================================================================
// _glfwPlatformLockMutex() - Request access to a mutex
//========================================================================
void _glfwPlatformLockMutex( GLFWmutex mutex )
{
// Wait for mutex to be released
(void) pthread_mutex_lock( (pthread_mutex_t *) mutex );
}
//========================================================================
// _glfwPlatformUnlockMutex() - Release a mutex
//========================================================================
void _glfwPlatformUnlockMutex( GLFWmutex mutex )
{
// Release mutex
pthread_mutex_unlock( (pthread_mutex_t *) mutex );
}
//========================================================================
// _glfwPlatformCreateCond() - Create a new condition variable object
//========================================================================
GLFWcond _glfwPlatformCreateCond( void )
{
pthread_cond_t *cond;
// Allocate memory for condition variable
cond = (pthread_cond_t *) malloc( sizeof(pthread_cond_t) );
if( !cond )
{
return NULL;
}
// Initialise condition variable
(void) pthread_cond_init( cond, NULL );
// Cast to GLFWcond and return
return (GLFWcond) cond;
}
//========================================================================
// _glfwPlatformDestroyCond() - Destroy a condition variable object
//========================================================================
void _glfwPlatformDestroyCond( GLFWcond cond )
{
// Destroy the condition variable object
(void) pthread_cond_destroy( (pthread_cond_t *) cond );
// Free memory for condition variable object
free( (void *) cond );
}
//========================================================================
// _glfwPlatformWaitCond() - Wait for a condition to be raised
//========================================================================
void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex,
double timeout )
{
struct timeval currenttime;
struct timespec wait;
long dt_sec, dt_usec;
// Select infinite or timed wait
if( timeout >= GLFW_INFINITY )
{
// Wait for condition (infinite wait)
(void) pthread_cond_wait( (pthread_cond_t *) cond,
(pthread_mutex_t *) mutex );
}
else
{
// Set timeout time, relatvie to current time
gettimeofday( &currenttime, NULL );
dt_sec = (long) timeout;
dt_usec = (long) ((timeout - (double)dt_sec) * 1000000.0);
wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;
if( wait.tv_nsec > 1000000000L )
{
wait.tv_nsec -= 1000000000L;
dt_sec ++;
}
wait.tv_sec = currenttime.tv_sec + dt_sec;
// Wait for condition (timed wait)
(void) pthread_cond_timedwait( (pthread_cond_t *) cond,
(pthread_mutex_t *) mutex, &wait );
}
}
//========================================================================
// _glfwPlatformSignalCond() - Signal a condition to one waiting thread
//========================================================================
void _glfwPlatformSignalCond( GLFWcond cond )
{
// Signal condition
(void) pthread_cond_signal( (pthread_cond_t *) cond );
}
//========================================================================
// _glfwPlatformBroadcastCond() - Broadcast a condition to all waiting
// threads
//========================================================================
void _glfwPlatformBroadcastCond( GLFWcond cond )
{
// Broadcast condition
(void) pthread_cond_broadcast( (pthread_cond_t *) cond );
}
//========================================================================
// _glfwPlatformGetNumberOfProcessors() - Return the number of processors
// in the system.
//========================================================================
int _glfwPlatformGetNumberOfProcessors( void )
{
int n;
// Get number of processors online
_glfw_numprocessors( n );
return n;
}

135
ogl_editor/src/External/glfw/lib/cocoa/cocoa_time.m vendored Normal file
View File

@ -0,0 +1,135 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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.
//
//========================================================================
#include "internal.h"
#include <mach/mach_time.h>
#include <sys/time.h>
//========================================================================
// Return raw time
//========================================================================
static uint64_t getRawTime( void )
{
return mach_absolute_time();
}
//========================================================================
// Initialise timer
//========================================================================
void _glfwInitTimer( void )
{
mach_timebase_info_data_t info;
mach_timebase_info( &info );
_glfwLibrary.timer.resolution = (double) info.numer / ( info.denom * 1.0e9 );
_glfwLibrary.timer.base = getRawTime();
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Return timer value in seconds
//========================================================================
double _glfwPlatformGetTime( void )
{
return (double) ( getRawTime() - _glfwLibrary.timer.base ) *
_glfwLibrary.timer.resolution;
}
//========================================================================
// Set timer value in seconds
//========================================================================
void _glfwPlatformSetTime( double time )
{
_glfwLibrary.timer.base = getRawTime() -
(uint64_t) ( time / _glfwLibrary.timer.resolution );
}
//========================================================================
// Put a thread to sleep for a specified amount of time
//========================================================================
void _glfwPlatformSleep( double time )
{
if( time == 0.0 )
{
sched_yield();
return;
}
struct timeval currenttime;
struct timespec wait;
pthread_mutex_t mutex;
pthread_cond_t cond;
long dt_sec, dt_usec;
// Not all pthread implementations have a pthread_sleep() function. We
// do it the portable way, using a timed wait for a condition that we
// will never signal. NOTE: The unistd functions sleep/usleep suspends
// the entire PROCESS, not a signle thread, which is why we can not
// use them to implement glfwSleep.
// Set timeout time, relatvie to current time
gettimeofday( &currenttime, NULL );
dt_sec = (long) time;
dt_usec = (long) ((time - (double)dt_sec) * 1000000.0);
wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;
if( wait.tv_nsec > 1000000000L )
{
wait.tv_nsec -= 1000000000L;
dt_sec ++;
}
wait.tv_sec = currenttime.tv_sec + dt_sec;
// Initialize condition and mutex objects
pthread_mutex_init( &mutex, NULL );
pthread_cond_init( &cond, NULL );
// Do a timed wait
pthread_mutex_lock( &mutex );
pthread_cond_timedwait( &cond, &mutex, &wait );
pthread_mutex_unlock( &mutex );
// Destroy condition and mutex objects
pthread_mutex_destroy( &mutex );
pthread_cond_destroy( &cond );
}

1139
ogl_editor/src/External/glfw/lib/cocoa/cocoa_window.m vendored Normal file
View File

File diff suppressed because it is too large Load Diff

11
ogl_editor/src/External/glfw/lib/cocoa/libglfw.pc.in vendored Normal file
View File

@ -0,0 +1,11 @@
prefix=@PREFIX@
exec_prefix=@PREFIX@
libdir=@PREFIX@/lib
includedir=@PREFIX@/include
Name: GLFW
Description: A portable framework for OpenGL development
Version: 2.7
URL: http://www.glfw.org/
Libs: -L${libdir} -lglfw -framework Cocoa -framework OpenGL -framework IOKit
Cflags: -I${includedir}

268
ogl_editor/src/External/glfw/lib/cocoa/platform.h vendored Normal file
View File

@ -0,0 +1,268 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Cocoa/NSOpenGL
// API Version: 2.7
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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 _platform_h_
#define _platform_h_
// This is the Mac OS X version of GLFW
#define _GLFW_MAC_OS_X
#if defined(__OBJC__)
#import <Cocoa/Cocoa.h>
#else
#include <ApplicationServices/ApplicationServices.h>
typedef void *id;
#endif
#include <pthread.h>
#include "../../include/GL/glfw.h"
#ifndef GL_VERSION_3_0
typedef const GLubyte * (APIENTRY *PFNGLGETSTRINGIPROC) (GLenum, GLuint);
#endif /*GL_VERSION_3_0*/
//========================================================================
// GLFW platform specific types
//========================================================================
//------------------------------------------------------------------------
// Pointer length integer
//------------------------------------------------------------------------
typedef intptr_t GLFWintptr;
//------------------------------------------------------------------------
// Window structure
//------------------------------------------------------------------------
typedef struct _GLFWwin_struct _GLFWwin;
struct _GLFWwin_struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// User callback functions
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWmousewheelfun mouseWheelCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
// User selected window settings
int fullscreen; // Fullscreen flag
int mouseLock; // Mouse-lock flag
int autoPollEvents; // Auto polling flag
int sysKeysDisabled; // System keys disabled flag
int windowNoResize; // Resize- and maximize gadgets disabled flag
int refreshRate; // Vertical monitor refresh rate
// Window status & parameters
int opened; // Flag telling if window is opened or not
int active; // Application active flag
int iconified; // Window iconified flag
int width, height; // Window width and heigth
int accelerated; // GL_TRUE if window is HW accelerated
// Framebuffer attributes
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;
// OpenGL extensions and context attributes
int has_GL_SGIS_generate_mipmap;
int has_GL_ARB_texture_non_power_of_two;
int glMajor, glMinor, glRevision;
int glForward, glDebug, glProfile;
PFNGLGETSTRINGIPROC GetStringi;
// ========= PLATFORM SPECIFIC PART ======================================
id window;
id pixelFormat;
id context;
id delegate;
unsigned int modifierFlags;
};
GLFWGLOBAL _GLFWwin _glfwWin;
//------------------------------------------------------------------------
// Library global data
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Window opening hints
_GLFWhints hints;
// Initial desktop mode
GLFWvidmode desktopMode;
// ========= PLATFORM SPECIFIC PART ======================================
// Timer data
struct {
double base;
double resolution;
} timer;
// dlopen handle for dynamically-loading extension function pointers
void *OpenGLFramework;
id originalMode;
id autoreleasePool;
CGEventSourceRef eventSource;
} _glfwLibrary;
//------------------------------------------------------------------------
// User input status (some of this should go in _GLFWwin)
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Mouse status
int MousePosX, MousePosY;
int WheelPos;
char MouseButton[ GLFW_MOUSE_BUTTON_LAST+1 ];
// Keyboard status
char Key[ GLFW_KEY_LAST+1 ];
int LastChar;
// User selected settings
int StickyKeys;
int StickyMouseButtons;
int KeyRepeat;
// ========= PLATFORM SPECIFIC PART ======================================
double WheelPosFloating;
} _glfwInput;
//------------------------------------------------------------------------
// Thread information
//------------------------------------------------------------------------
typedef struct _GLFWthread_struct _GLFWthread;
// Thread record (one for each thread)
struct _GLFWthread_struct {
// Pointer to previous and next threads in linked list
_GLFWthread *Previous, *Next;
// GLFW user side thread information
GLFWthread ID;
GLFWthreadfun Function;
// System side thread information
pthread_t PosixID;
};
// General thread information
GLFWGLOBAL struct {
// Critical section lock
pthread_mutex_t CriticalSection;
// Next thread ID to use (increments for every created thread)
GLFWthread NextID;
// First thread in linked list (always the main thread)
_GLFWthread First;
} _glfwThrd;
//========================================================================
// Macros for encapsulating critical code sections (i.e. making parts
// of GLFW thread safe)
//========================================================================
// Define so we can use the same thread code as X11
#define _glfw_numprocessors(n) { \
int mib[2], ncpu; \
size_t len = 1; \
mib[0] = CTL_HW; \
mib[1] = HW_NCPU; \
n = 1; \
if( sysctl( mib, 2, &ncpu, &len, NULL, 0 ) != -1 ) \
{ \
if( len > 0 ) \
{ \
n = ncpu; \
} \
} \
}
// Thread list management
#define ENTER_THREAD_CRITICAL_SECTION \
pthread_mutex_lock( &_glfwThrd.CriticalSection );
#define LEAVE_THREAD_CRITICAL_SECTION \
pthread_mutex_unlock( &_glfwThrd.CriticalSection );
//========================================================================
// Prototypes for platform specific internal functions
//========================================================================
// Time
void _glfwInitTimer( void );
// Joystick
void _glfwInitJoysticks( void );
void _glfwTerminateJoysticks( void );
#endif // _platform_h_

306
ogl_editor/src/External/glfw/lib/enable.c vendored Normal file
View File

@ -0,0 +1,306 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Enable (show) mouse cursor
//========================================================================
static void enableMouseCursor( void )
{
int centerPosX, centerPosY;
if( !_glfwWin.opened || !_glfwWin.mouseLock )
{
return;
}
// Show mouse cursor
_glfwPlatformShowMouseCursor();
centerPosX = _glfwWin.width / 2;
centerPosY = _glfwWin.height / 2;
if( centerPosX != _glfwInput.MousePosX || centerPosY != _glfwInput.MousePosY )
{
_glfwPlatformSetMouseCursorPos( centerPosX, centerPosY );
_glfwInput.MousePosX = centerPosX;
_glfwInput.MousePosY = centerPosY;
if( _glfwWin.mousePosCallback )
{
_glfwWin.mousePosCallback( _glfwInput.MousePosX,
_glfwInput.MousePosY );
}
}
// From now on the mouse is unlocked
_glfwWin.mouseLock = GL_FALSE;
}
//========================================================================
// Disable (hide) mouse cursor
//========================================================================
static void disableMouseCursor( void )
{
if( !_glfwWin.opened || _glfwWin.mouseLock )
{
return;
}
// Hide mouse cursor
_glfwPlatformHideMouseCursor();
// From now on the mouse is locked
_glfwWin.mouseLock = GL_TRUE;
}
//========================================================================
// Enable sticky keys
//========================================================================
static void enableStickyKeys( void )
{
_glfwInput.StickyKeys = 1;
}
//========================================================================
// Disable sticky keys
//========================================================================
static void disableStickyKeys( void )
{
int i;
_glfwInput.StickyKeys = 0;
// Release all sticky keys
for( i = 0; i <= GLFW_KEY_LAST; i++ )
{
if( _glfwInput.Key[ i ] == 2 )
{
_glfwInput.Key[ i ] = 0;
}
}
}
//========================================================================
// Enable sticky mouse buttons
//========================================================================
static void enableStickyMouseButtons( void )
{
_glfwInput.StickyMouseButtons = 1;
}
//========================================================================
// Disable sticky mouse buttons
//========================================================================
static void disableStickyMouseButtons( void )
{
int i;
_glfwInput.StickyMouseButtons = 0;
// Release all sticky mouse buttons
for( i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++ )
{
if( _glfwInput.MouseButton[ i ] == 2 )
{
_glfwInput.MouseButton[ i ] = 0;
}
}
}
//========================================================================
// Enable system keys
//========================================================================
static void enableSystemKeys( void )
{
if( !_glfwWin.sysKeysDisabled )
{
return;
}
_glfwPlatformEnableSystemKeys();
// Indicate that system keys are no longer disabled
_glfwWin.sysKeysDisabled = GL_FALSE;
}
//========================================================================
// Disable system keys
//========================================================================
static void disableSystemKeys( void )
{
if( _glfwWin.sysKeysDisabled )
{
return;
}
_glfwPlatformDisableSystemKeys();
// Indicate that system keys are now disabled
_glfwWin.sysKeysDisabled = GL_TRUE;
}
//========================================================================
// Enable key repeat
//========================================================================
static void enableKeyRepeat( void )
{
_glfwInput.KeyRepeat = 1;
}
//========================================================================
// Disable key repeat
//========================================================================
static void disableKeyRepeat( void )
{
_glfwInput.KeyRepeat = 0;
}
//========================================================================
// Enable automatic event polling
//========================================================================
static void enableAutoPollEvents( void )
{
_glfwWin.autoPollEvents = 1;
}
//========================================================================
// Disable automatic event polling
//========================================================================
static void disableAutoPollEvents( void )
{
_glfwWin.autoPollEvents = 0;
}
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Enable certain GLFW/window/system functions.
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwEnable( int token )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return;
}
switch( token )
{
case GLFW_MOUSE_CURSOR:
enableMouseCursor();
break;
case GLFW_STICKY_KEYS:
enableStickyKeys();
break;
case GLFW_STICKY_MOUSE_BUTTONS:
enableStickyMouseButtons();
break;
case GLFW_SYSTEM_KEYS:
enableSystemKeys();
break;
case GLFW_KEY_REPEAT:
enableKeyRepeat();
break;
case GLFW_AUTO_POLL_EVENTS:
enableAutoPollEvents();
break;
default:
break;
}
}
//========================================================================
// Disable certain GLFW/window/system functions.
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwDisable( int token )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return;
}
switch( token )
{
case GLFW_MOUSE_CURSOR:
disableMouseCursor();
break;
case GLFW_STICKY_KEYS:
disableStickyKeys();
break;
case GLFW_STICKY_MOUSE_BUTTONS:
disableStickyMouseButtons();
break;
case GLFW_SYSTEM_KEYS:
disableSystemKeys();
break;
case GLFW_KEY_REPEAT:
disableKeyRepeat();
break;
case GLFW_AUTO_POLL_EVENTS:
disableAutoPollEvents();
break;
default:
break;
}
}

94
ogl_editor/src/External/glfw/lib/fullscreen.c vendored Normal file
View File

@ -0,0 +1,94 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Get a list of available video modes
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetVideoModes( GLFWvidmode *list, int maxcount )
{
int count, i, swap, res1, res2, depth1, depth2;
GLFWvidmode vm;
if( !_glfwInitialized || maxcount <= 0 || list == (GLFWvidmode*) 0 )
{
return 0;
}
// Get list of video modes
count = _glfwPlatformGetVideoModes( list, maxcount );
// Sort list (bubble sort)
do
{
swap = 0;
for( i = 0; i < count-1; ++ i )
{
res1 = list[i].Width*list[i].Height;
depth1 = list[i].RedBits+list[i].GreenBits+list[i].BlueBits;
res2 = list[i+1].Width*list[i+1].Height;
depth2 = list[i+1].RedBits+list[i+1].GreenBits+
list[i+1].BlueBits;
if( (depth2<depth1) || ((depth2==depth1) && (res2<res1)) )
{
vm = list[i];
list[i] = list[i+1];
list[i+1] = vm;
swap = 1;
}
}
}
while( swap );
return count;
}
//========================================================================
// Get the desktop video mode
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwGetDesktopMode( GLFWvidmode *mode )
{
if( !_glfwInitialized || !mode )
{
return;
}
*mode = _glfwLibrary.desktopMode;
}

284
ogl_editor/src/External/glfw/lib/glext.c vendored Normal file
View File

@ -0,0 +1,284 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
#ifndef GL_VERSION_3_0
#define GL_NUM_EXTENSIONS 0x821D
#define GL_CONTEXT_FLAGS 0x821E
#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001
#endif
#ifndef GL_VERSION_3_2
#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
#define GL_CONTEXT_PROFILE_MASK 0x9126
#endif
//========================================================================
// Parses the OpenGL version string and extracts the version number
//========================================================================
void _glfwParseGLVersion( int *major, int *minor, int *rev )
{
GLuint _major, _minor = 0, _rev = 0;
const GLubyte *version;
const GLubyte *ptr;
// Get OpenGL version string
version = glGetString( GL_VERSION );
if( !version )
{
return;
}
// Parse string
ptr = version;
for( _major = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )
{
_major = 10*_major + (*ptr - '0');
}
if( *ptr == '.' )
{
ptr ++;
for( _minor = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )
{
_minor = 10*_minor + (*ptr - '0');
}
if( *ptr == '.' )
{
ptr ++;
for( _rev = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )
{
_rev = 10*_rev + (*ptr - '0');
}
}
}
// Return parsed values
*major = _major;
*minor = _minor;
*rev = _rev;
}
//========================================================================
// Check if a string can be found in an OpenGL extension string
//========================================================================
int _glfwStringInExtensionString( const char *string,
const GLubyte *extensions )
{
const GLubyte *start;
GLubyte *where, *terminator;
// It takes a bit of care to be fool-proof about parsing the
// OpenGL extensions string. Don't be fooled by sub-strings,
// etc.
start = extensions;
while( 1 )
{
where = (GLubyte *) strstr( (const char *) start, string );
if( !where )
{
return GL_FALSE;
}
terminator = where + strlen( string );
if( where == start || *(where - 1) == ' ' )
{
if( *terminator == ' ' || *terminator == '\0' )
{
break;
}
}
start = terminator;
}
return GL_TRUE;
}
//========================================================================
// Reads back OpenGL context properties from the current context
//========================================================================
void _glfwRefreshContextParams( void )
{
_glfwParseGLVersion( &_glfwWin.glMajor, &_glfwWin.glMinor,
&_glfwWin.glRevision );
_glfwWin.glProfile = 0;
_glfwWin.glForward = GL_FALSE;
// Read back the context profile, if applicable
if( _glfwWin.glMajor >= 3 )
{
GLint flags;
glGetIntegerv( GL_CONTEXT_FLAGS, &flags );
if( flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT )
{
_glfwWin.glForward = GL_TRUE;
}
}
if( _glfwWin.glMajor > 3 ||
( _glfwWin.glMajor == 3 && _glfwWin.glMinor >= 2 ) )
{
GLint mask;
glGetIntegerv( GL_CONTEXT_PROFILE_MASK, &mask );
if( mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT )
{
_glfwWin.glProfile = GLFW_OPENGL_COMPAT_PROFILE;
}
else if( mask & GL_CONTEXT_CORE_PROFILE_BIT )
{
_glfwWin.glProfile = GLFW_OPENGL_CORE_PROFILE;
}
}
}
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Check if an OpenGL extension is available at runtime
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwExtensionSupported( const char *extension )
{
const GLubyte *extensions;
GLubyte *where;
// Is GLFW initialized?
if( !_glfwInitialized || !_glfwWin.opened )
{
return GL_FALSE;
}
// Extension names should not have spaces
where = (GLubyte *) strchr( extension, ' ' );
if( where || *extension == '\0' )
{
return GL_FALSE;
}
if( _glfwWin.glMajor < 3 )
{
// Check if extension is in the old style OpenGL extensions string
extensions = glGetString( GL_EXTENSIONS );
if( extensions != NULL )
{
if( _glfwStringInExtensionString( extension, extensions ) )
{
return GL_TRUE;
}
}
}
else
{
// Check if extension is in the modern OpenGL extensions string list
GLint count;
int i;
glGetIntegerv( GL_NUM_EXTENSIONS, &count );
for( i = 0; i < count; i++ )
{
if( strcmp( (const char*) _glfwWin.GetStringi( GL_EXTENSIONS, i ),
extension ) == 0 )
{
return GL_TRUE;
}
}
}
// Additional platform specific extension checking (e.g. WGL)
if( _glfwPlatformExtensionSupported( extension ) )
{
return GL_TRUE;
}
return GL_FALSE;
}
//========================================================================
// Get the function pointer to an OpenGL function. This function can be
// used to get access to extended OpenGL functions.
//========================================================================
GLFWAPI void * GLFWAPIENTRY glfwGetProcAddress( const char *procname )
{
// Is GLFW initialized?
if( !_glfwInitialized || !_glfwWin.opened )
{
return NULL;
}
return _glfwPlatformGetProcAddress( procname );
}
//========================================================================
// Returns the OpenGL version
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwGetGLVersion( int *major, int *minor, int *rev )
{
// Is GLFW initialized?
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
if( major != NULL )
{
*major = _glfwWin.glMajor;
}
if( minor != NULL )
{
*minor = _glfwWin.glMinor;
}
if( rev != NULL )
{
*rev = _glfwWin.glRevision;
}
}

629
ogl_editor/src/External/glfw/lib/image.c vendored Normal file
View File

@ -0,0 +1,629 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
//========================================================================
// Description:
//
// This module acts as an interface for different image file formats (the
// image file format is detected automatically).
//
// By default the loaded image is rescaled (using bilinear interpolation)
// to the next higher 2^N x 2^M resolution, unless it has a valid
// 2^N x 2^M resolution. The interpolation is quite slow, even if the
// routine has been optimized for speed (a 200x200 RGB image is scaled to
// 256x256 in ~30 ms on a P3-500).
//
// Paletted images are converted to RGB/RGBA images.
//
// A convenience function is also included (glfwLoadTexture2D), which
// loads a texture image from a file directly to OpenGL texture memory,
// with an option to generate all mipmap levels. GL_SGIS_generate_mipmap
// is used whenever available, which should give an optimal mipmap
// generation speed (possibly performed in hardware). A software fallback
// method is included when GL_SGIS_generate_mipmap is not supported (it
// generates all mipmaps of a 256x256 RGB texture in ~3 ms on a P3-500).
//
//========================================================================
#include "internal.h"
// We want to support automatic mipmap generation
#ifndef GL_SGIS_generate_mipmap
#define GL_GENERATE_MIPMAP_SGIS 0x8191
#define GL_GENERATE_MIPMAP_HINT_SGIS 0x8192
#define GL_SGIS_generate_mipmap 1
#endif // GL_SGIS_generate_mipmap
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Upsample image, from size w1 x h1 to w2 x h2
//========================================================================
static void UpsampleImage( unsigned char *src, unsigned char *dst,
int w1, int h1, int w2, int h2, int bpp )
{
int m, n, k, x, y, col8;
float dx, dy, xstep, ystep, col, col1, col2;
unsigned char *src1, *src2, *src3, *src4;
// Calculate scaling factor
xstep = (float)(w1-1) / (float)(w2-1);
ystep = (float)(h1-1) / (float)(h2-1);
// Copy source data to destination data with bilinear interpolation
// Note: The rather strange look of this routine is a direct result of
// my attempts at optimizing it. Improvements are welcome!
dy = 0.0f;
y = 0;
for( n = 0; n < h2; n ++ )
{
dx = 0.0f;
src1 = &src[ y*w1*bpp ];
src3 = y < (h1-1) ? src1 + w1*bpp : src1;
src2 = src1 + bpp;
src4 = src3 + bpp;
x = 0;
for( m = 0; m < w2; m ++ )
{
for( k = 0; k < bpp; k ++ )
{
col1 = *src1 ++;
col2 = *src2 ++;
col = col1 + (col2 - col1) * dx;
col1 = *src3 ++;
col2 = *src4 ++;
col2 = col1 + (col2 - col1) * dx;
col += (col2 - col) * dy;
col8 = (int) (col + 0.5);
if( col8 >= 256 ) col8 = 255;
*dst++ = (unsigned char) col8;
}
dx += xstep;
if( dx >= 1.0f )
{
x ++;
dx -= 1.0f;
if( x >= (w1-1) )
{
src2 = src1;
src4 = src3;
}
}
else
{
src1 -= bpp;
src2 -= bpp;
src3 -= bpp;
src4 -= bpp;
}
}
dy += ystep;
if( dy >= 1.0f )
{
y ++;
dy -= 1.0f;
}
}
}
//========================================================================
// Build the next mip-map level
//========================================================================
static int HalveImage( GLubyte *src, int *width, int *height,
int components )
{
int halfwidth, halfheight, m, n, k, idx1, idx2;
GLubyte *dst;
// Last level?
if( *width <= 1 && *height <= 1 )
{
return GL_FALSE;
}
// Calculate new width and height (handle 1D case)
halfwidth = *width > 1 ? *width / 2 : 1;
halfheight = *height > 1 ? *height / 2 : 1;
// Downsample image with a simple box-filter
dst = src;
if( *width == 1 || *height == 1 )
{
// 1D case
for( m = 0; m < halfwidth+halfheight-1; m ++ )
{
for( k = 0; k < components; k ++ )
{
*dst ++ = (GLubyte) (((int)*src +
(int)src[components] + 1) >> 1);
src ++;
}
src += components;
}
}
else
{
// 2D case
idx1 = *width*components;
idx2 = (*width+1)*components;
for( m = 0; m < halfheight; m ++ )
{
for( n = 0; n < halfwidth; n ++ )
{
for( k = 0; k < components; k ++ )
{
*dst ++ = (GLubyte) (((int)*src +
(int)src[components] +
(int)src[idx1] +
(int)src[idx2] + 2) >> 2);
src ++;
}
src += components;
}
src += components * (*width);
}
}
// Return new width and height
*width = halfwidth;
*height = halfheight;
return GL_TRUE;
}
//========================================================================
// Rescales an image into power-of-two dimensions
//========================================================================
static int RescaleImage( GLFWimage* image )
{
int width, height, log2, newsize;
unsigned char *data;
// Calculate next larger 2^N width
for( log2 = 0, width = image->Width; width > 1; width >>= 1, log2 ++ )
;
width = (int) 1 << log2;
if( width < image->Width )
{
width <<= 1;
}
// Calculate next larger 2^M height
for( log2 = 0, height = image->Height; height > 1; height >>= 1, log2 ++ )
;
height = (int) 1 << log2;
if( height < image->Height )
{
height <<= 1;
}
// Do we really need to rescale?
if( width != image->Width || height != image->Height )
{
// Allocate memory for new (upsampled) image data
newsize = width * height * image->BytesPerPixel;
data = (unsigned char *) malloc( newsize );
if( data == NULL )
{
free( image->Data );
return GL_FALSE;
}
// Copy old image data to new image data with interpolation
UpsampleImage( image->Data, data, image->Width, image->Height,
width, height, image->BytesPerPixel );
// Free memory for old image data (not needed anymore)
free( image->Data );
// Set pointer to new image data, and set new image dimensions
image->Data = data;
image->Width = width;
image->Height = height;
}
return GL_TRUE;
}
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Read an image from a named file
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwReadImage( const char *name, GLFWimage *img,
int flags )
{
_GLFWstream stream;
// Is GLFW initialized?
if( !_glfwInitialized )
{
return GL_FALSE;
}
// Start with an empty image descriptor
img->Width = 0;
img->Height = 0;
img->BytesPerPixel = 0;
img->Data = NULL;
// Open file
if( !_glfwOpenFileStream( &stream, name, "rb" ) )
{
return GL_FALSE;
}
// We only support TGA files at the moment
if( !_glfwReadTGA( &stream, img, flags ) )
{
_glfwCloseStream( &stream );
return GL_FALSE;
}
// Close stream
_glfwCloseStream( &stream );
// Should we rescale the image to closest 2^N x 2^M resolution?
if( !(flags & GLFW_NO_RESCALE_BIT) )
{
if( !RescaleImage( img ) )
{
return GL_FALSE;
}
}
// Interpret BytesPerPixel as an OpenGL format
switch( img->BytesPerPixel )
{
default:
case 1:
if( flags & GLFW_ALPHA_MAP_BIT )
{
img->Format = GL_ALPHA;
}
else
{
img->Format = GL_LUMINANCE;
}
break;
case 3:
img->Format = GL_RGB;
break;
case 4:
img->Format = GL_RGBA;
break;
}
return GL_TRUE;
}
//========================================================================
// Read an image file from a memory buffer
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwReadMemoryImage( const void *data, long size, GLFWimage *img, int flags )
{
_GLFWstream stream;
// Is GLFW initialized?
if( !_glfwInitialized )
{
return GL_FALSE;
}
// Start with an empty image descriptor
img->Width = 0;
img->Height = 0;
img->BytesPerPixel = 0;
img->Data = NULL;
// Open buffer
if( !_glfwOpenBufferStream( &stream, (void*) data, size ) )
{
return GL_FALSE;
}
// We only support TGA files at the moment
if( !_glfwReadTGA( &stream, img, flags ) )
{
_glfwCloseStream( &stream );
return GL_FALSE;
}
// Close stream
_glfwCloseStream( &stream );
// Should we rescale the image to closest 2^N x 2^M resolution?
if( !(flags & GLFW_NO_RESCALE_BIT) )
{
if( !RescaleImage( img ) )
{
return GL_FALSE;
}
}
// Interpret BytesPerPixel as an OpenGL format
switch( img->BytesPerPixel )
{
default:
case 1:
if( flags & GLFW_ALPHA_MAP_BIT )
{
img->Format = GL_ALPHA;
}
else
{
img->Format = GL_LUMINANCE;
}
break;
case 3:
img->Format = GL_RGB;
break;
case 4:
img->Format = GL_RGBA;
break;
}
return GL_TRUE;
}
//========================================================================
// Free allocated memory for an image
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwFreeImage( GLFWimage *img )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return;
}
// Free memory
if( img->Data != NULL )
{
free( img->Data );
img->Data = NULL;
}
// Clear all fields
img->Width = 0;
img->Height = 0;
img->Format = 0;
img->BytesPerPixel = 0;
}
//========================================================================
// Read an image from a file, and upload it to texture memory
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwLoadTexture2D( const char *name, int flags )
{
GLFWimage img;
// Is GLFW initialized?
if( !_glfwInitialized || !_glfwWin.opened )
{
return GL_FALSE;
}
// Force rescaling if necessary
if( !_glfwWin.has_GL_ARB_texture_non_power_of_two )
{
flags &= (~GLFW_NO_RESCALE_BIT);
}
// Read image from file
if( !glfwReadImage( name, &img, flags ) )
{
return GL_FALSE;
}
if( !glfwLoadTextureImage2D( &img, flags ) )
{
return GL_FALSE;
}
// Data buffer is not needed anymore
glfwFreeImage( &img );
return GL_TRUE;
}
//========================================================================
// Read an image from a buffer, and upload it to texture memory
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwLoadMemoryTexture2D( const void *data, long size, int flags )
{
GLFWimage img;
// Is GLFW initialized?
if( !_glfwInitialized || !_glfwWin.opened )
{
return GL_FALSE;
}
// Force rescaling if necessary
if( !_glfwWin.has_GL_ARB_texture_non_power_of_two )
{
flags &= (~GLFW_NO_RESCALE_BIT);
}
// Read image from file
if( !glfwReadMemoryImage( data, size, &img, flags ) )
{
return GL_FALSE;
}
if( !glfwLoadTextureImage2D( &img, flags ) )
{
return GL_FALSE;
}
// Data buffer is not needed anymore
glfwFreeImage( &img );
return GL_TRUE;
}
//========================================================================
// Upload an image object to texture memory
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwLoadTextureImage2D( GLFWimage *img, int flags )
{
GLint UnpackAlignment, GenMipMap;
int level, format, AutoGen, newsize, n;
unsigned char *data, *dataptr;
// Is GLFW initialized?
if( !_glfwInitialized || !_glfwWin.opened )
{
return GL_FALSE;
}
// TODO: Use GL_MAX_TEXTURE_SIZE or GL_PROXY_TEXTURE_2D to determine
// whether the image size is valid.
// NOTE: May require box filter downsampling routine.
// Do we need to convert the alpha map to RGBA format (OpenGL 1.0)?
if( (_glfwWin.glMajor == 1) && (_glfwWin.glMinor == 0) &&
(img->Format == GL_ALPHA) )
{
// We go to RGBA representation instead
img->BytesPerPixel = 4;
// Allocate memory for new RGBA image data
newsize = img->Width * img->Height * img->BytesPerPixel;
data = (unsigned char *) malloc( newsize );
if( data == NULL )
{
free( img->Data );
return GL_FALSE;
}
// Convert Alpha map to RGBA
dataptr = data;
for( n = 0; n < (img->Width*img->Height); ++ n )
{
*dataptr ++ = 255;
*dataptr ++ = 255;
*dataptr ++ = 255;
*dataptr ++ = img->Data[n];
}
// Free memory for old image data (not needed anymore)
free( img->Data );
// Set pointer to new image data
img->Data = data;
}
// Set unpack alignment to one byte
glGetIntegerv( GL_UNPACK_ALIGNMENT, &UnpackAlignment );
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
// Should we use automatic mipmap generation?
AutoGen = ( flags & GLFW_BUILD_MIPMAPS_BIT ) &&
_glfwWin.has_GL_SGIS_generate_mipmap;
// Enable automatic mipmap generation
if( AutoGen )
{
glGetTexParameteriv( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,
&GenMipMap );
glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,
GL_TRUE );
}
// Format specification is different for OpenGL 1.0
if( _glfwWin.glMajor == 1 && _glfwWin.glMinor == 0 )
{
format = img->BytesPerPixel;
}
else
{
format = img->Format;
}
// Upload to texture memeory
level = 0;
do
{
// Upload this mipmap level
glTexImage2D( GL_TEXTURE_2D, level, format,
img->Width, img->Height, 0, format,
GL_UNSIGNED_BYTE, (void*) img->Data );
// Build next mipmap level manually, if required
if( ( flags & GLFW_BUILD_MIPMAPS_BIT ) && !AutoGen )
{
level = HalveImage( img->Data, &img->Width,
&img->Height, img->BytesPerPixel ) ?
level + 1 : 0;
}
}
while( level != 0 );
// Restore old automatic mipmap generation state
if( AutoGen )
{
glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,
GenMipMap );
}
// Restore old unpack alignment
glPixelStorei( GL_UNPACK_ALIGNMENT, UnpackAlignment );
return GL_TRUE;
}

110
ogl_editor/src/External/glfw/lib/init.c vendored Normal file
View File

@ -0,0 +1,110 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#define _init_c_
#include "internal.h"
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Initialize various GLFW state
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwInit( void )
{
// Is GLFW already initialized?
if( _glfwInitialized )
{
return GL_TRUE;
}
memset( &_glfwLibrary, 0, sizeof( _glfwLibrary ) );
memset( &_glfwWin, 0, sizeof( _glfwWin ) );
// Window is not yet opened
_glfwWin.opened = GL_FALSE;
// Default enable/disable settings
_glfwWin.sysKeysDisabled = GL_FALSE;
// Clear window hints
_glfwClearWindowHints();
// Platform specific initialization
if( !_glfwPlatformInit() )
{
return GL_FALSE;
}
// Form now on, GLFW state is valid
_glfwInitialized = GL_TRUE;
return GL_TRUE;
}
//========================================================================
// Close window and kill all threads.
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwTerminate( void )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return;
}
// Platform specific termination
if( !_glfwPlatformTerminate() )
{
return;
}
// GLFW is no longer initialized
_glfwInitialized = GL_FALSE;
}
//========================================================================
// Get GLFW version
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwGetVersion( int *major, int *minor, int *rev )
{
if( major != NULL ) *major = GLFW_VERSION_MAJOR;
if( minor != NULL ) *minor = GLFW_VERSION_MINOR;
if( rev != NULL ) *rev = GLFW_VERSION_REVISION;
}

269
ogl_editor/src/External/glfw/lib/input.c vendored Normal file
View File

@ -0,0 +1,269 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//========================================================================
// Return key state
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetKey( int key )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return GLFW_RELEASE;
}
// Is it a valid key?
if( key < 0 || key > GLFW_KEY_LAST )
{
return GLFW_RELEASE;
}
if( _glfwInput.Key[ key ] == GLFW_STICK )
{
// Sticky mode: release key now
_glfwInput.Key[ key ] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) _glfwInput.Key[ key ];
}
//========================================================================
// Return mouse button state
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetMouseButton( int button )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return GLFW_RELEASE;
}
// Is it a valid mouse button?
if( button < 0 || button > GLFW_MOUSE_BUTTON_LAST )
{
return GLFW_RELEASE;
}
if( _glfwInput.MouseButton[ button ] == GLFW_STICK )
{
// Sticky mode: release mouse button now
_glfwInput.MouseButton[ button ] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) _glfwInput.MouseButton[ button ];
}
//========================================================================
// Return mouse cursor position
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwGetMousePos( int *xpos, int *ypos )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Return mouse position
if( xpos != NULL )
{
*xpos = _glfwInput.MousePosX;
}
if( ypos != NULL )
{
*ypos = _glfwInput.MousePosY;
}
}
//========================================================================
// Sets the mouse cursor position
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetMousePos( int xpos, int ypos )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Don't do anything if the mouse position did not change
if( xpos == _glfwInput.MousePosX && ypos == _glfwInput.MousePosY )
{
return;
}
// Set GLFW mouse position
_glfwInput.MousePosX = xpos;
_glfwInput.MousePosY = ypos;
// If we have a locked mouse, do not change cursor position
if( _glfwWin.mouseLock )
{
return;
}
// Update physical cursor position
_glfwPlatformSetMouseCursorPos( xpos, ypos );
}
//========================================================================
// Return mouse wheel position
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetMouseWheel( void )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return 0;
}
// Return mouse wheel position
return _glfwInput.WheelPos;
}
//========================================================================
// Set mouse wheel position
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetMouseWheel( int pos )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Set mouse wheel position
_glfwInput.WheelPos = pos;
}
//========================================================================
// Set callback function for keyboard input
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetKeyCallback( GLFWkeyfun cbfun )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Set callback function
_glfwWin.keyCallback = cbfun;
}
//========================================================================
// Set callback function for character input
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetCharCallback( GLFWcharfun cbfun )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Set callback function
_glfwWin.charCallback = cbfun;
}
//========================================================================
// Set callback function for mouse clicks
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetMouseButtonCallback( GLFWmousebuttonfun cbfun )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Set callback function
_glfwWin.mouseButtonCallback = cbfun;
}
//========================================================================
// Set callback function for mouse moves
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetMousePosCallback( GLFWmouseposfun cbfun )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Set callback function
_glfwWin.mousePosCallback = cbfun;
// Call the callback function to let the application know the current
// mouse position
if( cbfun )
{
cbfun( _glfwInput.MousePosX, _glfwInput.MousePosY );
}
}
//========================================================================
// Set callback function for mouse wheel
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetMouseWheelCallback( GLFWmousewheelfun cbfun )
{
if( !_glfwInitialized || !_glfwWin.opened )
{
return;
}
// Set callback function
_glfwWin.mouseWheelCallback = cbfun;
// Call the callback function to let the application know the current
// mouse wheel position
if( cbfun )
{
cbfun( _glfwInput.WheelPos );
}
}

266
ogl_editor/src/External/glfw/lib/internal.h vendored Normal file
View File

@ -0,0 +1,266 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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 _internal_h_
#define _internal_h_
//========================================================================
// GLFWGLOBAL is a macro that places all global variables in the init.c
// module (all other modules reference global variables as 'extern')
//========================================================================
#if defined( _init_c_ )
#define GLFWGLOBAL
#else
#define GLFWGLOBAL extern
#endif
//========================================================================
// Input handling definitions
//========================================================================
// Internal key and button state/action definitions
#define GLFW_STICK 2
//========================================================================
// System independent include files
//========================================================================
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
//------------------------------------------------------------------------
// Window opening hints (set by glfwOpenWindowHint)
// A bucket of semi-random stuff bunched together for historical reasons
// This is used only by the platform independent code and only to store
// parameters passed to us by glfwOpenWindowHint
//------------------------------------------------------------------------
typedef struct {
int refreshRate;
int accumRedBits;
int accumGreenBits;
int accumBlueBits;
int accumAlphaBits;
int auxBuffers;
int stereo;
int windowNoResize;
int samples;
int glMajor;
int glMinor;
int glForward;
int glDebug;
int glProfile;
} _GLFWhints;
//------------------------------------------------------------------------
// Platform specific definitions goes in platform.h (which also includes
// glfw.h)
//------------------------------------------------------------------------
#include "platform.h"
//------------------------------------------------------------------------
// Parameters relating to the creation of the context and window but not
// directly related to the properties of the framebuffer
// This is used to pass window and context creation parameters from the
// platform independent code to the platform specific code
//------------------------------------------------------------------------
typedef struct {
int mode;
int refreshRate;
int windowNoResize;
int glMajor;
int glMinor;
int glForward;
int glDebug;
int glProfile;
} _GLFWwndconfig;
//------------------------------------------------------------------------
// Framebuffer configuration descriptor, i.e. buffers and their sizes
// Also a platform specific ID used to map back to the actual backend APIs
// This is used to pass framebuffer parameters from the platform independent
// code to the platform specific code, and also to enumerate and select
// available framebuffer configurations
//------------------------------------------------------------------------
typedef struct {
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;
GLFWintptr platformID;
} _GLFWfbconfig;
//========================================================================
// System independent global variables (GLFW internals)
//========================================================================
// Flag indicating if GLFW has been initialized
#if defined( _init_c_ )
int _glfwInitialized = 0;
#else
GLFWGLOBAL int _glfwInitialized;
#endif
//------------------------------------------------------------------------
// Abstract data stream (for image I/O)
//------------------------------------------------------------------------
typedef struct {
FILE* file;
void* data;
long position;
long size;
} _GLFWstream;
//========================================================================
// Prototypes for platform specific implementation functions
//========================================================================
// Init/terminate
int _glfwPlatformInit( void );
int _glfwPlatformTerminate( void );
// Enable/Disable
void _glfwPlatformEnableSystemKeys( void );
void _glfwPlatformDisableSystemKeys( void );
// Fullscreen
int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount );
void _glfwPlatformGetDesktopMode( GLFWvidmode *mode );
// OpenGL extensions
int _glfwPlatformExtensionSupported( const char *extension );
void * _glfwPlatformGetProcAddress( const char *procname );
// Joystick
int _glfwPlatformGetJoystickParam( int joy, int param );
int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes );
int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons, int numbuttons );
// Threads
GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg );
void _glfwPlatformDestroyThread( GLFWthread ID );
int _glfwPlatformWaitThread( GLFWthread ID, int waitmode );
GLFWthread _glfwPlatformGetThreadID( void );
GLFWmutex _glfwPlatformCreateMutex( void );
void _glfwPlatformDestroyMutex( GLFWmutex mutex );
void _glfwPlatformLockMutex( GLFWmutex mutex );
void _glfwPlatformUnlockMutex( GLFWmutex mutex );
GLFWcond _glfwPlatformCreateCond( void );
void _glfwPlatformDestroyCond( GLFWcond cond );
void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex, double timeout );
void _glfwPlatformSignalCond( GLFWcond cond );
void _glfwPlatformBroadcastCond( GLFWcond cond );
int _glfwPlatformGetNumberOfProcessors( void );
// Time
double _glfwPlatformGetTime( void );
void _glfwPlatformSetTime( double time );
void _glfwPlatformSleep( double time );
// Window management
int _glfwPlatformOpenWindow( int width, int height, const _GLFWwndconfig *wndconfig, const _GLFWfbconfig *fbconfig );
void _glfwPlatformCloseWindow( void );
void _glfwPlatformSetWindowTitle( const char *title );
void _glfwPlatformSetWindowSize( int width, int height );
void _glfwPlatformSetWindowPos( int x, int y );
void _glfwPlatformIconifyWindow( void );
void _glfwPlatformRestoreWindow( void );
void _glfwPlatformSwapBuffers( void );
void _glfwPlatformSwapInterval( int interval );
void _glfwPlatformRefreshWindowParams( void );
void _glfwPlatformPollEvents( void );
void _glfwPlatformWaitEvents( void );
void _glfwPlatformHideMouseCursor( void );
void _glfwPlatformShowMouseCursor( void );
void _glfwPlatformSetMouseCursorPos( int x, int y );
//========================================================================
// Prototypes for platform independent internal functions
//========================================================================
// Window management (window.c)
void _glfwClearWindowHints( void );
// Input handling (window.c)
void _glfwClearInput( void );
void _glfwInputDeactivation( void );
void _glfwInputKey( int key, int action );
void _glfwInputChar( int character, int action );
void _glfwInputMouseClick( int button, int action );
// Threads (thread.c)
_GLFWthread * _glfwGetThreadPointer( int ID );
void _glfwAppendThread( _GLFWthread * t );
void _glfwRemoveThread( _GLFWthread * t );
// OpenGL extensions (glext.c)
void _glfwParseGLVersion( int *major, int *minor, int *rev );
int _glfwStringInExtensionString( const char *string, const GLubyte *extensions );
void _glfwRefreshContextParams( void );
// Abstracted data streams (stream.c)
int _glfwOpenFileStream( _GLFWstream *stream, const char *name, const char *mode );
int _glfwOpenBufferStream( _GLFWstream *stream, void *data, long size );
long _glfwReadStream( _GLFWstream *stream, void *data, long size );
long _glfwTellStream( _GLFWstream *stream );
int _glfwSeekStream( _GLFWstream *stream, long offset, int whence );
void _glfwCloseStream( _GLFWstream *stream );
// Targa image I/O (tga.c)
int _glfwReadTGA( _GLFWstream *s, GLFWimage *img, int flags );
// Framebuffer configs
const _GLFWfbconfig *_glfwChooseFBConfig( const _GLFWfbconfig *desired,
const _GLFWfbconfig *alternatives,
unsigned int count );
#endif // _internal_h_

99
ogl_editor/src/External/glfw/lib/joystick.c vendored Normal file
View File

@ -0,0 +1,99 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Determine joystick capabilities
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetJoystickParam( int joy, int param )
{
if( !_glfwInitialized )
{
return 0;
}
return _glfwPlatformGetJoystickParam( joy, param );
}
//========================================================================
// Get joystick axis positions
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetJoystickPos( int joy, float *pos, int numaxes )
{
int i;
if( !_glfwInitialized )
{
return 0;
}
// Clear positions
for( i = 0; i < numaxes; i++ )
{
pos[ i ] = 0.0f;
}
return _glfwPlatformGetJoystickPos( joy, pos, numaxes );
}
//========================================================================
// Get joystick button states
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetJoystickButtons( int joy,
unsigned char *buttons,
int numbuttons )
{
int i;
if( !_glfwInitialized )
{
return 0;
}
// Clear button states
for( i = 0; i < numbuttons; i++ )
{
buttons[ i ] = GLFW_RELEASE;
}
return _glfwPlatformGetJoystickButtons( joy, buttons, numbuttons );
}

195
ogl_editor/src/External/glfw/lib/stream.c vendored Normal file
View File

@ -0,0 +1,195 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#define _CRT_SECURE_NO_WARNINGS
#include "internal.h"
//========================================================================
// Opens a GLFW stream with a file
//========================================================================
int _glfwOpenFileStream( _GLFWstream *stream, const char* name, const char* mode )
{
memset( stream, 0, sizeof(_GLFWstream) );
stream->file = fopen( name, mode );
if( stream->file == NULL )
{
return GL_FALSE;
}
return GL_TRUE;
}
//========================================================================
// Opens a GLFW stream with a memory block
//========================================================================
int _glfwOpenBufferStream( _GLFWstream *stream, void *data, long size )
{
memset( stream, 0, sizeof(_GLFWstream) );
stream->data = data;
stream->size = size;
return GL_TRUE;
}
//========================================================================
// Reads data from a GLFW stream
//========================================================================
long _glfwReadStream( _GLFWstream *stream, void *data, long size )
{
if( stream->file != NULL )
{
return (long) fread( data, 1, size, stream->file );
}
if( stream->data != NULL )
{
// Check for EOF
if( stream->position == stream->size )
{
return 0;
}
// Clamp read size to available data
if( stream->position + size > stream->size )
{
size = stream->size - stream->position;
}
// Perform data read
memcpy( data, (unsigned char*) stream->data + stream->position, size );
stream->position += size;
return size;
}
return 0;
}
//========================================================================
// Returns the current position of a GLFW stream
//========================================================================
long _glfwTellStream( _GLFWstream *stream )
{
if( stream->file != NULL )
{
return ftell( stream->file );
}
if( stream->data != NULL )
{
return stream->position;
}
return 0;
}
//========================================================================
// Sets the current position of a GLFW stream
//========================================================================
int _glfwSeekStream( _GLFWstream *stream, long offset, int whence )
{
long position;
if( stream->file != NULL )
{
if( fseek( stream->file, offset, whence ) != 0 )
{
return GL_FALSE;
}
return GL_TRUE;
}
if( stream->data != NULL )
{
position = offset;
// Handle whence parameter
if( whence == SEEK_CUR )
{
position += stream->position;
}
else if( whence == SEEK_END )
{
position += stream->size;
}
else if( whence != SEEK_SET )
{
return GL_FALSE;
}
// Clamp offset to buffer bounds and apply it
if( position > stream->size )
{
stream->position = stream->size;
}
else if( position < 0 )
{
stream->position = 0;
}
else
{
stream->position = position;
}
return GL_TRUE;
}
return GL_FALSE;
}
//========================================================================
// Closes a GLFW stream
//========================================================================
void _glfwCloseStream( _GLFWstream *stream )
{
if( stream->file != NULL )
{
fclose( stream->file );
}
// Nothing to be done about (user allocated) memory blocks
memset( stream, 0, sizeof(_GLFWstream) );
}

404
ogl_editor/src/External/glfw/lib/tga.c vendored Normal file
View File

@ -0,0 +1,404 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
//========================================================================
// Description:
//
// TGA format image file loader. This module supports version 1 Targa
// images, with these restrictions:
// - Pixel format may only be 8, 24 or 32 bits
// - Colormaps must be no longer than 256 entries
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions & declarations ****
//************************************************************************
//========================================================================
// TGA file header information
//========================================================================
typedef struct {
int idlen; // 1 byte
int cmaptype; // 1 byte
int imagetype; // 1 byte
int cmapfirstidx; // 2 bytes
int cmaplen; // 2 bytes
int cmapentrysize; // 1 byte
int xorigin; // 2 bytes
int yorigin; // 2 bytes
int width; // 2 bytes
int height; // 2 bytes
int bitsperpixel; // 1 byte
int imageinfo; // 1 byte
int _alphabits; // (derived from imageinfo)
int _origin; // (derived from imageinfo)
} _tga_header_t;
#define _TGA_CMAPTYPE_NONE 0
#define _TGA_CMAPTYPE_PRESENT 1
#define _TGA_IMAGETYPE_NONE 0
#define _TGA_IMAGETYPE_CMAP 1
#define _TGA_IMAGETYPE_TC 2
#define _TGA_IMAGETYPE_GRAY 3
#define _TGA_IMAGETYPE_CMAP_RLE 9
#define _TGA_IMAGETYPE_TC_RLE 10
#define _TGA_IMAGETYPE_GRAY_RLE 11
#define _TGA_IMAGEINFO_ALPHA_MASK 0x0f
#define _TGA_IMAGEINFO_ALPHA_SHIFT 0
#define _TGA_IMAGEINFO_ORIGIN_MASK 0x30
#define _TGA_IMAGEINFO_ORIGIN_SHIFT 4
#define _TGA_ORIGIN_BL 0
#define _TGA_ORIGIN_BR 1
#define _TGA_ORIGIN_UL 2
#define _TGA_ORIGIN_UR 3
//========================================================================
// Read TGA file header (and check that it is valid)
//========================================================================
static int ReadTGAHeader( _GLFWstream *s, _tga_header_t *h )
{
unsigned char buf[ 18 ];
int pos;
// Read TGA file header from file
pos = _glfwTellStream( s );
_glfwReadStream( s, buf, 18 );
// Interpret header (endian independent parsing)
h->idlen = (int) buf[0];
h->cmaptype = (int) buf[1];
h->imagetype = (int) buf[2];
h->cmapfirstidx = (int) buf[3] | (((int) buf[4]) << 8);
h->cmaplen = (int) buf[5] | (((int) buf[6]) << 8);
h->cmapentrysize = (int) buf[7];
h->xorigin = (int) buf[8] | (((int) buf[9]) << 8);
h->yorigin = (int) buf[10] | (((int) buf[11]) << 8);
h->width = (int) buf[12] | (((int) buf[13]) << 8);
h->height = (int) buf[14] | (((int) buf[15]) << 8);
h->bitsperpixel = (int) buf[16];
h->imageinfo = (int) buf[17];
// Extract alphabits and origin information
h->_alphabits = (int) (h->imageinfo & _TGA_IMAGEINFO_ALPHA_MASK) >>
_TGA_IMAGEINFO_ALPHA_SHIFT;
h->_origin = (int) (h->imageinfo & _TGA_IMAGEINFO_ORIGIN_MASK) >>
_TGA_IMAGEINFO_ORIGIN_SHIFT;
// Validate TGA header (is this a TGA file?)
if( (h->cmaptype == 0 || h->cmaptype == 1) &&
((h->imagetype >= 1 && h->imagetype <= 3) ||
(h->imagetype >= 9 && h->imagetype <= 11)) &&
(h->bitsperpixel == 8 || h->bitsperpixel == 24 ||
h->bitsperpixel == 32) )
{
// Skip the ID field
_glfwSeekStream( s, h->idlen, SEEK_CUR );
// Indicate that the TGA header was valid
return GL_TRUE;
}
else
{
// Restore file position
_glfwSeekStream( s, pos, SEEK_SET );
// Indicate that the TGA header was invalid
return GL_FALSE;
}
}
//========================================================================
// Read Run-Length Encoded data
//========================================================================
static void ReadTGA_RLE( unsigned char *buf, int size, int bpp,
_GLFWstream *s )
{
int repcount, bytes, k, n;
unsigned char pixel[ 4 ];
char c;
// Dummy check
if( bpp > 4 )
{
return;
}
while( size > 0 )
{
// Get repetition count
_glfwReadStream( s, &c, 1 );
repcount = (unsigned int) c;
bytes = ((repcount & 127) + 1) * bpp;
if( size < bytes )
{
bytes = size;
}
// Run-Length packet?
if( repcount & 128 )
{
_glfwReadStream( s, pixel, bpp );
for( n = 0; n < (repcount & 127) + 1; n ++ )
{
for( k = 0; k < bpp; k ++ )
{
*buf ++ = pixel[ k ];
}
}
}
else
{
// It's a Raw packet
_glfwReadStream( s, buf, bytes );
buf += bytes;
}
size -= bytes;
}
}
//========================================================================
// Read a TGA image from a file
//========================================================================
int _glfwReadTGA( _GLFWstream *s, GLFWimage *img, int flags )
{
_tga_header_t h;
unsigned char *cmap, *pix, tmp, *src, *dst;
int cmapsize, pixsize, pixsize2;
int bpp, bpp2, k, m, n, swapx, swapy;
// Read TGA header
if( !ReadTGAHeader( s, &h ) )
{
return 0;
}
// Is there a colormap?
cmapsize = (h.cmaptype == _TGA_CMAPTYPE_PRESENT ? 1 : 0) * h.cmaplen *
((h.cmapentrysize+7) / 8);
if( cmapsize > 0 )
{
// Is it a colormap that we can handle?
if( (h.cmapentrysize != 24 && h.cmapentrysize != 32) ||
h.cmaplen == 0 || h.cmaplen > 256 )
{
return 0;
}
// Allocate memory for colormap
cmap = (unsigned char *) malloc( cmapsize );
if( cmap == NULL )
{
return 0;
}
// Read colormap from file
_glfwReadStream( s, cmap, cmapsize );
}
else
{
cmap = NULL;
}
// Size of pixel data
pixsize = h.width * h.height * ((h.bitsperpixel + 7) / 8);
// Bytes per pixel (pixel data - unexpanded)
bpp = (h.bitsperpixel + 7) / 8;
// Bytes per pixel (expanded pixels - not colormap indeces)
if( cmap )
{
bpp2 = (h.cmapentrysize + 7) / 8;
}
else
{
bpp2 = bpp;
}
// For colormaped images, the RGB/RGBA image data may use more memory
// than the stored pixel data
pixsize2 = h.width * h.height * bpp2;
// Allocate memory for pixel data
pix = (unsigned char *) malloc( pixsize2 );
if( pix == NULL )
{
if( cmap )
{
free( cmap );
}
return 0;
}
// Read pixel data from file
if( h.imagetype >= _TGA_IMAGETYPE_CMAP_RLE )
{
ReadTGA_RLE( pix, pixsize, bpp, s );
}
else
{
_glfwReadStream( s, pix, pixsize );
}
// If the image origin is not what we want, re-arrange the pixels
switch( h._origin )
{
default:
case _TGA_ORIGIN_UL:
swapx = 0;
swapy = 1;
break;
case _TGA_ORIGIN_BL:
swapx = 0;
swapy = 0;
break;
case _TGA_ORIGIN_UR:
swapx = 1;
swapy = 1;
break;
case _TGA_ORIGIN_BR:
swapx = 1;
swapy = 0;
break;
}
if( (swapy && !(flags & GLFW_ORIGIN_UL_BIT)) ||
(!swapy && (flags & GLFW_ORIGIN_UL_BIT)) )
{
src = pix;
dst = &pix[ (h.height-1)*h.width*bpp ];
for( n = 0; n < h.height/2; n ++ )
{
for( m = 0; m < h.width ; m ++ )
{
for( k = 0; k < bpp; k ++ )
{
tmp = *src;
*src ++ = *dst;
*dst ++ = tmp;
}
}
dst -= 2*h.width*bpp;
}
}
if( swapx )
{
src = pix;
dst = &pix[ (h.width-1)*bpp ];
for( n = 0; n < h.height; n ++ )
{
for( m = 0; m < h.width/2 ; m ++ )
{
for( k = 0; k < bpp; k ++ )
{
tmp = *src;
*src ++ = *dst;
*dst ++ = tmp;
}
dst -= 2*bpp;
}
src += ((h.width+1)/2)*bpp;
dst += ((3*h.width+1)/2)*bpp;
}
}
// Convert BGR/BGRA to RGB/RGBA, and optionally colormap indeces to
// RGB/RGBA values
if( cmap )
{
// Convert colormap pixel format (BGR -> RGB or BGRA -> RGBA)
if( bpp2 == 3 || bpp2 == 4 )
{
for( n = 0; n < h.cmaplen; n ++ )
{
tmp = cmap[ n*bpp2 ];
cmap[ n*bpp2 ] = cmap[ n*bpp2 + 2 ];
cmap[ n*bpp2 + 2 ] = tmp;
}
}
// Convert pixel data to RGB/RGBA data
for( m = h.width * h.height - 1; m >= 0; m -- )
{
n = pix[ m ];
for( k = 0; k < bpp2; k ++ )
{
pix[ m*bpp2 + k ] = cmap[ n*bpp2 + k ];
}
}
// Free memory for colormap (it's not needed anymore)
free( cmap );
}
else
{
// Convert image pixel format (BGR -> RGB or BGRA -> RGBA)
if( bpp2 == 3 || bpp2 == 4 )
{
src = pix;
dst = &pix[ 2 ];
for( n = 0; n < h.height * h.width; n ++ )
{
tmp = *src;
*src = *dst;
*dst = tmp;
src += bpp2;
dst += bpp2;
}
}
}
// Fill out GLFWimage struct (the Format field will be set by
// glfwReadImage)
img->Width = h.width;
img->Height = h.height;
img->BytesPerPixel = bpp2;
img->Data = pix;
return 1;
}

341
ogl_editor/src/External/glfw/lib/thread.c vendored Normal file
View File

@ -0,0 +1,341 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Find pointer to thread with a matching ID
//========================================================================
_GLFWthread * _glfwGetThreadPointer( int ID )
{
_GLFWthread *t;
for( t = &_glfwThrd.First; t != NULL; t = t->Next )
{
if( t->ID == ID )
{
break;
}
}
return t;
}
//========================================================================
// Append thread to thread list
//========================================================================
void _glfwAppendThread( _GLFWthread * t )
{
_GLFWthread *t_tmp;
t_tmp = &_glfwThrd.First;
while( t_tmp->Next != NULL )
{
t_tmp = t_tmp->Next;
}
t_tmp->Next = t;
t->Previous = t_tmp;
t->Next = NULL;
}
//========================================================================
// Remove thread from thread list
//========================================================================
void _glfwRemoveThread( _GLFWthread * t )
{
if( t->Previous != NULL )
{
t->Previous->Next = t->Next;
}
if( t->Next != NULL )
{
t->Next->Previous = t->Previous;
}
free( (void *) t );
}
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Create a new thread
//========================================================================
GLFWAPI GLFWthread GLFWAPIENTRY glfwCreateThread( GLFWthreadfun fun,
void *arg )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return -1;
}
// Return the GLFW thread ID
return _glfwPlatformCreateThread( fun, arg );
}
//========================================================================
// Kill a thread. NOTE: THIS IS A VERY DANGEROUS OPERATION, AND SHOULD NOT
// BE USED EXCEPT IN EXTREME SITUATIONS!
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwDestroyThread( GLFWthread ID )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return;
}
// Is it a valid thread? (killing the main thread is not allowed)
if( ID < 1 )
{
return;
}
_glfwPlatformDestroyThread( ID );
}
//========================================================================
// Wait for a thread to die
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwWaitThread( GLFWthread ID, int waitmode )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return GL_TRUE;
}
// Is it a valid thread? (waiting for the main thread is not allowed)
if( ID < 1 )
{
return GL_TRUE;
}
return _glfwPlatformWaitThread( ID, waitmode );
}
//========================================================================
// Return the thread ID for the current thread
//========================================================================
GLFWAPI GLFWthread GLFWAPIENTRY glfwGetThreadID( void )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return 0;
}
return _glfwPlatformGetThreadID();
}
//========================================================================
// Create a mutual exclusion object
//========================================================================
GLFWAPI GLFWmutex GLFWAPIENTRY glfwCreateMutex( void )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return (GLFWmutex) 0;
}
return _glfwPlatformCreateMutex();
}
//========================================================================
// Destroy a mutual exclusion object
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwDestroyMutex( GLFWmutex mutex )
{
// Initialized & valid mutex (no real way of assuring this)?
if( !_glfwInitialized || !mutex )
{
return;
}
_glfwPlatformDestroyMutex( mutex );
}
//========================================================================
// Request access to a mutex
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwLockMutex( GLFWmutex mutex )
{
// Initialized & valid mutex (no real way of assuring this)?
if( !_glfwInitialized && !mutex )
{
return;
}
_glfwPlatformLockMutex( mutex );
}
//========================================================================
// Release a mutex
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwUnlockMutex( GLFWmutex mutex )
{
// Initialized & valid mutex (no real way of assuring this)?
if( !_glfwInitialized && !mutex )
{
return;
}
_glfwPlatformUnlockMutex( mutex );
}
//========================================================================
// Create a new condition variable object
//========================================================================
GLFWAPI GLFWcond GLFWAPIENTRY glfwCreateCond( void )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return (GLFWcond) 0;
}
return _glfwPlatformCreateCond();
}
//========================================================================
// Destroy a condition variable object
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwDestroyCond( GLFWcond cond )
{
// Initialized & valid condition variable?
if( !_glfwInitialized || !cond )
{
return;
}
_glfwPlatformDestroyCond( cond );
}
//========================================================================
// Wait for a condition to be raised
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwWaitCond( GLFWcond cond, GLFWmutex mutex,
double timeout )
{
// Initialized & valid condition variable and mutex?
if( !_glfwInitialized || !cond || !mutex )
{
return;
}
_glfwPlatformWaitCond( cond, mutex, timeout );
}
//========================================================================
// Signal a condition to one waiting thread
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSignalCond( GLFWcond cond )
{
// Initialized & valid condition variable?
if( !_glfwInitialized || !cond )
{
return;
}
_glfwPlatformSignalCond( cond );
}
//========================================================================
// Broadcast a condition to all waiting threads
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwBroadcastCond( GLFWcond cond )
{
// Initialized & valid condition variable?
if( !_glfwInitialized || !cond )
{
return;
}
_glfwPlatformBroadcastCond( cond );
}
//========================================================================
// Return the number of processors in the system. This information can be
// useful for determining the optimal number of threads to use for
// performing a certain task.
//========================================================================
GLFWAPI int GLFWAPIENTRY glfwGetNumberOfProcessors( void )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return 0;
}
return _glfwPlatformGetNumberOfProcessors();
}

84
ogl_editor/src/External/glfw/lib/time.c vendored Normal file
View File

@ -0,0 +1,84 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Return timer value in seconds
//========================================================================
GLFWAPI double GLFWAPIENTRY glfwGetTime( void )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return 0.0;
}
return _glfwPlatformGetTime();
}
//========================================================================
// Set timer value in seconds
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSetTime( double time )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return;
}
_glfwPlatformSetTime( time );
}
//========================================================================
// Put a thread to sleep for a specified amount of time
//========================================================================
GLFWAPI void GLFWAPIENTRY glfwSleep( double time )
{
// Is GLFW initialized?
if( !_glfwInitialized )
{
return;
}
_glfwPlatformSleep( time );
}

265
ogl_editor/src/External/glfw/lib/win32/Makefile.win32.cross-mgw vendored Normal file
View File

@ -0,0 +1,265 @@
##########################################################################
# Makefile for GLFW on Windows using MinGW32.
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# make -f Makefile.win32.mgw
##########################################################################
PREFIX ?= /usr/i586-mingw32msvc
TARGET ?= i586-mingw32msvc-
##########################################################################
# GLFW version
##########################################################################
VERMAJOR = 2
VERMINOR = 7
##########################################################################
# Compiler settings
##########################################################################
CC = gcc
CFLAGS = -c -I. -I.. -Wall -O2
CFLAGS_DLL = $(CFLAGS) -mdll -DGLFW_BUILD_DLL -D_GLFW_NO_DLOAD_GDI32 -D_GLFW_NO_DLOAD_WINMM
HEADERS = ../../include/GL/glfw.h ../internal.h platform.h
##########################################################################
# Library builder settings
##########################################################################
# Static library
MKLIB = ar
LIBFLAGS = -rcs
# DLL
LINKFLAGS = -s -Wl,--major-image-version,$(VERMAJOR),--minor-image-version,$(VERMINOR)
LINKLIBS = -lopengl32 -lwinmm -lgdi32
DLLTOOL = dlltool
SED = sed
INSTALL = install
##########################################################################
# Object files for static library
##########################################################################
OBJS = \
enable.o \
fullscreen.o \
glext.o \
image.o \
init.o \
input.o \
joystick.o \
stream.o \
tga.o \
thread.o \
time.o \
window.o \
win32_enable.o \
win32_fullscreen.o \
win32_glext.o \
win32_init.o \
win32_joystick.o \
win32_thread.o \
win32_time.o \
win32_window.o
##########################################################################
# Object files for dynamic library
##########################################################################
DLLOBJS = \
enable_dll.o \
fullscreen_dll.o \
glext_dll.o \
image_dll.o \
init_dll.o \
input_dll.o \
joystick_dll.o \
stream_dll.o \
tga_dll.o \
thread_dll.o \
time_dll.o \
window_dll.o \
win32_dllmain_dll.o \
win32_enable_dll.o \
win32_fullscreen_dll.o \
win32_glext_dll.o \
win32_init_dll.o \
win32_joystick_dll.o \
win32_thread_dll.o \
win32_time_dll.o \
win32_window_dll.o
##########################################################################
# Default: Build static and dynamic versions of GLFW
##########################################################################
all: libglfw.a glfw.dll
##########################################################################
# Install GLFW header and static library
##########################################################################
install: glfw.dll libglfw.a libglfw.pc
$(INSTALL) -d $(PREFIX)/bin
$(INSTALL) -c glfw.dll $(PREFIX)/bin/glfw.dll
$(INSTALL) -d $(PREFIX)/lib
$(INSTALL) -c -m 644 libglfw.a $(PREFIX)/lib/libglfw.a
$(INSTALL) -d $(PREFIX)/include/GL
$(INSTALL) -c -m 644 ../../include/GL/glfw.h $(PREFIX)/include/GL/glfw.h
$(INSTALL) -d $(PREFIX)/lib/pkgconfig
$(INSTALL) -c -m 644 libglfw.pc $(PREFIX)/lib/pkgconfig/libglfw.pc
##########################################################################
# Clean up generated files
##########################################################################
clean:
rm -f $(OBJS) $(DLLOBJS)
rm -f libglfw.a libglfwdll.a glfw.dll libglfw.pc
##########################################################################
# Rule for building static library
##########################################################################
libglfw.a: $(OBJS)
$(TARGET)$(MKLIB) $(LIBFLAGS) $@ $(OBJS) $(SYSOBJS)
##########################################################################
# Rules for building dynamic library
##########################################################################
glfw.dll: $(DLLOBJS)
$(TARGET)$(CC) -shared -o $@ -Wl,--output-def,libglfwdll.def $(DLLOBJS) $(LINKLIBS)
$(TARGET)$(CC) -shared -o $@ -Wl,--kill-at $(DLLOBJS) $(LINKFLAGS) $(LINKLIBS)
$(TARGET)$(DLLTOOL) --kill-at --output-lib libglfwdll.a --dllname $@ --def libglfwdll.def
libglfw.pc: libglfw.pc.in
$(SED) -e 's,\@PREFIX\@,$(PREFIX),' libglfw.pc.in > libglfw.pc
##########################################################################
# Rules for building static library object files
##########################################################################
enable.o: ../enable.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../enable.c
fullscreen.o: ../fullscreen.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../fullscreen.c
glext.o: ../glext.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../glext.c
image.o: ../image.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../image.c
init.o: ../init.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../init.c
input.o: ../input.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../input.c
joystick.o: ../joystick.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../joystick.c
stream.o: ../stream.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../stream.c
tga.o: ../tga.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../tga.c
thread.o: ../thread.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../thread.c
time.o: ../time.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../time.c
window.o: ../window.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ ../window.c
win32_enable.o: win32_enable.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_enable.c
win32_fullscreen.o: win32_fullscreen.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_fullscreen.c
win32_glext.o: win32_glext.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_glext.c
win32_init.o: win32_init.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_init.c
win32_joystick.o: win32_joystick.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_joystick.c
win32_thread.o: win32_thread.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_thread.c
win32_time.o: win32_time.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_time.c
win32_window.o: win32_window.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS) -o $@ win32_window.c
##########################################################################
# Rules for building dynamic library object files
##########################################################################
enable_dll.o: ../enable.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../enable.c
fullscreen_dll.o: ../fullscreen.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../fullscreen.c
glext_dll.o: ../glext.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../glext.c
image_dll.o: ../image.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../image.c
init_dll.o: ../init.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../init.c
input_dll.o: ../input.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../input.c
joystick_dll.o: ../joystick.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../joystick.c
stream_dll.o: ../stream.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../stream.c
tga_dll.o: ../tga.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../tga.c
thread_dll.o: ../thread.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../thread.c
time_dll.o: ../time.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../time.c
window_dll.o: ../window.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ ../window.c
win32_dllmain_dll.o: win32_dllmain.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_dllmain.c
win32_enable_dll.o: win32_enable.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_enable.c
win32_fullscreen_dll.o: win32_fullscreen.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_fullscreen.c
win32_glext_dll.o: win32_glext.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_glext.c
win32_init_dll.o: win32_init.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_init.c
win32_joystick_dll.o: win32_joystick.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_joystick.c
win32_thread_dll.o: win32_thread.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_thread.c
win32_time_dll.o: win32_time.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_time.c
win32_window_dll.o: win32_window.c $(HEADERS)
$(TARGET)$(CC) $(CFLAGS_DLL) -o $@ win32_window.c

242
ogl_editor/src/External/glfw/lib/win32/Makefile.win32.lcc vendored Normal file
View File

@ -0,0 +1,242 @@
##########################################################################
# Makefile for GLFW on Windows using LCC-Win32.
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# make -f Makefile.win32.lcc
##########################################################################
##########################################################################
# Default: Build static and dynamic versions of GLFW
##########################################################################
all: glfw.lib glfw.dll
##########################################################################
# GLFW version
##########################################################################
VERMAJOR = 2
VERMINOR = 7
##########################################################################
# Compiler settings
##########################################################################
CC = lc
CFLAGS = -c -O -A -I. -I..
CFLAGS_DLL = $(CFLAGS) -DGLFW_BUILD_DLL
##########################################################################
# Library builder settings
##########################################################################
# Static library
MKLIB = lcclib
LIBFLAGS =
# DLL
LINK = lcclnk
LINKFLAGS = -dll -nounderscores -version $(VERMAJOR).$(VERMINOR) -s
LINKLIBS = opengl32.lib
##########################################################################
# Object files for static library
##########################################################################
OBJS = \
enable.obj \
fullscreen.obj \
glext.obj \
image.obj \
init.obj \
input.obj \
joystick.obj \
stream.obj \
tga.obj \
thread.obj \
time.obj \
window.obj \
win32_enable.obj \
win32_fullscreen.obj \
win32_glext.obj \
win32_init.obj \
win32_joystick.obj \
win32_thread.obj \
win32_time.obj \
win32_window.obj
##########################################################################
# Object files for dynamic library
##########################################################################
DLLOBJS = \
enable_dll.obj \
fullscreen_dll.obj \
glext_dll.obj \
image_dll.obj \
init_dll.obj \
input_dll.obj \
joystick_dll.obj \
stream_dll.obj \
tga_dll.obj \
thread_dll.obj \
time_dll.obj \
window_dll.obj \
win32_dllmain_dll.obj \
win32_enable_dll.obj \
win32_fullscreen_dll.obj \
win32_glext_dll.obj \
win32_init_dll.obj \
win32_joystick_dll.obj \
win32_thread_dll.obj \
win32_time_dll.obj \
win32_window_dll.obj
##########################################################################
# Rule for building static library
##########################################################################
glfw.lib: $(OBJS)
$(MKLIB) $(LIBFLAGS) /out:glfw.lib $(OBJS)
##########################################################################
# Rule for building dynamic library
##########################################################################
glfw.dll: $(DLLOBJS)
if exist glfw.lib rename glfw.lib glfw_lib.bak
$(LINK) $(LINKFLAGS) -o $@ $(DLLOBJS) $(LINKLIBS)
if exist glfwdll.lib del glfwdll.lib
rename glfw.lib glfwdll.lib
if exist glfw_lib.bak rename glfw_lib.bak glfw.lib
##########################################################################
# Rules for building static library object files
##########################################################################
enable.obj: ..\\enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\enable.c
fullscreen.obj: ..\\fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\fullscreen.c
glext.obj: ..\\glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\glext.c
image.obj: ..\\image.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\image.c
init.obj: ..\\init.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\init.c
input.obj: ..\\input.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\input.c
joystick.obj: ..\\joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\joystick.c
stream.obj: ..\\stream.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\stream.c
tga.obj: ..\\tga.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\tga.c
thread.obj: ..\\thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\thread.c
time.obj: ..\\time.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\time.c
window.obj: ..\\window.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ ..\\window.c
win32_enable.obj: win32_enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_enable.c
win32_fullscreen.obj: win32_fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_fullscreen.c
win32_glext.obj: win32_glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_glext.c
win32_init.obj: win32_init.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_init.c
win32_joystick.obj: win32_joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_joystick.c
win32_thread.obj: win32_thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_thread.c
win32_time.obj: win32_time.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_time.c
win32_window.obj: win32_window.c ..\\internal.h platform.h
$(CC) $(CFLAGS) -Fo$@ win32_window.c
##########################################################################
# Rules for building dynamic library object files
##########################################################################
enable_dll.obj: ..\\enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\enable.c
fullscreen_dll.obj: ..\\fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\fullscreen.c
glext_dll.obj: ..\\glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\glext.c
image_dll.obj: ..\\image.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\image.c
init_dll.obj: ..\\init.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\init.c
input_dll.obj: ..\\input.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\input.c
joystick_dll.obj: ..\\joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\joystick.c
stream_dll.obj: ..\\stream.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\stream.c
tga_dll.obj: ..\\tga.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\tga.c
thread_dll.obj: ..\\thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\thread.c
time_dll.obj: ..\\time.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\time.c
window_dll.obj: ..\\window.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ ..\\window.c
win32_dllmain_dll.obj: win32_dllmain.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_dllmain.c
win32_enable_dll.obj: win32_enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_enable.c
win32_fullscreen_dll.obj: win32_fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_fullscreen.c
win32_glext_dll.obj: win32_glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_glext.c
win32_init_dll.obj: win32_init.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_init.c
win32_joystick_dll.obj: win32_joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_joystick.c
win32_thread_dll.obj: win32_thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_thread.c
win32_time_dll.obj: win32_time.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_time.c
win32_window_dll.obj: win32_window.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) -Fo$@ win32_window.c

242
ogl_editor/src/External/glfw/lib/win32/Makefile.win32.mingw vendored Normal file
View File

@ -0,0 +1,242 @@
##########################################################################
# Makefile for GLFW on Windows using MinGW32.
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# make -f Makefile.win32.mgw
##########################################################################
##########################################################################
# Default: Build static and dynamic versions of GLFW
##########################################################################
all: libglfw.a glfw.dll
##########################################################################
# GLFW version
##########################################################################
VERMAJOR = 2
VERMINOR = 7
##########################################################################
# Compiler settings
##########################################################################
CC = gcc
CFLAGS = -c -I. -I.. -Wall -O2
CFLAGS_DLL = $(CFLAGS) -mdll -DGLFW_BUILD_DLL -D_GLFW_NO_DLOAD_GDI32 -D_GLFW_NO_DLOAD_WINMM
##########################################################################
# Library builder settings
##########################################################################
# Static library
MKLIB = ar
LIBFLAGS = -rcs
# DLL
LINKFLAGS = -s -Wl,--major-image-version,$(VERMAJOR),--minor-image-version,$(VERMINOR)
LINKLIBS = -lopengl32 -lwinmm -lgdi32
DLLTOOL = dlltool
##########################################################################
# Object files for static library
##########################################################################
OBJS = \
enable.o \
fullscreen.o \
glext.o \
image.o \
init.o \
input.o \
joystick.o \
stream.o \
tga.o \
thread.o \
time.o \
window.o \
win32_enable.o \
win32_fullscreen.o \
win32_glext.o \
win32_init.o \
win32_joystick.o \
win32_thread.o \
win32_time.o \
win32_window.o
##########################################################################
# Object files for dynamic library
##########################################################################
DLLOBJS = \
enable_dll.o \
fullscreen_dll.o \
glext_dll.o \
image_dll.o \
init_dll.o \
input_dll.o \
joystick_dll.o \
stream_dll.o \
tga_dll.o \
thread_dll.o \
time_dll.o \
window_dll.o \
win32_dllmain_dll.o \
win32_enable_dll.o \
win32_fullscreen_dll.o \
win32_glext_dll.o \
win32_init_dll.o \
win32_joystick_dll.o \
win32_thread_dll.o \
win32_time_dll.o \
win32_window_dll.o
##########################################################################
# Rule for building static library
##########################################################################
libglfw.a: $(OBJS)
$(MKLIB) $(LIBFLAGS) $@ $(OBJS) $(SYSOBJS)
##########################################################################
# Rule for building dynamic library
##########################################################################
glfw.dll: $(DLLOBJS)
$(CC) -shared -o $@ -Wl,--output-def,libglfwdll.def $(DLLOBJS) $(LINKLIBS)
$(CC) -shared -o $@ -Wl,--kill-at $(DLLOBJS) $(LINKFLAGS) $(LINKLIBS)
$(DLLTOOL) --kill-at --output-lib libglfwdll.a --dllname $@ --def libglfwdll.def
##########################################################################
# Rules for building static library object files
##########################################################################
enable.o: ../enable.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../enable.c
fullscreen.o: ../fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../fullscreen.c
glext.o: ../glext.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../glext.c
image.o: ../image.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../image.c
init.o: ../init.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../init.c
input.o: ../input.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../input.c
joystick.o: ../joystick.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../joystick.c
stream.o: ../stream.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../stream.c
tga.o: ../tga.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../tga.c
thread.o: ../thread.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../thread.c
time.o: ../time.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../time.c
window.o: ../window.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ ../window.c
win32_enable.o: win32_enable.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_enable.c
win32_fullscreen.o: win32_fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_fullscreen.c
win32_glext.o: win32_glext.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_glext.c
win32_init.o: win32_init.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_init.c
win32_joystick.o: win32_joystick.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_joystick.c
win32_thread.o: win32_thread.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_thread.c
win32_time.o: win32_time.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_time.c
win32_window.o: win32_window.c ../internal.h platform.h
$(CC) $(CFLAGS) -o $@ win32_window.c
##########################################################################
# Rules for building dynamic library object files
##########################################################################
enable_dll.o: ../enable.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../enable.c
fullscreen_dll.o: ../fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../fullscreen.c
glext_dll.o: ../glext.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../glext.c
image_dll.o: ../image.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../image.c
init_dll.o: ../init.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../init.c
input_dll.o: ../input.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../input.c
joystick_dll.o: ../joystick.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../joystick.c
stream_dll.o: ../stream.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../stream.c
tga_dll.o: ../tga.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../tga.c
thread_dll.o: ../thread.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../thread.c
time_dll.o: ../time.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../time.c
window_dll.o: ../window.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ ../window.c
win32_dllmain_dll.o: win32_dllmain.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_dllmain.c
win32_enable_dll.o: win32_enable.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_enable.c
win32_fullscreen_dll.o: win32_fullscreen.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_fullscreen.c
win32_glext_dll.o: win32_glext.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_glext.c
win32_init_dll.o: win32_init.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_init.c
win32_joystick_dll.o: win32_joystick.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_joystick.c
win32_thread_dll.o: win32_thread.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_thread.c
win32_time_dll.o: win32_time.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_time.c
win32_window_dll.o: win32_window.c ../internal.h platform.h
$(CC) $(CFLAGS_DLL) -o $@ win32_window.c

273
ogl_editor/src/External/glfw/lib/win32/Makefile.win32.msys vendored Normal file
View File

@ -0,0 +1,273 @@
##########################################################################
# Makefile for GLFW on Windows using MSYS
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# make -f Makefile.win32.msys
##########################################################################
PREFIX ?= /usr/local
##########################################################################
# GLFW version
##########################################################################
VERMAJOR = 2
VERMINOR = 7
##########################################################################
# Compiler settings
##########################################################################
CC = gcc
CFLAGS = -c -I. -I.. -Wall -mwin32 -O2
CFLAGS_DLL = $(CFLAGS) -mdll -DGLFW_BUILD_DLL -D_GLFW_NO_DLOAD_GDI32 -D_GLFW_NO_DLOAD_WINMM
HEADERS = ../../include/GL/glfw.h ../internal.h platform.h
##########################################################################
# Library builder settings
##########################################################################
# Static library
MKLIB = ar
LIBFLAGS = -rcs
# DLL
LINKFLAGS = -shared -s -Wl,--kill-at,--major-image-version,$(VERMAJOR),--minor-image-version,$(VERMINOR)
LINKLIBS = -lopengl32 -lwinmm -lgdi32
DLLTOOL = dlltool
SED = sed
INSTALL = install
##########################################################################
# Object files for static library
##########################################################################
OBJS = \
enable.o \
fullscreen.o \
glext.o \
image.o \
init.o \
input.o \
joystick.o \
stream.o \
tga.o \
thread.o \
time.o \
window.o \
win32_enable.o \
win32_fullscreen.o \
win32_glext.o \
win32_init.o \
win32_joystick.o \
win32_thread.o \
win32_time.o \
win32_window.o
##########################################################################
# Object files for dynamic library
##########################################################################
DLLOBJS = \
enable_dll.o \
fullscreen_dll.o \
glext_dll.o \
image_dll.o \
init_dll.o \
input_dll.o \
joystick_dll.o \
stream_dll.o \
tga_dll.o \
thread_dll.o \
time_dll.o \
window_dll.o \
win32_dllmain_dll.o \
win32_enable_dll.o \
win32_fullscreen_dll.o \
win32_glext_dll.o \
win32_init_dll.o \
win32_joystick_dll.o \
win32_thread_dll.o \
win32_time_dll.o \
win32_window_dll.o
##########################################################################
# Default: Build static and dynamic versions of GLFW
##########################################################################
all: libglfw.a glfw.dll
##########################################################################
# Install GLFW header and static library
##########################################################################
install: libglfw.a libglfw.pc
$(INSTALL) -d $(PREFIX)/lib
$(INSTALL) -c -m 644 libglfw.a $(PREFIX)/lib/libglfw.a
$(INSTALL) -d $(PREFIX)/include/GL
$(INSTALL) -c -m 644 ../../include/GL/glfw.h $(PREFIX)/include/GL/glfw.h
$(INSTALL) -d $(PREFIX)/lib/pkgconfig
$(INSTALL) -c -m 644 libglfw.pc $(PREFIX)/lib/pkgconfig/libglfw.pc
##########################################################################
# Clean up generated files
##########################################################################
clean:
rm -f $(OBJS) $(DLLOBJS)
rm -f libglfw.a glfw.dll libglfw.pc
##########################################################################
# Rule for building libglfw.pc
##########################################################################
libglfw.pc: libglfw.pc.in
$(SED) -e 's,\@PREFIX\@,$(PREFIX),' libglfw.pc.in > libglfw.pc
##########################################################################
# Rule for building static library
##########################################################################
libglfw.a: $(OBJS)
$(MKLIB) $(LIBFLAGS) libglfw.a $(OBJS)
##########################################################################
# Rule for building dynamic library
##########################################################################
glfw.dll: $(DLLOBJS)
$(CC) -shared -o $@ -Wl,--output-def,libglfwdll.def $(DLLOBJS) $(LINKLIBS)
$(CC) -shared -o $@ -Wl,--kill-at $(DLLOBJS) $(LINKFLAGS) $(LINKLIBS)
$(DLLTOOL) --kill-at --output-lib libglfwdll.a --dllname $@ --def libglfwdll.def
##########################################################################
# Rules for building static library object files
##########################################################################
enable.o: ../enable.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../enable.c
fullscreen.o: ../fullscreen.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../fullscreen.c
glext.o: ../glext.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../glext.c
image.o: ../image.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../image.c
init.o: ../init.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../init.c
input.o: ../input.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../input.c
joystick.o: ../joystick.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../joystick.c
stream.o: ../stream.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../stream.c
tga.o: ../tga.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../tga.c
thread.o: ../thread.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../thread.c
time.o: ../time.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../time.c
window.o: ../window.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../window.c
win32_enable.o: win32_enable.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_enable.c
win32_fullscreen.o: win32_fullscreen.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_fullscreen.c
win32_glext.o: win32_glext.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_glext.c
win32_init.o: win32_init.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_init.c
win32_joystick.o: win32_joystick.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_joystick.c
win32_thread.o: win32_thread.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_thread.c
win32_time.o: win32_time.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_time.c
win32_window.o: win32_window.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ win32_window.c
##########################################################################
# Rules for building dynamic library object files
##########################################################################
enable_dll.o: ../enable.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../enable.c
fullscreen_dll.o: ../fullscreen.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../fullscreen.c
glext_dll.o: ../glext.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../glext.c
image_dll.o: ../image.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../image.c
init_dll.o: ../init.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../init.c
input_dll.o: ../input.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../input.c
joystick_dll.o: ../joystick.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../joystick.c
stream_dll.o: ../stream.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../stream.c
tga_dll.o: ../tga.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../tga.c
thread_dll.o: ../thread.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../thread.c
time_dll.o: ../time.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../time.c
window_dll.o: ../window.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ ../window.c
win32_dllmain_dll.o: win32_dllmain.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_dllmain.c
win32_enable_dll.o: win32_enable.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_enable.c
win32_fullscreen_dll.o: win32_fullscreen.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_fullscreen.c
win32_glext_dll.o: win32_glext.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_glext.c
win32_init_dll.o: win32_init.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_init.c
win32_joystick_dll.o: win32_joystick.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_joystick.c
win32_thread_dll.o: win32_thread.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_thread.c
win32_time_dll.o: win32_time.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_time.c
win32_window_dll.o: win32_window.c $(HEADERS)
$(CC) $(CFLAGS_DLL) -o $@ win32_window.c

238
ogl_editor/src/External/glfw/lib/win32/Makefile.win32.ow vendored Normal file
View File

@ -0,0 +1,238 @@
##########################################################################
# Makefile for GLFW on Windows using Open Watcom 1.0.
#-------------------------------------------------------------------------
# To compile GLFW using this makefile, run:
# "wmake -ms -f Makefile.win32.ow" or "nmake -f Makefile.win32.ow"
##########################################################################
##########################################################################
# Default: Build static and dynamic versions of GLFW
##########################################################################
all: glfw.lib glfw.dll
##########################################################################
# GLFW version
##########################################################################
VERMAJOR = 2
VERMINOR = 7
##########################################################################
# Compiler settings
##########################################################################
CC = cl386
CFLAGS = /nologo /c /O1sgiy /Gs /W3 /I. /I..
CFLAGS_DLL = $(CFLAGS) /DGLFW_BUILD_DLL
##########################################################################
# Library builder settings
##########################################################################
# Static library
MKLIB = lib386
LIBFLAGS = /nologo
# DLL
LINK = wlink
LINKFLAGS = OPTION { quiet version=$(VERMAJOR).$(VERMINOR) } SYSTEM nt_dll initinstance terminstance
LINKLIBS = opengl32.lib user32.lib
##########################################################################
# Object files for static library
##########################################################################
OBJS = \
enable.obj \
fullscreen.obj \
glext.obj \
image.obj \
init.obj \
input.obj \
joystick.obj \
stream.obj \
tga.obj \
thread.obj \
time.obj \
window.obj \
win32_enable.obj \
win32_fullscreen.obj \
win32_glext.obj \
win32_init.obj \
win32_joystick.obj \
win32_thread.obj \
win32_time.obj \
win32_window.obj
##########################################################################
# Object files for dynamic library
##########################################################################
DLLOBJS = \
enable_dll.obj \
fullscreen_dll.obj \
glext_dll.obj \
image_dll.obj \
init_dll.obj \
input_dll.obj \
joystick_dll.obj \
stream_dll.obj \
tga_dll.obj \
thread_dll.obj \
time_dll.obj \
window_dll.obj \
win32_dllmain_dll.obj \
win32_enable_dll.obj \
win32_fullscreen_dll.obj \
win32_glext_dll.obj \
win32_init_dll.obj \
win32_joystick_dll.obj \
win32_thread_dll.obj \
win32_time_dll.obj \
win32_window_dll.obj
##########################################################################
# Rule for building static library
##########################################################################
glfw.lib: $(OBJS)
$(MKLIB) $(LIBFLAGS) /OUT:glfw.lib $(OBJS)
##########################################################################
# Rule for building dynamic library
##########################################################################
glfw.dll: $(DLLOBJS)
$(LINK) $(LINKFLAGS) NAME glfw.dll OPTION { modname='GLFW.DLL' implib=glfwdll.lib stack=1M START=__DLLstartw_ } REFERENCE __DLLstartw_ FILE { $(DLLOBJS) } LIBRARY { $(LINKLIBS) }
##########################################################################
# Rules for building static library object files
##########################################################################
enable.obj: ..\\enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\enable.c
fullscreen.obj: ..\\fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\fullscreen.c
glext.obj: ..\\glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\glext.c
image.obj: ..\\image.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\image.c
init.obj: ..\\init.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\init.c
input.obj: ..\\input.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\input.c
joystick.obj: ..\\joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\joystick.c
stream.obj: ..\\stream.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\stream.c
tga.obj: ..\\tga.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\tga.c
thread.obj: ..\\thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\thread.c
time.obj: ..\\time.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\time.c
window.obj: ..\\window.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ ..\\window.c
win32_enable.obj: win32_enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_enable.c
win32_fullscreen.obj: win32_fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_fullscreen.c
win32_glext.obj: win32_glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_glext.c
win32_init.obj: win32_init.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_init.c
win32_joystick.obj: win32_joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_joystick.c
win32_thread.obj: win32_thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_thread.c
win32_time.obj: win32_time.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_time.c
win32_window.obj: win32_window.c ..\\internal.h platform.h
$(CC) $(CFLAGS) /Fo$@ win32_window.c
##########################################################################
# Rules for building dynamic library object files
##########################################################################
enable_dll.obj: ..\\enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\enable.c
fullscreen_dll.obj: ..\\fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\fullscreen.c
glext_dll.obj: ..\\glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\glext.c
image_dll.obj: ..\\image.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\image.c
init_dll.obj: ..\\init.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\init.c
input_dll.obj: ..\\input.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\input.c
joystick_dll.obj: ..\\joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\joystick.c
stream_dll.obj: ..\\stream.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\stream.c
tga_dll.obj: ..\\tga.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\tga.c
thread_dll.obj: ..\\thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\thread.c
time_dll.obj: ..\\time.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\time.c
window_dll.obj: ..\\window.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ ..\\window.c
win32_dllmain_dll.obj: win32_dllmain.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_dllmain.c
win32_enable_dll.obj: win32_enable.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_enable.c
win32_fullscreen_dll.obj: win32_fullscreen.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_fullscreen.c
win32_glext_dll.obj: win32_glext.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_glext.c
win32_init_dll.obj: win32_init.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_init.c
win32_joystick_dll.obj: win32_joystick.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_joystick.c
win32_thread_dll.obj: win32_thread.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_thread.c
win32_time_dll.obj: win32_time.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_time.c
win32_window_dll.obj: win32_window.c ..\\internal.h platform.h
$(CC) $(CFLAGS_DLL) /Fo$@ win32_window.c

67
ogl_editor/src/External/glfw/lib/win32/glfwdll.def vendored Normal file
View File

@ -0,0 +1,67 @@
LIBRARY GLFW.DLL
EXPORTS
glfwBroadcastCond
glfwCloseWindow
glfwCreateCond
glfwCreateMutex
glfwCreateThread
glfwDestroyCond
glfwDestroyMutex
glfwDestroyThread
glfwDisable
glfwEnable
glfwExtensionSupported
glfwFreeImage
glfwGetDesktopMode
glfwGetGLVersion
glfwGetJoystickButtons
glfwGetJoystickParam
glfwGetJoystickPos
glfwGetKey
glfwGetMouseButton
glfwGetMousePos
glfwGetMouseWheel
glfwGetNumberOfProcessors
glfwGetProcAddress
glfwGetThreadID
glfwGetTime
glfwGetVersion
glfwGetVideoModes
glfwGetWindowParam
glfwGetWindowSize
glfwIconifyWindow
glfwInit
glfwLoadMemoryTexture2D
glfwLoadTexture2D
glfwLoadTextureImage2D
glfwLockMutex
glfwOpenWindow
glfwOpenWindowHint
glfwPollEvents
glfwReadImage
glfwReadMemoryImage
glfwRestoreWindow
glfwSetCharCallback
glfwSetKeyCallback
glfwSetMouseButtonCallback
glfwSetMousePos
glfwSetMousePosCallback
glfwSetMouseWheel
glfwSetMouseWheelCallback
glfwSetTime
glfwSetWindowCloseCallback
glfwSetWindowRefreshCallback
glfwSetWindowPos
glfwSetWindowSize
glfwSetWindowSizeCallback
glfwSetWindowTitle
glfwSignalCond
glfwSleep
glfwSwapBuffers
glfwSwapInterval
glfwTerminate
glfwUnlockMutex
glfwWaitCond
glfwWaitEvents
glfwWaitThread

11
ogl_editor/src/External/glfw/lib/win32/libglfw.pc.in vendored Normal file
View File

@ -0,0 +1,11 @@
prefix=@PREFIX@
exec_prefix=@PREFIX@
libdir=@PREFIX@/lib
includedir=@PREFIX@/include
Name: GLFW
Description: A portable framework for OpenGL development
Version: 2.7
URL: http://www.glfw.org/
Libs: -L${libdir} -lglfw -lglu32 -lopengl32 -lm -s -mwindows -e _mainCRTStartup
Cflags: -I${includedir} -mwin32

558
ogl_editor/src/External/glfw/lib/win32/platform.h vendored Normal file
View File

@ -0,0 +1,558 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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 _platform_h_
#define _platform_h_
// This is the Windows version of GLFW
#define _GLFW_WIN32
// We don't need all the fancy stuff
#define NOMINMAX
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
// Include files
#include <windows.h>
#include <mmsystem.h>
#include "../../include/GL/glfw.h"
//========================================================================
// Hack: Define things that some <windows.h>'s do not define
//========================================================================
// Some old versions of w32api (used by MinGW and Cygwin) define
// WH_KEYBOARD_LL without typedef:ing KBDLLHOOKSTRUCT (!)
#if defined(__MINGW32__) || defined(__CYGWIN__)
#include <w32api.h>
#if defined(WH_KEYBOARD_LL) && (__W32API_MAJOR_VERSION == 1) && (__W32API_MINOR_VERSION <= 2)
#undef WH_KEYBOARD_LL
#endif
#endif
//------------------------------------------------------------------------
// ** NOTE ** If this gives you compiler errors and you are using MinGW
// (or Dev-C++), update to w32api version 1.3 or later:
// http://sourceforge.net/project/showfiles.php?group_id=2435
//------------------------------------------------------------------------
#ifndef WH_KEYBOARD_LL
#define WH_KEYBOARD_LL 13
typedef struct tagKBDLLHOOKSTRUCT {
DWORD vkCode;
DWORD scanCode;
DWORD flags;
DWORD time;
DWORD dwExtraInfo;
} KBDLLHOOKSTRUCT, FAR *LPKBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT;
#endif // WH_KEYBOARD_LL
#ifndef LLKHF_ALTDOWN
#define LLKHF_ALTDOWN 0x00000020
#endif
#ifndef SPI_SETSCREENSAVERRUNNING
#define SPI_SETSCREENSAVERRUNNING 97
#endif
#ifndef SPI_GETANIMATION
#define SPI_GETANIMATION 72
#endif
#ifndef SPI_SETANIMATION
#define SPI_SETANIMATION 73
#endif
#ifndef SPI_GETFOREGROUNDLOCKTIMEOUT
#define SPI_GETFOREGROUNDLOCKTIMEOUT 0x2000
#endif
#ifndef SPI_SETFOREGROUNDLOCKTIMEOUT
#define SPI_SETFOREGROUNDLOCKTIMEOUT 0x2001
#endif
#ifndef CDS_FULLSCREEN
#define CDS_FULLSCREEN 4
#endif
#ifndef PFD_GENERIC_ACCELERATED
#define PFD_GENERIC_ACCELERATED 0x00001000
#endif
#ifndef PFD_DEPTH_DONTCARE
#define PFD_DEPTH_DONTCARE 0x20000000
#endif
#ifndef ENUM_CURRENT_SETTINGS
#define ENUM_CURRENT_SETTINGS -1
#endif
#ifndef ENUM_REGISTRY_SETTINGS
#define ENUM_REGISTRY_SETTINGS -2
#endif
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x020A
#endif
#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120
#endif
#ifndef WM_XBUTTONDOWN
#define WM_XBUTTONDOWN 0x020B
#endif
#ifndef WM_XBUTTONUP
#define WM_XBUTTONUP 0x020C
#endif
#ifndef XBUTTON1
#define XBUTTON1 1
#endif
#ifndef XBUTTON2
#define XBUTTON2 2
#endif
#ifndef WGL_EXT_swap_control
/* Entry points */
typedef int (APIENTRY * PFNWGLSWAPINTERVALEXTPROC) (int);
#endif /*WGL_EXT_swap_control*/
#ifndef WGL_ARB_extensions_string
/* Entry points */
typedef const char *(APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC)( HDC );
#endif /*WGL_ARB_extensions_string*/
#ifndef WGL_EXT_extension_string
/* Entry points */
typedef const char *(APIENTRY * PFNWGLGETEXTENSIONSSTRINGEXTPROC)( void );
#endif /*WGL_EXT_extension_string*/
#ifndef WGL_ARB_pixel_format
/* Entry points */
typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC, int, int, UINT, const int *, int *);
/* Constants for wglGetPixelFormatAttribivARB */
#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
#define WGL_DRAW_TO_WINDOW_ARB 0x2001
#define WGL_SUPPORT_OPENGL_ARB 0x2010
#define WGL_ACCELERATION_ARB 0x2003
#define WGL_DOUBLE_BUFFER_ARB 0x2011
#define WGL_STEREO_ARB 0x2012
#define WGL_PIXEL_TYPE_ARB 0x2013
#define WGL_COLOR_BITS_ARB 0x2014
#define WGL_RED_BITS_ARB 0x2015
#define WGL_GREEN_BITS_ARB 0x2017
#define WGL_BLUE_BITS_ARB 0x2019
#define WGL_ALPHA_BITS_ARB 0x201B
#define WGL_ACCUM_BITS_ARB 0x201D
#define WGL_ACCUM_RED_BITS_ARB 0x201E
#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
#define WGL_DEPTH_BITS_ARB 0x2022
#define WGL_STENCIL_BITS_ARB 0x2023
#define WGL_AUX_BUFFERS_ARB 0x2024
#define WGL_SAMPLE_BUFFERS_ARB 0x2041
#define WGL_SAMPLES_ARB 0x2042
/* Constants for WGL_ACCELERATION_ARB */
#define WGL_NO_ACCELERATION_ARB 0x2025
#define WGL_GENERIC_ACCELERATION_ARB 0x2026
#define WGL_FULL_ACCELERATION_ARB 0x2027
/* Constants for WGL_PIXEL_TYPE_ARB */
#define WGL_TYPE_RGBA_ARB 0x202B
#define WGL_TYPE_COLORINDEX_ARB 0x202C
#endif /*WGL_ARB_pixel_format*/
#ifndef WGL_ARB_create_context
/* Entry points */
typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC, HGLRC, const int *);
/* Tokens for wglCreateContextAttribsARB attributes */
#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
#define WGL_CONTEXT_FLAGS_ARB 0x2094
#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
/* Bits for WGL_CONTEXT_FLAGS_ARB */
#define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001
#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
/* Bits for WGL_CONTEXT_PROFILE_MASK_ARB */
#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
#endif /*WGL_ARB_create_context*/
#ifndef GL_VERSION_3_0
typedef const GLubyte * (APIENTRY *PFNGLGETSTRINGIPROC) (GLenum, GLuint);
#endif /*GL_VERSION_3_0*/
//========================================================================
// DLLs that are loaded at glfwInit()
//========================================================================
// gdi32.dll function pointer typedefs
#ifndef _GLFW_NO_DLOAD_GDI32
typedef int (WINAPI * CHOOSEPIXELFORMAT_T) (HDC,CONST PIXELFORMATDESCRIPTOR*);
typedef int (WINAPI * DESCRIBEPIXELFORMAT_T) (HDC,int,UINT,LPPIXELFORMATDESCRIPTOR);
typedef int (WINAPI * GETPIXELFORMAT_T) (HDC);
typedef BOOL (WINAPI * SETPIXELFORMAT_T) (HDC,int,const PIXELFORMATDESCRIPTOR*);
typedef BOOL (WINAPI * SWAPBUFFERS_T) (HDC);
#endif // _GLFW_NO_DLOAD_GDI32
// winmm.dll function pointer typedefs
#ifndef _GLFW_NO_DLOAD_WINMM
typedef MMRESULT (WINAPI * JOYGETDEVCAPSA_T) (UINT,LPJOYCAPSA,UINT);
typedef MMRESULT (WINAPI * JOYGETPOS_T) (UINT,LPJOYINFO);
typedef MMRESULT (WINAPI * JOYGETPOSEX_T) (UINT,LPJOYINFOEX);
typedef DWORD (WINAPI * TIMEGETTIME_T) (void);
#endif // _GLFW_NO_DLOAD_WINMM
// gdi32.dll shortcuts
#ifndef _GLFW_NO_DLOAD_GDI32
#define _glfw_ChoosePixelFormat _glfwLibrary.Libs.ChoosePixelFormat
#define _glfw_DescribePixelFormat _glfwLibrary.Libs.DescribePixelFormat
#define _glfw_GetPixelFormat _glfwLibrary.Libs.GetPixelFormat
#define _glfw_SetPixelFormat _glfwLibrary.Libs.SetPixelFormat
#define _glfw_SwapBuffers _glfwLibrary.Libs.SwapBuffers
#else
#define _glfw_ChoosePixelFormat ChoosePixelFormat
#define _glfw_DescribePixelFormat DescribePixelFormat
#define _glfw_GetPixelFormat GetPixelFormat
#define _glfw_SetPixelFormat SetPixelFormat
#define _glfw_SwapBuffers SwapBuffers
#endif // _GLFW_NO_DLOAD_GDI32
// winmm.dll shortcuts
#ifndef _GLFW_NO_DLOAD_WINMM
#define _glfw_joyGetDevCaps _glfwLibrary.Libs.joyGetDevCapsA
#define _glfw_joyGetPos _glfwLibrary.Libs.joyGetPos
#define _glfw_joyGetPosEx _glfwLibrary.Libs.joyGetPosEx
#define _glfw_timeGetTime _glfwLibrary.Libs.timeGetTime
#else
#define _glfw_joyGetDevCaps joyGetDevCapsA
#define _glfw_joyGetPos joyGetPos
#define _glfw_joyGetPosEx joyGetPosEx
#define _glfw_timeGetTime timeGetTime
#endif // _GLFW_NO_DLOAD_WINMM
//========================================================================
// GLFW platform specific types
//========================================================================
//------------------------------------------------------------------------
// Pointer length integer
//------------------------------------------------------------------------
typedef INT_PTR GLFWintptr;
//------------------------------------------------------------------------
// Window structure
//------------------------------------------------------------------------
typedef struct _GLFWwin_struct _GLFWwin;
struct _GLFWwin_struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// User callback functions
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWmousewheelfun mouseWheelCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
// User selected window settings
int fullscreen; // Fullscreen flag
int mouseLock; // Mouse-lock flag
int autoPollEvents; // Auto polling flag
int sysKeysDisabled; // System keys disabled flag
int windowNoResize; // Resize- and maximize gadgets disabled flag
int refreshRate; // Vertical monitor refresh rate
// Window status & parameters
int opened; // Flag telling if window is opened or not
int active; // Application active flag
int iconified; // Window iconified flag
int width, height; // Window width and heigth
int accelerated; // GL_TRUE if window is HW accelerated
// Framebuffer attributes
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;
// OpenGL extensions and context attributes
int has_GL_SGIS_generate_mipmap;
int has_GL_ARB_texture_non_power_of_two;
int glMajor, glMinor, glRevision;
int glForward, glDebug, glProfile;
PFNGLGETSTRINGIPROC GetStringi;
// ========= PLATFORM SPECIFIC PART ======================================
// Platform specific window resources
HDC DC; // Private GDI device context
HGLRC context; // Permanent rendering context
HWND window; // Window handle
ATOM classAtom; // Window class atom
int modeID; // Mode ID for fullscreen mode
HHOOK keyboardHook; // Keyboard hook handle
DWORD dwStyle; // Window styles used for window creation
DWORD dwExStyle; // --"--
// Platform specific extensions (context specific)
PFNWGLSWAPINTERVALEXTPROC SwapIntervalEXT;
PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
PFNWGLGETEXTENSIONSSTRINGEXTPROC GetExtensionsStringEXT;
PFNWGLGETEXTENSIONSSTRINGARBPROC GetExtensionsStringARB;
PFNWGLCREATECONTEXTATTRIBSARBPROC CreateContextAttribsARB;
GLboolean has_WGL_EXT_swap_control;
GLboolean has_WGL_ARB_multisample;
GLboolean has_WGL_ARB_pixel_format;
GLboolean has_WGL_ARB_create_context;
GLboolean has_WGL_ARB_create_context_profile;
// Various platform specific internal variables
int oldMouseLock; // Old mouse-lock flag (used for remembering
// mouse-lock state when iconifying)
int oldMouseLockValid;
int desiredRefreshRate; // Desired vertical monitor refresh rate
};
GLFWGLOBAL _GLFWwin _glfwWin;
//------------------------------------------------------------------------
// User input status (most of this should go in _GLFWwin)
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Mouse status
int MousePosX, MousePosY;
int WheelPos;
char MouseButton[ GLFW_MOUSE_BUTTON_LAST+1 ];
// Keyboard status
char Key[ GLFW_KEY_LAST+1 ];
int LastChar;
// User selected settings
int StickyKeys;
int StickyMouseButtons;
int KeyRepeat;
// ========= PLATFORM SPECIFIC PART ======================================
// Platform specific internal variables
int MouseMoved, OldMouseX, OldMouseY;
} _glfwInput;
//------------------------------------------------------------------------
// Library global data
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// Window opening hints
_GLFWhints hints;
// Initial desktop mode
GLFWvidmode desktopMode;
// ========= PLATFORM SPECIFIC PART ======================================
HINSTANCE instance; // Instance of the application
// Timer data
struct {
int HasPerformanceCounter;
double Resolution;
unsigned int t0_32;
__int64 t0_64;
} Timer;
// System information
struct {
int winVer;
int hasUnicode;
DWORD foregroundLockTimeout;
} Sys;
#if !defined(_GLFW_NO_DLOAD_WINMM) || !defined(_GLFW_NO_DLOAD_GDI32)
// Library handles and function pointers
struct {
#ifndef _GLFW_NO_DLOAD_GDI32
// gdi32.dll
HINSTANCE gdi32;
CHOOSEPIXELFORMAT_T ChoosePixelFormat;
DESCRIBEPIXELFORMAT_T DescribePixelFormat;
GETPIXELFORMAT_T GetPixelFormat;
SETPIXELFORMAT_T SetPixelFormat;
SWAPBUFFERS_T SwapBuffers;
#endif // _GLFW_NO_DLOAD_GDI32
// winmm.dll
#ifndef _GLFW_NO_DLOAD_WINMM
HINSTANCE winmm;
JOYGETDEVCAPSA_T joyGetDevCapsA;
JOYGETPOS_T joyGetPos;
JOYGETPOSEX_T joyGetPosEx;
TIMEGETTIME_T timeGetTime;
#endif // _GLFW_NO_DLOAD_WINMM
} Libs;
#endif
} _glfwLibrary;
//------------------------------------------------------------------------
// Thread record (one for each thread)
//------------------------------------------------------------------------
typedef struct _GLFWthread_struct _GLFWthread;
struct _GLFWthread_struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Pointer to previous and next threads in linked list
_GLFWthread *Previous, *Next;
// GLFW user side thread information
GLFWthread ID;
GLFWthreadfun Function;
// ========= PLATFORM SPECIFIC PART ======================================
// System side thread information
HANDLE Handle;
DWORD WinID;
};
//------------------------------------------------------------------------
// General thread information
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Next thread ID to use (increments for every created thread)
GLFWthread NextID;
// First thread in linked list (always the main thread)
_GLFWthread First;
// ========= PLATFORM SPECIFIC PART ======================================
// Critical section lock
CRITICAL_SECTION CriticalSection;
} _glfwThrd;
//========================================================================
// Macros for encapsulating critical code sections (i.e. making parts
// of GLFW thread safe)
//========================================================================
// Thread list management
#define ENTER_THREAD_CRITICAL_SECTION \
EnterCriticalSection( &_glfwThrd.CriticalSection );
#define LEAVE_THREAD_CRITICAL_SECTION \
LeaveCriticalSection( &_glfwThrd.CriticalSection );
//========================================================================
// Various Windows version constants
//========================================================================
#define _GLFW_WIN_UNKNOWN 0x0000 // Earlier than 95 or NT4
#define _GLFW_WIN_95 0x0001
#define _GLFW_WIN_98 0x0002
#define _GLFW_WIN_ME 0x0003
#define _GLFW_WIN_UNKNOWN_9x 0x0004 // Later than ME
#define _GLFW_WIN_NT4 0x0101
#define _GLFW_WIN_2K 0x0102
#define _GLFW_WIN_XP 0x0103
#define _GLFW_WIN_NET_SERVER 0x0104
#define _GLFW_WIN_UNKNOWN_NT 0x0105 // Later than .NET Server
//========================================================================
// Prototypes for platform specific internal functions
//========================================================================
// Time
void _glfwInitTimer( void );
// Fullscreen support
int _glfwGetClosestVideoModeBPP( int *w, int *h, int *bpp, int *refresh );
int _glfwGetClosestVideoMode( int *w, int *h, int *r, int *g, int *b, int *refresh );
void _glfwSetVideoModeMODE( int mode );
void _glfwSetVideoMode( int *w, int *h, int r, int g, int b, int refresh );
#endif // _platform_h_

49
ogl_editor/src/External/glfw/lib/win32/win32_dllmain.c vendored Normal file
View File

@ -0,0 +1,49 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
#if defined(GLFW_BUILD_DLL)
//========================================================================
// GLFW DLL entry point
//========================================================================
BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, LPVOID reserved )
{
// NOTE: Some compilers complains about instance and x never being used -
// never mind that (we don't want to use them)!
return TRUE;
}
#endif // GLFW_BUILD_DLL

155
ogl_editor/src/External/glfw/lib/win32/win32_enable.c vendored Normal file
View File

@ -0,0 +1,155 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Low level keyboard hook (system callback) function
// Used to disable system keys under Windows NT
//========================================================================
static LRESULT CALLBACK keyboardHook( int nCode, WPARAM wParam, LPARAM lParam )
{
BOOL syskeys = FALSE;
PKBDLLHOOKSTRUCT p;
// We are only looking for keyboard events - interpret lParam as a
// pointer to a KBDLLHOOKSTRUCT
p = (PKBDLLHOOKSTRUCT) lParam;
if( nCode == HC_ACTION )
{
// We have a keyboard event
switch( wParam )
{
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_SYSKEYUP:
// Detect: ALT+TAB, ALT+ESC, ALT+F4, CTRL+ESC,
// LWIN, RWIN, APPS (mysterious menu key)
syskeys = ( p->vkCode == VK_TAB &&
p->flags & LLKHF_ALTDOWN ) ||
( p->vkCode == VK_ESCAPE &&
p->flags & LLKHF_ALTDOWN ) ||
( p->vkCode == VK_F4 &&
p->flags & LLKHF_ALTDOWN ) ||
( p->vkCode == VK_ESCAPE &&
(GetKeyState(VK_CONTROL) & 0x8000)) ||
p->vkCode == VK_LWIN ||
p->vkCode == VK_RWIN ||
p->vkCode == VK_APPS;
break;
default:
break;
}
}
// Was it a system key combination (e.g. ALT+TAB)?
if( syskeys )
{
// Pass the key event to our window message loop
if( _glfwWin.opened )
{
PostMessage( _glfwWin.window, (UINT) wParam, p->vkCode, 0 );
}
// We've taken care of it - don't let the system know about this
// key event
return 1;
}
else
{
// It's a harmless key press, let the system deal with it
return CallNextHookEx( _glfwWin.keyboardHook, nCode, wParam, lParam );
}
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Enable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys( void )
{
BOOL dummy;
// Use different methods depending on operating system version
if( _glfwLibrary.Sys.winVer >= _GLFW_WIN_NT4 )
{
if( _glfwWin.keyboardHook != NULL )
{
UnhookWindowsHookEx( _glfwWin.keyboardHook );
_glfwWin.keyboardHook = NULL;
}
}
else
{
(void) SystemParametersInfo( SPI_SETSCREENSAVERRUNNING, FALSE, &dummy, 0 );
}
}
//========================================================================
// Disable system keys
//========================================================================
void _glfwPlatformDisableSystemKeys( void )
{
BOOL dummy;
// Use different methods depending on operating system version
if( _glfwLibrary.Sys.winVer >= _GLFW_WIN_NT4 )
{
// Under Windows NT, install a low level keyboard hook
_glfwWin.keyboardHook = SetWindowsHookEx( WH_KEYBOARD_LL,
keyboardHook,
_glfwLibrary.instance,
0 );
}
else
{
// Under Windows 95/98/ME, fool Windows that a screensaver
// is running => prevents ALT+TAB, CTRL+ESC and CTRL+ALT+DEL
(void) SystemParametersInfo( SPI_SETSCREENSAVERRUNNING, TRUE, &dummy, 0 );
}
}

320
ogl_editor/src/External/glfw/lib/win32/win32_fullscreen.c vendored Normal file
View File

@ -0,0 +1,320 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Convert BPP to RGB bits based on "best guess"
//========================================================================
static void bpp2rgb( int bpp, int *r, int *g, int *b )
{
int delta;
// We assume that by 32 they really meant 24
if( bpp == 32 )
{
bpp = 24;
}
// Convert "bits per pixel" to red, green & blue sizes
*r = *g = *b = bpp / 3;
delta = bpp - (*r * 3);
if( delta >= 1 )
{
*g = *g + 1;
}
if( delta == 2 )
{
*r = *r + 1;
}
}
//========================================================================
// Return closest video mode by dimensions, refresh rate and bits per pixel
//========================================================================
int _glfwGetClosestVideoModeBPP( int *w, int *h, int *bpp, int *refresh )
{
int mode, bestmode, match, bestmatch, rr, bestrr, success;
DEVMODE dm;
// Find best match
bestmatch = 0x7fffffff;
bestrr = 0x7fffffff;
mode = bestmode = 0;
do
{
dm.dmSize = sizeof( DEVMODE );
success = EnumDisplaySettings( NULL, mode, &dm );
if( success )
{
match = dm.dmBitsPerPel - *bpp;
if( match < 0 ) match = -match;
match = ( match << 25 ) |
( (dm.dmPelsWidth - *w) *
(dm.dmPelsWidth - *w) +
(dm.dmPelsHeight - *h) *
(dm.dmPelsHeight - *h) );
if( match < bestmatch )
{
bestmatch = match;
bestmode = mode;
bestrr = (dm.dmDisplayFrequency - *refresh) *
(dm.dmDisplayFrequency - *refresh);
}
else if( match == bestmatch && *refresh > 0 )
{
rr = (dm.dmDisplayFrequency - *refresh) *
(dm.dmDisplayFrequency - *refresh);
if( rr < bestrr )
{
bestmatch = match;
bestmode = mode;
bestrr = rr;
}
}
}
mode ++;
}
while( success );
// Get the parameters for the best matching display mode
dm.dmSize = sizeof( DEVMODE );
(void) EnumDisplaySettings( NULL, bestmode, &dm );
// Fill out actual width and height
*w = dm.dmPelsWidth;
*h = dm.dmPelsHeight;
// Return bits per pixel
*bpp = dm.dmBitsPerPel;
// Return vertical refresh rate
*refresh = dm.dmDisplayFrequency;
return bestmode;
}
//========================================================================
// Return closest video mode by dimensions, refresh rate and channel sizes
//========================================================================
static int getClosestVideoMode( int *w, int *h,
int *r, int *g, int *b,
int *refresh )
{
int bpp, bestmode;
// Colorbits = sum of red/green/blue bits
bpp = *r + *g + *b;
// If colorbits < 15 (e.g. 0) or >= 24, default to 32 bpp
if( bpp < 15 || bpp >= 24 )
{
bpp = 32;
}
// Find best match
bestmode = _glfwGetClosestVideoModeBPP( w, h, &bpp, refresh );
// Convert "bits per pixel" to red, green & blue sizes
bpp2rgb( bpp, r, g, b );
return bestmode;
}
//========================================================================
// Change the current video mode
//========================================================================
void _glfwSetVideoModeMODE( int mode )
{
DEVMODE dm;
int success;
// Get the parameters for the best matching display mode
dm.dmSize = sizeof( DEVMODE );
(void) EnumDisplaySettings( NULL, mode, &dm );
// Set which fields we want to specify
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
// Do we have a prefered refresh rate?
if( _glfwWin.desiredRefreshRate > 0 )
{
dm.dmFields = dm.dmFields | DM_DISPLAYFREQUENCY;
dm.dmDisplayFrequency = _glfwWin.desiredRefreshRate;
}
// Change display setting
dm.dmSize = sizeof( DEVMODE );
success = ChangeDisplaySettings( &dm, CDS_FULLSCREEN );
// If the mode change was not possible, query the current display
// settings (we'll use the desktop resolution for fullscreen mode)
if( success == DISP_CHANGE_SUCCESSFUL )
{
_glfwWin.modeID = mode;
}
else
{
_glfwWin.modeID = ENUM_REGISTRY_SETTINGS;
EnumDisplaySettings( NULL, ENUM_REGISTRY_SETTINGS, &dm );
}
// Set the window size to that of the display mode
_glfwWin.width = dm.dmPelsWidth;
_glfwWin.height = dm.dmPelsHeight;
}
//========================================================================
// Change the current video mode
//========================================================================
void _glfwSetVideoMode( int *w, int *h, int r, int g, int b, int refresh )
{
int bestmode;
// Find a best match mode
bestmode = getClosestVideoMode( w, h, &r, &g, &b, &refresh );
// Change mode
_glfwSetVideoModeMODE( bestmode );
}
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Get a list of available video modes
//========================================================================
int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )
{
int count, success, mode, i, j;
int m1, m2, bpp, r, g, b;
DEVMODE dm;
// Loop through all video modes and extract all the UNIQUE modes
count = 0;
mode = 0;
do
{
// Get video mode properties
dm.dmSize = sizeof( DEVMODE );
success = EnumDisplaySettings( NULL, mode, &dm );
// Is it a valid mode? (only list depths >= 15 bpp)
if( success && dm.dmBitsPerPel >= 15 )
{
// Convert to RGB, and back to bpp ("mask out" alpha bits etc)
bpp2rgb( dm.dmBitsPerPel, &r, &g, &b );
bpp = r + g + b;
// Mode "code" for this mode
m1 = (bpp << 25) | (dm.dmPelsWidth * dm.dmPelsHeight);
// Insert mode in list (sorted), and avoid duplicates
for( i = 0; i < count; i ++ )
{
// Mode "code" for already listed mode
bpp = list[i].RedBits + list[i].GreenBits +
list[i].BlueBits;
m2 = (bpp << 25) | (list[i].Width * list[i].Height);
if( m1 <= m2 )
{
break;
}
}
// New entry at the end of the list?
if( i >= count )
{
list[count].Width = dm.dmPelsWidth;
list[count].Height = dm.dmPelsHeight;
list[count].RedBits = r;
list[count].GreenBits = g;
list[count].BlueBits = b;
count ++;
}
// Insert new entry in the list?
else if( m1 < m2 )
{
for( j = count; j > i; j -- )
{
list[j] = list[j-1];
}
list[i].Width = dm.dmPelsWidth;
list[i].Height = dm.dmPelsHeight;
list[i].RedBits = r;
list[i].GreenBits = g;
list[i].BlueBits = b;
count ++;
}
}
mode ++;
}
while( success && (count < maxcount) );
return count;
}
//========================================================================
// Get the desktop video mode
//========================================================================
void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )
{
DEVMODE dm;
// Get desktop display mode
dm.dmSize = sizeof( DEVMODE );
(void) EnumDisplaySettings( NULL, ENUM_REGISTRY_SETTINGS, &dm );
// Return desktop mode parameters
mode->Width = dm.dmPelsWidth;
mode->Height = dm.dmPelsHeight;
bpp2rgb( dm.dmBitsPerPel, &mode->RedBits, &mode->GreenBits, &mode->BlueBits );
}

82
ogl_editor/src/External/glfw/lib/win32/win32_glext.c vendored Normal file
View File

@ -0,0 +1,82 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Check if the current context supports the specified WGL extension
//========================================================================
int _glfwPlatformExtensionSupported( const char *extension )
{
const GLubyte *extensions;
if( _glfwWin.GetExtensionsStringEXT != NULL )
{
extensions = (GLubyte *) _glfwWin.GetExtensionsStringEXT();
if( extensions != NULL )
{
if( _glfwStringInExtensionString( extension, extensions ) )
{
return GL_TRUE;
}
}
}
if( _glfwWin.GetExtensionsStringARB != NULL )
{
extensions = (GLubyte *) _glfwWin.GetExtensionsStringARB( _glfwWin.DC );
if( extensions != NULL )
{
if( _glfwStringInExtensionString( extension, extensions ) )
{
return GL_TRUE;
}
}
}
return GL_FALSE;
}
//========================================================================
// Get the function pointer to an OpenGL function
//========================================================================
void *_glfwPlatformGetProcAddress( const char *procname )
{
return (void *) wglGetProcAddress( procname );
}

358
ogl_editor/src/External/glfw/lib/win32/win32_init.c vendored Normal file
View File

@ -0,0 +1,358 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
// With the Borland C++ compiler, we want to disable FPU exceptions
#ifdef __BORLANDC__
#include <float.h>
#endif // __BORLANDC__
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Load necessary libraries (DLLs)
//========================================================================
static int _glfwInitLibraries( void )
{
// gdi32.dll (OpenGL pixel format functions & SwapBuffers)
#ifndef _GLFW_NO_DLOAD_GDI32
_glfwLibrary.Libs.gdi32 = LoadLibrary( "gdi32.dll" );
if( _glfwLibrary.Libs.gdi32 != NULL )
{
_glfwLibrary.Libs.ChoosePixelFormat = (CHOOSEPIXELFORMAT_T)
GetProcAddress( _glfwLibrary.Libs.gdi32, "ChoosePixelFormat" );
_glfwLibrary.Libs.DescribePixelFormat = (DESCRIBEPIXELFORMAT_T)
GetProcAddress( _glfwLibrary.Libs.gdi32, "DescribePixelFormat" );
_glfwLibrary.Libs.GetPixelFormat = (GETPIXELFORMAT_T)
GetProcAddress( _glfwLibrary.Libs.gdi32, "GetPixelFormat" );
_glfwLibrary.Libs.SetPixelFormat = (SETPIXELFORMAT_T)
GetProcAddress( _glfwLibrary.Libs.gdi32, "SetPixelFormat" );
_glfwLibrary.Libs.SwapBuffers = (SWAPBUFFERS_T)
GetProcAddress( _glfwLibrary.Libs.gdi32, "SwapBuffers" );
if( _glfwLibrary.Libs.ChoosePixelFormat == NULL ||
_glfwLibrary.Libs.DescribePixelFormat == NULL ||
_glfwLibrary.Libs.GetPixelFormat == NULL ||
_glfwLibrary.Libs.SetPixelFormat == NULL ||
_glfwLibrary.Libs.SwapBuffers == NULL )
{
FreeLibrary( _glfwLibrary.Libs.gdi32 );
_glfwLibrary.Libs.gdi32 = NULL;
return GL_FALSE;
}
}
else
{
return GL_FALSE;
}
#endif // _GLFW_NO_DLOAD_GDI32
// winmm.dll (for joystick and timer support)
#ifndef _GLFW_NO_DLOAD_WINMM
_glfwLibrary.Libs.winmm = LoadLibrary( "winmm.dll" );
if( _glfwLibrary.Libs.winmm != NULL )
{
_glfwLibrary.Libs.joyGetDevCapsA = (JOYGETDEVCAPSA_T)
GetProcAddress( _glfwLibrary.Libs.winmm, "joyGetDevCapsA" );
_glfwLibrary.Libs.joyGetPos = (JOYGETPOS_T)
GetProcAddress( _glfwLibrary.Libs.winmm, "joyGetPos" );
_glfwLibrary.Libs.joyGetPosEx = (JOYGETPOSEX_T)
GetProcAddress( _glfwLibrary.Libs.winmm, "joyGetPosEx" );
_glfwLibrary.Libs.timeGetTime = (TIMEGETTIME_T)
GetProcAddress( _glfwLibrary.Libs.winmm, "timeGetTime" );
if( _glfwLibrary.Libs.joyGetDevCapsA == NULL ||
_glfwLibrary.Libs.joyGetPos == NULL ||
_glfwLibrary.Libs.joyGetPosEx == NULL ||
_glfwLibrary.Libs.timeGetTime == NULL )
{
FreeLibrary( _glfwLibrary.Libs.winmm );
_glfwLibrary.Libs.winmm = NULL;
return GL_FALSE;
}
}
else
{
return GL_FALSE;
}
#endif // _GLFW_NO_DLOAD_WINMM
return GL_TRUE;
}
//========================================================================
// Unload used libraries (DLLs)
//========================================================================
static void _glfwFreeLibraries( void )
{
// gdi32.dll
#ifndef _GLFW_NO_DLOAD_GDI32
if( _glfwLibrary.Libs.gdi32 != NULL )
{
FreeLibrary( _glfwLibrary.Libs.gdi32 );
_glfwLibrary.Libs.gdi32 = NULL;
}
#endif // _GLFW_NO_DLOAD_GDI32
// winmm.dll
#ifndef _GLFW_NO_DLOAD_WINMM
if( _glfwLibrary.Libs.winmm != NULL )
{
FreeLibrary( _glfwLibrary.Libs.winmm );
_glfwLibrary.Libs.winmm = NULL;
}
#endif // _GLFW_NO_DLOAD_WINMM
}
//========================================================================
// Initialize GLFW thread package
//========================================================================
static void _glfwInitThreads( void )
{
// Initialize critical section handle
InitializeCriticalSection( &_glfwThrd.CriticalSection );
// The first thread (the main thread) has ID 0
_glfwThrd.NextID = 0;
// Fill out information about the main thread (this thread)
_glfwThrd.First.ID = _glfwThrd.NextID ++;
_glfwThrd.First.Function = NULL;
_glfwThrd.First.Handle = GetCurrentThread();
_glfwThrd.First.WinID = GetCurrentThreadId();
_glfwThrd.First.Previous = NULL;
_glfwThrd.First.Next = NULL;
}
//========================================================================
// Terminate GLFW thread package
//========================================================================
static void _glfwTerminateThreads( void )
{
_GLFWthread *t, *t_next;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Kill all threads (NOTE: THE USER SHOULD WAIT FOR ALL THREADS TO
// DIE, _BEFORE_ CALLING glfwTerminate()!!!)
t = _glfwThrd.First.Next;
while( t != NULL )
{
// Get pointer to next thread
t_next = t->Next;
// Simply murder the process, no mercy!
if( TerminateThread( t->Handle, 0 ) )
{
// Close thread handle
CloseHandle( t->Handle );
// Free memory allocated for this thread
free( (void *) t );
}
// Select next thread in list
t = t_next;
}
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Delete critical section handle
DeleteCriticalSection( &_glfwThrd.CriticalSection );
}
//========================================================================
// Terminate GLFW when exiting application
//========================================================================
void _glfwTerminate_atexit( void )
{
glfwTerminate();
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Initialize various GLFW state
//========================================================================
int _glfwPlatformInit( void )
{
OSVERSIONINFO osi;
// To make SetForegroundWindow() work as we want, we need to fiddle
// with the FOREGROUNDLOCKTIMEOUT system setting (we do this as early
// as possible in the hope of still being the foreground process)
SystemParametersInfo( SPI_GETFOREGROUNDLOCKTIMEOUT, 0,
&_glfwLibrary.Sys.foregroundLockTimeout, 0 );
SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (LPVOID)0,
SPIF_SENDCHANGE );
// Check which OS version we are running
osi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
GetVersionEx( &osi );
_glfwLibrary.Sys.winVer = _GLFW_WIN_UNKNOWN;
if( osi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
{
if( osi.dwMajorVersion == 4 && osi.dwMinorVersion < 10 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_95;
}
else if( osi.dwMajorVersion == 4 && osi.dwMinorVersion < 90 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_98;
}
else if( osi.dwMajorVersion == 4 && osi.dwMinorVersion == 90 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_ME;
}
else if( osi.dwMajorVersion >= 4 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_UNKNOWN_9x;
}
}
else if( osi.dwPlatformId == VER_PLATFORM_WIN32_NT )
{
if( osi.dwMajorVersion == 4 && osi.dwMinorVersion == 0 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_NT4;
}
else if( osi.dwMajorVersion == 5 && osi.dwMinorVersion == 0 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_2K;
}
else if( osi.dwMajorVersion == 5 && osi.dwMinorVersion == 1 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_XP;
}
else if( osi.dwMajorVersion == 5 && osi.dwMinorVersion == 2 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_NET_SERVER;
}
else if( osi.dwMajorVersion >= 5 )
{
_glfwLibrary.Sys.winVer = _GLFW_WIN_UNKNOWN_NT;
}
}
// Do we have Unicode support?
if( _glfwLibrary.Sys.winVer >= _GLFW_WIN_NT4 )
{
// Windows NT/2000/XP/.NET has Unicode support
_glfwLibrary.Sys.hasUnicode = GL_TRUE;
}
else
{
// Windows 9x/ME does not have Unicode support
_glfwLibrary.Sys.hasUnicode = GL_FALSE;
}
// Load libraries (DLLs)
if( !_glfwInitLibraries() )
{
return GL_FALSE;
}
// With the Borland C++ compiler, we want to disable FPU exceptions
// (this is recommended for OpenGL applications under Windows)
#ifdef __BORLANDC__
_control87( MCW_EM, MCW_EM );
#endif
// Retrieve GLFW instance handle
_glfwLibrary.instance = GetModuleHandle( NULL );
// System keys are not disabled
_glfwWin.keyboardHook = NULL;
// Initialise thread package
_glfwInitThreads();
_glfwPlatformGetDesktopMode( &_glfwLibrary.desktopMode );
// Install atexit() routine
atexit( _glfwTerminate_atexit );
// Start the timer
_glfwInitTimer();
return GL_TRUE;
}
//========================================================================
// Close window and kill all threads
//========================================================================
int _glfwPlatformTerminate( void )
{
// Only the main thread is allowed to do this...
if( GetCurrentThreadId() != _glfwThrd.First.WinID )
{
return GL_FALSE;
}
// Close OpenGL window
glfwCloseWindow();
// Kill thread package
_glfwTerminateThreads();
// Enable system keys again (if they were disabled)
glfwEnable( GLFW_SYSTEM_KEYS );
// Unload libraries (DLLs)
_glfwFreeLibraries();
// Restore FOREGROUNDLOCKTIMEOUT system setting
SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT, 0,
(LPVOID) (INT_PTR) _glfwLibrary.Sys.foregroundLockTimeout,
SPIF_SENDCHANGE );
return GL_TRUE;
}

233
ogl_editor/src/External/glfw/lib/win32/win32_joystick.c vendored Normal file
View File

@ -0,0 +1,233 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Return GL_TRUE if joystick is present, else return GL_FALSE.
//========================================================================
static int _glfwJoystickPresent( int joy )
{
JOYINFO ji;
// Windows NT 4.0 MMSYSTEM only supports 2 sticks (other Windows
// versions support 16 sticks)
if( _glfwLibrary.Sys.winVer == _GLFW_WIN_NT4 && joy > GLFW_JOYSTICK_2 )
{
return GL_FALSE;
}
// Is it a valid stick ID (Windows don't support more than 16 sticks)?
if( joy < GLFW_JOYSTICK_1 || joy > GLFW_JOYSTICK_16 )
{
return GL_FALSE;
}
// Is the joystick present?
if( _glfw_joyGetPos( joy - GLFW_JOYSTICK_1, &ji ) != JOYERR_NOERROR )
{
return GL_FALSE;
}
return GL_TRUE;
}
//========================================================================
// Calculate joystick position
//========================================================================
static float _glfwCalcJoystickPos( DWORD pos, DWORD min, DWORD max )
{
float fpos = (float) pos;
float fmin = (float) min;
float fmax = (float) max;
return (2.0f*(fpos - fmin) / (fmax - fmin)) - 1.0f;
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Determine joystick capabilities
//========================================================================
int _glfwPlatformGetJoystickParam( int joy, int param )
{
JOYCAPS jc;
// return 0;
// Is joystick present?
if( !_glfwJoystickPresent( joy ) )
{
return 0;
}
// We got this far, the joystick is present
if( param == GLFW_PRESENT )
{
return GL_TRUE;
}
// Get joystick capabilities
_glfw_joyGetDevCaps( joy - GLFW_JOYSTICK_1, &jc, sizeof(JOYCAPS) );
switch( param )
{
case GLFW_AXES:
// Return number of joystick axes
return jc.wNumAxes;
case GLFW_BUTTONS:
// Return number of joystick axes
return jc.wNumButtons;
default:
break;
}
return 0;
}
//========================================================================
// Get joystick axis positions
//========================================================================
int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )
{
JOYCAPS jc;
JOYINFOEX ji;
int axis;
// return 0;
// Is joystick present?
if( !_glfwJoystickPresent( joy ) )
{
return 0;
}
// Get joystick capabilities
_glfw_joyGetDevCaps( joy - GLFW_JOYSTICK_1, &jc, sizeof(JOYCAPS) );
// Get joystick state
ji.dwSize = sizeof( JOYINFOEX );
ji.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ |
JOY_RETURNR | JOY_RETURNU | JOY_RETURNV;
_glfw_joyGetPosEx( joy - GLFW_JOYSTICK_1, &ji );
// Get position values for all axes
axis = 0;
if( axis < numaxes )
{
pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwXpos, jc.wXmin,
jc.wXmax );
}
if( axis < numaxes )
{
pos[ axis++ ] = -_glfwCalcJoystickPos( ji.dwYpos, jc.wYmin,
jc.wYmax );
}
if( axis < numaxes && jc.wCaps & JOYCAPS_HASZ )
{
pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwZpos, jc.wZmin,
jc.wZmax );
}
if( axis < numaxes && jc.wCaps & JOYCAPS_HASR )
{
pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwRpos, jc.wRmin,
jc.wRmax );
}
if( axis < numaxes && jc.wCaps & JOYCAPS_HASU )
{
pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwUpos, jc.wUmin,
jc.wUmax );
}
if( axis < numaxes && jc.wCaps & JOYCAPS_HASV )
{
pos[ axis++ ] = -_glfwCalcJoystickPos( ji.dwVpos, jc.wVmin,
jc.wVmax );
}
// Return number of returned axes
return axis;
}
//========================================================================
// Get joystick button states
//========================================================================
int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons,
int numbuttons )
{
JOYCAPS jc;
JOYINFOEX ji;
int button;
// return 0;
// Is joystick present?
if( !_glfwJoystickPresent( joy ) )
{
return 0;
}
// Get joystick capabilities
_glfw_joyGetDevCaps( joy - GLFW_JOYSTICK_1, &jc, sizeof(JOYCAPS) );
// Get joystick state
ji.dwSize = sizeof( JOYINFOEX );
ji.dwFlags = JOY_RETURNBUTTONS;
_glfw_joyGetPosEx( joy - GLFW_JOYSTICK_1, &ji );
// Get states of all requested buttons
button = 0;
while( button < numbuttons && button < (int) jc.wNumButtons )
{
buttons[ button ] = (unsigned char)
(ji.dwButtons & (1UL << button) ? GLFW_PRESS : GLFW_RELEASE);
button ++;
}
return button;
}

506
ogl_editor/src/External/glfw/lib/win32/win32_thread.c vendored Normal file
View File

@ -0,0 +1,506 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
// This is an implementation of POSIX "compatible" condition variables for
// Win32, as described by Douglas C. Schmidt and Irfan Pyarali:
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
//************************************************************************
enum {
_GLFW_COND_SIGNAL = 0,
_GLFW_COND_BROADCAST = 1
};
typedef struct {
// Signal and broadcast event HANDLEs
HANDLE events[ 2 ];
// Count of the number of waiters
unsigned int waiters_count;
// Serialize access to <waiters_count>
CRITICAL_SECTION waiters_count_lock;
} _GLFWcond;
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// This is simply a "wrapper" for calling the user thread function.
//========================================================================
DWORD WINAPI _glfwNewThread( LPVOID lpParam )
{
GLFWthreadfun threadfun;
_GLFWthread *t;
// Get pointer to thread information for current thread
t = _glfwGetThreadPointer( _glfwPlatformGetThreadID() );
if( t == NULL )
{
return 0;
}
// Get user thread function pointer
threadfun = t->Function;
// Call the user thread function
threadfun( (void *) lpParam );
// Remove thread from thread list
ENTER_THREAD_CRITICAL_SECTION
_glfwRemoveThread( t );
LEAVE_THREAD_CRITICAL_SECTION
// When the thread function returns, the thread will die...
return 0;
}
//************************************************************************
//**** GLFW user functions ****
//************************************************************************
//========================================================================
// Create a new thread
//========================================================================
GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )
{
GLFWthread ID;
_GLFWthread *t, *t_tmp;
HANDLE hThread;
DWORD dwThreadId;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Create a new thread information memory area
t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );
if( t == NULL )
{
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Get a new unique thread id
ID = _glfwThrd.NextID ++;
// Store thread information in the thread list
t->Function = fun;
t->ID = ID;
// Create thread
hThread = CreateThread(
NULL, // Default security attributes
0, // Default stack size (1 MB)
_glfwNewThread, // Thread function (a wrapper function)
(LPVOID)arg, // Argument to thread is the user argument
0, // Default creation flags
&dwThreadId // Returned thread identifier
);
// Did the thread creation fail?
if( hThread == NULL )
{
free( (void *) t );
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Store more thread information in the thread list
t->Handle = hThread;
t->WinID = dwThreadId;
// Append thread to thread list
t_tmp = &_glfwThrd.First;
while( t_tmp->Next != NULL )
{
t_tmp = t_tmp->Next;
}
t_tmp->Next = t;
t->Previous = t_tmp;
t->Next = NULL;
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the GLFW thread ID
return ID;
}
//========================================================================
// Kill a thread. NOTE: THIS IS A VERY DANGEROUS OPERATION, AND SHOULD NOT
// BE USED EXCEPT IN EXTREME SITUATIONS!
//========================================================================
void _glfwPlatformDestroyThread( GLFWthread ID )
{
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return;
}
// Simply murder the process, no mercy!
if( TerminateThread( t->Handle, 0 ) )
{
// Close thread handle
CloseHandle( t->Handle );
// Remove thread from thread list
_glfwRemoveThread( t );
}
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
}
//========================================================================
// Wait for a thread to die
//========================================================================
int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )
{
DWORD result;
HANDLE hThread;
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
// Is the thread already dead?
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return GL_TRUE;
}
// Get thread handle
hThread = t->Handle;
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Wait for thread to die
if( waitmode == GLFW_WAIT )
{
result = WaitForSingleObject( hThread, INFINITE );
}
else if( waitmode == GLFW_NOWAIT )
{
result = WaitForSingleObject( hThread, 0 );
}
else
{
return GL_FALSE;
}
// Did we have a time-out?
if( result == WAIT_TIMEOUT )
{
return GL_FALSE;
}
return GL_TRUE;
}
//========================================================================
// Return the thread ID for the current thread
//========================================================================
GLFWthread _glfwPlatformGetThreadID( void )
{
_GLFWthread *t;
GLFWthread ID = -1;
DWORD WinID;
// Get Windows thread ID
WinID = GetCurrentThreadId();
// Enter critical section (to avoid an inconsistent thread list)
ENTER_THREAD_CRITICAL_SECTION
// Loop through entire list of threads to find the matching Windows
// thread ID
for( t = &_glfwThrd.First; t != NULL; t = t->Next )
{
if( t->WinID == WinID )
{
ID = t->ID;
break;
}
}
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the found GLFW thread identifier
return ID;
}
//========================================================================
// Create a mutual exclusion object
//========================================================================
GLFWmutex _glfwPlatformCreateMutex( void )
{
CRITICAL_SECTION *mutex;
// Allocate memory for mutex
mutex = (CRITICAL_SECTION *) malloc( sizeof(CRITICAL_SECTION) );
if( !mutex )
{
return NULL;
}
// Initialize mutex
InitializeCriticalSection( mutex );
// Cast to GLFWmutex and return
return (GLFWmutex) mutex;
}
//========================================================================
// Destroy a mutual exclusion object
//========================================================================
void _glfwPlatformDestroyMutex( GLFWmutex mutex )
{
// Destroy mutex
DeleteCriticalSection( (CRITICAL_SECTION *) mutex );
free( mutex );
}
//========================================================================
// Request access to a mutex
//========================================================================
void _glfwPlatformLockMutex( GLFWmutex mutex )
{
// Wait for mutex to be released
EnterCriticalSection( (CRITICAL_SECTION *) mutex );
}
//========================================================================
// Release a mutex
//========================================================================
void _glfwPlatformUnlockMutex( GLFWmutex mutex )
{
// Release mutex
LeaveCriticalSection( (CRITICAL_SECTION *) mutex );
}
//========================================================================
// Create a new condition variable object
//========================================================================
GLFWcond _glfwPlatformCreateCond( void )
{
_GLFWcond *cond;
// Allocate memory for condition variable
cond = (_GLFWcond *) malloc( sizeof(_GLFWcond) );
if( !cond )
{
return NULL;
}
// Initialize condition variable
cond->waiters_count = 0;
cond->events[ _GLFW_COND_SIGNAL ] = CreateEvent( NULL, FALSE,
FALSE, NULL );
cond->events[ _GLFW_COND_BROADCAST ] = CreateEvent( NULL, TRUE,
FALSE, NULL );
InitializeCriticalSection( &cond->waiters_count_lock );
// Cast to GLFWcond and return
return (GLFWcond) cond;
}
//========================================================================
// Destroy a condition variable object
//========================================================================
void _glfwPlatformDestroyCond( GLFWcond cond )
{
// Close the condition variable handles
CloseHandle( ((_GLFWcond *)cond)->events[ _GLFW_COND_SIGNAL ] );
CloseHandle( ((_GLFWcond *)cond)->events[ _GLFW_COND_BROADCAST ] );
// Delete critical section
DeleteCriticalSection( &((_GLFWcond *)cond)->waiters_count_lock );
// Free memory for condition variable
free( (void *) cond );
}
//========================================================================
// Wait for a condition to be raised
//========================================================================
void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex, double timeout )
{
_GLFWcond *cv = (_GLFWcond *) cond;
int result, last_waiter;
DWORD timeout_ms;
// Avoid race conditions
EnterCriticalSection( &cv->waiters_count_lock );
cv->waiters_count ++;
LeaveCriticalSection( &cv->waiters_count_lock );
// It's ok to release the mutex here since Win32 manual-reset events
// maintain state when used with SetEvent()
LeaveCriticalSection( (CRITICAL_SECTION *) mutex );
// Translate timeout into milliseconds
if( timeout >= GLFW_INFINITY )
{
timeout_ms = INFINITE;
}
else
{
timeout_ms = (DWORD) (1000.0 * timeout + 0.5);
if( timeout_ms <= 0 )
{
timeout_ms = 1;
}
}
// Wait for either event to become signaled due to glfwSignalCond or
// glfwBroadcastCond being called
result = WaitForMultipleObjects( 2, cv->events, FALSE, timeout_ms );
// Check if we are the last waiter
EnterCriticalSection( &cv->waiters_count_lock );
cv->waiters_count --;
last_waiter = (result == WAIT_OBJECT_0 + _GLFW_COND_BROADCAST) &&
(cv->waiters_count == 0);
LeaveCriticalSection( &cv->waiters_count_lock );
// Some thread called glfwBroadcastCond
if( last_waiter )
{
// We're the last waiter to be notified or to stop waiting, so
// reset the manual event
ResetEvent( cv->events[ _GLFW_COND_BROADCAST ] );
}
// Reacquire the mutex
EnterCriticalSection( (CRITICAL_SECTION *) mutex );
}
//========================================================================
// Signal a condition to one waiting thread
//========================================================================
void _glfwPlatformSignalCond( GLFWcond cond )
{
_GLFWcond *cv = (_GLFWcond *) cond;
int have_waiters;
// Avoid race conditions
EnterCriticalSection( &cv->waiters_count_lock );
have_waiters = cv->waiters_count > 0;
LeaveCriticalSection( &cv->waiters_count_lock );
if( have_waiters )
{
SetEvent( cv->events[ _GLFW_COND_SIGNAL ] );
}
}
//========================================================================
// Broadcast a condition to all waiting threads
//========================================================================
void _glfwPlatformBroadcastCond( GLFWcond cond )
{
_GLFWcond *cv = (_GLFWcond *) cond;
int have_waiters;
// Avoid race conditions
EnterCriticalSection( &cv->waiters_count_lock );
have_waiters = cv->waiters_count > 0;
LeaveCriticalSection( &cv->waiters_count_lock );
if( have_waiters )
{
SetEvent( cv->events[ _GLFW_COND_BROADCAST ] );
}
}
//========================================================================
// Return the number of processors in the system.
//========================================================================
int _glfwPlatformGetNumberOfProcessors( void )
{
SYSTEM_INFO si;
// Get hardware system information
GetSystemInfo( &si );
return (int) si.dwNumberOfProcessors;
}

146
ogl_editor/src/External/glfw/lib/win32/win32_time.c vendored Normal file
View File

@ -0,0 +1,146 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Initialise timer
//========================================================================
void _glfwInitTimer( void )
{
__int64 freq;
// Check if we have a performance counter
if( QueryPerformanceFrequency( (LARGE_INTEGER *)&freq ) )
{
// Performance counter is available => use it!
_glfwLibrary.Timer.HasPerformanceCounter = GL_TRUE;
// Counter resolution is 1 / counter frequency
_glfwLibrary.Timer.Resolution = 1.0 / (double)freq;
// Set start time for timer
QueryPerformanceCounter( (LARGE_INTEGER *)&_glfwLibrary.Timer.t0_64 );
}
else
{
// No performace counter available => use the tick counter
_glfwLibrary.Timer.HasPerformanceCounter = GL_FALSE;
// Counter resolution is 1 ms
_glfwLibrary.Timer.Resolution = 0.001;
// Set start time for timer
_glfwLibrary.Timer.t0_32 = _glfw_timeGetTime();
}
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Return timer value in seconds
//========================================================================
double _glfwPlatformGetTime( void )
{
double t;
__int64 t_64;
if( _glfwLibrary.Timer.HasPerformanceCounter )
{
QueryPerformanceCounter( (LARGE_INTEGER *)&t_64 );
t = (double)(t_64 - _glfwLibrary.Timer.t0_64);
}
else
{
t = (double)(_glfw_timeGetTime() - _glfwLibrary.Timer.t0_32);
}
// Calculate the current time in seconds
return t * _glfwLibrary.Timer.Resolution;
}
//========================================================================
// Set timer value in seconds
//========================================================================
void _glfwPlatformSetTime( double t )
{
__int64 t_64;
if( _glfwLibrary.Timer.HasPerformanceCounter )
{
QueryPerformanceCounter( (LARGE_INTEGER *)&t_64 );
_glfwLibrary.Timer.t0_64 = t_64 - (__int64)(t/_glfwLibrary.Timer.Resolution);
}
else
{
_glfwLibrary.Timer.t0_32 = _glfw_timeGetTime() - (int)(t*1000.0);
}
}
//========================================================================
// Put a thread to sleep for a specified amount of time
//========================================================================
void _glfwPlatformSleep( double time )
{
DWORD t;
if( time == 0.0 )
{
t = 0;
}
else if( time < 0.001 )
{
t = 1;
}
else if( time > 2147483647.0 )
{
t = 2147483647;
}
else
{
t = (DWORD)(time*1000.0 + 0.5);
}
Sleep( t );
}

1886
ogl_editor/src/External/glfw/lib/win32/win32_window.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1005
ogl_editor/src/External/glfw/lib/window.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

259
ogl_editor/src/External/glfw/lib/x11/Makefile.x11.in vendored Normal file
View File

@ -0,0 +1,259 @@
##########################################################################
# Installation prefix (default to /usr/local)
##########################################################################
PREFIX ?= /usr/local
##########################################################################
# Default: Build GLFW static library
##########################################################################
all: libglfw.a libglfw.so
##########################################################################
# Library builder settings
##########################################################################
AR = ar
LD = ld
SED = sed
INSTALL = install
ARFLAGS = -rcs
HEADERS = ../../include/GL/glfw.h ../internal.h platform.h
##########################################################################
# Install GLFW static library
##########################################################################
install: libglfw.a libglfw.pc
$(INSTALL) -d $(PREFIX)/lib
$(INSTALL) -c -m 644 libglfw.a $(PREFIX)/lib/libglfw.a
$(INSTALL) -d $(PREFIX)/include/GL
$(INSTALL) -c -m 644 ../../include/GL/glfw.h $(PREFIX)/include/GL/glfw.h
$(INSTALL) -d $(PREFIX)/lib/pkgconfig
$(INSTALL) -c -m 644 libglfw.pc $(PREFIX)/lib/pkgconfig/libglfw.pc
##########################################################################
# Install GLFW static and shared libraries
##########################################################################
dist-install: libglfw.so install
$(INSTALL) -c -m 644 libglfw.so $(PREFIX)/lib/libglfw.so
##########################################################################
# Object files which are part of the GLFW library
##########################################################################
STATIC_OBJS = \
enable.o \
fullscreen.o \
glext.o \
image.o \
init.o \
input.o \
joystick.o \
stream.o \
tga.o \
thread.o \
time.o \
window.o \
x11_enable.o \
x11_fullscreen.o \
x11_glext.o \
x11_init.o \
x11_joystick.o \
x11_keysym2unicode.o \
x11_thread.o \
x11_time.o \
x11_window.o
##########################################################################
# Object files which are part of the GLFW library
##########################################################################
SHARED_OBJS = \
so_enable.o \
so_fullscreen.o \
so_glext.o \
so_image.o \
so_init.o \
so_input.o \
so_joystick.o \
so_stream.o \
so_tga.o \
so_thread.o \
so_time.o \
so_window.o \
so_x11_enable.o \
so_x11_fullscreen.o \
so_x11_glext.o \
so_x11_init.o \
so_x11_joystick.o \
so_x11_keysym2unicode.o \
so_x11_thread.o \
so_x11_time.o \
so_x11_window.o
##########################################################################
# Rule for building libglfw.pc
##########################################################################
libglfw.pc: libglfw.pc.in
$(SED) -e 's,\@PREFIX\@,$(PREFIX),' libglfw.pc.in > libglfw.pc
##########################################################################
# Rule for building static library
##########################################################################
libglfw.a: $(STATIC_OBJS)
$(AR) $(ARFLAGS) $@ $(STATIC_OBJS)
##########################################################################
# Rule for building shared library
##########################################################################
libglfw.so: $(SHARED_OBJS)
$(CC) $(SOFLAGS) -o $@ $(SHARED_OBJS) $(LFLAGS) $(LIBS)
##########################################################################
# Rules for building static library object files
##########################################################################
enable.o: ../enable.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../enable.c
fullscreen.o: ../fullscreen.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../fullscreen.c
glext.o: ../glext.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../glext.c
image.o: ../image.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../image.c
init.o: ../init.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../init.c
input.o: ../input.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../input.c
joystick.o: ../joystick.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../joystick.c
stream.o: ../stream.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../stream.c
tga.o: ../tga.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../tga.c
thread.o: ../thread.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../thread.c
time.o: ../time.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../time.c
window.o: ../window.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ ../window.c
x11_enable.o: x11_enable.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_enable.c
x11_fullscreen.o: x11_fullscreen.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_fullscreen.c
x11_glext.o: x11_glext.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_glext.c
x11_init.o: x11_init.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_init.c
x11_joystick.o: x11_joystick.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_joystick.c
x11_thread.o: x11_thread.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_thread.c
x11_time.o: x11_time.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_time.c
x11_window.o: x11_window.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_window.c
x11_keysym2unicode.o: x11_keysym2unicode.c $(HEADERS)
$(CC) $(CFLAGS) -o $@ x11_keysym2unicode.c
##########################################################################
# Rules for building shared library object files
##########################################################################
so_enable.o: ../enable.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../enable.c
so_fullscreen.o: ../fullscreen.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../fullscreen.c
so_glext.o: ../glext.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../glext.c
so_image.o: ../image.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../image.c
so_init.o: ../init.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../init.c
so_input.o: ../input.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../input.c
so_joystick.o: ../joystick.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../joystick.c
so_stream.o: ../stream.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../stream.c
so_tga.o: ../tga.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../tga.c
so_thread.o: ../thread.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../thread.c
so_time.o: ../time.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../time.c
so_window.o: ../window.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ ../window.c
so_x11_enable.o: x11_enable.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_enable.c
so_x11_fullscreen.o: x11_fullscreen.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_fullscreen.c
so_x11_glext.o: x11_glext.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_glext.c
so_x11_init.o: x11_init.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_init.c
so_x11_joystick.o: x11_joystick.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_joystick.c
so_x11_thread.o: x11_thread.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_thread.c
so_x11_time.o: x11_time.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_time.c
so_x11_window.o: x11_window.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_window.c
so_x11_keysym2unicode.o: x11_keysym2unicode.c $(HEADERS)
$(CC) -fPIC $(CFLAGS) -o $@ x11_keysym2unicode.c
##########################################################################
# Clean
##########################################################################
clean:
rm -f $(STATIC_OBJS) $(SHARED_OBJS) libglfw.a libglfw.so libglfw.pc

526
ogl_editor/src/External/glfw/lib/x11/platform.h vendored Normal file
View File

@ -0,0 +1,526 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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 _platform_h_
#define _platform_h_
// This is the X11 version of GLFW
#define _GLFW_X11
// Include files
#include <sys/time.h>
#include <unistd.h>
#include <stdint.h>
#include <signal.h>
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <GL/glx.h>
#include "../../include/GL/glfw.h"
// Do we have pthread support?
#ifdef _GLFW_HAS_PTHREAD
#include <pthread.h>
#include <sched.h>
#endif
// We need declarations for GLX version 1.3 or above even if the server doesn't
// support version 1.3
#ifndef GLX_VERSION_1_3
#error "GLX header version 1.3 or above is required"
#endif
#if defined( _GLFW_HAS_XF86VIDMODE ) && defined( _GLFW_HAS_XRANDR )
#error "Xf86VidMode and RandR extensions cannot both be enabled"
#endif
// With XFree86, we can use the XF86VidMode extension
#if defined( _GLFW_HAS_XF86VIDMODE )
#include <X11/extensions/xf86vmode.h>
#endif
#if defined( _GLFW_HAS_XRANDR )
#include <X11/extensions/Xrandr.h>
#endif
// Do we have support for dlopen/dlsym?
#if defined( _GLFW_HAS_DLOPEN )
#include <dlfcn.h>
#endif
// We support two different ways for getting the number of processors in
// the system: sysconf (POSIX) and sysctl (BSD?)
#if defined( _GLFW_HAS_SYSCONF )
// Use a single constant for querying number of online processors using
// the sysconf function (e.g. SGI defines _SC_NPROC_ONLN instead of
// _SC_NPROCESSORS_ONLN)
#ifndef _SC_NPROCESSORS_ONLN
#ifdef _SC_NPROC_ONLN
#define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN
#else
#error POSIX constant _SC_NPROCESSORS_ONLN not defined!
#endif
#endif
// Macro for querying the number of processors
#define _glfw_numprocessors(n) n=(int)sysconf(_SC_NPROCESSORS_ONLN)
#elif defined( _GLFW_HAS_SYSCTL )
#include <sys/types.h>
#include <sys/sysctl.h>
// Macro for querying the number of processors
#define _glfw_numprocessors(n) { \
int mib[2], ncpu; \
size_t len = 1; \
mib[0] = CTL_HW; \
mib[1] = HW_NCPU; \
n = 1; \
if( sysctl( mib, 2, &ncpu, &len, NULL, 0 ) != -1 ) \
{ \
if( len > 0 ) \
{ \
n = ncpu; \
} \
} \
}
#else
// If neither sysconf nor sysctl is supported, assume single processor
// system
#define _glfw_numprocessors(n) n=1
#endif
// Pointer length integer
// One day, this will most likely move into glfw.h
typedef intptr_t GLFWintptr;
#ifndef GLX_EXT_swap_control
typedef void (*PFNGLXSWAPINTERVALEXT)(Display*,GLXDrawable,int);
#endif /*GLX_MESA_swap_control*/
#ifndef GLX_MESA_swap_control
typedef int (*PFNGLXSWAPINTERVALMESA)(int);
#endif /*GLX_MESA_swap_control*/
#ifndef GLX_SGI_swap_control
// Function signature for GLX_SGI_swap_control
typedef int ( * PFNGLXSWAPINTERVALSGIPROC) (int interval);
#endif /*GLX_SGI_swap_control*/
#ifndef GLX_SGIX_fbconfig
/* Type definitions for GLX_SGIX_fbconfig */
typedef XID GLXFBConfigIDSGIX;
typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
/* Function signatures for GLX_SGIX_fbconfig */
typedef int ( * PFNGLXGETFBCONFIGATTRIBSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
typedef GLXFBConfigSGIX * ( * PFNGLXCHOOSEFBCONFIGSGIXPROC) (Display *dpy, int screen, int *attrib_list, int *nelements);
typedef GLXContext ( * PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
typedef XVisualInfo * ( * PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config);
/* Tokens for GLX_SGIX_fbconfig */
#define GLX_WINDOW_BIT_SGIX 0x00000001
#define GLX_PIXMAP_BIT_SGIX 0x00000002
#define GLX_RGBA_BIT_SGIX 0x00000001
#define GLX_COLOR_INDEX_BIT_SGIX 0x00000002
#define GLX_DRAWABLE_TYPE_SGIX 0x8010
#define GLX_RENDER_TYPE_SGIX 0x8011
#define GLX_X_RENDERABLE_SGIX 0x8012
#define GLX_FBCONFIG_ID_SGIX 0x8013
#define GLX_RGBA_TYPE_SGIX 0x8014
#define GLX_COLOR_INDEX_TYPE_SGIX 0x8015
#define GLX_SCREEN_EXT 0x800C
#endif /*GLX_SGIX_fbconfig*/
#ifndef GLX_ARB_create_context
/* Tokens for glXCreateContextAttribsARB attributes */
#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
#define GLX_CONTEXT_FLAGS_ARB 0x2094
/* Bits for WGL_CONTEXT_FLAGS_ARB */
#define GLX_CONTEXT_DEBUG_BIT_ARB 0x0001
#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
/* Prototype for glXCreateContextAttribs */
typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)( Display *display, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
#endif /*GLX_ARB_create_context*/
#ifndef GLX_ARB_create_context_profile
/* Tokens for glXCreateContextAttribsARB attributes */
#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
/* BIts for GLX_CONTEXT_PROFILE_MASK_ARB */
#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
#endif /*GLX_ARB_create_context_profile*/
#ifndef GL_VERSION_3_0
typedef const GLubyte * (APIENTRY *PFNGLGETSTRINGIPROC) (GLenum, GLuint);
#endif /*GL_VERSION_3_0*/
//========================================================================
// Global variables (GLFW internals)
//========================================================================
//------------------------------------------------------------------------
// Window structure
//------------------------------------------------------------------------
typedef struct _GLFWwin_struct _GLFWwin;
struct _GLFWwin_struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// User callback functions
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWmousewheelfun mouseWheelCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
// User selected window settings
int fullscreen; // Fullscreen flag
int mouseLock; // Mouse-lock flag
int autoPollEvents; // Auto polling flag
int sysKeysDisabled; // System keys disabled flag
int windowNoResize; // Resize- and maximize gadgets disabled flag
int refreshRate; // Vertical monitor refresh rate
// Window status & parameters
int opened; // Flag telling if window is opened or not
int active; // Application active flag
int iconified; // Window iconified flag
int width, height; // Window width and heigth
int accelerated; // GL_TRUE if window is HW accelerated
// Framebuffer attributes
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;
// OpenGL extensions and context attributes
int has_GL_SGIS_generate_mipmap;
int has_GL_ARB_texture_non_power_of_two;
int glMajor, glMinor, glRevision;
int glForward, glDebug, glProfile;
PFNGLGETSTRINGIPROC GetStringi;
// ========= PLATFORM SPECIFIC PART ======================================
// Platform specific window resources
Colormap colormap; // Window colormap
Window window; // Window
Window root; // Root window for screen
int screen; // Screen ID
XVisualInfo *visual; // Visual for selected GLXFBConfig
GLXFBConfigID fbconfigID; // ID of selected GLXFBConfig
GLXContext context; // OpenGL rendering context
Atom wmDeleteWindow; // WM_DELETE_WINDOW atom
Atom wmPing; // _NET_WM_PING atom
Atom wmState; // _NET_WM_STATE atom
Atom wmStateFullscreen; // _NET_WM_STATE_FULLSCREEN atom
Atom wmActiveWindow; // _NET_ACTIVE_WINDOW atom
Cursor cursor; // Invisible cursor for hidden cursor
// GLX extensions
PFNGLXSWAPINTERVALEXTPROC SwapIntervalEXT;
PFNGLXSWAPINTERVALMESAPROC SwapIntervalMESA;
PFNGLXSWAPINTERVALSGIPROC SwapIntervalSGI;
PFNGLXGETFBCONFIGATTRIBSGIXPROC GetFBConfigAttribSGIX;
PFNGLXCHOOSEFBCONFIGSGIXPROC ChooseFBConfigSGIX;
PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;
PFNGLXGETVISUALFROMFBCONFIGSGIXPROC GetVisualFromFBConfigSGIX;
PFNGLXCREATECONTEXTATTRIBSARBPROC CreateContextAttribsARB;
GLboolean has_GLX_SGIX_fbconfig;
GLboolean has_GLX_EXT_swap_control;
GLboolean has_GLX_MESA_swap_control;
GLboolean has_GLX_SGI_swap_control;
GLboolean has_GLX_ARB_multisample;
GLboolean has_GLX_ARB_create_context;
GLboolean has_GLX_ARB_create_context_profile;
// Various platform specific internal variables
GLboolean hasEWMH; // True if window manager supports EWMH
GLboolean overrideRedirect; // True if window is OverrideRedirect
GLboolean keyboardGrabbed; // True if keyboard is currently grabbed
GLboolean pointerGrabbed; // True if pointer is currently grabbed
GLboolean pointerHidden; // True if pointer is currently hidden
// Screensaver data
struct {
int changed;
int timeout;
int interval;
int blanking;
int exposure;
} Saver;
// Fullscreen data
struct {
int modeChanged;
#if defined( _GLFW_HAS_XF86VIDMODE )
XF86VidModeModeInfo oldMode;
#endif
#if defined( _GLFW_HAS_XRANDR )
SizeID oldSizeID;
int oldWidth;
int oldHeight;
Rotation oldRotation;
#endif
} FS;
};
GLFWGLOBAL _GLFWwin _glfwWin;
//------------------------------------------------------------------------
// User input status (most of this should go in _GLFWwin)
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Mouse status
int MousePosX, MousePosY;
int WheelPos;
char MouseButton[ GLFW_MOUSE_BUTTON_LAST+1 ];
// Keyboard status
char Key[ GLFW_KEY_LAST+1 ];
int LastChar;
// User selected settings
int StickyKeys;
int StickyMouseButtons;
int KeyRepeat;
// ========= PLATFORM SPECIFIC PART ======================================
// Platform specific internal variables
int MouseMoved, CursorPosX, CursorPosY;
} _glfwInput;
//------------------------------------------------------------------------
// Library global data
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Window opening hints
_GLFWhints hints;
// Initial desktop mode
GLFWvidmode desktopMode;
// ========= PLATFORM SPECIFIC PART ======================================
Display *display;
// Server-side GLX version
int glxMajor, glxMinor;
struct {
int available;
int eventBase;
int errorBase;
} XF86VidMode;
struct {
int available;
int eventBase;
int errorBase;
} XRandR;
// Timer data
struct {
GLboolean monotonic;
double resolution;
long long base;
} Timer;
#if defined(_GLFW_HAS_DLOPEN)
struct {
void *libGL; // dlopen handle for libGL.so
} Libs;
#endif
} _glfwLibrary;
//------------------------------------------------------------------------
// Thread record (one for each thread)
//------------------------------------------------------------------------
typedef struct _GLFWthread_struct _GLFWthread;
struct _GLFWthread_struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Pointer to previous and next threads in linked list
_GLFWthread *Previous, *Next;
// GLFW user side thread information
GLFWthread ID;
GLFWthreadfun Function;
// ========= PLATFORM SPECIFIC PART ======================================
// System side thread information
#ifdef _GLFW_HAS_PTHREAD
pthread_t PosixID;
#endif
};
//------------------------------------------------------------------------
// General thread information
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Next thread ID to use (increments for every created thread)
GLFWthread NextID;
// First thread in linked list (always the main thread)
_GLFWthread First;
// ========= PLATFORM SPECIFIC PART ======================================
// Critical section lock
#ifdef _GLFW_HAS_PTHREAD
pthread_mutex_t CriticalSection;
#endif
} _glfwThrd;
//------------------------------------------------------------------------
// Joystick information & state
//------------------------------------------------------------------------
GLFWGLOBAL struct {
int Present;
int fd;
int NumAxes;
int NumButtons;
float *Axis;
unsigned char *Button;
} _glfwJoy[ GLFW_JOYSTICK_LAST + 1 ];
//========================================================================
// Macros for encapsulating critical code sections (i.e. making parts
// of GLFW thread safe)
//========================================================================
// Thread list management
#ifdef _GLFW_HAS_PTHREAD
#define ENTER_THREAD_CRITICAL_SECTION \
pthread_mutex_lock( &_glfwThrd.CriticalSection );
#define LEAVE_THREAD_CRITICAL_SECTION \
pthread_mutex_unlock( &_glfwThrd.CriticalSection );
#else
#define ENTER_THREAD_CRITICAL_SECTION
#define LEAVE_THREAD_CRITICAL_SECTION
#endif
//========================================================================
// Prototypes for platform specific internal functions
//========================================================================
// Time
void _glfwInitTimer( void );
// Fullscreen support
int _glfwGetClosestVideoMode( int screen, int *width, int *height, int *rate );
void _glfwSetVideoModeMODE( int screen, int mode, int rate );
void _glfwSetVideoMode( int screen, int *width, int *height, int *rate );
void _glfwRestoreVideoMode( void );
// Joystick input
void _glfwInitJoysticks( void );
void _glfwTerminateJoysticks( void );
// Unicode support
long _glfwKeySym2Unicode( KeySym keysym );
#endif // _platform_h_

64
ogl_editor/src/External/glfw/lib/x11/x11_enable.c vendored Normal file
View File

@ -0,0 +1,64 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11 (Unix)
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Enable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys( void )
{
if( _glfwWin.keyboardGrabbed )
{
XUngrabKeyboard( _glfwLibrary.display, CurrentTime );
_glfwWin.keyboardGrabbed = GL_FALSE;
}
}
//========================================================================
// Disable system keys
//========================================================================
void _glfwPlatformDisableSystemKeys( void )
{
if( XGrabKeyboard( _glfwLibrary.display, _glfwWin.window, True,
GrabModeAsync, GrabModeAsync, CurrentTime ) ==
GrabSuccess )
{
_glfwWin.keyboardGrabbed = GL_TRUE;
}
}

567
ogl_editor/src/External/glfw/lib/x11/x11_fullscreen.c vendored Normal file
View File

@ -0,0 +1,567 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
#include <limits.h>
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Convert BPP to RGB bits (based on "best guess")
//========================================================================
static void BPP2RGB( int bpp, int *r, int *g, int *b )
{
int delta;
// Special case: BPP = 32 (I don't think this is necessary for X11??)
if( bpp == 32 )
bpp = 24;
// Convert "bits per pixel" to red, green & blue sizes
*r = *g = *b = bpp / 3;
delta = bpp - (*r * 3);
if( delta >= 1 )
{
*g = *g + 1;
}
if( delta == 2 )
{
*r = *r + 1;
}
}
//========================================================================
// Finds the video mode closest in size to the specified desired size
//========================================================================
int _glfwGetClosestVideoMode( int screen, int *width, int *height, int *rate )
{
#if defined( _GLFW_HAS_XRANDR )
int i, match, bestmatch;
int sizecount, bestsize;
int ratecount, bestrate;
short *ratelist;
XRRScreenConfiguration *sc;
XRRScreenSize *sizelist;
if( _glfwLibrary.XRandR.available )
{
sc = XRRGetScreenInfo( _glfwLibrary.display,
RootWindow( _glfwLibrary.display, screen ) );
sizelist = XRRConfigSizes( sc, &sizecount );
// Find the best matching mode
bestsize = -1;
bestmatch = INT_MAX;
for( i = 0; i < sizecount; i++ )
{
match = (*width - sizelist[i].width) *
(*width - sizelist[i].width) +
(*height - sizelist[i].height) *
(*height - sizelist[i].height);
if( match < bestmatch )
{
bestmatch = match;
bestsize = i;
}
}
if( bestsize != -1 )
{
// Report width & height of best matching mode
*width = sizelist[bestsize].width;
*height = sizelist[bestsize].height;
if( *rate > 0 )
{
ratelist = XRRConfigRates( sc, bestsize, &ratecount );
bestrate = -1;
bestmatch = INT_MAX;
for( i = 0; i < ratecount; i++ )
{
match = abs( ratelist[i] - *rate );
if( match < bestmatch )
{
bestmatch = match;
bestrate = ratelist[i];
}
}
if( bestrate != -1 )
{
*rate = bestrate;
}
}
}
// Free modelist
XRRFreeScreenConfigInfo( sc );
if( bestsize != -1 )
{
return bestsize;
}
}
#elif defined( _GLFW_HAS_XF86VIDMODE )
XF86VidModeModeInfo **modelist;
int modecount, i, bestmode, bestmatch, match;
// Use the XF86VidMode extension to control video resolution
if( _glfwLibrary.XF86VidMode.available )
{
// Get a list of all available display modes
XF86VidModeGetAllModeLines( _glfwLibrary.display, screen,
&modecount, &modelist );
// Find the best matching mode
bestmode = -1;
bestmatch = INT_MAX;
for( i = 0; i < modecount; i++ )
{
match = (*width - modelist[i]->hdisplay) *
(*width - modelist[i]->hdisplay) +
(*height - modelist[i]->vdisplay) *
(*height - modelist[i]->vdisplay);
if( match < bestmatch )
{
bestmatch = match;
bestmode = i;
}
}
if( bestmode != -1 )
{
// Report width & height of best matching mode
*width = modelist[ bestmode ]->hdisplay;
*height = modelist[ bestmode ]->vdisplay;
}
// Free modelist
XFree( modelist );
if( bestmode != -1 )
{
return bestmode;
}
}
#endif
// Default: Simply use the screen resolution
*width = DisplayWidth( _glfwLibrary.display, screen );
*height = DisplayHeight( _glfwLibrary.display, screen );
return 0;
}
//========================================================================
// Change the current video mode
//========================================================================
void _glfwSetVideoModeMODE( int screen, int mode, int rate )
{
#if defined( _GLFW_HAS_XRANDR )
XRRScreenConfiguration *sc;
Window root;
if( _glfwLibrary.XRandR.available )
{
root = RootWindow( _glfwLibrary.display, screen );
sc = XRRGetScreenInfo( _glfwLibrary.display, root );
// Remember old size and flag that we have changed the mode
if( !_glfwWin.FS.modeChanged )
{
_glfwWin.FS.oldSizeID = XRRConfigCurrentConfiguration( sc, &_glfwWin.FS.oldRotation );
_glfwWin.FS.oldWidth = DisplayWidth( _glfwLibrary.display, screen );
_glfwWin.FS.oldHeight = DisplayHeight( _glfwLibrary.display, screen );
_glfwWin.FS.modeChanged = GL_TRUE;
}
if( rate > 0 )
{
// Set desired configuration
XRRSetScreenConfigAndRate( _glfwLibrary.display,
sc,
root,
mode,
RR_Rotate_0,
(short) rate,
CurrentTime );
}
else
{
// Set desired configuration
XRRSetScreenConfig( _glfwLibrary.display,
sc,
root,
mode,
RR_Rotate_0,
CurrentTime );
}
XRRFreeScreenConfigInfo( sc );
}
#elif defined( _GLFW_HAS_XF86VIDMODE )
XF86VidModeModeInfo **modelist;
int modecount;
// Use the XF86VidMode extension to control video resolution
if( _glfwLibrary.XF86VidMode.available )
{
// Get a list of all available display modes
XF86VidModeGetAllModeLines( _glfwLibrary.display, screen,
&modecount, &modelist );
// Unlock mode switch if necessary
if( _glfwWin.FS.modeChanged )
{
XF86VidModeLockModeSwitch( _glfwLibrary.display, screen, 0 );
}
// Change the video mode to the desired mode
XF86VidModeSwitchToMode( _glfwLibrary.display, screen,
modelist[ mode ] );
// Set viewport to upper left corner (where our window will be)
XF86VidModeSetViewPort( _glfwLibrary.display, screen, 0, 0 );
// Lock mode switch
XF86VidModeLockModeSwitch( _glfwLibrary.display, screen, 1 );
// Remember old mode and flag that we have changed the mode
if( !_glfwWin.FS.modeChanged )
{
_glfwWin.FS.oldMode = *modelist[ 0 ];
_glfwWin.FS.modeChanged = GL_TRUE;
}
// Free mode list
XFree( modelist );
}
#endif
}
//========================================================================
// Change the current video mode
//========================================================================
void _glfwSetVideoMode( int screen, int *width, int *height, int *rate )
{
int bestmode;
// Find a best match mode
bestmode = _glfwGetClosestVideoMode( screen, width, height, rate );
// Change mode
_glfwSetVideoModeMODE( screen, bestmode, *rate );
}
//========================================================================
// Restore the previously saved (original) video mode
//========================================================================
void _glfwRestoreVideoMode( void )
{
if( _glfwWin.FS.modeChanged )
{
#if defined( _GLFW_HAS_XRANDR )
if( _glfwLibrary.XRandR.available )
{
XRRScreenConfiguration *sc;
sc = XRRGetScreenInfo( _glfwLibrary.display, _glfwWin.root );
XRRSetScreenConfig( _glfwLibrary.display,
sc,
_glfwWin.root,
_glfwWin.FS.oldSizeID,
_glfwWin.FS.oldRotation,
CurrentTime );
XRRFreeScreenConfigInfo( sc );
}
#elif defined( _GLFW_HAS_XF86VIDMODE )
if( _glfwLibrary.XF86VidMode.available )
{
// Unlock mode switch
XF86VidModeLockModeSwitch( _glfwLibrary.display, _glfwWin.screen, 0 );
// Change the video mode back to the old mode
XF86VidModeSwitchToMode( _glfwLibrary.display,
_glfwWin.screen,
&_glfwWin.FS.oldMode );
}
#endif
_glfwWin.FS.modeChanged = GL_FALSE;
}
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
struct _glfwResolution
{
int width;
int height;
};
//========================================================================
// List available video modes
//========================================================================
int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )
{
int count, k, l, r, g, b, rgba, gl;
int depth, screen;
Display *dpy;
XVisualInfo *vislist, dummy;
int viscount, rgbcount, rescount;
int *rgbarray;
struct _glfwResolution *resarray;
// Get display and screen
dpy = _glfwLibrary.display;
screen = DefaultScreen( dpy );
// Get list of visuals
vislist = XGetVisualInfo( dpy, 0, &dummy, &viscount );
if( vislist == NULL )
{
return 0;
}
rgbarray = (int*) malloc( sizeof(int) * viscount );
rgbcount = 0;
// Build RGB array
for( k = 0; k < viscount; k++ )
{
// Does the visual support OpenGL & true color?
glXGetConfig( dpy, &vislist[k], GLX_USE_GL, &gl );
glXGetConfig( dpy, &vislist[k], GLX_RGBA, &rgba );
if( gl && rgba )
{
// Get color depth for this visual
depth = vislist[k].depth;
// Convert to RGB
BPP2RGB( depth, &r, &g, &b );
depth = (r<<16) | (g<<8) | b;
// Is this mode unique?
for( l = 0; l < rgbcount; l++ )
{
if( depth == rgbarray[ l ] )
{
break;
}
}
if( l >= rgbcount )
{
rgbarray[ rgbcount ] = depth;
rgbcount++;
}
}
}
rescount = 0;
resarray = NULL;
// Build resolution array
#if defined( _GLFW_HAS_XRANDR )
if( _glfwLibrary.XRandR.available )
{
XRRScreenConfiguration *sc;
XRRScreenSize *sizelist;
int sizecount;
sc = XRRGetScreenInfo( dpy, RootWindow( dpy, screen ) );
sizelist = XRRConfigSizes( sc, &sizecount );
resarray = (struct _glfwResolution*) malloc( sizeof(struct _glfwResolution) * sizecount );
for( k = 0; k < sizecount; k++ )
{
resarray[ rescount ].width = sizelist[ k ].width;
resarray[ rescount ].height = sizelist[ k ].height;
rescount++;
}
XRRFreeScreenConfigInfo( sc );
}
#elif defined( _GLFW_HAS_XF86VIDMODE )
if( _glfwLibrary.XF86VidMode.available )
{
XF86VidModeModeInfo **modelist;
int modecount, width, height;
XF86VidModeGetAllModeLines( dpy, screen, &modecount, &modelist );
resarray = (struct _glfwResolution*) malloc( sizeof(struct _glfwResolution) * modecount );
for( k = 0; k < modecount; k++ )
{
width = modelist[ k ]->hdisplay;
height = modelist[ k ]->vdisplay;
// Is this mode unique?
for( l = 0; l < rescount; l++ )
{
if( width == resarray[ l ].width && height == resarray[ l ].height )
{
break;
}
}
if( l >= rescount )
{
resarray[ rescount ].width = width;
resarray[ rescount ].height = height;
rescount++;
}
}
XFree( modelist );
}
#endif
if( !resarray )
{
rescount = 1;
resarray = (struct _glfwResolution*) malloc( sizeof(struct _glfwResolution) * rescount );
resarray[ 0 ].width = DisplayWidth( dpy, screen );
resarray[ 0 ].height = DisplayHeight( dpy, screen );
}
// Build permutations of colors and resolutions
count = 0;
for( k = 0; k < rgbcount && count < maxcount; k++ )
{
for( l = 0; l < rescount && count < maxcount; l++ )
{
list[count].Width = resarray[ l ].width;
list[count].Height = resarray[ l ].height;
list[count].RedBits = (rgbarray[ k ] >> 16) & 255;
list[count].GreenBits = (rgbarray[ k ] >> 8) & 255;
list[count].BlueBits = rgbarray[ k ] & 255;
count++;
}
}
// Free visuals list
XFree( vislist );
free( resarray );
free( rgbarray );
return count;
}
//========================================================================
// Get the desktop video mode
//========================================================================
void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )
{
Display *dpy;
int bpp, screen;
// Get display and screen
dpy = _glfwLibrary.display;
screen = DefaultScreen( dpy );
// Get display depth
bpp = DefaultDepth( dpy, screen );
// Convert BPP to RGB bits
BPP2RGB( bpp, &mode->RedBits, &mode->GreenBits, &mode->BlueBits );
#if defined( _GLFW_HAS_XRANDR )
if( _glfwLibrary.XRandR.available )
{
if( _glfwWin.FS.modeChanged )
{
mode->Width = _glfwWin.FS.oldWidth;
mode->Height = _glfwWin.FS.oldHeight;
return;
}
}
#elif defined( _GLFW_HAS_XF86VIDMODE )
if( _glfwLibrary.XF86VidMode.available )
{
XF86VidModeModeInfo **modelist;
int modecount;
if( _glfwWin.FS.modeChanged )
{
// The old (desktop) mode is stored in _glfwWin.FS.oldMode
mode->Width = _glfwWin.FS.oldMode.hdisplay;
mode->Height = _glfwWin.FS.oldMode.vdisplay;
}
else
{
// Use the XF86VidMode extension to get list of video modes
XF86VidModeGetAllModeLines( dpy, screen, &modecount,
&modelist );
// The first mode in the list is the current (desktio) mode
mode->Width = modelist[ 0 ]->hdisplay;
mode->Height = modelist[ 0 ]->vdisplay;
// Free list
XFree( modelist );
}
return;
}
#endif
// Get current display width and height
mode->Width = DisplayWidth( dpy, screen );
mode->Height = DisplayHeight( dpy, screen );
}

89
ogl_editor/src/External/glfw/lib/x11/x11_glext.c vendored Normal file
View File

@ -0,0 +1,89 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
void (*glXGetProcAddress(const GLubyte *procName))();
void (*glXGetProcAddressARB(const GLubyte *procName))();
void (*glXGetProcAddressEXT(const GLubyte *procName))();
// We support four different ways for getting addresses for GL/GLX
// extension functions: glXGetProcAddress, glXGetProcAddressARB,
// glXGetProcAddressEXT, and dlsym
#if defined( _GLFW_HAS_GLXGETPROCADDRESSARB )
#define _glfw_glXGetProcAddress(x) glXGetProcAddressARB(x)
#elif defined( _GLFW_HAS_GLXGETPROCADDRESS )
#define _glfw_glXGetProcAddress(x) glXGetProcAddress(x)
#elif defined( _GLFW_HAS_GLXGETPROCADDRESSEXT )
#define _glfw_glXGetProcAddress(x) glXGetProcAddressEXT(x)
#elif defined( _GLFW_HAS_DLOPEN )
#define _glfw_glXGetProcAddress(x) dlsym(_glfwLibrary.Libs.libGL,x)
#else
#define _glfw_glXGetProcAddress(x) NULL
#endif
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Check if an OpenGL extension is available at runtime
//========================================================================
int _glfwPlatformExtensionSupported( const char *extension )
{
const GLubyte *extensions;
// Get list of GLX extensions
extensions = (const GLubyte*) glXQueryExtensionsString( _glfwLibrary.display,
_glfwWin.screen );
if( extensions != NULL )
{
if( _glfwStringInExtensionString( extension, extensions ) )
{
return GL_TRUE;
}
}
return GL_FALSE;
}
//========================================================================
// Get the function pointer to an OpenGL function
//========================================================================
void * _glfwPlatformGetProcAddress( const char *procname )
{
return (void *) _glfw_glXGetProcAddress( (const GLubyte *) procname );
}

288
ogl_editor/src/External/glfw/lib/x11/x11_init.c vendored Normal file
View File

@ -0,0 +1,288 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Initialize GLFW thread package
//========================================================================
static void initThreads( void )
{
// Initialize critical section handle
#ifdef _GLFW_HAS_PTHREAD
(void) pthread_mutex_init( &_glfwThrd.CriticalSection, NULL );
#endif
// The first thread (the main thread) has ID 0
_glfwThrd.NextID = 0;
// Fill out information about the main thread (this thread)
_glfwThrd.First.ID = _glfwThrd.NextID++;
_glfwThrd.First.Function = NULL;
_glfwThrd.First.Previous = NULL;
_glfwThrd.First.Next = NULL;
#ifdef _GLFW_HAS_PTHREAD
_glfwThrd.First.PosixID = pthread_self();
#endif
}
//========================================================================
// Terminate GLFW thread package
//========================================================================
static void terminateThreads( void )
{
#ifdef _GLFW_HAS_PTHREAD
_GLFWthread *t, *t_next;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Kill all threads (NOTE: THE USER SHOULD WAIT FOR ALL THREADS TO
// DIE, _BEFORE_ CALLING glfwTerminate()!!!)
t = _glfwThrd.First.Next;
while( t != NULL )
{
// Get pointer to next thread
t_next = t->Next;
// Simply murder the process, no mercy!
pthread_kill( t->PosixID, SIGKILL );
// Free memory allocated for this thread
free( (void *) t );
// Select next thread in list
t = t_next;
}
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Delete critical section handle
pthread_mutex_destroy( &_glfwThrd.CriticalSection );
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Dynamically load libraries
//========================================================================
static void initLibraries( void )
{
#ifdef _GLFW_DLOPEN_LIBGL
int i;
char *libGL_names[ ] =
{
"libGL.so",
"libGL.so.1",
"/usr/lib/libGL.so",
"/usr/lib/libGL.so.1",
NULL
};
_glfwLibrary.Libs.libGL = NULL;
for( i = 0; !libGL_names[ i ] != NULL; i ++ )
{
_glfwLibrary.Libs.libGL = dlopen( libGL_names[ i ],
RTLD_LAZY | RTLD_GLOBAL );
if( _glfwLibrary.Libs.libGL )
break;
}
#endif
}
//========================================================================
// Terminate GLFW when exiting application
//========================================================================
static void glfw_atexit( void )
{
glfwTerminate();
}
//========================================================================
// Initialize X11 display
//========================================================================
static int initDisplay( void )
{
// Open display
_glfwLibrary.display = XOpenDisplay( 0 );
if( !_glfwLibrary.display )
{
fprintf(stderr, "Failed to open X display\n");
return GL_FALSE;
}
// Check for XF86VidMode extension
#ifdef _GLFW_HAS_XF86VIDMODE
_glfwLibrary.XF86VidMode.available =
XF86VidModeQueryExtension( _glfwLibrary.display,
&_glfwLibrary.XF86VidMode.eventBase,
&_glfwLibrary.XF86VidMode.errorBase);
#else
_glfwLibrary.XF86VidMode.available = 0;
#endif
// Check for XRandR extension
#ifdef _GLFW_HAS_XRANDR
_glfwLibrary.XRandR.available =
XRRQueryExtension( _glfwLibrary.display,
&_glfwLibrary.XRandR.eventBase,
&_glfwLibrary.XRandR.errorBase );
#else
_glfwLibrary.XRandR.available = 0;
#endif
// Fullscreen & screen saver settings
// Check if GLX is supported on this display
if( !glXQueryExtension( _glfwLibrary.display, NULL, NULL ) )
{
fprintf(stderr, "GLX not supported\n");
return GL_FALSE;
}
// Retrieve GLX version
if( !glXQueryVersion( _glfwLibrary.display,
&_glfwLibrary.glxMajor,
&_glfwLibrary.glxMinor ) )
{
fprintf(stderr, "Unable to query GLX version\n");
return GL_FALSE;
}
return GL_TRUE;
}
//========================================================================
// Terminate X11 display
//========================================================================
static void terminateDisplay( void )
{
// Open display
if( _glfwLibrary.display )
{
XCloseDisplay( _glfwLibrary.display );
_glfwLibrary.display = NULL;
}
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Initialize various GLFW state
//========================================================================
int _glfwPlatformInit( void )
{
// Initialize display
if( !initDisplay() )
{
return GL_FALSE;
}
// Initialize thread package
initThreads();
// Try to load libGL.so if necessary
initLibraries();
_glfwPlatformGetDesktopMode( &_glfwLibrary.desktopMode );
// Install atexit() routine
atexit( glfw_atexit );
// Initialize joysticks
_glfwInitJoysticks();
// Start the timer
_glfwInitTimer();
return GL_TRUE;
}
//========================================================================
// Close window and kill all threads
//========================================================================
int _glfwPlatformTerminate( void )
{
#ifdef _GLFW_HAS_PTHREAD
// Only the main thread is allowed to do this...
if( pthread_self() != _glfwThrd.First.PosixID )
{
return GL_FALSE;
}
#endif // _GLFW_HAS_PTHREAD
// Close OpenGL window
glfwCloseWindow();
// Kill thread package
terminateThreads();
// Terminate display
terminateDisplay();
// Terminate joysticks
_glfwTerminateJoysticks();
// Unload libGL.so if necessary
#ifdef _GLFW_DLOPEN_LIBGL
if( _glfwLibrary.Libs.libGL != NULL )
{
dlclose( _glfwLibrary.Libs.libGL );
_glfwLibrary.Libs.libGL = NULL;
}
#endif
return GL_TRUE;
}

367
ogl_editor/src/External/glfw/lib/x11/x11_joystick.c vendored Normal file
View File

@ -0,0 +1,367 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//========================================================================
// Note: Only Linux joystick input is supported at the moment. Other
// systems will behave as if there are no joysticks connected.
//========================================================================
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
#ifdef _GLFW_USE_LINUX_JOYSTICKS
//------------------------------------------------------------------------
// Here are the Linux joystick driver v1.x interface definitions that we
// use (we do not want to rely on <linux/joystick.h>):
//------------------------------------------------------------------------
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
// Joystick event types
#define JS_EVENT_BUTTON 0x01 /* button pressed/released */
#define JS_EVENT_AXIS 0x02 /* joystick moved */
#define JS_EVENT_INIT 0x80 /* initial state of device */
// Joystick event structure
struct js_event {
unsigned int time; /* (u32) event timestamp in milliseconds */
signed short value; /* (s16) value */
unsigned char type; /* (u8) event type */
unsigned char number; /* (u8) axis/button number */
};
// Joystick IOCTL commands
#define JSIOCGVERSION _IOR('j', 0x01, int) /* get driver version (u32) */
#define JSIOCGAXES _IOR('j', 0x11, char) /* get number of axes (u8) */
#define JSIOCGBUTTONS _IOR('j', 0x12, char) /* get number of buttons (u8) */
#endif // _GLFW_USE_LINUX_JOYSTICKS
//========================================================================
// Initialize joystick interface
//========================================================================
void _glfwInitJoysticks( void )
{
#ifdef _GLFW_USE_LINUX_JOYSTICKS
int k, n, fd, joy_count;
char *joy_base_name, joy_dev_name[ 20 ];
int driver_version = 0x000800;
char ret_data;
#endif // _GLFW_USE_LINUX_JOYSTICKS
int i;
// Start by saying that there are no sticks
for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i )
{
_glfwJoy[ i ].Present = GL_FALSE;
}
#ifdef _GLFW_USE_LINUX_JOYSTICKS
// Try to open joysticks (nonblocking)
joy_count = 0;
for( k = 0; k <= 1 && joy_count <= GLFW_JOYSTICK_LAST; ++ k )
{
// Pick joystick base name
switch( k )
{
case 0:
joy_base_name = "/dev/input/js"; // USB sticks
break;
case 1:
joy_base_name = "/dev/js"; // "Legacy" sticks
break;
default:
continue; // (should never happen)
}
// Try to open a few of these sticks
for( i = 0; i <= 50 && joy_count <= GLFW_JOYSTICK_LAST; ++ i )
{
sprintf( joy_dev_name, "%s%d", joy_base_name, i );
fd = open( joy_dev_name, O_NONBLOCK );
if( fd != -1 )
{
// Remember fd
_glfwJoy[ joy_count ].fd = fd;
// Check that the joystick driver version is 1.0+
ioctl( fd, JSIOCGVERSION, &driver_version );
if( driver_version < 0x010000 )
{
// It's an old 0.x interface (we don't support it)
close( fd );
continue;
}
// Get number of joystick axes
ioctl( fd, JSIOCGAXES, &ret_data );
_glfwJoy[ joy_count ].NumAxes = (int) ret_data;
// Get number of joystick buttons
ioctl( fd, JSIOCGBUTTONS, &ret_data );
_glfwJoy[ joy_count ].NumButtons = (int) ret_data;
// Allocate memory for joystick state
_glfwJoy[ joy_count ].Axis =
(float *) malloc( sizeof(float) *
_glfwJoy[ joy_count ].NumAxes );
if( _glfwJoy[ joy_count ].Axis == NULL )
{
close( fd );
continue;
}
_glfwJoy[ joy_count ].Button =
(unsigned char *) malloc( sizeof(char) *
_glfwJoy[ joy_count ].NumButtons );
if( _glfwJoy[ joy_count ].Button == NULL )
{
free( _glfwJoy[ joy_count ].Axis );
close( fd );
continue;
}
// Clear joystick state
for( n = 0; n < _glfwJoy[ joy_count ].NumAxes; ++ n )
{
_glfwJoy[ joy_count ].Axis[ n ] = 0.0f;
}
for( n = 0; n < _glfwJoy[ joy_count ].NumButtons; ++ n )
{
_glfwJoy[ joy_count ].Button[ n ] = GLFW_RELEASE;
}
// The joystick is supported and connected
_glfwJoy[ joy_count ].Present = GL_TRUE;
joy_count ++;
}
}
}
#endif // _GLFW_USE_LINUX_JOYSTICKS
}
//========================================================================
// Close all opened joystick handles
//========================================================================
void _glfwTerminateJoysticks( void )
{
#ifdef _GLFW_USE_LINUX_JOYSTICKS
int i;
// Close any opened joysticks
for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i )
{
if( _glfwJoy[ i ].Present )
{
close( _glfwJoy[ i ].fd );
free( _glfwJoy[ i ].Axis );
free( _glfwJoy[ i ].Button );
_glfwJoy[ i ].Present = GL_FALSE;
}
}
#endif // _GLFW_USE_LINUX_JOYSTICKS
}
//========================================================================
// Empty joystick event queue
//========================================================================
static void pollJoystickEvents( void )
{
#ifdef _GLFW_USE_LINUX_JOYSTICKS
struct js_event e;
int i;
// Get joystick events for all GLFW joysticks
for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i )
{
// Is the stick present?
if( _glfwJoy[ i ].Present )
{
// Read all queued events (non-blocking)
while( read(_glfwJoy[i].fd, &e, sizeof(struct js_event)) > 0 )
{
// We don't care if it's an init event or not
e.type &= ~JS_EVENT_INIT;
// Check event type
switch( e.type )
{
case JS_EVENT_AXIS:
_glfwJoy[ i ].Axis[ e.number ] = (float) e.value /
32767.0f;
// We need to change the sign for the Y axes, so that
// positive = up/forward, according to the GLFW spec.
if( e.number & 1 )
{
_glfwJoy[ i ].Axis[ e.number ] =
-_glfwJoy[ i ].Axis[ e.number ];
}
break;
case JS_EVENT_BUTTON:
_glfwJoy[ i ].Button[ e.number ] =
e.value ? GLFW_PRESS : GLFW_RELEASE;
break;
default:
break;
}
}
}
}
#endif // _GLFW_USE_LINUX_JOYSTICKS
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Determine joystick capabilities
//========================================================================
int _glfwPlatformGetJoystickParam( int joy, int param )
{
// Is joystick present?
if( !_glfwJoy[ joy ].Present )
{
return 0;
}
switch( param )
{
case GLFW_PRESENT:
return GL_TRUE;
case GLFW_AXES:
return _glfwJoy[ joy ].NumAxes;
case GLFW_BUTTONS:
return _glfwJoy[ joy ].NumButtons;
default:
break;
}
return 0;
}
//========================================================================
// Get joystick axis positions
//========================================================================
int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )
{
int i;
// Is joystick present?
if( !_glfwJoy[ joy ].Present )
{
return 0;
}
// Update joystick state
pollJoystickEvents();
// Does the joystick support less axes than requested?
if( _glfwJoy[ joy ].NumAxes < numaxes )
{
numaxes = _glfwJoy[ joy ].NumAxes;
}
// Copy axis positions from internal state
for( i = 0; i < numaxes; ++ i )
{
pos[ i ] = _glfwJoy[ joy ].Axis[ i ];
}
return numaxes;
}
//========================================================================
// Get joystick button states
//========================================================================
int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons,
int numbuttons )
{
int i;
// Is joystick present?
if( !_glfwJoy[ joy ].Present )
{
return 0;
}
// Update joystick state
pollJoystickEvents();
// Does the joystick support less buttons than requested?
if( _glfwJoy[ joy ].NumButtons < numbuttons )
{
numbuttons = _glfwJoy[ joy ].NumButtons;
}
// Copy button states from internal state
for( i = 0; i < numbuttons; ++ i )
{
buttons[ i ] = _glfwJoy[ joy ].Button[ i ];
}
return numbuttons;
}

901
ogl_editor/src/External/glfw/lib/x11/x11_keysym2unicode.c vendored Normal file
View File

@ -0,0 +1,901 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
/*
* Marcus: This code was originally written by Markus G. Kuhn.
* I have made some slight changes (trimmed it down a bit from >60 KB to
* 20 KB), but the functionality is the same.
*/
/*
* This module converts keysym values into the corresponding ISO 10646
* (UCS, Unicode) values.
*
* The array keysymtab[] contains pairs of X11 keysym values for graphical
* characters and the corresponding Unicode value. The function
* _glfwKeySym2Unicode() maps a keysym onto a Unicode value using a binary
* search, therefore keysymtab[] must remain SORTED by keysym value.
*
* We allow to represent any UCS character in the range U-00000000 to
* U-00FFFFFF by a keysym value in the range 0x01000000 to 0x01ffffff.
* This admittedly does not cover the entire 31-bit space of UCS, but
* it does cover all of the characters up to U-10FFFF, which can be
* represented by UTF-16, and more, and it is very unlikely that higher
* UCS codes will ever be assigned by ISO. So to get Unicode character
* U+ABCD you can directly use keysym 0x0100abcd.
*
* Original author: Markus G. Kuhn <mkuhn@acm.org>, University of
* Cambridge, April 2001
*
* Special thanks to Richard Verhoeven <river@win.tue.nl> for preparing
* an initial draft of the mapping table.
*
*/
//************************************************************************
//**** KeySym to Unicode mapping table ****
//************************************************************************
static struct codepair {
unsigned short keysym;
unsigned short ucs;
} keysymtab[] = {
{ 0x01a1, 0x0104 },
{ 0x01a2, 0x02d8 },
{ 0x01a3, 0x0141 },
{ 0x01a5, 0x013d },
{ 0x01a6, 0x015a },
{ 0x01a9, 0x0160 },
{ 0x01aa, 0x015e },
{ 0x01ab, 0x0164 },
{ 0x01ac, 0x0179 },
{ 0x01ae, 0x017d },
{ 0x01af, 0x017b },
{ 0x01b1, 0x0105 },
{ 0x01b2, 0x02db },
{ 0x01b3, 0x0142 },
{ 0x01b5, 0x013e },
{ 0x01b6, 0x015b },
{ 0x01b7, 0x02c7 },
{ 0x01b9, 0x0161 },
{ 0x01ba, 0x015f },
{ 0x01bb, 0x0165 },
{ 0x01bc, 0x017a },
{ 0x01bd, 0x02dd },
{ 0x01be, 0x017e },
{ 0x01bf, 0x017c },
{ 0x01c0, 0x0154 },
{ 0x01c3, 0x0102 },
{ 0x01c5, 0x0139 },
{ 0x01c6, 0x0106 },
{ 0x01c8, 0x010c },
{ 0x01ca, 0x0118 },
{ 0x01cc, 0x011a },
{ 0x01cf, 0x010e },
{ 0x01d0, 0x0110 },
{ 0x01d1, 0x0143 },
{ 0x01d2, 0x0147 },
{ 0x01d5, 0x0150 },
{ 0x01d8, 0x0158 },
{ 0x01d9, 0x016e },
{ 0x01db, 0x0170 },
{ 0x01de, 0x0162 },
{ 0x01e0, 0x0155 },
{ 0x01e3, 0x0103 },
{ 0x01e5, 0x013a },
{ 0x01e6, 0x0107 },
{ 0x01e8, 0x010d },
{ 0x01ea, 0x0119 },
{ 0x01ec, 0x011b },
{ 0x01ef, 0x010f },
{ 0x01f0, 0x0111 },
{ 0x01f1, 0x0144 },
{ 0x01f2, 0x0148 },
{ 0x01f5, 0x0151 },
{ 0x01f8, 0x0159 },
{ 0x01f9, 0x016f },
{ 0x01fb, 0x0171 },
{ 0x01fe, 0x0163 },
{ 0x01ff, 0x02d9 },
{ 0x02a1, 0x0126 },
{ 0x02a6, 0x0124 },
{ 0x02a9, 0x0130 },
{ 0x02ab, 0x011e },
{ 0x02ac, 0x0134 },
{ 0x02b1, 0x0127 },
{ 0x02b6, 0x0125 },
{ 0x02b9, 0x0131 },
{ 0x02bb, 0x011f },
{ 0x02bc, 0x0135 },
{ 0x02c5, 0x010a },
{ 0x02c6, 0x0108 },
{ 0x02d5, 0x0120 },
{ 0x02d8, 0x011c },
{ 0x02dd, 0x016c },
{ 0x02de, 0x015c },
{ 0x02e5, 0x010b },
{ 0x02e6, 0x0109 },
{ 0x02f5, 0x0121 },
{ 0x02f8, 0x011d },
{ 0x02fd, 0x016d },
{ 0x02fe, 0x015d },
{ 0x03a2, 0x0138 },
{ 0x03a3, 0x0156 },
{ 0x03a5, 0x0128 },
{ 0x03a6, 0x013b },
{ 0x03aa, 0x0112 },
{ 0x03ab, 0x0122 },
{ 0x03ac, 0x0166 },
{ 0x03b3, 0x0157 },
{ 0x03b5, 0x0129 },
{ 0x03b6, 0x013c },
{ 0x03ba, 0x0113 },
{ 0x03bb, 0x0123 },
{ 0x03bc, 0x0167 },
{ 0x03bd, 0x014a },
{ 0x03bf, 0x014b },
{ 0x03c0, 0x0100 },
{ 0x03c7, 0x012e },
{ 0x03cc, 0x0116 },
{ 0x03cf, 0x012a },
{ 0x03d1, 0x0145 },
{ 0x03d2, 0x014c },
{ 0x03d3, 0x0136 },
{ 0x03d9, 0x0172 },
{ 0x03dd, 0x0168 },
{ 0x03de, 0x016a },
{ 0x03e0, 0x0101 },
{ 0x03e7, 0x012f },
{ 0x03ec, 0x0117 },
{ 0x03ef, 0x012b },
{ 0x03f1, 0x0146 },
{ 0x03f2, 0x014d },
{ 0x03f3, 0x0137 },
{ 0x03f9, 0x0173 },
{ 0x03fd, 0x0169 },
{ 0x03fe, 0x016b },
{ 0x047e, 0x203e },
{ 0x04a1, 0x3002 },
{ 0x04a2, 0x300c },
{ 0x04a3, 0x300d },
{ 0x04a4, 0x3001 },
{ 0x04a5, 0x30fb },
{ 0x04a6, 0x30f2 },
{ 0x04a7, 0x30a1 },
{ 0x04a8, 0x30a3 },
{ 0x04a9, 0x30a5 },
{ 0x04aa, 0x30a7 },
{ 0x04ab, 0x30a9 },
{ 0x04ac, 0x30e3 },
{ 0x04ad, 0x30e5 },
{ 0x04ae, 0x30e7 },
{ 0x04af, 0x30c3 },
{ 0x04b0, 0x30fc },
{ 0x04b1, 0x30a2 },
{ 0x04b2, 0x30a4 },
{ 0x04b3, 0x30a6 },
{ 0x04b4, 0x30a8 },
{ 0x04b5, 0x30aa },
{ 0x04b6, 0x30ab },
{ 0x04b7, 0x30ad },
{ 0x04b8, 0x30af },
{ 0x04b9, 0x30b1 },
{ 0x04ba, 0x30b3 },
{ 0x04bb, 0x30b5 },
{ 0x04bc, 0x30b7 },
{ 0x04bd, 0x30b9 },
{ 0x04be, 0x30bb },
{ 0x04bf, 0x30bd },
{ 0x04c0, 0x30bf },
{ 0x04c1, 0x30c1 },
{ 0x04c2, 0x30c4 },
{ 0x04c3, 0x30c6 },
{ 0x04c4, 0x30c8 },
{ 0x04c5, 0x30ca },
{ 0x04c6, 0x30cb },
{ 0x04c7, 0x30cc },
{ 0x04c8, 0x30cd },
{ 0x04c9, 0x30ce },
{ 0x04ca, 0x30cf },
{ 0x04cb, 0x30d2 },
{ 0x04cc, 0x30d5 },
{ 0x04cd, 0x30d8 },
{ 0x04ce, 0x30db },
{ 0x04cf, 0x30de },
{ 0x04d0, 0x30df },
{ 0x04d1, 0x30e0 },
{ 0x04d2, 0x30e1 },
{ 0x04d3, 0x30e2 },
{ 0x04d4, 0x30e4 },
{ 0x04d5, 0x30e6 },
{ 0x04d6, 0x30e8 },
{ 0x04d7, 0x30e9 },
{ 0x04d8, 0x30ea },
{ 0x04d9, 0x30eb },
{ 0x04da, 0x30ec },
{ 0x04db, 0x30ed },
{ 0x04dc, 0x30ef },
{ 0x04dd, 0x30f3 },
{ 0x04de, 0x309b },
{ 0x04df, 0x309c },
{ 0x05ac, 0x060c },
{ 0x05bb, 0x061b },
{ 0x05bf, 0x061f },
{ 0x05c1, 0x0621 },
{ 0x05c2, 0x0622 },
{ 0x05c3, 0x0623 },
{ 0x05c4, 0x0624 },
{ 0x05c5, 0x0625 },
{ 0x05c6, 0x0626 },
{ 0x05c7, 0x0627 },
{ 0x05c8, 0x0628 },
{ 0x05c9, 0x0629 },
{ 0x05ca, 0x062a },
{ 0x05cb, 0x062b },
{ 0x05cc, 0x062c },
{ 0x05cd, 0x062d },
{ 0x05ce, 0x062e },
{ 0x05cf, 0x062f },
{ 0x05d0, 0x0630 },
{ 0x05d1, 0x0631 },
{ 0x05d2, 0x0632 },
{ 0x05d3, 0x0633 },
{ 0x05d4, 0x0634 },
{ 0x05d5, 0x0635 },
{ 0x05d6, 0x0636 },
{ 0x05d7, 0x0637 },
{ 0x05d8, 0x0638 },
{ 0x05d9, 0x0639 },
{ 0x05da, 0x063a },
{ 0x05e0, 0x0640 },
{ 0x05e1, 0x0641 },
{ 0x05e2, 0x0642 },
{ 0x05e3, 0x0643 },
{ 0x05e4, 0x0644 },
{ 0x05e5, 0x0645 },
{ 0x05e6, 0x0646 },
{ 0x05e7, 0x0647 },
{ 0x05e8, 0x0648 },
{ 0x05e9, 0x0649 },
{ 0x05ea, 0x064a },
{ 0x05eb, 0x064b },
{ 0x05ec, 0x064c },
{ 0x05ed, 0x064d },
{ 0x05ee, 0x064e },
{ 0x05ef, 0x064f },
{ 0x05f0, 0x0650 },
{ 0x05f1, 0x0651 },
{ 0x05f2, 0x0652 },
{ 0x06a1, 0x0452 },
{ 0x06a2, 0x0453 },
{ 0x06a3, 0x0451 },
{ 0x06a4, 0x0454 },
{ 0x06a5, 0x0455 },
{ 0x06a6, 0x0456 },
{ 0x06a7, 0x0457 },
{ 0x06a8, 0x0458 },
{ 0x06a9, 0x0459 },
{ 0x06aa, 0x045a },
{ 0x06ab, 0x045b },
{ 0x06ac, 0x045c },
{ 0x06ae, 0x045e },
{ 0x06af, 0x045f },
{ 0x06b0, 0x2116 },
{ 0x06b1, 0x0402 },
{ 0x06b2, 0x0403 },
{ 0x06b3, 0x0401 },
{ 0x06b4, 0x0404 },
{ 0x06b5, 0x0405 },
{ 0x06b6, 0x0406 },
{ 0x06b7, 0x0407 },
{ 0x06b8, 0x0408 },
{ 0x06b9, 0x0409 },
{ 0x06ba, 0x040a },
{ 0x06bb, 0x040b },
{ 0x06bc, 0x040c },
{ 0x06be, 0x040e },
{ 0x06bf, 0x040f },
{ 0x06c0, 0x044e },
{ 0x06c1, 0x0430 },
{ 0x06c2, 0x0431 },
{ 0x06c3, 0x0446 },
{ 0x06c4, 0x0434 },
{ 0x06c5, 0x0435 },
{ 0x06c6, 0x0444 },
{ 0x06c7, 0x0433 },
{ 0x06c8, 0x0445 },
{ 0x06c9, 0x0438 },
{ 0x06ca, 0x0439 },
{ 0x06cb, 0x043a },
{ 0x06cc, 0x043b },
{ 0x06cd, 0x043c },
{ 0x06ce, 0x043d },
{ 0x06cf, 0x043e },
{ 0x06d0, 0x043f },
{ 0x06d1, 0x044f },
{ 0x06d2, 0x0440 },
{ 0x06d3, 0x0441 },
{ 0x06d4, 0x0442 },
{ 0x06d5, 0x0443 },
{ 0x06d6, 0x0436 },
{ 0x06d7, 0x0432 },
{ 0x06d8, 0x044c },
{ 0x06d9, 0x044b },
{ 0x06da, 0x0437 },
{ 0x06db, 0x0448 },
{ 0x06dc, 0x044d },
{ 0x06dd, 0x0449 },
{ 0x06de, 0x0447 },
{ 0x06df, 0x044a },
{ 0x06e0, 0x042e },
{ 0x06e1, 0x0410 },
{ 0x06e2, 0x0411 },
{ 0x06e3, 0x0426 },
{ 0x06e4, 0x0414 },
{ 0x06e5, 0x0415 },
{ 0x06e6, 0x0424 },
{ 0x06e7, 0x0413 },
{ 0x06e8, 0x0425 },
{ 0x06e9, 0x0418 },
{ 0x06ea, 0x0419 },
{ 0x06eb, 0x041a },
{ 0x06ec, 0x041b },
{ 0x06ed, 0x041c },
{ 0x06ee, 0x041d },
{ 0x06ef, 0x041e },
{ 0x06f0, 0x041f },
{ 0x06f1, 0x042f },
{ 0x06f2, 0x0420 },
{ 0x06f3, 0x0421 },
{ 0x06f4, 0x0422 },
{ 0x06f5, 0x0423 },
{ 0x06f6, 0x0416 },
{ 0x06f7, 0x0412 },
{ 0x06f8, 0x042c },
{ 0x06f9, 0x042b },
{ 0x06fa, 0x0417 },
{ 0x06fb, 0x0428 },
{ 0x06fc, 0x042d },
{ 0x06fd, 0x0429 },
{ 0x06fe, 0x0427 },
{ 0x06ff, 0x042a },
{ 0x07a1, 0x0386 },
{ 0x07a2, 0x0388 },
{ 0x07a3, 0x0389 },
{ 0x07a4, 0x038a },
{ 0x07a5, 0x03aa },
{ 0x07a7, 0x038c },
{ 0x07a8, 0x038e },
{ 0x07a9, 0x03ab },
{ 0x07ab, 0x038f },
{ 0x07ae, 0x0385 },
{ 0x07af, 0x2015 },
{ 0x07b1, 0x03ac },
{ 0x07b2, 0x03ad },
{ 0x07b3, 0x03ae },
{ 0x07b4, 0x03af },
{ 0x07b5, 0x03ca },
{ 0x07b6, 0x0390 },
{ 0x07b7, 0x03cc },
{ 0x07b8, 0x03cd },
{ 0x07b9, 0x03cb },
{ 0x07ba, 0x03b0 },
{ 0x07bb, 0x03ce },
{ 0x07c1, 0x0391 },
{ 0x07c2, 0x0392 },
{ 0x07c3, 0x0393 },
{ 0x07c4, 0x0394 },
{ 0x07c5, 0x0395 },
{ 0x07c6, 0x0396 },
{ 0x07c7, 0x0397 },
{ 0x07c8, 0x0398 },
{ 0x07c9, 0x0399 },
{ 0x07ca, 0x039a },
{ 0x07cb, 0x039b },
{ 0x07cc, 0x039c },
{ 0x07cd, 0x039d },
{ 0x07ce, 0x039e },
{ 0x07cf, 0x039f },
{ 0x07d0, 0x03a0 },
{ 0x07d1, 0x03a1 },
{ 0x07d2, 0x03a3 },
{ 0x07d4, 0x03a4 },
{ 0x07d5, 0x03a5 },
{ 0x07d6, 0x03a6 },
{ 0x07d7, 0x03a7 },
{ 0x07d8, 0x03a8 },
{ 0x07d9, 0x03a9 },
{ 0x07e1, 0x03b1 },
{ 0x07e2, 0x03b2 },
{ 0x07e3, 0x03b3 },
{ 0x07e4, 0x03b4 },
{ 0x07e5, 0x03b5 },
{ 0x07e6, 0x03b6 },
{ 0x07e7, 0x03b7 },
{ 0x07e8, 0x03b8 },
{ 0x07e9, 0x03b9 },
{ 0x07ea, 0x03ba },
{ 0x07eb, 0x03bb },
{ 0x07ec, 0x03bc },
{ 0x07ed, 0x03bd },
{ 0x07ee, 0x03be },
{ 0x07ef, 0x03bf },
{ 0x07f0, 0x03c0 },
{ 0x07f1, 0x03c1 },
{ 0x07f2, 0x03c3 },
{ 0x07f3, 0x03c2 },
{ 0x07f4, 0x03c4 },
{ 0x07f5, 0x03c5 },
{ 0x07f6, 0x03c6 },
{ 0x07f7, 0x03c7 },
{ 0x07f8, 0x03c8 },
{ 0x07f9, 0x03c9 },
{ 0x08a1, 0x23b7 },
{ 0x08a2, 0x250c },
{ 0x08a3, 0x2500 },
{ 0x08a4, 0x2320 },
{ 0x08a5, 0x2321 },
{ 0x08a6, 0x2502 },
{ 0x08a7, 0x23a1 },
{ 0x08a8, 0x23a3 },
{ 0x08a9, 0x23a4 },
{ 0x08aa, 0x23a6 },
{ 0x08ab, 0x239b },
{ 0x08ac, 0x239d },
{ 0x08ad, 0x239e },
{ 0x08ae, 0x23a0 },
{ 0x08af, 0x23a8 },
{ 0x08b0, 0x23ac },
{ 0x08bc, 0x2264 },
{ 0x08bd, 0x2260 },
{ 0x08be, 0x2265 },
{ 0x08bf, 0x222b },
{ 0x08c0, 0x2234 },
{ 0x08c1, 0x221d },
{ 0x08c2, 0x221e },
{ 0x08c5, 0x2207 },
{ 0x08c8, 0x223c },
{ 0x08c9, 0x2243 },
{ 0x08cd, 0x21d4 },
{ 0x08ce, 0x21d2 },
{ 0x08cf, 0x2261 },
{ 0x08d6, 0x221a },
{ 0x08da, 0x2282 },
{ 0x08db, 0x2283 },
{ 0x08dc, 0x2229 },
{ 0x08dd, 0x222a },
{ 0x08de, 0x2227 },
{ 0x08df, 0x2228 },
{ 0x08ef, 0x2202 },
{ 0x08f6, 0x0192 },
{ 0x08fb, 0x2190 },
{ 0x08fc, 0x2191 },
{ 0x08fd, 0x2192 },
{ 0x08fe, 0x2193 },
{ 0x09e0, 0x25c6 },
{ 0x09e1, 0x2592 },
{ 0x09e2, 0x2409 },
{ 0x09e3, 0x240c },
{ 0x09e4, 0x240d },
{ 0x09e5, 0x240a },
{ 0x09e8, 0x2424 },
{ 0x09e9, 0x240b },
{ 0x09ea, 0x2518 },
{ 0x09eb, 0x2510 },
{ 0x09ec, 0x250c },
{ 0x09ed, 0x2514 },
{ 0x09ee, 0x253c },
{ 0x09ef, 0x23ba },
{ 0x09f0, 0x23bb },
{ 0x09f1, 0x2500 },
{ 0x09f2, 0x23bc },
{ 0x09f3, 0x23bd },
{ 0x09f4, 0x251c },
{ 0x09f5, 0x2524 },
{ 0x09f6, 0x2534 },
{ 0x09f7, 0x252c },
{ 0x09f8, 0x2502 },
{ 0x0aa1, 0x2003 },
{ 0x0aa2, 0x2002 },
{ 0x0aa3, 0x2004 },
{ 0x0aa4, 0x2005 },
{ 0x0aa5, 0x2007 },
{ 0x0aa6, 0x2008 },
{ 0x0aa7, 0x2009 },
{ 0x0aa8, 0x200a },
{ 0x0aa9, 0x2014 },
{ 0x0aaa, 0x2013 },
{ 0x0aae, 0x2026 },
{ 0x0aaf, 0x2025 },
{ 0x0ab0, 0x2153 },
{ 0x0ab1, 0x2154 },
{ 0x0ab2, 0x2155 },
{ 0x0ab3, 0x2156 },
{ 0x0ab4, 0x2157 },
{ 0x0ab5, 0x2158 },
{ 0x0ab6, 0x2159 },
{ 0x0ab7, 0x215a },
{ 0x0ab8, 0x2105 },
{ 0x0abb, 0x2012 },
{ 0x0abc, 0x2329 },
{ 0x0abe, 0x232a },
{ 0x0ac3, 0x215b },
{ 0x0ac4, 0x215c },
{ 0x0ac5, 0x215d },
{ 0x0ac6, 0x215e },
{ 0x0ac9, 0x2122 },
{ 0x0aca, 0x2613 },
{ 0x0acc, 0x25c1 },
{ 0x0acd, 0x25b7 },
{ 0x0ace, 0x25cb },
{ 0x0acf, 0x25af },
{ 0x0ad0, 0x2018 },
{ 0x0ad1, 0x2019 },
{ 0x0ad2, 0x201c },
{ 0x0ad3, 0x201d },
{ 0x0ad4, 0x211e },
{ 0x0ad6, 0x2032 },
{ 0x0ad7, 0x2033 },
{ 0x0ad9, 0x271d },
{ 0x0adb, 0x25ac },
{ 0x0adc, 0x25c0 },
{ 0x0add, 0x25b6 },
{ 0x0ade, 0x25cf },
{ 0x0adf, 0x25ae },
{ 0x0ae0, 0x25e6 },
{ 0x0ae1, 0x25ab },
{ 0x0ae2, 0x25ad },
{ 0x0ae3, 0x25b3 },
{ 0x0ae4, 0x25bd },
{ 0x0ae5, 0x2606 },
{ 0x0ae6, 0x2022 },
{ 0x0ae7, 0x25aa },
{ 0x0ae8, 0x25b2 },
{ 0x0ae9, 0x25bc },
{ 0x0aea, 0x261c },
{ 0x0aeb, 0x261e },
{ 0x0aec, 0x2663 },
{ 0x0aed, 0x2666 },
{ 0x0aee, 0x2665 },
{ 0x0af0, 0x2720 },
{ 0x0af1, 0x2020 },
{ 0x0af2, 0x2021 },
{ 0x0af3, 0x2713 },
{ 0x0af4, 0x2717 },
{ 0x0af5, 0x266f },
{ 0x0af6, 0x266d },
{ 0x0af7, 0x2642 },
{ 0x0af8, 0x2640 },
{ 0x0af9, 0x260e },
{ 0x0afa, 0x2315 },
{ 0x0afb, 0x2117 },
{ 0x0afc, 0x2038 },
{ 0x0afd, 0x201a },
{ 0x0afe, 0x201e },
{ 0x0ba3, 0x003c },
{ 0x0ba6, 0x003e },
{ 0x0ba8, 0x2228 },
{ 0x0ba9, 0x2227 },
{ 0x0bc0, 0x00af },
{ 0x0bc2, 0x22a5 },
{ 0x0bc3, 0x2229 },
{ 0x0bc4, 0x230a },
{ 0x0bc6, 0x005f },
{ 0x0bca, 0x2218 },
{ 0x0bcc, 0x2395 },
{ 0x0bce, 0x22a4 },
{ 0x0bcf, 0x25cb },
{ 0x0bd3, 0x2308 },
{ 0x0bd6, 0x222a },
{ 0x0bd8, 0x2283 },
{ 0x0bda, 0x2282 },
{ 0x0bdc, 0x22a2 },
{ 0x0bfc, 0x22a3 },
{ 0x0cdf, 0x2017 },
{ 0x0ce0, 0x05d0 },
{ 0x0ce1, 0x05d1 },
{ 0x0ce2, 0x05d2 },
{ 0x0ce3, 0x05d3 },
{ 0x0ce4, 0x05d4 },
{ 0x0ce5, 0x05d5 },
{ 0x0ce6, 0x05d6 },
{ 0x0ce7, 0x05d7 },
{ 0x0ce8, 0x05d8 },
{ 0x0ce9, 0x05d9 },
{ 0x0cea, 0x05da },
{ 0x0ceb, 0x05db },
{ 0x0cec, 0x05dc },
{ 0x0ced, 0x05dd },
{ 0x0cee, 0x05de },
{ 0x0cef, 0x05df },
{ 0x0cf0, 0x05e0 },
{ 0x0cf1, 0x05e1 },
{ 0x0cf2, 0x05e2 },
{ 0x0cf3, 0x05e3 },
{ 0x0cf4, 0x05e4 },
{ 0x0cf5, 0x05e5 },
{ 0x0cf6, 0x05e6 },
{ 0x0cf7, 0x05e7 },
{ 0x0cf8, 0x05e8 },
{ 0x0cf9, 0x05e9 },
{ 0x0cfa, 0x05ea },
{ 0x0da1, 0x0e01 },
{ 0x0da2, 0x0e02 },
{ 0x0da3, 0x0e03 },
{ 0x0da4, 0x0e04 },
{ 0x0da5, 0x0e05 },
{ 0x0da6, 0x0e06 },
{ 0x0da7, 0x0e07 },
{ 0x0da8, 0x0e08 },
{ 0x0da9, 0x0e09 },
{ 0x0daa, 0x0e0a },
{ 0x0dab, 0x0e0b },
{ 0x0dac, 0x0e0c },
{ 0x0dad, 0x0e0d },
{ 0x0dae, 0x0e0e },
{ 0x0daf, 0x0e0f },
{ 0x0db0, 0x0e10 },
{ 0x0db1, 0x0e11 },
{ 0x0db2, 0x0e12 },
{ 0x0db3, 0x0e13 },
{ 0x0db4, 0x0e14 },
{ 0x0db5, 0x0e15 },
{ 0x0db6, 0x0e16 },
{ 0x0db7, 0x0e17 },
{ 0x0db8, 0x0e18 },
{ 0x0db9, 0x0e19 },
{ 0x0dba, 0x0e1a },
{ 0x0dbb, 0x0e1b },
{ 0x0dbc, 0x0e1c },
{ 0x0dbd, 0x0e1d },
{ 0x0dbe, 0x0e1e },
{ 0x0dbf, 0x0e1f },
{ 0x0dc0, 0x0e20 },
{ 0x0dc1, 0x0e21 },
{ 0x0dc2, 0x0e22 },
{ 0x0dc3, 0x0e23 },
{ 0x0dc4, 0x0e24 },
{ 0x0dc5, 0x0e25 },
{ 0x0dc6, 0x0e26 },
{ 0x0dc7, 0x0e27 },
{ 0x0dc8, 0x0e28 },
{ 0x0dc9, 0x0e29 },
{ 0x0dca, 0x0e2a },
{ 0x0dcb, 0x0e2b },
{ 0x0dcc, 0x0e2c },
{ 0x0dcd, 0x0e2d },
{ 0x0dce, 0x0e2e },
{ 0x0dcf, 0x0e2f },
{ 0x0dd0, 0x0e30 },
{ 0x0dd1, 0x0e31 },
{ 0x0dd2, 0x0e32 },
{ 0x0dd3, 0x0e33 },
{ 0x0dd4, 0x0e34 },
{ 0x0dd5, 0x0e35 },
{ 0x0dd6, 0x0e36 },
{ 0x0dd7, 0x0e37 },
{ 0x0dd8, 0x0e38 },
{ 0x0dd9, 0x0e39 },
{ 0x0dda, 0x0e3a },
{ 0x0ddf, 0x0e3f },
{ 0x0de0, 0x0e40 },
{ 0x0de1, 0x0e41 },
{ 0x0de2, 0x0e42 },
{ 0x0de3, 0x0e43 },
{ 0x0de4, 0x0e44 },
{ 0x0de5, 0x0e45 },
{ 0x0de6, 0x0e46 },
{ 0x0de7, 0x0e47 },
{ 0x0de8, 0x0e48 },
{ 0x0de9, 0x0e49 },
{ 0x0dea, 0x0e4a },
{ 0x0deb, 0x0e4b },
{ 0x0dec, 0x0e4c },
{ 0x0ded, 0x0e4d },
{ 0x0df0, 0x0e50 },
{ 0x0df1, 0x0e51 },
{ 0x0df2, 0x0e52 },
{ 0x0df3, 0x0e53 },
{ 0x0df4, 0x0e54 },
{ 0x0df5, 0x0e55 },
{ 0x0df6, 0x0e56 },
{ 0x0df7, 0x0e57 },
{ 0x0df8, 0x0e58 },
{ 0x0df9, 0x0e59 },
{ 0x0ea1, 0x3131 },
{ 0x0ea2, 0x3132 },
{ 0x0ea3, 0x3133 },
{ 0x0ea4, 0x3134 },
{ 0x0ea5, 0x3135 },
{ 0x0ea6, 0x3136 },
{ 0x0ea7, 0x3137 },
{ 0x0ea8, 0x3138 },
{ 0x0ea9, 0x3139 },
{ 0x0eaa, 0x313a },
{ 0x0eab, 0x313b },
{ 0x0eac, 0x313c },
{ 0x0ead, 0x313d },
{ 0x0eae, 0x313e },
{ 0x0eaf, 0x313f },
{ 0x0eb0, 0x3140 },
{ 0x0eb1, 0x3141 },
{ 0x0eb2, 0x3142 },
{ 0x0eb3, 0x3143 },
{ 0x0eb4, 0x3144 },
{ 0x0eb5, 0x3145 },
{ 0x0eb6, 0x3146 },
{ 0x0eb7, 0x3147 },
{ 0x0eb8, 0x3148 },
{ 0x0eb9, 0x3149 },
{ 0x0eba, 0x314a },
{ 0x0ebb, 0x314b },
{ 0x0ebc, 0x314c },
{ 0x0ebd, 0x314d },
{ 0x0ebe, 0x314e },
{ 0x0ebf, 0x314f },
{ 0x0ec0, 0x3150 },
{ 0x0ec1, 0x3151 },
{ 0x0ec2, 0x3152 },
{ 0x0ec3, 0x3153 },
{ 0x0ec4, 0x3154 },
{ 0x0ec5, 0x3155 },
{ 0x0ec6, 0x3156 },
{ 0x0ec7, 0x3157 },
{ 0x0ec8, 0x3158 },
{ 0x0ec9, 0x3159 },
{ 0x0eca, 0x315a },
{ 0x0ecb, 0x315b },
{ 0x0ecc, 0x315c },
{ 0x0ecd, 0x315d },
{ 0x0ece, 0x315e },
{ 0x0ecf, 0x315f },
{ 0x0ed0, 0x3160 },
{ 0x0ed1, 0x3161 },
{ 0x0ed2, 0x3162 },
{ 0x0ed3, 0x3163 },
{ 0x0ed4, 0x11a8 },
{ 0x0ed5, 0x11a9 },
{ 0x0ed6, 0x11aa },
{ 0x0ed7, 0x11ab },
{ 0x0ed8, 0x11ac },
{ 0x0ed9, 0x11ad },
{ 0x0eda, 0x11ae },
{ 0x0edb, 0x11af },
{ 0x0edc, 0x11b0 },
{ 0x0edd, 0x11b1 },
{ 0x0ede, 0x11b2 },
{ 0x0edf, 0x11b3 },
{ 0x0ee0, 0x11b4 },
{ 0x0ee1, 0x11b5 },
{ 0x0ee2, 0x11b6 },
{ 0x0ee3, 0x11b7 },
{ 0x0ee4, 0x11b8 },
{ 0x0ee5, 0x11b9 },
{ 0x0ee6, 0x11ba },
{ 0x0ee7, 0x11bb },
{ 0x0ee8, 0x11bc },
{ 0x0ee9, 0x11bd },
{ 0x0eea, 0x11be },
{ 0x0eeb, 0x11bf },
{ 0x0eec, 0x11c0 },
{ 0x0eed, 0x11c1 },
{ 0x0eee, 0x11c2 },
{ 0x0eef, 0x316d },
{ 0x0ef0, 0x3171 },
{ 0x0ef1, 0x3178 },
{ 0x0ef2, 0x317f },
{ 0x0ef3, 0x3181 },
{ 0x0ef4, 0x3184 },
{ 0x0ef5, 0x3186 },
{ 0x0ef6, 0x318d },
{ 0x0ef7, 0x318e },
{ 0x0ef8, 0x11eb },
{ 0x0ef9, 0x11f0 },
{ 0x0efa, 0x11f9 },
{ 0x0eff, 0x20a9 },
{ 0x13a4, 0x20ac },
{ 0x13bc, 0x0152 },
{ 0x13bd, 0x0153 },
{ 0x13be, 0x0178 },
{ 0x20ac, 0x20ac },
// Numeric keypad with numlock on
{ XK_KP_Space, ' ' },
{ XK_KP_Equal, '=' },
{ XK_KP_Multiply, '*' },
{ XK_KP_Add, '+' },
{ XK_KP_Separator, ',' },
{ XK_KP_Subtract, '-' },
{ XK_KP_Decimal, '.' },
{ XK_KP_Divide, '/' },
{ XK_KP_0, 0x0030 },
{ XK_KP_1, 0x0031 },
{ XK_KP_2, 0x0032 },
{ XK_KP_3, 0x0033 },
{ XK_KP_4, 0x0034 },
{ XK_KP_5, 0x0035 },
{ XK_KP_6, 0x0036 },
{ XK_KP_7, 0x0037 },
{ XK_KP_8, 0x0038 },
{ XK_KP_9, 0x0039 }
};
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Convert X11 KeySym to Unicode
//========================================================================
long _glfwKeySym2Unicode( KeySym keysym )
{
int min = 0;
int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
int mid;
/* First check for Latin-1 characters (1:1 mapping) */
if( (keysym >= 0x0020 && keysym <= 0x007e) ||
(keysym >= 0x00a0 && keysym <= 0x00ff) )
{ return keysym;
}
/* Also check for directly encoded 24-bit UCS characters */
if( (keysym & 0xff000000) == 0x01000000 )
{
return keysym & 0x00ffffff;
}
/* Binary search in table */
while( max >= min )
{
mid = (min + max) / 2;
if( keysymtab[mid].keysym < keysym )
{
min = mid + 1;
}
else if( keysymtab[mid].keysym > keysym )
{
max = mid - 1;
}
else
{
/* Found it! */
return keysymtab[mid].ucs;
}
}
/* No matching Unicode value found */
return -1;
}

503
ogl_editor/src/External/glfw/lib/x11/x11_thread.c vendored Normal file
View File

@ -0,0 +1,503 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
#ifdef _GLFW_HAS_PTHREAD
//========================================================================
// This is simply a "wrapper" for calling the user thread function.
//========================================================================
void * _glfwNewThread( void * arg )
{
GLFWthreadfun threadfun;
_GLFWthread *t;
pthread_t posixID;
// Get current thread ID
posixID = pthread_self();
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Loop through entire list of threads to find the matching POSIX
// thread ID
for( t = &_glfwThrd.First; t != NULL; t = t->Next )
{
if( t->PosixID == posixID )
{
break;
}
}
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return NULL;
}
// Get user thread function pointer
threadfun = t->Function;
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Call the user thread function
threadfun( arg );
// Remove thread from thread list
ENTER_THREAD_CRITICAL_SECTION
_glfwRemoveThread( t );
LEAVE_THREAD_CRITICAL_SECTION
// When the thread function returns, the thread will die...
return NULL;
}
#endif // _GLFW_HAS_PTHREAD
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Create a new thread
//========================================================================
GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )
{
#ifdef _GLFW_HAS_PTHREAD
GLFWthread ID;
_GLFWthread *t;
int result;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Create a new thread information memory area
t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );
if( t == NULL )
{
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Get a new unique thread id
ID = _glfwThrd.NextID ++;
// Store thread information in the thread list
t->Function = fun;
t->ID = ID;
// Create thread
result = pthread_create(
&t->PosixID, // Thread handle
NULL, // Default thread attributes
_glfwNewThread, // Thread function (a wrapper function)
(void *)arg // Argument to thread is user argument
);
// Did the thread creation fail?
if( result != 0 )
{
free( (void *) t );
LEAVE_THREAD_CRITICAL_SECTION
return -1;
}
// Append thread to thread list
_glfwAppendThread( t );
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the GLFW thread ID
return ID;
#else
return -1;
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Kill a thread. NOTE: THIS IS A VERY DANGEROUS OPERATION, AND SHOULD NOT
// BE USED EXCEPT IN EXTREME SITUATIONS!
//========================================================================
void _glfwPlatformDestroyThread( GLFWthread ID )
{
#ifdef _GLFW_HAS_PTHREAD
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return;
}
// Simply murder the process, no mercy!
pthread_kill( t->PosixID, SIGKILL );
// Remove thread from thread list
_glfwRemoveThread( t );
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Wait for a thread to die
//========================================================================
int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )
{
#ifdef _GLFW_HAS_PTHREAD
pthread_t thread;
_GLFWthread *t;
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Get thread information pointer
t = _glfwGetThreadPointer( ID );
// Is the thread already dead?
if( t == NULL )
{
LEAVE_THREAD_CRITICAL_SECTION
return GL_TRUE;
}
// If got this far, the thread is alive => polling returns FALSE
if( waitmode == GLFW_NOWAIT )
{
LEAVE_THREAD_CRITICAL_SECTION
return GL_FALSE;
}
// Get thread handle
thread = t->PosixID;
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Wait for thread to die
(void) pthread_join( thread, NULL );
return GL_TRUE;
#else
return GL_TRUE;
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Return the thread ID for the current thread
//========================================================================
GLFWthread _glfwPlatformGetThreadID( void )
{
#ifdef _GLFW_HAS_PTHREAD
_GLFWthread *t;
GLFWthread ID = -1;
pthread_t posixID;
// Get current thread ID
posixID = pthread_self();
// Enter critical section
ENTER_THREAD_CRITICAL_SECTION
// Loop through entire list of threads to find the matching POSIX
// thread ID
for( t = &_glfwThrd.First; t != NULL; t = t->Next )
{
if( t->PosixID == posixID )
{
ID = t->ID;
break;
}
}
// Leave critical section
LEAVE_THREAD_CRITICAL_SECTION
// Return the found GLFW thread identifier
return ID;
#else
return 0;
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Create a mutual exclusion object
//========================================================================
GLFWmutex _glfwPlatformCreateMutex( void )
{
#ifdef _GLFW_HAS_PTHREAD
pthread_mutex_t *mutex;
// Allocate memory for mutex
mutex = (pthread_mutex_t *) malloc( sizeof( pthread_mutex_t ) );
if( !mutex )
{
return NULL;
}
// Initialise a mutex object
(void) pthread_mutex_init( mutex, NULL );
// Cast to GLFWmutex and return
return (GLFWmutex) mutex;
#else
return (GLFWmutex) 0;
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Destroy a mutual exclusion object
//========================================================================
void _glfwPlatformDestroyMutex( GLFWmutex mutex )
{
#ifdef _GLFW_HAS_PTHREAD
// Destroy the mutex object
pthread_mutex_destroy( (pthread_mutex_t *) mutex );
// Free memory for mutex object
free( (void *) mutex );
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Request access to a mutex
//========================================================================
void _glfwPlatformLockMutex( GLFWmutex mutex )
{
#ifdef _GLFW_HAS_PTHREAD
// Wait for mutex to be released
(void) pthread_mutex_lock( (pthread_mutex_t *) mutex );
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Release a mutex
//========================================================================
void _glfwPlatformUnlockMutex( GLFWmutex mutex )
{
#ifdef _GLFW_HAS_PTHREAD
// Release mutex
pthread_mutex_unlock( (pthread_mutex_t *) mutex );
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Create a new condition variable object
//========================================================================
GLFWcond _glfwPlatformCreateCond( void )
{
#ifdef _GLFW_HAS_PTHREAD
pthread_cond_t *cond;
// Allocate memory for condition variable
cond = (pthread_cond_t *) malloc( sizeof(pthread_cond_t) );
if( !cond )
{
return NULL;
}
// Initialise condition variable
(void) pthread_cond_init( cond, NULL );
// Cast to GLFWcond and return
return (GLFWcond) cond;
#else
return (GLFWcond) 0;
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Destroy a condition variable object
//========================================================================
void _glfwPlatformDestroyCond( GLFWcond cond )
{
#ifdef _GLFW_HAS_PTHREAD
// Destroy the condition variable object
(void) pthread_cond_destroy( (pthread_cond_t *) cond );
// Free memory for condition variable object
free( (void *) cond );
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Wait for a condition to be raised
//========================================================================
void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex,
double timeout )
{
#ifdef _GLFW_HAS_PTHREAD
struct timeval currenttime;
struct timespec wait;
long dt_sec, dt_usec;
// Select infinite or timed wait
if( timeout >= GLFW_INFINITY )
{
// Wait for condition (infinite wait)
(void) pthread_cond_wait( (pthread_cond_t *) cond,
(pthread_mutex_t *) mutex );
}
else
{
// Set timeout time, relatvie to current time
gettimeofday( &currenttime, NULL );
dt_sec = (long) timeout;
dt_usec = (long) ((timeout - (double)dt_sec) * 1000000.0);
wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;
if( wait.tv_nsec > 1000000000L )
{
wait.tv_nsec -= 1000000000L;
dt_sec ++;
}
wait.tv_sec = currenttime.tv_sec + dt_sec;
// Wait for condition (timed wait)
(void) pthread_cond_timedwait( (pthread_cond_t *) cond,
(pthread_mutex_t *) mutex, &wait );
}
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Signal a condition to one waiting thread
//========================================================================
void _glfwPlatformSignalCond( GLFWcond cond )
{
#ifdef _GLFW_HAS_PTHREAD
// Signal condition
(void) pthread_cond_signal( (pthread_cond_t *) cond );
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Broadcast a condition to all waiting threads
//========================================================================
void _glfwPlatformBroadcastCond( GLFWcond cond )
{
#ifdef _GLFW_HAS_PTHREAD
// Broadcast condition
(void) pthread_cond_broadcast( (pthread_cond_t *) cond );
#endif // _GLFW_HAS_PTHREAD
}
//========================================================================
// Return the number of processors in the system.
//========================================================================
int _glfwPlatformGetNumberOfProcessors( void )
{
int n;
// Get number of processors online
_glfw_numprocessors( n );
return n;
}

174
ogl_editor/src/External/glfw/lib/x11/x11_time.c vendored Normal file
View File

@ -0,0 +1,174 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
// API version: 2.7
// WWW: http://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.
//
//========================================================================
#include "internal.h"
#include <time.h>
//========================================================================
// Return raw time
//========================================================================
static uint64_t getRawTime(void)
{
#if defined( CLOCK_MONOTONIC )
if( _glfwLibrary.Timer.monotonic )
{
struct timespec ts;
clock_gettime( CLOCK_MONOTONIC, &ts );
return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
}
else
#endif
{
struct timeval tv;
gettimeofday( &tv, NULL );
return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
}
}
//========================================================================
// Initialise timer
//========================================================================
void _glfwInitTimer( void )
{
#if defined( CLOCK_MONOTONIC )
struct timespec ts;
if( clock_gettime( CLOCK_MONOTONIC, &ts ) == 0 )
{
_glfwLibrary.Timer.monotonic = GL_TRUE;
_glfwLibrary.Timer.resolution = 1e-9;
}
else
#endif
{
_glfwLibrary.Timer.resolution = 1e-6;
}
_glfwLibrary.Timer.base = getRawTime();
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
//========================================================================
// Return timer value in seconds
//========================================================================
double _glfwPlatformGetTime( void )
{
return (double) (getRawTime() - _glfwLibrary.Timer.base) *
_glfwLibrary.Timer.resolution;
}
//========================================================================
// Set timer value in seconds
//========================================================================
void _glfwPlatformSetTime( double time )
{
_glfwLibrary.Timer.base = getRawTime() -
(uint64_t) (time / _glfwLibrary.Timer.resolution);
}
//========================================================================
// Put a thread to sleep for a specified amount of time
//========================================================================
void _glfwPlatformSleep( double time )
{
#ifdef _GLFW_HAS_PTHREAD
if( time == 0.0 )
{
#ifdef _GLFW_HAS_SCHED_YIELD
sched_yield();
#endif
return;
}
struct timeval currenttime;
struct timespec wait;
pthread_mutex_t mutex;
pthread_cond_t cond;
long dt_sec, dt_usec;
// Not all pthread implementations have a pthread_sleep() function. We
// do it the portable way, using a timed wait for a condition that we
// will never signal. NOTE: The unistd functions sleep/usleep suspends
// the entire PROCESS, not a signle thread, which is why we can not
// use them to implement glfwSleep.
// Set timeout time, relatvie to current time
gettimeofday( &currenttime, NULL );
dt_sec = (long) time;
dt_usec = (long) ((time - (double)dt_sec) * 1000000.0);
wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;
if( wait.tv_nsec > 1000000000L )
{
wait.tv_nsec -= 1000000000L;
dt_sec++;
}
wait.tv_sec = currenttime.tv_sec + dt_sec;
// Initialize condition and mutex objects
pthread_mutex_init( &mutex, NULL );
pthread_cond_init( &cond, NULL );
// Do a timed wait
pthread_mutex_lock( &mutex );
pthread_cond_timedwait( &cond, &mutex, &wait );
pthread_mutex_unlock( &mutex );
// Destroy condition and mutex objects
pthread_mutex_destroy( &mutex );
pthread_cond_destroy( &cond );
#else
// For systems without PTHREAD, use unistd usleep
if( time > 0 )
{
usleep( (unsigned int) (time*1000000) );
}
#endif // _GLFW_HAS_PTHREAD
}

1938
ogl_editor/src/External/glfw/lib/x11/x11_window.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff