Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreSharedRuns.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreSharedRuns.h	(revision 1722)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreSharedRuns.h	(revision 2240)
@@ -19,4 +19,5 @@
 	RenderTarget* renderTarget;
 };
+
 /**
 	@brief Class of SharedRuns used in an OGRE environment.	
@@ -183,8 +184,21 @@
 	//inherited
 	void destroy();
+	//inherited
 	void runUpdated(RenderingRunType runType, RenderingRun* run);
+	//inherited
 	void runChanged(RenderingRunType runType, RenderingRun* run);
+	//inherited
 	virtual void addTechniqueGroup(TechniqueGroup* group){childTechniqueGroups.push_back(group);}
+	/**
+	 @brief Sets the given material for all connected renderables.
+
+	 The previous materials will be stored so later can be restored. @see restoreMaterial
+
+	 @param name of the material to be set.
+	*/
 	void setMaterial(String materialName);
+	/**
+		@brief Restores the prevoius materials for the connected renderables. @see setMaterial
+	*/
 	void restoreMaterial();
 
@@ -203,9 +217,14 @@
 	std::map<RenderingRunType, RenderingRun*> sharedRuns;
 	/**
-		@brief map of connected renderablis with visibility information
+		@brief map of connected renderables with visibility information
 
 		Used to show or hide the renderables connected to a leaf OgreSharedRuns node.
 	*/
-	std::map<OgreRenderable*, bool> renderables; 
+	std::map<OgreRenderable*, bool> renderables;
+	/**
+		@brief map of connected renderables with material name information
+
+		Used to resture the original materials of the renderables connected to a leaf OgreSharedRuns node.
+	*/
 	std::map<OgreRenderable*, String> renderableMaterials;
 	/**
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreIlluminationManager.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreIlluminationManager.h	(revision 2200)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreIlluminationManager.h	(revision 2240)
@@ -22,18 +22,46 @@
 using namespace Ogre;
 
+/**
+ @brief Structure to store path map cluster information for a subentity.
+*/
 struct PathMapClusters
 {
+	/**
+		@brief the number of clusters this subentity belongs to
+	*/
 	unsigned int count;
+	/**
+		@brief the indices of the cluster this subentity belongs to.
+	*/
 	unsigned int* clusters;
+	/**
+		@brief the name of the path map file this subentity uses
+	*/
 	String pathMapTextureFilename;
+	/**
+		@brief the resolution of the path map file.
+	*/
 	unsigned int pathMapResolution;
 };
 
+/**
+	@brief Structure of a path map entry point.
+*/
 struct PathMapEntryPoint
 {
+	/**
+		@brief the position of the entry point.
+	*/
     Vector3 position;
+	/**
+		@brief the normal of the entry point.
+	*/
 	Vector3 normal;
+	/**
+		@brief the probability of the entry point.
+	*/
 	float prob;
 };
+
 /**
 	@brief Implementation of IlluminationManager in an OGRE environment.
@@ -70,5 +98,15 @@
 	*/
 	BillboardSet* findRenderableInParticleSystem(ParticleSystem* system);
+	/**
+		@brief Fires preAllUpdates for registered UpdateListeners.
+
+		This is called in each frame before updating the RenderTechniques.
+	*/
 	void preAllUpdates();
+	/**
+		@brief Fires postAllUpdates for registered UpdateListeners.
+
+		This is called in each frame after updating the RenderTechniques.
+	*/
 	void postAllUpdates();
 
@@ -83,16 +121,71 @@
 	*/
 	float maxRad;
+	/**
+		@brief Size of the focusing map.
+
+		This map is used if the shadow maps should be focused.
+	*/
 	unsigned int focusingMapSize;
+	/**
+		@brief Size of the shadow maps.
+	*/
 	unsigned int shadowMapSize;
+	/**
+		@brief Size of area lights for soft shadows.
+	*/
 	float areaLightRadius;
+	/**
+		@brief Sets if light space perspective shadow mapping should be used.
+	*/
 	bool useLISPSM;
-	bool useVSM;
+	/**
+		@brief Sets if the shadow maps should be blurred.
+
+		Used in variance shadow mapping.
+	*/
 	bool blurSM;
+	/**
+		@brief Sets if shadow maps should be focused.
+	*/
 	bool focusingSM;
+	/**
+		@brief The material name that should be used during rendering the shadow maps.
+
+		There are several predefined materials that can be used to render shadow maps:
+		 - GTP/Basic/Depth : writes projected depth values of front facing polygons
+		 - GTP/Basic/DepthCCW : writes projected depth values of back facing polygons
+		 - GTP/Basic/Distance : writes distance values (from eyepoint) of front facing polygons
+		 - GTP/Basic/DistanceCCW : writes distance values (from eyepoint) of back facing polygons
+		 - GTP/Basic/Distance_Normalized : writes normalized distance values
+			(distance values devided by projection farplane - which is set to the attenuation range in case of shadow maps) of front facing polygons
+		 - GTP/Basic/Distance_NormalizedCCW : writes normalized distance values of back facing polygons
+
+		 The default material is GTP/Basic/Distance_NormalizedCCW.
+		 Recommended materials for different light types:
+		 - spot and point lights : GTP/Basic/Distance_NormalizedCCW or GTP/Basic/Distance_Normalized
+		 - directional lights : GTP/Basic/Depth or GTP/Basic/DepthCCW
+	*/
 	String shadowMapMaterialName;
+	/**
+		@brief Size of the phase texture.
+	*/
 	unsigned int phaseTextureSize;
+	/**
+		@brief Stores maximum bounding radius values for each rendering run type.
+	*/
 	std::map<RenderingRunType,float> maxRads;
+	/**
+		@brief Stores PathMapClusters structures for each subentity.
+
+		The String key is the name of the subentity.
+	*/
 	std::map<String, PathMapClusters> pathMapClusters;
+	/**
+		@brief PathMapEntryPoint list.
+	*/
 	std::vector<PathMapEntryPoint> pathMapEntryPoints;
+	/**
+		@brief Stores cluster size for each path map cluster.
+	*/
 	std::vector<unsigned int> pathMapClusterLengths;
 	/**
@@ -139,11 +232,17 @@
 	*/
 	std::map<String, OgreSharedRuns*> perLightRuns;
-
+	/**
+		@brief 
+	*/
 	std::map<GlobalTargetType, GlobalUseRenderTarget*> globalTargets;
-
+	/**
+		@brief Stores registered UpdateListeners.
+	*/
 	std::vector<UpdateListener*> updateListeners;
 
 public:
-
+	/**
+		@brief Registers an UpdateListener instance. @see UpdateListener
+	*/
 	void addUpdateListener(UpdateListener* l){updateListeners.push_back(l);}
 	/**
@@ -156,9 +255,15 @@
 	/**
 		@brief retirieves the maximum bounding sphere radius with two SharedRuns can be joined.
+
+		Only valid fi all run types use the same radius. This can be set with calling setMaxJoinRadius().
+		@see setMaxJoinRadius
 	*/
 	float getMaxJoinRadius(){return maxRad;}
+	/**
+		@brief Retirieves the maximum shared bounding sphere radius for a given run type.
+	*/
 	float getMaxJoinRadius(RenderingRunType type){return maxRads[type];}
 	/**
-		@brief sets the maximum bounding sphere radius with two SharedRuns can be joined.
+		@brief sets the maximum bounding sphere radius with two SharedRuns can be joined for all run type.
 	*/
 	void setMaxJoinRadius(float rad)
@@ -176,7 +281,19 @@
 		
 	}
+	/**
+		@brief Sets the maximum shared bounding sphere radius for a given run type.
+	*/
 	void setMaxJoinRadius(RenderingRunType type, float rad){maxRads[type] = rad;}
+	/**
+		@see focusingMapSize
+	*/
 	void setFocusingMapSize(unsigned int size){focusingMapSize = size;}
+	/**
+		@see phaseTextureSize
+	*/
 	void setPhaseTextureSize(unsigned int size){phaseTextureSize = size;}
+	/**
+		@see shadowMapSize
+	*/
 	void setShadowMapSize(unsigned int size){shadowMapSize = size;}
 	/**
@@ -285,6 +402,8 @@
 	RenderingRun* getGlobalRun(RenderingRunType runType);
 
+	// These GlobalUseRenderTargets are only used in fire render technique. Maybe it could be solved with global rendering runs too.
 	GlobalUseRenderTarget* getGlobalTarget(GlobalTargetType type);
 	void addGlobalTarget(GlobalTargetType type, GlobalUseRenderTarget* target);
+
 	/**
 		@brief Updates a global RenderingRun with the given type.
@@ -318,52 +437,111 @@
 	*/
 	void updatePerLightRun(String lightName, RenderingRunType runType, unsigned long frameNum);
