// Quickdraw 3D sample code

//

// Nick Thompson, AppleLink: DEVSUPPORT (devsupport@applelink.apple.com)

//

// ©1994-5 Apple Computer Inc., All Rights Reserved

// system headers

#include <Devices.h>

#include <Dialogs.h>

#include <DiskInit.h>

#include <Fonts.h>

#include <Menus.h>

#include <PictUtils.h>

#include <QDOffScreen.h>

#include <QuickDraw.h>

#include <SegLoad.h>

#include <StandardFile.h>

#include <TextEdit.h>

#include <ToolUtils.h>

// for QuickDraw 3D

#include "QD3D.h"

#include "QD3DMath.h"

#include "QD3DDrawContext.h"

#include "QD3DShader.h"

#include "QD3DTransform.h"

#include "QD3DGroup.h"

#include "QD3DCamera.h"

#include "MetaFileReadShell.h"

#include "MetaFileReadSupport.h"

#include "MyErrorHandler.h"

//-------------------------------------------------------------------------------------------

// function prototypes

static void         InitToolbox( void ) ;

static void         MainEventLoop( void ) ;

static void         HandleKeyPress(EventRecord *event) ;

static void         HandleOSEvent(EventRecord *event) ;

void InitDocumentData( DocumentPtr theDocument ) ;

TQ3Status DocumentDraw3DData( DocumentPtr theDocument ) ;

void DisposeDocumentData( DocumentPtr theDocument) ;

//-------------------------------------------------------------------------------------------

//

Boolean         gQuitFlag       = false ;

WindowPtr       gMainWindow     = nil ;

DocumentRec     gDocument ;

//-------------------------------------------------------------------------------------------

// main()

// entry point for the application, initialize the toolbox, initialize QuickDraw 3D

// and enter the main event loop.  On exit from the main event loop, we want to call

// the QuickDraw 3D exit function to clean up QuickDraw 3d.

void main(void)

{

    TQ3Status   myStatus;

    Rect        rBounds = { 50, 50, 350, 350 } ;

    Str255      title = "\pSpinning Box" ;

    FSSpec      theFileSpec ;               // the file we are opening

    InitToolbox() ;

    if(MetafileFileSpecify( &theFileSpec )) {

        SetCursor(*(GetCursor(watchCursor)));

        //  Initialize QuickDraw 3D, open a connection to the QuickDraw 3D library

        myStatus = Q3Initialize();

        if ( myStatus == kQ3Failure ) {

            DebugStr("\pErInitialize returned failure.");   

            ExitToShell() ;

        }

        // install the error handler - this gets called whenever

        // an error occurs, which means we don't have to check so 

        // much

        Q3Error_Register( MyErrorHandler, 0L );     

        Q3Warning_Register( MyWarningHandler, 0L );     

        // set up our globals

        gQuitFlag = false ;

        gMainWindow = NewCWindow(nil,&rBounds,title,false,noGrowDocProc,(WindowPtr)-1,true,0) ;

        // initialise our document structure

        InitDocumentData( &gDocument ) ;

        // try to read the file into the main display group

        if((gDocument.fModel = MyNewModelFromFile(&theFileSpec)) != NULL ) {        

            AdjustCamera(   &gDocument,

                            (gMainWindow->portRect.right - gMainWindow->portRect.left),

                            (gMainWindow->portRect.bottom - gMainWindow->portRect.top) ) ;

            SetWTitle( gMainWindow, theFileSpec.name );

            ShowWindow( gMainWindow ) ;

            SetPort( gMainWindow ) ;

            SetCursor(&qd.arrow) ;

            MainEventLoop();

        }

        DisposeDocumentData( &gDocument ) ;

        //  Close our connection to the QuickDraw 3D library

        myStatus = Q3Exit();

        if ( myStatus == kQ3Failure )

            DebugStr("\pErExit returned failure.");

    }   

}

//-------------------------------------------------------------------------------------------

//

void InitDocumentData( DocumentPtr theDocument ) 

{

    TQ3Point3D      myOrigin = { 0, 0, 0 } ;

    // sets up the 3d data for the scene

    //  Create view for QuickDraw 3D.

    theDocument->fView = MyNewView( gMainWindow );

    // the main display group:

    theDocument->fModel = NULL ;

    // the drawing styles:

    theDocument->fInterpolation = Q3InterpolationStyle_New(kQ3InterpolationStyleNone) ;

    theDocument->fBackFacing = Q3BackfacingStyle_New(kQ3BackfacingStyleRemove ) ;

    theDocument->fFillStyle = Q3FillStyle_New(kQ3FillStyleFilled ) ;

    theDocument->fGroupScale = 1;               

    theDocument->fGroupCenter = myOrigin ;          

    // set the rotation matrix the identity matrix

    Q3Matrix4x4_SetIdentity(&theDocument->fRotation);   

    return ;

bail:

    // either we failed getting the model or the view

    // so we want to quit here

    ExitToShell() ;

}

