Rooba
/
boinc
mirror of https://github.com/BOINC/boinc.git
1
0
Fork 0
Code Issues 1 Packages Projects Releases Wiki Activity
boinc/api/mac_carbon_gl.cpp

541 lines
17 KiB
C++
Executable File
Raw Blame History

// The contents of this file are subject to the Mozilla Public License
// Version 1.0 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// http://www.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
// License for the specific language governing rights and limitations
// under the License.
//
// The Original Code is the Berkeley Open Infrastructure for Network Computing.
//
// The Initial Developer of the Original Code is the SETI@home project.
// Portions created by the SETI@home project are Copyright (C) 2002
// University of California at Berkeley. All Rights Reserved.
//
// Contributor(s):
//
/*
Contains: Functions to enable building and destorying a GL full screen or windowed context
Written by: Geoff Stahl (ggs)
Copyright: Copyright © 1999 Apple Computer, Inc., All Rights Reserved
Disclaimer: You may incorporate this sample code into your applications without
restriction, though the sample code has been provided "AS IS" and the
responsibility for its operation is 100% yours. However, what you are
not permitted to do is to redistribute the source as "DSC Sample Code"
after having made changes. If you're going to re-distribute the source,
we require that you make it clear in the source that the code was
descended from Apple Sample Code, but that you've made changes.
Adapted to BOINC by Eric Heien
*/
// system includes ----------------------------------------------------------
#ifdef __APPLE_CC__
#include <AGL/agl.h>
#else
#include <Gestalt.h>
#include <MacTypes.h>
#include <DriverServices.h>
#include <Timer.h>
#include <Math64.h>
#include <agl.h>
#include <gl.h>
#endif
#include <stdio.h>
// project includes ---------------------------------------------------------
#include "mac_carbon_gl.h"
#include "graphics_api.h"
#include "mac_app_opengl.h"
#include "util.h"
extern WindowRef appGLWindow;
// --------------------------------------------------------------------------
// BuildGLonWindow
// Takes a window and tries to build on it
// Inputs: aglDraw: a valid AGLDrawable
// *pcontextInfo: request and requirements for cotext and drawable
// Outputs: *paglContext as allocated
// *pcontextInfo: allocated parameters
// if fail to allocate: paglContext will be NULL
// if error: will return error and paglContext will be NULL
OSStatus BuildGLonWindow (WindowPtr pWindow, AGLContext* paglContext, pstructGLWindowInfo pcontextInfo)
{
GDHandle hGD = NULL;
GrafPtr cgrafSave = NULL;
short numDevices;
OSStatus err = noErr;
GetPort (&cgrafSave);
SetPortWindowPort(pWindow);
// check renderer VRAM and acceleration
numDevices = FindGDHandleFromWindow (pWindow, &hGD);
// do agl
if ((Ptr) kUnresolvedCFragSymbolAddress == (Ptr) aglChoosePixelFormat) { // check for existance of OpenGL
ReportError ("OpenGL not installed");
return NULL;
}
// we successfully passed the renderer check
pcontextInfo->fmt = aglChoosePixelFormat (NULL, 0, pcontextInfo->aglAttributes); // get an appropriate pixel format
aglReportError ();
if (NULL == pcontextInfo->fmt) {
ReportError("Could not find valid pixel format");
return NULL;
}
*paglContext = aglCreateContext (pcontextInfo->fmt, NULL); // Create an AGL context
aglReportError ();
if (NULL == *paglContext) {
ReportError ("Could not create context");
return NULL;
}
if (!aglSetDrawable (*paglContext, GetWindowPort (pWindow))) // attach the CGrafPtr to the context
return aglReportError ();
if(!aglSetCurrentContext (*paglContext)) // make the context the current context
return aglReportError ();
SetPort (cgrafSave);
return err;
}
#pragma mark -
// functions (public) -------------------------------------------------------
// DestroyGLFromWindow
// Destroys context that waas allocated with BuildGLFromWindow
// Ouputs: *paglContext should be NULL on exit
OSStatus DestroyGLFromWindow (AGLContext* paglContext, pstructGLWindowInfo pcontextInfo) {
OSStatus err;
if ((!paglContext) || (!*paglContext))
return paramErr; // not a valid context
glFinish ();
aglSetCurrentContext (NULL);
err = aglReportError ();
aglSetDrawable (*paglContext, NULL);
err = aglReportError ();
aglDestroyContext (*paglContext);
err = aglReportError ();
*paglContext = NULL;
if (pcontextInfo->fmt) {
aglDestroyPixelFormat (pcontextInfo->fmt); // pixel format is no longer valid
err = aglReportError ();
}
pcontextInfo->fmt = 0;
return err;
}
//-----------------------------------------------------------------------------------------------------------------------
// SuspendFullScreenGL
// Special suspend function to ensure the the GL window is hidden
// needs to be reviewed
OSStatus SuspendFullScreenGL (AGLDrawable aglDraw, AGLContext aglContext) {
if (aglDraw && aglContext) { // will only have a drawable
glFinish (); // must do this to ensure the queue is complete
aglSetCurrentContext (NULL);
HideWindow (GetWindowFromPort (aglDraw));
return aglReportError ();
}
return noErr;
}
//-----------------------------------------------------------------------------------------------------------------------
// ResumeFullScreenGL
// Needs a special resume function to ensure the the GL window is shown
// needs to be reviewed
OSStatus ResumeFullScreenGL (AGLDrawable aglDraw, AGLContext aglContext) {
if (aglDraw && aglContext) {
ShowWindow (GetWindowFromPort (aglDraw));
aglSetCurrentContext (aglContext);
aglUpdateContext (aglContext);
return aglReportError ();
}
return paramErr;
}
// --------------------------------------------------------------------------
// GetWindowDevice
// Inputs: a valid WindowPtr
// Outputs: the GDHandle that that window is mostly on
// returns the number of devices that the windows content touches
short FindGDHandleFromWindow (WindowPtr pWindow, GDHandle * phgdOnThisDevice)
{
GrafPtr pgpSave;
Rect rectWind, rectSect;
long greatestArea, sectArea;
short numDevices = 0;
GDHandle hgdNthDevice;
if (!pWindow || !phgdOnThisDevice)
return NULL;
*phgdOnThisDevice = NULL;
GetPort (&pgpSave);
SetPortWindowPort (pWindow);
GetWindowPortBounds (pWindow, &rectWind);
LocalToGlobal ((Point*)& rectWind.top); // convert to global coordinates
LocalToGlobal ((Point*)& rectWind.bottom);
hgdNthDevice = GetDeviceList ();
greatestArea = 0;
// check window against all gdRects in gDevice list and remember
// which gdRect contains largest area of window}
while (hgdNthDevice)
{
if (TestDeviceAttribute (hgdNthDevice, screenDevice)) {
if (TestDeviceAttribute (hgdNthDevice, screenActive))
{
// The SectRect routine calculates the intersection
// of the window rectangle and this gDevice
// rectangle and returns TRUE if the rectangles intersect,
// FALSE if they don't.
SectRect (&rectWind, &(**hgdNthDevice).gdRect, &rectSect);
// determine which screen holds greatest window area
// first, calculate area of rectangle on current device
sectArea = (long) (rectSect.right - rectSect.left) * (rectSect.bottom - rectSect.top);
if (sectArea > 0)
numDevices++;
if (sectArea > greatestArea)
{
greatestArea = sectArea; // set greatest area so far
*phgdOnThisDevice = hgdNthDevice; // set zoom device
}
hgdNthDevice = GetNextDevice(hgdNthDevice);
}
}
}
SetPort (pgpSave);
return numDevices;
}
#pragma mark -
//-----------------------------------------------------------------------------------------------------------------------
GLuint BuildFontGL (AGLContext ctx, GLint fontID, Style face, GLint size)
{
GLuint listBase = glGenLists (256);
if (aglUseFont (ctx, fontID , face, size, 0, 256, (long) listBase)) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
return listBase;
} else {
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glDeleteLists (listBase, 256);
return 0;
}
}
//-----------------------------------------------------------------------------------------------------------------------
void DeleteFontGL (GLuint fontList)
{
if (fontList)
glDeleteLists (fontList, 256);
}
#pragma mark -
// --------------------------------------------------------------------------
// central error reporting
void ReportErrorNum (char * strError, long numError)
{
fprintf (stderr, "%s %ld (0x%lx)\n", strError, numError, numError);
}
// --------------------------------------------------------------------------
void ReportError (char * strError)
{
fprintf (stderr, "%s\n", strError);
}
//-----------------------------------------------------------------------------------------------------------------------
OSStatus DSpReportError (OSStatus error)
{
switch (error)
{
case noErr:
break;
case kDSpNotInitializedErr:
ReportError ("DSp Error: Not initialized");
break;
case kDSpSystemSWTooOldErr:
ReportError ("DSp Error: system Software too old");
break;
case kDSpInvalidContextErr:
ReportError ("DSp Error: Invalid context");
break;
case kDSpInvalidAttributesErr:
ReportError ("DSp Error: Invalid attributes");
break;
case kDSpContextAlreadyReservedErr:
ReportError ("DSp Error: Context already reserved");
break;
case kDSpContextNotReservedErr:
ReportError ("DSp Error: Context not reserved");
break;
case kDSpContextNotFoundErr:
ReportError ("DSp Error: Context not found");
break;
case kDSpFrameRateNotReadyErr:
ReportError ("DSp Error: Frame rate not ready");
break;
case kDSpConfirmSwitchWarning:
// ReportError ("DSp Warning: Must confirm switch"); // removed since it is just a warning, add back for debugging
return 0; // don't want to fail on this warning
break;
case kDSpInternalErr:
ReportError ("DSp Error: Internal error");
break;
case kDSpStereoContextErr:
ReportError ("DSp Error: Stereo context");
break;
}
return error;
}
//-----------------------------------------------------------------------------------------------------------------------
// if error dump agl errors to debugger string, return error
OSStatus aglReportError (void)
{
GLenum err = aglGetError();
if (AGL_NO_ERROR != err)
ReportError ((char *)aglErrorString(err));
// ensure we are returning an OSStatus noErr if no error condition
if (err == AGL_NO_ERROR)
return noErr;
else
return (OSStatus) err;
}
//-----------------------------------------------------------------------------------------------------------------------
// if error dump gl errors to debugger string, return error
OSStatus glReportError (void)
{
GLenum err = glGetError();
switch (err)
{
case GL_NO_ERROR:
break;
case GL_INVALID_ENUM:
ReportError ("GL Error: Invalid enumeration");
break;
case GL_INVALID_VALUE:
ReportError ("GL Error: Invalid value");
break;
case GL_INVALID_OPERATION:
ReportError ("GL Error: Invalid operation");
break;
case GL_STACK_OVERFLOW:
ReportError ("GL Error: Stack overflow");
break;
case GL_STACK_UNDERFLOW:
ReportError ("GL Error: Stack underflow");
break;
case GL_OUT_OF_MEMORY:
ReportError ("GL Error: Out of memory");
break;
}
// ensure we are returning an OSStatus noErr if no error condition
if (err == GL_NO_ERROR)
return noErr;
else
return (OSStatus) err;
}
// --------------------------------------------------------------------------
void DoUpdate (AGLContext aglContext)
{
Rect portRect;
int width, height;
if (aglContext)
{
aglSetCurrentContext (aglContext);
aglUpdateContext (aglContext);
GetWindowBounds( appGLWindow, kWindowContentRgn, &portRect );
width = portRect.right - portRect.left;
height = portRect.bottom - portRect.top;
ReSizeGLScene(width,height);
app_render(width, height, time(0)); // Here's Where We Do All The Drawing
aglSwapBuffers(aglContext); // send swap command
}
}
/*
Contains: Functions to enable building and destroying a DSp fullscreen context
*/
// globals (internal/private) -----------------------------------------------
Boolean gDSpStarted = false; // will never be true unless DSp is installed and start succeeds
// functions (public) -------------------------------------------------------
// StartDSp
// handles starting up DrawSprocket
OSStatus StartDSp (void)
{
OSStatus err = noErr;
if (!gDSpStarted) {
// check for DSp
if ((Ptr) kUnresolvedCFragSymbolAddress == (Ptr) DSpStartup) {
ReportError ("DSp not installed");
return kDSpNotInitializedErr;
} else {
err = DSpReportError (DSpStartup()); // start DSp
if (noErr != err)
return err;
else
gDSpStarted = true;
}
}
return err;
}
// --------------------------------------------------------------------------
// ShutdownDSpContext
// shuts down DrawSprocket
void ShutdownDSp (void)
{
if (gDSpStarted) {
DSpShutdown ();
gDSpStarted = false;
}
}
#pragma mark -
// --------------------------------------------------------------------------
// GetDSpDrawable
// Just returns the front buffer
// Inputs: *pdspContext
// pcontextInfo: request and requirements for cotext and drawable
// Outputs: returns CGrafPtr thaat is front buffer of context
// if error: will return NULL
CGrafPtr GetDSpDrawable (DSpContextReference dspContext)
{
CGrafPtr pCGraf = NULL;
if (noErr == DSpReportError (DSpContext_GetFrontBuffer (dspContext, &pCGraf)))
return pCGraf;
else
return NULL;
}
//-----------------------------------------------------------------------------------------------------------------------
// Deactivates and dumps context
void DestroyDSpContext (DSpContextReference* pdspContext)
{
if (gDSpStarted) {
if (*pdspContext) {
DSpReportError (DSpContext_SetState(*pdspContext, kDSpContextState_Inactive));
DSpReportError (DSpContext_CustomFadeGammaIn (NULL, fadeTicks));
DSpReportError (DSpContext_Release (*pdspContext));
*pdspContext = NULL;
}
}
}
#pragma mark -
//-----------------------------------------------------------------------------------------------------------------------
OSStatus DSpContext_CustomFadeGammaIn (DSpContextReference inContext, long fadeTicks)
{
OSStatus err = noErr;
RGBColor inZeroIntensityColor;
UInt32 currTick;
UInt16 step = (UInt16) (800 / fadeTicks);
long x, percent = 0;
if (gDSpStarted)
{
if (fadeTicks == 0)
fadeTicks = 1;
inZeroIntensityColor.red = 0x0000;
inZeroIntensityColor.green = 0x0000;
inZeroIntensityColor.blue = 0x0000;
currTick = TickCount ();
for (x = 1; x <= fadeTicks; x++)
{
percent = step * x / 8;
err = DSpContext_FadeGamma(inContext, percent, &inZeroIntensityColor);
if (err != noErr) break;
while (currTick >= TickCount ()) {}
currTick = TickCount ();
}
if (err == noErr)
err = DSpContext_FadeGamma(inContext, 100, &inZeroIntensityColor);
}
return err;
}
//-----------------------------------------------------------------------------------------------------------------------
OSStatus DSpContext_CustomFadeGammaOut (DSpContextReference inContext, long fadeTicks )
{
OSStatus err = noErr;
RGBColor inZeroIntensityColor;
UInt32 currTick;
UInt16 step = (UInt16) (800 / fadeTicks);
long x, percent = 0;
if (gDSpStarted)
{
if (fadeTicks == 0)
fadeTicks = 1; // ensure we do not have zero fade time
inZeroIntensityColor.red = 0x0000;
inZeroIntensityColor.green = 0x0000;
inZeroIntensityColor.blue = 0x0000;
currTick = TickCount ();
for (x = fadeTicks - 1; x >= 0; x--)
{
percent = step * x / 8;
err = DSpContext_FadeGamma(inContext, percent, &inZeroIntensityColor);
if (err != noErr) break;
while (currTick >= TickCount ()) {}
currTick = TickCount ();
}
}
return err;
}
Reference in New Issue View Git Blame Copy Permalink