-
+	/**
+		@brief Saves the phase texture to the given file.
+	*/
 	void savePhaseTextureToFile(String filename);
-
+	/**
+		@brief Frame listener event handler function.
+		
+		Inherited from FrameListener. Called at the beginning of each frame.
+	*/
 	bool frameStarted(const FrameEvent& evt)
     {
 		update(Root::getSingleton().getCurrentFrameNumber(), mainViewport->getTarget());
 		return FrameListener::frameStarted(evt);
-	}
-
+	}	
+	/**
+		@see useLISPSM
+	*/
 	bool getUseLISPSM(){return useLISPSM;}
-	bool getUseVSM(){return useVSM;}
+	/**
+		@see focusingSM
+	*/
 	bool getFocusingShadowMap(){return focusingSM;}
+	/**
+		@see blurSM
+	*/
 	bool getBlurShadowMap(){return blurSM;}
+	/**
+		@see useLISPSM
+	*/
 	void setUseLISPSM(bool use){useLISPSM = use;}
-	void setUseVSM(bool use){useVSM = use;}
+	/**
+		@see focusingSM
+	*/
 	void setFocusingSM(bool use){focusingSM = use;}
+	/**
+		@see blurSM
+	*/
 	void setBlurShadowMap(bool use){blurSM = use;}
+	/**
+		@see shadowMapMaterialName
+	*/
 	void setShadowMapMaterialName(String name){shadowMapMaterialName = name;}
-
+	/**
+		@brief Registers a PathMapClusters structure for a given subentity.
+
+		@param subEntityName name of te subentity
+		@param clusters the PathMapClusters that belongs to the given subentity
+	*/
 	void addPathMapClusters(String subEntityName, PathMapClusters clusters)
 	{
 		this->pathMapClusters[subEntityName] = clusters;
 	}
+	/**
+		@brief Returns the PathMapClusters structure registered for a given subentity.
+
+		@param subEntityName name of te subentity
+		@return pointer to the PathMapClusters structure that belongs to the given subentity
+	*/
 	PathMapClusters* getPathMapClusters(String subEntityName)
 	{
 		return &pathMapClusters[subEntityName];
 	}
+	/**
+		@brief Adds a new PathMapEntryPoint cluster to the entrypoint list.
+	*/
 	void addPathMapEntryPoint(PathMapEntryPoint p)
 	{
 		this->pathMapEntryPoints.push_back(p);
 	}
+	/**
+		@brief Returns the list of entrypoints.
+	*/
 	std::vector<PathMapEntryPoint>& getPathMapEntryPoints()
 	{
 		return pathMapEntryPoints;
 	}
+	/**
+		@brief Adds a new cluster size.
+	*/
 	void addPathMapClusterLength(unsigned int l)
 	{
 		this->pathMapClusterLengths.push_back(l);
 	}
+	/**
+		@brief Gets the number of clusters.
+	*/
 	unsigned int getPathMapClusterLengthsSize()
 	{
 		return this->pathMapClusterLengths.size();
 	}
+	/**
+		@brief Gets the size of the given cluster.
+
+		@param index of the cluster
+		@return the size of the cluster
+	*/
 	unsigned int getPathMapClusterLength(unsigned int index)
 	{
 		return pathMapClusterLengths.at(index);
 	}
+	/**
+		@see areaLightRadius
+	*/
 	float getAreaLightRadius(){return areaLightRadius;}
+	/**
+		@see areaLightRadius
+	*/
 	void setAreaLigtRadius(float radius){areaLightRadius = radius;}
 };
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderingRun.h	(revision 1722)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderingRun.h	(revision 2240)
@@ -45,5 +45,4 @@
 	*/
 	std::map<Renderable*, String> visibleObjects;
-	String terrainMaterial;
 	/**
 		@brief fulls screen quad plane used in full screen quad rendering
@@ -82,5 +81,4 @@
 	*/
 	String spriteSetName;
-
 	/**
 		@brief Returns a direction for a cubemap face id.
@@ -163,5 +161,11 @@
 	*/
 	void renderPixelSprites(String& materialName, RenderTarget* rt, int width, int height);
-	void renderFullscreenGrid(String& materialName, RenderTarget* rt, int width, int height);
-	
+	/**
+		@brief Renders a grid onto the screen.
+
+		@param rt the RenderTarget the grid should be rendered on
+		@param width the desired horizontal resolution of the grid
+		@param height the desired vertical resolution of the grid
+	*/
+	void renderFullscreenGrid(String& materialName, RenderTarget* rt, int width, int height);	
 };
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreCausticCubeMapRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreCausticCubeMapRenderingRun.h	(revision 2142)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreCausticCubeMapRenderingRun.h	(revision 2240)
@@ -14,5 +14,5 @@
 
 /**
-	@brief ColorCubeMapRenderingRun used in an OGRE environment.
+	@brief CausticCubeMapRenderingRun used in an OGRE environment.
 */
 class OgreCausticCubeMapRenderingRun : public OgreRenderingRun,
@@ -32,4 +32,7 @@
 		@param photonMapTexId			the texture unit state id of the caustic map generation material where the photonhit map should be bound to
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param attenuation				attenuation distance of the caustic
+		@param useTriangles				sets if triangles should be rendered into the caustic cubemap instead of sprites
+		@param blurMap					sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles)
 	*/	
 	OgreCausticCubeMapRenderingRun(OgreSharedRuns* sharedRuns,
@@ -58,6 +61,9 @@
 	//inherited
 	void photonMapChanged(RenderingRun* run);
+	/**
+		@see attenuation
+	*/
 	float getAttenuation(){return attenuation;}
-	
+	//inherited
 	bool canJoin(RenderingRun* run)
 	{
@@ -67,5 +73,7 @@
 		return false;
 	}
-
+	/**
+		@see blurMap
+	*/
 	void setBlurMap(bool blur){blurMap = blur;}
 
@@ -95,6 +103,15 @@
 	*/
 	String materialName;
+	/**
+		@brief attenuation distance of the caustic
+	*/
 	float attenuation;
+	/**
+		@brief sets if triangles should be rendered into the caustic cubemap instead of sprites
+	*/
 	bool useTriangles;
+	/**
+		@brief sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles)
+	*/
 	bool blurMap;
 	
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreChildPSystemRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreChildPSystemRenderingRun.h	(revision 1722)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreChildPSystemRenderingRun.h	(revision 2240)
@@ -14,5 +14,5 @@
 
 /**
-	@brief ColorCubeMapRenderingRun used in an OGRE environment.
+	@brief ChildPsystemRenderingRun used in an OGRE environment.
 */
 class OgreChildPSystemRenderingRun : public OgreRenderingRun,
@@ -28,5 +28,10 @@
 		@param startFrame			adds an offset to the current frame number to help evenly distribute updates between frames
 		@param updateInterval		update frequency
-		@param materialName			the name of the material should be used when rendering the choton hit map
+		@param resolution			resolution of the impostor texture
+		@param perspectiveRendering	sets if the impostor should be rendered with a perspective projection or orthogonal
+		@param childPSysScriptName	the name of the particle system script
+		@param useOwnMaterial		use the material that was defined in the particle script
+		@param materialName			use this specific material while rendering the impostor
+		
 */	
 	OgreChildPSystemRenderingRun(OgreSharedRuns* sharedRuns,
@@ -45,5 +50,5 @@
 	*/
 	String getImpostorTextureName(){return name;}
-	
+	//inherited
 	bool canJoin(RenderingRun* run)
 	{
@@ -51,4 +56,5 @@
 		return false;
 	}
+
 	void setNode(SceneNode* n){psysNode = n;}
 	Real getSmallSysRadius(){return sysRad;}
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderable.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderable.h	(revision 1425)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderable.h	(revision 2240)
@@ -50,5 +50,4 @@
 	*/
 	~OgreRenderable(void);
-
 	/**
 		@brief Sets the visibility of the wrapped renderable.
@@ -135,8 +134,6 @@
 	*/
 	Renderable* getRenderable();
-
 	
 protected:
-
 	/**
 		@brief unique name assigned to the renderable
@@ -155,6 +152,8 @@
 	*/
 	BillboardSet* billboardSetRenderable;
+	/**
+		@brief pointer to the parent Particle System of the wrapped BillboardSet (if the renderable is a BillboardSet)
+	*/
 	ParticleSystem* parentParticleSystem;
-
 	/**
 		@brief axis-aligned bounding box of the wrapped renderable in world space
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderTechnique.h	(revision 1055)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderTechnique.h	(revision 2240)
@@ -6,8 +6,20 @@
 class OgreTechniqueGroup;
 
+/**
+	@brief Event handler class.
+
+	The derived calsses of this class can register task that should be done before and/or after updating all RenderTechniques.
+	UpdateListeners can be registered to the OgreIlluminationMager. @see addUpdateListener
+*/
 class UpdateListener
 {
 public:
+	/**
+		@brief Called before RenderTechnique updates
+	*/
 	virtual void preAllUpdates(){}
+	/**
+		@brief Called after RenderTechnique updates
+	*/
 	virtual void postAllUpdates(){}
 };
@@ -100,5 +112,12 @@
 										OgreRenderable* parentRenderable,
 										OgreTechniqueGroup* parentTechniqueGroup) = 0;
+	/**
+		@brief parses parameters from the material file.
 
+		The parsed parameters will be passed to the new RenderTechnique's constructor.
+
+		@param params pointer to the IllumTechniqueParams structure that was read from the material script and containes the parameters to be parsed.
+
+	*/
 	virtual void parseParams(IllumTechniqueParams* params);
 	
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreSBBRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreSBBRenderTechnique.h	(revision 1055)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreSBBRenderTechnique.h	(revision 2240)
@@ -42,9 +42,13 @@
 	//inherited
 	virtual void update(unsigned long frameNum);
-
+	//inherited
 	void  preRenderTargetUpdate (const RenderTargetEvent &evt);
+	//inherited
 	void  postRenderTargetUpdate (const RenderTargetEvent &evt);
+	//inherited
 	bool  frameEnded (const FrameEvent &evt);
+	//inherited
 	void preAllUpdates();
+	//inherited
 	void postAllUpdates();
 	
@@ -59,5 +63,7 @@
 };
 
