#!/usr/bin/env python
import sys
import os
import math
from PyOSG import Producer
from PyOSG import osg
from PyOSG import osgGA
from PyOSG import osgUtil
from PyOSG import osgProducer
from PyOSG import osgDB

class TechniqueEventHandler(osgGA.GUIEventHandler):
    def __init__(self, logicOp):
        osgGA.GUIEventHandler.__init__(self)
        self._ops_nb=16
        self._logicOp = logicOp
        self._ops_index = self._ops_nb - 1
        self._operations = [
                osg.LogicOp.CLEAR,
                osg.LogicOp.SET,
                osg.LogicOp.COPY,
                osg.LogicOp.COPY_INVERTED,
                osg.LogicOp.NOOP,
                osg.LogicOp.INVERT,
                osg.LogicOp.AND,
                osg.LogicOp.NAND,
                osg.LogicOp.OR,
                osg.LogicOp.NOR,
                osg.LogicOp.XOR,
                osg.LogicOp.EQUIV,
                osg.LogicOp.AND_REVERSE,
                osg.LogicOp.AND_INVERTED,
                osg.LogicOp.OR_REVERSE,
                osg.LogicOp.OR_INVERTED
                ]

        self._ops_name=[
                "osg.LogicOp.CLEAR",
                "osg.LogicOp.SET",
                "osg.LogicOp.COPY",
                "osg.LogicOp.COPY_INVERTED",
                "osg.LogicOp.NOOP",
                "osg.LogicOp.INVERT",
                "osg.LogicOp.AND",
                "osg.LogicOp.NAND",
                "osg.LogicOp.OR",
                "osg.LogicOp.NOR",
                "osg.LogicOp.XOR",
                "osg.LogicOp.EQUIV",
                "osg.LogicOp.AND_REVERSE",
                "osg.LogicOp.AND_INVERTED",
                "osg.LogicOp.OR_REVERSE",
                "osg.LogicOp.OR_INVERTED"
                ]
        self._self = self

    def accept(self, v):
        v.visit(self)

    def handle(self, ea, aa):
        eType = ea.getEventType()
        if eType == osgGA.GUIEventAdapter.KEYDOWN:
            if ea.getKey()==osgGA.GUIEventAdapter.KEY_Right or \
                ea.getKey()==osgGA.GUIEventAdapter.KEY_KP_Right:
                self._ops_index += 1
                if self._ops_index >= self._ops_nb:
                    self._ops_index=0
                self._logicOp.setOpcode(self._operations[self._ops_index])
                print "Operation name = ", self._ops_name[self._ops_index]
                return True
            elif ea.getKey()==osgGA.GUIEventAdapter.KEY_Left or \
                    ea.getKey()==osgGA.GUIEventAdapter.KEY_KP_Left:
                self._ops_index -= 1
                if self._ops_index<0:
                    self._ops_index=self._ops_nb-1
                self._logicOp.setOpcode(self._operations[self._ops_index])
                print "Operation name = ", self._ops_name[self._ops_index]
                return True
            return False
        return False

    def getUsage(self, usage):
        usage.addKeyboardMouseBinding("- or Left Arrow","Advance to next opcode")
        usage.addKeyboardMouseBinding("+ or Right Array","Move to previous opcode")


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 how to use glBlendEquation for mixing rendered scene and the frame-buffer.")
    arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...")
    arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information")

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

    # load the nodes from the commandline arguments.
    loadedModel = osgDB.readNodeFiles(arguments)
    if not loadedModel:
        return 1

    root = osg.Group()
    root.addChild(loadedModel)

    stateset = osg.StateSet()
    logicOp = osg.LogicOp(osg.LogicOp.OR_INVERTED)

    stateset.setAttributeAndModes(logicOp,osg.StateAttribute.OVERRIDE|osg.StateAttribute.ON)


    #tell to sort the mesh before displaying it
    stateset.setRenderingHint(osg.StateSet.TRANSPARENT_BIN)

    loadedModel.setStateSet(stateset)

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

    viewer.getEventHandlerList().push_front(TechniqueEventHandler(logicOp))

    # 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(os.stdout)
        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(os.stdout)
        return 1

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

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

    # add a viewport to the viewer and attach the scene graph.
    viewer.setSceneData( root )

    # 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)