#!/usr/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.
#

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

class UpdateCallback(osg.NodeCallback):
    def __init__(self):
        osg.NodeCallback.__init__(self)
        self._self = self

    def apply(self, node, nv):
        print "update callback - pre traverse", node
        self.traverse(node,nv)
        print "update callback - post traverse", node

class CullCallback(osg.NodeCallback):
    def __init__(self):
        osg.NodeCallback.__init__(self)

    def apply(self, node, nv):
        print "cull callback - pre traverse", node
        self.traverse(node,nv)
        print "cull callback - post traverse", node

class DrawableDrawCallback(osg.Drawable.DrawCallback):
    def __init__(self):
        osg.Drawable.DrawCallback.__init__(self)

    def drawImplementation(self, state, drawable):
        print "draw call back - pre drawImplementation", drawable
        drawable.drawImplementation(state)
        print "draw call back - post drawImplementation", drawable

class DrawableUpdateCallback(osg.Drawable.UpdateCallback):
    def __init__(self):
        osg.Drawable.UpdateCallback.__init__(self)

    def update(self, nv, drawable):
        print "Drawable update callback ", drawable

class DrawableCullCallback(osg.Drawable.CullCallback):
    def __init__(self):
        osg.Drawable.CullCallback.__init__(self)
        self._self = self

    # do customized cull code
    def cull(self, nv, drawable, state):
        print "Drawable cull callback "
        return False

class InsertCallbacksVisitor(osg.NodeVisitor):
    def __init__(self):
        osg.NodeVisitor.__init__(self, osg.NodeVisitor.TRAVERSE_ALL_CHILDREN)

    def apply_node(self, node):
        node.setUpdateCallback(UpdateCallback());
        node.setCullCallback(CullCallback());
        self.traverse(node);

    def apply(self, node):
        geode = node.asGeode()
        transform = node.asTransform()
        if geode:
            geode.setUpdateCallback(UpdateCallback())

            #note, it makes no sense to attach a cull callback to the node
            #at there are no nodes to traverse below the geode, only
            #drawables, and as such the Cull node callbacks is ignored.
            #If you wish to control the culling of drawables
            #then use a drawable cullback...

            for i in range(geode.getNumDrawables()):
                geode.getDrawable(i).setUpdateCallback(DrawableUpdateCallback())
                geode.getDrawable(i).setCullCallback(DrawableCullCallback())
                geode.getDrawable(i).setDrawCallback(DrawableDrawCallback())
        elif transform:
            self.apply_node(node)
        else:
            self.apply_node(node)

# XXX To implement
#class MyReadFileCallback : public osgDB::Registry::ReadFileCallback
#{
#public:
#    virtual osgDB::ReaderWriter::ReadResult readNode(const std::string& fileName, osgDB::ReaderWriter::Options* options)
#    {
#        std::cout<<"before readNode"<<std::endl;
#        // note when calling the Registry to do the read you have to call readNodeImplementation NOT readNode, as this will
#        // cause on infinite recusive loop.
#        osgDB::ReaderWriter::ReadResult result = osgDB::Registry::instance()->readNodeImplementation(fileName,options);
#        std::cout<<"after readNode"<<std::endl;
#        return result;
#    }
#};

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().setDescription(arguments.getApplicationName()+" is the example which demonstrates use of the range of different types of callbacks supported in the OpenSceneGraph.")
    arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...")
    arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information")

    # set the osgDB::Registy the read file callback to catch all requests for reading files.
    # XXX osgDB.Registry.instance().setReadFileCallback(MyReadFileCallback())

    # initialize the viewer.
    viewer = osgProducer.Viewer(arguments)

    # set up the value with sensible default event handlers.
    viewer.setUpViewer(osgProducer.Viewer.STANDARD_SETTINGS)

    # get details on keyboard and mouse bindings used by the viewer.
    viewer.getUsage(arguments.getApplicationUsage())

    # 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
    

    # load the nodes from the commandline arguments.
    rootnode = osgDB.readNodeFiles(arguments)
    if not rootnode:
#        write_usage(osg.notify(osg.NOTICE),argv[0])
        return 1

    # run optimization over the scene graph
    optimzer = osgUtil.Optimizer()
    optimzer.optimize(rootnode)

    # insert all the callbacks
    icv = InsertCallbacksVisitor()
    rootnode.accept(icv)

    # set the scene to render
    viewer.setSceneData(rootnode)

    # create the windows and run the threads.
    viewer.realize()

    while not viewer.done():
        # wait for all cull and draw threads to complete.
        viewer.sync()

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

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

    # wait for all cull and draw threads to complete before exit.
    viewer.sync()

    return 0

if __name__ == "__main__":
    main(sys.argv)