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

from PyOSG import *
import sys

def addToLightPointNode(lpn, start, end, noSteps):
    if noSteps<=1:
        lpn.addLightPoint(start)
        return
    
    rend = 0.0
    rdelta = 1.0/(float(noSteps)-1.0)
    
#---    lpn.getLightPointList().reserve(noSteps)
    
    for i in range(noSteps):
        rend += rdelta
        rstart = 1.0-rend
        lp = osgSim.LightPoint(start)
        lp._position = start._position * rstart + end._position * rend
        lp._intensity = start._intensity * rstart + end._intensity * rend
        lp._color = start._color * rstart + end._color * rend
        lp._radius = start._radius * rstart + end._radius * rend

        lpn.addLightPoint(lp)


def createLightPointsDatabase():
    start = osgSim.LightPoint()
    end =  osgSim.LightPoint()

    start._position.set(0.0,0.0,0.0)
    start._color.set(1.0,0.0,0.0,1.0)
    
    end._position.set(1000.0,0.0,0.0)
    end._color.set(1.0,1.0,1.0,1.0)
    
    transform = osg.Transform()

    start_delta = osg.Vec3(0.0,10.0,0.0)
    end_delta = osg.Vec3(0.0,10.0,1.0)

    noStepsX = 100
    noStepsY = 100

#     osgSim.BlinkSequence* bs = osgSim.BlinkSequence
#     bs.addPulse(1.0,osg.Vec4(1.0,0.0,0.0,1.0))
#     bs.addPulse(0.5,osg.Vec4(0.0,0.0,0.0,0.0)); # off
#     bs.addPulse(1.5,osg.Vec4(1.0,1.0,0.0,1.0))
#     bs.addPulse(0.5,osg.Vec4(0.0,0.0,0.0,0.0)); # off
#     bs.addPulse(1.0,osg.Vec4(1.0,1.0,1.0,1.0))
#     bs.addPulse(0.5,osg.Vec4(0.0,0.0,0.0,0.0)); # off
    

#    osgSim.Sector* sector = osgSim.ConeSector(osg.Vec3(0.0,0.0,1.0),osg.inDegrees(45.0),osg.inDegrees(45.0))
#    osgSim.Sector* sector = osgSim.ElevationSector(-osg.inDegrees(45.0),osg.inDegrees(45.0),osg.inDegrees(45.0))
#    osgSim.Sector* sector = osgSim.AzimSector(-osg.inDegrees(45.0),osg.inDegrees(45.0),osg.inDegrees(90.0))
#     osgSim.Sector* sector = osgSim.AzimElevationSector(osg.inDegrees(180),osg.inDegrees(90), # azim range
#                                                                 osg.inDegrees(0.0),osg.inDegrees(90.0), # elevation range
#                                                                 osg.inDegrees(5.0))

    for i in range(noStepsY):
#         osgSim.BlinkSequence* local_bs = osgSim.BlinkSequence(*bs)
#         local_bs.setSequenceGroup(new osgSim.BlinkSequence.SequenceGroup((double)i*0.1));        
#         start._blinkSequence = local_bs

#        start._sector = sector

        lpn = osgSim.LightPointNode()
        addToLightPointNode(lpn,start,end,noStepsX)
        
        start._position += start_delta
        end._position += end_delta
        
        transform.addChild(lpn)
        
    group = osg.Group()
    group.addChild(transform)

    return group


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 high quality light point, typically used for naviagional lights.")
    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
    
    rootnode = osg.Group()

    # load the nodes from the commandline arguments.
    rootnode.addChild(osgDB.readNodeFiles(arguments))
    rootnode.addChild(createLightPointsDatabase())
    
    
    # run optimization over the scene graph
    optimzer = osgUtil.Optimizer()
    optimzer.optimize(rootnode)
     
    # add a viewport to the viewer and attach the scene graph.
    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)