#!/usr/bin/env python

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

def create_specular_highlights(node):
    ss = node.getOrCreateStateSet()

    # create and setup the texture object
    tcm = osg.TextureCubeMap()
    tcm.setWrap(osg.Texture.WRAP_S, osg.Texture.CLAMP)
    tcm.setWrap(osg.Texture.WRAP_T, osg.Texture.CLAMP)
    tcm.setWrap(osg.Texture.WRAP_R, osg.Texture.CLAMP)
    tcm.setFilter(osg.Texture.MIN_FILTER, osg.Texture.LINEAR_MIPMAP_LINEAR)
    tcm.setFilter(osg.Texture.MAG_FILTER, osg.Texture.LINEAR);

    # generate the six highlight map images (light direction = [1, 1, -1])
    mapgen = osgUtil.HighlightMapGenerator(
        osg.Vec3(1, 1, -1),          # light direction
        osg.Vec4(1, 0.9, 0.8, 1),    # light color
        8)                           # specular exponent

    mapgen.generateMap()

    # assign the six images to the texture object
    tcm.setImage(osg.TextureCubeMap.POSITIVE_X, mapgen.getImage(osg.TextureCubeMap.POSITIVE_X))
    tcm.setImage(osg.TextureCubeMap.NEGATIVE_X, mapgen.getImage(osg.TextureCubeMap.NEGATIVE_X))
    tcm.setImage(osg.TextureCubeMap.POSITIVE_Y, mapgen.getImage(osg.TextureCubeMap.POSITIVE_Y))
    tcm.setImage(osg.TextureCubeMap.NEGATIVE_Y, mapgen.getImage(osg.TextureCubeMap.NEGATIVE_Y))
    tcm.setImage(osg.TextureCubeMap.POSITIVE_Z, mapgen.getImage(osg.TextureCubeMap.POSITIVE_Z))
    tcm.setImage(osg.TextureCubeMap.NEGATIVE_Z, mapgen.getImage(osg.TextureCubeMap.NEGATIVE_Z))

    # enable texturing, replacing any textures in the subgraphs
    ss.setTextureAttributeAndModes(0, tcm, osg.StateAttribute.OVERRIDE | osg.StateAttribute.ON)

    # texture coordinate generation
    tg = osg.TexGen()
    tg.setMode(osg.TexGen.REFLECTION_MAP)
    ss.setTextureAttributeAndModes(0, tg, osg.StateAttribute.OVERRIDE | osg.StateAttribute.ON)

    # use TexEnvCombine to add the highlights to the original lighting
    te = osg.TexEnvCombine()
    te.setCombine_RGB(osg.TexEnvCombine.ADD)
    te.setSource0_RGB(osg.TexEnvCombine.TEXTURE)
    te.setOperand0_RGB(osg.TexEnvCombine.SRC_COLOR)
    te.setSource1_RGB(osg.TexEnvCombine.PRIMARY_COLOR)
    te.setOperand1_RGB(osg.TexEnvCombine.SRC_COLOR)
    ss.setTextureAttributeAndModes(0, te, osg.StateAttribute.OVERRIDE | osg.StateAttribute.ON)

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 texture cube mapping.");
    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)

    # 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:
        return 1

    # create specular highlights
    create_specular_highlights(rootnode)

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

    # add model to viewer
    viewer.setSceneData(rootnode)

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

    for contextID in range(viewer.getDisplaySettings().getMaxNumberOfGraphicsContexts()):
        tcmExt = osg.TextureCubeMap.getExtensions(contextID, False)
        if tcmExt:
            if not tcmExt.isCubeMapSupported():
                print "Warning: texture_cube_map not supported by OpenGL drivers, unable to run application."
                return 1

    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)