from PyOSG import *
from OpenGL.GL import *
from terrain_coords import vertex
import math


def createSpotLightImage(centerColour, backgroudColour, size,  power):
    image = osg.Image()
    image.allocateImage(size,size,1,
                         GL_RGBA,GL_UNSIGNED_BYTE)


    mid = (float(size)-1)*0.5
    div = 2.0/float(size)
    for r in range(size):
        # ptr = image.data(0,r,0) : FIXME
        for c in range(size):
            dx = (float(c) - mid)*div
            dy = (float(r) - mid)*div
            i = pow(1.0-math.sqrt(dx*dx+dy*dy),power)
            if i<0.0: i=0.0
            color = centerColour*i+backgroudColour*(1.0-i)
            image.setPixel(c, r, 0, color)

            #*ptr++ = (unsigned char)((color[0])*255.0)
            #*ptr++ = (unsigned char)((color[1])*255.0)
            #*ptr++ = (unsigned char)((color[2])*255.0)
            #*ptr++ = (unsigned char)((color[3])*255.0)
    return image

    #return osgDB.readImageFile("spot.dds")

def createSpotLightDecoratorState(lightNum, textureUnit):
    stateset = osg.StateSet()

    stateset.setMode(GL_LIGHT0+lightNum, osg.StateAttribute.ON)

    centerColour = osg.Vec4(1.0,1.0,1.0,1.0)
    ambientColour = osg.Vec4(0.05,0.05,0.05,1.0)

    # set up spot light texture
    texture = osg.Texture2D()
    texture.setImage(createSpotLightImage(centerColour, ambientColour, 64, 1.0))
    texture.setBorderColor(osg.Vec4(ambientColour))
    texture.setWrap(osg.Texture.WRAP_S,osg.Texture.CLAMP_TO_BORDER)
    texture.setWrap(osg.Texture.WRAP_T,osg.Texture.CLAMP_TO_BORDER)
    texture.setWrap(osg.Texture.WRAP_R,osg.Texture.CLAMP_TO_BORDER)

    stateset.setTextureAttributeAndModes(textureUnit, texture, osg.StateAttribute.ON)

    # set up tex gens
    stateset.setTextureMode(textureUnit, GL_TEXTURE_GEN_S, osg.StateAttribute.ON)
    stateset.setTextureMode(textureUnit, GL_TEXTURE_GEN_T, osg.StateAttribute.ON)
    stateset.setTextureMode(textureUnit, GL_TEXTURE_GEN_R, osg.StateAttribute.ON)
    stateset.setTextureMode(textureUnit, GL_TEXTURE_GEN_Q, osg.StateAttribute.ON)

    return stateset


def createSpotLightNode(position, direction, angle, lightNum, textureUnit):
    group = osg.Group()

    # create light source.
    lightsource = osg.LightSource()
    light = lightsource.getLight()
    light.setLightNum(lightNum)
    light.setPosition(osg.Vec4(position,1.0))
    light.setAmbient(osg.Vec4(0.00,0.00,0.05,1.0))
    light.setDiffuse(osg.Vec4(1.0,1.0,1.0,1.0))
    group.addChild(lightsource)

    # create tex gen.

    up = osg.Vec3(0.0,0.0,1.0)
    up = (direction ^ up) ^ direction
    up.normalize()

    texgenNode = osg.TexGenNode()
    texgenNode.setTextureUnit(textureUnit)
    texgen = texgenNode.getTexGen()
    texgen.setMode(osg.TexGen.EYE_LINEAR)
    texgen.setPlanesFromMatrix(osg.Matrix.lookAt(position, position+direction, up)*
                                osg.Matrix.perspective(angle,1.0,0.1,100))


    group.addChild(texgenNode)

    return group


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/(numSamples-1.0)
    roll = osg.inDegrees(30.0)

    time=0.0
    time_delta = looptime/float(numSamples)
    for i in range(numSamples):
        position = osg.Vec3(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 = 1e38
    maxHeight = -1e38

    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)

        xform.addChild(createSpotLightNode(osg.Vec3(0.0,0.0,0.0), osg.Vec3(0.0,1.0,-1.0), 60.0, 0, 1))

        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.1),radius)

    # combine the models together to create one which has the shadower and the shadowed with the required callback.
    root = osg.Group()

    root.setStateSet(createSpotLightDecoratorState(0,1))

    root.addChild(shadower)
    root.addChild(shadowed)

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