Tracking Renderer Changes

It's fairly straightforward to track geometry changes, but how are renderer changes tracked? This is where the concept of a virtual screen becomes important (see Virtual Screens). A change in the virtual screen indicates a renderer change, a change in renderer capability, or both. When your application detects a window resize event, window move event, or display change, it should check for a virtual screen change and respond to the change to ensure that the current application state reflects any changes in renderer capabilities.

Each of the Apple-specific OpenGL APIs has a function that returns the current virtual screen number:

• The currentVirtualScreen method of the NSOpenGLContext class

• The CGLGetVirtualScreen function

The virtual screen number represents an index in the list of virtual screens that were set up specifically for the pixel format object used for the rendering context. The number is unique to the list but is meaningless otherwise.

When the renderer changes, the limits and extensions available to OpenGL may also change. Your application should retest the capabilities of the renderer and use these to choose its rendering algorithms appropriately. See Determining the OpenGL Capabilities Supported by the Renderer.

Updating a Rendering Context for a Custom Cocoa View

If you subclass NSView instead of using the NSOpenGLView class, your application must update the rendering context. That's due to a slight difference between the events normally handled by the NSView class and those handled by the NSOpenGLView class. Cocoa does not call a reshape method for the NSView class when the size changes because that class does not export a reshape method to override. Instead, you need to perform reshape operations directly in your drawRect: method, looking for changes in view bounds prior to drawing content. Using this approach provides results that are equivalent to using the reshape method of the NSOpenGLView class.

Listing 7-1 is a partial implementation of a custom view that shows how to handle context updates. The update method is called after move, resize, and display change events and when the surface needs updating. The class adds an observer to the notification NSViewGlobalFrameDidChangeNotification, which is posted whenever an NSView object that has attached surfaces (that is, NSOpenGLContext objects) resizes, moves, or changes coordinate offsets.

It's slightly more complicated to handle changes in the display configuration. For that, you need to register for the notification NSApplicationDidChangeScreenParametersNotification through the NSApplication class. This notification is posted whenever the configuration of any of the displays attached to the computer is changed (either programmatically or when the user changes the settings in the interface).

Listing 7-1  Handling context updates for a custom view

#import <Cocoa/Cocoa.h>

#import <OpenGL/OpenGL.h>

#import <OpenGL/gl.h>

@class NSOpenGLContext, NSOpenGLPixelFormat;

@interface CustomOpenGLView : NSView

{

  @private

  NSOpenGLContext*   _openGLContext;

  NSOpenGLPixelFormat* _pixelFormat;

}

- (id)initWithFrame:(NSRect)frameRect

        pixelFormat:(NSOpenGLPixelFormat*)format;

- (void)update;

@end

@implementation CustomOpenGLView

- (id)initWithFrame:(NSRect)frameRect

        pixelFormat:(NSOpenGLPixelFormat*)format

{

  self = [super initWithFrame:frameRect];

  if (self != nil) {

    _pixelFormat   = [format retain];

  [[NSNotificationCenter defaultCenter] addObserver:self

                   selector:@selector(_surfaceNeedsUpdate:)

                   name:NSViewGlobalFrameDidChangeNotification

                   object:self];

  }

  return self;

}

- (void)dealloc

  [[NSNotificationCenter defaultCenter] removeObserver:self

                     name:NSViewGlobalFrameDidChangeNotification

                     object:self];

  [self clearGLContext];

}

- (void)update

{

  if ([_openGLContext view] == self) {

    [_openGLContext update];

  }

}

- (void) _surfaceNeedsUpdate:(NSNotification*)notification

{

  [self update];

}

@end

Swap Interval Allows an Application to Synchronize Updates to the Screen Refresh

If the swap interval is set to 0 (the default), buffers are swapped as soon as possible, without regard to the vertical refresh rate of the monitor. If the swap interval is set to any other value, the buffers are swapped only during the vertical retrace of the monitor. For more information, see Synchronize with the Screen Refresh Rate.

You can use the following constants to specify that you are setting the swap interval value:

• For Cocoa, use NSOpenGLCPSwapInterval.