-
+/**
+	@brief RenderTechniqueFactory to create OgreSBBRenderTechnique instances.
+*/
 class OgreSBBRenderTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDistanceCubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDistanceCubeMapRenderTechnique.h	(revision 1886)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDistanceCubeMapRenderTechnique.h	(revision 2240)
@@ -34,4 +34,13 @@
 		@param angleTolerance			angle tolerance used in face skip
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame		
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map
+		@param selfMaterial				the material that should be set for the object while rendering the cubemap
+		@param environmentMaterial      the material that should be set for the environment while rendering the cubemap
+		@param layer					the layer of this cubemap
+		@param getMinMax				sets if the minimum and maximum values of the cubemap should be computed
+		@param attachToTexUnit			sets if this cubemap should be attach to a texture unit of the pass
+		@param minVariableName			sets the name of the gpu shader program parameter to which the minimum value should be bound to
+		@param maxVariableName			sets the name of the gpu shader program parameter to which the maximum value should be bound to
 		@param pass						the pass to operate on			
 		@param parentRenderable			the object to operate on
@@ -78,5 +87,7 @@
 };
 
-
+/**
+	@brief RenderTechniqueFactory to create OgreDistanceCubeMapRenderTechnique instances.
+*/
 class OgreDistanceCubeMapRenderTechniqueFactory : public OgreCubeMapRenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreHierarchicalParticleSystemTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreHierarchicalParticleSystemTechnique.h	(revision 1425)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreHierarchicalParticleSystemTechnique.h	(revision 2240)
@@ -12,5 +12,5 @@
 
 /**
-	@brief CausticCasterRenderTechnique used in an OGRE environment.
+	@brief HierarchicalParticleSystemTechnique used in an OGRE environment.
 */
 class OgreHierarchicalParticleSystemTechnique : public OgreRenderTechnique,
@@ -18,5 +18,24 @@
 {
 public:
+	/**
+		@brief Constructor.
 
+		@param startFrame				adds an offset to the current frame number to help evenly distribute updates between frames
+		@param impostorUpdateInterval	update frequency of the impostor texture (image of the smaller system)
+		@param impostorResolution		resolution of the impostor texture
+		@param impostorTexID			the id of the texture unit state the impostor image should be bound to
+		@param useDistCalc				flag to skip impostor update if object is far away (//not used)
+		@param perspectiveRendering		sets if the impostor should be rendered with a perspective projection or orthogonal
+		@param childPSysScriptName		name of the small particle system script
+		@param useOwnMaterial			use the material for the smaller system that was defined in the particle script
+		@param impostorMaterialName		use this specific material for the small particle system
+		@param useVParam				bound particle radius to a gpu vertex program parameter
+		@param VParamRadius				name of the gpu vertex program parameter the particle radius should be bound to
+		@param useFParam				bound particle radius to a gpu fragment program parameter
+		@param FParamRadius				name of the gpu fragment program parameter the particle radius should be bound to
+		@param pass						the pass to operate on			
+		@param parentRenderable			the object to operate on
+		@param parentTechniqueGroup		the TechniqueGroup this RenderedTechnique is attached to
+	*/
 	OgreHierarchicalParticleSystemTechnique(unsigned long startFrame,
 							unsigned long impostorUpdateInterval,
@@ -43,22 +62,54 @@
 		
 protected:
-	
+	/**
+		@brief use this specific material for the small particle system
+	*/
 	String impostorMaterialName;
+	/**
+		@brief name of the small particle system script
+	*/
 	String childPSysScriptName;
+	/**
+		@brief name of the created child particle system
+	*/
 	String childPSysName;
+	/**
+		@brief the id of the texture unit state the impostor image should be bound to
+	*/
 	unsigned char impostorTexID;
+	/**
+		@brief use the material for the smaller system that was defined in the particle script
+	*/
 	bool useOwnMaterial;
+	/**
+		@brief name of the gpu vertex program parameter the particle radius should be bound to
+	*/
 	String VParamRadius;
+	/**
+		@brief name of the gpu fragment program parameter the particle radius should be bound to
+	*/
 	String FParamRadius;
+	/**
+		@brief bound particle radius to a gpu vertex program parameter
+	*/
 	bool useVParam;
+	/**
+		@brief bound particle radius to a gpu fragment program parameter
+	*/
 	bool useFParam;
 	
 	//inherited
 	RenderingRun* createChildPSysRenderingRun();
+	//inherited
 	RenderingRun* createLightVolumeRenderingRun();
+	//inherited
 	virtual void impostorChanged(RenderingRun* run);
+	//inherited
 	virtual void impostorUpdated(RenderingRun* run);
 };
 
+/**
+	@brief RenderTechniqueFactory to create OgreHierarchicalParticleSystemTechnique instances.
+*/
 class OgreHierarchicalParticleSystemTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreIllumVolumeRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreIllumVolumeRenderTechnique.h	(revision 1425)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreIllumVolumeRenderTechnique.h	(revision 2240)
@@ -12,5 +12,5 @@
 
 /**
-	@brief CausticCasterRenderTechnique used in an OGRE environment.
+	@brief IllumVolumeRenderTechnique used in an OGRE environment.
 */
 class OgreIllumVolumeRenderTechnique : public OgreRenderTechnique,
@@ -18,5 +18,21 @@
 {
 public:
+	/**
+		@brief Constructor.
 
+		@param startFrame					adds an offset to the current frame number to help evenly distribute updates between frames
+		@param illumVolumeUpdateInterval	the update frequency of the light volume
+		@param illumTextureResolution		the resolution of the light volume texture
+		@param textureDepth					the number of layers to use (should be set to 1)
+		@param illumTexID					the id of the texture unit state the resulting illumevolume should be bound to
+		@param useDistCalc					flag to skip updates if the shaded particle system is far away (not used)
+		@param materialName					the name of the material that is used while rendering the light volume
+		@param lightMatrixGPUParamName		the name of the gpu program parameter where the light matrix should be bound to
+		@param useHierarchicalImpostor		set this flag to true if the particle system is a hierarchical particle system
+		@param impostorTexID				the id of the texture unit state where the impostor image of the smaller system should be bound to
+		@param pass							the pass to operate on			
+		@param parentRenderable				the object to operate on
+		@param parentTechniqueGroup			the TechniqueGroup this RenderedTechnique is attached to
+	*/
 	OgreIllumVolumeRenderTechnique(unsigned long startFrame,
 							unsigned long illumVolumeUpdateInterval,
@@ -39,17 +55,34 @@
 	
 protected:
-	
+	/**
+		@brief the name of the material that is used while rendering the light volume
+	*/
 	String materialName;
+	/**
+		@brief the id of the texture unit state the resulting illumevolume should be bound to
+	*/
 	unsigned char illumTexID;
+	/**
+		@brief the name of the gpu program parameter where the light matrix should be bound to
+	*/
 	String lightMatrixGPUParamName;
+	/**
+		@brief the id of the texture unit state where the impostor image of the smaller system should be bound to
+	*/
 	unsigned char impostorTexID;
 	
 	//inherited
 	RenderingRun* createLightVolumeRenderingRun();
+	//inherited
 	void lightVolumeChanged(RenderingRun* run);
+	//inherited
 	void lightVolumeUpdated(RenderingRun* run);
+	//inherited
 	void hierarchicalImpostorUpdated(RenderingRun* run);
 };
 
+/**
+	@brief RenderTechniqueFactory to create OgreIllumVolumeRenderTechnique instances.
+*/
 class OgreIllumVolumeRenderTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgrePathMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgrePathMapRenderTechnique.h	(revision 2200)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgrePathMapRenderTechnique.h	(revision 2240)
@@ -15,16 +15,7 @@
 struct PathMapClusters;
 /**
-	@brief DepthShadowRecieverRenderTechnique used in an OGRE environment.
+	@brief A technique that defines that the rendering of the object will use the path map technique.
 
-	This technique defines that the object will recieve shadows with the help of depth shadow maps.
-	Each lightsource can have a depth map assigned to it. These are going to be refreshed only 
-	if shadow recievers are visible. It is the shadow reciever technique's resposibility
-	to refresh them.
-
-	The shadows from each light are calculated in separate passes. Each pass will
-	modulate the shaded image, so thes should be the last passes (but before caustic passes).
-	The given Pass* parameter n the constructor defines the pass after which new
-	shadow recieving passes will be added by the technique.
-
+	This rendering technique can add indirect lighting to the scene.
 */
 class OgrePathMapRenderTechnique : public OgreRenderTechnique
@@ -34,8 +25,4 @@
 		@brief Constructor.
 
-		@param maxlights				the maximum number of light sources to recieve shadow from
-		@param shadowVertexProgram		the vertex program to be used in the shadowing passes
-		@param shadowFragmentProgram	the fragment program to be used in the shadowing passes
-										It should have one pass and the depth map of a light will be bound to the first sampler unit. 
 		@param pass						the pass after which shadowing passes should be added
 		@param parentRenderable			the object to operate on
@@ -54,13 +41,26 @@
 	virtual void update(unsigned long frameNum);
 	
-protected:	
+protected:
+	/**
+		@brief the new pass created by this technique
+	*/
 	Pass* pathMapPass;
-	PathMapClusters* clusters;	
+	/**
+		@brief the PathMapClusters structure that belongs to the subentity renderable
+	*/
+	PathMapClusters* clusters;
+	/**
+		@brief the weight index lookup map created by this technique
+	*/
 	Texture* weightIndexTexture;
-
+	/**
+		@brief create a weight index lookup map
+	*/
 	void createWeightIndexTexture();
 };
 
-
+/**
+	@brief RenderTechniqueFactory to create OgrePathMapRenderTechnique instances.
+*/
 class OgrePathMapRenderTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreColorCubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreColorCubeMapRenderTechnique.h	(revision 1930)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreColorCubeMapRenderTechnique.h	(revision 2240)
@@ -15,5 +15,5 @@
 
 /**
-	@brief CubeMapRenderTechnique used in an Ogre environment.
+	@brief ColorCubeMapRenderTechnique used in an Ogre environment.
 */
 class OgreColorCubeMapRenderTechnique :	public ColorCubeMapRenderTechnique,
@@ -34,4 +34,13 @@
 		@param angleTolerance			angle tolerance used in face skip
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map
+		@param selfMaterial				the material that should be set for the object while rendering the cubemap
+		@param environmentMaterial      the material that should be set for the environment while rendering the cubemap
+		@param layer					the layer of this cubemap
+		@param getMinMax				sets if the minimum and maximum values of the cubemap should be computed
+		@param attachToTexUnit			sets if this cubemap should be attach to a texture unit of the pass
+		@param minVariableName			sets the name of the gpu shader program parameter to which the minimum value should be bound to
+		@param maxVariableName			sets the name of the gpu shader program parameter to which the maximum value should be bound to
 		@param pass						the pass to operate on			
 		@param parentRenderable			the object to operate on
@@ -70,8 +79,12 @@
 protected:		
 	//inherited
-	void colorCubeMapRunChanged(RenderingRun* run);	
+	void colorCubeMapRunChanged(RenderingRun* run);
+	//inherited
 	void colorCubeMapRunUpdated(RenderingRun* run);	
 };
 
