MyOpenGLView Class Reference

#include <MyOpenGLView.h>

Inheritance diagram for MyOpenGLView:

Collaboration diagram for MyOpenGLView:

Instance Methods
(void)	- initKeyMappingData
(void)	- setStringInput:
(void)	- allowStringInput:
(enum StringInput)	- allowingStringInput
(NSString *)	- typedString
(void)	- resetTypedString
(void)	- setTypedString:
(NSSize)	- viewSize
(NSSize)	- backingViewSize
(GLfloat)	- display_z
(GLfloat)	- x_offset
(GLfloat)	- y_offset
(GameController *)	- gameController
(void)	- setGameController:
(void)	- noteMouseInteractionModeChangedFrom:to:
(void)	- initialiseGLWithSize:
(NSData *)	- pixelFormatAttributes
(void)	- drawRect:
(void)	- updateScreen
(void)	- pollControls
(void)	- stringToClipboard:
(BOOL)	- snapShot:
(void)	- mouseDown:
(void)	- mouseUp:
(void)	- resetMouse
(void)	- setVirtualJoystick:vmx:
(NSPoint)	- virtualJoystickPosition
(void)	- clearKeys
(void)	- clearMouse
(void)	- clearKey:
(BOOL)	- isAlphabetKeyDown
(void)	- suppressKeysUntilKeyUp
(BOOL)	- isDown:
(BOOL)	- isOptDown
(BOOL)	- isCtrlDown
(BOOL)	- isCommandDown
(BOOL)	- isShiftDown
(BOOL)	- isCapsLockOn
(BOOL)	- lastKeyWasShifted
(int)	- numKeys
(int)	- mouseWheelState
(float)	- mouseWheelDelta
(void)	- setMouseWheelDelta:
(BOOL)	- isCommandQDown
(BOOL)	- isCommandFDown
(void)	- clearCommandF
(OOOpenGLMatrixManager *)	- getOpenGLMatrixManager
(void)	- dumpRGBAToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpRGBToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpGrayToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpGrayAlphaToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpRGBAToRGBFileNamed:andGrayFileNamed:bytes:width:height:rowBytes:
(void)	- setGammaValue:
(float)	- gammaValue
(void)	- setFov:fromFraction:
(float)	- fov:
(id)	- init
(void)	- initSplashScreen
(void)	- endSplashScreen
(void)	- autoShowMouse
(void)	- initKeyMappingData
(void)	- setStringInput:
(void)	- allowStringInput:
(enum StringInput)	- allowingStringInput
(NSString *)	- typedString
(void)	- resetTypedString
(void)	- setTypedString:
(NSSize)	- viewSize
(NSSize)	- backingViewSize
(GLfloat)	- display_z
(GLfloat)	- x_offset
(GLfloat)	- y_offset
(GameController *)	- gameController
(void)	- setGameController:
(void)	- noteMouseInteractionModeChangedFrom:to:
(void)	- initialiseGLWithSize:
(void)	- initialiseGLWithSize:useVideoMode:
(BOOL)	- isRunningOnPrimaryDisplayDevice
(float)	- colorSaturation
(void)	- adjustColorSaturation:
(BOOL)	- hdrOutput
(BOOL)	- isOutputDisplayHDREnabled
(void)	- grabMouseInsideGameWindow:
(void)	- stringToClipboard:
(void)	- drawRect:
(void)	- updateScreen
(void)	- updateScreenWithVideoMode:
(void)	- display
(BOOL)	- snapShot:
(BOOL)	- pngSaveSurface:withSurface:
(NSRect)	- bounds
(void)	- setFullScreenMode:
(BOOL)	- inFullScreenMode
(void)	- toggleScreenMode
(void)	- setDisplayMode:fullScreen:
(int)	- indexOfCurrentSize
(void)	- setScreenSize:
(NSMutableArray *)	- getScreenSizeArray
(void)	- populateFullScreenModelist
(NSSize)	- modeAsSize:
(void)	- saveWindowSize:
(NSSize)	- loadWindowSize
(int)	- loadFullscreenSettings
(int)	- findDisplayModeForWidth:Height:Refresh:
(NSSize)	- currentScreenSize
(void)	- pollControls
(void)	- setVirtualJoystick:vmx:
(NSPoint)	- virtualJoystickPosition
(void)	- clearKeys
(void)	- clearMouse
(void)	- clearKey:
(void)	- resetMouse
(BOOL)	- isAlphabetKeyDown
(void)	- suppressKeysUntilKeyUp
(BOOL)	- isDown:
(BOOL)	- isOptDown
(BOOL)	- isCtrlDown
(BOOL)	- isCommandDown
(BOOL)	- isShiftDown
(BOOL)	- isCapsLockOn
(BOOL)	- lastKeyWasShifted
(int)	- numKeys
(int)	- mouseWheelState
(float)	- mouseWheelDelta
(void)	- setMouseWheelDelta:
(BOOL)	- isCommandQDown
(BOOL)	- isCommandFDown
(void)	- clearCommandF
(void)	- setMouseInDeltaMode:
(void)	- setGammaValue:
(float)	- gammaValue
(void)	- setFov:fromFraction:
(float)	- fov:
(void)	- setMsaa:
(BOOL)	- msaa
(OOOpenGLMatrixManager *)	- getOpenGLMatrixManager
(void)	- dumpRGBAToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpRGBToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpGrayToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpGrayAlphaToFileNamed:bytes:width:height:rowBytes:
(void)	- dumpRGBAToRGBFileNamed:andGrayFileNamed:bytes:width:height:rowBytes:
(id)	- initWithFrame: [implementation]
(void)	- dealloc [implementation]
(void)	- noteMovedToBadDisplay [implementation]
(void)	- update [implementation]
(BOOL)	- acceptsFirstResponder [implementation]
(void)	- keyUp: [implementation]
(void)	- keyDown: [implementation]
(void)	- flagsChanged: [implementation]
(void)	- mouseMoved: [implementation]
(void)	- mouseDragged: [implementation]
(void)	- scrollWheel: [implementation]
(void)	- otherMouseDragged: [implementation]
(void)	- rightMouseDown: [implementation]
(void)	- rightMouseUp: [implementation]
(void)	- touchesEndedWithEvent: [implementation]
(void)	- recenterVirtualJoystick [implementation]
(int)	- translateKeyCode: [implementation]
(void)	- createSurface [implementation]
(void)	- resetSDLKeyModifiers [implementation]
(void)	- setWindowBorderless: [implementation]
(void)	- handleStringInput:keyID: [implementation]
(BOOL)	- isCommandModifierKeyDown [implementation]

Class Methods
(BOOL)	+ pollShiftKey
(NSMutableDictionary *)	+ getNativeSize
(BOOL)	+ pollShiftKey
(static void)	+ GetDesiredCursorState [implementation]
(static void)	+ ApplyCursorState [implementation]
(static void)	+ UnapplyCursorState [implementation]

Protected Attributes
NSPoint	mouseDragStartPoint
BOOL	mouseWarped
NSTimeInterval	timeSinceLastMouseWheel
double	squareX
double	squareY
NSRect	bounds
float	_gamma
BOOL	_msaa
NSMutableArray *	screenSizes
int	currentSize
BOOL	fullScreen
NSSize	currentWindowSize
SDL_Surface *	surface
BOOL	showSplashScreen
float	_colorSaturation
BOOL	_hdrOutput
BOOL	grabMouseStatus
NSSize	firstScreen
BOOL	mouseInDeltaMode

Private Attributes
GameController *	gameController
BOOL	keys [NUM_KEYS]
int	scancode2Unicode [NUM_KEYS]
NSDictionary *	keyMappings_normal
NSDictionary *	keyMappings_shifted
BOOL	suppressKeys
BOOL	opt
BOOL	ctrl
BOOL	command
BOOL	shift
BOOL	capsLockOn
BOOL	lastKeyShifted
BOOL	allowingStringInput
BOOL	isAlphabetKeyDown
BOOL	commandQ
BOOL	commandF
BOOL	f12
int	keycodetrans [255]
BOOL	m_glContextInitialized
NSTimeInterval	timeIntervalAtLastClick
NSTimeInterval	timeIntervalAtLastMouseWheel
BOOL	doubleClick
NSMutableString *	typedString
NSPoint	virtualJoystickPosition
float	_mouseWheelDelta
NSSize	viewSize
NSSize	backingViewSize
GLfloat	display_z
GLfloat	x_offset
GLfloat	y_offset
float	_fov
int	_virtualScreen
NSData *	_pixelFormatAttributes
OOOpenGLMatrixManager *	matrixManager

Detailed Description

Definition at line 123 of file MyOpenGLView.h.

Method Documentation

acceptsFirstResponder

- (BOOL) acceptsFirstResponder

implementation

Definition at line 50 of file MyOpenGLView.m.

{
    return YES;
}

adjustColorSaturation:

- (void) adjustColorSaturation:

(float)

colorSaturationAdjustment

Definition at line 50 of file MyOpenGLView.m.

                              :(float)colorSaturationAdjustment;
{
    _colorSaturation += colorSaturationAdjustment;
    _colorSaturation = OOClamp_0_max_f(_colorSaturation, MAX_COLOR_SATURATION);
}

Referenced by GlobalSetColorSaturation().

Here is the caller graph for this function:

allowingStringInput [1/2]

- (enum StringInput) allowingStringInput

allowingStringInput [2/2]

- (enum StringInput) allowingStringInput

allowStringInput: [1/2]

- (void) allowStringInput:

(BOOL)

value

Definition at line 50 of file MyOpenGLView.m.

                         :(BOOL)value
{
    if (value)
    {
        allowingStringInput = gvStringInputAlpha;
    }
    else
    {
        allowingStringInput = gvStringInputNo;
    }
}

allowStringInput: [2/2]

- (void) allowStringInput:

(BOOL)

value

ApplyCursorState

+ (static void) ApplyCursorState (OOMouseInteractionMode) mode

implementation

Definition at line 1341 of file MyOpenGLView.m.

{
    BOOL hidden, obscured;
    GetDesiredCursorState(mode, &hidden, &obscured);
    if (hidden)  [NSCursor hide];
    if (obscured)  [NSCursor setHiddenUntilMouseMoves:YES];
}

References GetDesiredCursorState().

Here is the call graph for this function:

autoShowMouse

- (void) autoShowMouse

Definition at line 50 of file MyOpenGLView.m.

{
    //don't touch the 'please wait...' cursor.
    if (fullScreen)
    {
        if (SDL_ShowCursor(SDL_QUERY) == SDL_ENABLE)
            SDL_ShowCursor(SDL_DISABLE);
    }
    else
    {
        if (SDL_ShowCursor(SDL_QUERY) == SDL_DISABLE)
            SDL_ShowCursor(SDL_ENABLE);
    }
}

backingViewSize [1/2]

- (NSSize) backingViewSize

backingViewSize [2/2]

- (NSSize) backingViewSize

bounds

- (NSRect) bounds

clearCommandF [1/2]

- (void) clearCommandF

Definition at line 50 of file MyOpenGLView.m.

{
    commandF = NO;
}

clearCommandF [2/2]

- (void) clearCommandF

clearKey: [1/2]

- (void) clearKey:

(int)

theKey

Definition at line 50 of file MyOpenGLView.m.

                 : (int)theKey
{
    if (theKey >= 0 && theKey < [self numKeys])
    {
        keys[theKey] = NO;
    }
}

clearKey: [2/2]

- (void) clearKey:

(int)

theKey

clearKeys [1/2]

- (void) clearKeys

Definition at line 50 of file MyOpenGLView.m.

{
    int i;
    lastKeyShifted = NO;
    for (i = 0; i < [self numKeys]; i++)
        keys[i] = NO;
}

clearKeys [2/2]

- (void) clearKeys

clearMouse [1/2]

- (void) clearMouse

Definition at line 50 of file MyOpenGLView.m.

{
    keys[gvMouseDoubleClick] = NO;
    keys[gvMouseLeftButton] = NO;
    doubleClick = NO;
}

clearMouse [2/2]

- (void) clearMouse

colorSaturation

- (float) colorSaturation

Definition at line 50 of file MyOpenGLView.m.

{
    return _colorSaturation;
}

Referenced by GlobalSetColorSaturation().

