#!/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 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__":
    # raw_input("Press Enter:")
    main(sys.argv)