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

#pragma once
#include "CubeMapRenderTechnique.h"

/**
        @brief Base abstract class __declspec( dllexport ) of rendering a color cube map. 
        
        This technique defines that the final rendering of an object needs a cubmap of the colors of the surrounding environment.
*/
class __declspec( dllexport ) ColorCubeMapRenderTechnique : virtual public CubeMapRenderTechnique
{
public:
        /**
                @brief Constructor.

                @param startFrame                               adds an offset to the current frame number to help evenly distribute updates between frames
                @param cubeMapUpdateInterval    update frequency
                @param cubeMapResolution                color cubemap resolution
                @param useDistCalc                              flag to skip cube face update if object is far away
                @param useFaceAngleCalc                 flag to skip cube face update if face is neglible
                @param distTolerance                    distance tolerance used in face skip
                @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
        */
        ColorCubeMapRenderTechnique( unsigned long startFrame,
                                                                unsigned long cubeMapUpdateInterval,
                                                                unsigned int cubeMapResolution,
                                                                bool useDistCalc,
                                                                bool useFaceAngleCalc,
                                                                float distTolerance,
                                                                float angleTolerance,
                                                                bool updateAllFace,
                                                                bool renderSelf,
                                                                bool renderEnvironment,
                                                                int layer,
                                                                ElementaryRenderable* parentRenderable,
                                                                TechniqueGroup* parentTechniqueGroup
                                                                );
        virtual ~ColorCubeMapRenderTechnique();
        
        /**
                        @brief Updates the resources in the given frame.

                        @param frameNum the actual framenumber
        */
        virtual void update(unsigned long frameNum);

        //inherited
        void runChanged(RenderingRunType runType, RenderingRun* run);
        //inherited
        void runUpdated(RenderingRunType runType, RenderingRun* run);

protected:
        /**
                @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;     
};