source: GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRun.h @ 1722

#pragma once

/**
        @brief Base class for a computation module.

        A run typically - but not necessarily or exclusively - consists of a series of rendering passes.
        A run is alway created to compute some kind of resource for a RenderTechnique. The type of the resource 
        depends on the type of the run (typically it is a Texture). Runs can be attached to only one Technique 
        (if only one of the Techniques attached to a Renderable can use this resource, and each Renderable requires a unique one),
        or can be shared between several Techniques and Renderables (for example a cube-map). 
        Runs are updated only once in a frame, but not necessary in each frame. 
*/
class RenderingRun
{       
public:
        
        /**
                @brief Constructor.
                
                @param startFrame                       adds an offset to the current frame number to help evenly distribute updates between frames
                @param updateInterval           photon map update frequency             
        */
        RenderingRun(unsigned long startFrame,
                                        unsigned long updateInterval);

        /**
                @brief Calls updateFrame() if the run needs update according to its starting frame and update interval and has not been allready updated in this frame.                 
        */
        bool update(unsigned long frameNum)
        {
                bool needupdate = needUpdate(frameNum);
                if(needupdate)
                {
                        updateFrame(frameNum);
                        lastupdated = frameNum;                 
                }
                return needupdate;
        }
        
        /**
                @brief Conversion to OgreRenderRun.

                This function is needed because of virtual inheritance.
        */
        virtual class OgreRenderingRun* asOgreRenderingRun(){return 0;}
        
        virtual bool canJoin(RenderingRun* run){return true;}

protected:

        /**
                        @brief Returns if this run needs update
                        
                        @param frameNum current frame number                    
                */
                virtual bool needUpdate(unsigned long frameNum )
                {
                        if(frameNum == lastupdated )
                                return false;                   

                        if ( updateInterval == 0 ) //update only once
                        {
                                if( lastupdated == 0)
                                {
                                        return true;
                                }
                                return false;
                        }
                        else
                        {
                                return ((frameNum - startFrame) % updateInterval == 0);
                        }
                }

        /**
                @brief The number of the last frame this run was updated.
        */
        unsigned long lastupdated;
        /**
                @brief The number of the frame this run should be updated first.
        */
        unsigned long startFrame;
        /**
                @brief Refresh frequency in frames.
        */
        unsigned long updateInterval;
        /**
                @brief This function does the actual update in a frame.
                
                @param frameNum current frame number
        */
        virtual void updateFrame(unsigned long frameNum){}
        
};