Here is the caller graph for this function:

createSurface

- (void) createSurface

implementation

Definition at line 50 of file MyOpenGLView.m.

{
    // Changing these flags can trigger texture bugs.
    const int videoModeFlags = SDL_HWSURFACE | SDL_OPENGL | SDL_RESIZABLE;
 
    if (showSplashScreen)
    {
#if OOLITE_WINDOWS
        // Pre setVideoMode adjustments.
        NSSize tmp = currentWindowSize;
        ShowWindow(SDL_Window,SW_SHOWMINIMIZED);
        updateContext = NO; //don't update the (splash screen) window yet!
 
        // Initialise the SDL surface. (need custom SDL.dll)
        surface = SDL_SetVideoMode(firstScreen.width, firstScreen.height, 32, videoModeFlags);
 
        // Post setVideoMode adjustments.
        currentWindowSize=tmp;
#else
        // Changing the flags can trigger texture bugs.
        surface = SDL_SetVideoMode(8, 8, 32, videoModeFlags);
#endif
        if (!surface) {
            return;
        }
    }
    else
    {
#if OOLITE_WINDOWS
        updateContext = YES;
#endif
        surface = SDL_SetVideoMode(firstScreen.width, firstScreen.height, 32, videoModeFlags);
        if (!surface) {
            return;
        }
        // blank the surface / go to fullscreen
        [self initialiseGLWithSize: firstScreen];
    }
 
    _gamma = 1.0f;
    if (SDL_SetGamma(_gamma, _gamma, _gamma) < 0 )
    {
        char * errStr = SDL_GetError();
        OOLogWARN(@"gamma.set.failed", @"Could not set gamma: %s", errStr);
        // CIM: this doesn't seem to necessarily be fatal. Gamma settings
        // mostly work on mine despite this function failing.
        //  exit(1);
    }
    SDL_EnableUNICODE(1);
}

currentScreenSize

- (NSSize) currentScreenSize

Definition at line 50 of file MyOpenGLView.m.

{
    NSDictionary *mode=[screenSizes objectAtIndex: currentSize];
 
    if(mode)
    {
        return NSMakeSize([[mode objectForKey: kOODisplayWidth] intValue],
                [[mode objectForKey: kOODisplayHeight] intValue]);
    }
    OOLog(@"display.mode.unknown", @"%@", @"Screen size unknown!");
    return NSMakeSize(WINDOW_SIZE_DEFAULT_WIDTH, WINDOW_SIZE_DEFAULT_HEIGHT);
}

dealloc

- (void) dealloc

implementation

Definition at line 50 of file MyOpenGLView.m.

{
    DESTROY(typedString);
    DESTROY(_pixelFormatAttributes);
    DESTROY(matrixManager);
    
    if (keyMappings_normal)
        [keyMappings_normal release];
    if (keyMappings_shifted)
        [keyMappings_shifted release];
 
    [super dealloc];
}

display

- (void) display

Definition at line 50 of file MyOpenGLView.m.

{
    [self updateScreen];
}

display_z [1/2]

- (GLfloat) display_z

display_z [2/2]

- (GLfloat) display_z

drawRect: [1/2]

- (void) drawRect:

(NSRect)

rect

Definition at line 50 of file MyOpenGLView.m.

                 :(NSRect)rect
{
    if ((viewSize.width != [self frame].size.width)||(viewSize.height != [self frame].size.height)) // resized
    {
        m_glContextInitialized = NO;
        viewSize = [self frame].size;
    }
    
    if (!m_glContextInitialized)  [self initialiseGLWithSize:viewSize];
    
    // do all the drawing!
    if (UNIVERSE != nil)  [UNIVERSE drawUniverse];
    else
    {
        // not set up yet, draw a black screen
        OOGL(glClearColor(0.0, 0.0, 0.0, 0.0));
        OOGL(glClear(GL_COLOR_BUFFER_BIT));
    }
    
    [[self openGLContext] flushBuffer];
}

drawRect: [2/2]

- (void) drawRect:

(NSRect)

rect

dumpGrayAlphaToFileNamed:bytes:width:height:rowBytes: [1/2]

- (void) dumpGrayAlphaToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

Definition at line 50 of file MyOpenGLView.m.

                                 :(NSString *)name
                            bytes:(uint8_t *)bytes
                            width:(NSUInteger)width
                           height:(NSUInteger)height
                         rowBytes:(NSUInteger)rowBytes
{
    if (name == nil || bytes == NULL || width == 0 || height == 0 || rowBytes < width * 2)  return;
    
    NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:&bytes
                                                                       pixelsWide:width
                                                                       pixelsHigh:height
                                                                    bitsPerSample:8
                                                                  samplesPerPixel:2
                                                                         hasAlpha:YES
                                                                         isPlanar:NO
                                                                   colorSpaceName:NSCalibratedWhiteColorSpace
                                                                      bytesPerRow:rowBytes
                                                                     bitsPerPixel:16];
    
    if (bitmap != nil)
    {
        [bitmap autorelease];
        
        NSString *filepath = [[[[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent] stringByAppendingPathComponent:name] stringByAppendingPathExtension:@"png"];
        [[bitmap representationUsingType:NSPNGFileType properties:[NSDictionary dictionary]] writeToFile:filepath atomically:YES];
    }
}

Referenced by OODumpPixMap().

Here is the caller graph for this function:

dumpGrayAlphaToFileNamed:bytes:width:height:rowBytes: [2/2]

- (void) dumpGrayAlphaToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

dumpGrayToFileNamed:bytes:width:height:rowBytes: [1/2]

- (void) dumpGrayToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

Definition at line 50 of file MyOpenGLView.m.

                            :(NSString *)name
                       bytes:(uint8_t *)bytes
                       width:(NSUInteger)width
                      height:(NSUInteger)height
                    rowBytes:(NSUInteger)rowBytes
{
    if (name == nil || bytes == NULL || width == 0 || height == 0 || rowBytes < width)  return;
    
    NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:&bytes
                                                                       pixelsWide:width
                                                                       pixelsHigh:height
                                                                    bitsPerSample:8
                                                                  samplesPerPixel:1
                                                                         hasAlpha:NO
                                                                         isPlanar:NO
                                                                   colorSpaceName:NSCalibratedWhiteColorSpace
                                                                      bytesPerRow:rowBytes
                                                                     bitsPerPixel:8];
    
    if (bitmap != nil)
    {
        [bitmap autorelease];
        
        NSString *filepath = [[[[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent] stringByAppendingPathComponent:name] stringByAppendingPathExtension:@"png"];
        [[bitmap representationUsingType:NSPNGFileType properties:[NSDictionary dictionary]] writeToFile:filepath atomically:YES];
    }
}

Referenced by OODumpPixMap().

Here is the caller graph for this function:

dumpGrayToFileNamed:bytes:width:height:rowBytes: [2/2]

- (void) dumpGrayToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

dumpRGBAToFileNamed:bytes:width:height:rowBytes: [1/2]

- (void) dumpRGBAToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

Definition at line 50 of file MyOpenGLView.m.

                            :(NSString *)name
                       bytes:(uint8_t *)bytes
                       width:(NSUInteger)width
                      height:(NSUInteger)height
                    rowBytes:(NSUInteger)rowBytes
{
    if (name == nil || bytes == NULL || width == 0 || height == 0 || rowBytes < width * 4)  return;
    
    NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:&bytes
                                                                       pixelsWide:width
                                                                       pixelsHigh:height
                                                                    bitsPerSample:8
                                                                  samplesPerPixel:4
                                                                         hasAlpha:YES
                                                                         isPlanar:NO
                                                                   colorSpaceName:NSCalibratedRGBColorSpace
                                                                      bytesPerRow:rowBytes
                                                                     bitsPerPixel:32];
    
    if (bitmap != nil)
    {
        [bitmap autorelease];
        
        NSString *filepath = [[[[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent] stringByAppendingPathComponent:name] stringByAppendingPathExtension:@"png"];
        [[bitmap representationUsingType:NSPNGFileType properties:[NSDictionary dictionary]] writeToFile:filepath atomically:YES];
    }
}

dumpRGBAToFileNamed:bytes:width:height:rowBytes: [2/2]

- (void) dumpRGBAToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

dumpRGBAToRGBFileNamed:andGrayFileNamed:bytes:width:height:rowBytes: [1/2]

- (void) dumpRGBAToRGBFileNamed:		(NSString *)	rgbName
andGrayFileNamed:		(NSString *)	grayName
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

Definition at line 50 of file MyOpenGLView.m.

                               :(NSString *)rgbName
               andGrayFileNamed:(NSString *)grayName
                          bytes:(uint8_t *)bytes
                          width:(NSUInteger)width
                         height:(NSUInteger)height
                       rowBytes:(NSUInteger)rowBytes
{
    if ((rgbName == nil && grayName == nil) || bytes == NULL || width == 0 || height == 0 || rowBytes < width * 4)  return;
    
    uint8_t             *rgbBytes, *rgbPx, *grayBytes, *grayPx, *srcPx;
    NSUInteger          x, y;
    BOOL                trivalAlpha = YES;
    
    rgbPx = rgbBytes = malloc(width * height * 3);
    if (rgbBytes == NULL)  return;
    
    grayPx = grayBytes = malloc(width * height);
    if (grayBytes == NULL)
    {
        free(rgbBytes);
        return;
    }
    
    for (y = 0; y < height; y++)
    {
        srcPx = bytes + rowBytes * y;
        
        for (x = 0; x < width; x++)
        {
            *rgbPx++ = *srcPx++;
            *rgbPx++ = *srcPx++;
            *rgbPx++ = *srcPx++;
            trivalAlpha = trivalAlpha && ((*srcPx == 0xFF) || (*srcPx == 0x00));    // Look for any "interesting" pixels in alpha.
            *grayPx++ = *srcPx++;
        }
    }
    
    [self dumpRGBToFileNamed:rgbName
                       bytes:rgbBytes
                       width:width
                      height:height
                    rowBytes:width * 3];
    free(rgbBytes);
    
    if (!trivalAlpha)
    {
        [self dumpGrayToFileNamed:grayName
                            bytes:grayBytes
                            width:width
                           height:height
                         rowBytes:width];
    }
    free(grayBytes);
}

Referenced by OODumpPixMap().

Here is the caller graph for this function:

dumpRGBAToRGBFileNamed:andGrayFileNamed:bytes:width:height:rowBytes: [2/2]

- (void) dumpRGBAToRGBFileNamed:		(NSString *)	rgbName
andGrayFileNamed:		(NSString *)	grayName
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

dumpRGBToFileNamed:bytes:width:height:rowBytes: [1/2]

- (void) dumpRGBToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

Definition at line 50 of file MyOpenGLView.m.

                           :(NSString *)name
                      bytes:(uint8_t *)bytes
                      width:(NSUInteger)width
                     height:(NSUInteger)height
                   rowBytes:(NSUInteger)rowBytes
{
    if (name == nil || bytes == NULL || width == 0 || height == 0 || rowBytes < width * 3)  return;
    
    NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:&bytes
                                                                       pixelsWide:width
                                                                       pixelsHigh:height
                                                                    bitsPerSample:8
                                                                  samplesPerPixel:3
                                                                         hasAlpha:NO
                                                                         isPlanar:NO
                                                                   colorSpaceName:NSCalibratedRGBColorSpace
                                                                      bytesPerRow:rowBytes
                                                                     bitsPerPixel:24];
    
    if (bitmap != nil)
    {
        [bitmap autorelease];
        
        NSString *filepath = [[[[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent] stringByAppendingPathComponent:name] stringByAppendingPathExtension:@"png"];
        [[bitmap representationUsingType:NSPNGFileType properties:[NSDictionary dictionary]] writeToFile:filepath atomically:YES];
    }
}

dumpRGBToFileNamed:bytes:width:height:rowBytes: [2/2]

- (void) dumpRGBToFileNamed:		(NSString *)	name
bytes:		(uint8_t *)	bytes
width:		(NSUInteger)	width
height:		(NSUInteger)	height
rowBytes:		(NSUInteger)	rowBytes

endSplashScreen

- (void) endSplashScreen

Definition at line 50 of file MyOpenGLView.m.

