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

class UpdateCameraAndTexGenCallback(osg.NodeCallback):
	def __init__(self, position, cameraNode, texgenNode):
		osg.NodeCallback.__init__(self)
		self._position = position
		self._cameraNode = cameraNode
		self._texgenNode = texgenNode

	def apply(self,node,nv):

	# first update subgraph to make sure objects are all moved into postion
		self.traverse(node,nv)
		
		# now compute the camera's view and projection matrix to point at the shadower (the camera's children)
		bs = osg.BoundingSphere()
		for i in range(self._cameraNode.getNumChildren()):
			bs.expandBy(self._cameraNode.getChild(i).getBound())
		
		if (not bs):
			print osg.notify(osg.WARN) + "bb invalid" + self._cameraNode
			return
	
		centerDistance = (self._position-bs.center()).length()
	
		znear = centerDistance-bs.radius()
		zfar  = centerDistance+bs.radius()
		zNearRatio = 0.001
		if (znear<zfar*zNearRatio):
			 znear = zfar*zNearRatio
	
		top   = (bs.radius()/centerDistance)*znear
		right = top
	
		self._cameraNode.setReferenceFrame(osg.CameraNode.ABSOLUTE_RF)
		self._cameraNode.setProjectionMatrixAsFrustum(-right,right,-top,top,znear,zfar)
		self._cameraNode.setViewMatrixAsLookAt(self._position,bs.center(),osg.Vec3(0.0,1.0,0.0))
	
		# compute the matrix which takes a vertex from local coords into tex coords
		# will use this later to specify osg.TexGen..
		MVPT = self._cameraNode.getViewMatrix() * \
				self._cameraNode.getProjectionMatrix() * \
				osg.Matrix.translate(1.0,1.0,1.0) * \
				osg.Matrix.scale(0.5,0.5,0.5)
				
		self._texgenNode.getTexGen().setMode(osg.TexGen.EYE_LINEAR)
		self._texgenNode.getTexGen().setPlanesFromMatrix(MVPT)



def createShadowedScene(shadower,shadowed,lightPosition,radius,unit):

	group = osg.Group()

# add light source

	lightSource = osg.LightSource()
	lightSource.getLight().setPosition(osg.Vec4(lightPosition,1.0))
	lightSource.getLight().setLightNum(0)

	group.addChild(lightSource)

	lightgeode = osg.Geode()
	lightgeode.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF)
	lightgeode.addDrawable(osg.ShapeDrawable(osg.Sphere(lightPosition,radius)))
	group.addChild(lightgeode)

	ambientLightColor = osg.Vec4(0.2,0.2,0.2,1.0)
	
	# add the shadower and shadowed.
	group.addChild(shadower)
	group.addChild(shadowed)
	
		
	tex_width = 512
	tex_height = 512
	
	texture = osg.Texture2D()
	texture.setTextureSize(tex_width, tex_height)
	texture.setInternalFormat(GL_RGB)
	texture.setFilter(osg.Texture2D.MIN_FILTER,osg.Texture2D.LINEAR)
	texture.setFilter(osg.Texture2D.MAG_FILTER,osg.Texture2D.LINEAR)
	texture.setWrap(osg.Texture2D.WRAP_S,osg.Texture2D.CLAMP_TO_BORDER)
	texture.setWrap(osg.Texture2D.WRAP_T,osg.Texture2D.CLAMP_TO_BORDER)
	texture.setBorderColor(osg.Vec4(1.0,1.0,1.0,1.0))
	
# set up the render to texture camera.

	# create the camera
	camera = osg.CameraNode()

	camera.setClearColor(osg.Vec4(1.0,1.0,1.0,1.0))

	# set viewport
	camera.setViewport(0,0,tex_width,tex_height)

	# set the camera to render before the main camera.
	camera.setRenderOrder(osg.CameraNode.PRE_RENDER)

	# tell the camera to use OpenGL frame buffer object where supported.
	camera.setRenderTargetImplementation(osg.CameraNode.FRAME_BUFFER_OBJECT)

	# attach the texture and use it as the color buffer.
	camera.attach(osg.CameraNode.COLOR_BUFFER, texture, 0, 0, False)

	# add subgraph to render
	camera.addChild(shadower)
	
	stateset = camera.getOrCreateStateSet()

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

	group.addChild(camera)
	
	# create the texgen node to project the tex coords onto the subgraph
	texgenNode = osg.TexGenNode()
	texgenNode.setTextureUnit(unit)
	group.addChild(texgenNode)

	# set an update callback to keep moving the camera and tex gen in the right direction.
	group.setUpdateCallback(UpdateCameraAndTexGenCallback(lightPosition, camera, texgenNode))


# set the shadowed subgraph so that it uses the texture and tex gen settings.

	stateset = shadowed.getOrCreateStateSet()
	stateset.setTextureAttributeAndModes(unit,texture,osg.StateAttribute.ON)
	stateset.setTextureMode(unit,GL_TEXTURE_GEN_S,osg.StateAttribute.ON)
	stateset.setTextureMode(unit,GL_TEXTURE_GEN_T,osg.StateAttribute.ON)
	stateset.setTextureMode(unit,GL_TEXTURE_GEN_R,osg.StateAttribute.ON)
	stateset.setTextureMode(unit,GL_TEXTURE_GEN_Q,osg.StateAttribute.ON)



# set hud to render shadow texture, just for interest

	geode = osg.Geode()
	geom = osg.createTexturedQuadGeometry(osg.Vec3(0,0,0),osg.Vec3(100.0,0.0,0.0),osg.Vec3(0.0,100.0,0.0),1.0,1.0)
	geom.getOrCreateStateSet().setTextureAttributeAndModes(0,texture,osg.StateAttribute.ON)
	geom.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF)
	geode.addDrawable(geom)
	
	camera = osg.CameraNode()

	# set the projection matrix
	camera.setProjectionMatrix(osg.Matrix.ortho2D(0,100,0,100))

	# set the view matrix
	camera.setReferenceFrame(osg.Transform.ABSOLUTE_RF)
	camera.setViewMatrix(osg.Matrix.identity())
	
	camera.setViewport(50,50,100,100)

	# only clear the depth buffer
	camera.setClearMask(GL_DEPTH_BUFFER_BIT)

	# draw subgraph after main camera view.
	camera.setRenderOrder(osg.CameraNode.POST_RENDER)

	camera.addChild(geode)
	
	group.addChild(camera)
	
	return group