#!/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 osg
from PyOSG import osgUtil
import math
import OpenGL
from OpenGL.GL import *

# TODO: Make it up to date with the osg demo

keep = []
class MyTexGen(osg.TexGenDer):
    def __init__(self):
        osg.TexGenDer.__init__(self)

        # XXX Dirty trick to prevent the garbage collector from
        # deleting the instance of MyTexGen.
        # Need to do this since the MyTexGen instance is passed to osg
        # and osg is unable to increase the reference of the instance object
        # Thus the moment the object goes out of scope, it is flagged for deletion, 
        # UNLESS it is self referencing (circular reference)!
        self._self = self

        self._matrix = osg.Matrix()

    def setMatrix(self, matrix):
        self._matrix = matrix

    def apply(self, state):
        glPushMatrix()
        glLoadMatrixf(self._matrix.asList())
        osg.TexGenDer.apply(self, state)
        glPopMatrix()

class CreateShadowTextureCullCallback(osg.NodeCallback):
    def __init__(self, shadower, position, ambientLightColor, textureUnit):
        osg.NodeCallback.__init__(self)
        self._self = self
        self._shadower = shadower
        self._position = position
        self._ambientLightColor = ambientLightColor
        self._unit = textureUnit
        self._shadowState = osg.StateSet()
        
        self._texture = osg.Texture2D()
        self._texture.setFilter(osg.Texture2D.MIN_FILTER,osg.Texture2D.LINEAR)
        self._texture.setFilter(osg.Texture2D.MAG_FILTER,osg.Texture2D.LINEAR)
        self._texture.setWrap(osg.Texture2D.WRAP_S,osg.Texture2D.CLAMP_TO_BORDER)
        self._texture.setWrap(osg.Texture2D.WRAP_T,osg.Texture2D.CLAMP_TO_BORDER)
        self._texture.setBorderColor(osg.Vec4(1.0,1.0,1.0,1.0))

    def apply(self, node, nv):
        cullVisitor = osgUtil.asCullVisitor(nv)
        if cullVisitor and self._texture and self._shadower:
            self.doPreRender(node,cullVisitor, nv)
        else:
            # must traverse the shadower            
            self.traverse(node, nv)

    def doPreRender(self, node, cv, nv):
        global keep
        bs = self._shadower.getBound()
        if not bs:
            print "bb invalid", self._shadower
            return

        # create the render to texture stage.
        rtts = osgUtil.RenderToTextureStage()
        #--  keep.append(rtts)

        # set up lighting.
        # currently ignore lights in the scene graph itself..
        # will do later.
        previous_stage = cv.getCurrentRenderBin().getStage()

        # set up the background color and clear mask.
        rtts.setClearColor(osg.Vec4(1.0,1.0,1.0,1.0))
        rtts.setClearMask(previous_stage.getClearMask())

        # set up to charge the same RenderStageLighting is the parent previous stage.
        rtts.setRenderStageLighting(previous_stage.getRenderStageLighting())

        # record the render bin, to be restored after creation
        # of the render to text
        previousRenderBin = cv.getCurrentRenderBin()

        # set the current renderbin to be the newly created stage.
        cv.setCurrentRenderBin(rtts)

        centerDistance = (self._position-bs.center()).length()

        znear = centerDistance-bs.radius()
        zfar  = centerDistance+bs.radius()
        zNearRatio = 0.001
        if znear<zfar*zNearRatio:
            znear = zfar*zNearRatio


        # 2:1 aspect ratio as per flag geomtry below.
        top   = (bs.radius()/centerDistance)*znear
        right = top

        # set up projection.
        projection = osg.RefMatrix()
        projection.makeFrustum(-right,right,-top,top,znear,zfar)

        cv.pushProjectionMatrix(projection)

        matrix = osg.RefMatrix()
        matrix.makeLookAt(self._position,bs.center(),osg.Vec3(0.0,1.0,0.0))

        MV = cv.getModelViewMatrix()

        # compute the matrix which takes a vertex from local coords into tex coords
        # will use this later to specify osg.TexGen..
        MVPT = matrix * projection * osg.Matrix.translate(1.0,1.0,1.0) * osg.Matrix.scale(0.5,0.5,0.5)

        cv.pushModelViewMatrix(matrix)

        # make the material black for a shadow.
        material = osg.Material()
        material.setAmbient(osg.Material.FRONT_AND_BACK,self._ambientLightColor)
        material.setDiffuse(osg.Material.FRONT_AND_BACK,osg.Vec4(0.0,0.0,0.0,1.0))
        material.setEmission(osg.Material.FRONT_AND_BACK,osg.Vec4(0.0,0.0,0.0,1.0))
        material.setShininess(osg.Material.FRONT_AND_BACK,0.0)
        self._shadowState.setAttribute(material,osg.StateAttribute.OVERRIDE)

        cv.pushStateSet(self._shadowState)
        # traverse the shadower
        self._shadower.accept(cv)

        cv.popStateSet()

        # restore the previous model view matrix.
        cv.popModelViewMatrix()


        # restore the previous model view matrix.
        cv.popProjectionMatrix()

        # restore the previous renderbin.
        cv.setCurrentRenderBin(previousRenderBin)

        #-- if rtts._renderGraphList.size()==0 and rtts._bins.size()==0:
        #--     # getting to this point means that all the shadower has been
        #--     # culled by small feature culling or is beyond LOD ranges.
        #--     return

        height = 256
        width  = 256

        viewport = cv.getViewport()

        # offset the impostor viewport from the center of the main window
        # viewport as often the edges of the viewport might be obscured by
        # other windows, which can cause image/reading writing problems.
        center_x = viewport.x()+viewport.width()/2
        center_y = viewport.y()+viewport.height()/2

        new_viewport = osg.Viewport()
        new_viewport.setViewport(center_x-width/2,center_y-height/2,width,height)
        rtts.setViewport(new_viewport)
        
        self._shadowState.setAttribute(new_viewport)

        # and the render to texture stage to the current stages
        # dependancy list.
        cv.getCurrentRenderBin().getStage().addToDependencyList(rtts)

        # if one exist attach texture to the RenderToTextureStage.
        if self._texture:
            rtts.setTexture(self._texture)

        # set up the stateset to decorate the shadower with the shadow texture
        # with the appropriate tex gen coords.
        stateset = osg.StateSet()
        # XXX When I remove this, the application crashes, 
        # don't know why... Maybe multithreading problem ?
        # The C version has the same problem, it has actually a major memory 
        # leak in this respect (so does the python version)
        keep.append(stateset)

        texgen = MyTexGen()
        keep.append(texgen)
        texgen.setMatrix(MV)
        texgen.setMode(osg.TexGen.EYE_LINEAR)
        texgen.setPlane(osg.TexGen.S,osg.Plane(MVPT[0*4 + 0],MVPT[1*4 + 0],MVPT[2*4 + 0],MVPT[3*4 + 0]))
        texgen.setPlane(osg.TexGen.T,osg.Plane(MVPT[0*4 + 1],MVPT[1*4 + 1],MVPT[2*4 + 1],MVPT[3*4 + 1]))
        texgen.setPlane(osg.TexGen.R,osg.Plane(MVPT[0*4 + 2],MVPT[1*4 + 2],MVPT[2*4 + 2],MVPT[3*4 + 2]))
        texgen.setPlane(osg.TexGen.Q,osg.Plane(MVPT[0*4 + 3],MVPT[1*4 + 3],MVPT[2*4 + 3],MVPT[3*4 + 3]))

        stateset.setTextureAttributeAndModes(self._unit,self._texture,osg.StateAttribute.ON)
        stateset.setTextureAttribute(self._unit,texgen)
        stateset.setTextureMode(self._unit,GL_TEXTURE_GEN_S,osg.StateAttribute.ON)
        stateset.setTextureMode(self._unit,GL_TEXTURE_GEN_T,osg.StateAttribute.ON)
        stateset.setTextureMode(self._unit,GL_TEXTURE_GEN_R,osg.StateAttribute.ON)
        stateset.setTextureMode(self._unit,GL_TEXTURE_GEN_Q,osg.StateAttribute.ON)

        cv.pushStateSet(stateset)

        # must traverse the shadower
        self.traverse(node,cv)

        cv.popStateSet()

# set up a light source with the shadower and shodower subgraphs below it
# with the appropriate callbacks set up.

def createShadowedScene(shadower, shadowed, lightPosition, radius, textureUnit):
    lightgroup = osg.LightSource()

    light = osg.Light()
    light.setPosition(osg.Vec4(lightPosition,1.0))
    light.setLightNum(0)

    lightgroup.setLight(light)
    
    ambientLightColor = osg.Vec4(0.1,0.1,0.1,1.0)

    # add the shadower
    lightgroup.addChild(shadower)

    # add the shadowed with the callback to generate the shadow texture.
    shadowed.setCullCallback(CreateShadowTextureCullCallback(shadower,lightPosition,ambientLightColor,textureUnit))
    lightgroup.addChild(shadowed)
    
    lightgeode = osg.Geode()
    lightgeode.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF)
    lightgeode.addDrawable(osg.ShapeDrawable(osg.Sphere(lightPosition,radius)))
    
    lightgroup.addChild(lightgeode)
    
    return lightgroup