mirror of
https://github.com/gwm17/glfw.git
synced 2024-11-26 20:28:49 -05:00
887 lines
25 KiB
Objective-C
887 lines
25 KiB
Objective-C
//========================================================================
|
|
// GLFW - An OpenGL framework
|
|
// Platform: Cocoa/NSOpenGL
|
|
// API Version: 3.0
|
|
// 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"
|
|
|
|
//========================================================================
|
|
// Delegate for window related notifications
|
|
// (but also used as an application delegate)
|
|
//========================================================================
|
|
|
|
@interface GLFWWindowDelegate : NSObject
|
|
@end
|
|
|
|
@implementation GLFWWindowDelegate
|
|
|
|
- (BOOL)windowShouldClose:(id)window
|
|
{
|
|
if( _glfwWin.windowCloseCallback )
|
|
{
|
|
if( !_glfwWin.windowCloseCallback() )
|
|
{
|
|
return NO;
|
|
}
|
|
}
|
|
|
|
// This is horribly ugly, but it works
|
|
glfwCloseWindow();
|
|
return NO;
|
|
}
|
|
|
|
- (void)windowDidResize:(NSNotification *)notification
|
|
{
|
|
[_glfwWin.context update];
|
|
|
|
NSRect contentRect =
|
|
[_glfwWin.window contentRectForFrameRect:[_glfwWin.window frame]];
|
|
_glfwWin.width = contentRect.size.width;
|
|
_glfwWin.height = contentRect.size.height;
|
|
|
|
if( _glfwWin.windowSizeCallback )
|
|
{
|
|
_glfwWin.windowSizeCallback( _glfwWin.width, _glfwWin.height );
|
|
}
|
|
}
|
|
|
|
- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
|
|
{
|
|
if( _glfwWin.windowCloseCallback )
|
|
{
|
|
if( !_glfwWin.windowCloseCallback() )
|
|
{
|
|
return NSTerminateCancel;
|
|
}
|
|
}
|
|
|
|
// This is horribly ugly, but it works
|
|
glfwCloseWindow();
|
|
return NSTerminateCancel;
|
|
}
|
|
|
|
@end
|
|
|
|
// TODO: Need to find mappings for F13-F15, volume down/up/mute, and eject.
|
|
static const unsigned int MAC_TO_GLFW_KEYCODE_MAPPING[128] =
|
|
{
|
|
/* 00 */ 'A',
|
|
/* 01 */ 'S',
|
|
/* 02 */ 'D',
|
|
/* 03 */ 'F',
|
|
/* 04 */ 'H',
|
|
/* 05 */ 'G',
|
|
/* 06 */ 'Z',
|
|
/* 07 */ 'X',
|
|
/* 08 */ 'C',
|
|
/* 09 */ 'V',
|
|
/* 0a */ -1,
|
|
/* 0b */ 'B',
|
|
/* 0c */ 'Q',
|
|
/* 0d */ 'W',
|
|
/* 0e */ 'E',
|
|
/* 0f */ 'R',
|
|
/* 10 */ 'Y',
|
|
/* 11 */ 'T',
|
|
/* 12 */ '1',
|
|
/* 13 */ '2',
|
|
/* 14 */ '3',
|
|
/* 15 */ '4',
|
|
/* 16 */ '6',
|
|
/* 17 */ '5',
|
|
/* 18 */ '=',
|
|
/* 19 */ '9',
|
|
/* 1a */ '7',
|
|
/* 1b */ '-',
|
|
/* 1c */ '8',
|
|
/* 1d */ '0',
|
|
/* 1e */ ']',
|
|
/* 1f */ 'O',
|
|
/* 20 */ 'U',
|
|
/* 21 */ '[',
|
|
/* 22 */ 'I',
|
|
/* 23 */ 'P',
|
|
/* 24 */ GLFW_KEY_ENTER,
|
|
/* 25 */ 'L',
|
|
/* 26 */ 'J',
|
|
/* 27 */ '\'',
|
|
/* 28 */ 'K',
|
|
/* 29 */ ';',
|
|
/* 2a */ '\\',
|
|
/* 2b */ ',',
|
|
/* 2c */ '/',
|
|
/* 2d */ 'N',
|
|
/* 2e */ 'M',
|
|
/* 2f */ '.',
|
|
/* 30 */ GLFW_KEY_TAB,
|
|
/* 31 */ GLFW_KEY_SPACE,
|
|
/* 32 */ '`',
|
|
/* 33 */ GLFW_KEY_BACKSPACE,
|
|
/* 34 */ -1,
|
|
/* 35 */ GLFW_KEY_ESC,
|
|
/* 36 */ GLFW_KEY_RSUPER,
|
|
/* 37 */ GLFW_KEY_LSUPER,
|
|
/* 38 */ GLFW_KEY_LSHIFT,
|
|
/* 39 */ GLFW_KEY_CAPS_LOCK,
|
|
/* 3a */ GLFW_KEY_LALT,
|
|
/* 3b */ GLFW_KEY_LCTRL,
|
|
/* 3c */ GLFW_KEY_RSHIFT,
|
|
/* 3d */ GLFW_KEY_RALT,
|
|
/* 3e */ GLFW_KEY_RCTRL,
|
|
/* 3f */ -1, /*Function*/
|
|
/* 40 */ GLFW_KEY_F17,
|
|
/* 41 */ GLFW_KEY_KP_DECIMAL,
|
|
/* 42 */ -1,
|
|
/* 43 */ GLFW_KEY_KP_MULTIPLY,
|
|
/* 44 */ -1,
|
|
/* 45 */ GLFW_KEY_KP_ADD,
|
|
/* 46 */ -1,
|
|
/* 47 */ -1, /*KeypadClear*/
|
|
/* 48 */ -1, /*VolumeUp*/
|
|
/* 49 */ -1, /*VolumeDown*/
|
|
/* 4a */ -1, /*Mute*/
|
|
/* 4b */ GLFW_KEY_KP_DIVIDE,
|
|
/* 4c */ GLFW_KEY_KP_ENTER,
|
|
/* 4d */ -1,
|
|
/* 4e */ GLFW_KEY_KP_SUBTRACT,
|
|
/* 4f */ GLFW_KEY_F18,
|
|
/* 50 */ GLFW_KEY_F19,
|
|
/* 51 */ GLFW_KEY_KP_EQUAL,
|
|
/* 52 */ GLFW_KEY_KP_0,
|
|
/* 53 */ GLFW_KEY_KP_1,
|
|
/* 54 */ GLFW_KEY_KP_2,
|
|
/* 55 */ GLFW_KEY_KP_3,
|
|
/* 56 */ GLFW_KEY_KP_4,
|
|
/* 57 */ GLFW_KEY_KP_5,
|
|
/* 58 */ GLFW_KEY_KP_6,
|
|
/* 59 */ GLFW_KEY_KP_7,
|
|
/* 5a */ GLFW_KEY_F20,
|
|
/* 5b */ GLFW_KEY_KP_8,
|
|
/* 5c */ GLFW_KEY_KP_9,
|
|
/* 5d */ -1,
|
|
/* 5e */ -1,
|
|
/* 5f */ -1,
|
|
/* 60 */ GLFW_KEY_F5,
|
|
/* 61 */ GLFW_KEY_F6,
|
|
/* 62 */ GLFW_KEY_F7,
|
|
/* 63 */ GLFW_KEY_F3,
|
|
/* 64 */ GLFW_KEY_F8,
|
|
/* 65 */ GLFW_KEY_F9,
|
|
/* 66 */ -1,
|
|
/* 67 */ GLFW_KEY_F11,
|
|
/* 68 */ -1,
|
|
/* 69 */ GLFW_KEY_F13,
|
|
/* 6a */ GLFW_KEY_F16,
|
|
/* 6b */ GLFW_KEY_F14,
|
|
/* 6c */ -1,
|
|
/* 6d */ GLFW_KEY_F10,
|
|
/* 6e */ -1,
|
|
/* 6f */ GLFW_KEY_F12,
|
|
/* 70 */ -1,
|
|
/* 71 */ GLFW_KEY_F15,
|
|
/* 72 */ GLFW_KEY_INSERT, /*Help*/
|
|
/* 73 */ GLFW_KEY_HOME,
|
|
/* 74 */ GLFW_KEY_PAGEUP,
|
|
/* 75 */ GLFW_KEY_DEL,
|
|
/* 76 */ GLFW_KEY_F4,
|
|
/* 77 */ GLFW_KEY_END,
|
|
/* 78 */ GLFW_KEY_F2,
|
|
/* 79 */ GLFW_KEY_PAGEDOWN,
|
|
/* 7a */ GLFW_KEY_F1,
|
|
/* 7b */ GLFW_KEY_LEFT,
|
|
/* 7c */ GLFW_KEY_RIGHT,
|
|
/* 7d */ GLFW_KEY_DOWN,
|
|
/* 7e */ GLFW_KEY_UP,
|
|
/* 7f */ -1,
|
|
};
|
|
|
|
//========================================================================
|
|
// Converts a Mac OS X keycode to a GLFW keycode
|
|
//========================================================================
|
|
|
|
static int convertMacKeyCode( unsigned int macKeyCode )
|
|
{
|
|
if( macKeyCode >= 128 )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// This treats keycodes as *positional*; that is, we'll return 'a'
|
|
// for the key left of 's', even on an AZERTY keyboard. The charInput
|
|
// function should still get 'q' though.
|
|
return MAC_TO_GLFW_KEYCODE_MAPPING[macKeyCode];
|
|
}
|
|
|
|
//========================================================================
|
|
// Content view class for the GLFW window
|
|
//========================================================================
|
|
|
|
@interface GLFWContentView : NSView
|
|
@end
|
|
|
|
@implementation GLFWContentView
|
|
|
|
- (BOOL)isOpaque
|
|
{
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)canBecomeKeyView
|
|
{
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)acceptsFirstResponder
|
|
{
|
|
return YES;
|
|
}
|
|
|
|
- (void)mouseDown:(NSEvent *)event
|
|
{
|
|
_glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS );
|
|
}
|
|
|
|
- (void)mouseDragged:(NSEvent *)event
|
|
{
|
|
[self mouseMoved:event];
|
|
}
|
|
|
|
- (void)mouseUp:(NSEvent *)event
|
|
{
|
|
_glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE );
|
|
}
|
|
|
|
- (void)mouseMoved:(NSEvent *)event
|
|
{
|
|
if( _glfwWin.mouseLock )
|
|
{
|
|
_glfwInput.MousePosX += [event deltaX];
|
|
_glfwInput.MousePosY += [event deltaY];
|
|
}
|
|
else
|
|
{
|
|
NSPoint p = [event locationInWindow];
|
|
|
|
// Cocoa coordinate system has origin at lower left
|
|
_glfwInput.MousePosX = p.x;
|
|
_glfwInput.MousePosY = [[_glfwWin.window contentView] bounds].size.height - p.y;
|
|
}
|
|
|
|
if( _glfwWin.mousePosCallback )
|
|
{
|
|
_glfwWin.mousePosCallback( _glfwInput.MousePosX, _glfwInput.MousePosY );
|
|
}
|
|
}
|
|
|
|
- (void)rightMouseDown:(NSEvent *)event
|
|
{
|
|
_glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS );
|
|
}
|
|
|
|
- (void)rightMouseDragged:(NSEvent *)event
|
|
{
|
|
[self mouseMoved:event];
|
|
}
|
|
|
|
- (void)rightMouseUp:(NSEvent *)event
|
|
{
|
|
_glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_RELEASE );
|
|
}
|
|
|
|
- (void)otherMouseDown:(NSEvent *)event
|
|
{
|
|
_glfwInputMouseClick( [event buttonNumber], GLFW_PRESS );
|
|
}
|
|
|
|
- (void)otherMouseDragged:(NSEvent *)event
|
|
{
|
|
[self mouseMoved:event];
|
|
}
|
|
|
|
- (void)otherMouseUp:(NSEvent *)event
|
|
{
|
|
_glfwInputMouseClick( [event buttonNumber], GLFW_RELEASE );
|
|
}
|
|
|
|
- (void)keyDown:(NSEvent *)event
|
|
{
|
|
NSUInteger length;
|
|
NSString* characters;
|
|
int i, code = convertMacKeyCode( [event keyCode] );
|
|
|
|
if( code != -1 )
|
|
{
|
|
_glfwInputKey( code, GLFW_PRESS );
|
|
|
|
if( [event modifierFlags] & NSCommandKeyMask )
|
|
{
|
|
if( !_glfwWin.sysKeysDisabled )
|
|
{
|
|
[super keyDown:event];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
characters = [event characters];
|
|
length = [characters length];
|
|
|
|
for( i = 0; i < length; i++ )
|
|
{
|
|
_glfwInputChar( [characters characterAtIndex:i], GLFW_PRESS );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)flagsChanged:(NSEvent *)event
|
|
{
|
|
unsigned int newModifierFlags = [event modifierFlags] | NSDeviceIndependentModifierFlagsMask;
|
|
int mode;
|
|
|
|
if( newModifierFlags > _glfwWin.modifierFlags )
|
|
{
|
|
mode = GLFW_PRESS;
|
|
}
|
|
else
|
|
{
|
|
mode = GLFW_RELEASE;
|
|
}
|
|
|
|
_glfwWin.modifierFlags = newModifierFlags;
|
|
_glfwInputKey( MAC_TO_GLFW_KEYCODE_MAPPING[[event keyCode]], mode );
|
|
}
|
|
|
|
- (void)keyUp:(NSEvent *)event
|
|
{
|
|
NSUInteger length;
|
|
NSString* characters;
|
|
int i, code = convertMacKeyCode( [event keyCode] );
|
|
|
|
if( code != -1 )
|
|
{
|
|
_glfwInputKey( code, GLFW_RELEASE );
|
|
|
|
characters = [event characters];
|
|
length = [characters length];
|
|
|
|
for( i = 0; i < length; i++ )
|
|
{
|
|
_glfwInputChar( [characters characterAtIndex:i], GLFW_RELEASE );
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)scrollWheel:(NSEvent *)event
|
|
{
|
|
_glfwInput.WheelPosFloating += [event deltaY];
|
|
_glfwInput.WheelPos = lrint(_glfwInput.WheelPosFloating);
|
|
|
|
if( _glfwWin.mouseWheelCallback )
|
|
{
|
|
_glfwWin.mouseWheelCallback( _glfwInput.WheelPos );
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
//************************************************************************
|
|
//**** Platform implementation functions ****
|
|
//************************************************************************
|
|
|
|
//========================================================================
|
|
// Here is where the window is created, and the OpenGL rendering context is
|
|
// created
|
|
//========================================================================
|
|
|
|
int _glfwPlatformOpenWindow( int width, int height,
|
|
const _GLFWwndconfig *wndconfig,
|
|
const _GLFWfbconfig *fbconfig )
|
|
{
|
|
int colorBits;
|
|
|
|
_glfwWin.pixelFormat = nil;
|
|
_glfwWin.window = nil;
|
|
_glfwWin.context = nil;
|
|
_glfwWin.delegate = nil;
|
|
|
|
// Fail if OpenGL 3.0 or above was requested
|
|
if( wndconfig->glMajor > 2 )
|
|
{
|
|
_glfwPlatformCloseWindow();
|
|
return GL_FALSE;
|
|
}
|
|
|
|
_glfwWin.delegate = [[GLFWWindowDelegate alloc] init];
|
|
if( _glfwWin.delegate == nil )
|
|
{
|
|
_glfwPlatformCloseWindow();
|
|
return GL_FALSE;
|
|
}
|
|
|
|
[NSApp setDelegate:_glfwWin.delegate];
|
|
|
|
// Mac OS X needs non-zero color size, so set resonable values
|
|
colorBits = fbconfig->redBits + fbconfig->greenBits + fbconfig->blueBits;
|
|
if( colorBits == 0 )
|
|
{
|
|
colorBits = 24;
|
|
}
|
|
else if( colorBits < 15 )
|
|
{
|
|
colorBits = 15;
|
|
}
|
|
|
|
// Ignored hints:
|
|
// OpenGLMajor, OpenGLMinor, OpenGLForward:
|
|
// pending Mac OS X support for OpenGL 3.x
|
|
// OpenGLDebug
|
|
// pending it meaning anything on Mac OS X
|
|
|
|
// Don't use accumulation buffer support; it's not accelerated
|
|
// Aux buffers probably aren't accelerated either
|
|
|
|
CFDictionaryRef fullscreenMode = NULL;
|
|
if( wndconfig->mode == GLFW_FULLSCREEN )
|
|
{
|
|
fullscreenMode =
|
|
// I think it's safe to pass 0 to the refresh rate for this function
|
|
// rather than conditionalizing the code to call the version which
|
|
// doesn't specify refresh...
|
|
CGDisplayBestModeForParametersAndRefreshRateWithProperty(
|
|
CGMainDisplayID(),
|
|
colorBits + fbconfig->alphaBits,
|
|
width,
|
|
height,
|
|
wndconfig->refreshRate,
|
|
// Controversial, see macosx_fullscreen.m for discussion
|
|
kCGDisplayModeIsSafeForHardware,
|
|
NULL);
|
|
|
|
width = [[(id)fullscreenMode objectForKey:(id)kCGDisplayWidth] intValue];
|
|
height = [[(id)fullscreenMode objectForKey:(id)kCGDisplayHeight] intValue];
|
|
}
|
|
|
|
unsigned int styleMask = 0;
|
|
if( wndconfig->mode == GLFW_WINDOW )
|
|
{
|
|
styleMask = NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask;
|
|
|
|
if( !wndconfig->windowNoResize )
|
|
{
|
|
styleMask |= NSResizableWindowMask;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
styleMask = NSBorderlessWindowMask;
|
|
}
|
|
|
|
_glfwWin.window = [[NSWindow alloc]
|
|
initWithContentRect:NSMakeRect(0, 0, width, height)
|
|
styleMask:styleMask
|
|
backing:NSBackingStoreBuffered
|
|
defer:NO];
|
|
[_glfwWin.window setContentView:[[GLFWContentView alloc] init]];
|
|
[_glfwWin.window setDelegate:_glfwWin.delegate];
|
|
[_glfwWin.window setAcceptsMouseMovedEvents:YES];
|
|
[_glfwWin.window center];
|
|
|
|
if( wndconfig->mode == GLFW_FULLSCREEN )
|
|
{
|
|
CGCaptureAllDisplays();
|
|
CGDisplaySwitchToMode( CGMainDisplayID(), fullscreenMode );
|
|
}
|
|
|
|
unsigned int attribute_count = 0;
|
|
#define ADD_ATTR(x) attributes[attribute_count++] = x
|
|
#define ADD_ATTR2(x, y) (void)({ ADD_ATTR(x); ADD_ATTR(y); })
|
|
#define MAX_ATTRS 24 // urgh
|
|
NSOpenGLPixelFormatAttribute attributes[MAX_ATTRS];
|
|
|
|
ADD_ATTR( NSOpenGLPFADoubleBuffer );
|
|
|
|
if( wndconfig->mode == GLFW_FULLSCREEN )
|
|
{
|
|
ADD_ATTR( NSOpenGLPFAFullScreen );
|
|
ADD_ATTR( NSOpenGLPFANoRecovery );
|
|
ADD_ATTR2( NSOpenGLPFAScreenMask,
|
|
CGDisplayIDToOpenGLDisplayMask( CGMainDisplayID() ) );
|
|
}
|
|
|
|
ADD_ATTR2( NSOpenGLPFAColorSize, colorBits );
|
|
|
|
if( fbconfig->alphaBits > 0)
|
|
{
|
|
ADD_ATTR2( NSOpenGLPFAAlphaSize, fbconfig->alphaBits );
|
|
}
|
|
|
|
if( fbconfig->depthBits > 0)
|
|
{
|
|
ADD_ATTR2( NSOpenGLPFADepthSize, fbconfig->depthBits );
|
|
}
|
|
|
|
if( fbconfig->stencilBits > 0)
|
|
{
|
|
ADD_ATTR2( NSOpenGLPFAStencilSize, fbconfig->stencilBits );
|
|
}
|
|
|
|
int accumBits = fbconfig->accumRedBits + fbconfig->accumGreenBits +
|
|
fbconfig->accumBlueBits + fbconfig->accumAlphaBits;
|
|
|
|
if( accumBits > 0)
|
|
{
|
|
ADD_ATTR2( NSOpenGLPFAAccumSize, accumBits );
|
|
}
|
|
|
|
if( fbconfig->auxBuffers > 0)
|
|
{
|
|
ADD_ATTR2( NSOpenGLPFAAuxBuffers, fbconfig->auxBuffers );
|
|
}
|
|
|
|
if( fbconfig->stereo)
|
|
{
|
|
ADD_ATTR( NSOpenGLPFAStereo );
|
|
}
|
|
|
|
if( fbconfig->samples > 0)
|
|
{
|
|
ADD_ATTR2( NSOpenGLPFASampleBuffers, 1 );
|
|
ADD_ATTR2( NSOpenGLPFASamples, fbconfig->samples );
|
|
}
|
|
|
|
ADD_ATTR(0);
|
|
|
|
_glfwWin.pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
|
|
if( _glfwWin.pixelFormat == nil )
|
|
{
|
|
_glfwPlatformCloseWindow();
|
|
return GL_FALSE;
|
|
}
|
|
|
|
_glfwWin.context = [[NSOpenGLContext alloc] initWithFormat:_glfwWin.pixelFormat
|
|
shareContext:nil];
|
|
if( _glfwWin.context == nil )
|
|
{
|
|
_glfwPlatformCloseWindow();
|
|
return GL_FALSE;
|
|
}
|
|
|
|
[_glfwWin.window makeKeyAndOrderFront:nil];
|
|
[_glfwWin.context setView:[_glfwWin.window contentView]];
|
|
|
|
if( wndconfig->mode == GLFW_FULLSCREEN )
|
|
{
|
|
// TODO: Make this work on pre-Leopard systems
|
|
[[_glfwWin.window contentView] enterFullScreenMode:[NSScreen mainScreen]
|
|
withOptions:nil];
|
|
}
|
|
|
|
[_glfwWin.context makeCurrentContext];
|
|
|
|
NSPoint point = [[NSCursor currentCursor] hotSpot];
|
|
_glfwInput.MousePosX = point.x;
|
|
_glfwInput.MousePosY = point.y;
|
|
|
|
return GL_TRUE;
|
|
}
|
|
|
|
//========================================================================
|
|
// Properly kill the window / video display
|
|
//========================================================================
|
|
|
|
void _glfwPlatformCloseWindow( void )
|
|
{
|
|
[_glfwWin.window orderOut:nil];
|
|
|
|
if( _glfwWin.fullscreen )
|
|
{
|
|
[[_glfwWin.window contentView] exitFullScreenModeWithOptions:nil];
|
|
CGDisplaySwitchToMode( CGMainDisplayID(),
|
|
(CFDictionaryRef)_glfwLibrary.DesktopMode );
|
|
CGReleaseAllDisplays();
|
|
}
|
|
|
|
[_glfwWin.pixelFormat release];
|
|
_glfwWin.pixelFormat = nil;
|
|
|
|
[NSOpenGLContext clearCurrentContext];
|
|
[_glfwWin.context release];
|
|
_glfwWin.context = nil;
|
|
|
|
[_glfwWin.window setDelegate:nil];
|
|
[NSApp setDelegate:nil];
|
|
[_glfwWin.delegate release];
|
|
_glfwWin.delegate = nil;
|
|
|
|
[_glfwWin.window close];
|
|
_glfwWin.window = nil;
|
|
|
|
// TODO: Probably more cleanup
|
|
}
|
|
|
|
//========================================================================
|
|
// Set the window title
|
|
//========================================================================
|
|
|
|
void _glfwPlatformSetWindowTitle( const char *title )
|
|
{
|
|
[_glfwWin.window setTitle:[NSString stringWithCString:title
|
|
encoding:NSISOLatin1StringEncoding]];
|
|
}
|
|
|
|
//========================================================================
|
|
// Set the window size
|
|
//========================================================================
|
|
|
|
void _glfwPlatformSetWindowSize( int width, int height )
|
|
{
|
|
[_glfwWin.window setContentSize:NSMakeSize(width, height)];
|
|
}
|
|
|
|
//========================================================================
|
|
// Set the window position
|
|
//========================================================================
|
|
|
|
void _glfwPlatformSetWindowPos( int x, int y )
|
|
{
|
|
NSRect contentRect = [_glfwWin.window contentRectForFrameRect:[_glfwWin.window frame]];
|
|
|
|
// We assume here that the client code wants to position the window within the
|
|
// screen the window currently occupies
|
|
NSRect screenRect = [[_glfwWin.window screen] visibleFrame];
|
|
contentRect.origin = NSMakePoint(screenRect.origin.x + x,
|
|
screenRect.origin.y + screenRect.size.height -
|
|
y - contentRect.size.height);
|
|
|
|
[_glfwWin.window setFrame:[_glfwWin.window frameRectForContentRect:contentRect]
|
|
display:YES];
|
|
}
|
|
|
|
//========================================================================
|
|
// Iconify the window
|
|
//========================================================================
|
|
|
|
void _glfwPlatformIconifyWindow( void )
|
|
{
|
|
[_glfwWin.window miniaturize:nil];
|
|
}
|
|
|
|
//========================================================================
|
|
// Restore (un-iconify) the window
|
|
//========================================================================
|
|
|
|
void _glfwPlatformRestoreWindow( void )
|
|
{
|
|
[_glfwWin.window deminiaturize:nil];
|
|
}
|
|
|
|
//========================================================================
|
|
// Swap buffers
|
|
//========================================================================
|
|
|
|
void _glfwPlatformSwapBuffers( void )
|
|
{
|
|
// ARP appears to be unnecessary, but this is future-proof
|
|
[_glfwWin.context flushBuffer];
|
|
}
|
|
|
|
//========================================================================
|
|
// Set double buffering swap interval
|
|
//========================================================================
|
|
|
|
void _glfwPlatformSwapInterval( int interval )
|
|
{
|
|
GLint sync = interval;
|
|
[_glfwWin.context setValues:&sync forParameter:NSOpenGLCPSwapInterval];
|
|
}
|
|
|
|
//========================================================================
|
|
// Write back window parameters into GLFW window structure
|
|
//========================================================================
|
|
|
|
void _glfwPlatformRefreshWindowParams( void )
|
|
{
|
|
GLint value;
|
|
|
|
// Since GLFW 2.x doesn't understand screens, we use virtual screen zero
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFAAccelerated
|
|
forVirtualScreen:0];
|
|
_glfwWin.accelerated = value;
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFAAlphaSize
|
|
forVirtualScreen:0];
|
|
_glfwWin.alphaBits = value;
|
|
|
|
// It seems that the color size includes the size of the alpha channel
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFAColorSize
|
|
forVirtualScreen:0];
|
|
value -= _glfwWin.alphaBits;
|
|
_glfwWin.redBits = value / 3;
|
|
_glfwWin.greenBits = value / 3;
|
|
_glfwWin.blueBits = value / 3;
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFADepthSize
|
|
forVirtualScreen:0];
|
|
_glfwWin.depthBits = value;
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFAStencilSize
|
|
forVirtualScreen:0];
|
|
_glfwWin.stencilBits = value;
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFAAccumSize
|
|
forVirtualScreen:0];
|
|
_glfwWin.accumRedBits = value / 3;
|
|
_glfwWin.accumGreenBits = value / 3;
|
|
_glfwWin.accumBlueBits = value / 3;
|
|
|
|
// TODO: Figure out what to set this value to
|
|
_glfwWin.accumAlphaBits = 0;
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFAAuxBuffers
|
|
forVirtualScreen:0];
|
|
_glfwWin.auxBuffers = value;
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFAStereo
|
|
forVirtualScreen:0];
|
|
_glfwWin.stereo = value;
|
|
|
|
[_glfwWin.pixelFormat getValues:&value
|
|
forAttribute:NSOpenGLPFASamples
|
|
forVirtualScreen:0];
|
|
_glfwWin.samples = value;
|
|
|
|
// These are forced to false as long as Mac OS X lacks support for OpenGL 3.0+
|
|
_glfwWin.glForward = GL_FALSE;
|
|
_glfwWin.glDebug = GL_FALSE;
|
|
_glfwWin.glProfile = 0;
|
|
}
|
|
|
|
//========================================================================
|
|
// Poll for new window and input events
|
|
//========================================================================
|
|
|
|
void _glfwPlatformPollEvents( void )
|
|
{
|
|
NSEvent *event;
|
|
|
|
do
|
|
{
|
|
event = [NSApp nextEventMatchingMask:NSAnyEventMask
|
|
untilDate:[NSDate distantPast]
|
|
inMode:NSDefaultRunLoopMode
|
|
dequeue:YES];
|
|
|
|
if (event)
|
|
{
|
|
[NSApp sendEvent:event];
|
|
}
|
|
}
|
|
while (event);
|
|
|
|
[_glfwLibrary.AutoreleasePool drain];
|
|
_glfwLibrary.AutoreleasePool = [[NSAutoreleasePool alloc] init];
|
|
}
|
|
|
|
//========================================================================
|
|
// Wait for new window and input events
|
|
//========================================================================
|
|
|
|
void _glfwPlatformWaitEvents( void )
|
|
{
|
|
// I wanted to pass NO to dequeue:, and rely on PollEvents to
|
|
// dequeue and send. For reasons not at all clear to me, passing
|
|
// NO to dequeue: causes this method never to return.
|
|
NSEvent *event = [NSApp nextEventMatchingMask:NSAnyEventMask
|
|
untilDate:[NSDate distantFuture]
|
|
inMode:NSDefaultRunLoopMode
|
|
dequeue:YES];
|
|
[NSApp sendEvent:event];
|
|
|
|
_glfwPlatformPollEvents();
|
|
}
|
|
|
|
//========================================================================
|
|
// Hide mouse cursor (lock it)
|
|
//========================================================================
|
|
|
|
void _glfwPlatformHideMouseCursor( void )
|
|
{
|
|
[NSCursor hide];
|
|
CGAssociateMouseAndMouseCursorPosition( false );
|
|
}
|
|
|
|
//========================================================================
|
|
// Show mouse cursor (unlock it)
|
|
//========================================================================
|
|
|
|
void _glfwPlatformShowMouseCursor( void )
|
|
{
|
|
[NSCursor unhide];
|
|
CGAssociateMouseAndMouseCursorPosition( true );
|
|
}
|
|
|
|
//========================================================================
|
|
// Set physical mouse cursor position
|
|
//========================================================================
|
|
|
|
void _glfwPlatformSetMouseCursorPos( int x, int y )
|
|
{
|
|
// The library seems to assume that after calling this the mouse won't move,
|
|
// but obviously it will, and escape the app's window, and activate other apps,
|
|
// and other badness in pain. I think the API's just silly, but maybe I'm
|
|
// misunderstanding it...
|
|
|
|
// Also, (x, y) are window coords...
|
|
|
|
// Also, it doesn't seem possible to write this robustly without
|
|
// calculating the maximum y coordinate of all screens, since Cocoa's
|
|
// "global coordinates" are upside down from CG's...
|
|
|
|
// Without this (once per app run, but it's convenient to do it here)
|
|
// events will be suppressed for a default of 0.25 seconds after we
|
|
// move the cursor.
|
|
CGSetLocalEventsSuppressionInterval( 0.0 );
|
|
|
|
NSPoint localPoint = NSMakePoint( x, y );
|
|
NSPoint globalPoint = [_glfwWin.window convertBaseToScreen:localPoint];
|
|
CGPoint mainScreenOrigin = CGDisplayBounds( CGMainDisplayID() ).origin;
|
|
double mainScreenHeight = CGDisplayBounds( CGMainDisplayID() ).size.height;
|
|
CGPoint targetPoint = CGPointMake( globalPoint.x - mainScreenOrigin.x,
|
|
mainScreenHeight - globalPoint.y - mainScreenOrigin.y );
|
|
CGDisplayMoveCursorToPoint( CGMainDisplayID(), targetPoint );
|
|
}
|
|
|