panda3d/doc/SceneEditor/seFileSaver.py

####################################################################################################################################################    
# File Saving 
# This code saves the scene out as python code... the scene is stored in the various dictionaries in "dataHolder.py" ...the class "AllScene"
# 
####################################################################################################################################################
from PandaModules import *

from ShowBaseGlobal import *
import os
import shutil
from EggData import *
import string

####################################################################################################################################################
#### These modules are modified versions of Disney's equivalent modules
#### We need to figure out a way to inherit their modules and overwrite what we need changed
import seParticlePanel
import seParticles
import seParticleEffect
import seForceGroup
####################################################################################################################################################

class FileSaver:

    ####################################################################################################################################################    
    # This class saves out the scene built with the scene editor as python code
    # There are dictionaries saved out to save the state of the scene for reloading it with the editor
    # Currently saving is supported for Models, Animations, Lights, Dummy Nodes
    # Attributes like parenting are also saved out
    # This class is actually instantiated in sceneEditor.py in the saveScene() method 
    ####################################################################################################################################################

    def __init(self):
	pass

    def SaveFile(self,AllScene,filename,dirname,reSaveFlag=0):

        ################################################################################################################################################	
	# This function takes the "dataHolder" instance "AllScene" which has dictionaries containing scene information
	# The filename is where the scene will be written to
	################################################################################################################################################
	
	i1="    " # indentation
	i2=i1+i1  # double indentation
	out_file = open(filename,"w")
	print "dirname:" + dirname
	if( not os.path.isdir(dirname)):
	    os.mkdir(dirname)
	savepathname=Filename(filename)
	self.savepath=savepathname.getBasenameWoExtension()
	out_file.write("##########################################################################################################\n")
	out_file.write("# Auto Generated Code by Scene Editor\n")
	out_file.write("# Edit with caution\n")
	out_file.write("# Using this file in your code:\n")
	out_file.write("# For example, if you have named this file as \"myscene.py\"\n")
	out_file.write("# Do the following:\n")
	out_file.write("# from myscene import * \n")
	out_file.write("# theScene=SavedScene() #instantiate the class\n")
	out_file.write("# IMPORTANT: All the documentation below refers to \"theScene\" as the instance of SavedScene()\n")
	out_file.write("##########################################################################################################\n\n")
	
	out_file.write("##########################################################################################################\n")
	out_file.write("# Import Panda Modules\n")
	out_file.write("##########################################################################################################\n")
	out_file.write("from ShowBaseGlobal import * # Core functionality for running the \"show\"\n")
	out_file.write("import Actor # Importing models with animations\n")
	out_file.write("import Mopath # Motion Paths\n")
	out_file.write("import MopathInterval # Motion Paths\n")
	out_file.write("from IntervalGlobal import * # Intervals for interpolation, sequencing and parallelization\n")
	out_file.write("import ParticleEffect # Particle Systems\n")
	out_file.write("import ForceGroup # Forces acting on Particles\n")
	out_file.write("import Particles\n\n")
	out_file.write("##########################################################################################################\n")
	out_file.write("# This class stores the entire scene\n")
	out_file.write("##########################################################################################################\n\n")
	out_file.write("class SavedScene(DirectObject): # We inherit from DirectObject so that we can use self.accept method to catch messages\n")
        out_file.write("\n")
	out_file.write(i1+"# These dictionaries are required for re-loading a scene in the editor\n")
	out_file.write(i1+"# They can be used to access the objects as well\n\n")
	out_file.write(i1+"ModelDic={}# Stores all the models and static geometry\n")
	out_file.write(i1+"ModelRefDic={}# Stores the paths to the models\n")
        out_file.write("\n")
	out_file.write(i1+"ActorDic={}# Stores all the actors\n")
	out_file.write(i1+"ActorRefDic={}# Stores the paths to the actors\n")
	out_file.write(i1+"ActorAnimsDic={}# Stores the animations for each actor\n")
	out_file.write(i1+"blendAnimDict={}# Stores all the blended animations\n")
        out_file.write("\n")
	out_file.write(i1+"LightDict={}# Stores all the lights\n")
	out_file.write(i1+"LightTypes={}# Stores types for the lights\n")
	out_file.write(i1+"LightNodes={}# Stores the actual nodes for the lights\n")
        out_file.write("\n")
	out_file.write(i1+"dummyDict={}# Stores dummies\n")
        out_file.write("\n")
	out_file.write(i1+"collisionDict={}# Stores Collision information\n")
        out_file.write("\n")
	out_file.write(i1+"curveDict={}# Stores Mopath information\n")
	out_file.write(i1+"curveIntervals=[]# Stores list of mopath intervals\n")
	out_file.write(i1+"curveRefColl=[]# Stores paths to mopaths\n")
	out_file.write(i1+"curveIntervalsDict={}# Stores mopath intervals\n")
        out_file.write("\n")
	out_file.write(i1+"particleDict={}# Stores particles\n")
	out_file.write(i1+"particleNodes={}# Stores particle nodes\n")
        out_file.write("\n")
        out_file.write(i1+"#Light Count\n")
	out_file.write(i1+"ambientCount=0\n")
	out_file.write(i1+"directionalCount=0\n")
	out_file.write(i1+"pointCount=0\n")
	out_file.write(i1+"spotCount=0\n")
        out_file.write("\n")
	out_file.write(i1+"#Lighting Attribute\n")
	out_file.write(i1+"lightAttrib = LightAttrib.makeAllOff()# Initialize lighting\n")
        out_file.write("\n")
	out_file.write(i1+"CollisionHandler=CollisionHandlerEvent()# Setup a Collision Handler\n")

      	out_file.write(i1+"##########################################################################################################\n")
	out_file.write(i1+"# Constructor: this is run first when you instantiate the SavedScene class\n")
	out_file.write(i1+"##########################################################################################################\n")
	out_file.write(i1+"def __init__(self,loadmode=1,seParticleEffect=None,seParticles=None,executionpath=None):# loadmode 0 specifies that this file is being loaded by the scene editor and it passes its own versions of the particle fx modules\n")
	out_file.write("\n")
	out_file.write(i2+"self.loadmode=loadmode\n")
	out_file.write(i2+"self.seParticleEffect=seParticleEffect\n")
	out_file.write(i2+"self.seParticles=seParticles\n")
	out_file.write(i2+"self.executionpath=executionpath\n")
        out_file.write("\n")
	out_file.write(i2+"base.enableParticles()# Enable Particle effects\n")
        out_file.write("\n")
	out_file.write(i2+"self.cTrav = CollisionTraverser() # Setup a traverser for collisions\n")
	out_file.write(i2+"base.cTrav = self.cTrav\n")
	out_file.write(i2+"self.CollisionHandler.setInPattern(\"enter%in\")# The message to be raised when something enters a collision node\n")
	out_file.write(i2+"self.CollisionHandler.setOutPattern(\"exit%in\")# The message to be raised when something exits a collision node\n")
        out_file.write("\n")
	####################################################################################################################################################
	# Save Models
	####################################################################################################################################################

      	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Code for all the models\n")
	out_file.write(i2+"# To access these models:\n")
	out_file.write(i2+"# theScene.ModelDic[\"'Model_Name\"']\n")
	out_file.write(i2+"# where theScene is the SavedScene class instance\n")
	out_file.write(i2+"# Properties saved include:\n")
	out_file.write(i2+"# Transformations\n")
	out_file.write(i2+"# Alpha and color\n")
	out_file.write(i2+"# Parent and child information\n")
      	out_file.write(i2+"##########################################################################################################\n")

	for model in AllScene.ModelDic:
            out_file.write("\n")
	    modelS=str(model)
	    
	    if(1): # This is kept for now... perhaps later some sort of check might have to be enforced based on loadMode
                #Loading Code
		out_file.write(i2+"# Loading model's egg file\n")
	        #out_file.write(i2+ "self."+ modelS + "=loader.loadModel(\'" + AllScene.ModelRefDic[model].getFullpath() + "\')\n")#Absolute Paths

		newpath = dirname + "/" + AllScene.ModelRefDic[model].getBasename()
		newpathF=Filename(newpath)
		newpathSpecific=newpathF.toOsSpecific()

		# Copy all the textures referenced by this file over to the relative directory
		fnamelist=[]
	        modelData=EggData()
	        modelData.read(AllScene.ModelRefDic[model])
	 	textures=EggTextureCollection()
		textures.findUsedTextures(modelData)
		for index in range(textures.getNumTextures()):
		    texture=textures.getTexture(index)
		    texfilename=texture.getFilename()
	   	    fnamelist.append(texfilename.getFullpath())   
		    oldFilename=Filename(Filename(AllScene.ModelRefDic[model].getDirname()),texfilename)
		    if(not oldFilename.isRegularFile()):
			if(texfilename.resolveFilename(getTexturePath(),"")):
			    oldFilename=texfilename
		    oldtexpath=oldFilename.toOsSpecific();
		
		    newtexpath=dirname + "/" + texfilename.getBasename()
		    newtexpathF=Filename(newtexpath)
	            newtexpathSpecific=newtexpathF.toOsSpecific()
		    
		    print "TEXTURE SAVER:: copying" + oldtexpath + " to " + newtexpathSpecific
		    if(oldtexpath != newtexpathSpecific):
		        shutil.copyfile(oldtexpath,newtexpathSpecific)

		    
		
		    

		
		# Copy the file over to the relative directory
		oldModelpath=AllScene.ModelRefDic[model].toOsSpecific()
		print "FILESAVER:: copying from " + AllScene.ModelRefDic[model].toOsSpecific() + "to" + newpathSpecific 
		if(oldModelpath!=newpathSpecific):
		    shutil.copyfile(oldModelpath,newpathSpecific)

		
		e=EggData()
		e.read(AllScene.ModelRefDic[model])
		etc=EggTextureCollection()
		etc.extractTextures(e)
		for index in range(len(fnamelist)):
		    print fnamelist[index]
		    tex=etc.findFilename(Filename(fnamelist[index]))
		    fn=Filename(tex.getFilename())
		    fn.setDirname("")
		    tex.setFilename(fn)
		    e.writeEgg(Filename.fromOsSpecific(newpathSpecific))
		


		out_file.write(i2+"if(self.loadmode==1):\n")	
	        out_file.write(i2+i1+ "self."+ modelS + "=loader.loadModel(\'" + self.savepath + "/" +  AllScene.ModelRefDic[model].getBasename() + "')\n")#Relative Path
		out_file.write(i2+"else:\n")
		out_file.write(i2+i1+ "self."+ modelS + "=loader.loadModel(self.executionpath + \'/" +  AllScene.ModelRefDic[model].getBasename() + "')\n")#Relative Path with execution point specified by the invoking-level-editor

		#Transformation Code
                out_file.write("\n")
		out_file.write(i2+"# Transforming the model\n")
		out_file.write(i2+ "self."+ modelS + ".setPosHprScale(%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f)\n"% (AllScene.ModelDic[model].getX(),AllScene.ModelDic[model].getY(),AllScene.ModelDic[model].getZ(),AllScene.ModelDic[model].getH(),AllScene.ModelDic[model].getP(),AllScene.ModelDic[model].getR(),AllScene.ModelDic[model].getSx(),AllScene.ModelDic[model].getSy(),AllScene.ModelDic[model].getSz()))

	        if(AllScene.ModelDic[model].hasTransparency()):
                    out_file.write("\n")
 		    out_file.write(i2+"# Alpha\n")
		    out_file.write(i2+ "self."+ modelS + ".setTransparency(1)\n")
	            clr=AllScene.ModelDic[model].getColor()
		    out_file.write(i2+ "self."+ modelS + ".setColor(%.4f,%.4f,%.4f,%.4f)\n"%(clr.getX(),clr.getY(),clr.getZ(),clr.getW()))		    

                out_file.write("\n")
	        out_file.write(i2+ "# Reparent To Render for now and later we update all the parentings\n")
	        out_file.write(i2+ "self."+ modelS + ".reparentTo(render)\n")
                out_file.write("\n")
		out_file.write(i2+ "# Save Metadata...can be retrieved by doing theScene.ModelDic[\"Model_Name\"].getTag(\"Metadata\")\n")
	        out_file.write(i2+ "self."+ modelS + ".setTag(\"Metadata\",\"" + AllScene.ModelDic[model].getTag("Metadata") + "\")\n")
                out_file.write("\n")
		out_file.write(i2+ "# Fill in the dictionaries which are used by level Ed to reload state\n")
                out_file.write(i2+ "self.ModelDic[\'" + modelS + "\']=self." + AllScene.ModelDic[model].getName()+"\n")
                #out_file.write(i2+ "self.ModelRefDic[\'" + modelS + "\']=Filename(\'"+ AllScene.ModelRefDic[model].getFullpath() +"\')\n")# The old Absolute Path way
		out_file.write(i2+ "self.ModelRefDic[\'" + modelS + "\']=\'"+ AllScene.ModelRefDic[model].getBasename() +"\'\n")# Relative paths
		out_file.write(i2+ "self.ModelDic[\'"+ modelS + "\'].setName(\'"+ modelS +"\')\n")		
                out_file.write("\n")

	####################################################################################################################################################
	# Save Dummies
	####################################################################################################################################################
	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Code for all the Dummy Objects\n")
	out_file.write(i2+"# To access the dummies\n")
	out_file.write(i2+"# theScene.dummyDict['Dummy_Name']\n")
	out_file.write(i2+"##########################################################################################################\n")
        for dummy in AllScene.dummyDict:
            out_file.write("\n")
	    dummyS=str(dummy)
	    
            if(1): # This is kept for now... perhaps later some sort of check might have to be enforced based on loadMode
	        out_file.write(i2+ "self."+ dummyS + "=loader.loadModelCopy(\"misc/sphere\")\n")
		#Transformation Code
		out_file.write(i2+"# Transforming the Dummy\n")
	        out_file.write(i2+ "self."+ dummyS + ".setPosHprScale(%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f)\n"% (AllScene.dummyDict[dummy].getX(),AllScene.dummyDict[dummy].getY(),AllScene.dummyDict[dummy].getZ(),AllScene.dummyDict[dummy].getH(),AllScene.dummyDict[dummy].getP(),AllScene.dummyDict[dummy].getR(),AllScene.dummyDict[dummy].getSx(),AllScene.dummyDict[dummy].getSy(),AllScene.dummyDict[dummy].getSz()))
                out_file.write("\n")
	        out_file.write(i2+ "# Fill in the dictionaries which are used by level Ed to reload state\n")
		out_file.write(i2+ "self.dummyDict[\'" + dummyS + "\']=self." + AllScene.dummyDict[dummy].getName()+"\n")
                out_file.write(i2+ "self.dummyDict[\'"+ dummyS + "\'].setName(\'"+ dummyS +"\')\n")
		out_file.write("\n")
		out_file.write(i2+ "# Save Metadata...can be retrieved by doing theScene.dummyDict[\"Dummy_Name\"].getTag(\"Metadata\")\n")		
	        out_file.write(i2+ "self."+ dummyS + ".setTag(\"Metadata\",\"" + AllScene.dummyDict[dummy].getTag("Metadata") + "\")\n")
                out_file.write("\n")

	####################################################################################################################################################
	# Saving Actors and their animations
	####################################################################################################################################################			
	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Code for all the Actors and animations\n")
	out_file.write(i2+"# To access the Actors\n")
	out_file.write(i2+"# theScene.ActorDic[\'Actor_Name\']\n")
	out_file.write(i2+"# theScene.ActorDic[\'Actor_Name\'].play(\'Animation_Name\')\n")
	out_file.write(i2+"##########################################################################################################\n")
	for actor in AllScene.ActorDic:
	    out_file.write("\n")
	    actorS=str(actor)
            
	    if(1): # This is kept for now... perhaps later some sort of check might have to be enforced based on loadMode
	        #out_file.write(i2+ "self."+ actorS + "=Actor.Actor(\'"+ AllScene.ActorRefDic[actor].getFullpath() + "\')\n")# The old way with absolute paths


		newpath = dirname + "/" + AllScene.ActorRefDic[actor].getBasename()
		newpathF=Filename(newpath)
		newpathSpecific=newpathF.toOsSpecific()

		# Copy all the textures referenced by this file over to the relative directory
		actorfnamelist=[]
	        actorData=EggData()
	        actorData.read(AllScene.ActorRefDic[actor])
	 	textures=EggTextureCollection()
		textures.findUsedTextures(actorData)
		for index in range(textures.getNumTextures()):
		    texture=textures.getTexture(index)
		    texfilename=texture.getFilename()
		    actorfnamelist.append(texfilename.getFullpath()) 

		    oldFilename=Filename(Filename(AllScene.ActorRefDic[actor].getDirname()),texfilename)
		    if(not oldFilename.isRegularFile()):
			if(texfilename.resolveFilename(getTexturePath(),"")):
			    oldFilename=texfilename
		    oldtexpath=oldFilename.toOsSpecific();


		    newtexpath=dirname + "/" + texfilename.getBasename()
		    newtexpathF=Filename(newtexpath)
	            newtexpathSpecific=newtexpathF.toOsSpecific()
		    print "TEXTURE SAVER:: copying" + oldtexpath + " to " + newtexpathSpecific
		    if(oldtexpath != newtexpathSpecific):
		        shutil.copyfile(oldtexpath,newtexpathSpecific)


		# Copy the file over to the relative directory
		oldActorpath=AllScene.ActorRefDic[actor].toOsSpecific()
		print "FILESAVER:: copying from " + AllScene.ActorRefDic[actor].toOsSpecific() + "to" + newpathSpecific 
		if(oldActorpath!=newpathSpecific):
		    shutil.copyfile(oldActorpath,newpathSpecific)
		

		e=EggData()
		e.read(AllScene.ActorRefDic[actor])
		etc=EggTextureCollection()
		etc.extractTextures(e)
		for index in range(len(actorfnamelist)):
		    print actorfnamelist[index]
		    tex=etc.findFilename(Filename(actorfnamelist[index]))
		    fn=Filename(tex.getFilename())
		    fn.setDirname("")
		    tex.setFilename(fn)
		    e.writeEgg(Filename.fromOsSpecific(newpathSpecific))
		


		out_file.write(i2+"if(self.loadmode==1):\n")	
	        out_file.write(i2+i1+ "self."+ actorS + "=Actor.Actor(\'" + self.savepath + "/" +  AllScene.ActorRefDic[actor].getBasename() + "')\n")#Relative Path
		out_file.write(i2+"else:\n")
		out_file.write(i2+i1+ "self."+ actorS + "=Actor.Actor(self.executionpath + \'/" +  AllScene.ActorRefDic[actor].getBasename() + "')\n")#Relative Path with execution point specified by the invoking-level-editor

		#Transformation Code
		out_file.write(i2+"# Transforming the Actor\n")
	        out_file.write(i2+ "self."+ actorS + ".setPosHprScale(%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f)\n"% (AllScene.ActorDic[actor].getX(),AllScene.ActorDic[actor].getY(),AllScene.ActorDic[actor].getZ(),AllScene.ActorDic[actor].getH(),AllScene.ActorDic[actor].getP(),AllScene.ActorDic[actor].getR(),AllScene.ActorDic[actor].getSx(),AllScene.ActorDic[actor].getSy(),AllScene.ActorDic[actor].getSz()))

	        if(AllScene.ActorDic[actor].hasTransparency()):
 		    out_file.write(i2+"# Alpha\n")
		    out_file.write(i2+ "self."+ actorS + ".setTransparency(1)\n")
	            clr=AllScene.ActorDic[actor].getColor()
		    out_file.write(i2+ "self."+ actorS + ".setColor(%.4f,%.4f,%.4f,%.4f)\n"%(clr.getX(),clr.getY(),clr.getZ(),clr.getW()))

	        out_file.write(i2+ "self."+ actorS + ".reparentTo(render)\n")
                
		out_file.write("\n")
		out_file.write(i2+ "# Save Metadata...can be retrieved by doing theScene.ActorDic[\"Actor_Name\"].getTag(\"Metadata\")\n")
	        out_file.write(i2+ "self."+ actorS + ".setTag(\"Metadata\",\"" + AllScene.ActorDic[actor].getTag("Metadata") + "\")\n")

		out_file.write("\n")
	        out_file.write(i2+ "# Fill in the dictionaries which are used by level Ed to reload state\n")
	        ActorAnimations=AllScene.getAnimationDictFromActor(actor)
		ActorAnimationsInvoke={}

		if(ActorAnimations!={}):  #Check if a dictionary of animations exists for this actor
		    for animation in ActorAnimations:
	            	#out_file.write(i2+ "self."+ actorS + ".loadAnims(" + str(ActorAnimations) +")\n") # Old way with absolute paths
			print "ACTOR ANIMATIONS" + ActorAnimations[animation]	
			oldAnimPath=Filename(ActorAnimations[animation])
			oldAnim=oldAnimPath.toOsSpecific()
			dirOS=Filename(dirname)
			newAnim=dirOS.toOsSpecific() + "\\" + oldAnimPath.getBasename()
			print "ACTOR ANIM SAVER:: Comparing" + oldAnim +"and" + newAnim
			if(oldAnim!=newAnim):
			    shutil.copyfile(oldAnim,newAnim)
			newAnimF=Filename.fromOsSpecific(newAnim)
			ActorAnimationsInvoke[animation]="self.executionpath +" + "/" +newAnimF.getBasename()
			ActorAnimations[animation]= self.savepath + "/" + newAnimF.getBasename()


		out_file.write(i2+"if(self.loadmode==1):\n")
		out_file.write(i2+ i1+"self."+ actorS + ".loadAnims(" + str(ActorAnimations) +")\n") # Now with new relative paths
		out_file.write(i2+"else:\n")
		theloadAnimString=str(ActorAnimationsInvoke)# We hack the "self.executionpath" part into the dictionary as a variable using string replace
		print "LOAD ANIM STRING BEFORE" + theloadAnimString
		theloadAnimString=theloadAnimString.replace('\'self.executionpath +','self.executionpath + \'')		
	 	print "LOAD ANIM STRING AFTER" + theloadAnimString
		out_file.write(i2+ i1+"self."+ actorS + ".loadAnims(" + theloadAnimString +")\n") # Now with new relative paths based on editor invocation

                out_file.write(i2+ "self.ActorDic[\'" + actorS + "\']=self." + AllScene.ActorDic[actor].getName()+"\n")
		#out_file.write(i2+ "self.ActorRefDic[\'" + actorS + "\']=Filename(\'"+AllScene.ActorRefDic[actor].getFullpath() +"\')\n") # Old way with absolute paths
		out_file.write(i2+ "self.ActorRefDic[\'" + actorS + "\']=\'"+ AllScene.ActorRefDic[actor].getBasename() +"\'\n")# Relative paths
		out_file.write(i2+ "self.ActorDic[\'"+ actorS + "\'].setName(\'"+ actorS +"\')\n")		
		if(AllScene.blendAnimDict.has_key(actor)): # Check if a dictionary of blended animations exists
	 	    out_file.write(i2+ "self.blendAnimDict[\"" + actorS +"\"]=" + str(AllScene.blendAnimDict[actor]) + "\n")
		
		
	        out_file.write("\n")
	
	####################################################################################################################################################
	# Collsion Node Saving
	####################################################################################################################################################
	
	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Code for setting up Collision Nodes\n")
	out_file.write(i2+"# To use collision detection:\n")
	out_file.write(i2+"# You must set up your own bitmasking and event handlers, the traverser \"cTrav\" is created for you at the top\n")
	out_file.write(i2+"# The collision nodes are stored in collisionDict\n")
	out_file.write(i2+"##########################################################################################################\n\n")
	for collnode in AllScene.collisionDict:
	    collnodeS=str(collnode)
	    solid=AllScene.collisionDict[collnode].node().getSolid(0)
            nodetype=solid.getType().getName()

	    if(nodetype=="CollisionSphere"): #Save Collison Sphere
		out_file.write(i2+"collSolid=CollisionSphere(%.3f,%.3f,%.3f,%.3f)\n"%(solid.getCenter().getX(),solid.getCenter().getY(),solid.getCenter().getZ(),solid.getRadius()))		
		pass
	    elif(nodetype=="CollisionPolygon"): #Save Collison Polygon

		ax=AllScene.collisionDict[collnode].getTag("A_X")
		ay=AllScene.collisionDict[collnode].getTag("A_Y")
		az=AllScene.collisionDict[collnode].getTag("A_Z")

		bx=AllScene.collisionDict[collnode].getTag("B_X")
		by=AllScene.collisionDict[collnode].getTag("B_Y")
		bz=AllScene.collisionDict[collnode].getTag("B_Z")

		cx=AllScene.collisionDict[collnode].getTag("C_X")
		cy=AllScene.collisionDict[collnode].getTag("C_Y")
		cz=AllScene.collisionDict[collnode].getTag("C_Z")

		out_file.write(i2+"pointA =  Point3(" + ax + "," + ay + "," + az + ")\n")
		out_file.write(i2+"pointB =  Point3(" + bx + "," + by + "," + bz + ")\n")
		out_file.write(i2+"pointC =  Point3(" + cx + "," + cy + "," + cz + ")\n")
                out_file.write(i2+"collSolid=CollisionPolygon(pointA, pointB, pointC)\n")
		
		pass

	    elif(nodetype=="CollisionSegment"): #Save Collison Segment
		A=AllScene.collisionDict[collnode].node().getSolid(0).getPointA()
		B=AllScene.collisionDict[collnode].node().getSolid(0).getPointB()
		
		out_file.write(i2+"pointA =  Point3(%.3f,%.3f,%.3f)\n"%(A.getX(),A.getY(),A.getZ()))
		out_file.write(i2+"pointB =  Point3(%.3f,%.3f,%.3f)\n"%(B.getX(),B.getY(),B.getZ()))
		out_file.write(i2+"collSolid=CollisionSegment()\n")
		out_file.write(i2+"collSolid.setPointA(pointA)\n")
		out_file.write(i2+"collSolid.setFromLens(base.cam.node(),Point2(-1,1))\n")
		out_file.write(i2+"collSolid.setPointB(pointB)\n")

		pass

	    elif(nodetype=="CollisionRay"): #Save Collison Ray
		P =  AllScene.collisionDict[collnode].node().getSolid(0).getOrigin()
                V =  AllScene.collisionDict[collnode].node().getSolid(0).getDirection()

		out_file.write(i2+"point=Point3(%.3f,%.3f,%.3f)\n"%(P.getX(),P.getY(),P.getZ()))
		out_file.write(i2+"vector=Vec3(%.3f,%.3f,%.3f)\n"%(V.getX(),V.getY(),V.getZ()))
		out_file.write(i2+"collSolid=CollisionRay()\n")
		out_file.write(i2+"collSolid.setOrigin(point)\n")
		out_file.write(i2+"collSolid.setDirection(vector)\n")
            
		pass
	    else:
	         print "Invalid Collision Node: " + nodetype
       	    out_file.write("\n")


	    out_file.write(i2+"self." + collnodeS + "_Node" + "=CollisionNode(\""+collnodeS+"\")\n")
	    out_file.write(i2+"self." + collnodeS + "_Node" + ".addSolid(collSolid)\n")
	    out_file.write(i2+"base.cTrav.addCollider(self." + collnodeS + "_Node,self.CollisionHandler)\n")
	    out_file.write("\n")
	   



	####################################################################################################################################################
	# Light Saving
	####################################################################################################################################################
	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Code for Lighting\n")
	out_file.write(i2+"# To manipulated lights:\n")
	out_file.write(i2+"# Manipulate the light node in theScene.LightNodes[\'Light_Name\']\n")
	out_file.write(i2+"##########################################################################################################\n\n")

	LightList=AllScene.lightManager.getLightNodeList()
	for light in LightList:
                 type = light.getType()
	         if type == 'ambient':
		     out_file.write(i2+"# Ambient Light\n")
            	     out_file.write (i2+ "self.ambientCount += 1\n")
		     out_file.write (i2+ "alight = AmbientLight(\'"+ light.getName() +"\')\n")
           	     out_file.write (i2+ "alight.setColor(VBase4("+ str(light.getLightColor().getX())+ "," + str(light.getLightColor().getY())+ "," + str(light.getLightColor().getZ()) + "," + str(light.getLightColor().getW()) + "))\n")
		     out_file.write (i2+ "self.lightAttrib=self.lightAttrib.addLight(alight)\n")
  	     	     out_file.write (i2+ "self."+light.getName()+"= render.attachNewNode(alight.upcastToPandaNode())\n") 
 		     out_file.write (i2+ "self."+light.getName()+".setTag(\"Metadata\",\"" + light.getTag("Metadata") + "\")\n")	
		     out_file.write (i2+ "self.LightDict[\'" + light.getName() + "\']=alight\n")
   		     out_file.write (i2+ "self.LightTypes[\'" + light.getName() + "\']=\'" + type + "\'\n")
   		     out_file.write (i2+ "self.LightNodes[\'" + light.getName() + "\']=self." + light.getName() + "\n")
		     out_file.write ("\n")
	         elif type == 'directional':
		     out_file.write(i2+"# Directional Light\n")
         	     out_file.write (i2+ "self.directionalCount += 1\n")
	             out_file.write (i2+ "alight = DirectionalLight(\'"+ light.getName() + "\')\n")
           	     out_file.write (i2+ "alight.setColor(VBase4("+ str(light.getLightColor().getX())+ "," + str(light.getLightColor().getY())+ "," + str(light.getLightColor().getZ()) + "," + str(light.getLightColor().getW()) + "))\n")
	             #out_file.write (i2+ "alight.setDirection(Vec3("+ str(light.getH())+ "," + str(light.getP())+ "," + str(light.getR()) + "))\n")
	             #out_file.write (i2+ "alight.setPoint(Point3(" + str(light.getX()) + "," + str(light.getY()) + "," + str(light.getZ()) + "))\n")
 	             out_file.write (i2+ "alight.setSpecularColor(Vec4(" + str(light.getSpecColor().getX()) + "," + str(light.getSpecColor().getY()) + "," + str(light.getSpecColor().getZ()) + "," + str(light.getSpecColor().getW()) + "))\n")
		     out_file.write (i2+ "self.lightAttrib=self.lightAttrib.addLight(alight)\n")
  	     	     out_file.write (i2+ "self."+light.getName()+ "= render.attachNewNode(alight.upcastToPandaNode())\n") 
		     out_file.write (i2+ "self."+light.getName()+ ".setPos(Point3(" + str(light.getX()) + "," + str(light.getY()) + "," + str(light.getZ()) + "))\n")
		     out_file.write (i2+ "self."+light.getName()+ ".setHpr(Vec3("+ str(light.getH())+ "," + str(light.getP())+ "," + str(light.getR()) + "))\n")
 		     out_file.write (i2+ "self."+light.getName()+ ".setTag(\"Metadata\",\"" + light.getTag("Metadata") + "\")\n")	
		     #out_file.write (i2+ "alight.setPos
		     out_file.write (i2+ "self.LightDict[\'" + light.getName() + "\']=alight\n")
   		     out_file.write (i2+ "self.LightTypes[\'" + light.getName() + "\']=\'" + type + "\'\n")
   		     out_file.write (i2+ "self.LightNodes[\'" + light.getName() + "\']=self." + light.getName()  + "\n")
		     out_file.write ("\n")
	         elif type == 'point':
		     out_file.write(i2+"# Point Light\n")
	             out_file.write (i2+ "self.pointCount += 1\n")
	             out_file.write (i2+ "alight = PointLight(\'"+ light.getName() +"\')\n")
           	     out_file.write (i2+ "alight.setColor(VBase4("+ str(light.getLightColor().getX())+ "," + str(light.getLightColor().getY())+ "," + str(light.getLightColor().getZ()) + "," + str(light.getLightColor().getW()) + "))\n")
	             #out_file.write (i2+ "alight.setPoint(Point3(" + str(light.getX()) + "," + str(light.getY()) + "," + str(light.getZ()) + "))\n")
 	             out_file.write (i2+ "alight.setSpecularColor(Vec4(" + str(light.getSpecColor().getX()) + "," + str(light.getSpecColor().getY()) + "," + str(light.getSpecColor().getZ()) + "," + str(light.getSpecColor().getW()) + "))\n")
	             out_file.write (i2+ "alight.setAttenuation(Vec3("+ str(light.getAttenuation().getX()) + "," + str(light.getAttenuation().getY()) + "," + str(light.getAttenuation().getZ()) + "))\n")
		     out_file.write (i2+ "self.lightAttrib=self.lightAttrib.addLight(alight)\n")
  	     	     out_file.write (i2+ "self."+light.getName()+ "= render.attachNewNode(alight.upcastToPandaNode())\n") 
 		     out_file.write (i2+ "self."+light.getName()+ ".setTag(\"Metadata\",\"" + light.getTag("Metadata") + "\")\n")	
		     out_file.write (i2+ "self."+light.getName()+ ".setPos(Point3(" + str(light.getX()) + "," + str(light.getY()) + "," + str(light.getZ()) + "))\n")
		     out_file.write (i2+ "self.LightDict[\'" + light.getName() + "\']=alight\n")
   		     out_file.write (i2+ "self.LightTypes[\'" + light.getName() + "\']=\'" + type + "\'\n")
   		     out_file.write (i2+ "self.LightNodes[\'" + light.getName() + "\']=self." + light.getName() +  "\n")
		     out_file.write ("\n")
	         elif type == 'spot':
		     out_file.write(i2+"# Spot Light\n")
         	     out_file.write (i2+ "self.spotCount += 1\n")
	             out_file.write (i2+ "alight = Spotlight(\'"+ light.getName() + "\')\n")
           	     out_file.write (i2+ "alight.setColor(VBase4("+ str(light.getLightColor().getX())+ "," + str(light.getLightColor().getY())+ "," + str(light.getLightColor().getZ()) + "," + str(light.getLightColor().getW()) + "))\n")
	             out_file.write (i2+ "alens = PerspectiveLens()\n")
	             out_file.write (i2+ "alight.setLens(alens)\n")
 	             out_file.write (i2+ "alight.setSpecularColor(Vec4(" + str(light.getSpecColor().getX()) + "," + str(light.getSpecColor().getY()) + "," + str(light.getSpecColor().getZ()) + "," + str(light.getSpecColor().getW()) + "))\n")
	             out_file.write (i2+ "alight.setAttenuation(Vec3("+ str(light.getAttenuation().getX()) + "," + str(light.getAttenuation().getY()) + "," + str(light.getAttenuation().getZ()) + "))\n")
	             out_file.write (i2+ "alight.setExponent(" +str(light.getExponent()) +")\n")
		     out_file.write (i2+ "self.lightAttrib=self.lightAttrib.addLight(alight)\n")
  	     	     out_file.write (i2+ "self."+light.getName()+ "= render.attachNewNode(alight.upcastToLensNode())\n") 
 		     out_file.write (i2+ "self."+light.getName()+ ".setTag(\"Metadata\",\"" + light.getTag("Metadata") + "\")\n")	
		     out_file.write (i2+ "self."+light.getName()+ ".setPos(Point3(" + str(light.getX()) + "," + str(light.getY()) + "," + str(light.getZ()) + "))\n")
		     out_file.write (i2+ "self."+light.getName()+ ".setHpr(Vec3("+ str(light.getH())+ "," + str(light.getP())+ "," + str(light.getR()) + "))\n")
		     out_file.write (i2+ "self.LightDict[\'" + light.getName() + "\']=alight\n")
   		     out_file.write (i2+ "self.LightTypes[\'" + light.getName() + "\']=\'" + type + "\'\n")
   		     out_file.write (i2+ "self.LightNodes[\'" + light.getName() + "\']=self." + light.getName() + "\n")
		     out_file.write ("\n")
	         else:
	             out_file.write (i2+ "print \'Invalid light type\'")
         	     out_file.write (i2+ "return None")
		 out_file.write("\n")

	

	####################################################################################################################################################
	# Enable Lighting
	####################################################################################################################################################

	out_file.write(i2+ "# Enable Ligthing\n")
	out_file.write(i2+ "render.node().setAttrib(self.lightAttrib)\n")
	out_file.write("\n")



	####################################################################################################################################################
	# Initialize Particles for non scene editor mode
	####################################################################################################################################################

        out_file.write(i2+"# Load Particle Effects. The parameters to this function are to allow us to use our modified versions of the Particle Effects modules when loading this file with the level editor\n")
	out_file.write(i2+"self.starteffects(self.loadmode,self.seParticleEffect,self.seParticles)\n")
	out_file.write("\n")
		
	####################################################################################################################################################
	# Save Camera Settings
	####################################################################################################################################################

	out_file.write("\n")
 	out_file.write(i2+ "# Save Camera Settings\n")
	out_file.write(i2+ "camera.setX(" + str(camera.getX()) + ")\n") 	
	out_file.write(i2+ "camera.setY(" + str(camera.getY()) + ")\n") 	
	out_file.write(i2+ "camera.setZ(" + str(camera.getZ()) + ")\n") 	
	out_file.write(i2+ "camera.setH(" + str(camera.getH()) + ")\n") 	
	out_file.write(i2+ "camera.setP(" + str(camera.getP()) + ")\n") 	
	out_file.write(i2+ "camera.setR(" + str(camera.getR()) + ")\n") 
	out_file.write(i2+ "camera.getChild(0).node().getLens().setNear(" + str(camera.getChild(0).node().getLens().getNear()) + ")\n") 
	out_file.write(i2+ "camera.getChild(0).node().getLens().setFar(" + str(camera.getChild(0).node().getLens().getFar()) + ")\n") 
	out_file.write(i2+ "camera.getChild(0).node().getLens().setFov(VBase2(%.5f,%.5f))\n"% (camera.getChild(0).node().getLens().getHfov(),camera.getChild(0).node().getLens().getVfov())) 
	FilmSize=camera.getChild(0).node().getLens().getFilmSize()
	out_file.write(i2+ "camera.getChild(0).node().getLens().setFilmSize(%.3f,%.3f)\n"%(FilmSize.getX(),FilmSize.getY())) 
	out_file.write(i2+ "camera.getChild(0).node().getLens().setFocalLength(" + str(camera.getChild(0).node().getLens().getFocalLength()) + ")\n") 
        out_file.write(i2+ "camera.setTag(\"Metadata\",\"" + camera.getTag("Metadata") + "\")\n")	
	out_file.write(i2+ "camera.reparentTo(render)\n")
	out_file.write(i2+ "base.disableMouse()\n")
	self.bgColor=base.getBackgroundColor()
	out_file.write(i2+ "base.setBackgroundColor(%.3f,%.3f,%.3f)\n"%(self.bgColor.getX(),self.bgColor.getY(),self.bgColor.getZ()))
	out_file.write("\n")
	

	####################################################################################################################################################
	# Mopath Saving
	####################################################################################################################################################

	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Motion Paths\n")
	out_file.write(i2+"# Using Mopaths:\n")
	out_file.write(i2+"# theScene.curveIntervals[0].start() or .loop() will play curve with index 0\n")
	out_file.write(i2+"##########################################################################################################\n\n")

	for node in AllScene.curveDict:
	    curveCollection=AllScene.curveDict[node]
	    curvenumber=0
	    for curve in curveCollection:
		filestring=dirname+ "\\" + str(node)+"_curve_"+str(curvenumber)+".egg"
		f=Filename.fromOsSpecific(filestring)
		#filestring=f.getFullpath()# The old absolute path way
		filestring=f.getBasename() # The new relative path way
	        curve.writeEgg(f)
		out_file.write(i2+"m=Mopath.Mopath()\n")

		out_file.write(i2+"if(self.loadmode==1):\n")
		out_file.write(i2+i1+"m.loadFile(\"" + self.savepath +"/"+ filestring + "\")\n") # If just normally executed
		out_file.write(i2+"else:\n")
		out_file.write(i2+i1+"m.loadFile(self.executionpath + \"/"+ filestring + "\")\n") # If being invoked by level Ed

		out_file.write(i2+"mp=MopathInterval(m,self." + str(node) + ")\n")
		out_file.write(i2+"self.curveIntervals.append(mp)\n")
		
		out_file.write(i2+"if(self.loadmode==1):\n")
		out_file.write(i2+i1+"self.curveRefColl.append(\"" + self.savepath +"/"+ filestring +"\")\n")
		out_file.write(i2+"else:\n")
		out_file.write(i2+i1+"self.curveRefColl.append(self.executionpath + \"/"+ filestring +"\")\n")

	 	curvenumber=curvenumber+1
	    out_file.write(i2+"self.curveIntervalsDict[\"" + str(node) + "\"]=self.curveIntervals\n")        
	    out_file.write(i2+"self.curveDict[\"" + str(node) + "\"]=self.curveRefColl\n")

    
	####################################################################################################################################################
	# Lets do all the reparenting here so as to make sure everything that needed to load was loaded
	####################################################################################################################################################


	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Reparenting\n")
	out_file.write(i2+"# A final pass is done on setting all the scenegraph hierarchy after all objects are laoded\n")
	out_file.write(i2+"##########################################################################################################\n\n")

	for model in AllScene.ModelDic:
	    modelS=str(model)
	    parent=AllScene.ModelDic[model].getParent().getName()
	    if(parent=="render" or parent=="camera"):
		out_file.write(i2+ "self."+ modelS + ".reparentTo(" + parent + ")\n")
	    else:
		if(AllScene.particleDict.has_key(parent)):
		    out_file.write(i2+ "self."+ modelS + ".reparentTo(self." + parent + ".getEffect())\n")
		else:
		    out_file.write(i2+ "self."+ modelS + ".reparentTo(self." + parent + ")\n")
	    out_file.write(i2+ "self.ModelDic[\'" + modelS + "\']=self." + AllScene.ModelDic[model].getName()+"\n")
      	    out_file.write(i2+"\n")

	for dummy in AllScene.dummyDict:
	    dummyS=str(dummy)
	    parent=AllScene.dummyDict[dummy].getParent().getName()
	    if(parent=="render" or parent=="camera"):
	        out_file.write(i2+ "self."+ dummyS + ".reparentTo(" + parent + ")\n")
	    else:  
		if(AllScene.particleDict.has_key(parent)):
		    out_file.write(i2+ "self."+ dummyS + ".reparentTo(self." + parent + ".getEffect())\n")
		else:
		    out_file.write(i2+ "self."+ dummyS + ".reparentTo(self." + parent + ")\n")

   	    out_file.write(i2+ "self.dummyDict[\'" + dummyS + "\']=self." + AllScene.dummyDict[dummy].getName()+"\n")
      	    out_file.write(i2+"\n")

	for actor in AllScene.ActorDic:
	    actorS=str(actor)	
	    parent=AllScene.ActorDic[actor].getParent().getName()
	    if(parent=="render" or parent=="camera"):
	        out_file.write(i2+ "self."+ actorS + ".reparentTo(" + parent + ")\n")
	    else:
	        if(AllScene.particleDict.has_key(parent)):
		    out_file.write(i2+ "self."+ actorS + ".reparentTo(self." + parent + ".getEffect())\n")
		else:
		    out_file.write(i2+ "self."+ actorS + ".reparentTo(self." + parent + ")\n")

            out_file.write(i2+ "self.ActorDic[\'" + actorS + "\']=self." + AllScene.ActorDic[actor].getName()+"\n")
      	    out_file.write(i2+"\n")
	

	for collnode in AllScene.collisionDict:
	    collnodeS=str(collnode)
	    solid=AllScene.collisionDict[collnode].node().getSolid(0)
	    nodetype=solid.getType().getName()
	    parentname=AllScene.collisionDict[collnode].getParent().getName()
	    if(parentname=="render" or parentname =="camera"):
	        out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"]="+ parentname + ".attachNewNode(self." + collnodeS + "_Node)\n")
	    else:
		if(AllScene.particleDict.has_key(parent)):
		    out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"]=self."+ parentname + "getEffect().attachNewNode(self." + collnodeS + "_Node)\n")
		else:
	            out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"]=self."+ parentname + ".attachNewNode(self." + collnodeS + "_Node)\n")
	    dictelem=AllScene.collisionDict[collnode]
	    out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setPosHprScale(%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f)\n"%(dictelem.getX(),dictelem.getY(),dictelem.getZ(),dictelem.getH(),dictelem.getP(),dictelem.getR(),dictelem.getSx(),dictelem.getSy(),dictelem.getSz()))
   	    out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag(\"Metadata\",\"" + AllScene.collisionDict[collnode].getTag("Metadata") + "\")\n")
	    out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].show()\n")
	    if(nodetype=="CollisionPolygon"): #Save Collison Polygon... the reason we need to use setTag here is because there is no inbuilt way of saving transforms for collision polys

		ax=float(AllScene.collisionDict[collnode].getTag("A_X"))
		ay=float(AllScene.collisionDict[collnode].getTag("A_Y"))
		az=float(AllScene.collisionDict[collnode].getTag("A_Z"))

		bx=float(AllScene.collisionDict[collnode].getTag("B_X"))
		by=float(AllScene.collisionDict[collnode].getTag("B_Y"))
		bz=float(AllScene.collisionDict[collnode].getTag("B_Z"))

		cx=float(AllScene.collisionDict[collnode].getTag("C_X"))
		cy=float(AllScene.collisionDict[collnode].getTag("C_Y"))
		cz=float(AllScene.collisionDict[collnode].getTag("C_Z"))

		out_file.write(i2+"pointA=Point3(%.3f,%.3f,%.3f)\n"%(ax,ay,az))
		out_file.write(i2+"pointB=Point3(%.3f,%.3f,%.3f)\n"%(bx,by,bz))
		out_file.write(i2+"pointC=Point3(%.3f,%.3f,%.3f)\n"%(cx,cy,cz))

                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('A_X','%f'%pointA.getX())\n")
                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('A_Y','%f'%pointA.getY())\n")
                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('A_Z','%f'%pointA.getZ())\n")

                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('B_X','%f'%pointB.getX())\n")
                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('B_Y','%f'%pointB.getY())\n")
                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('B_Z','%f'%pointB.getZ())\n")

                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('C_X','%f'%pointC.getX())\n")
                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('C_Y','%f'%pointC.getY())\n")
                out_file.write(i2+"self.collisionDict[\"" + collnodeS + "\"].setTag('C_Z','%f'%pointC.getZ())\n")
      	    out_file.write(i2+"\n")


	for effect in AllScene.particleDict:
	    parent=AllScene.particleNodes[effect].getParent().getName()
	    if(parent=="render" or parent=="camera"):
		out_file.write(i2+"self.particleDict[\""+ str(effect) +"\"].reparentTo("  + parent + ")\n")		
	    else:
	        out_file.write(i2+"self.particleDict[\""+ str(effect) +"\"].reparentTo(self."  + parent + ")\n")
      	    out_file.write(i2+"\n")


	####################################################################################################################################################
	# Particle Saving
	####################################################################################################################################################
        out_file.write("\n")
	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Particle Effects\n")
	out_file.write(i2+"# Using Particles:\n")
	out_file.write(i2+"# theScene.enableeffect(\"Effect_Name\")\n")
	out_file.write(i2+"##########################################################################################################\n\n")
	out_file.write(i1+"def starteffects(self,mode,seParticleEffect=None,seParticles=None):\n")
	for effect in AllScene.particleDict:
	    effectS=str(effect)
   	    out_file.write(i2+ "self." + effectS + "=" + effectS + "(mode,seParticleEffect,seParticles)\n")
	    out_file.write(i2+ "effect=self."+ effectS + ".getEffect()\n")
	    out_file.write(i2+ "self.particleDict[\"" + effectS + "\"]=effect\n")
	    out_file.write(i2+ "effect.reparentTo(render)\n")
	    thenode=AllScene.particleNodes[effect]
	    out_file.write(i2+ "self.particleDict[\"" + effectS + "\"].setPosHprScale(%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f)\n"%(thenode.getX(),thenode.getY(),thenode.getZ(),thenode.getH(),thenode.getP(),thenode.getR(),thenode.getSx(),thenode.getSy(),thenode.getSz()))
	    out_file.write("\n")
   	out_file.write(i2+"return\n")
        out_file.write("\n")
	out_file.write(i1+"def enableeffect(self,effect_name):\n")
        out_file.write(i2+"self.particleDict[effect_name].enable()\n")
        out_file.write(i2+"return\n")
        out_file.write("\n")
	out_file.write(i1+"def disableeffect(self,effect_name):\n")
        out_file.write(i2+"self.particleDict[effect_name].disable()\n")
        out_file.write(i2+"return\n")
        out_file.write("\n")


	####################################################################################################################################################
	# Animation Blending Methods
	####################################################################################################################################################
        out_file.write("\n")
	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Animation Blending\n")
	out_file.write(i2+"# Using blending:\n")
	out_file.write(i2+"# theScene.playBlendAnim(actor,blendname)\n")
	out_file.write(i2+"# theScene.stopBlendAnim(actor,blendname)\n")
	out_file.write(i2+"# theScene.changeBlendAnim(actor,blendname,blend_amount)\n")
	out_file.write(i2+"##########################################################################################################\n\n")
	out_file.write(i1+"def playBlendAnim(self,actor,blendName,loop=0):\n")
	out_file.write(i2+"actor.enableBlend()\n")
	out_file.write(i2+"blendDicts=self.blendAnimDict[actor.getName()]\n")
	out_file.write(i2+"blendList=blendDicts[blendName]\n")
	out_file.write(i2+"actor.setControlEffect(blendList[0],blendList[2])\n")
	out_file.write(i2+"actor.setControlEffect(blendList[1],1.0-blendList[2])\n")
	out_file.write(i2+"if(loop):\n")
	out_file.write(i2+i1+"actor.loop(blendList[0])\n")
	out_file.write(i2+i1+"actor.loop(blendList[1])\n")
	out_file.write(i2+"else:\n")
	out_file.write(i2+i1+"actor.start(blendList[0])\n")
	out_file.write(i2+i1+"actor.start(blendList[1])\n")
	out_file.write("\n")


	out_file.write(i1+"def stopBlendAnim(self,actor,blendName):\n")
	out_file.write(i2+"blendDicts=self.blendAnimDict[actor.getName()]\n")
	out_file.write(i2+"blendList=blendDicts[blendName]\n")
	out_file.write(i2+"actor.stop(blendList[0])\n")
	out_file.write(i2+"actor.stop(blendList[1])\n")
        out_file.write("\n")	

	out_file.write(i1+"def changeBlending(self,actor,blendName,blending):\n")
	out_file.write(i2+"blendDicts=self.blendAnimDict[actor.getName()]\n")
	out_file.write(i2+"blendList=blendDicts[blendName]\n")	
	out_file.write(i2+"blendList[2]=blending\n")
	out_file.write(i2+"self.blendAnimDict[actor.getName()]={blendName:[blendList[0],blendList[1],blending]}\n")
	out_file.write("\n")



	####################################################################################################################################################
	# Hide and Show Methods
	####################################################################################################################################################
     
	out_file.write("\n")
	out_file.write(i2+"##########################################################################################################\n")
	out_file.write(i2+"# Hide and Show Methods\n")
	out_file.write(i2+"# These will help you hide/show dummies, collision solids, effect nodes etc.\n")
	out_file.write(i2+"##########################################################################################################\n\n")
  
     
	out_file.write("\n")
	out_file.write(i1+"def hideDummies(self):\n")
	out_file.write("\n")
	out_file.write(i2+"for dummy in self.dummyDict:\n")
	out_file.write(i2+i1+"self.dummyDict[dummy].reparentTo(hidden)\n")
	
       
	out_file.write("\n")
	out_file.write(i1+"def hideCollSolids(self):\n")
	out_file.write("\n")
	out_file.write(i2+"for collSolid in self.collisionDict:\n")
	out_file.write(i2+i1+"self.collisionDict[collSolid].hide()\n")


	out_file.write("\n")
	out_file.write(i1+"def hideEffectNodes(self):\n")
	out_file.write("\n")
	out_file.write(i2+"for effectnode in self.particleNodes:\n")
	out_file.write(i2+i1+"self.particleNodes[effectnode].hide()\n")


	out_file.write("\n")
	out_file.write(i1+"def showDummies(self):\n")
	out_file.write("\n")
	out_file.write(i2+"for dummy in self.dummyDict:\n")
	out_file.write(i2+i1+"self.dummyDict[dummy].reparentTo(hidden)\n")
	
       
	out_file.write("\n")
	out_file.write(i1+"def showCollSolids(self):\n")
	out_file.write("\n")
	out_file.write(i2+"for collSolid in self.collisionDict:\n")
	out_file.write(i2+i1+"self.collisionDict[collSolid].show()\n")


	out_file.write("\n")
	out_file.write(i1+"def showEffectNodes(self):\n")
	out_file.write("\n")
	out_file.write(i2+"for effectnode in self.particleNodes:\n")
	out_file.write(i2+i1+"self.particleNodes[effectnode].show()\n\n")


	##########################################################################################################
	# Saving Particle Parameters as a Class
	##########################################################################################################

	out_file.write("\n")
 	out_file.write(i2+"##########################################################################################################\n")
  	out_file.write(i2+"# Particle Effects\n")
	out_file.write(i2+"# This is where effect parameters are saved in a class\n")
	out_file.write(i2+"# The class is then instantiated in the starteffects method and appended to the dictionaries\n")
	out_file.write(i2+"##########################################################################################################\n\n")

	for effect in AllScene.particleDict:
        
	    out_file.write("\n\n")
	    out_file.write("class " + str(effect) + ":\n")
	    out_file.write(i1+"def __init__(self,mode=1,seParticleEffect=None,seParticles=None):\n")
	    out_file.write(i2+"if(mode==0):\n")
	    out_file.write(i2+i1+"self.effect=seParticleEffect.ParticleEffect()\n")
	    out_file.write(i2+"else:\n")
	    out_file.write(i2+i1+"self.effect=ParticleEffect.ParticleEffect()\n")
	    AllScene.particleDict[effect].AppendConfig(out_file)
	    #out_file.write(i2+"return self.effect\n")
	    out_file.write("\n\n")
	    out_file.write(i1+"def starteffect(self):\n")
	    out_file.write(i2+"pass\n")
	    out_file.write("\n\n")
	    out_file.write(i1+"def stopeffect(self):\n")
	    out_file.write(i2+"pass\n\n")
	    out_file.write(i1+"def getEffect(self):\n")
	    out_file.write(i2+"return self.effect\n\n")



	#Un-comment the lines below to make this a stand-alone file
        #out_file.write("Scene=SavedScene()\n")
        #out_file.write("run()\n")

	out_file.close()