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

import sys
import math
from PyOSG import *

# include the call which creates the shadowed subgraph.
from CreateShadowedScene import createShadowedScene

# for the grid data..
from terrain_coords import vertex

def createAnimationPath(center, radius, looptime):
    # set up the animation path 
    animationPath = osg.AnimationPath()
    animationPath.setLoopMode(osg.AnimationPath.LOOP)
    
    numSamples = 40
    yaw = 0.0
    yaw_delta = 2.0*osg.PI/float(numSamples-1.0)
    roll = osg.inDegrees(30.0)
    
    time=0.0
    time_delta = looptime/float(numSamples)
    for i in range(numSamples):
        position = center + osg.Vec3(math.sin(yaw)*radius,math.cos(yaw)*radius,0.0)
        rotation = osg.Quat(roll,osg.Vec3(0.0,1.0,0.0))*osg.Quat(-(yaw+osg.inDegrees(90.0)),osg.Vec3(0.0,0.0,1.0))
        
        animationPath.insert(time,osg.AnimationPath.ControlPoint(position,rotation))

        yaw += yaw_delta
        time += time_delta
    
    return animationPath


def createBase( center, radius):

    geode = osg.Geode()

    # set up the texture of the base.
    stateset = osg.StateSet()
    image = osgDB.readImageFile("Images/lz.rgb")
    if image:
        texture = osg.Texture2D()
        texture.setImage(image)
        stateset.setTextureAttributeAndModes(0,texture,osg.StateAttribute.ON)

    geode.setStateSet( stateset )

    grid = osg.HeightField()
    grid.allocate(38,39)
    grid.setOrigin(center+osg.Vec3(-radius,-radius,0.0))
    grid.setXInterval(radius*2.0/float(38-1))
    grid.setYInterval(radius*2.0/float(39-1))

    minHeight = 1.0e38
    maxHeight = -1.0e38

    for r in range(39):
        for c in range(38):
            h = vertex[r+c*39][2]
            if (h>maxHeight):
                maxHeight=h
            if (h<minHeight):
                minHeight=h

    hieghtScale = radius*0.5/(maxHeight-minHeight)
    hieghtOffset = -(minHeight+maxHeight)*0.5

    for r in range(39):
        for c in range(38):
            h = vertex[r+c*39][2]
            grid.setHeight(c,r,(h+hieghtOffset)*hieghtScale)

    geode.addDrawable(osg.ShapeDrawable(grid))

    group = osg.Group()
    group.addChild(geode)

    return group



def createMovingModel(center,  radius):

    animationLength = 10.0

    animationPath = createAnimationPath(center,radius,animationLength)

    model = osg.Group()
 
    cessna = osgDB.readNodeFile("cessna.osg")
    if cessna:
    
        bs = cessna.getBound()

        size = radius/bs.radius()*0.3
        positioned = osg.MatrixTransform()
        positioned.setDataVariance(osg.Object.STATIC)
        positioned.setMatrix(osg.Matrix.translate(-bs.center())*
                              osg.Matrix.scale(size,size,size)*
                              osg.Matrix.rotate(osg.inDegrees(180.0),0.0,0.0,2.0))
    
        positioned.addChild(cessna)
    
        xform = osg.MatrixTransform()
        xform.setUpdateCallback(osg.AnimationPathCallback(animationPath,0.0,2.0))
        xform.addChild(positioned)

        model.addChild(xform)
    
    return model





def createModel():

    center = osg.Vec3(0.0,0.0,0.0)
    radius = 100.0
    lightPosition = center+osg.Vec3(0.0,0.0,radius)

    # the shadower model
    shadower = createMovingModel(center,radius*0.5)

    # the shadowed model
    shadowed = createBase(center-osg.Vec3(0.0,0.0,radius*0.25),radius)

    # combine the models together to create one which has the shadower and the shadowed with the required callback.
    root = createShadowedScene(shadower,shadowed,lightPosition,radius/100.0,1)

    return root



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 of pre rendering to texture to create a shadow effect..")
    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
    
    
    # load the nodes from the commandline arguments.
    model = createModel()
    if  not model:
        return 1
    
    # comment out optimization over the scene graph right now as it optimizers away the shadow... will look into this..
    #optimzer = osgUtil.Optimizer()
    #optimzer.optimize(rootnode)
     
    # add a viewport to the viewer and attach the scene graph.
    viewer.setSceneData( model )
    
    # 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__":
    # raw_input("Press enter:")
    main(sys.argv)