+/**
+	@brief RenderTechniqueFactory to create OgreColorCubeMapRenderTechnique instances.
+*/
 class OgreColorCubeMapRenderTechniqueFactory : public OgreCubeMapRenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreConvolvedCubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreConvolvedCubeMapRenderTechnique.h	(revision 1886)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreConvolvedCubeMapRenderTechnique.h	(revision 2240)
@@ -35,4 +35,12 @@
 		@param angleTolerance				angle tolerance used in face skip
 		@param updateAllFace				defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map
+		@param selfMaterial				the material that should be set for the object while rendering the cubemap
+		@param environmentMaterial      the material that should be set for the environment while rendering the cubemap
+		@param getMinMax				sets if the minimum and maximum values of the cubemap should be computed
+		@param attachToTexUnit			sets if this cubemap should be attach to a texture unit of the pass
+		@param minVariableName			sets the name of the gpu shader program parameter to which the minimum value should be bound to
+		@param maxVariableName			sets the name of the gpu shader program parameter to which the maximum value should be bound to
 		@param pass							the pass to operate on			
 		@param parentRenderable				the object to operate on
@@ -80,6 +88,7 @@
 };
 
-
-
+/**
+	@brief RenderTechniqueFactory to create OgreConvoledCubeMapRenderTechnique instances.
+*/
 class OgreConvoledCubeMapRenderTechniqueFactory : public OgreCubeMapRenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCubeMapRenderTechnique.h	(revision 1930)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCubeMapRenderTechnique.h	(revision 2240)
@@ -34,4 +34,13 @@
 		@param angleTolerance			angle tolerance used in face skip
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map
+		@param selfMaterial				the material that should be set for the object while rendering the cubemap
+		@param environmentMaterial      the material that should be set for the environment while rendering the cubemap
+		@param layer					the layer of this cubemap
+		@param getMinMax				sets if the minimum and maximum values of the cubemap should be computed
+		@param attachToTexUnit			sets if this cubemap should be attach to a texture unit of the pass
+		@param minVariableName			sets the name of the gpu shader program parameter to which the minimum value should be bound to
+		@param maxVariableName			sets the name of the gpu shader program parameter to which the maximum value should be bound to
 		@param pass						the pass to operate on			
 		@param parentRenderable			the object to operate on
@@ -73,18 +82,42 @@
 	*/
 	unsigned char texID;
+	/**
+		@brief the material that should be set for the object while rendering the cubemap
+	*/
 	String selfMaterial;
+	/**
+		@brief the material that should be set for the environment while rendering the cubemap
+	*/
 	String environmentMaterial;
+	//helper string to name the created cubemaps
 	String texturePostFix;
-
+	/**
+		@brief sets if the minimum and maximum values of the cubemap should be computed
+	*/
 	bool getMinMax;
+	/**
+		@brief sets if this cubemap should be attach to a texture unit of the pass
+	*/
 	bool attachToTexUnit;
+	/**
+		@brief sets the name of the gpu shader program parameter to which the minimum value should be bound to
+	*/
 	String minVariableName;
+	/**
+		@brief sets the name of the gpu shader program parameter to which the maximum value should be bound to
+	*/
 	String maxVariableName;
 
+	//inherited
 	RenderingRun* createCubeMapRun();
-	void cubeMapRunChanged(RenderingRun* run);	
+	//inherited
+	void cubeMapRunChanged(RenderingRun* run);
+	//inherited
 	void cubeMapRunUpdated(RenderingRun* run);	
 };
 
+/**
+	@brief RenderTechniqueFactory to create OgreCubeMapRenderTechnique instances.
+*/
 class OgreCubeMapRenderTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticCasterRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticCasterRenderTechnique.h	(revision 1688)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticCasterRenderTechnique.h	(revision 2240)
@@ -30,4 +30,7 @@
 		@param updateAllFace				defines if all cubemap faces should be updated in a frame or only one face per frame
 		@param useDistance					tells if a distance cubemap impostor should be used in photon hit calculation (recommended)