{
#if OOLITE_WINDOWS
    if ([self hdrOutput] && ![self isOutputDisplayHDREnabled])
    {
        if (MessageBox(NULL,    "No primary display in HDR mode was detected.\n\n"
                            "If you continue, graphics will not be rendered as intended.\n"
                            "Click OK to launch anyway, or Cancel to exit.", "oolite.exe - HDR requested",
                            MB_OKCANCEL | MB_ICONWARNING) == IDCANCEL)
        {
            exit (1);
        }
    }
#endif // OOLITE_WINDOWS
    
    if (!showSplashScreen) return;
 
#if OOLITE_WINDOWS
 
    wasFullScreen = !fullScreen;
    updateContext = YES;
    ShowWindow(SDL_Window,SW_RESTORE);
    [self initialiseGLWithSize: firstScreen];
 
#else
 
    int videoModeFlags = SDL_HWSURFACE | SDL_OPENGL;
 
    videoModeFlags |= (fullScreen) ? SDL_FULLSCREEN : SDL_RESIZABLE;
    surface = SDL_SetVideoMode(firstScreen.width, firstScreen.height, 32, videoModeFlags);
 
    if (!surface && fullScreen == YES)
    {
        [self setFullScreenMode: NO];
        videoModeFlags &= ~SDL_FULLSCREEN;
        videoModeFlags |= SDL_RESIZABLE;
        surface = SDL_SetVideoMode(currentWindowSize.width, currentWindowSize.height, 32, videoModeFlags);
    }
 
    SDL_putenv ("SDL_VIDEO_WINDOW_POS=none"); //stop linux from auto centering on resize
 
    /* MKW 2011.11.11
     * Eat all SDL events to gobble up any resize events while the
     * splash-screen was visible.  They affected the main window after 1.74.
     * TODO: should really process SDL events while showing the splash-screen
 
    int numEvents = 0;
    */
    SDL_Event dummyEvent;
    while (SDL_PollEvent(&dummyEvent))
    {
        /* Do nothing; the below is for development info
        numEvents++;
        OOLog(@"display.splash", @"Suppressed splash-screen event %d: %d ", numEvents, dummyEvent.type);
        */
    }
 
 
#endif
 
    [self updateScreen];
    [self autoShowMouse];
}

findDisplayModeForWidth:Height:Refresh:

- (int) findDisplayModeForWidth:		(unsigned int)	d_width
Height:		(unsigned int)	d_height
Refresh:		(unsigned int)	d_refresh

Definition at line 50 of file MyOpenGLView.m.

                               :(unsigned int) d_width Height:(unsigned int) d_height Refresh:(unsigned int) d_refresh
{
    int i, modeCount;
    NSDictionary *mode;
    unsigned int modeWidth, modeHeight, modeRefresh;
 
    modeCount = [screenSizes count];
 
    for (i = 0; i < modeCount; i++)
    {
        mode = [screenSizes objectAtIndex: i];
        modeWidth = [[mode objectForKey: kOODisplayWidth] intValue];
        modeHeight = [[mode objectForKey: kOODisplayHeight] intValue];
        modeRefresh = [[mode objectForKey: kOODisplayRefreshRate] intValue];
        if ((modeWidth == d_width)&&(modeHeight == d_height)&&(modeRefresh == d_refresh))
        {
            OOLog(@"display.mode.found", @"Found mode %@", mode);
            return i;
        }
    }
 
    OOLog(@"display.mode.found.failed", @"Failed to find mode: width=%d height=%d refresh=%d", d_width, d_height, d_refresh);
    OOLog(@"display.mode.found.failed.list", @"Contents of list: %@", screenSizes);
    return 0;
}

flagsChanged:

- (void) flagsChanged: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                    :(NSEvent *)theEvent
{
    NSUInteger flags = [theEvent modifierFlags];
    opt = (flags & NSAlternateKeyMask) ? YES : NO;
    ctrl = (flags & NSControlKeyMask) ? YES : NO;
    command = (flags & NSCommandKeyMask) ? YES : NO;
    shift = ( flags & NSShiftKeyMask ) ? YES : NO;
    if ([theEvent keyCode] == 0x39) // 57 = key code for caps lock
    {
        capsLockOn = (flags & NSAlphaShiftKeyMask) ? YES : NO;
    }
}

fov: [1/2]

- (float) fov:

(BOOL)

inFraction

Definition at line 1350 of file MyOpenGLView.m.

             :(BOOL)inFraction
{
    return inFraction ? _fov : 2 * atanf(_fov) * 180.0f / M_PI;
}

References GetDesiredCursorState().

Referenced by HeadUpDisplay::drawScannerGrid.

Here is the call graph for this function:

Here is the caller graph for this function:

fov: [2/2]

- (float) fov:

(BOOL)

inFraction

gameController [1/2]

- (GameController *) gameController

gameController [2/2]

- (GameController *) gameController

gammaValue [1/2]

- (float) gammaValue

Definition at line 1350 of file MyOpenGLView.m.

{
    return 1.0;
}

gammaValue [2/2]

- (float) gammaValue

GetDesiredCursorState

+ (static void) GetDesiredCursorState (OOMouseInteractionMode) mode (BOOL *) outHidden (BOOL *) outObscured

implementation

Definition at line 1332 of file MyOpenGLView.m.

{
    NSCParameterAssert(outHidden != NULL && outObscured != NULL);
    
    *outHidden = (mode == MOUSE_MODE_FLIGHT_WITH_MOUSE_CONTROL);
    *outObscured = (mode == MOUSE_MODE_FLIGHT_NO_MOUSE_CONTROL);
}

References MOUSE_MODE_FLIGHT_NO_MOUSE_CONTROL, and MOUSE_MODE_FLIGHT_WITH_MOUSE_CONTROL.

getNativeSize

+ (NSMutableDictionary *) getNativeSize

Definition at line 50 of file MyOpenGLView.m.

{
    NSMutableDictionary *mode=[[NSMutableDictionary alloc] init];
    int nativeDisplayWidth = 1024;
    int nativeDisplayHeight = 768;
 
#if OOLITE_LINUX
    SDL_SysWMinfo  dpyInfo;
    SDL_VERSION(&dpyInfo.version);
    if(SDL_GetWMInfo(&dpyInfo))
    {
        nativeDisplayWidth = DisplayWidth(dpyInfo.info.x11.display, 0);
        nativeDisplayHeight = DisplayHeight(dpyInfo.info.x11.display, 0);
        OOLog(@"display.mode.list.native", @"X11 native resolution detected: %d x %d", nativeDisplayWidth, nativeDisplayHeight);
    }
    else
    {
        OOLog(@"display.mode.list.native.failed", @"%@", @"SDL_GetWMInfo failed, defaulting to 1024x768 for native size");
    }
#elif OOLITE_WINDOWS
    nativeDisplayWidth = GetSystemMetrics(SM_CXSCREEN);
    nativeDisplayHeight = GetSystemMetrics(SM_CYSCREEN);
    OOLog(@"display.mode.list.native", @"Windows native resolution detected: %d x %d", nativeDisplayWidth, nativeDisplayHeight);
#else
    OOLog(@"display.mode.list.native.unknown", @"Unknown architecture, defaulting to 1024x768");
#endif
    [mode setValue: [NSNumber numberWithInt: nativeDisplayWidth] forKey:kOODisplayWidth];
    [mode setValue: [NSNumber numberWithInt: nativeDisplayHeight] forKey: kOODisplayHeight];
    [mode setValue: [NSNumber numberWithInt: 0] forKey: kOODisplayRefreshRate];
 
    return [mode autorelease];
}

getOpenGLMatrixManager [1/2]

- (OOOpenGLMatrixManager *) getOpenGLMatrixManager

Definition at line 50 of file MyOpenGLView.m.

{
    return matrixManager;
}

getOpenGLMatrixManager [2/2]

- (OOOpenGLMatrixManager *) getOpenGLMatrixManager

getScreenSizeArray

- (NSMutableArray *) getScreenSizeArray

grabMouseInsideGameWindow:

- (void) grabMouseInsideGameWindow:

(BOOL)

value

Definition at line 50 of file MyOpenGLView.m.

                                  :(BOOL) value
{
    // do nothing
}

handleStringInput:keyID:

- (void) handleStringInput: (SDL_KeyboardEvent *) kbd_event keyID: (Uint16) key_id

implementation

Provided by category MyOpenGLView(OOPrivate).

Definition at line 50 of file MyOpenGLView.m.

                          : (SDL_KeyboardEvent *) kbd_event keyID:(Uint16)key_id;
{
    SDLKey key=kbd_event->keysym.sym;
 
    // Del, Backspace
    if((key == SDLK_BACKSPACE || key == SDLK_DELETE) && [typedString length] > 0)
    {
        // delete
        [typedString deleteCharactersInRange:NSMakeRange([typedString length]-1, 1)];
    }
 
    isAlphabetKeyDown=NO;
 
    // TODO: a more flexible mechanism  for max. string length ?
    if([typedString length] < 40)
    {
        lastKeyShifted = shift;
        if (allowingStringInput == gvStringInputAlpha)
        {
            // inputAlpha - limited input for planet find screen
            if(key >= SDLK_a && key <= SDLK_z)
            {
                isAlphabetKeyDown=YES;
                [typedString appendFormat:@"%c", key];
                // if in inputAlpha, keep in lower case.
            }
        }
        else
        {
            //Uint16 unicode = kbd_event->keysym.unicode;
            // printable range
            if (key_id >= 32 && key_id <= 255) // 126
            {
                if ((char)key_id != '/' || allowingStringInput == gvStringInputAll)
                {
                    isAlphabetKeyDown=YES;
                    [typedString appendFormat:@"%c", key_id];
                }
            }
        }
    }
}

hdrOutput

- (BOOL) hdrOutput

Definition at line 50 of file MyOpenGLView.m.

{
    return NO;
}

indexOfCurrentSize

- (int) indexOfCurrentSize

inFullScreenMode

- (BOOL) inFullScreenMode

Definition at line 50 of file MyOpenGLView.m.

{
    return fullScreen;
}

initialiseGLWithSize: [1/2]

- (void) initialiseGLWithSize:

(NSSize)

v_size

Definition at line 50 of file MyOpenGLView.m.

                             :(NSSize)v_size
{
    viewSize = v_size;
    if (viewSize.width/viewSize.height > 4.0/3.0) {
        display_z = 480.0 * viewSize.width/viewSize.height;
        x_offset = 240.0 * viewSize.width/viewSize.height;
        y_offset = 240.0;
    } else {
        display_z = 640.0;
        x_offset = 320.0;
        y_offset = 320.0 * viewSize.height/viewSize.width;
    }
    
    if ([self respondsToSelector:@selector(convertSizeToBacking:)])
    {
        // High resolution mode support.
        backingViewSize = [self convertSizeToBacking:viewSize];
    }
    else
    {
        backingViewSize = viewSize;
    }
    
    [self openGLContext];   // Force lazy setup if needed.
    [[self gameController] setUpBasicOpenGLStateWithSize:v_size];
    [[self openGLContext] flushBuffer];
    
    m_glContextInitialized = YES;
}

initialiseGLWithSize: [2/2]

- (void) initialiseGLWithSize:

(NSSize)

v_size

initialiseGLWithSize:useVideoMode:

- (void) initialiseGLWithSize:		(NSSize)	v_size
useVideoMode:		(BOOL)	v_mode