• If you are using the CGL API, use kCGLCPSwapInterval as shown in Listing 7-2.

Listing 7-2  Using CGL to set up synchronization

GLint sync = 1;

// ctx must be a valid context

CGLSetParameter (ctx, kCGLCPSwapInterval, &sync);

Surface Opacity Specifies How the OpenGL Surface Blends with Surfaces Behind It

OpenGL surfaces are typically rendered as opaque. Thus the background color for pixels with alpha values of 0.0 is the surface background color. If you set the value of the surface opacity parameter to 0, then the contents of the surface are blended with the contents of surfaces behind the OpenGL surface. This operation is equivalent to OpenGL blending with a source contribution proportional to the source alpha and a background contribution proportional to 1 minus the source alpha. A value of 1 means the surface is opaque (the default); 0 means completely transparent.

You can use the following constants to specify that you are setting the surface opacity value:

• For Cocoa, use NSOpenGLCPSurfaceOpacity.

• If you are using the CGL API, use kCGLCPSurfaceOpacity as shown in Listing 7-3.

Listing 7-3  Using CGL to set surface opacity

GLint opaque = 0;

// ctx must be a valid context

CGLSetParameter (ctx, kCGLCPSurfaceOpacity, &opaque);

Surface Drawing Order Specifies the Position of the OpenGL Surface Relative to the Window

A value of 1 means that the position is above the window; a value of –1 specifies a position that is below the window. When you have overlapping views, setting the order to -1 causes OpenGL to draw underneath, 1 causes OpenGL to draw on top. This parameter is useful for drawing user interface controls on top of an OpenGL view.

You can use the following constants to specify that you are setting the surface drawing order value:

• For Cocoa, use NSOpenGLCPSurfaceOrder.

• If you are using the CGL API, use kCGLCPSurfaceOrder as shown in Listing 7-4.

Listing 7-4  Using CGL to set surface drawing order

GLint order = –1; // below window

// ctx must be a valid context

CGLSetParameter (ctx, kCGLCPSurfaceOrder, &order);

Determining Whether Vertex and Fragment Processing Happens on the GPU

CGL provides two parameters for checking whether the system is using the GPU for processing: kCGLCPGPUVertexProcessing and kCGLCPGPUFragmentProcessing. To check vertex processing, pass the vertex constant to the CGLGetParameter function. To check fragment processing, pass the fragment constant to CGLGetParameter. Listing 7-5 demonstrates how to use these parameters.

Listing 7-5  Using CGL to check whether the GPU is processing vertices and fragments

BOOL gpuProcessing;

GLint fragmentGPUProcessing, vertexGPUProcessing;

CGLGetParameter (CGLGetCurrentContext(), kCGLCPGPUFragmentProcessing,

                                         &fragmentGPUProcessing);

CGLGetParameter(CGLGetCurrentContext(), kCGLCPGPUVertexProcessing,

                                         &vertexGPUProcessing);

gpuProcessing = (fragmentGPUProcessing && vertexGPUProcessing) ? YES : NO;

Controlling the Back Buffer Size

Normally, the back buffer is the same size as the window or view that it's drawn into, and it changes size when the window or view changes size. For a window whose size is 720×pixels, the OpenGL back buffer is sized to match. If the window grows to 1024×768 pixels, for example, then the back buffer is resized as well. If you do not want this behavior, use the back buffer size control parameter.

Using this parameter fixes the size of the back buffer and lets the system scale the image automatically when it moves the data to a variable size buffer (see Figure 7-1). The size of the back buffer remains fixed at the size that you set up regardless of whether the image is resized to display larger onscreen.

You can use the following constants to specify that you are setting the surface backing size:

• If you are using the CGL API, use kCGLCPSurfaceBackingSize, as shown in Listing 7-6.

Listing 7-6  Using CGL to set up back buffer size control

GLint dim[2] = {720, 480};

// ctx must be a valid context

CGLSetParameter(ctx, kCGLCPSurfaceBackingSize, dim);

CGLEnable (ctx, kCGLCESurfaceBackingSize);