+		@param attenuation					attenuation distance of the caustic
+		@param useTriangles					sets if triangles should be rendered into the caustic cubemap instead of sprites
+		@param blurCauCubeMap				sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles)
 		@param pass							the pass to operate on
 		@param parentRenderable				the object to operate on
@@ -37,5 +40,5 @@
 							unsigned long photonMapUpdateInterval,
 							unsigned int photonMapResolution,
-							unsigned int custicCubeMapResolution,
+							unsigned int causticCubeMapResolution,
 							String photonMapMaterialName,
 							String causticMapMaterialName,
@@ -60,4 +63,7 @@
 	*/
 	const String& getCausticCubeMapName();
+	/**
+		@see attenuation
+	*/
 	float getAttenuation(){return attenuation;}
 
@@ -76,6 +82,15 @@
 	*/
 	unsigned char photonMapTexID;
+	/**
+		@brief attenuation distance of the caustic
+	*/
 	float attenuation;
+	/**
+		@brief sets if triangles should be rendered into the caustic cubemap instead of sprites
+	*/
 	bool useTriangles;
+	/**
+		@brief sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles)
+	*/
 	bool blurCauCubeMap;
 	
@@ -96,5 +111,7 @@
 };
 
-
+/**
+	@brief RenderTechniqueFactory to create OgreCausticCasterRenderTechnique instances.
+*/
 class OgreCausticCasterRenderTechniqueFactory : public RenderTechniqueFactory
 {
@@ -121,5 +138,3 @@
 	bool useTriangles;
 	bool blurCauCubeMap;
-	
-
 };
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDepthShadowRecieverRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDepthShadowRecieverRenderTechnique.h	(revision 2180)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDepthShadowRecieverRenderTechnique.h	(revision 2240)
@@ -39,4 +39,12 @@
 		@param shadowFragmentProgram	the fragment program to be used in the shadowing passes
 										It should have one pass and the depth map of a light will be bound to the first sampler unit. 
+		@param WorldViewProjParamName   the name of the gpu program parameter the world-view-projection matrix should be bound to
+		@param WorldParamName			the name of the gpu program parameter the world matrix should be bound to
+		@param setLightViewMatrix		bound light space view matrix to a gpu program parameter
+		@param setLightViewProjMatrix   bound light space view-projection matrix to a gpu program parameter
+		@param setLightProjFarPlane		bound light space projection far plane to a gpu program parameter
+		@param lightViewProjParamName   the name of the gpu program parameter the light space view-projection matrix should be bound to
+		@param lightViewParamName       the name of the gpu program parameter the light space view matrix should be bound to
+		@param lightFarPlaneParamName	the name of the gpu program parameter the light space projection far plane should be bound to
 		@param pass						the pass after which shadowing passes should be added
 		@param parentRenderable			the object to operate on
@@ -88,16 +96,42 @@
 	*/
 	std::vector<Pass*> passes;
+	/**
+		@brief bound light space view matrix to a gpu program parameter
+	*/
 	bool setLightViewMatrix;
+	/**
+		@brief bound light space view-projection matrix to a gpu program parameter
+	*/
 	bool setLightViewProjMatrix;
+	/**
+		@brief bound light space projection far plane to a gpu program parameter
+	*/
 	bool setLightProjFarPlane;
+	/**
+		@brief the name of the gpu program parameter the light space view-projection matrix should be bound to
+	*/
 	String lightViewProjParamName;
+	/**
+		@brief the name of the gpu program parameter the light space view matrix should be bound to
+	*/
 	String lightViewParamName;
+	/**
+		@brief the name of the gpu program parameter the light space projection far plane should be bound to
+	*/
 	String lightFarPlaneParamName;
+	/**
+		@brief the name of the gpu program parameter the world-view-projection matrix should be bound to
+	*/	
 	String WorldViewProjParamName;
+	/**
+		@brief the name of the gpu program parameter the world matrix should be bound to
+	*/
 	String WorldParamName;
 												
 };
 
-
+/**
+	@brief RenderTechniqueFactory to create OgreDepthShadowRecieverRenderTechnique instances.
+*/
 class OgreDepthShadowRecieverRenderTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticRecieverRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticRecieverRenderTechnique.h	(revision 836)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticRecieverRenderTechnique.h	(revision 2240)
@@ -84,4 +84,7 @@
 };
 
+/**
+	@brief RenderTechniqueFactory to create OgreCausticRecieverRenderTechnique instances.
+*/
 class OgreCausticRecieverRenderTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreFireRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreFireRenderTechnique.h	(revision 1055)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreFireRenderTechnique.h	(revision 2240)
@@ -26,5 +26,11 @@
 
 /**
-	@brief SBBRenderTechnique used in an OGRE environment.
+	@brief A special SBBRenderTechnique used in an OGRE environment.
+
+	Instead of rendering to the frame buffer this Technique renders into two render targets at the same time.
+	The firs render target will be used as it were an ordinary backbuffer.
+	The second rendertarget will be used to simulate heat shimmering (offset values will be written to it).
+	The shimmering effect will be achieved with post processing: combining the backbuffer with the first render target using the second render target as uv offset.
+	Just like the spherical billboard techniqeue, this thechnique requires a depth image taken from main camera's viewpoint.	
 */
 class OgreFireRenderTechnique : public OgreRenderTechnique,
@@ -52,8 +58,11 @@
 	//inherited
 	virtual void update(unsigned long frameNum);
-
+	//inherited
 	void  preRenderTargetUpdate (const RenderTargetEvent &evt);
+	//inherited
 	void  postRenderTargetUpdate (const RenderTargetEvent &evt);
+	//inherited
 	bool  frameEnded (const FrameEvent &evt);
+	//inherited
 	void preAllUpdates();
 	
@@ -67,5 +76,7 @@
 };
 