Definition at line 50 of file MyOpenGLView.m.

                             :(NSSize) v_size useVideoMode:(BOOL) v_mode
{
#if OOLITE_LINUX
    NSSize oldViewSize = viewSize;
#endif
    viewSize = v_size;
    OOLog(@"display.initGL", @"Requested a new surface of %d x %d, %@.", (int)viewSize.width, (int)viewSize.height,(fullScreen ? @"fullscreen" : @"windowed"));
    SDL_GL_SwapBuffers();   // clear the buffer before resize
    
#if OOLITE_WINDOWS
    if (!updateContext) return;
 
    DEVMODE settings;
    settings.dmSize        = sizeof(DEVMODE);
    settings.dmDriverExtra = 0;
    EnumDisplaySettings(0, ENUM_CURRENT_SETTINGS, &settings);
    
    WINDOWPLACEMENT windowPlacement;
    windowPlacement.length = sizeof(WINDOWPLACEMENT);
    GetWindowPlacement(SDL_Window, &windowPlacement);
    
    static BOOL lastWindowPlacementMaximized = NO;
    if (fullScreen && (windowPlacement.showCmd == SW_SHOWMAXIMIZED))
    {
        if (!wasFullScreen)
        {
            lastWindowPlacementMaximized = YES;
        }
    }
    
    if (lastWindowPlacementMaximized)
    {
        windowPlacement.showCmd = SW_SHOWMAXIMIZED;
    }
    
    // are we attempting to go to a different screen resolution? Note: this also takes care of secondary monitor situations because 
    // by design the only resolution available for fullscreen on a secondary display device is its native one - Nikos 20150605
    BOOL changingResolution =   [self isRunningOnPrimaryDisplayDevice] &&
                                ((fullScreen && (settings.dmPelsWidth != viewSize.width || settings.dmPelsHeight != viewSize.height)) ||
                                (wasFullScreen && (settings.dmPelsWidth != [[[screenSizes objectAtIndex:0] objectForKey: kOODisplayWidth] intValue]
                                || settings.dmPelsHeight != [[[screenSizes objectAtIndex:0] objectForKey: kOODisplayHeight] intValue])));
            
    RECT wDC;
 
    if (fullScreen)
    {
        /*NOTE: If we ever decide to change the default behaviour of launching
        always on primary monitor to launching on the monitor the program was 
        started on, all that needs to be done is comment out the line below, as
        well as the identical one in the else branch further down.
        Nikos 20141222
       */
       [self getCurrentMonitorInfo: &monitorInfo];
        
        settings.dmPelsWidth = viewSize.width;
        settings.dmPelsHeight = viewSize.height;
        settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
                
        // just before going fullscreen, save the location of the current window. It
        // may be needed in case of potential attempts to move our fullscreen window
        // in a maximized state (yes, in Windows this is entirely possible).
        if(lastWindowPlacementMaximized)
        {
            CopyRect(&lastGoodRect, &windowPlacement.rcNormalPosition);
            // if maximized, switch to normal placement before going full screen
            windowPlacement.showCmd = SW_SHOWNORMAL;
            SetWindowPlacement(SDL_Window, &windowPlacement);
        }
        else  GetWindowRect(SDL_Window, &lastGoodRect);
        
        // ok, can go fullscreen now
        SetForegroundWindow(SDL_Window);
        if (changingResolution)
        {
            if (ChangeDisplaySettingsEx(monitorInfo.szDevice, &settings, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL)
            {
                m_glContextInitialized = YES;
                OOLogERR(@"displayMode.change.error", @"Could not switch to requested display mode.");
                return;
            }
            atDesktopResolution = settings.dmPelsWidth == [[[screenSizes objectAtIndex:0] objectForKey: kOODisplayWidth] intValue]
                                && settings.dmPelsHeight == [[[screenSizes objectAtIndex:0] objectForKey: kOODisplayHeight] intValue];
        }
        
        MoveWindow(SDL_Window, monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.top, (int)viewSize.width, (int)viewSize.height, TRUE);
        if(!wasFullScreen)
        {
            [self setWindowBorderless:YES];
        }
    }
    
    else if ( wasFullScreen )
    {
        if (changingResolution)
        {
            // restore original desktop resolution
            if (ChangeDisplaySettingsEx(NULL, NULL, NULL, 0, NULL) == DISP_CHANGE_SUCCESSFUL)
            {
                atDesktopResolution = YES;
            }
        }
        
        /*NOTE: If we ever decide to change the default behaviour of launching
        always on primary monitor to launching on the monitor the program was 
        started on, we need to comment out the line below.
        For now, this line is needed for correct positioning of our window in case
        we return from a non-native resolution fullscreen and has to come after the
        display settings have been reverted.
        Nikos 20141222
        */
        [self getCurrentMonitorInfo: &monitorInfo];
        
        if (lastWindowPlacementMaximized)  CopyRect(&windowPlacement.rcNormalPosition, &lastGoodRect);
        SetWindowPlacement(SDL_Window, &windowPlacement);
        if (!lastWindowPlacementMaximized)
        {
            MoveWindow(SDL_Window,  (monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left - (int)viewSize.width)/2 +
                                monitorInfo.rcMonitor.left,
                                (monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top - (int)viewSize.height)/2 +
                                monitorInfo.rcMonitor.top,
                                (int)viewSize.width, (int)viewSize.height, TRUE);
        }
        
        [self setWindowBorderless:NO];
                                
        lastWindowPlacementMaximized = NO;
        ShowWindow(SDL_Window,SW_SHOW);
    }
    
    // stop saveWindowSize from reacting to caption & frame if necessary
    saveSize = !wasFullScreen;
 
    GetClientRect(SDL_Window, &wDC);
 
    if (!fullScreen && (bounds.size.width != wDC.right - wDC.left
                    || bounds.size.height != wDC.bottom - wDC.top))
    {
        // Resize the game window if needed. When we ask for a W x H
        // window, we intend that the client area be W x H. The actual
        // window itself must become big enough to accomodate an area
        // of such size. 
        if (wasFullScreen)  // this is true when switching from full screen or when starting in windowed mode
                            //after the splash screen has ended
        {
            RECT desiredClientRect;
            GetWindowRect(SDL_Window, &desiredClientRect);
            AdjustWindowRect(&desiredClientRect, WS_CAPTION | WS_THICKFRAME, FALSE);
            SetWindowPos(SDL_Window, NULL,  desiredClientRect.left, desiredClientRect.top,
                                            desiredClientRect.right - desiredClientRect.left,
                                            desiredClientRect.bottom - desiredClientRect.top, 0);
        }
        GetClientRect(SDL_Window, &wDC);
        viewSize.width = wDC.right - wDC.left;
        viewSize.height = wDC.bottom - wDC.top;
    }
 
    // Reset bounds and viewSize to current values
    bounds.size.width = viewSize.width = wDC.right - wDC.left;
    bounds.size.height = viewSize.height = wDC.bottom - wDC.top;
    
    if (fullScreen) // bounds on fullscreen coincide with client area, since we are borderless
    {
        bounds.origin.x = monitorInfo.rcMonitor.left;
        bounds.origin.y = monitorInfo.rcMonitor.top;
    }
    wasFullScreen=fullScreen;
 
#else //OOLITE_LINUX
 
    int videoModeFlags = SDL_HWSURFACE | SDL_OPENGL;
 
    if (v_mode == NO)
        videoModeFlags |= SDL_NOFRAME;
    if (fullScreen == YES)
    {
        videoModeFlags |= SDL_FULLSCREEN;
    }
    else
    {
        videoModeFlags |= SDL_RESIZABLE;
    }
    surface = SDL_SetVideoMode((int)viewSize.width, (int)viewSize.height, 32, videoModeFlags);
 
    if (!surface && fullScreen == YES)
    {
        [self setFullScreenMode: NO];
        viewSize = oldViewSize;
        videoModeFlags &= ~SDL_FULLSCREEN;
        videoModeFlags |= SDL_RESIZABLE;
        surface = SDL_SetVideoMode((int)viewSize.width, (int)viewSize.height, 32, videoModeFlags);
    }
 
    if (!surface)
    {
      // we should always have a valid surface, but in case we don't
        OOLogERR(@"display.mode.error",@"Unable to change display mode: %s",SDL_GetError());
        exit(1);
    }
 
    bounds.size.width = surface->w;
    bounds.size.height = surface->h;
 
#endif
    OOLog(@"display.initGL", @"Created a new surface of %d x %d, %@.", (int)viewSize.width, (int)viewSize.height,(fullScreen ? @"fullscreen" : @"windowed"));
 
    if (viewSize.width/viewSize.height > 4.0/3.0) {
        display_z = 480.0 * bounds.size.width/bounds.size.height;
        x_offset = 240.0 * bounds.size.width/bounds.size.height;
        y_offset = 240.0;
    } else {
        display_z = 640.0;
        x_offset = 320.0;
        y_offset = 320.0 * bounds.size.height/bounds.size.width;
    }
 
    if (surface != 0)  SDL_FreeSurface(surface);
 
    [self autoShowMouse];
 
    [[self gameController] setUpBasicOpenGLStateWithSize:viewSize];
    SDL_GL_SwapBuffers();
    squareX = 0.0f;
 
    m_glContextInitialized = YES;
}

initKeyMappingData [1/2]

- (void) initKeyMappingData

Definition at line 50 of file MyOpenGLView.m.

{
    NSUserDefaults *prefs = [NSUserDefaults standardUserDefaults];
    NSDictionary *kmap = [NSDictionary dictionaryWithDictionary:[ResourceManager dictionaryFromFilesNamed:@"keymappings_mac.plist" inFolder:@"Config" mergeMode:MERGE_BASIC cache:NO]];
    // get the stored keyboard code from preferences
    NSString *kbd = [prefs oo_stringForKey:@"keyboard-code" defaultValue:@"default"];
    NSDictionary *subset = [kmap objectForKey:kbd];
 
    [keyMappings_normal release];
    keyMappings_normal = [[subset objectForKey:@"mapping_normal"] copy];
    [keyMappings_shifted release];
    keyMappings_shifted = [[subset objectForKey:@"mapping_shifted"] copy];
}

initKeyMappingData [2/2]

- (void) initKeyMappingData

initSplashScreen

- (void) initSplashScreen

Definition at line 50 of file MyOpenGLView.m.

{
    if (!showSplashScreen) return;
 
    //too early for OOTexture!
    SDL_Surface         *image=NULL;
    SDL_Rect            dest;
 
    NSString        *imagesDir = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:@"Images"];
 
    image = SDL_LoadBMP([[imagesDir stringByAppendingPathComponent:@"splash.bmp"] UTF8String]);
 
    if (image == NULL)
    {
        SDL_FreeSurface(image);
        OOLogWARN(@"sdl.gameStart", @"%@", @"image 'splash.bmp' not found!");
        [self endSplashScreen];
        return;
    }
 
    dest.x = 0;
    dest.y = 0;
    dest.w = image->w;
    dest.h = image->h;
 
  #if OOLITE_WINDOWS
 
    dest.x = (GetSystemMetrics(SM_CXSCREEN)- dest.w)/2;
    dest.y = (GetSystemMetrics(SM_CYSCREEN)-dest.h)/2;
    SetWindowLong(SDL_Window,GWL_STYLE,GetWindowLong(SDL_Window,GWL_STYLE) & ~WS_CAPTION & ~WS_THICKFRAME);
    ShowWindow(SDL_Window,SW_RESTORE);
    MoveWindow(SDL_Window,dest.x,dest.y,dest.w,dest.h,TRUE);
 
  #else
 
    /* MKW 2011.11.11
     * According to Marc using the NOFRAME flag causes trouble under Ubuntu 8.04.
     *
     * The current Ubuntu LTS is 10.04, which doesn't seem to have that problem.
     * 12.04 LTS is going to be released soon, also without apparent problems.
     * Changed to SDL_NOFRAME, throwing caution to the wind - Kaks 2012.03.23
     * Took SDL_NOFRAME out, since it still causes strange problems here - cim 2012.04.09
     */
     surface = SDL_SetVideoMode(dest.w, dest.h, 32, SDL_HWSURFACE | SDL_OPENGL);
 
  #endif
 
    OOSetOpenGLState(OPENGL_STATE_OVERLAY);
 
    glViewport( 0, 0, dest.w, dest.h);
 
    glEnable( GL_TEXTURE_2D );
    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
    glClear( GL_COLOR_BUFFER_BIT );
 
    [matrixManager resetProjection];
    [matrixManager orthoLeft: 0.0f right: dest.w bottom: dest.h top: 0.0 near: -1.0 far: 1.0];
    [matrixManager syncProjection];
 
    [matrixManager resetModelView];
    [matrixManager syncModelView];
 
    GLuint texture;
    GLenum texture_format;
    GLint  nOfColors;
 
    // get the number of channels in the SDL image
    nOfColors = image->format->BytesPerPixel;
    if (nOfColors == 4)     // contains an alpha channel
    {
        if (image->format->Rmask == 0x000000ff)
            texture_format = GL_RGBA;
        else
            texture_format = GL_BGRA;
    }
    else if (nOfColors == 3)     // no alpha channel
    {
        if (image->format->Rmask == 0x000000ff)
            texture_format = GL_RGB;
        else
            texture_format = GL_BGR;
    } else {
        SDL_FreeSurface(image);
        OOLog(@"Sdl.GameStart", @"%@", @"----- Encoding error within image 'splash.bmp'");
        [self endSplashScreen];
        return;
    }
 
    glGenTextures( 1, &texture );
    glBindTexture( GL_TEXTURE_2D, texture );
 
    // Set the texture's stretching properties
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 
    // Set the texture image data with the information  from SDL_Surface
    glTexImage2D( GL_TEXTURE_2D, 0, nOfColors, image->w, image->h, 0,
                      texture_format, GL_UNSIGNED_BYTE, image->pixels );
 
    glBindTexture( GL_TEXTURE_2D, texture );
    glBegin( GL_QUADS );
 
    glTexCoord2i( 0, 0 );
    glVertex2i( 0, 0 );
    glTexCoord2i( 1, 0 );
    glVertex2i( dest.w, 0 );
    glTexCoord2i( 1, 1 );
    glVertex2i( dest.w, dest.h );
    glTexCoord2i( 0, 1 );
    glVertex2i( 0, dest.h );
 
    glEnd();
 
    SDL_GL_SwapBuffers();
    [matrixManager resetModelView];
    [matrixManager syncModelView];
 
    if ( image ) {
        SDL_FreeSurface( image );
    }
    glDeleteTextures(1, &texture);
 
    glDisable( GL_TEXTURE_2D );
    OOVerifyOpenGLState();
}

