source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/precompiled/include/IllumModule/RenderTechniques/IllumVolumeRenderTechnique.h @ 3255

#pragma once
#include "RenderTechnique.h"

/**
        @brief Base abstract class __declspec( dllexport ) 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 __declspec( dllexport ) IllumVolumeRenderTechnique : virtual public RenderTechnique
{
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 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(
                                                        unsigned long startFrame,
                                                        unsigned long illumVolumeUpdateInterval,
                                                        unsigned int illumTextureResolution,
                                                        unsigned int textureDepth,
                                                        bool useDistCalc,
                                                        bool useHierarchicalImpostor,   
                                                        ElementaryRenderable* parentRenderable,
                                                        TechniqueGroup* parentTechniqueGroup
                                                        );
        virtual ~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;
        /**
                        @brief offset in frame number used during update
        */
        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;
        
};