static int mac_shadow_detect_monitors(macShadowSubsystem* subsystem)
{
size_t wide, high;
MONITOR_DEF* monitor;
CGDirectDisplayID displayId;
displayId = CGMainDisplayID();
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(displayId);
subsystem->pixelWidth = CGDisplayModeGetPixelWidth(mode);
subsystem->pixelHeight = CGDisplayModeGetPixelHeight(mode);
wide = CGDisplayPixelsWide(displayId);
high = CGDisplayPixelsHigh(displayId);
CGDisplayModeRelease(mode);
subsystem->retina = ((subsystem->pixelWidth / wide) == 2) ? TRUE : FALSE;
if (subsystem->retina)
{
subsystem->width = wide;
subsystem->height = high;
}
else
{
subsystem->width = subsystem->pixelWidth;
subsystem->height = subsystem->pixelHeight;
}
subsystem->numMonitors = 1;
monitor = &(subsystem->monitors[0]);
monitor->left = 0;
monitor->top = 0;
monitor->right = subsystem->width;
monitor->bottom = subsystem->height;
monitor->flags = 1;
return 1;
}
VideoMode VideoModeImpl::getDesktopMode()
{
CGDirectDisplayID display = CGMainDisplayID();
return VideoMode(CGDisplayPixelsWide(display),
CGDisplayPixelsHigh(display),
displayBitsPerPixel(display));
}
void
listDisplays(void)
{
CGDisplayErr dErr;
CGDisplayCount displayCount, i;
CGDirectDisplayID mainDisplay;
CGDisplayCount maxDisplays = MAX_DISPLAYS;
CGDirectDisplayID onlineDisplays[MAX_DISPLAYS];
mainDisplay = CGMainDisplayID();
dErr = CGGetOnlineDisplayList(maxDisplays, onlineDisplays, &displayCount);
if (dErr != kCGErrorSuccess) {
fprintf(stderr, "CGGetOnlineDisplayList: error %d.\n", dErr);
exit(1);
}
printf("Display ID Resolution\n");
for (i = 0; i < displayCount; i++) {
CGDirectDisplayID dID = onlineDisplays[i];
printf("%-16p %lux%lu %32s", dID,
CGDisplayPixelsWide(dID), CGDisplayPixelsHigh(dID),
(dID == mainDisplay) ? "[main display]\n" : "\n");
}
exit(0);
}
void praat_reportGraphicalProperties () {
MelderInfo_open ();
MelderInfo_writeLine (U"Graphical properties of this edition of Praat on this computer:\n");
double x, y, width, height;
Gui_getWindowPositioningBounds (& x, & y, & width, & height);
MelderInfo_writeLine (U"Window positioning area: x = ", x, U", y = ", y,
U", width = ", width, U", height = ", height);
#if defined (macintosh)
CGDirectDisplayID screen = CGMainDisplayID ();
CGSize screenSize_mm = CGDisplayScreenSize (screen);
double diagonal_mm = sqrt (screenSize_mm. width * screenSize_mm. width + screenSize_mm. height * screenSize_mm. height);
double diagonal_inch = diagonal_mm / 25.4;
MelderInfo_writeLine (U"\nScreen size: ", screenSize_mm. width, U" x ", screenSize_mm. height,
U" mm (diagonal ", Melder_fixed (diagonal_mm, 1), U" mm = ", Melder_fixed (diagonal_inch, 1), U" inch)");
size_t screenWidth_pixels = CGDisplayPixelsWide (screen);
size_t screenHeight_pixels = CGDisplayPixelsHigh (screen);
MelderInfo_writeLine (U"Screen \"resolution\": ", screenWidth_pixels, U" x ", screenHeight_pixels, U" pixels");
double resolution = 25.4 * screenWidth_pixels / screenSize_mm. width;
MelderInfo_writeLine (U"Screen resolution: ", Melder_fixed (resolution, 1), U" pixels/inch");
#elif defined (_WIN32)
/*for (int i = 0; i <= 88; i ++)
MelderInfo_writeLine (U"System metric ", i, U": ", GetSystemMetrics (i));*/
#endif
MelderInfo_close ();
}
static void setup_screen(void) {
CGDirectDisplayID targetDisplay = kCGDirectMainDisplay;
CGDisplayCapture(targetDisplay); /* crucial for being permitted to write on it */
screen.base = (uint32_t *) CGDisplayBaseAddress(targetDisplay);
screen.stride = CGDisplayBytesPerRow(targetDisplay) / sizeof(uint32_t);
screen.width = CGDisplayPixelsWide(targetDisplay);
screen.height = CGDisplayPixelsHigh(targetDisplay);
}
Status GetVideoMode(int* xres, int* yres, int* bpp, int* freq)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
CGDisplayModeRef currentMode = CGDisplayCopyDisplayMode(kCGDirectMainDisplay);
#else
CFDictionaryRef currentMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
#endif
if(xres)
*xres = (int)CGDisplayPixelsWide(kCGDirectMainDisplay);
if(yres)
*yres = (int)CGDisplayPixelsHigh(kCGDirectMainDisplay);
if(bpp)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
// CGDisplayBitsPerPixel was deprecated in OS X 10.6
CFStringRef pixelEncoding = CGDisplayModeCopyPixelEncoding(currentMode);
if (CFStringCompare(pixelEncoding, CFSTR(IO32BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
*bpp = 32;
else if (CFStringCompare(pixelEncoding, CFSTR(IO16BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
*bpp = 16;
else if (CFStringCompare(pixelEncoding, CFSTR(IO8BitIndexedPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
*bpp = 8;
else // error
*bpp = 0;
// We're responsible for this
CFRelease(pixelEncoding);
#else
CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(currentMode, kCGDisplayBitsPerPixel);
CFNumberGetValue(num, kCFNumberIntType, bpp);
#endif
}
if(freq)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
*freq = (int)CGDisplayModeGetRefreshRate(currentMode);
#else
CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(currentMode, kCGDisplayRefreshRate);
CFNumberGetValue(num, kCFNumberIntType, freq);
#endif
}
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
// We're responsible for this
CGDisplayModeRelease(currentMode);
#endif
return INFO::OK;
}
// Pixels-pr-mm.
SbVec2f
SoOffscreenCGData::getResolution(void)
{
#ifdef COIN_MACOS_10_3
CGDirectDisplayID display = CGMainDisplayID();
CGSize size = CGDisplayScreenSize(display);
return SbVec2f(CGDisplayPixelsWide(display)/size.width,
CGDisplayPixelsHigh(display)/size.height)l
#else
return SbVec2f(72.0f / 25.4f, 72.0f / 25.4f); // fall back to 72dpi
#endif
}
XInputSimulatorImplMacOs::XInputSimulatorImplMacOs()
{
//TODO
//this->initCurrentMousePosition();
std::cout << "constructor " << std::endl;
this->currentX = 500;
this->currentY = 500;
CGDirectDisplayID displayID = CGMainDisplayID();
this->displayX = CGDisplayPixelsWide(displayID);
this->displayY = CGDisplayPixelsHigh(displayID);
}
/**********************************************************************
* device_init
*
* Perform initializations needed upon creation of the first device.
*/
static void device_init(void)
{
CGDirectDisplayID mainDisplay = CGMainDisplayID();
CGSize size_mm = CGDisplayScreenSize(mainDisplay);
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(mainDisplay);
check_retina_status();
/* Initialize device caps */
horz_size = size_mm.width;
vert_size = size_mm.height;
bits_per_pixel = 32;
if (mode)
{
CFStringRef pixelEncoding = CGDisplayModeCopyPixelEncoding(mode);
horz_res = CGDisplayModeGetWidth(mode);
vert_res = CGDisplayModeGetHeight(mode);
if (pixelEncoding)
{
if (CFEqual(pixelEncoding, CFSTR(IO32BitDirectPixels)))
bits_per_pixel = 32;
else if (CFEqual(pixelEncoding, CFSTR(IO16BitDirectPixels)))
bits_per_pixel = 16;
else if (CFEqual(pixelEncoding, CFSTR(IO8BitIndexedPixels)))
bits_per_pixel = 8;
CFRelease(pixelEncoding);
}
CGDisplayModeRelease(mode);
}
else
{
horz_res = CGDisplayPixelsWide(mainDisplay);
vert_res = CGDisplayPixelsHigh(mainDisplay);
}
if (retina_on)
{
horz_res *= 2;
vert_res *= 2;
}
compute_desktop_rect();
desktop_horz_res = desktop_rect.size.width;
desktop_vert_res = desktop_rect.size.height;
device_data_valid = TRUE;
}
int main (int argc, const char * argv[])
{
Command cmd;
char lineBuff[100];
// http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/Quartz_Services_Ref/Reference/reference.html#//apple_ref/doc/uid/TP30001070
g_screenWidth = CGDisplayPixelsWide(CGDisplayPrimaryDisplay(CGMainDisplayID()));
g_screenHeight = CGDisplayPixelsHigh(CGDisplayPrimaryDisplay(CGMainDisplayID()));
while (true) {
readLine(lineBuff, 100);
parseCommand(&cmd, lineBuff);
execCommand(&cmd);
}
return 0;
}
void
infoDisplays(void)
{
CGDisplayErr dErr;
CGDisplayCount displayCount, i;
CGDirectDisplayID mainDisplay;
CGDisplayCount maxDisplays = MAX_DISPLAYS;
CGDirectDisplayID onlineDisplays[MAX_DISPLAYS];
CGEventRef ourEvent = CGEventCreate(NULL);
CGPoint ourLoc = CGEventGetLocation(ourEvent);
CFRelease(ourEvent);
mainDisplay = CGMainDisplayID();
dErr = CGGetOnlineDisplayList(maxDisplays, onlineDisplays, &displayCount);
if (dErr != kCGErrorSuccess) {
fprintf(stderr, "CGGetOnlineDisplayList: error %d.\n", dErr);
exit(1);
}
printf("# Display_ID Resolution ____Display_Bounds____ Rotation\n");
for (i = 0; i < displayCount; i++) {
CGDirectDisplayID dID = onlineDisplays[i];
printf("%-2d %10p %4lux%-4lu %5.0f %5.0f %5.0f %5.0f %3.0f %s%s%s",
CGDisplayUnitNumber (dID), dID,
CGDisplayPixelsWide(dID), CGDisplayPixelsHigh(dID),
CGRectGetMinX (CGDisplayBounds (dID)),
CGRectGetMinY (CGDisplayBounds (dID)),
CGRectGetMaxX (CGDisplayBounds (dID)),
CGRectGetMaxY (CGDisplayBounds (dID)),
CGDisplayRotation (dID),
(CGDisplayIsActive (dID)) ? "" : "[inactive]",
(dID == mainDisplay) ? "[main]" : "",
(CGDisplayIsBuiltin (dID)) ? "[internal]\n" : "\n");
}
printf("Mouse Cursor Position: ( %5.0f , %5.0f )\n",
(float)ourLoc.x, (float)ourLoc.y);
exit(0);
}
//--------------------------------------------------------------
// global initialization called in main.m
void initFramework(
const char* resourceDir)
{
chdir(resourceDir);
mgOSLaunchSendLog();
// initialize random numbers
time_t seed;
time(&seed);
srand(12123123); // srand(seed & 0xFFFF);
mgDebugReset(); // reset trace file
mgDebug(":Program: %s", mgProgramName != NULL ? mgProgramName : "unknown");
mgDebug(":Program Version: %s", mgProgramVersion != NULL ? mgProgramVersion : "unknown");
char machineID[256];
getPlatformUUID(machineID, sizeof(machineID)-1);
machineID[sizeof(machineID)-1] = '\0';
mgDebug(":Machine Id: %s", machineID);
struct utsname name;
if (uname(&name) != -1)
{
mgDebug(":OS: %s", name.sysname);
mgDebug(":Machine 64-bit: %s", strstr(name.machine, "_64") != NULL ? "true" : "false");
}
else mgDebug(":OS: OSX");
const int MAX_DISPLAYS = 20;
uint32_t displayCount;
CGGetActiveDisplayList(MAX_DISPLAYS, NULL, &displayCount);
mgDebug(":Machine Monitor count: %d", displayCount);
CGDirectDisplayID mainDisplay = CGMainDisplayID();
mgDebug(":Machine Monitor res: %d by %d", CGDisplayPixelsWide(mainDisplay), CGDisplayPixelsHigh(mainDisplay));
mgOSInitTimer(); // performance timer
atexit(termFramework);
}
/**********************************************************************
* device_init
*
* Perform initializations needed upon creation of the first device.
*/
static void device_init(void)
{
CGDirectDisplayID mainDisplay = CGMainDisplayID();
CGSize size_mm = CGDisplayScreenSize(mainDisplay);
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(mainDisplay);
CGDirectPaletteRef palette;
/* Initialize device caps */
log_pixels_x = log_pixels_y = get_dpi();
if (!log_pixels_x)
{
size_t width = CGDisplayPixelsWide(mainDisplay);
size_t height = CGDisplayPixelsHigh(mainDisplay);
log_pixels_x = MulDiv(width, 254, size_mm.width * 10);
log_pixels_y = MulDiv(height, 254, size_mm.height * 10);
}
horz_size = size_mm.width;
vert_size = size_mm.height;
bits_per_pixel = 32;
if (mode)
{
CFStringRef pixelEncoding = CGDisplayModeCopyPixelEncoding(mode);
horz_res = CGDisplayModeGetWidth(mode);
vert_res = CGDisplayModeGetHeight(mode);
if (pixelEncoding)
{
if (CFEqual(pixelEncoding, CFSTR(IO32BitDirectPixels)))
bits_per_pixel = 32;
else if (CFEqual(pixelEncoding, CFSTR(IO16BitDirectPixels)))
bits_per_pixel = 16;
else if (CFEqual(pixelEncoding, CFSTR(IO8BitIndexedPixels)))
bits_per_pixel = 8;
CFRelease(pixelEncoding);
}
CGDisplayModeRelease(mode);
}
else
{
horz_res = CGDisplayPixelsWide(mainDisplay);
vert_res = CGDisplayPixelsHigh(mainDisplay);
}
macdrv_get_desktop_rect();
desktop_horz_res = desktop_rect.size.width;
desktop_vert_res = desktop_rect.size.height;
palette = CGPaletteCreateWithDisplay(mainDisplay);
if (palette)
{
palette_size = CGPaletteGetNumberOfSamples(palette);
CGPaletteRelease(palette);
}
else
palette_size = 0;
device_data_valid = TRUE;
}
//========================================================================
int main( ){
ofGLFWWindowSettings mainSettings;
mainSettings.resizable = false;
mainSettings.setGLVersion(4, 1);
mainSettings.decorated = false;
ofGLFWWindowSettings guiSettings;
guiSettings.resizable = true;
guiSettings.setGLVersion(4, 1);
// Get screen widths and heights from Quartz Services
// See https://developer.apple.com/library/mac/documentation/GraphicsImaging/Reference/Quartz_Services_Ref/index.html
CGDisplayCount displayCount;
CGDirectDisplayID displays[32];
// Grab the active displays
CGGetActiveDisplayList(32, displays, &displayCount);
int numDisplays= displayCount;
// print display info.
cout<<numDisplays<<" display(s) detected."<<endl;
for (int i = 0; i < displayCount; i++){
cout << displays[i] << "\t(" << CGDisplayPixelsWide(displays[i]) << "x" << CGDisplayPixelsHigh(displays[i]) << ")"<< endl;
}
CGRect mainDisplayBounds= CGDisplayBounds ( displays[0] );
if(numDisplays == 1 ){
float divisions = 4.0;
// one display: palce gui and mainWindow in a default arrangement
mainSettings.width = round(mainDisplayBounds.size.width * (divisions-1) / divisions);
mainSettings.height = round((mainSettings.width * (9.0 / 16.0)) / 2.0);
mainSettings.setPosition(ofVec2f(round(mainDisplayBounds.size.width / divisions) ,mainDisplayBounds.origin.y));
mainSettings.decorated = true;
guiSettings.width = round(mainDisplayBounds.size.width - 100);
guiSettings.height = mainDisplayBounds.size.height - 100;
guiSettings.setPosition(ofVec2f(mainDisplayBounds.origin.x, mainDisplayBounds.origin.y + 80));
cout << "configured default one display setup" << endl;
} else if (numDisplays > 1){
// two displays: palce resizeable gui on first and fill second with undecorated mainWindow - will also work with dual head configuraions for projectors
guiSettings.width = mainDisplayBounds.size.width;
guiSettings.height = mainDisplayBounds.size.height - 100;
guiSettings.setPosition(ofVec2f(mainDisplayBounds.origin.x, mainDisplayBounds.origin.y));
CGRect secondDisplayBounds= CGDisplayBounds ( displays[1] );
mainSettings.width = secondDisplayBounds.size.width;
mainSettings.height = secondDisplayBounds.size.height;
mainSettings.setPosition(ofVec2f(secondDisplayBounds.origin.x,secondDisplayBounds.origin.y));
// CGError e = CGDisplaySetStereoOperation(displays[1], true, true, kCGConfigureForAppOnly);
// if(e == kCGErrorRangeCheck) cout << "no hardware stereo" << endl;
// if(e == kCGErrorSuccess) cout << "hardware stereo" << endl;
if (numDisplays > 2 ) {
// three or more displays: palce resizeable gui on first and fill second and third with undecorated mainWindow, if they are same size.
CGRect thirdDisplayBounds= CGDisplayBounds ( displays[2] );
if(secondDisplayBounds.size.width == thirdDisplayBounds.size.width && secondDisplayBounds.size.height == thirdDisplayBounds.size.height){
mainSettings.width = secondDisplayBounds.size.width * 2;
mainSettings.setPosition(ofVec2f(1,1));
cout << "configured default three display setup" << endl;
}
} else {
cout << "configured default two display setup" << endl;
}
}
shared_ptr<ofAppBaseWindow> mainWindow = ofCreateWindow(mainSettings);
guiSettings.shareContextWith = mainWindow;
shared_ptr<ofAppBaseWindow> guiWindow = ofCreateWindow(guiSettings);
//guiWindow->setVerticalSync(false);
shared_ptr<ofApp> mainApp(new ofApp);
mainApp->setupGui(guiWindow, mainWindow);
ofAddListener(guiWindow->events().draw,mainApp.get(),&ofApp::drawGui);
// gui events to main app gui listener functions
#define guiEventMacro(NAME) ofAddListener(guiWindow->events() . NAME , mainApp.get(), &ofApp::NAME ## Gui);
guiEventMacro(keyPressed);
guiEventMacro(keyReleased);
guiEventMacro(mouseMoved);
guiEventMacro(mouseDragged);
guiEventMacro(mousePressed);
guiEventMacro(mouseReleased);
guiEventMacro(mouseEntered);
guiEventMacro(mouseExited);
guiEventMacro(windowResized);
ofRunApp(mainWindow, mainApp);
ofRunMainLoop();
}
//--------------------------------------------------------------
void ofApp::setup(){
camWidth = 1024;
camHeight = 768;
projWidth = 1024;
projHeight = 768;
canvasHeight = ofGetHeight() / 3 - 10;
canvasWidth = canvasHeight * 4 / 3;
outputHeight = ofGetHeight() * 2 / 3 - 10;
outputWidth = outputHeight * 4 / 3;
guiPos = ofPoint(10,10);
canvas1Pos = ofPoint(ofGetWidth()/3 + 5, 5);
canvas2Pos = ofPoint(ofGetWidth()*2/3 + 5, 5);
outputPos = ofPoint(ofGetWidth()/3 + 5, ofGetHeight()/3+5);
ofSetWindowTitle("FaceMapper - OTU CINEMA SL");
CGDisplayCount displayCount;
CGDirectDisplayID displays[32];
// grab the active displays
CGGetActiveDisplayList(32, displays, &displayCount);
cout<<"displayCount "<<displayCount<<endl;
vidGrabber.setVerbose(true);
vidGrabber.initGrabber(camWidth, camHeight);
colorImg.allocate(camWidth, camHeight);
grayImage.allocate(canvasWidth, canvasHeight);
warpedImg.allocate(canvasWidth, canvasHeight);
if (displayCount == 1) {
whichDisplay = 0;
mainDisplayWidth = CGDisplayPixelsWide ( displays[whichDisplay] );
mainDisplayWidth = CGDisplayPixelsHigh ( displays[whichDisplay] );
}
else {
whichDisplay = 1;
mainDisplayWidth = CGDisplayPixelsWide ( displays[0] );
mainDisplayHeight = CGDisplayPixelsHigh ( displays[0] );
secondDisplayWidth = CGDisplayPixelsWide ( displays[whichDisplay] );
secondDisplayHeight = CGDisplayPixelsHigh ( displays[whichDisplay] );
}
// the arguments for the second window are its initial x and y position,
// and its width and height. the last argument is whether the window
// should be undecorated, i.e. title bar is visible. setting it to
// true removes the title bar.
if (displayCount == 1) secondWindow.setup("Output", 0, 0, 640, 480, false);
else secondWindow.setup("Output", mainDisplayWidth, 0, secondDisplayWidth, secondDisplayHeight, true);
threshold = 80;
bLearnBakground = true;
backgroundSubOn = false;
//detect finger is off by default
fidfinder.detectFinger = false;
//fidfinder.maxFingerSize = 25;
//fidfinder.minFingerSize = 5;
//fidfinder.fingerSensitivity = 0.05f; //from 0 to 2.0f
gui.setup("Control Panel"); // most of the time you don't need a name
gui.add(selection.setup("Image Selection", false));
gui.add(warping.setup("Warping Mode", false));
gui.add(threshold.setup("Threshold", 160, 0, 255));
gui.add(tableWidth.setup("Largo Mesa (cm)", 200, 10, 500));
gui.add(tableHeight.setup("Ancho Mesa (cm)", 100, 10, 500));
// Definimos los puntos de recorte de ROI (warping inverso de imagen de entrada)
roiCorners[0] = ofPoint(10,10);
roiCorners[1] = ofPoint(canvasWidth-10, 10);
roiCorners[2] = ofPoint(canvasWidth - 10, canvasHeight - 10);
roiCorners[3] = ofPoint(10,canvasHeight - 10);
destCorners[0] = ofPoint(0,0);
destCorners[1] = ofPoint(canvasWidth, 0);
destCorners[2] = ofPoint(canvasWidth, canvasHeight);
destCorners[3] = ofPoint(0,canvasHeight);
for (int i = 0; i < 4; i++) {
activeCorners[i] = false;
}
// Inicializamos los canvas
canvas1.allocate(canvasWidth, canvasHeight, GL_RGB);
canvas2.allocate(canvasWidth, canvasHeight, GL_RGB);
canvasWarp.allocate(canvasWidth, canvasHeight, GL_RGB);
output.allocate(outputWidth, outputHeight, GL_RGB);
warpedOutput.allocate(outputWidth, outputHeight, GL_RGB);
pixels.allocate(canvasWidth, canvasHeight, GL_RGB);
// Inicializamos el quad
quadRoi.setMode(OF_PRIMITIVE_LINE_LOOP);
for(int i = 0; i < 4; i++) {
quadRoi.addVertex(roiCorners[i]);
}
// Inicializamos el warper
warperGui.setup(outputPos.x, outputPos.y, outputWidth, outputHeight);
warperGui.activate();
warperOutput.setup(mainDisplayWidth, 0, secondDisplayWidth, secondDisplayHeight);; //initializates ofxGLWarper
// Inicializamos el objeto "Bola"
//lets setup some stupid particles
for(int i = 0; i < 10; i++){
cards[i].setup(i);
}
}
LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
const std::string& title, const std::string& name, S32 x, S32 y, S32 width,
S32 height, U32 flags,
BOOL fullscreen, BOOL clearBg,
BOOL disable_vsync, BOOL use_gl,
BOOL ignore_pixel_depth,
//U32 fsaa_samples,) // <FS:LO> Legacy cursor setting from main program
U32 fsaa_samples,
BOOL useLegacyCursors)
: LLWindow(NULL, fullscreen, flags)
{
mUseLegacyCursors = useLegacyCursors; // <FS:LO> Legacy cursor setting from main program
// *HACK: During window construction we get lots of OS events for window
// reshape, activate, etc. that the viewer isn't ready to handle.
// Route them to a dummy callback structure until the end of constructor.
LLWindowCallbacks null_callbacks;
mCallbacks = &null_callbacks;
// Voodoo for calling cocoa from carbon (see llwindowmacosx-objc.mm).
setupCocoa();
// Initialize the keyboard
gKeyboard = new LLKeyboardMacOSX();
gKeyboard->setCallbacks(callbacks);
// Ignore use_gl for now, only used for drones on PC
mWindow = NULL;
mContext = NULL;
mPixelFormat = NULL;
mDisplay = CGMainDisplayID();
mSimulatedRightClick = FALSE;
mLastModifiers = 0;
mHandsOffEvents = FALSE;
mCursorDecoupled = FALSE;
mCursorLastEventDeltaX = 0;
mCursorLastEventDeltaY = 0;
mCursorIgnoreNextDelta = FALSE;
mNeedsResize = FALSE;
mOverrideAspectRatio = 0.f;
mMaximized = FALSE;
mMinimized = FALSE;
mLanguageTextInputAllowed = FALSE;
mPreeditor = NULL;
mFSAASamples = fsaa_samples;
mForceRebuild = FALSE;
// Get the original aspect ratio of the main device.
mOriginalAspectRatio = (double)CGDisplayPixelsWide(mDisplay) / (double)CGDisplayPixelsHigh(mDisplay);
// Stash the window title
mWindowTitle = title;
//mWindowTitle[0] = title.length();
mDragOverrideCursor = -1;
// Set up global event handlers (the fullscreen case needs this)
//InstallStandardEventHandler(GetApplicationEventTarget());
// Stash an object pointer for OSMessageBox()
gWindowImplementation = this;
// Create the GL context and set it up for windowed or fullscreen, as appropriate.
if(createContext(x, y, width, height, 32, fullscreen, disable_vsync))
{
if(mWindow != NULL)
{
makeWindowOrderFront(mWindow);
}
if (!gGLManager.initGL())
{
setupFailure(
"Second Life is unable to run because your video card drivers\n"
"are out of date or unsupported. Please make sure you have\n"
"the latest video card drivers installed.\n"
"If you continue to receive this message, contact customer service.",
"Error",
OSMB_OK);
return;
}
//start with arrow cursor
//initCursors();
initCursors(mUseLegacyCursors); // <FS:LO> Legacy cursor setting from main program
setCursor( UI_CURSOR_ARROW );
allowLanguageTextInput(NULL, FALSE);
}
mCallbacks = callbacks;
stop_glerror();
}
MMBitmapRef copyMMBitmapFromDisplayInRect(MMRect rect)
{
#if defined(IS_MACOSX)
/* The following is a very modified version of the glGrab code example
* given by Apple (as are some of the convenience functions called). */
size_t bytewidth;
uint8_t bitsPerPixel, bytesPerPixel;
uint8_t *buffer;
/* Build OpenGL context of entire screen */
CGDirectDisplayID displayID = CGMainDisplayID();
CGOpenGLDisplayMask mask = CGDisplayIDToOpenGLDisplayMask(displayID);
CGLContextObj glContext = createFullScreenCGLContext(mask);
if (glContext == NULL) return NULL;
/* TODO: CGDisplayBitsPerPixel() is deprecated in Snow Leopard; I'm not
* sure of the replacement function. */
bitsPerPixel = (uint8_t)CGDisplayBitsPerPixel(displayID);
bytesPerPixel = bitsPerPixel / 8;
/* Align width to padding. */
bytewidth = ADD_PADDING(rect.size.width * bytesPerPixel);
/* Convert Quartz point to postscript point. */
rect.origin.y = CGDisplayPixelsHigh(displayID) - rect.origin.y - rect.size.height;
/* Extract buffer from context */
buffer = createBufferFromCurrentCGLContext((GLint)rect.origin.x,
(GLint)rect.origin.y,
(GLsizei)rect.size.width,
(GLsizei)rect.size.height,
bytewidth);
/* Reset and release GL context */
destroyFullScreenCGLContext(glContext);
if (buffer == NULL) return NULL;
/* Convert from OpenGL (origin at bottom left) to Quartz (origin at top
* left) coordinate system. */
flipBitmapData(buffer, rect.size.width, rect.size.height, bytewidth);
return createMMBitmap(buffer, rect.size.width, rect.size.height, bytewidth,
bitsPerPixel, bytesPerPixel);
#elif defined(USE_X11)
MMBitmapRef bitmap;
Display *display = XOpenDisplay(NULL);
XImage *image = XGetImage(display,
XDefaultRootWindow(display),
(int)rect.origin.x,
(int)rect.origin.y,
(unsigned int)rect.size.width,
(unsigned int)rect.size.height,
AllPlanes, ZPixmap);
XCloseDisplay(display);
if (image == NULL) return NULL;
bitmap = createMMBitmap((uint8_t *)image->data,
rect.size.width,
rect.size.height,
(size_t)image->bytes_per_line,
(uint8_t)image->bits_per_pixel,
(uint8_t)image->bits_per_pixel / 8);
image->data = NULL; /* Steal ownership of bitmap data so we don't have to
* copy it. */
XDestroyImage(image);
return bitmap;
#elif defined(IS_WINDOWS)
MMBitmapRef bitmap;
void *data;
HDC screen = NULL, screenMem = NULL;
HBITMAP dib;
BITMAPINFO bi;
/* Initialize bitmap info. */
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
bi.bmiHeader.biWidth = (long)rect.size.width;
bi.bmiHeader.biHeight = -(long)rect.size.height; /* Non-cartesian, please */
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 32;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biSizeImage = (DWORD)(4 * rect.size.width * rect.size.height);
bi.bmiHeader.biXPelsPerMeter = 0;
bi.bmiHeader.biYPelsPerMeter = 0;
bi.bmiHeader.biClrUsed = 0;
bi.bmiHeader.biClrImportant = 0;
screen = GetDC(NULL); /* Get entire screen */
if (screen == NULL) return NULL;
/* Get screen data in display device context. */
dib = CreateDIBSection(screen, &bi, DIB_RGB_COLORS, &data, NULL, 0);
/* Copy the data into a bitmap struct. */
if ((screenMem = CreateCompatibleDC(screen)) == NULL ||
SelectObject(screenMem, dib) == NULL ||
!BitBlt(screenMem,
(int)rect.origin.x,
(int)rect.origin.y,
(int)rect.size.width,
(int)rect.size.height, screen, 0, 0, SRCCOPY)) {
/* Error copying data. */
ReleaseDC(NULL, screen);
DeleteObject(dib);
if (screenMem != NULL) DeleteDC(screenMem);
return NULL;
}
bitmap = createMMBitmap(NULL,
rect.size.width,
rect.size.height,
4 * rect.size.width,
(uint8_t)bi.bmiHeader.biBitCount,
4);
/* Copy the data to our pixel buffer. */
if (bitmap != NULL) {
bitmap->imageBuffer = malloc(bitmap->bytewidth * bitmap->height);
memcpy(bitmap->imageBuffer, data, bitmap->bytewidth * bitmap->height);
}
ReleaseDC(NULL, screen);
DeleteObject(dib);
DeleteDC(screenMem);
return bitmap;
#endif
}
int doMain (int argc, char **argv)
{
int dummy;
// OSG init
OSG::osgInit(argc, argv);
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore( t1 );
t1n->addChild( b1n );
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
dlight->setCore( dl );
dl->setAmbient( .3, .3, .3, 1 );
dl->setDiffuse( 1, 1, 1, 1 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
// root
root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
// Load the file
OSG::NodeUnrecPtr file = NULL;
if ( argc > 1 )
file = OSG::SceneFileHandler::the()->read(argv[1]);
if ( file == NULL )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file = OSG::makeTorus( .5, 2, 16, 16 );
}
OSG::Thread::getCurrentChangeList()->commitChanges();
file->updateVolume();
OSG::Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
dlight->addChild( file );
std::cerr << "Tree: " << std::endl;
//root->dump();
// Camera
cam = OSG::PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 90 ) );
cam->setNear( 0.1 );
cam->setFar( 100000 );
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
bkgnd->setColor(OSG::Color3f(0,0,1));
// Viewport
vp = OSG::Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
// Action
ract = OSG::RenderAction::create();
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
tball.setMode( OSG::Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( OSG::Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(tCenter);
// CoreGL init
// Install event handler
EventHandlerUPP eventHandlerUPP = NewEventHandlerUPP(eventHandler);
EventTypeSpec eventList[] =
{
{ kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
{ kEventClassMouse, kEventMouseDown },
{ kEventClassMouse, kEventMouseUp },
{ kEventClassMouse, kEventMouseDragged }
};
InstallApplicationEventHandler(eventHandlerUPP, GetEventTypeCount(eventList), eventList, 0, 0);
CGDisplayCapture(kCGDirectMainDisplay);
CGLPixelFormatAttribute attribs[] =
{
kCGLPFADoubleBuffer,
kCGLPFAFullScreen,
kCGLPFADepthSize,
(CGLPixelFormatAttribute)16,
kCGLPFADisplayMask,
(CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay),
(CGLPixelFormatAttribute)0
};
CGLPixelFormatObj pixelFormatObj;
GLint numPixelFormats;
CGLChoosePixelFormat(attribs, &pixelFormatObj, &numPixelFormats);
CGLContextObj contextObj;
CGLCreateContext(pixelFormatObj, 0, &contextObj);
CGLDestroyPixelFormat(pixelFormatObj);
CGLSetCurrentContext(contextObj);
CGLSetFullScreen(contextObj);
// Create OpenSG window
win = OSG::CoreGLWindow::create();
win->addPort( vp );
win->setContext ( contextObj );
win->init();
win->resize( CGDisplayPixelsWide(kCGDirectMainDisplay), CGDisplayPixelsHigh(kCGDirectMainDisplay) );
win->activate();
// do some OpenGL init. Will move into State Chunks later.
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
redraw();
// Main loop ( event dispatching )
RunApplicationEventLoop();
// Cleanup
CGLSetCurrentContext(0);
CGLClearDrawable(contextObj);
CGLDestroyContext(contextObj);
CGReleaseAllDisplays();
DisposeEventHandlerUPP(eventHandlerUPP);
ract = NULL;
win = NULL;
root = NULL;
file = NULL;
vp = NULL;
cam_trans = NULL;
cam = NULL;
return 0;
}
DisplayInfo MythDisplay::GetDisplayInfo(int video_rate)
{
DisplayInfo ret;
#if defined(Q_WS_MAC)
CGDirectDisplayID disp = GetOSXDisplay(GetWindowID());
if (!disp)
return ret;
CFDictionaryRef ref = CGDisplayCurrentMode(disp);
float rate = 0.0f;
if (ref)
rate = get_float_CF(ref, kCGDisplayRefreshRate);
if (VALID_RATE(rate))
ret.rate = 1000000.0f / rate;
else
ret.rate = fix_rate(video_rate);
CGSize size_in_mm = CGDisplayScreenSize(disp);
ret.size = QSize((uint) size_in_mm.width, (uint) size_in_mm.height);
uint width = (uint)CGDisplayPixelsWide(disp);
uint height = (uint)CGDisplayPixelsHigh(disp);
ret.res = QSize(width, height);
#elif defined(Q_WS_WIN)
HDC hdc = GetDC(GetWindowID());
int rate = 0;
if (hdc)
{
rate = GetDeviceCaps(hdc, VREFRESH);
int width = GetDeviceCaps(hdc, HORZSIZE);
int height = GetDeviceCaps(hdc, VERTSIZE);
ret.size = QSize((uint)width, (uint)height);
width = GetDeviceCaps(hdc, HORZRES);
height = GetDeviceCaps(hdc, VERTRES);
ret.res = QSize((uint)width, (uint)height);
}
if (VALID_RATE(rate))
{
// see http://support.microsoft.com/kb/2006076
switch (rate)
{
case 23:
ret.rate = 41708;
break; // 23.976Hz
case 29:
ret.rate = 33367;
break; // 29.970Hz
case 47:
ret.rate = 20854;
break; // 47.952Hz
case 59:
ret.rate = 16683;
break; // 59.940Hz
case 71:
ret.rate = 13903;
break; // 71.928Hz
case 119:
ret.rate = 8342;
break; // 119.880Hz
default:
ret.rate = 1000000.0f / (float)rate;
}
}
else
ret.rate = fix_rate(video_rate);
#elif USING_X11
MythXDisplay *disp = OpenMythXDisplay();
if (!disp)
return ret;
float rate = disp->GetRefreshRate();
if (VALID_RATE(rate))
ret.rate = 1000000.0f / rate;
else
ret.rate = fix_rate(video_rate);
ret.res = disp->GetDisplaySize();
ret.size = disp->GetDisplayDimensions();
delete disp;
#endif
return ret;
}
int QuartzWindow::screen_height() {
return CGDisplayPixelsHigh(screen(my_window()));
}
MMBitmapRef copyMMBitmapFromDisplayInRect(MMRect rect)
{
#if defined(IS_MACOSX)
size_t bytewidth;
uint8_t bitsPerPixel, bytesPerPixel;
uint8_t *buffer;
CGDirectDisplayID displayID = CGMainDisplayID();
//Replacement for CGDisplayBitsPerPixel.
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(displayID);
size_t depth = 0;
CFStringRef pixEnc = CGDisplayModeCopyPixelEncoding(mode);
if(CFStringCompare(pixEnc, CFSTR(IO32BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
depth = 32;
else if(CFStringCompare(pixEnc, CFSTR(IO16BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
depth = 16;
else if(CFStringCompare(pixEnc, CFSTR(IO8BitIndexedPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
depth = 8;
bitsPerPixel = (uint8_t) depth;
bytesPerPixel = bitsPerPixel / 8;
/* Align width to padding. */
bytewidth = ADD_PADDING(rect.size.width * bytesPerPixel);
/* Convert Quartz point to postscript point. */
rect.origin.y = CGDisplayPixelsHigh(displayID) - rect.origin.y - rect.size.height;
CGImageRef image = CGDisplayCreateImageForRect(displayID, CGRectMake(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height));
// Request access to the raw pixel data via the image's DataProvider.
CGDataProviderRef provider = CGImageGetDataProvider(image);
CFDataRef data = CGDataProviderCopyData(provider);
size_t width, height;
width = CGImageGetWidth(image);
height = CGImageGetHeight(image);
size_t bpp = CGImageGetBitsPerPixel(image) / 8;
uint8 *pixels = malloc(width * height * bpp);
memcpy(pixels, CFDataGetBytePtr(data), width * height * bpp);
CFRelease(data);
CGImageRelease(image);
return createMMBitmap(pixels, rect.size.width, rect.size.height, bytewidth,
bitsPerPixel, bytesPerPixel);
#elif defined(USE_X11)
MMBitmapRef bitmap;
Display *display = XOpenDisplay(NULL);
XImage *image = XGetImage(display,
XDefaultRootWindow(display),
(int)rect.origin.x,
(int)rect.origin.y,
(unsigned int)rect.size.width,
(unsigned int)rect.size.height,
AllPlanes, ZPixmap);
XCloseDisplay(display);
if (image == NULL) return NULL;
bitmap = createMMBitmap((uint8_t *)image->data,
rect.size.width,
rect.size.height,
(size_t)image->bytes_per_line,
(uint8_t)image->bits_per_pixel,
(uint8_t)image->bits_per_pixel / 8);
image->data = NULL; /* Steal ownership of bitmap data so we don't have to
* copy it. */
XDestroyImage(image);
return bitmap;
#elif defined(IS_WINDOWS)
MMBitmapRef bitmap;
void *data;
HDC screen = NULL, screenMem = NULL;
HBITMAP dib;
BITMAPINFO bi;
/* Initialize bitmap info. */
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
bi.bmiHeader.biWidth = (long)rect.size.width;
bi.bmiHeader.biHeight = -(long)rect.size.height; /* Non-cartesian, please */
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 32;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biSizeImage = (DWORD)(4 * rect.size.width * rect.size.height);
bi.bmiHeader.biXPelsPerMeter = 0;
bi.bmiHeader.biYPelsPerMeter = 0;
bi.bmiHeader.biClrUsed = 0;
bi.bmiHeader.biClrImportant = 0;
screen = GetDC(NULL); /* Get entire screen */
if (screen == NULL) return NULL;
/* Get screen data in display device context. */
dib = CreateDIBSection(screen, &bi, DIB_RGB_COLORS, &data, NULL, 0);
/* Copy the data into a bitmap struct. */
if ((screenMem = CreateCompatibleDC(screen)) == NULL ||
SelectObject(screenMem, dib) == NULL ||
!BitBlt(screenMem,
(int)rect.origin.x,
(int)rect.origin.y,
(int)rect.size.width,
(int)rect.size.height, screen, 0, 0, SRCCOPY)) {
/* Error copying data. */
ReleaseDC(NULL, screen);
DeleteObject(dib);
if (screenMem != NULL) DeleteDC(screenMem);
return NULL;
}
bitmap = createMMBitmap(NULL,
rect.size.width,
rect.size.height,
4 * rect.size.width,
(uint8_t)bi.bmiHeader.biBitCount,
4);
/* Copy the data to our pixel buffer. */
if (bitmap != NULL) {
bitmap->imageBuffer = malloc(bitmap->bytewidth * bitmap->height);
memcpy(bitmap->imageBuffer, data, bitmap->bytewidth * bitmap->height);
}
ReleaseDC(NULL, screen);
DeleteObject(dib);
DeleteDC(screenMem);
return bitmap;
#endif
}