from PyOSG import Producer
from PyOSG import osg
from PyOSG import osgGA
from PyOSG import osgDB
from PyOSG import osgProducer
from OpenGL.GL import *

s_imageStream = None
#class PostSwapFinishCallback( Producer.Camera.Callback):
#    def __init__(self):
#        Producer.Camera.Callback.__init__(self)
#
#    def apply(self, camera):
#        global s_imageStream
#        # osg.Timer_t start_tick = osg.Timer.instance().tick()
#
#        osgProducer.OsgSceneHandler* sh = const_cast<osgProducer.OsgSceneHandler*>(dynamic_cast<const osgProducer.OsgSceneHandler*>(camera.getSceneHandler()))
#
#        if s_imageStream and s_imageStream.getPixelBufferObject():
#            s_imageStream.getPixelBufferObject().compileBuffer(*(sh.getSceneView().getState()))
#        # glFinish()
#        #osg.notify(osg.NOTICE)<<"callback after PBO "<<osg.Timer.instance().delta_m(start_tick,osg.Timer.instance().tick())<<"ms"<<std.endl


class MovieEventHandler(osgGA.GUIEventHandler):
    class FindImageStreamsVisitor(osg.NodeVisitor):
        def __init__(self, imageStreamList):
            osg.NodeVisitor.__init__(self)
            self._imageStreamList = imageStreamList

        def apply(self, node):
            geode = node.asGeode()
            if not geode:
                self.apply_node(node)
                return

            self.apply_stateset(geode.getStateSet())
            for i in range(geode.getNumDrawables()):
                self.apply_stateset(geode.getDrawable(i).getStateSet())
            self.traverse(geode)

        def apply_node(self, node):
            self.apply_stateset(node.getStateSet())
            self.traverse(node)

        def apply_stateset(self, stateset):
            if not stateset:
                return

            attr = stateset.getTextureAttribute(0,osg.StateAttribute.TEXTURE)
            if attr:

                texture2D = attr.asTexture2D()
                if texture2D:
                    self.apply_imagestream(texture2D.getImage().asImageStream())

                textureRec = attr.asTextureRectangle()
                if textureRec:
                    self.apply_imagestream(textureRec.getImage().asImageStream())

        def apply_imagestream(self, imagestream):
            global s_imageStream
            if imagestream:
                self._imageStreamList.append(imagestream)
                s_imageStream = imagestream

    def __init__(self):
        osgGA.GUIEventHandler.__init__(self)
        self._imageStreamList = []

    def set(self, node):
        self._imageStreamList = []
        if node:
            fisv = MovieEventHandler.FindImageStreamsVisitor(self._imageStreamList)
            node.accept(fisv)

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

    def handle(self, ea, aa):
        if ea.getEventType() == osgGA.GUIEventAdapter.KEYDOWN:
            if ea.getKey()==ord('s'):
                for itr in self._imageStreamList:
                    print "Play"
                    itr.play()
                return True
            elif ea.getKey()==ord('p'):
                for itr in self._imageStreamList:
                    print "Pause"
                    itr.pause()
                return True
            elif ea.getKey()==ord('r'):
                return True
            elif ea.getKey()==ord('l'):
                return True
            return False
        else:
            return False

    def getUsage(self, usage):
        usage.addKeyboardMouseBinding("p","Pause movie")
        usage.addKeyboardMouseBinding("s","Play movie")
        usage.addKeyboardMouseBinding("r","Start movie")
        usage.addKeyboardMouseBinding("l","Toggle looping of movie")


def createTexturedQuadGeometry(pos, width, height, image):
    useTextureRectangle = True
    if useTextureRectangle:
        pictureQuad = osg.createTexturedQuadGeometry(pos,
                                           osg.Vec3(width,0.0,0.0),
                                           osg.Vec3(0.0,0.0,height),
                                           0.0,image.t(), image.s(),0.0)

        pictureQuad.getOrCreateStateSet().setTextureAttributeAndModes(0,
                    osg.TextureRectangle(image),
                    osg.StateAttribute.ON)
        return pictureQuad
    else:
        pictureQuad = osg.createTexturedQuadGeometry(pos,
                                           osg.Vec3(width,0.0,0.0),
                                           osg.Vec3(0.0,0.0,height),
                                           0.0,0.0, 1.0,1.0)

        pictureQuad.getOrCreateStateSet().setTextureAttributeAndModes(0,
                    osg.Texture2D(image),
                    osg.StateAttribute.ON)
        return pictureQuad


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 OpenSceneGraph example which loads and visualises 3d models.")
    arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...")
    arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information")


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

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

    # register the handler to add keyboard and mosue handling.
    meh =MovieEventHandler()
    viewer.getEventHandlerList().push_front(meh)

    # 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

    geode = osg.Geode()
    pos = osg.Vec3(0.0,0.0,0.0)

    for i in range(1, arguments.argc()):
        if arguments.isString(i):
            image = osgDB.readImageFile(arguments[i])
            imagestream = image.asImageStream()
            if imagestream:
                imagestream.play()

            if image:
                geode.addDrawable(createTexturedQuadGeometry(pos,image.s(),image.t(),image))
                geode.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF)

                pos._z += image.t() * 1.5
            else:
                print "Unable to read file " + arguments[i]

    if geode.getNumDrawables() == 0:
        # nothing loaded.
        return 1

    # pass the model to the MovieEventHandler so it can pick out ImageStream's to manipulate.
    meh.set(geode)

    # 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


    # 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(std.cout)

#    # set up a post swap callback to flush deleted GL objects and compile new GL objects
#    for(unsigned int cameraNum=0;cameraNum<viewer.getNumberOfCameras();++cameraNum)
#    {
#        Producer.Camera* camera=viewer.getCamera(cameraNum)
#        camera.addPostSwapCallback(new PostSwapFinishCallback())
#    }

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

    # 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__":
    import sys
    main(sys.argv)