initWithFrame:

- (id) initWithFrame: (NSRect) frameRect

implementation

Definition at line 50 of file MyOpenGLView.m.

                    :(NSRect)frameRect
{
#ifndef NDEBUG
    if (NSZombieEnabled)
    {
        OOLog(@"debug.zombieEnabled", @"*** ZOMBIES WILL EAT YOUR BRAIN ***");
    }
#endif
    
    // Pixel Format Attributes for the View-based (non-FullScreen) NSOpenGLContext
    NSOpenGLPixelFormatAttribute attrs[] =
    {
        // Specify that we want a windowed OpenGL context.
        // Must be first or we'll hit an assert in the legacy fullscreen controller.
        NSOpenGLPFAWindow,
        
        // We may be on a multi-display system (and each screen may be driven by a different renderer), so we need to specify which screen we want to take over.
        // For this demo, we'll specify the main screen.
        NSOpenGLPFAScreenMask, CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay),
        
        // Specifying "NoRecovery" gives us a context that cannot fall back to the software renderer.
        // This makes the View-based context a compatible with the fullscreen context, enabling us to use the "shareContext"
        // feature to share textures, display lists, and other OpenGL objects between the two.
        NSOpenGLPFANoRecovery,
        
        // Attributes Common to FullScreen and non-FullScreen
        NSOpenGLPFACompliant,
        
        NSOpenGLPFAColorSize, 32,
        NSOpenGLPFADepthSize, 32,
        NSOpenGLPFADoubleBuffer,
        NSOpenGLPFAAccelerated,
#if FSAA
        // Need a preference or other sane way to activate this
        NSOpenGLPFAMultisample,
        NSOpenGLPFASampleBuffers, 1,
        NSOpenGLPFASamples,4,
#endif
        0
    };
    
    // Create our non-FullScreen pixel format.
    NSOpenGLPixelFormat *pixelFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes:attrs] autorelease];
    
    if ((self = [super initWithFrame:frameRect pixelFormat:pixelFormat]))
    {
        if ([self respondsToSelector:@selector(setAcceptsTouchEvents:)])
        {
            [self setAcceptsTouchEvents:YES];
        }
        
        if ([self respondsToSelector:@selector(setWantsBestResolutionOpenGLSurface:)])
        {
            // Enable high resolution on Retina displays.
            [self setWantsBestResolutionOpenGLSurface:YES];
        }
        
        matrixManager = [[OOOpenGLMatrixManager alloc] init];
        _pixelFormatAttributes = [[NSData alloc] initWithBytes:attrs length:sizeof attrs];
        virtualJoystickPosition = NSMakePoint(0.0,0.0);
        
        typedString = [[NSMutableString alloc] initWithString:@""];
        allowingStringInput = gvStringInputNo;
        isAlphabetKeyDown = NO;
            
        timeIntervalAtLastClick = [NSDate timeIntervalSinceReferenceDate];
        
        _virtualScreen = [[self openGLContext] currentVirtualScreen];
    }
    
    // preload the printscreen key into our translation array because SDLK_PRINTSCREEN isn't available
    scancode2Unicode[55] = gvPrintScreenKey;
    [self initKeyMappingData];
 
    return self;
}

isAlphabetKeyDown [1/2]

- (BOOL) isAlphabetKeyDown

isAlphabetKeyDown [2/2]

- (BOOL) isAlphabetKeyDown

isCapsLockOn [1/2]

- (BOOL) isCapsLockOn

Definition at line 50 of file MyOpenGLView.m.

{
    return capsLockOn;
}

isCapsLockOn [2/2]

- (BOOL) isCapsLockOn

isCommandDown [1/2]

- (BOOL) isCommandDown

Definition at line 50 of file MyOpenGLView.m.

{
    return command;
}

isCommandDown [2/2]

- (BOOL) isCommandDown

isCommandFDown [1/2]

- (BOOL) isCommandFDown

Definition at line 50 of file MyOpenGLView.m.

{
    return commandF;
}

isCommandFDown [2/2]

- (BOOL) isCommandFDown

isCommandModifierKeyDown

- (BOOL) isCommandModifierKeyDown

implementation

Provided by category MyOpenGLView(OOLoadSaveExtensions).

Definition at line 1003 of file PlayerEntityLoadSave.m.

{
    return [self isCtrlDown];
}

isCommandQDown [1/2]

- (BOOL) isCommandQDown

Definition at line 50 of file MyOpenGLView.m.

{
    return commandQ;
}

isCommandQDown [2/2]

- (BOOL) isCommandQDown

isCtrlDown [1/2]

- (BOOL) isCtrlDown

Definition at line 50 of file MyOpenGLView.m.

{
    return ctrl;
}

isCtrlDown [2/2]

- (BOOL) isCtrlDown

isDown: [1/2]

- (BOOL) isDown:

(int)

key

Definition at line 50 of file MyOpenGLView.m.

               : (int) key
{
    if( suppressKeys )
        return NO;
    if ( key < 0 )
        return NO;
    if ( key >= [self numKeys] )
        return NO;
    return keys[key];
}

isDown: [2/2]

- (BOOL) isDown:

(int)

key

isOptDown [1/2]

- (BOOL) isOptDown

Definition at line 50 of file MyOpenGLView.m.

{
    return opt;
}

isOptDown [2/2]

- (BOOL) isOptDown

isOutputDisplayHDREnabled

- (BOOL) isOutputDisplayHDREnabled

Definition at line 50 of file MyOpenGLView.m.

{
    return NO;
}

isRunningOnPrimaryDisplayDevice

- (BOOL) isRunningOnPrimaryDisplayDevice

Definition at line 50 of file MyOpenGLView.m.

{
    return YES;
}

isShiftDown [1/2]

- (BOOL) isShiftDown

Definition at line 50 of file MyOpenGLView.m.

{
    return shift;
}

isShiftDown [2/2]

- (BOOL) isShiftDown

keyDown:

- (void) keyDown: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                :(NSEvent *)theEvent
{
    NSString    *stringValue = nil;
    int         key;
    int         keycode;
    
    stringValue = [theEvent charactersIgnoringModifiers];
    
    /*  Bug: exception when pressing accent key.
        Analysis: Dead keys (accents and similar) return an empty string.
        Fix: reject zero-length strings. This is the Wrong Thing - we should
        really be using KeyTranslate()/UCKeyTranslate() to find out what the
        string would be if you pressed the key and then space.
        -- Ahruman 20070714
    */
    //if ([stringValue length] < 1)  return;
    
    keycode = [theEvent keyCode] & 255;
    
    if ([stringValue length] < 1)
    {
        if (!shift)
        {
            NSString *keyNormal = [keyMappings_normal objectForKey:[NSString stringWithFormat:@"%d", keycode]];
            if (keyNormal) stringValue = [NSString stringWithFormat:@"%c", [keyNormal integerValue]];
        }
        else
        {
            NSString *keyShifted = [keyMappings_shifted objectForKey:[NSString stringWithFormat:@"%d", keycode]];
            if (keyShifted) stringValue = [NSString stringWithFormat:@"%c", [keyShifted integerValue]];
        }       
        // if we still have a zero-length string, return at this point
        if ([stringValue length] < 1) return;
    }
 
    key = [stringValue characterAtIndex:0];
    key = [self translateKeyCode:key];
    
    OOLog(kOOLogKeyDown, @"Key down: stringValue = \"%@\", keyCode = %d, key = %u", stringValue, keycode, key);
    
    // Special handling of command keys used in full-screen mode.
    if ([theEvent modifierFlags] & NSCommandKeyMask)
    {
        switch (key)
        {
            case 'q':
                commandQ = YES;
                break;
                
            case 'f':
                commandF = YES;
                break;
        }
        
        return;
    }
    
    keycodetrans[keycode] = key;    // record the character we got for pressing the hardware at key location 'keycode'
    
    /*  HACK: treat f12 as alias to cmd-F for compatibility with helpful forum
        advice etc.
    */
    if (key == NSF12FunctionKey)
    {
        if (!f12)
        {
            f12 = YES;
            [gameController performSelector:@selector(toggleFullScreenAction:) withObject:nil afterDelay:0.0];
        }
        
        return;
    };
    
    if ((key >= 0)&&(key < [self numKeys])&&(!keys[key]))
    {
        keys[key] = YES;
        
        if (allowingStringInput)
        {
            if ((key == gvDeleteKey || key == gvBackspaceKey) && [typedString length] > 0)
            {
                // delete
                [typedString deleteCharactersInRange:NSMakeRange([typedString length] - 1, 1)];
            }
 
            isAlphabetKeyDown = NO;
            lastKeyShifted = shift;
 
            // limited input for planet find screen
            if (allowingStringInput == gvStringInputAlpha)
            {
                if (isalpha(key))
                {
                    isAlphabetKeyDown = YES;
                    // convert to lower case
                    [typedString appendFormat:@"%c", tolower(key)];
                }
            }
            
            // full input for load-save screen or 'all' input
            if (allowingStringInput >= gvStringInputLoadSave)
            {
                // except '/' for loadsave
                if (isprint(key) && key != '/')
                {
                    isAlphabetKeyDown = YES;
                    [typedString appendFormat:@"%c", key];
                }
                else if (key == '/' && allowingStringInput == gvStringInputAll)
                {
                    isAlphabetKeyDown = YES;
                    [typedString appendFormat:@"%c", key];
                }
            }
            
        }
    }
    else
    {
        if (key > [self numKeys])
        {
            OOLog(kOOLogKeyCodeOutOfRange, @"Translated key: %d out of range", key);
        }
    }
} 

Referenced by OoliteApp::sendEvent:.

Here is the caller graph for this function:

keyUp:

- (void) keyUp: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

              :(NSEvent *)theEvent
{
    NSString    *stringValue = nil;
    int         key;
    int         keycode;
    
    stringValue = [theEvent charactersIgnoringModifiers];
    
    /*  Bug: exception when releasing accent key.
        Analysis: Dead keys (accents and similar) return an empty string.
        Fix: reject zero-length strings. This is the Wrong Thing - we should
        really be using KeyTranslate()/UCKeyTranslate() to find out what the
        string would be if you pressed the key and then space.
        -- Ahruman 20070714
    */
    if ([stringValue length] < 1)  return;
    
    suppressKeys = NO;
    
    keycode = [theEvent keyCode] & 255;
    key = keycodetrans[keycode];    // retrieve the character we got for pressing the hardware at key location 'keycode'
    
    OOLog(kOOLogKeyUp, @"Key up: stringValue = \"%@\", keyCode = %d, key = %u", stringValue, keycode, key);
    
    // Special handling of command keys used in full-screen mode.
    if ([theEvent modifierFlags] & NSCommandKeyMask)
    {
        switch (key)
        {
            case 'q':
                commandQ = NO;
                break;
                
            case 'f':
                commandF = NO;
                break;
        }
        // Pass through to allow clearing of normal key as well.
    }
    
    /*  HACK: treat f12 as alias to cmd-F for compatibility with helpful forum
        advice etc.
    */
    if (key == NSF12FunctionKey)
    {
        commandF = NO;
        f12 = NO;
        return;
    };
    
    isAlphabetKeyDown = NO;
    if ((key >= 0)&&(key < [self numKeys])&&(keys[key]))
    {
        keys[key] = NO;
    }
    else
    {
        if (key > [self numKeys])
            OOLog(kOOLogKeyCodeOutOfRange, @"Translated key: %d out of range", key);
    }
}

