Source/WindowSystem/Carbon/testWindowCarbon.cpp

   1 #include "OSGConfig.h"
   2
   3 #include <iostream>
   4
   5 #include <AGL/agl.h>
   6
   7 #ifdef check
   8 # undef check
   9 #endif
  10
  11 #include "OSGFieldContainerFactory.h"
  12 #include "OSGVector.h"
  13 #include "OSGQuaternion.h"
  14 #include "OSGMatrix.h"
  15 #include "OSGMatrixUtility.h"
  16 #include "OSGBoxVolume.h"
  17 #include "OSGNode.h"
  18 #include "OSGGroup.h"
  19 #include "OSGTransform.h"
  20 #include "OSGSimpleGeometry.h"
  21 #include "OSGAction.h"
  22 #include "OSGRenderAction.h"
  23 #include "OSGSceneFileHandler.h"
  24 #include "OSGDirectionalLight.h"
  25
  26 #include "OSGViewport.h"
  27 #include "OSGCamera.h"
  28 #include "OSGWindow.h"
  29 #include "OSGCarbonWindow.h"
  30 #include "OSGCamera.h"
  31 #include "OSGPerspectiveCamera.h"
  32 #include "OSGSolidBackground.h"
  33
  34 #include "OSGTrackball.h"
  35
  36 OSG::CarbonWindowUnrecPtr    win;
  37
  38 OSG::RenderActionRefPtr   ract;
  39 OSG::NodeRecPtr           root;
  40 OSG::NodeRecPtr           file;
  41 OSG::ViewportRecPtr   vp;
  42 OSG::TransformRecPtr  cam_trans;
  43 OSG::Trackball     tball;
  44 OSG::PerspectiveCameraRecPtr cam;
  45
  46 bool          stopIt = false;
  47 int           lastx=0, lasty=0;
  48
  49 #if !defined(__LP64__)
  50
  51 void redraw ( void )
  52 {
  53     OSG::Matrix m1, m2, m3;
  54     OSG::Quaternion q1;
  55
  56     tball.getRotation().getValue(m3);
  57     q1.setValue(m3);
  58     m1.setRotate(q1);
  59     m2.setTranslate( tball.getPosition() );
  60     m1.mult( m2 );
  61     cam_trans->editSFMatrix()->setValue( m1 );
  62
  63     OSG::Thread::getCurrentChangeList()->commitChanges();
  64
  65     win->render(ract);
  66 }
  67
  68 static OSStatus handleMouseEvent(EventHandlerCallRef nextHandler, EventRef event, void *userData)
  69 {
  70     OSStatus err;
  71     OSG::Real32 w,h,a,b,c,d;
  72
  73     // Get the window
  74     WindowRef window;
  75     err = GetEventParameter(event, kEventParamWindowRef, typeWindowRef, 0, sizeof(window), 0, &window);
  76     if (err != noErr)
  77         return err;
  78
  79     // Get the window rectangle
  80     Rect portRect;
  81     GetWindowPortBounds(window, &portRect);
  82
  83     // Get the pressed mouse button
  84     EventMouseButton mouseButton;
  85     err = GetEventParameter(event, kEventParamMouseButton, typeMouseButton, 0, sizeof(mouseButton), 0, &mouseButton);
  86     if (err != noErr)
  87         return err;
  88
  89     // Get the modifier keys
  90     ::UInt32 modifierKeys;
  91     err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, 0, sizeof(modifierKeys), 0, &modifierKeys);
  92     if (err != noErr)
  93         return err;
  94
  95     // Traditionally, Apple mice just have one button. It is common practice to simulate
  96     // the middle and the right button by pressing the option or the control key.
  97     if (mouseButton == kEventMouseButtonPrimary)
  98     {
  99         if (modifierKeys & optionKey)
 100             mouseButton = kEventMouseButtonTertiary;
 101         if (modifierKeys & controlKey)
 102             mouseButton = kEventMouseButtonSecondary;
 103     }
 104
 105     // Get the location of the mouse pointer
 106     ::Point location;
 107     err = GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, 0, sizeof(location), 0, &location);
 108     if (err != noErr)
 109         return err;
 110
 111     // The location of the mouse pointer is in screen coordinates, so
 112     // we have to transform it into the local coordinate system of the
 113     // window content area.
 114     SetPortWindowPort(window);
 115     GlobalToLocal(&location);
 116
 117     // Handle the different kinds of events
 118     ::UInt32 eventKind = GetEventKind(event);
 119     switch (eventKind)
 120     {
 121     // mouse button pressed
 122     case kEventMouseDown:
 123         lastx = location.h;
 124         lasty = location.v;
 125         switch (mouseButton)
 126         {
 127         case kEventMouseButtonPrimary: // left button
 128             break;
 129         case kEventMouseButtonSecondary: // right button
 130             tball.setAutoPositionNeg(true);
 131             break;
 132         case kEventMouseButtonTertiary: // middle button
 133             tball.setAutoPosition(true);
 134             break;
 135         }
 136         break;
 137
 138     // mouse button released
 139     case kEventMouseUp:
 140         switch (mouseButton)
 141         {
 142         case kEventMouseButtonPrimary: // left button
 143             break;
 144         case kEventMouseButtonSecondary: // right button
 145             tball.setAutoPositionNeg(false);
 146             break;
 147         case kEventMouseButtonTertiary: // middle button
 148             tball.setAutoPosition(false);
 149             break;
 150         }
 151         break;
 152
 153     // mouse moved while a button is pressed
 154     case kEventMouseDragged:
 155         w = win->getWidth();
 156         h = win->getHeight();
 157         a = -2. * ( lastx / w - .5 );
 158         b = -2. * ( .5 - lasty / h );
 159         c = -2. * ( location.h / w - .5 );
 160         d = -2. * ( .5 - location.v / h );
 161         switch (mouseButton)
 162         {
 163         case kEventMouseButtonPrimary: // left button
 164             tball.updateRotation( a, b, c, d );
 165             break;
 166         case kEventMouseButtonSecondary: // right button
 167             tball.updatePositionNeg( a, b, c, d );
 168             break;
 169         case kEventMouseButtonTertiary: // middle button
 170             tball.updatePosition( a, b, c, d );
 171             break;
 172         }
 173         lastx = location.h;
 174         lasty = location.v;
 175
 176         // Redraw the whole window
 177         InvalWindowRect(window, &portRect);
 178
 179         break;
 180     }
 181
 182     // We have to return eventNotHandledErr, otherwise the system is
 183     // not able to operate the menu and the window border
 184     return eventNotHandledErr;
 185 }
 186
 187 static OSStatus handleKeyEvent(EventHandlerCallRef nextHandler, EventRef event, void *userData)
 188 {
 189     OSStatus err;
 190
 191     // Try to determine the size of the text input
 192     ::UInt32 actualSize;
 193     err = GetEventParameter(event, kEventParamTextInputSendText, typeUnicodeText, 0, 0, &actualSize, 0);
 194     if (err != noErr)
 195         return err;
 196
 197     // The input can actually consist of more than one character.
 198     // We are only interested in single character input
 199     if (actualSize == sizeof(UniChar))
 200     {
 201         // Get the character unicode
 202         UniChar c;
 203         err = GetEventParameter(event, kEventParamTextInputSendText, typeUnicodeText, 0, sizeof(UniChar), 0, &c);
 204         if (err != noErr)
 205             return err;
 206
 207         // Handle different keyboard commands
 208         aglSetCurrentContext(win->getContext());
 209         switch (c)
 210         {
 211         case kEscapeCharCode:
 212             QuitApplicationEventLoop();
 213             break;
 214         case 'a':
 215             glDisable( GL_LIGHTING );
 216             redraw();
 217             break;
 218         case 's':
 219             glEnable( GL_LIGHTING );
 220             redraw();
 221             break;
 222         case 'z':
 223             glPolygonMode( GL_FRONT_AND_BACK, GL_POINT);
 224             redraw();
 225             break;
 226         case 'x':
 227             glPolygonMode( GL_FRONT_AND_BACK, GL_LINE);
 228             redraw();
 229             break;
 230         case 'c':
 231             glPolygonMode( GL_FRONT_AND_BACK, GL_FILL);
 232             redraw();
 233             break;
 234         }
 235     }
 236
 237     return noErr;
 238 }
 239
 240 static OSStatus handleWindowEvent(EventHandlerCallRef nextHandler, EventRef event, void *userData)
 241 {
 242     OSStatus err;
 243
 244     // Get the window
 245     WindowRef window;
 246     err = GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0, sizeof(window), 0, &window);
 247     if (err != noErr)
 248         return err;
 249
 250     // Handle the different kinds of events
 251     ::UInt32 eventKind = GetEventKind(event);
 252     switch (eventKind)
 253     {
 254     // Quit the application when the user closes the window
 255     case kEventWindowClose:
 256         QuitApplicationEventLoop();
 257         return noErr;
 258
 259     // Draw the contents of the window
 260     case kEventWindowDrawContent:
 261         redraw();
 262         return noErr;
 263
 264     case kEventWindowBoundsChanged:
 265         {
 266             // Update the GL context
 267             aglUpdateContext(win->getContext());
 268
 269             // Find out if we have a move or a resize situation
 270             ::UInt32 attributes;
 271             GetEventParameter(event, kEventParamAttributes, typeUInt32, 0, sizeof(attributes), 0, &attributes);
 272
 273             if ((attributes & kWindowBoundsChangeSizeChanged) != 0)
 274             {
 275                 // Get the new bounds of the window
 276                 Rect bounds;
 277                 GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, 0, sizeof(Rect), 0, &bounds);
 278
 279                 // Resize the OpenSG Window
 280                 GLsizei width = bounds.right - bounds.left;
 281                 GLsizei height = bounds.bottom - bounds.top;
 282                 win->resize(width, height);
 283
 284                 // Redraw the whole window
 285                 Rect portRect;
 286                 GetWindowPortBounds(window, &portRect);
 287                 InvalWindowRect(window, &portRect);
 288             }
 289
 290             return noErr;
 291         }
 292
 293     default:
 294         return eventNotHandledErr;
 295     }
 296 }
 297
 298 static pascal OSStatus eventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData)
 299 {
 300     ::UInt32 eventClass = GetEventClass(event);
 301     switch (eventClass)
 302     {
 303     // Mouse events
 304     case kEventClassMouse:
 305         return handleMouseEvent(nextHandler, event, userData);
 306
 307     // Key press events
 308     case kEventClassTextInput:
 309         return handleKeyEvent(nextHandler, event, userData);
 310
 311     // Window events
 312     case kEventClassWindow:
 313         return handleWindowEvent(nextHandler, event, userData);
 314
 315     default:
 316         return eventNotHandledErr;
 317     }
 318 }
 319
 320 // A magic method that allows applications to react to events even
 321 // when they are not organized in a bundle
 322 void osx_AllowForeground()
 323 {
 324     ProcessSerialNumber psn = { 0, kCurrentProcess };
 325     TransformProcessType(&psn, kProcessTransformToForegroundApplication);
 326     SetFrontProcess(&psn);
 327 }
 328
 329 int doMain (int argc, char **argv)
 330 {
 331     osx_AllowForeground();
 332
 333     // OSG init
 334
 335     OSG::osgInit(argc, argv);
 336
 337     // create the graph
 338
 339     // beacon for camera and light
 340     OSG::NodeUnrecPtr b1n = OSG::Node::create();
 341     OSG::GroupUnrecPtr b1 = OSG::Group::create();
 342     b1n->setCore( b1 );
 343
 344     // transformation
 345     OSG::NodeUnrecPtr t1n = OSG::Node::create();
 346     OSG::TransformUnrecPtr t1 = OSG::Transform::create();
 347     t1n->setCore( t1 );
 348     t1n->addChild( b1n );
 349
 350     cam_trans = t1;
 351
 352     // light
 353
 354     OSG::NodeUnrecPtr dlight = OSG::Node::create();
 355     OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
 356
 357     dlight->setCore( dl );
 358
 359     dl->setAmbient( .0, .0, .0, 1 );
 360     dl->setDiffuse( .8, .8, .8, .8 );
 361     dl->setDirection(0,0,1);
 362     dl->setBeacon( b1n);
 363
 364     // root
 365     root = OSG::Node::create();
 366     OSG::GroupUnrecPtr gr1 = OSG::Group::create();
 367
 368     root->setCore( gr1 );
 369     root->addChild( t1n );
 370     root->addChild( dlight );
 371
 372     // Load the file
 373
 374     OSG::NodeUnrecPtr file = NULL;
 375
 376     if ( argc > 1 )
 377         file = OSG::SceneFileHandler::the()->read(argv[1]);
 378
 379     if ( file == NULL )
 380     {
 381         std::cerr << "Couldn't load file, ignoring" << std::endl;
 382         file = OSG::makeTorus( .5, 2, 16, 16 );
 383     }
 384
 385     OSG::Thread::getCurrentChangeList()->commitChanges();
 386     file->updateVolume();
 387
 388     OSG::Vec3f min,max;
 389     file->getVolume().getBounds( min, max );
 390
 391     std::cout << "Volume: from " << min << " to " << max << std::endl;
 392
 393     dlight->addChild( file );
 394
 395     std::cerr << "Tree: " << std::endl;
 396     //root->dump();
 397
 398     // Camera
 399     cam = OSG::PerspectiveCamera::create();
 400
 401     cam->setBeacon( b1n );
 402     cam->setFov( OSG::osgDegree2Rad( 90 ) );
 403     cam->setNear( 0.1 );
 404     cam->setFar( 100000 );
 405
 406     // Background
 407     OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
 408
 409     bkgnd->setColor(OSG::Color3f(0,0,1));
 410
 411     // Viewport
 412
 413     vp = OSG::Viewport::create();
 414     vp->setCamera( cam );
 415     vp->setBackground( bkgnd );
 416     vp->setRoot( root );
 417     vp->setSize( 0,0, 1,1 );
 418
 419     // Action
 420
 421     ract = OSG::RenderAction::create();
 422
 423     // tball
 424
 425     OSG::Vec3f pos;
 426     pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
 427                   min[1] + ((max[1] - min[1]) * 0.5),
 428                   max[2] + ( max[2] - min[2] ) * 1.5 );
 429
 430     float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
 431
 432     OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
 433                        min[1] + (max[1] - min[1]) / 2,
 434                        min[2] + (max[2] - min[2]) / 2);
 435
 436     tball.setMode( OSG::Trackball::OSGObject );
 437     tball.setStartPosition( pos, true );
 438     tball.setSum( true );
 439     tball.setTranslationMode( OSG::Trackball::OSGFree );
 440     tball.setTranslationScale(scale);
 441     tball.setRotationCenter(tCenter);
 442
 443     // Carbon init
 444
 445     // Create window
 446     WindowAttributes windowAttrs =
 447         kWindowStandardDocumentAttributes |
 448         kWindowLiveResizeAttribute |
 449         kWindowStandardHandlerAttribute;
 450     Rect contentRect;
 451     SetRect(&contentRect, 0,  0, 300, 300);
 452     WindowRef window;
 453     CreateNewWindow(kDocumentWindowClass, windowAttrs, &contentRect, &window);
 454     SetWindowTitleWithCFString(window, CFSTR("testWindowCarbon"));
 455
 456     // Install event handler
 457     EventHandlerUPP eventHandlerUPP = NewEventHandlerUPP(eventHandler);
 458     EventTypeSpec eventList[] =
 459     {
 460         { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
 461         { kEventClassMouse, kEventMouseDown },
 462         { kEventClassMouse, kEventMouseUp },
 463         { kEventClassMouse, kEventMouseDragged },
 464         { kEventClassWindow, kEventWindowClose },
 465         { kEventClassWindow, kEventWindowDrawContent },
 466         { kEventClassWindow, kEventWindowBoundsChanged }
 467     };
 468     InstallWindowEventHandler(window, eventHandlerUPP, GetEventTypeCount(eventList), eventList, /*this*/0, 0);
 469
 470     // Initialize OpenGL
 471     GLint attribs[] = { AGL_RGBA, AGL_DOUBLEBUFFER, AGL_DEPTH_SIZE, 16, AGL_NONE };
 472     AGLPixelFormat pixelFormat = aglChoosePixelFormat(0, 0, attribs);
 473     if (pixelFormat == 0)
 474         std::cerr << "Cannot choose pixel format" << std::endl;
 475     AGLContext context = aglCreateContext(pixelFormat, 0);
 476     aglDestroyPixelFormat(pixelFormat);
 477     if (context == 0)
 478         std::cerr << "Cannot create context" << std::endl;
 479     aglSetDrawable(context, GetWindowPort(window));
 480
 481     // Create OpenSG window
 482     win = OSG::CarbonWindow::create();
 483     win->addPort( vp );
 484     win->setContext ( context );
 485     win->init();
 486     win->resize( 300, 300 );
 487
 488     // Show window
 489     RepositionWindow(window, 0, kWindowCascadeOnMainScreen);
 490     ShowWindow(window);
 491
 492     win->activate();
 493
 494     // do some OpenGL init. Will move into State Chunks later.
 495
 496     glEnable( GL_DEPTH_TEST );
 497     glEnable( GL_LIGHTING );
 498     glEnable( GL_LIGHT0 );
 499
 500
 501     // Main loop ( event dispatching )
 502     RunApplicationEventLoop();
 503
 504     // Cleanup
 505     aglDestroyContext(context);
 506     DisposeWindow(window);
 507     DisposeEventHandlerUPP(eventHandlerUPP);
 508
 509     ract      = NULL;
 510     win       = NULL;
 511     root      = NULL;
 512     file      = NULL;
 513     vp        = NULL;
 514     cam_trans = NULL;
 515     cam       = NULL;
 516
 517     return 0;
 518 }
 519
 520 int main (int argc, char **argv)
 521 {
 522     doMain(argc, argv);
 523
 524     OSG::osgExit();
 525
 526     return 0;
 527 }
 528
 529 #else
 530 int main (int argc, char **argv)
 531
 532 {
 533     fprintf(stderr, "Carbon not available in 64bit\n");
 534 }
 535 #endif