void DisposeDocumentData( DocumentPtr theDocument)

{

    Q3Object_Dispose(theDocument->fView) ;              // the view for the scene

    Q3Object_Dispose(theDocument->fModel) ;             // object in the scene being modelled

    Q3Object_Dispose(theDocument->fInterpolation) ;     // interpolation style used when rendering

    Q3Object_Dispose(theDocument->fBackFacing) ;        // whether to draw shapes that face away from the camera

    Q3Object_Dispose(theDocument->fFillStyle) ;         // whether drawn as solid filled object or decomposed to components

}

//-----------------------------------------------------------------------------

// assumes the port is set up before being called

TQ3Status DocumentDraw3DData( DocumentPtr theDocument )

{

    TQ3Vector3D             globalScale;

    TQ3Vector3D             globalTranslate;

//{

//  TQ3CameraData       theCameraData ;

//  TQ3CameraObject     theCameraObject;

//  

//  Q3View_GetCamera(theDocument->fView, &theCameraObject);

//  Q3Camera_GetData(theCameraObject, &theCameraData);

//Debugger() ;

//

//}

    TQ3Status theStatus ;   

    Q3View_StartRendering(theDocument->fView) ;

    do {

        theStatus = SubmitScene( theDocument ) ;

    } while (Q3View_EndRendering(theDocument->fView) == kQ3ViewStatusRetraverse );

    return theStatus ;  

}

//----------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------

//

short HiWrd(long aLong)

{

    return  (((aLong) >> 16) & 0xFFFF) ;

}

//-------------------------------------------------------------------------------------------

//

short LoWrd(long aLong)

{

    return  ((aLong) & 0xFFFF) ;

}

//-------------------------------------------------------------------------------------------

//

void InitToolbox()

{

    Handle      menuBar = nil;

    MaxApplZone() ;

    MoreMasters() ; MoreMasters() ; MoreMasters() ; 

    InitGraf( &qd.thePort );

    InitFonts();

    InitWindows();

    FlushEvents( everyEvent, 0 ) ;

    // initialize application globals

    gQuitFlag = false;

    InitCursor();

}

//-------------------------------------------------------------------------------------------

//

void MainEventLoop()

{

    EventRecord     event;

    WindowPtr       window;

    short           thePart;

    Rect            screenRect, updateRect;

    Point           aPoint = {100, 100};

    CGrafPtr        savedPort ;

    while( !gQuitFlag )

    {

        if (WaitNextEvent( everyEvent, &event, 0, nil ))

        {

            switch (event.what) {

                case mouseDown:

                    thePart = FindWindow( event.where, &window );

                    switch( thePart ) {

                        case inMenuBar: 

                            break;

                        case inDrag:

                            screenRect = (**GetGrayRgn()).rgnBBox;

                            DragWindow( window, event.where, &screenRect );

                            break ;

                        case inContent:

                            if (window != FrontWindow())

                                SelectWindow( window );

                            break ;

                        case inGoAway:

                            if (TrackGoAway( window, event.where )) {

                                DisposeWindow ( window );

                                gQuitFlag = true;

                            }

                            break ;

                        default:

                            break ;

                    }

                    break ;

                case updateEvt:

                    window = (WindowPtr)event.message;

                    updateRect = (**(window->visRgn)).rgnBBox;

                    SetPort( window ) ;

                    BeginUpdate( window );

                    DocumentDraw3DData( &gDocument ) ;

                    EndUpdate( window );

                    break ;

                case keyDown:

                case autoKey:

                    HandleKeyPress(&event);

                    break;

                case diskEvt:

                    if ( HiWrd(event.message) != noErr ) 

                        (void) DIBadMount(aPoint, event.message);

                    break;

                case osEvt:

                case activateEvt:

                    break;

            }

        }

        else {

            // we received a null event, rotate the cube

            TQ3Matrix4x4    tmp;

            Rect        theRect = ((GrafPtr)gMainWindow)->portRect ;

            SetPort((GrafPtr)gMainWindow) ;

            Q3Matrix4x4_SetRotate_XYZ(&tmp, 0.1, 0.12, 0.08);

            Q3Matrix4x4_Multiply(&gDocument.fRotation, &tmp, &gDocument.fRotation);

            InvalRect( &theRect ) ;

        }

    }

}

//-------------------------------------------------------------------------------------------

//

void HandleKeyPress(EventRecord *event)

{}

//-------------------------------------------------------------------------------------------

//