Referenced by OoliteApp::sendEvent:.

Here is the caller graph for this function:

lastKeyWasShifted [1/2]

- (BOOL) lastKeyWasShifted

Definition at line 50 of file MyOpenGLView.m.

{
    return lastKeyShifted;
}

lastKeyWasShifted [2/2]

- (BOOL) lastKeyWasShifted

loadFullscreenSettings

- (int) loadFullscreenSettings

Definition at line 50 of file MyOpenGLView.m.

{
    currentSize=0;
    int width=0, height=0, refresh=0;
    unsigned i;
 
    NSArray* cmdline_arguments = [[NSProcessInfo processInfo] arguments];
 
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    if ([userDefaults objectForKey:@"display_width"])
        width = [userDefaults integerForKey:@"display_width"];
    if ([userDefaults objectForKey:@"display_height"])
        height = [userDefaults integerForKey:@"display_height"];
    if ([userDefaults objectForKey:@"display_refresh"])
        refresh = [userDefaults integerForKey:@"display_refresh"];
    if([userDefaults objectForKey:@"fullscreen"])
        fullScreen=[userDefaults boolForKey:@"fullscreen"];
 
    // Check if -fullscreen or -windowed has been passed on the command line. If yes,
    // set it regardless of what is set by .GNUstepDefaults. If both are found in the
    // arguments list, the one that comes last wins.
    for (i = 0; i < [cmdline_arguments count]; i++)
    {
        if ([[cmdline_arguments objectAtIndex:i] isEqual:@"-fullscreen"]) fullScreen = YES;
        if ([[cmdline_arguments objectAtIndex:i] isEqual:@"-windowed"]) fullScreen = NO;
    }
    
    if(width && height)
    {
            currentSize=[self findDisplayModeForWidth: width Height: height Refresh: refresh];
            return currentSize;
    }
    return currentSize;
}

loadWindowSize

- (NSSize) loadWindowSize

Definition at line 50 of file MyOpenGLView.m.

{
    NSSize windowSize;
    NSUserDefaults *defaults=[NSUserDefaults standardUserDefaults];
    if([defaults objectForKey:@"window_width"] && [defaults objectForKey:@"window_height"])
    {
        windowSize=NSMakeSize([defaults integerForKey: @"window_width"],
                    [defaults integerForKey: @"window_height"]);
    }
    else
    {
        windowSize=NSMakeSize(WINDOW_SIZE_DEFAULT_WIDTH, WINDOW_SIZE_DEFAULT_HEIGHT);
    }
    currentWindowSize=windowSize;
    return windowSize;
}

modeAsSize:

- (NSSize) modeAsSize:

(int)

sizeIndex

mouseDown:

- (void) mouseDown:

(NSEvent *)

theEvent

Definition at line 50 of file MyOpenGLView.m.

                 :(NSEvent *)theEvent
{
    if (doubleClick)
    {
        doubleClick = NO;
        keys[gvMouseDoubleClick] = NO;
    }
    keys[gvMouseLeftButton] = YES; // 'a' down
}

mouseDragged:

- (void) mouseDragged: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                     :(NSEvent *)theEvent
{
    [self mouseMoved:theEvent];
}

mouseMoved:

- (void) mouseMoved: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                  :(NSEvent *)theEvent
{
    double mx = [theEvent locationInWindow].x - viewSize.width/2.0;
    double my = [theEvent locationInWindow].y - viewSize.height/2.0;
 
    if (display_z > 640.0)
    {
        mx /= viewSize.width * MAIN_GUI_PIXEL_WIDTH / display_z;
        my /= viewSize.height;
    }
    else
    {
        mx /= MAIN_GUI_PIXEL_WIDTH * viewSize.width / 640.0;
        my /= MAIN_GUI_PIXEL_HEIGHT * viewSize.width / 640.0;
    }
    
    [self setVirtualJoystick:mx :-my];
}

mouseUp:

- (void) mouseUp:

(NSEvent *)

theEvent

Definition at line 50 of file MyOpenGLView.m.

               :(NSEvent *)theEvent
{
    NSTimeInterval timeBetweenClicks = [NSDate timeIntervalSinceReferenceDate] - timeIntervalAtLastClick;
    timeIntervalAtLastClick += timeBetweenClicks;
    
    if (!doubleClick)
    {
        doubleClick = (timeBetweenClicks < MOUSE_DOUBLE_CLICK_INTERVAL);    // One fifth of a second
        keys[gvMouseDoubleClick] = doubleClick;
    }
    
    keys[gvMouseLeftButton] = NO;  // 'a' up
}

mouseWheelDelta [1/2]

- (float) mouseWheelDelta

Definition at line 50 of file MyOpenGLView.m.

{
    return _mouseWheelDelta / OOMOUSEWHEEL_DELTA;
}

mouseWheelDelta [2/2]

- (float) mouseWheelDelta

mouseWheelState [1/2]

- (int) mouseWheelState

Definition at line 50 of file MyOpenGLView.m.

{
    if (_mouseWheelDelta > 0.0f)
        return gvMouseWheelUp;
    else if (_mouseWheelDelta < 0.0f)
        return gvMouseWheelDown;
    else
        return gvMouseWheelNeutral;
}

mouseWheelState [2/2]

- (int) mouseWheelState

msaa

- (BOOL) msaa

Definition at line 50 of file MyOpenGLView.m.

{
    return _msaa;
}

noteMouseInteractionModeChangedFrom:to: [1/2]

- (void) noteMouseInteractionModeChangedFrom:		(OOMouseInteractionMode)	oldMode
to:		(OOMouseInteractionMode)	newMode

Definition at line 50 of file MyOpenGLView.m.

                                            :(OOMouseInteractionMode)oldMode to:(OOMouseInteractionMode)newMode
{
    UnapplyCursorState(oldMode);
    ApplyCursorState(newMode);
}

noteMouseInteractionModeChangedFrom:to: [2/2]

- (void) noteMouseInteractionModeChangedFrom:		(OOMouseInteractionMode)	oldMode
to:		(OOMouseInteractionMode)	newMode

noteMovedToBadDisplay

- (void) noteMovedToBadDisplay

implementation

Definition at line 50 of file MyOpenGLView.m.

{
    NSRunInformationalAlertPanel(DESC(@"oolite-mac-bad-display"), @"%@", nil, nil, nil, DESC(@"oolite-mac-bad-display-2"));
}

numKeys [1/2]

- (int) numKeys

Definition at line 50 of file MyOpenGLView.m.

{
    return NUM_KEYS;
}

numKeys [2/2]

- (int) numKeys

otherMouseDragged:

- (void) otherMouseDragged: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                          :(NSEvent *)theEvent
{
    [self mouseMoved:theEvent];
}

pixelFormatAttributes

- (NSData *) pixelFormatAttributes

Definition at line 50 of file MyOpenGLView.m.

{
    return _pixelFormatAttributes;
}

pngSaveSurface:withSurface:

- (BOOL) pngSaveSurface:		(NSString *)	fileName
withSurface:		(SDL_Surface *)	surf

