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

#pragma once 
#include "ElementaryRenderable.h"
#include "SharedRuns.h"

class __declspec( dllexport ) TechniqueGroup;

/**
        @brief Base class __declspec( dllexport ) for a rendering technique.

        A RenderTechnique gives a  description about how to render an object, and what kind of resources are needed to do this.
        A RenderTechnique does not define the whole process of rendering only one property of the display, 
        example: this object will need a cubemap or this object is going to be a caustic caster. 
        RenderTechniques usually operate on one pass of the rendering, and bind some resources to this pass 
        (for example it can bind a texture or cubemap tho the given pass).

        RenderTechniques are always bound to a Renderable, and a SharedRuns object. The Renderable defines the object to
        operate on. SharedRuns is to register RenderingRuns which can be shared between other RenderTechniques 
        (example: a cubemap can be used by other techniques too, or even more than one object can share a single cubemap).
*/
class __declspec( dllexport ) RenderTechnique
{
        public:
                /**
                        @brief Constructor.

                        @param parentRenderable the object to operate on
                        @param parentTechniqueGroup the TechniqueGroup this RenderedTechnique is attached to
                */
                RenderTechnique(
                                                ElementaryRenderable* parentRenderable,
                                                TechniqueGroup* parentTechniqueGroup);
                
                /**
                        @brief Updates the resources in the given frame.
                        
                        A RenderTechnique is usually need some resources from several runs, so these runs will be updated.
                        
                        @param frameNum the actual framenumber
                */
                virtual void update(unsigned long frameNum){}
                /**
                        @brief Called after one of he shared runs changes.
                        
                        @param runType enum describing the type of the changed run
                        @param run pointer to the changed RenderingRun
                */
                virtual void runChanged(RenderingRunType runType, RenderingRun* run){}
                /**
                        @brief Called after one of he shared runs updates.
                        
                        @param runType enum describing the type of the updated run
                        @param run pointer to the updated RenderingRun
                */
                virtual void runUpdated(RenderingRunType runType, RenderingRun* run){}
                /**
                        @brief Conversion to OgreRenderTechnique.

                        This function is needed because of virtual inheritance.
                */
                virtual class __declspec( dllexport ) OgreRenderTechnique* asOgreRenderTechnique(){return 0;}
                /**
                        @brief Retrieves the renderable this technique operates on.
                */
                ElementaryRenderable* getParentRenderable(){return parentRenderable;}
                                
        protected:

                /**
                        @brief The renderable this technique operates on.
                */
                ElementaryRenderable* parentRenderable;
                /**
                        @brief The TechniqueGroup this RenderedTechnique is attached to.
                */
                TechniqueGroup* parentTechniqueGroup;
                /**
                        @brief The SharedRuns this RenderedTechnique is attached to.
                */
                SharedRuns* sharedRuns; 
                
                
                
};