#!/bin/env python

# Copyright (C) 2002-2003 Gideon May (gideon@computer.org)
#
# Permission to copy, use, sell and distribute this software is granted
# provided this copyright notice appears in all copies.
# Permission to modify the code and to distribute modified code is granted
# provided this copyright notice appears in all copies, and a notice
# that the code was modified is included with the copyright notice.
#
# This software is provided "as is" without express or implied warranty,
# and with no claim as to its suitability for any purpose.

# -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield 
#
# This application is open source and may be redistributed and/or modified   
# freely and without restriction, both in commericial and non commericial applications,
# as long as this copyright notice is maintained.
# 
# This application is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#

from PyOSG import Producer
from PyOSG import osg
from PyOSG import osgGA
from PyOSG import osgDB
from PyOSG import osgUtil
from PyOSG import osgProducer
import sys

# Simple example of use of Producer.RenderSurface
# The myGraphics class is a simple sample of how one would implement
# graphics drawing with Producer.RenderSurface


class MyKeyboardMouseCallback(Producer.KeyboardMouseCallback):
    def __init__(self):
        Producer.KeyboardMouseCallback.__init__(self)
        self._mx = 0.0
        self._my = 0.0
        self._mbutton = 0
        self._done = False

    def specialKeyPress(self, key ):
        if key==Producer.KeyChar_Escape:
            self.shutdown()

    def shutdown(self):
        self._done = True

    def mouseMotion(self, mx, my):
        self._mx = mx
        self._my = my

    def buttonPress(self, mx, my, mbutton ):
        self._mx = mx
        self._my = my
        self._mbutton |= (1<<(mbutton-1))

    def buttonRelease(self, mx, my, mbutton ):
        self._mx = mx
        self._my = my
        self._mbutton &= ~(1<<(mbutton-1))

    def done(self):
        return self._done

    def mx(self):
        return self._mx

    def my(self):
        return self._my

    def mbutton(self):
        return self._mbutton

    def idle(self):
        return True

def main(argv ):

    # use an ArgumentParser object to manage the program arguments.
    arguments = osg.ArgumentParser(argv)

    # set up the usage document, in case we need to print out how to use this program.
    arguments.getApplicationUsage().setApplicationName(arguments.getApplicationName())
    arguments.getApplicationUsage().setDescription(arguments.getApplicationName()+" is the standard example of using osgProducer.CameraGroup.")
    arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...")
    arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information")

    # create the camera group.
    cg = osgProducer.OsgCameraGroup(arguments)

    # if user request help write it out to cout.
    if arguments.read("-h") or arguments.read("--help"):
        arguments.getApplicationUsage().write()
        return 1

    # any option left unread are converted into errors to write out later.
    arguments.reportRemainingOptionsAsUnrecognized()

    # report any errors if they have occured when parsing the program aguments.
    if arguments.errors():
        arguments.writeErrorMessages()
        return 1

    if arguments.argc()<=1:
        arguments.getApplicationUsage().write(osg.ApplicationUsage.COMMAND_LINE_OPTION)
        return 1

    # read the scene.
    loadedModel = osgDB.readNodeFiles(arguments)
    if not loadedModel:
        print arguments.getApplicationName()  + ": No data loaded"
        return 1

    optimizer = osgUtil.Optimizer()
    optimizer.optimize(loadedModel)

    # set up the keyboard and mouse handling.
    ia = cg.getCameraConfig().getInputArea()
    if ia:
        kbm = Producer.KeyboardMouse(ia)
    else:
        kbm = Producer.KeyboardMouse(cg.getCamera(0).getRenderSurface())


    kbmcb = MyKeyboardMouseCallback()

    # register the callback with the keyboard mouse manger.
    kbm.setCallback(kbmcb)
    kbm.startThread()

    # set the scene to render
    cg.setSceneData(loadedModel)

    bs = loadedModel.getBound()

    tb = Producer.Trackball()
    tb.setOrientation( Producer.Trackball.Z_UP )
    tb.setDistance(bs.radius()*3.0)
    tb.translate(-bs.center()._x,-bs.center()._y,-bs.center()._z)

    # create the windows and run the threads.
    #cg.realize()
    cg.realize(Producer.CameraGroup.SingleThreaded)

    update = osgUtil.UpdateVisitor()

    while not kbmcb.done():
        # syncronize to the when cull and draw threads have completed.
        cg.sync()

        # update the scene by traversing it with the the update visitor which will
        # call all node update callbacks and animations.
        cg.getSceneData().accept(update)

        tb.input( kbmcb.mx(), kbmcb.my(), kbmcb.mbutton() )

        # update the main producer camera
        cg.setViewByMatrix(tb.getMatrix())

        # fire off the cull and draw traversals of the scene.
        cg.frame()

    # syncronize to the when cull and draw threads have completed.
    cg.sync()

    return 0

if __name__ == "__main__":
    # raw_input("press enter")
    main(sys.argv)