Definition at line 50 of file MyOpenGLView.m.

                       :(NSString *)fileName withSurface:(SDL_Surface *)surf
{
    FILE *fp;
    png_structp pngPtr;
    png_infop infoPtr;
    int i, colorType;
    png_bytep *rowPointers;
 
    fp = fopen([fileName UTF8String], "wb");
    if (fp == NULL)
    {
        OOLog(@"pngSaveSurface.fileCreate.failed", @"Failed to create output screenshot file %@", fileName);
        return NO;
    }
 
    // initialize png structures (no callbacks)
    pngPtr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (pngPtr == NULL)
    {
        return NO;
    }
 
    infoPtr = png_create_info_struct(pngPtr);
    if (infoPtr == NULL) {
        png_destroy_write_struct(&pngPtr, (png_infopp)NULL);
        OOLog(@"pngSaveSurface.info_struct.failed", @"%@", @"png_create_info_struct error");
        exit(-1);
    }
 
    if (setjmp(png_jmpbuf(pngPtr)))
    {
        png_destroy_write_struct(&pngPtr, &infoPtr);
        fclose(fp);
        exit(-1);
    }
 
    png_init_io(pngPtr, fp);
 
    colorType = PNG_COLOR_MASK_COLOR; /* grayscale not supported */
    if (surf->format->palette)
    {
        colorType |= PNG_COLOR_MASK_PALETTE;
    }
    else if (surf->format->Amask)
    {
        colorType |= PNG_COLOR_MASK_ALPHA;
    }
 
    png_set_IHDR(pngPtr, infoPtr, surf->w, surf->h, 8, colorType,   PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
    
    // if we are outputting HDR, our backbuffer is linear, so gamma is 1.0. Make sure our png has this info
    // note: some image viewers seem to ignore the gAMA chunk; still, this is better than not having it at all
    if ([self hdrOutput])  png_set_gAMA(pngPtr, infoPtr, 1.0f);
 
    // write the image
    png_write_info(pngPtr, infoPtr);
    png_set_packing(pngPtr);
 
    rowPointers = (png_bytep*) malloc(sizeof(png_bytep)*surf->h);
    for (i = 0; i < surf->h; i++)
    {
        rowPointers[i] = (png_bytep)(Uint8 *)surf->pixels + i*surf->pitch;
    }
    png_write_image(pngPtr, rowPointers);
    png_write_end(pngPtr, infoPtr);
 
    free(rowPointers);
    png_destroy_write_struct(&pngPtr, &infoPtr);
    fclose(fp);
 
    return YES;
}

pollControls [1/2]

- (void) pollControls

Definition at line 50 of file MyOpenGLView.m.

{
    if ([NSDate timeIntervalSinceReferenceDate] > timeIntervalAtLastMouseWheel + OOMOUSEWHEEL_EVENTS_DELAY_INTERVAL)
        _mouseWheelDelta = 0.0f;
}

pollControls [2/2]

- (void) pollControls

pollShiftKey [1/2]

+ (BOOL) pollShiftKey

Definition at line 50 of file MyOpenGLView.m.

{
    #define KEYMAP_GET(m, index) ((((uint8_t*)(m))[(index) >> 3] & (1L << ((index) & 7))) ? 1 : 0)
    
    KeyMap              map;
    
    GetKeys(map);
    return KEYMAP_GET(map, 56) || KEYMAP_GET(map, 60);  // Left shift or right shift -- although 60 shouldn't occur.
}

pollShiftKey [2/2]

+ (BOOL) pollShiftKey

populateFullScreenModelist

- (void) populateFullScreenModelist

Definition at line 50 of file MyOpenGLView.m.

{
    int i;
    SDL_Rect **modes;
    NSMutableDictionary *mode;
 
    screenSizes=[[NSMutableArray alloc] init];
 
    // The default resolution (slot 0) is the resolution we are
    // already in since this is guaranteed to work.
    mode=[MyOpenGLView getNativeSize];
    [screenSizes addObject: mode];
 
    modes=SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
    if(modes == (SDL_Rect **)NULL)
    {
        OOLog(@"display.mode.list.none", @"%@", @"SDL didn't return any screen modes");
        return;
    }
 
    if(modes == (SDL_Rect **)-1)
    {
        OOLog(@"display.mode.list.none", @"%@", @"SDL claims 'all resolutions available' which is unhelpful in the extreme");
        return;
    }
 
    int lastw=[[mode objectForKey: kOODisplayWidth] intValue];
    int lasth=[[mode objectForKey: kOODisplayHeight] intValue];
    for(i=0; modes[i]; i++)
    {
        // SDL_ListModes often lists a mode several times,
        // presumably because each mode has several refresh rates.
        // But the modes pointer is an SDL_Rect which can't represent
        // refresh rates. WHY!?
        if(modes[i]->w != lastw || modes[i]->h != lasth)
        {
            // new resolution, save it
            mode=[NSMutableDictionary dictionary];
            [mode setValue: [NSNumber numberWithInt: (int)modes[i]->w]
                    forKey: kOODisplayWidth];
            [mode setValue: [NSNumber numberWithInt: (int)modes[i]->h]
                    forKey: kOODisplayHeight];
            [mode setValue: [NSNumber numberWithInt: 0]
                    forKey: kOODisplayRefreshRate];
            if (![screenSizes containsObject:mode])
            {
                [screenSizes addObject: mode];
                OOLog(@"display.mode.list", @"Added res %d x %d", modes[i]->w, modes[i]->h);
                lastw=modes[i]->w;
                lasth=modes[i]->h;
            }
        }
    }
}

recenterVirtualJoystick

- (void) recenterVirtualJoystick

implementation

Provided by category MyOpenGLView(Internal).

Definition at line 50 of file MyOpenGLView.m.

{
    if ([PLAYER guiScreen] == GUI_SCREEN_MAIN)
    {
        [[GameController sharedController] recenterVirtualJoystick];
    }
}

resetMouse [1/2]

- (void) resetMouse

Definition at line 50 of file MyOpenGLView.m.

{
    CGPoint centerPoint = CGPointMake(viewSize.width / 2.0, viewSize.height / 2.0);
    CGWarpMouseCursorPosition(centerPoint);
    [self setVirtualJoystick:0.0 :0.0];
}

resetMouse [2/2]

- (void) resetMouse

resetSDLKeyModifiers

- (void) resetSDLKeyModifiers

implementation

Provided by category MyOpenGLView(OOPrivate).

Definition at line 50 of file MyOpenGLView.m.

{
    // probably not needed for Linux
}

resetTypedString [1/2]

- (void) resetTypedString

Definition at line 50 of file MyOpenGLView.m.

{
    [typedString setString:@""];
}

resetTypedString [2/2]

- (void) resetTypedString

rightMouseDown:

- (void) rightMouseDown: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                       :(NSEvent *)theEvent
{
    [self resetMouse];
}

rightMouseUp:

- (void) rightMouseUp: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                     :(NSEvent *)theEvent
{
    [self recenterVirtualJoystick];
}

saveWindowSize:

- (void) saveWindowSize:

(NSSize)

windowSize

Definition at line 50 of file MyOpenGLView.m.

                       : (NSSize) windowSize
{
    NSUserDefaults *defaults=[NSUserDefaults standardUserDefaults];
    [defaults setInteger: (int)windowSize.width forKey: @"window_width"];
    [defaults setInteger: (int)windowSize.height forKey: @"window_height"];
    currentWindowSize=windowSize;
}

scrollWheel:

- (void) scrollWheel: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                   :(NSEvent *)theEvent
{
    float dy = [theEvent scrollingDeltaY];
    
    if (dy == 0)
        return;
    
    if (dy > 0)
    {
        if (_mouseWheelDelta >= 0)
            _mouseWheelDelta += dy;
        else
            _mouseWheelDelta = 0;
    }
    else
    {
        if (_mouseWheelDelta <= 0)
            _mouseWheelDelta += dy;
        else
            _mouseWheelDelta = 0;
    }
    timeIntervalAtLastMouseWheel = [NSDate timeIntervalSinceReferenceDate];
}

setDisplayMode:fullScreen:

- (void) setDisplayMode:		(int)	mode
fullScreen:		(BOOL)	fsm

setFov:fromFraction: [1/2]

- (void) setFov:		(float)	value
fromFraction:		(BOOL)	fromFraction

Definition at line 1350 of file MyOpenGLView.m.

               :(float)value fromFraction:(BOOL)fromFraction
{
    _fov = fromFraction ? value : tanf((value / 2.0f) * M_PI / 180.0f);
}

setFov:fromFraction: [2/2]

- (void) setFov:		(float)	value
fromFraction:		(BOOL)	fromFraction

setFullScreenMode:

- (void) setFullScreenMode:

(BOOL)

fsm

setGameController: [1/2]

- (void) setGameController:

(GameController *)

controller

Definition at line 50 of file MyOpenGLView.m.

                          :(GameController *) controller
{
    gameController = controller;
}

setGameController: [2/2]

- (void) setGameController:

(GameController *)

controller

setGammaValue: [1/2]

- (void) setGammaValue:

(float)

value

Definition at line 1350 of file MyOpenGLView.m.

                      : (float) value
{
    // no-op
}

setGammaValue: [2/2]

- (void) setGammaValue:

(float)

value

setMouseInDeltaMode:

- (void) setMouseInDeltaMode:

(BOOL)

inDelta

Definition at line 50 of file MyOpenGLView.m.

                            : (BOOL) inDelta
{
    mouseInDeltaMode=inDelta;
}

setMouseWheelDelta: [1/2]

- (void) setMouseWheelDelta:

(float)

newWheelDelta

Definition at line 50 of file MyOpenGLView.m.

                           : (float) newWheelDelta
{
    _mouseWheelDelta = newWheelDelta * OOMOUSEWHEEL_DELTA;
}

setMouseWheelDelta: [2/2]

- (void) setMouseWheelDelta:

(float)

newWheelDelta

setMsaa:

- (void) setMsaa:

(BOOL)

newMsaa

Definition at line 50 of file MyOpenGLView.m.

                :(BOOL)newMsaa
{
    _msaa = !!newMsaa;
}

setScreenSize:

- (void) setScreenSize:

(int)

sizeIndex

setStringInput: [1/2]

- (void) setStringInput:

(enum StringInput)

value

Definition at line 50 of file MyOpenGLView.m.

                       :(enum StringInput)value
{
    allowingStringInput = value;
}

setStringInput: [2/2]

- (void) setStringInput:

(enum StringInput)

value

setTypedString: [1/2]

- (void) setTypedString:

(NSString*)

value

Definition at line 50 of file MyOpenGLView.m.

                       :(NSString *)value
{
    [typedString setString:value];
}

setTypedString: [2/2]

- (void) setTypedString:

(NSString *)

value

setVirtualJoystick:vmx: [1/2]

- (void) setVirtualJoystick:		(double)
vmx:		(double)	vmy

Definition at line 50 of file MyOpenGLView.m.

                           :(double) vmx :(double) vmy
{
    virtualJoystickPosition.x = vmx;
    virtualJoystickPosition.y = vmy;
}

setVirtualJoystick:vmx: [2/2]

- (void) setVirtualJoystick:		(double)
vmx:		(double)	vmy

setWindowBorderless:

- (void) setWindowBorderless: (BOOL) borderless

implementation

Provided by category MyOpenGLView(OOPrivate).

Definition at line 50 of file MyOpenGLView.m.

                            :(BOOL)borderless
{
    // do nothing on Linux
}

snapShot: [1/2]

- (BOOL) snapShot:

(NSString *)

filename

Definition at line 50 of file MyOpenGLView.m.

                 :(NSString *)filename
{
    BOOL snapShotOK = YES;
    NSSize v_size = backingViewSize;
    
    int w = v_size.width;
    int h = v_size.height;
    
    if (w & 3)
        w = w + 4 - (w & 3);
    
    long nPixels = w * h + 1;   
    
    unsigned char   *red = (unsigned char *)malloc(nPixels);
    unsigned char   *green = (unsigned char *)malloc(nPixels);
    unsigned char   *blue = (unsigned char *)malloc(nPixels);
    
    // backup the previous directory
    NSString *originalDirectory = [[NSFileManager defaultManager] currentDirectoryPath];
    // use the snapshots directory
    NSString *snapshotsDirectory = [[[GameController sharedController] snapshotsURLCreatingIfNeeded:YES] path];
    if (![[NSFileManager defaultManager] changeCurrentDirectoryPath:snapshotsDirectory])
    {
        NSBeep();
        OOLog(@"savedSnapshot.defaultPath.chdir.failed", @"Could not navigate to %@", snapshotsDirectory);
        snapShotOK = NO;
        goto FAIL;
    }
    
    BOOL                withFilename = (filename != nil);
    static unsigned     imageNo = 0;
    unsigned            tmpImageNo = 0;
    NSString            *pathToPic = nil;
    NSString            *baseName = @"oolite";
    
    if (withFilename) 
    {
        baseName = filename;
        pathToPic = [filename stringByAppendingString:@".png"];
    }
    else
    {
        tmpImageNo = imageNo;
    }
    
    if (withFilename && [[NSFileManager defaultManager] fileExistsAtPath:pathToPic])
    {
        OOLog(@"screenshot.filenameExists", @"Snapshot \"%@.png\" already exists - adding numerical sequence.", pathToPic);
        pathToPic = nil;
    }
    
    if (pathToPic == nil) 
    {
        do
        {
            tmpImageNo++;
            pathToPic = [NSString stringWithFormat:@"%@-%03d.png", baseName, tmpImageNo];
        } while ([[NSFileManager defaultManager] fileExistsAtPath:pathToPic]);
    }
    
    if (!withFilename)
    {
        imageNo = tmpImageNo;
    }
    
    OOLog(@"screenshot", @"Saved screen shot \"%@\" (%u x %u pixels).", pathToPic, w, h);
    
    NSBitmapImageRep* bitmapRep = 
        [[NSBitmapImageRep alloc]
            initWithBitmapDataPlanes:NULL   // --> let the class allocate it
            pixelsWide:         w
            pixelsHigh:         h
            bitsPerSample:      8           // each component is 8 bits (1 byte)
            samplesPerPixel:    3           // number of components (R, G, B)
            hasAlpha:           NO          // no transparency
            isPlanar:           NO          // data integrated into single plane
            colorSpaceName:     NSDeviceRGBColorSpace
            bytesPerRow:        3*w         // can no longer let the class figure it out
            bitsPerPixel:       24          // can no longer let the class figure it out
        ];
    
    unsigned char *pixels = [bitmapRep bitmapData];
        
    OOGL(glReadPixels(0,0, w,h, GL_RED,   GL_UNSIGNED_BYTE, red));
    OOGL(glReadPixels(0,0, w,h, GL_GREEN, GL_UNSIGNED_BYTE, green));
    OOGL(glReadPixels(0,0, w,h, GL_BLUE,  GL_UNSIGNED_BYTE, blue));
    
    int x,y;
    for (y = 0; y < h; y++)
    {
        long index = (h - y - 1)*w;
        for (x = 0; x < w; x++)     // set bitmap pixels
        {
            *pixels++ = red[index];
            *pixels++ = green[index];
            *pixels++ = blue[index++];
        }
    }
    
    [[bitmapRep representationUsingType:NSPNGFileType properties:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], NSImageInterlaced, NULL]]
        writeToFile:pathToPic atomically:YES];          // save PNG representation of image
    
    // free allocated objects and memory
    [bitmapRep release];
    
FAIL:
    free(red);
    free(green);
    free(blue);
    
    // return to the previous directory
    [[NSFileManager defaultManager] changeCurrentDirectoryPath:originalDirectory];
    return snapShotOK;
}

snapShot: [2/2]

- (BOOL) snapShot:

(NSString *)

filename

stringToClipboard: [1/2]

- (void) stringToClipboard:

(NSString *)

stringToCopy

Definition at line 50 of file MyOpenGLView.m.

                          :(NSString *)stringToCopy
{
    NSPasteboard *clipBoard = [NSPasteboard generalPasteboard];
    [clipBoard declareTypes:[NSArray arrayWithObject:NSPasteboardTypeString] owner:nil];
    [clipBoard setString:stringToCopy forType:NSPasteboardTypeString];
}

stringToClipboard: [2/2]

- (void) stringToClipboard:

(NSString *)

stringToCopy

suppressKeysUntilKeyUp [1/2]

- (void) suppressKeysUntilKeyUp

Definition at line 50 of file MyOpenGLView.m.

{
    if (keys[gvMouseDoubleClick] == NO)
    {
        suppressKeys = YES;
        [self clearKeys];
    }
    else
    {
        [self clearMouse];
    }
}

suppressKeysUntilKeyUp [2/2]

- (void) suppressKeysUntilKeyUp

toggleScreenMode

- (void) toggleScreenMode