-
+/**
+	@brief RenderTechniqueFactory to create OgreFireRenderTechnique instances.
+*/
 class OgreFireRenderTechniqueFactory : public RenderTechniqueFactory
 {
Index: /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp	(revision 2200)
+++ /GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp	(revision 2240)
@@ -84,5 +84,5 @@
 	phaseTextureSize = 256;
 	useLISPSM = false;
-	useVSM = false;
+//	useVSM = false;
 	blurSM = false;
 	focusingSM = true;
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/SharedRuns.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/SharedRuns.h	(revision 2189)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/SharedRuns.h	(revision 2240)
@@ -10,5 +10,5 @@
 
 	If a new class is derived from RenderingRun, this enum should be extended.
-	This types are used in messages sent when a run changes or updates.
+	These types are used in messages sent when a run changes or updates.
 */
 enum RenderingRunType
@@ -47,5 +47,5 @@
 	Technique resources which can be shared between several techniques or objects are managed by SharedRuns.
 	These SharedRuns store the shared resources. They also act like nodes of a binary tree, as separate 
-	SharedRuns can also be joined if for example the objects for witch they store resources are close enough so
+	SharedRuns can also be joined if for example the objects for which they store resources are close enough so
 	even one shared resources is enough for the given objects.
 */
@@ -57,5 +57,13 @@
 	*/
 	SharedRuns(void);	
-	
+	/**
+		&brief Returns true if this shared run object has a given run type.
+
+		It returns true if the shared run object node has a rendering run object with the given type.
+		It checks only the current node of the tree, no children nodes are searched for existing rendering runs.
+
+		@param runType enum, type of the RenderingRun to search for
+		@return search result
+	*/
 	virtual bool hasOwnRun(RenderingRunType runType) = 0;
     /**
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/IlluminationManager.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/IlluminationManager.h	(revision 780)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/IlluminationManager.h	(revision 2240)
@@ -6,6 +6,5 @@
 	@brief Base abstract class of the illumination manager.
 
-	The illumination manager is responsible for refreshing rendering techniques connected to visible renderables, 
-	and to render the scene with these updated resources.
+	The illumination manager is responsible for refreshing rendering techniques connected to visible renderables.
 	It also has the resposibility to manage shared runs, to join and split them if needed.
 */
@@ -20,6 +19,6 @@
 		@brief The function to be called to render one frame.
 
-		This is the main refreshing function. It seasrches for visible objects, manages shared runs, updates render techniques and 
-		finally renders the scene to framebuffer.
+		This is the main refreshing function. It seasrches for visible objects, manages shared runs and updates render techniques.
+		It should be called after all animations are done and before rendering to the frame buffer.
 
 		@param frameNumber current framenumber
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ChildPSystemRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ChildPSystemRenderingRun.h	(revision 1055)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ChildPSystemRenderingRun.h	(revision 2240)
@@ -3,9 +3,7 @@
 
 /**
-	@brief Base abstract class that defines a rendering process of a photon hit map.
+	@brief Base abstract class that defines a rendering process of a particle system impostor image.
 
-	A photon hit map stores the directions where the incoming photons are refracted by a caustic emitter object.
-	One pixel of the photon map represents one photon hit, hte direction is encoded in the RGB channels.
-	If  the alpha channel has zero value, the hit is invalid.
+	This impostor can be used as a texture for ither particle systems. This rendering method is called hieararchical particle system.
 */
 class ChildPsystemRenderingRun : virtual public RenderingRun
@@ -15,4 +13,6 @@
 		@brief Constructor.
 
+		@param resolution               the resolution of the impostor image
+		@param perspectiveRendering		sets if the impostor should be rendered with a perspective projection or orthogonal
 		@param startFrame				adds an offset to the current frame number to help evenly distribute updates between frames
 		@param updateInterval			update frequency
@@ -31,12 +31,15 @@
 protected:
 	/**
-		@brief the resolution of the photonmap texture that was created by this run
+		@brief the resolution of the impostor image
 	*/
 	unsigned int resolution;
+	/**
+		@brief sets if the impostor should be rendered with a perspective projection or orthogonal
+	*/
 	bool perspectiveRendering;
     //inherited
 	virtual void updateFrame(unsigned long frameNum) = 0;	
 	/**
-		@brief Creates a photon hit map.
+		@brief Creates an impostor texture that can be used as a rendertarget during impostor rendering.
 	*/
 	virtual inline void createImpostorTexture() = 0;	
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ReducedCubeMapRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ReducedCubeMapRenderingRun.h	(revision 780)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ReducedCubeMapRenderingRun.h	(revision 2240)
@@ -3,7 +3,7 @@
 
 /**
-	@brief Base abstract class that defines a rendering process of a reduced sized color-cubemap.
+	@brief Base abstract class that defines a rendering process of a downsampled color-cubemap.
 
-	The resulting cubemap is a lower resolution variation of a color cube map. It is created with averaging the original cubemap.
+	The resulting cubemap is a lower resolution variation of the color cube map. It is created with averaging the original cubemap.
 	The lower resolution cubemap can be convolved faster and can efficiently be used in effects like diffuse reflection.
 */
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/SceneCameraDepthRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/SceneCameraDepthRenderingRun.h	(revision 874)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/SceneCameraDepthRenderingRun.h	(revision 2240)
@@ -3,5 +3,5 @@
 
 /**
-	@brief Base abstract class that defines a rendering process that creates depth map.
+	@brief Base abstract class that defines a rendering process that creates depth map fro the camera.
 
 	The depth map stores the scene's camera space z coordinates (rendered from the player's view).
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/CubeMapRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/CubeMapRenderingRun.h	(revision 1722)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/CubeMapRenderingRun.h	(revision 2240)
@@ -3,7 +3,5 @@
 
 /**
-	@brief Base abstract class that defines a rendering process of a color-cubemap.
-
-	A color cubemap is a cubemap of the colors of the surrounding environment.
+	@brief Base abstract class that defines a rendering process of a cubemap.	
 */
 class CubeMapRenderingRun : virtual public RenderingRun
@@ -21,5 +19,6 @@
 		@param angleTolerance			angle tolerance used in face skip
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame
-		
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map		
 	*/
 	CubeMapRenderingRun(unsigned long startFrame,
@@ -72,5 +71,11 @@
 	*/
 	float angleTolerance;
+	/**
+		@brief sets if the object should be rendered to the cube map
+	*/
 	bool renderSelf;
+	/**
+		@brief sets if the environment should be rendered to the cube map
+	*/
 	bool renderEnvironment;
 
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/LightVolumeRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/LightVolumeRenderingRun.h	(revision 1425)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/LightVolumeRenderingRun.h	(revision 2240)
@@ -3,9 +3,9 @@
 
 /**
-	@brief Base abstract class that defines a rendering process of a photon hit map.
+	@brief Base abstract class that defines a rendering process of a light volume texture.
 
-	A photon hit map stores the directions where the incoming photons are refracted by a caustic emitter object.
-	One pixel of the photon map represents one photon hit, hte direction is encoded in the RGB channels.
-	If  the alpha channel has zero value, the hit is invalid.
+	Light volumes are used when self shadowing of particle systems should be simulated.
+	Each layer of the volume represents the amount of transmitted light. The current implementation uses four grayscale layers, 
+	and places these layers to the four channel of the light volume texture.
 */
 class LightVolumeRenderingRun : virtual public RenderingRun
@@ -17,4 +17,6 @@
 		@param startFrame				adds an offset to the current frame number to help evenly distribute updates between frames
 		@param updateInterval			update frequency
+		@param resolution				the resolution of the light volume texture
+		@param textureDepth				the number of layers (should be set to 1)
 	*/
 	LightVolumeRenderingRun(unsigned long startFrame,
@@ -32,11 +34,14 @@
 	virtual void updateFrame(unsigned long frameNum) = 0;	
 	/**
-		@brief Creates a photon hit map.
+		@brief Creates a light volume map.
 	*/
 	virtual inline void createLightVolumeMap() = 0;	
 	/**
-		@brief the resolution of the photonmap texture that was created by this run
+		@brief the resolution of the light volume map
 	*/
 	unsigned int resolution;
+	/**
+		@brief number of layers (should be 1)
+	*/
 	unsigned int textureDepth;
 
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/PhaseTextureRenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/PhaseTextureRenderingRun.h	(revision 1425)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/PhaseTextureRenderingRun.h	(revision 2240)
@@ -3,7 +3,11 @@
 
 /**
-	@brief Base abstract class that defines a rendering process that creates depth map.
+	@brief Base abstract class that defines a rendering process that creates phase texture.
 
-	The depth map stores the scene's camera space z coordinates (rendered from the player's view).
+	The phase texture can be used as a look-up table during rendering of partcipating media.
+	If the texture is created once it can be saved and reused, so this run is usually not needed, only runned once.
+	This texture is addressed as the following: the u coordinates represents the symmetry of scattering 
+	(negative if backward scattering, positive if forward scattering and zero if equally scaterring in the forward and in the backward directions)
+	; the v coordinates represent the cosine of the angle between the incoming and outgoing directions.
 */
 class PhaseTextureRenderingRun : virtual public RenderingRun
@@ -12,4 +16,7 @@
 	/**
 		@brief Constructor.
+
+		@param resolutionX	width of the texture
+		@param resolutionY	height of the texture
 	*/
 	PhaseTextureRenderingRun(unsigned int resolutionX,
@@ -22,5 +29,11 @@
 
 protected:
+	/**
+		@brief width of the texture
+	*/
     unsigned int resolutionX;
+	/**
+		@brief height of the texture
+	*/
 	unsigned int resolutionY;
 	/**
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/SBBRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/SBBRenderTechnique.h	(revision 780)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/SBBRenderTechnique.h	(revision 2240)
@@ -4,4 +4,6 @@
 /**
 	@brief Base abstract class of rendering a particle system with the spherical billboard method. 	
+
+	This technique only defines that the rendering of the object needs depth information of the scene from the player camera's view.
 */
 class SBBRenderTechnique : virtual public RenderTechnique
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DistanceCubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DistanceCubeMapRenderTechnique.h	(revision 1725)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DistanceCubeMapRenderTechnique.h	(revision 2240)
@@ -21,4 +21,7 @@
 		@param angleTolerance			angle tolerance used in face skip
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map
+		@param layer					the layer of this cubemap
 		@param parentRenderable			the object to operate on
 		@param parentTechniqueGroup		the TechniqueGroup this RenderedTechnique is attached to
@@ -55,13 +58,13 @@
 	
 	/**
-			@brief Called if the changed run is a ColorCubeMapRenderingRun.
+			@brief Called if the changed run is a CubeMapRenderingRun (containing distances of the current layer).
 
-			@param run pointer to the changed ColorCubeMapRenderingRun
+			@param run pointer to the changed CubeMapRenderingRun
 	*/		
 	virtual void distanceCubeMapRunChanged(RenderingRun* run) = 0;
 	/**
-			@brief Called if the changed run is a ColorCubeMapRenderingRun.
+			@brief Called if the changed run is a CubeMapRenderingRun (containing distances of the current layer).
 
-			@param run pointer to the changed ColorCubeMapRenderingRun
+			@param run pointer to the changed CubeMapRenderingRun
 	*/		
 	virtual void distanceCubeMapRunUpdated(RenderingRun* run) = 0;
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/HierarchicalParticleSystemTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/HierarchicalParticleSystemTechnique.h	(revision 1425)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/HierarchicalParticleSystemTechnique.h	(revision 2240)
@@ -3,5 +3,9 @@
 
 /**
-	@brief Base abstract class of rendering a particle system with the spherical billboard method. 	
+	@brief Base abstract class of rendering a hierarchical particle system.
+
+	A hierarchical particle system is a particle system made out of a smaller particle system. 
+	It renders an image of the smaller particle system and multiplies this image to achieve a bigger particle system.
+	This way fewer computation is needed to simulate large number of particles, while the trick is usually unnoticable.
 */
 class HierarchicalParticleSystemTechnique : virtual public RenderTechnique
@@ -11,6 +15,11 @@
 		@brief Constructor.
 
-		@param parentRenderable the object to operate on
-		@param parentTechniqueGroup the TechniqueGroup this RenderedTechnique is attached to
+		@param startFrame				adds an offset to the current frame number to help evenly distribute updates between frames
+		@param impostorUpdateInterval	update frequency of the impostor texture (image of the smaller system)
+		@param impostorResolution		resolution of the impostor texture
+		@param useDistCalc				flag to skip impostor update if object is far away (//not used)
+		@param perspectiveRendering		sets if the impostor should be rendered with a perspective projection or orthogonal
+		@param parentRenderable			the object to operate on
+		@param parentTechniqueGroup		the TechniqueGroup this RenderedTechnique is attached to
 	*/
 	HierarchicalParticleSystemTechnique(
@@ -25,12 +34,19 @@
 	~HierarchicalParticleSystemTechnique();
 
+	//inherited
 	void update(unsigned long frameNum);
-
 	//inherited
 	void runChanged(RenderingRunType runType, RenderingRun* run);
+	//inherited
 	void runUpdated(RenderingRunType runType, RenderingRun* run);
 
 protected:
+	/**
+			@brief update frequency of the impostor texture (image of the smaller system)
+	*/
 	unsigned long impostorUpdateInterval;
+	/**
+			@brief resolution of the impostor texture
+	*/
 	unsigned int impostorResolution;
 	/**
@@ -38,9 +54,29 @@
 	*/
 	unsigned long startFrame;	
+	/**
+			@brief flag to skip impostor update if object is far away (//not used)
+	*/
 	bool useDistCalc;
+	/**
+			@brief sets if the impostor should be rendered with a perspective projection or orthogonal
+	*/
 	bool perspectiveRendering;
+	/**
+			@brief Creates the ChildParticleSystemRenderingRun needed by this technique.
 
+			@return pointer to the ChildParticleSystemRenderingRun created instance
+	*/
 	virtual RenderingRun* createChildPSysRenderingRun()=0;	
+	/**
+			@brief Called if the impostor rendering run changed.
+
+			@param run pointer to the new ChildParticleSystemRenderingRun instance to use
+	*/
 	virtual void impostorChanged(RenderingRun* run) = 0;
+	/**
+			@brief Called if the impostor rendering run is updated.
+
+			@param run pointer to the updated ChildParticleSystemRenderingRu.
+	*/
 	virtual void impostorUpdated(RenderingRun* run) = 0;
 	
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/IllumVolumeRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/IllumVolumeRenderTechnique.h	(revision 1425)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/IllumVolumeRenderTechnique.h	(revision 2240)
@@ -3,5 +3,9 @@
 
 /**
-	@brief Base abstract class of rendering a particle system with the spherical billboard method. 	
+	@brief Base abstract class of rendering a light volume of a particle system. 	
+	
+	Light volumes are used when self shadowing of particle systems should be simulated.
+	Each layer of the volume represents the amount of transmitted light. The current implementation uses four grayscale layers, 
+	and places these layers to the four channel of the light volume texture.
 */
 class IllumVolumeRenderTechnique : virtual public RenderTechnique
@@ -11,6 +15,12 @@
 		@brief Constructor.
 
-		@param parentRenderable the object to operate on
-		@param parentTechniqueGroup the TechniqueGroup this RenderedTechnique is attached to
+		@param startFrame					adds an offset to the current frame number to help evenly distribute updates between frames
+		@param illumVolumeUpdateInterval	the update frequency of the light volume
+		@param illumTextureResolution		the resolution of the light volume texture
+		@param textureDepth					the number of layers to use (should be set to 1)
+		@param useDistCalc					flag to skip updates if the shaded particle system is far away (not used)
+		@param useHierarchicalImpostor		set this flag to true if the particle system is a hierarchical particle system
+		@param parentRenderable				the object to operate on
+		@param parentTechniqueGroup			the TechniqueGroup this RenderedTechnique is attached to
 	*/
 	IllumVolumeRenderTechnique(
@@ -26,13 +36,23 @@
 	~IllumVolumeRenderTechnique();
 
+	//inherited
 	void update(unsigned long frameNum);
-
 	//inherited
 	void runChanged(RenderingRunType runType, RenderingRun* run);
+	//inherited
 	void runUpdated(RenderingRunType runType, RenderingRun* run);
 
 protected:
+	/**
+		@brief the update frequency of the light volume
+	*/
 	unsigned long illumVolumeUpdateInterval;
+	/**
+		@brief the resolution of the light volume texture 
+	*/
 	unsigned int illumTextureResolution;
+	/**
+		@brief the number of layers to use (should be set to 1)
+	*/
 	unsigned int textureDepth;
 	/**
@@ -40,10 +60,38 @@
 	*/
 	unsigned long startFrame;
+	/**
+		@brief flag to skip updates if the shaded particle system is far away (not used) 
+	*/
 	bool useDistCalc;
+	/**
+		@brief set this flag to true if the particle system is a hierarchical particle system 
+	*/
 	bool useHierarchicalImpostor;	
 	
+	/**
+		@brief creates a light volume rendering run needed by this technique
+
+		@return pointer to the created LightVolumeRenderingRun instance
+	*/
 	virtual RenderingRun* createLightVolumeRenderingRun()=0;
+	/**
+		@brief Called if the LightVolumeRenderingRun is chaged
+
+		@param pointer to the new LightVolumeRenderingRun instance to use
+	*/
 	virtual void lightVolumeChanged(RenderingRun* run) = 0;
+	/**
+		@brief Called if the LightVolumeRenderingRun is updated
+
+		@param pointer to the updated LightVolumeRenderingRun instance
+	*/
 	virtual void lightVolumeUpdated(RenderingRun* run) = 0;
+	/**
+		@brief Called if the ChildParticleSystemRenderingRun is chaged
+
+		Only called if this particle system is a hierarchical particle system.
+
+		@param pointer to the new ChildParticleSystemRenderingRun instance to use
+	*/
 	virtual void hierarchicalImpostorUpdated(RenderingRun* run) = 0;
 	
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ColorCubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ColorCubeMapRenderTechnique.h	(revision 1930)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ColorCubeMapRenderTechnique.h	(revision 2240)
@@ -21,4 +21,7 @@
 		@param angleTolerance			angle tolerance used in face skip
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map
+		@param layer					the layer of this cubemap
 		@param parentRenderable			the object to operate on
 		@param parentTechniqueGroup		the TechniqueGroup this RenderedTechnique is attached to
@@ -49,8 +52,19 @@
 	//inherited
 	void runChanged(RenderingRunType runType, RenderingRun* run);
+	//inherited
 	void runUpdated(RenderingRunType runType, RenderingRun* run);
 
 protected:
-	virtual void colorCubeMapRunChanged(RenderingRun* run) = 0;	
+	/**
+		@brief Called if the color cubemap rendering run object changes.
+		
+		@param run pointer to the new rendering run object
+	*/
+	virtual void colorCubeMapRunChanged(RenderingRun* run) = 0;
+	/**
+		@brief Called if the color cubemap rendering run object is updated.
+		
+		@param run pointer to the rendering run object
+	*/
 	virtual void colorCubeMapRunUpdated(RenderingRun* run) = 0;	
 };
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ConvolvedCubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ConvolvedCubeMapRenderTechnique.h	(revision 1722)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ConvolvedCubeMapRenderTechnique.h	(revision 2240)
@@ -24,4 +24,6 @@
 		@param angleTolerance				angle tolerance used in face skip
 		@param updateAllFace				defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param renderSelf				    sets if the object should be rendered to the cube map
+		@param renderEnvironment		    sets if the environment should be rendered to the cube map
 		@param parentRenderable				the object to operate on
 		@param parentTechniqueGroup			the TechniqueGroup this RenderedTechnique is attached to
@@ -54,22 +56,24 @@
 
 protected:
-
+	/**
+		@brief The resolution of the downsampled cubemap created by this run.
+	*/
 	unsigned int reducedCubeMapResolution;
 	/**
-			@brief Called if the changed run is a ColorCubeMapRenderingRun.
+			@brief Called if the changed run is a ReducedCubeMapRenderingRun.
 
-			@param run pointer to the changed ColorCubeMapRenderingRun
+			@param run pointer to the changed ReducedCubeMapRenderingRun
 	*/		
 	virtual void reducedCubeMapRunChanged(RenderingRun* run) = 0;
 	/**
-			@brief Called if the changed run is a ColorCubeMapRenderingRun.
+			@brief Called if the changed run is a CubeMapRenderingRun (containing colors of the environment).
 
-			@param run pointer to the changed ColorCubeMapRenderingRun
+			@param run pointer to the changed CubeMapRenderingRun
 	*/		
 	virtual void colorCubeMapRunChanged(RenderingRun* run) = 0;
 	/**
-			@brief Creates a ColorCubeMapRenderingRun.
+			@brief Creates a ReducedCubeMapRenderingRun.
 
-			@return the new ColorCubeMapRenderingRun instance.
+			@return the new ReducedCubeMapRenderingRun instance.
 	*/
 	virtual RenderingRun* createReducedCubeMapRun() = 0;
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CubeMapRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CubeMapRenderTechnique.h	(revision 1930)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CubeMapRenderTechnique.h	(revision 2240)
@@ -3,7 +3,7 @@
 
 /**
-	@brief Base abstract class of rendering a color cube map. 
+	@brief Base abstract class of rendering a cube map. 
 	
-	This technique defines that the final rendering of an object needs a cubmap of the colors of the surrounding environment.
+	This technique defines that the final rendering of an object needs a cubmap of the surrounding environment and/or the object itself.
 */
 class CubeMapRenderTechnique : virtual public RenderTechnique
@@ -21,4 +21,7 @@
 		@param angleTolerance			angle tolerance used in face skip
 		@param updateAllFace			defines if all cubemap faces should be updated in a frame or only one face per frame
+		@param renderSelf				sets if the object should be rendered to the cube map
+		@param renderEnvironment		sets if the environment should be rendered to the cube map
+		@param layer					the layer of this cubemap
 		@param parentRenderable			the object to operate on
 		@param parentTechniqueGroup		the TechniqueGroup this RenderedTechnique is attached to
@@ -40,5 +43,7 @@
 	~CubeMapRenderTechnique();
 	
+	//inherited
 	void runChanged(RenderingRunType runType, RenderingRun* run);
+	//inherited
 	void runUpdated(RenderingRunType runType, RenderingRun* run);
 
@@ -84,11 +89,41 @@
 	*/
 	unsigned long startFrame;
+	/**
+			@brief Sets if the object should be rendered to the cube map
+	*/
 	bool renderSelf;
+	/**
+			@brief Sets if the environment should be rendered to the cube map
+	*/
 	bool renderEnvironment;
+	/**
+			@brief The layer of the cubemap.
+
+			This extension was created to achieve effect such as multiple reflections and refractions
+			 that require more complete sampling of the scene. 
+			With this extension we can render the environment into several cubemap layers eg. with depth peeling.
+	*/
 	int layer;
+	/**
+			@brief The exact run type of this run (according to the actual layer).
+	*/
 	RenderingRunType cubemapLayer;	
-	
+	/**
+			@brief Creates a CubeMapRenderingRun.
+
+			@return the new CubeMapRenderingRun instance.
+	*/
 	virtual RenderingRun* createCubeMapRun() = 0;
-	virtual void cubeMapRunChanged(RenderingRun* run) = 0;	
+	/**
+			@brief Called if the changed run is a CubeMapRenderingRun.
+
+			@param run pointer to the new CubeMapRenderingRun
+	*/		
+	virtual void cubeMapRunChanged(RenderingRun* run) = 0;
+	/**
+			@brief Called if the updated run is a CubeMapRenderingRun.
+
+			@param run pointer to the updated CubeMapRenderingRun
+	*/		
 	virtual void cubeMapRunUpdated(RenderingRun* run) = 0;
 };
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CausticCasterRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CausticCasterRenderTechnique.h	(revision 949)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CausticCasterRenderTechnique.h	(revision 2240)
@@ -6,5 +6,5 @@
 	
 	This technique defines that the given object needs a caustic photon map and a caustic cubemap.
-	These resources will be updated by caustic recievers.
+	The caustic cube map will be used by caustic recievers.
 */
 class CausticCasterRenderTechnique : virtual public RenderTechnique
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DepthShadowRecieverRenderTechnique.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DepthShadowRecieverRenderTechnique.h	(revision 780)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DepthShadowRecieverRenderTechnique.h	(revision 2240)
@@ -18,7 +18,5 @@
 							TechniqueGroup* parentTechniqueGroup
 							);
-	~DepthShadowRecieverRenderTechnique();
-	
-	
+	~DepthShadowRecieverRenderTechnique();	
 	
 protected:		
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRun.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRun.h	(revision 1722)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRun.h	(revision 2240)
@@ -45,4 +45,11 @@
 	virtual class OgreRenderingRun* asOgreRenderingRun(){return 0;}
 	
+	/**
+		@brief Returns true if two runs can be joined.
+
+		In some cases special requirements should stand to join two runs (even if they have the same type). 
+		Eg.: two caustic cube map generation technique should only be joined if they use the same material 
+		when rendering the caustic cubemap.
+	*/
 	virtual bool canJoin(RenderingRun* run){return true;}
 
@@ -51,4 +58,6 @@
 	/**
 			@brief Returns if this run needs update
+
+			This tipically depends on the upate interval and the starting frame number.
 			
 			@param frameNum current frame number			
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/TechniqueGroup.h
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/TechniqueGroup.h	(revision 1055)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/TechniqueGroup.h	(revision 2240)
@@ -4,5 +4,5 @@
 
 /**
-	@brief Base abstract class for a collection techniques.
+	@brief Base abstract class for a collection of techniques.
 
 	This is a helper class, to collect RenderTechnique instances bound to a single renderable.
@@ -23,5 +23,5 @@
 		Used after creating a new TechniqueGroup.
 
-		@param sharedRuns the SharedRun instance the RenderTechniques will use.
+		@param sharedRuns pointer to the SharedRun instance this RenderTechniques will use.
 	*/
 	void addSharedRun(SharedRuns* sharedRuns){parentSharedRuns = sharedRuns;
@@ -30,5 +30,5 @@
 		@brief Retrieves the shared runs.
 
-		@result the SharedRun instance the RenderTechniques use.
+		@result pointer to the SharedRun instance this RenderTechniques uses.
 	*/
 	SharedRuns* getSharedRuns(){return parentSharedRuns;}
@@ -46,5 +46,5 @@
 	virtual void update(unsigned long frameNum) = 0;
 	/**
-		@brief Called after one of he shared runs changes.
+		@brief Called after one of the rendering runs changes.
 
 		This message will be forwarded to each RenderTechique.
@@ -55,5 +55,5 @@
 	virtual void runChanged(RenderingRunType runType, RenderingRun* run) = 0;
 	/**
-		@brief Called after one of he shared runs updates.
+		@brief Called after one of the rendering runs updates.
 		
 		This message will be forwarded to each RenderTechique.
Index: /GTP/trunk/Lib/Illum/IllumModule/IllumModule/scripts/illummodule.7.10.vcproj
===================================================================
--- /GTP/trunk/Lib/Illum/IllumModule/IllumModule/scripts/illummodule.7.10.vcproj	(revision 2027)
+++ /GTP/trunk/Lib/Illum/IllumModule/IllumModule/scripts/illummodule.7.10.vcproj	(revision 2240)
@@ -285,14 +285,4 @@
 				</File>
 			</Filter>
-			<Filter
-				Name="Resource Files"
-				Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
-				<File
-					RelativePath="..\..\..\..\..\..\..\EGDemoGame\Media\materials\scripts\car.material">
-				</File>
-				<File
-					RelativePath="..\..\..\..\..\..\..\EGDemoGame\Media\materials\programs\CarReflections.hlsl">
-				</File>
-			</Filter>
 		</Filter>
 	</Files>