touchesEndedWithEvent:

- (void) touchesEndedWithEvent: (NSEvent *) theEvent

implementation

Definition at line 50 of file MyOpenGLView.m.

                              :(NSEvent *)theEvent
{
    [self recenterVirtualJoystick];
}

translateKeyCode:

- (int) translateKeyCode: (int) input

implementation

Provided by category MyOpenGLView(Internal).

Definition at line 50 of file MyOpenGLView.m.

                        : (int) input
{
    int key = input;
    switch ( input )
    {
        case NSUpArrowFunctionKey:
            key = gvArrowKeyUp;
            break;
        
        case NSDownArrowFunctionKey:
            key = gvArrowKeyDown;
            break;
            
        case NSLeftArrowFunctionKey:
            key = gvArrowKeyLeft;
            break;
            
        case NSRightArrowFunctionKey:
            key = gvArrowKeyRight;
            break;
        
        case NSF1FunctionKey:
            key = gvFunctionKey1;
            break;
            
        case NSF2FunctionKey:
            key = gvFunctionKey2;
            break;
            
        case NSF3FunctionKey:
            key = gvFunctionKey3;
            break;
            
        case NSF4FunctionKey:
            key = gvFunctionKey4;
            break;
            
        case NSF5FunctionKey:
            key = gvFunctionKey5;
            break;
            
        case NSF6FunctionKey:
            key = gvFunctionKey6;
            break;
            
        case NSF7FunctionKey:
            key = gvFunctionKey7;
            break;
            
        case NSF8FunctionKey:
            key = gvFunctionKey8;
            break;
            
        case NSF9FunctionKey:
            key = gvFunctionKey9;
            break;
            
        case NSF10FunctionKey:
            key = gvFunctionKey10;
            break;
            
        case NSF11FunctionKey:
            key = gvFunctionKey11;
            break;
            
        case NSHomeFunctionKey:
            key = gvHomeKey;
            break;
        
        case NSBackspaceCharacter:
            key = gvBackspaceKey;
            break;
 
        case NSDeleteCharacter:
            key = gvDeleteKey;
            break;
            
        case NSInsertFunctionKey:
            key = gvInsertKey;
            break;
            
        case NSEndFunctionKey:
            key = gvEndKey;
            break;
            
        case NSPageUpFunctionKey:
            key = gvPageUpKey;
            break;
            
        case NSPageDownFunctionKey:
            key = gvPageDownKey;
            break;
        
        case NSPrintScreenFunctionKey:
            key = gvPrintScreenKey;
            break;
        
        case NSPauseFunctionKey:
            key = gvPauseKey;
            break;
 
        default:
            break;
    }
    return key;
}

typedString [1/2]

- (NSString *) typedString

typedString [2/2]

- (NSString *) typedString

UnapplyCursorState

+ (static void) UnapplyCursorState (OOMouseInteractionMode) mode

implementation

Definition at line 1350 of file MyOpenGLView.m.

{
    BOOL hidden, obscured;
    GetDesiredCursorState(mode, &hidden, &obscured);
    if (hidden)  [NSCursor unhide];
    if (obscured)  [NSCursor setHiddenUntilMouseMoves:NO];
}

update

- (void) update

implementation

Definition at line 50 of file MyOpenGLView.m.

{
    NSOpenGLContext *context = [self openGLContext];
    
    [context update];
    int virtualScreen = [context currentVirtualScreen];
    if (virtualScreen != _virtualScreen)
    {
        @try
        {
            [[OOGraphicsResetManager sharedManager] resetGraphicsState];
            _virtualScreen = virtualScreen;
        }
        @catch (NSException *exception)
        {
            /*  Graphics reset failed, most likely because of OpenGL context
                incompatibility. Reset to previous "virtual screen" (i.e.,
                renderer). OS X's OpenGL implementation will take care of
                copying 
            */
            [context setCurrentVirtualScreen:_virtualScreen];
            [[OOGraphicsResetManager sharedManager] resetGraphicsState];    // If this throws, we're screwed.
            
            if ([[self gameController] inFullScreenMode])
            {
                [[self gameController] pauseFullScreenModeToPerform:@selector(noteMovedToBadDisplay) onTarget:self];
            }
            else
            {
                [self noteMovedToBadDisplay];
            }
        }
    }
}

updateScreen [1/2]

- (void) updateScreen

Definition at line 50 of file MyOpenGLView.m.

{
    if ([[self window] isVisible])
    {
        [self drawRect:NSMakeRect(0, 0, viewSize.width, viewSize.height)];
    }
}

updateScreen [2/2]

- (void) updateScreen

updateScreenWithVideoMode:

- (void) updateScreenWithVideoMode:

(BOOL)

v_mode

Definition at line 50 of file MyOpenGLView.m.

                                  :(BOOL) v_mode
{
    if ((viewSize.width != surface->w)||(viewSize.height != surface->h)) // resized
    {
#if OOLITE_LINUX
        m_glContextInitialized = NO; //probably not needed
#endif
        viewSize.width = surface->w;
        viewSize.height = surface->h;
    }
 
    if (m_glContextInitialized == NO)
    {
        [self initialiseGLWithSize:viewSize useVideoMode:v_mode];
    }
 
    if (surface == 0)
        return;
 
    // do all the drawing!
    //
    if (UNIVERSE)  [UNIVERSE drawUniverse];
    else
    {
        // not set up yet, draw a black screen
        glClearColor( 0.0, 0.0, 0.0, 0.0);
        glClear( GL_COLOR_BUFFER_BIT);
    }
 
    SDL_GL_SwapBuffers();
}

viewSize [1/2]

- (NSSize) viewSize

viewSize [2/2]

- (NSSize) viewSize

virtualJoystickPosition [1/2]

- (NSPoint) virtualJoystickPosition

virtualJoystickPosition [2/2]

- (NSPoint) virtualJoystickPosition

x_offset [1/2]

- (GLfloat) x_offset

x_offset [2/2]

- (GLfloat) x_offset

y_offset [1/2]

- (GLfloat) y_offset

y_offset [2/2]

- (GLfloat) y_offset

Member Data Documentation

_colorSaturation

- (float) _colorSaturation

protected

Definition at line 218 of file MyOpenGLView.h.

_fov

- (float) _fov

private

Definition at line 160 of file MyOpenGLView.h.

_gamma

- (float) _gamma

protected

Definition at line 188 of file MyOpenGLView.h.

_hdrOutput

- (BOOL) _hdrOutput

protected

Definition at line 220 of file MyOpenGLView.h.

_mouseWheelDelta

- (float) _mouseWheelDelta

private

Definition at line 153 of file MyOpenGLView.h.

_msaa

- (BOOL) _msaa

protected

Definition at line 190 of file MyOpenGLView.h.

_pixelFormatAttributes

- (NSData*) _pixelFormatAttributes

private

Definition at line 163 of file MyOpenGLView.h.

_virtualScreen

- (int) _virtualScreen

private

Definition at line 162 of file MyOpenGLView.h.

allowingStringInput

- (enum StringInput) allowingStringInput

private

Definition at line 136 of file MyOpenGLView.h.

backingViewSize

- (NSSize) backingViewSize

private

Definition at line 156 of file MyOpenGLView.h.

bounds

- (NSRect) bounds

protected

Definition at line 186 of file MyOpenGLView.h.

capsLockOn

- (BOOL) capsLockOn

private

Definition at line 135 of file MyOpenGLView.h.

command

- (BOOL) command

private

Definition at line 135 of file MyOpenGLView.h.

commandF

- (BOOL) commandF

private

Definition at line 139 of file MyOpenGLView.h.

commandQ

- (BOOL) commandQ

private

Definition at line 138 of file MyOpenGLView.h.

ctrl

- (BOOL) ctrl

private

Definition at line 135 of file MyOpenGLView.h.

currentSize

- (int) currentSize

protected

Definition at line 194 of file MyOpenGLView.h.

currentWindowSize

- (NSSize) currentWindowSize

protected

Definition at line 198 of file MyOpenGLView.h.

display_z

- (GLfloat) display_z

private

Definition at line 157 of file MyOpenGLView.h.

doubleClick

- (BOOL) doubleClick

private

Definition at line 148 of file MyOpenGLView.h.

f12

- (BOOL) f12

private

Definition at line 140 of file MyOpenGLView.h.

firstScreen

- (NSSize) firstScreen

protected

Definition at line 224 of file MyOpenGLView.h.

fullScreen

- (BOOL) fullScreen

protected

Definition at line 195 of file MyOpenGLView.h.

gameController

- (GameController *) gameController

private

Definition at line 126 of file MyOpenGLView.h.

grabMouseStatus

- (BOOL) grabMouseStatus

protected

Definition at line 222 of file MyOpenGLView.h.

isAlphabetKeyDown

- (BOOL) isAlphabetKeyDown

private

Definition at line 137 of file MyOpenGLView.h.

keycodetrans

- (int) keycodetrans

private

Definition at line 142 of file MyOpenGLView.h.

keyMappings_normal

- (NSDictionary *) keyMappings_normal

private

Definition at line 130 of file MyOpenGLView.h.

keyMappings_shifted

- (NSDictionary *) keyMappings_shifted

private

Definition at line 131 of file MyOpenGLView.h.

keys

- (BOOL) keys

private

Definition at line 128 of file MyOpenGLView.h.

lastKeyShifted

- (BOOL) lastKeyShifted

private

Definition at line 135 of file MyOpenGLView.h.

m_glContextInitialized

- (BOOL) m_glContextInitialized

private

Definition at line 144 of file MyOpenGLView.h.

matrixManager

- (OOOpenGLMatrixManager *) matrixManager

private

Definition at line 165 of file MyOpenGLView.h.

mouseDragStartPoint

- (NSPoint) mouseDragStartPoint

protected

Definition at line 169 of file MyOpenGLView.h.

mouseInDeltaMode

- (BOOL) mouseInDeltaMode

protected

Definition at line 229 of file MyOpenGLView.h.

mouseWarped

- (BOOL) mouseWarped

protected

Definition at line 171 of file MyOpenGLView.h.

opt

- (BOOL) opt

private

Definition at line 135 of file MyOpenGLView.h.

scancode2Unicode

- (int) scancode2Unicode

private

Definition at line 129 of file MyOpenGLView.h.

screenSizes

- (NSMutableArray*) screenSizes

protected

Definition at line 193 of file MyOpenGLView.h.

shift

- (BOOL) shift

private

Definition at line 135 of file MyOpenGLView.h.

showSplashScreen

- (BOOL) showSplashScreen

protected

Definition at line 201 of file MyOpenGLView.h.

squareX

- (double) squareX

protected

Definition at line 185 of file MyOpenGLView.h.

squareY

- (double) squareY

protected

Definition at line 185 of file MyOpenGLView.h.

suppressKeys

- (BOOL) suppressKeys

private

Definition at line 133 of file MyOpenGLView.h.

surface

- (SDL_Surface*) surface

protected

Definition at line 199 of file MyOpenGLView.h.

timeIntervalAtLastClick

- (NSTimeInterval) timeIntervalAtLastClick

private

Definition at line 146 of file MyOpenGLView.h.

timeIntervalAtLastMouseWheel

- (NSTimeInterval) timeIntervalAtLastMouseWheel

private

Definition at line 147 of file MyOpenGLView.h.

timeSinceLastMouseWheel

- (NSTimeInterval) timeSinceLastMouseWheel

protected

Definition at line 174 of file MyOpenGLView.h.

typedString

- (NSString *) typedString

private

Definition at line 150 of file MyOpenGLView.h.

viewSize

- (NSSize) viewSize

private

Definition at line 155 of file MyOpenGLView.h.

Referenced by HeadUpDisplay::drawScannerGrid.

virtualJoystickPosition

- (NSPoint) virtualJoystickPosition

private

Definition at line 152 of file MyOpenGLView.h.

x_offset

- (GLfloat) x_offset

private

Definition at line 158 of file MyOpenGLView.h.

y_offset

- (GLfloat) y_offset

private

Definition at line 158 of file MyOpenGLView.h.

---

The documentation for this class was generated from the following files:

• src/Cocoa/MyOpenGLView.h
• src/SDL/MyOpenGLView.h
• src/Cocoa/MyOpenGLView.m
• src/SDL/MyOpenGLView.m