Changeset 2240


Ignore:
Timestamp:
03/13/07 09:27:17 (17 years ago)
Author:
szirmay
Message:
 
Location:
GTP/trunk/Lib/Illum/IllumModule
Files:
40 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/IlluminationManager.h

    r780 r2240  
    66        @brief Base abstract class of the illumination manager. 
    77 
    8         The illumination manager is responsible for refreshing rendering techniques connected to visible renderables,  
    9         and to render the scene with these updated resources. 
     8        The illumination manager is responsible for refreshing rendering techniques connected to visible renderables. 
    109        It also has the resposibility to manage shared runs, to join and split them if needed. 
    1110*/ 
    … …  
    2019                @brief The function to be called to render one frame. 
    2120 
    22                 This is the main refreshing function. It seasrches for visible objects, manages shared runs, updates render techniques and  
    23                 finally renders the scene to framebuffer. 
     21                This is the main refreshing function. It seasrches for visible objects, manages shared runs and updates render techniques. 
     22                It should be called after all animations are done and before rendering to the frame buffer. 
    2423 
    2524                @param frameNumber current framenumber 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CausticCasterRenderTechnique.h

    r949 r2240  
    66         
    77        This technique defines that the given object needs a caustic photon map and a caustic cubemap. 
    8         These resources will be updated by caustic recievers. 
     8        The caustic cube map will be used by caustic recievers. 
    99*/ 
    1010class CausticCasterRenderTechnique : virtual public RenderTechnique 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ColorCubeMapRenderTechnique.h

    r1930 r2240  
    2121                @param angleTolerance                   angle tolerance used in face skip 
    2222                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame 
     23                @param renderSelf                               sets if the object should be rendered to the cube map 
     24                @param renderEnvironment                sets if the environment should be rendered to the cube map 
     25                @param layer                                    the layer of this cubemap 
    2326                @param parentRenderable                 the object to operate on 
    2427                @param parentTechniqueGroup             the TechniqueGroup this RenderedTechnique is attached to 
    … …  
    4952        //inherited 
    5053        void runChanged(RenderingRunType runType, RenderingRun* run); 
     54        //inherited 
    5155        void runUpdated(RenderingRunType runType, RenderingRun* run); 
    5256 
    5357protected: 
    54         virtual void colorCubeMapRunChanged(RenderingRun* run) = 0;      
     58        /** 
     59                @brief Called if the color cubemap rendering run object changes. 
     60                 
     61                @param run pointer to the new rendering run object 
     62        */ 
     63        virtual void colorCubeMapRunChanged(RenderingRun* run) = 0; 
     64        /** 
     65                @brief Called if the color cubemap rendering run object is updated. 
     66                 
     67                @param run pointer to the rendering run object 
     68        */ 
    5569        virtual void colorCubeMapRunUpdated(RenderingRun* run) = 0;      
    5670}; 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/ConvolvedCubeMapRenderTechnique.h

    r1722 r2240  
    2424                @param angleTolerance                           angle tolerance used in face skip 
    2525                @param updateAllFace                            defines if all cubemap faces should be updated in a frame or only one face per frame 
     26                @param renderSelf                                   sets if the object should be rendered to the cube map 
     27                @param renderEnvironment                    sets if the environment should be rendered to the cube map 
    2628                @param parentRenderable                         the object to operate on 
    2729                @param parentTechniqueGroup                     the TechniqueGroup this RenderedTechnique is attached to 
    … …  
    5456 
    5557protected: 
    56  
     58        /** 
     59                @brief The resolution of the downsampled cubemap created by this run. 
     60        */ 
    5761        unsigned int reducedCubeMapResolution; 
    5862        /** 
    59                         @brief Called if the changed run is a ColorCubeMapRenderingRun. 
     63                        @brief Called if the changed run is a ReducedCubeMapRenderingRun. 
    6064 
    61                         @param run pointer to the changed ColorCubeMapRenderingRun 
     65                        @param run pointer to the changed ReducedCubeMapRenderingRun 
    6266        */               
    6367        virtual void reducedCubeMapRunChanged(RenderingRun* run) = 0; 
    6468        /** 
    65                         @brief Called if the changed run is a ColorCubeMapRenderingRun. 
     69                        @brief Called if the changed run is a CubeMapRenderingRun (containing colors of the environment). 
    6670 
    67                         @param run pointer to the changed ColorCubeMapRenderingRun 
     71                        @param run pointer to the changed CubeMapRenderingRun 
    6872        */               
    6973        virtual void colorCubeMapRunChanged(RenderingRun* run) = 0; 
    7074        /** 
    71                         @brief Creates a ColorCubeMapRenderingRun. 
     75                        @brief Creates a ReducedCubeMapRenderingRun. 
    7276 
    73                         @return the new ColorCubeMapRenderingRun instance. 
     77                        @return the new ReducedCubeMapRenderingRun instance. 
    7478        */ 
    7579        virtual RenderingRun* createReducedCubeMapRun() = 0; 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/CubeMapRenderTechnique.h

    r1930 r2240  
    33 
    44/** 
    5         @brief Base abstract class of rendering a color cube map.  
     5        @brief Base abstract class of rendering a cube map.  
    66         
    7         This technique defines that the final rendering of an object needs a cubmap of the colors of the surrounding environment. 
     7        This technique defines that the final rendering of an object needs a cubmap of the surrounding environment and/or the object itself. 
    88*/ 
    99class CubeMapRenderTechnique : virtual public RenderTechnique 
    … …  
    2121                @param angleTolerance                   angle tolerance used in face skip 
    2222                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame 
     23                @param renderSelf                               sets if the object should be rendered to the cube map 
     24                @param renderEnvironment                sets if the environment should be rendered to the cube map 
     25                @param layer                                    the layer of this cubemap 
    2326                @param parentRenderable                 the object to operate on 
    2427                @param parentTechniqueGroup             the TechniqueGroup this RenderedTechnique is attached to 
    … …  
    4043        ~CubeMapRenderTechnique(); 
    4144         
     45        //inherited 
    4246        void runChanged(RenderingRunType runType, RenderingRun* run); 
     47        //inherited 
    4348        void runUpdated(RenderingRunType runType, RenderingRun* run); 
    4449 
    … …  
    8489        */ 
    8590        unsigned long startFrame; 
     91        /** 
     92                        @brief Sets if the object should be rendered to the cube map 
     93        */ 
    8694        bool renderSelf; 
     95        /** 
     96                        @brief Sets if the environment should be rendered to the cube map 
     97        */ 
    8798        bool renderEnvironment; 
     99        /** 
     100                        @brief The layer of the cubemap. 
     101 
     102                        This extension was created to achieve effect such as multiple reflections and refractions 
     103                         that require more complete sampling of the scene.  
     104                        With this extension we can render the environment into several cubemap layers eg. with depth peeling. 
     105        */ 
    88106        int layer; 
     107        /** 
     108                        @brief The exact run type of this run (according to the actual layer). 
     109        */ 
    89110        RenderingRunType cubemapLayer;   
    90          
     111        /** 
     112                        @brief Creates a CubeMapRenderingRun. 
     113 
     114                        @return the new CubeMapRenderingRun instance. 
     115        */ 
    91116        virtual RenderingRun* createCubeMapRun() = 0; 
    92         virtual void cubeMapRunChanged(RenderingRun* run) = 0;   
     117        /** 
     118                        @brief Called if the changed run is a CubeMapRenderingRun. 
     119 
     120                        @param run pointer to the new CubeMapRenderingRun 
     121        */               
     122        virtual void cubeMapRunChanged(RenderingRun* run) = 0; 
     123        /** 
     124                        @brief Called if the updated run is a CubeMapRenderingRun. 
     125 
     126                        @param run pointer to the updated CubeMapRenderingRun 
     127        */               
    93128        virtual void cubeMapRunUpdated(RenderingRun* run) = 0; 
    94129}; 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DepthShadowRecieverRenderTechnique.h

    r780 r2240  
    1818                                                        TechniqueGroup* parentTechniqueGroup 
    1919                                                        ); 
    20         ~DepthShadowRecieverRenderTechnique(); 
    21          
    22          
     20        ~DepthShadowRecieverRenderTechnique();   
    2321         
    2422protected:               

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/DistanceCubeMapRenderTechnique.h

    r1725 r2240  
    2121                @param angleTolerance                   angle tolerance used in face skip 
    2222                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame 
     23                @param renderSelf                               sets if the object should be rendered to the cube map 
     24                @param renderEnvironment                sets if the environment should be rendered to the cube map 
     25                @param layer                                    the layer of this cubemap 
    2326                @param parentRenderable                 the object to operate on 
    2427                @param parentTechniqueGroup             the TechniqueGroup this RenderedTechnique is attached to 
    … …  
    5558         
    5659        /** 
    57                         @brief Called if the changed run is a ColorCubeMapRenderingRun. 
     60                        @brief Called if the changed run is a CubeMapRenderingRun (containing distances of the current layer). 
    5861 
    59                         @param run pointer to the changed ColorCubeMapRenderingRun 
     62                        @param run pointer to the changed CubeMapRenderingRun 
    6063        */               
    6164        virtual void distanceCubeMapRunChanged(RenderingRun* run) = 0; 
    6265        /** 
    63                         @brief Called if the changed run is a ColorCubeMapRenderingRun. 
     66                        @brief Called if the changed run is a CubeMapRenderingRun (containing distances of the current layer). 
    6467 
    65                         @param run pointer to the changed ColorCubeMapRenderingRun 
     68                        @param run pointer to the changed CubeMapRenderingRun 
    6669        */               
    6770        virtual void distanceCubeMapRunUpdated(RenderingRun* run) = 0; 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/HierarchicalParticleSystemTechnique.h

    r1425 r2240  
    33 
    44/** 
    5         @brief Base abstract class of rendering a particle system with the spherical billboard method.   
     5        @brief Base abstract class of rendering a hierarchical particle system. 
     6 
     7        A hierarchical particle system is a particle system made out of a smaller particle system.  
     8        It renders an image of the smaller particle system and multiplies this image to achieve a bigger particle system. 
     9        This way fewer computation is needed to simulate large number of particles, while the trick is usually unnoticable. 
    610*/ 
    711class HierarchicalParticleSystemTechnique : virtual public RenderTechnique 
    … …  
    1115                @brief Constructor. 
    1216 
    13                 @param parentRenderable the object to operate on 
    14                 @param parentTechniqueGroup the TechniqueGroup this RenderedTechnique is attached to 
     17                @param startFrame                               adds an offset to the current frame number to help evenly distribute updates between frames 
     18                @param impostorUpdateInterval   update frequency of the impostor texture (image of the smaller system) 
     19                @param impostorResolution               resolution of the impostor texture 
     20                @param useDistCalc                              flag to skip impostor update if object is far away (//not used) 
     21                @param perspectiveRendering             sets if the impostor should be rendered with a perspective projection or orthogonal 
     22                @param parentRenderable                 the object to operate on 
     23                @param parentTechniqueGroup             the TechniqueGroup this RenderedTechnique is attached to 
    1524        */ 
    1625        HierarchicalParticleSystemTechnique( 
    … …  
    2534        ~HierarchicalParticleSystemTechnique(); 
    2635 
     36        //inherited 
    2737        void update(unsigned long frameNum); 
    28  
    2938        //inherited 
    3039        void runChanged(RenderingRunType runType, RenderingRun* run); 
     40        //inherited 
    3141        void runUpdated(RenderingRunType runType, RenderingRun* run); 
    3242 
    3343protected: 
     44        /** 
     45                        @brief update frequency of the impostor texture (image of the smaller system) 
     46        */ 
    3447        unsigned long impostorUpdateInterval; 
     48        /** 
     49                        @brief resolution of the impostor texture 
     50        */ 
    3551        unsigned int impostorResolution; 
    3652        /** 
    … …  
    3854        */ 
    3955        unsigned long startFrame;        
     56        /** 
     57                        @brief flag to skip impostor update if object is far away (//not used) 
     58        */ 
    4059        bool useDistCalc; 
     60        /** 
     61                        @brief sets if the impostor should be rendered with a perspective projection or orthogonal 
     62        */ 
    4163        bool perspectiveRendering; 
     64        /** 
     65                        @brief Creates the ChildParticleSystemRenderingRun needed by this technique. 
    4266 
     67                        @return pointer to the ChildParticleSystemRenderingRun created instance 
     68        */ 
    4369        virtual RenderingRun* createChildPSysRenderingRun()=0;   
     70        /** 
     71                        @brief Called if the impostor rendering run changed. 
     72 
     73                        @param run pointer to the new ChildParticleSystemRenderingRun instance to use 
     74        */ 
    4475        virtual void impostorChanged(RenderingRun* run) = 0; 
     76        /** 
     77                        @brief Called if the impostor rendering run is updated. 
     78 
     79                        @param run pointer to the updated ChildParticleSystemRenderingRu. 
     80        */ 
    4581        virtual void impostorUpdated(RenderingRun* run) = 0; 
    4682         

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/IllumVolumeRenderTechnique.h

    r1425 r2240  
    33 
    44/** 
    5         @brief Base abstract class of rendering a particle system with the spherical billboard method.   
     5        @brief Base abstract class of rendering a light volume of a particle system.     
     6         
     7        Light volumes are used when self shadowing of particle systems should be simulated. 
     8        Each layer of the volume represents the amount of transmitted light. The current implementation uses four grayscale layers,  
     9        and places these layers to the four channel of the light volume texture. 
    610*/ 
    711class IllumVolumeRenderTechnique : virtual public RenderTechnique 
    … …  
    1115                @brief Constructor. 
    1216 
    13                 @param parentRenderable the object to operate on 
    14                 @param parentTechniqueGroup the TechniqueGroup this RenderedTechnique is attached to 
     17                @param startFrame                                       adds an offset to the current frame number to help evenly distribute updates between frames 
     18                @param illumVolumeUpdateInterval        the update frequency of the light volume 
     19                @param illumTextureResolution           the resolution of the light volume texture 
     20                @param textureDepth                                     the number of layers to use (should be set to 1) 
     21                @param useDistCalc                                      flag to skip updates if the shaded particle system is far away (not used) 
     22                @param useHierarchicalImpostor          set this flag to true if the particle system is a hierarchical particle system 
     23                @param parentRenderable                         the object to operate on 
     24                @param parentTechniqueGroup                     the TechniqueGroup this RenderedTechnique is attached to 
    1525        */ 
    1626        IllumVolumeRenderTechnique( 
    … …  
    2636        ~IllumVolumeRenderTechnique(); 
    2737 
     38        //inherited 
    2839        void update(unsigned long frameNum); 
    29  
    3040        //inherited 
    3141        void runChanged(RenderingRunType runType, RenderingRun* run); 
     42        //inherited 
    3243        void runUpdated(RenderingRunType runType, RenderingRun* run); 
    3344 
    3445protected: 
     46        /** 
     47                @brief the update frequency of the light volume 
     48        */ 
    3549        unsigned long illumVolumeUpdateInterval; 
     50        /** 
     51                @brief the resolution of the light volume texture  
     52        */ 
    3653        unsigned int illumTextureResolution; 
     54        /** 
     55                @brief the number of layers to use (should be set to 1) 
     56        */ 
    3757        unsigned int textureDepth; 
    3858        /** 
    … …  
    4060        */ 
    4161        unsigned long startFrame; 
     62        /** 
     63                @brief flag to skip updates if the shaded particle system is far away (not used)  
     64        */ 
    4265        bool useDistCalc; 
     66        /** 
     67                @brief set this flag to true if the particle system is a hierarchical particle system  
     68        */ 
    4369        bool useHierarchicalImpostor;    
    4470         
     71        /** 
     72                @brief creates a light volume rendering run needed by this technique 
     73 
     74                @return pointer to the created LightVolumeRenderingRun instance 
     75        */ 
    4576        virtual RenderingRun* createLightVolumeRenderingRun()=0; 
     77        /** 
     78                @brief Called if the LightVolumeRenderingRun is chaged 
     79 
     80                @param pointer to the new LightVolumeRenderingRun instance to use 
     81        */ 
    4682        virtual void lightVolumeChanged(RenderingRun* run) = 0; 
     83        /** 
     84                @brief Called if the LightVolumeRenderingRun is updated 
     85 
     86                @param pointer to the updated LightVolumeRenderingRun instance 
     87        */ 
    4788        virtual void lightVolumeUpdated(RenderingRun* run) = 0; 
     89        /** 
     90                @brief Called if the ChildParticleSystemRenderingRun is chaged 
     91 
     92                Only called if this particle system is a hierarchical particle system. 
     93 
     94                @param pointer to the new ChildParticleSystemRenderingRun instance to use 
     95        */ 
    4896        virtual void hierarchicalImpostorUpdated(RenderingRun* run) = 0; 
    4997         

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderTechniques/SBBRenderTechnique.h

    r780 r2240  
    44/** 
    55        @brief Base abstract class of rendering a particle system with the spherical billboard method.   
     6 
     7        This technique only defines that the rendering of the object needs depth information of the scene from the player camera's view. 
    68*/ 
    79class SBBRenderTechnique : virtual public RenderTechnique 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRun.h

    r1722 r2240  
    4545        virtual class OgreRenderingRun* asOgreRenderingRun(){return 0;} 
    4646         
     47        /** 
     48                @brief Returns true if two runs can be joined. 
     49 
     50                In some cases special requirements should stand to join two runs (even if they have the same type).  
     51                Eg.: two caustic cube map generation technique should only be joined if they use the same material  
     52                when rendering the caustic cubemap. 
     53        */ 
    4754        virtual bool canJoin(RenderingRun* run){return true;} 
    4855 
    … …  
    5158        /** 
    5259                        @brief Returns if this run needs update 
     60 
     61                        This tipically depends on the upate interval and the starting frame number. 
    5362                         
    5463                        @param frameNum current frame number                     

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ChildPSystemRenderingRun.h

    r1055 r2240  
    33 
    44/** 
    5         @brief Base abstract class that defines a rendering process of a photon hit map. 
     5        @brief Base abstract class that defines a rendering process of a particle system impostor image. 
    66 
    7         A photon hit map stores the directions where the incoming photons are refracted by a caustic emitter object. 
    8         One pixel of the photon map represents one photon hit, hte direction is encoded in the RGB channels. 
    9         If  the alpha channel has zero value, the hit is invalid. 
     7        This impostor can be used as a texture for ither particle systems. This rendering method is called hieararchical particle system. 
    108*/ 
    119class ChildPsystemRenderingRun : virtual public RenderingRun 
    … …  
    1513                @brief Constructor. 
    1614 
     15                @param resolution               the resolution of the impostor image 
     16                @param perspectiveRendering             sets if the impostor should be rendered with a perspective projection or orthogonal 
    1717                @param startFrame                               adds an offset to the current frame number to help evenly distribute updates between frames 
    1818                @param updateInterval                   update frequency 
    … …  
    3131protected: 
    3232        /** 
    33                 @brief the resolution of the photonmap texture that was created by this run 
     33                @brief the resolution of the impostor image 
    3434        */ 
    3535        unsigned int resolution; 
     36        /** 
     37                @brief sets if the impostor should be rendered with a perspective projection or orthogonal 
     38        */ 
    3639        bool perspectiveRendering; 
    3740    //inherited 
    3841        virtual void updateFrame(unsigned long frameNum) = 0;    
    3942        /** 
    40                 @brief Creates a photon hit map. 
     43                @brief Creates an impostor texture that can be used as a rendertarget during impostor rendering. 
    4144        */ 
    4245        virtual inline void createImpostorTexture() = 0;         

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/CubeMapRenderingRun.h

    r1722 r2240  
    33 
    44/** 
    5         @brief Base abstract class that defines a rendering process of a color-cubemap. 
    6  
    7         A color cubemap is a cubemap of the colors of the surrounding environment. 
     5        @brief Base abstract class that defines a rendering process of a cubemap.        
    86*/ 
    97class CubeMapRenderingRun : virtual public RenderingRun 
    … …  
    2119                @param angleTolerance                   angle tolerance used in face skip 
    2220                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame 
    23                  
     21                @param renderSelf                               sets if the object should be rendered to the cube map 
     22                @param renderEnvironment                sets if the environment should be rendered to the cube map               
    2423        */ 
    2524        CubeMapRenderingRun(unsigned long startFrame, 
    … …  
    7271        */ 
    7372        float angleTolerance; 
     73        /** 
     74                @brief sets if the object should be rendered to the cube map 
     75        */ 
    7476        bool renderSelf; 
     77        /** 
     78                @brief sets if the environment should be rendered to the cube map 
     79        */ 
    7580        bool renderEnvironment; 
    7681 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/LightVolumeRenderingRun.h

    r1425 r2240  
    33 
    44/** 
    5         @brief Base abstract class that defines a rendering process of a photon hit map. 
     5        @brief Base abstract class that defines a rendering process of a light volume texture. 
    66 
    7         A photon hit map stores the directions where the incoming photons are refracted by a caustic emitter object. 
    8         One pixel of the photon map represents one photon hit, hte direction is encoded in the RGB channels. 
    9         If  the alpha channel has zero value, the hit is invalid. 
     7        Light volumes are used when self shadowing of particle systems should be simulated. 
     8        Each layer of the volume represents the amount of transmitted light. The current implementation uses four grayscale layers,  
     9        and places these layers to the four channel of the light volume texture. 
    1010*/ 
    1111class LightVolumeRenderingRun : virtual public RenderingRun 
    … …  
    1717                @param startFrame                               adds an offset to the current frame number to help evenly distribute updates between frames 
    1818                @param updateInterval                   update frequency 
     19                @param resolution                               the resolution of the light volume texture 
     20                @param textureDepth                             the number of layers (should be set to 1) 
    1921        */ 
    2022        LightVolumeRenderingRun(unsigned long startFrame, 
    … …  
    3234        virtual void updateFrame(unsigned long frameNum) = 0;    
    3335        /** 
    34                 @brief Creates a photon hit map. 
     36                @brief Creates a light volume map. 
    3537        */ 
    3638        virtual inline void createLightVolumeMap() = 0;  
    3739        /** 
    38                 @brief the resolution of the photonmap texture that was created by this run 
     40                @brief the resolution of the light volume map 
    3941        */ 
    4042        unsigned int resolution; 
     43        /** 
     44                @brief number of layers (should be 1) 
     45        */ 
    4146        unsigned int textureDepth; 
    4247 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/PhaseTextureRenderingRun.h

    r1425 r2240  
    33 
    44/** 
    5         @brief Base abstract class that defines a rendering process that creates depth map. 
     5        @brief Base abstract class that defines a rendering process that creates phase texture. 
    66 
    7         The depth map stores the scene's camera space z coordinates (rendered from the player's view). 
     7        The phase texture can be used as a look-up table during rendering of partcipating media. 
     8        If the texture is created once it can be saved and reused, so this run is usually not needed, only runned once. 
     9        This texture is addressed as the following: the u coordinates represents the symmetry of scattering  
     10        (negative if backward scattering, positive if forward scattering and zero if equally scaterring in the forward and in the backward directions) 
     11        ; the v coordinates represent the cosine of the angle between the incoming and outgoing directions. 
    812*/ 
    913class PhaseTextureRenderingRun : virtual public RenderingRun 
    … …  
    1216        /** 
    1317                @brief Constructor. 
     18 
     19                @param resolutionX      width of the texture 
     20                @param resolutionY      height of the texture 
    1421        */ 
    1522        PhaseTextureRenderingRun(unsigned int resolutionX, 
    … …  
    2229 
    2330protected: 
     31        /** 
     32                @brief width of the texture 
     33        */ 
    2434    unsigned int resolutionX; 
     35        /** 
     36                @brief height of the texture 
     37        */ 
    2538        unsigned int resolutionY; 
    2639        /** 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/ReducedCubeMapRenderingRun.h

    r780 r2240  
    33 
    44/** 
    5         @brief Base abstract class that defines a rendering process of a reduced sized color-cubemap. 
     5        @brief Base abstract class that defines a rendering process of a downsampled color-cubemap. 
    66 
    7         The resulting cubemap is a lower resolution variation of a color cube map. It is created with averaging the original cubemap. 
     7        The resulting cubemap is a lower resolution variation of the color cube map. It is created with averaging the original cubemap. 
    88        The lower resolution cubemap can be convolved faster and can efficiently be used in effects like diffuse reflection. 
    99*/ 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/RenderingRuns/SceneCameraDepthRenderingRun.h

    r874 r2240  
    33 
    44/** 
    5         @brief Base abstract class that defines a rendering process that creates depth map. 
     5        @brief Base abstract class that defines a rendering process that creates depth map fro the camera. 
    66 
    77        The depth map stores the scene's camera space z coordinates (rendered from the player's view). 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/SharedRuns.h

    r2189 r2240  
    1010 
    1111        If a new class is derived from RenderingRun, this enum should be extended. 
    12         This types are used in messages sent when a run changes or updates. 
     12        These types are used in messages sent when a run changes or updates. 
    1313*/ 
    1414enum RenderingRunType 
    … …  
    4747        Technique resources which can be shared between several techniques or objects are managed by SharedRuns. 
    4848        These SharedRuns store the shared resources. They also act like nodes of a binary tree, as separate  
    49         SharedRuns can also be joined if for example the objects for witch they store resources are close enough so 
     49        SharedRuns can also be joined if for example the objects for which they store resources are close enough so 
    5050        even one shared resources is enough for the given objects. 
    5151*/ 
    … …  
    5757        */ 
    5858        SharedRuns(void);        
    59          
     59        /** 
     60                &brief Returns true if this shared run object has a given run type. 
     61 
     62                It returns true if the shared run object node has a rendering run object with the given type. 
     63                It checks only the current node of the tree, no children nodes are searched for existing rendering runs. 
     64 
     65                @param runType enum, type of the RenderingRun to search for 
     66                @return search result 
     67        */ 
    6068        virtual bool hasOwnRun(RenderingRunType runType) = 0; 
    6169    /** 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/include/TechniqueGroup.h

    r1055 r2240  
    44 
    55/** 
    6         @brief Base abstract class for a collection techniques. 
     6        @brief Base abstract class for a collection of techniques. 
    77 
    88        This is a helper class, to collect RenderTechnique instances bound to a single renderable. 
    … …  
    2323                Used after creating a new TechniqueGroup. 
    2424 
    25                 @param sharedRuns the SharedRun instance the RenderTechniques will use. 
     25                @param sharedRuns pointer to the SharedRun instance this RenderTechniques will use. 
    2626        */ 
    2727        void addSharedRun(SharedRuns* sharedRuns){parentSharedRuns = sharedRuns; 
    … …  
    3030                @brief Retrieves the shared runs. 
    3131 
    32                 @result the SharedRun instance the RenderTechniques use. 
     32                @result pointer to the SharedRun instance this RenderTechniques uses. 
    3333        */ 
    3434        SharedRuns* getSharedRuns(){return parentSharedRuns;} 
    … …  
    4646        virtual void update(unsigned long frameNum) = 0; 
    4747        /** 
    48                 @brief Called after one of he shared runs changes. 
     48                @brief Called after one of the rendering runs changes. 
    4949 
    5050                This message will be forwarded to each RenderTechique. 
    … …  
    5555        virtual void runChanged(RenderingRunType runType, RenderingRun* run) = 0; 
    5656        /** 
    57                 @brief Called after one of he shared runs updates. 
     57                @brief Called after one of the rendering runs updates. 
    5858                 
    5959                This message will be forwarded to each RenderTechique. 

  • GTP/trunk/Lib/Illum/IllumModule/IllumModule/scripts/illummodule.7.10.vcproj

    r2027 r2240  
    285285                                </File> 
    286286                        </Filter> 
    287                         <Filter 
    288                                 Name="Resource Files" 
    289                                 Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> 
    290                                 <File 
    291                                         RelativePath="..\..\..\..\..\..\..\EGDemoGame\Media\materials\scripts\car.material"> 
    292                                 </File> 
    293                                 <File 
    294                                         RelativePath="..\..\..\..\..\..\..\EGDemoGame\Media\materials\programs\CarReflections.hlsl"> 
    295                                 </File> 
    296                         </Filter> 
    297287                </Filter> 
    298288        </Files> 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreIlluminationManager.h

    r2200 r2240  
    2222using namespace Ogre; 
    2323 
     24/** 
     25 @brief Structure to store path map cluster information for a subentity. 
     26*/ 
    2427struct PathMapClusters 
    2528{ 
     29        /** 
     30                @brief the number of clusters this subentity belongs to 
     31        */ 
    2632        unsigned int count; 
     33        /** 
     34                @brief the indices of the cluster this subentity belongs to. 
     35        */ 
    2736        unsigned int* clusters; 
     37        /** 
     38                @brief the name of the path map file this subentity uses 
     39        */ 
    2840        String pathMapTextureFilename; 
     41        /** 
     42                @brief the resolution of the path map file. 
     43        */ 
    2944        unsigned int pathMapResolution; 
    3045}; 
    3146 
     47/** 
     48        @brief Structure of a path map entry point. 
     49*/ 
    3250struct PathMapEntryPoint 
    3351{ 
     52        /** 
     53                @brief the position of the entry point. 
     54        */ 
    3455    Vector3 position; 
     56        /** 
     57                @brief the normal of the entry point. 
     58        */ 
    3559        Vector3 normal; 
     60        /** 
     61                @brief the probability of the entry point. 
     62        */ 
    3663        float prob; 
    3764}; 
     65 
    3866/** 
    3967        @brief Implementation of IlluminationManager in an OGRE environment. 
    … …  
    7098        */ 
    7199        BillboardSet* findRenderableInParticleSystem(ParticleSystem* system); 
     100        /** 
     101                @brief Fires preAllUpdates for registered UpdateListeners. 
     102 
     103                This is called in each frame before updating the RenderTechniques. 
     104        */ 
    72105        void preAllUpdates(); 
     106        /** 
     107                @brief Fires postAllUpdates for registered UpdateListeners. 
     108 
     109                This is called in each frame after updating the RenderTechniques. 
     110        */ 
    73111        void postAllUpdates(); 
    74112 
    … …  
    83121        */ 
    84122        float maxRad; 
     123        /** 
     124                @brief Size of the focusing map. 
     125 
     126                This map is used if the shadow maps should be focused. 
     127        */ 
    85128        unsigned int focusingMapSize; 
     129        /** 
     130                @brief Size of the shadow maps. 
     131        */ 
    86132        unsigned int shadowMapSize; 
     133        /** 
     134                @brief Size of area lights for soft shadows. 
     135        */ 
    87136        float areaLightRadius; 
     137        /** 
     138                @brief Sets if light space perspective shadow mapping should be used. 
     139        */ 
    88140        bool useLISPSM; 
    89         bool useVSM; 
     141        /** 
     142                @brief Sets if the shadow maps should be blurred. 
     143 
     144                Used in variance shadow mapping. 
     145        */ 
    90146        bool blurSM; 
     147        /** 
     148                @brief Sets if shadow maps should be focused. 
     149        */ 
    91150        bool focusingSM; 
     151        /** 
     152                @brief The material name that should be used during rendering the shadow maps. 
     153 
     154                There are several predefined materials that can be used to render shadow maps: 
     155                 - GTP/Basic/Depth : writes projected depth values of front facing polygons 
     156                 - GTP/Basic/DepthCCW : writes projected depth values of back facing polygons 
     157                 - GTP/Basic/Distance : writes distance values (from eyepoint) of front facing polygons 
     158                 - GTP/Basic/DistanceCCW : writes distance values (from eyepoint) of back facing polygons 
     159                 - GTP/Basic/Distance_Normalized : writes normalized distance values 
     160                        (distance values devided by projection farplane - which is set to the attenuation range in case of shadow maps) of front facing polygons 
     161                 - GTP/Basic/Distance_NormalizedCCW : writes normalized distance values of back facing polygons 
     162 
     163                 The default material is GTP/Basic/Distance_NormalizedCCW. 
     164                 Recommended materials for different light types: 
     165                 - spot and point lights : GTP/Basic/Distance_NormalizedCCW or GTP/Basic/Distance_Normalized 
     166                 - directional lights : GTP/Basic/Depth or GTP/Basic/DepthCCW 
     167        */ 
    92168        String shadowMapMaterialName; 
     169        /** 
     170                @brief Size of the phase texture. 
     171        */ 
    93172        unsigned int phaseTextureSize; 
     173        /** 
     174                @brief Stores maximum bounding radius values for each rendering run type. 
     175        */ 
    94176        std::map<RenderingRunType,float> maxRads; 
     177        /** 
     178                @brief Stores PathMapClusters structures for each subentity. 
     179 
     180                The String key is the name of the subentity. 
     181        */ 
    95182        std::map<String, PathMapClusters> pathMapClusters; 
     183        /** 
     184                @brief PathMapEntryPoint list. 
     185        */ 
    96186        std::vector<PathMapEntryPoint> pathMapEntryPoints; 
     187        /** 
     188                @brief Stores cluster size for each path map cluster. 
     189        */ 
    97190        std::vector<unsigned int> pathMapClusterLengths; 
    98191        /** 
    … …  
    139232        */ 
    140233        std::map<String, OgreSharedRuns*> perLightRuns; 
    141  
     234        /** 
     235                @brief  
     236        */ 
    142237        std::map<GlobalTargetType, GlobalUseRenderTarget*> globalTargets; 
    143  
     238        /** 
     239                @brief Stores registered UpdateListeners. 
     240        */ 
    144241        std::vector<UpdateListener*> updateListeners; 
    145242 
    146243public: 
    147  
     244        /** 
     245                @brief Registers an UpdateListener instance. @see UpdateListener 
     246        */ 
    148247        void addUpdateListener(UpdateListener* l){updateListeners.push_back(l);} 
    149248        /** 
    … …  
    156255        /** 
    157256                @brief retirieves the maximum bounding sphere radius with two SharedRuns can be joined. 
     257 
     258                Only valid fi all run types use the same radius. This can be set with calling setMaxJoinRadius(). 
     259                @see setMaxJoinRadius 
    158260        */ 
    159261        float getMaxJoinRadius(){return maxRad;} 
     262        /** 
     263                @brief Retirieves the maximum shared bounding sphere radius for a given run type. 
     264        */ 
    160265        float getMaxJoinRadius(RenderingRunType type){return maxRads[type];} 
    161266        /** 
    162                 @brief sets the maximum bounding sphere radius with two SharedRuns can be joined. 
     267                @brief sets the maximum bounding sphere radius with two SharedRuns can be joined for all run type. 
    163268        */ 
    164269        void setMaxJoinRadius(float rad) 
    … …  
    176281                 
    177282        } 
     283        /** 
     284                @brief Sets the maximum shared bounding sphere radius for a given run type. 
     285        */ 
    178286        void setMaxJoinRadius(RenderingRunType type, float rad){maxRads[type] = rad;} 
     287        /** 
     288                @see focusingMapSize 
     289        */ 
    179290        void setFocusingMapSize(unsigned int size){focusingMapSize = size;} 
     291        /** 
     292                @see phaseTextureSize 
     293        */ 
    180294        void setPhaseTextureSize(unsigned int size){phaseTextureSize = size;} 
     295        /** 
     296                @see shadowMapSize 
     297        */ 
    181298        void setShadowMapSize(unsigned int size){shadowMapSize = size;} 
    182299        /** 
    … …  
    285402        RenderingRun* getGlobalRun(RenderingRunType runType); 
    286403 
     404        // These GlobalUseRenderTargets are only used in fire render technique. Maybe it could be solved with global rendering runs too. 
    287405        GlobalUseRenderTarget* getGlobalTarget(GlobalTargetType type); 
    288406        void addGlobalTarget(GlobalTargetType type, GlobalUseRenderTarget* target); 
     407 
    289408        /** 
    290409                @brief Updates a global RenderingRun with the given type. 
    … …  
    318437        */ 
    319438        void updatePerLightRun(String lightName, RenderingRunType runType, unsigned long frameNum); 
    320  
     439        /** 
     440                @brief Saves the phase texture to the given file. 
     441        */ 
    321442        void savePhaseTextureToFile(String filename); 
    322  
     443        /** 
     444                @brief Frame listener event handler function. 
     445                 
     446                Inherited from FrameListener. Called at the beginning of each frame. 
     447        */ 
    323448        bool frameStarted(const FrameEvent& evt) 
    324449    { 
    325450                update(Root::getSingleton().getCurrentFrameNumber(), mainViewport->getTarget()); 
    326451                return FrameListener::frameStarted(evt); 
    327         } 
    328  
     452        }        
     453        /** 
     454                @see useLISPSM 
     455        */ 
    329456        bool getUseLISPSM(){return useLISPSM;} 
    330         bool getUseVSM(){return useVSM;} 
     457        /** 
     458                @see focusingSM 
     459        */ 
    331460        bool getFocusingShadowMap(){return focusingSM;} 
     461        /** 
     462                @see blurSM 
     463        */ 
    332464        bool getBlurShadowMap(){return blurSM;} 
     465        /** 
     466                @see useLISPSM 
     467        */ 
    333468        void setUseLISPSM(bool use){useLISPSM = use;} 
    334         void setUseVSM(bool use){useVSM = use;} 
     469        /** 
     470                @see focusingSM 
     471        */ 
    335472        void setFocusingSM(bool use){focusingSM = use;} 
     473        /** 
     474                @see blurSM 
     475        */ 
    336476        void setBlurShadowMap(bool use){blurSM = use;} 
     477        /** 
     478                @see shadowMapMaterialName 
     479        */ 
    337480        void setShadowMapMaterialName(String name){shadowMapMaterialName = name;} 
    338  
     481        /** 
     482                @brief Registers a PathMapClusters structure for a given subentity. 
     483 
     484                @param subEntityName name of te subentity 
     485                @param clusters the PathMapClusters that belongs to the given subentity 
     486        */ 
    339487        void addPathMapClusters(String subEntityName, PathMapClusters clusters) 
    340488        { 
    341489                this->pathMapClusters[subEntityName] = clusters; 
    342490        } 
     491        /** 
     492                @brief Returns the PathMapClusters structure registered for a given subentity. 
     493 
     494                @param subEntityName name of te subentity 
     495                @return pointer to the PathMapClusters structure that belongs to the given subentity 
     496        */ 
    343497        PathMapClusters* getPathMapClusters(String subEntityName) 
    344498        { 
    345499                return &pathMapClusters[subEntityName]; 
    346500        } 
     501        /** 
     502                @brief Adds a new PathMapEntryPoint cluster to the entrypoint list. 
     503        */ 
    347504        void addPathMapEntryPoint(PathMapEntryPoint p) 
    348505        { 
    349506                this->pathMapEntryPoints.push_back(p); 
    350507        } 
     508        /** 
     509                @brief Returns the list of entrypoints. 
     510        */ 
    351511        std::vector<PathMapEntryPoint>& getPathMapEntryPoints() 
    352512        { 
    353513                return pathMapEntryPoints; 
    354514        } 
     515        /** 
     516                @brief Adds a new cluster size. 
     517        */ 
    355518        void addPathMapClusterLength(unsigned int l) 
    356519        { 
    357520                this->pathMapClusterLengths.push_back(l); 
    358521        } 
     522        /** 
     523                @brief Gets the number of clusters. 
     524        */ 
    359525        unsigned int getPathMapClusterLengthsSize() 
    360526        { 
    361527                return this->pathMapClusterLengths.size(); 
    362528        } 
     529        /** 
     530                @brief Gets the size of the given cluster. 
     531 
     532                @param index of the cluster 
     533                @return the size of the cluster 
     534        */ 
    363535        unsigned int getPathMapClusterLength(unsigned int index) 
    364536        { 
    365537                return pathMapClusterLengths.at(index); 
    366538        } 
     539        /** 
     540                @see areaLightRadius 
     541        */ 
    367542        float getAreaLightRadius(){return areaLightRadius;} 
     543        /** 
     544                @see areaLightRadius 
     545        */ 
    368546        void setAreaLigtRadius(float radius){areaLightRadius = radius;} 
    369547}; 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderTechnique.h

    r1055 r2240  
    66class OgreTechniqueGroup; 
    77 
     8/** 
     9        @brief Event handler class. 
     10 
     11        The derived calsses of this class can register task that should be done before and/or after updating all RenderTechniques. 
     12        UpdateListeners can be registered to the OgreIlluminationMager. @see addUpdateListener 
     13*/ 
    814class UpdateListener 
    915{ 
    1016public: 
     17        /** 
     18                @brief Called before RenderTechnique updates 
     19        */ 
    1120        virtual void preAllUpdates(){} 
     21        /** 
     22                @brief Called after RenderTechnique updates 
     23        */ 
    1224        virtual void postAllUpdates(){} 
    1325}; 
    … …  
    100112                                                                                OgreRenderable* parentRenderable, 
    101113                                                                                OgreTechniqueGroup* parentTechniqueGroup) = 0; 
     114        /** 
     115                @brief parses parameters from the material file. 
    102116 
     117                The parsed parameters will be passed to the new RenderTechnique's constructor. 
     118 
     119                @param params pointer to the IllumTechniqueParams structure that was read from the material script and containes the parameters to be parsed. 
     120 
     121        */ 
    103122        virtual void parseParams(IllumTechniqueParams* params); 
    104123         

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderable.h

    r1425 r2240  
    5050        */ 
    5151        ~OgreRenderable(void); 
    52  
    5352        /** 
    5453                @brief Sets the visibility of the wrapped renderable. 
    … …  
    135134        */ 
    136135        Renderable* getRenderable(); 
    137  
    138136         
    139137protected: 
    140  
    141138        /** 
    142139                @brief unique name assigned to the renderable 
    … …  
    155152        */ 
    156153        BillboardSet* billboardSetRenderable; 
     154        /** 
     155                @brief pointer to the parent Particle System of the wrapped BillboardSet (if the renderable is a BillboardSet) 
     156        */ 
    157157        ParticleSystem* parentParticleSystem; 
    158  
    159158        /** 
    160159                @brief axis-aligned bounding box of the wrapped renderable in world space 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreRenderingRun.h

    r1722 r2240  
    4545        */ 
    4646        std::map<Renderable*, String> visibleObjects; 
    47         String terrainMaterial; 
    4847        /** 
    4948                @brief fulls screen quad plane used in full screen quad rendering 
    … …  
    8281        */ 
    8382        String spriteSetName; 
    84  
    8583        /** 
    8684                @brief Returns a direction for a cubemap face id. 
    … …  
    163161        */ 
    164162        void renderPixelSprites(String& materialName, RenderTarget* rt, int width, int height); 
    165         void renderFullscreenGrid(String& materialName, RenderTarget* rt, int width, int height); 
    166          
     163        /** 
     164                @brief Renders a grid onto the screen. 
     165 
     166                @param rt the RenderTarget the grid should be rendered on 
     167                @param width the desired horizontal resolution of the grid 
     168                @param height the desired vertical resolution of the grid 
     169        */ 
     170        void renderFullscreenGrid(String& materialName, RenderTarget* rt, int width, int height);        
    167171}; 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/OgreSharedRuns.h

    r1722 r2240  
    1919        RenderTarget* renderTarget; 
    2020}; 
     21 
    2122/** 
    2223        @brief Class of SharedRuns used in an OGRE environment.  
    … …  
    183184        //inherited 
    184185        void destroy(); 
     186        //inherited 
    185187        void runUpdated(RenderingRunType runType, RenderingRun* run); 
     188        //inherited 
    186189        void runChanged(RenderingRunType runType, RenderingRun* run); 
     190        //inherited 
    187191        virtual void addTechniqueGroup(TechniqueGroup* group){childTechniqueGroups.push_back(group);} 
     192        /** 
     193         @brief Sets the given material for all connected renderables. 
     194 
     195         The previous materials will be stored so later can be restored. @see restoreMaterial 
     196 
     197         @param name of the material to be set. 
     198        */ 
    188199        void setMaterial(String materialName); 
     200        /** 
     201                @brief Restores the prevoius materials for the connected renderables. @see setMaterial 
     202        */ 
    189203        void restoreMaterial(); 
    190204 
    … …  
    203217        std::map<RenderingRunType, RenderingRun*> sharedRuns; 
    204218        /** 
    205                 @brief map of connected renderablis with visibility information 
     219                @brief map of connected renderables with visibility information 
    206220 
    207221                Used to show or hide the renderables connected to a leaf OgreSharedRuns node. 
    208222        */ 
    209         std::map<OgreRenderable*, bool> renderables;  
     223        std::map<OgreRenderable*, bool> renderables; 
     224        /** 
     225                @brief map of connected renderables with material name information 
     226 
     227                Used to resture the original materials of the renderables connected to a leaf OgreSharedRuns node. 
     228        */ 
    210229        std::map<OgreRenderable*, String> renderableMaterials; 
    211230        /** 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticCasterRenderTechnique.h

    r1688 r2240  
    3030                @param updateAllFace                            defines if all cubemap faces should be updated in a frame or only one face per frame 
    3131                @param useDistance                                      tells if a distance cubemap impostor should be used in photon hit calculation (recommended) 
     32                @param attenuation                                      attenuation distance of the caustic 
     33                @param useTriangles                                     sets if triangles should be rendered into the caustic cubemap instead of sprites 
     34                @param blurCauCubeMap                           sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles) 
    3235                @param pass                                                     the pass to operate on 
    3336                @param parentRenderable                         the object to operate on 
    … …  
    3740                                                        unsigned long photonMapUpdateInterval, 
    3841                                                        unsigned int photonMapResolution, 
    39                                                         unsigned int custicCubeMapResolution, 
     42                                                        unsigned int causticCubeMapResolution, 
    4043                                                        String photonMapMaterialName, 
    4144                                                        String causticMapMaterialName, 
    … …  
    6063        */ 
    6164        const String& getCausticCubeMapName(); 
     65        /** 
     66                @see attenuation 
     67        */ 
    6268        float getAttenuation(){return attenuation;} 
    6369 
    … …  
    7682        */ 
    7783        unsigned char photonMapTexID; 
     84        /** 
     85                @brief attenuation distance of the caustic 
     86        */ 
    7887        float attenuation; 
     88        /** 
     89                @brief sets if triangles should be rendered into the caustic cubemap instead of sprites 
     90        */ 
    7991        bool useTriangles; 
     92        /** 
     93                @brief sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles) 
     94        */ 
    8095        bool blurCauCubeMap; 
    8196         
    … …  
    96111}; 
    97112 
    98  
     113/** 
     114        @brief RenderTechniqueFactory to create OgreCausticCasterRenderTechnique instances. 
     115*/ 
    99116class OgreCausticCasterRenderTechniqueFactory : public RenderTechniqueFactory 
    100117{ 
    … …  
    121138        bool useTriangles; 
    122139        bool blurCauCubeMap; 
    123          
    124  
    125140}; 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCausticRecieverRenderTechnique.h

    r836 r2240  
    8484}; 
    8585 
     86/** 
     87        @brief RenderTechniqueFactory to create OgreCausticRecieverRenderTechnique instances. 
     88*/ 
    8689class OgreCausticRecieverRenderTechniqueFactory : public RenderTechniqueFactory 
    8790{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreColorCubeMapRenderTechnique.h

    r1930 r2240  
    1515 
    1616/** 
    17         @brief CubeMapRenderTechnique used in an Ogre environment. 
     17        @brief ColorCubeMapRenderTechnique used in an Ogre environment. 
    1818*/ 
    1919class OgreColorCubeMapRenderTechnique : public ColorCubeMapRenderTechnique, 
    … …  
    3434                @param angleTolerance                   angle tolerance used in face skip 
    3535                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame 
     36                @param renderSelf                               sets if the object should be rendered to the cube map 
     37                @param renderEnvironment                sets if the environment should be rendered to the cube map 
     38                @param selfMaterial                             the material that should be set for the object while rendering the cubemap 
     39                @param environmentMaterial      the material that should be set for the environment while rendering the cubemap 
     40                @param layer                                    the layer of this cubemap 
     41                @param getMinMax                                sets if the minimum and maximum values of the cubemap should be computed 
     42                @param attachToTexUnit                  sets if this cubemap should be attach to a texture unit of the pass 
     43                @param minVariableName                  sets the name of the gpu shader program parameter to which the minimum value should be bound to 
     44                @param maxVariableName                  sets the name of the gpu shader program parameter to which the maximum value should be bound to 
    3645                @param pass                                             the pass to operate on                   
    3746                @param parentRenderable                 the object to operate on 
    … …  
    7079protected:               
    7180        //inherited 
    72         void colorCubeMapRunChanged(RenderingRun* run);  
     81        void colorCubeMapRunChanged(RenderingRun* run); 
     82        //inherited 
    7383        void colorCubeMapRunUpdated(RenderingRun* run);  
    7484}; 
    7585 
     86/** 
     87        @brief RenderTechniqueFactory to create OgreColorCubeMapRenderTechnique instances. 
     88*/ 
    7689class OgreColorCubeMapRenderTechniqueFactory : public OgreCubeMapRenderTechniqueFactory 
    7790{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreConvolvedCubeMapRenderTechnique.h

    r1886 r2240  
    3535                @param angleTolerance                           angle tolerance used in face skip 
    3636                @param updateAllFace                            defines if all cubemap faces should be updated in a frame or only one face per frame 
     37                @param renderSelf                               sets if the object should be rendered to the cube map 
     38                @param renderEnvironment                sets if the environment should be rendered to the cube map 
     39                @param selfMaterial                             the material that should be set for the object while rendering the cubemap 
     40                @param environmentMaterial      the material that should be set for the environment while rendering the cubemap 
     41                @param getMinMax                                sets if the minimum and maximum values of the cubemap should be computed 
     42                @param attachToTexUnit                  sets if this cubemap should be attach to a texture unit of the pass 
     43                @param minVariableName                  sets the name of the gpu shader program parameter to which the minimum value should be bound to 
     44                @param maxVariableName                  sets the name of the gpu shader program parameter to which the maximum value should be bound to 
    3745                @param pass                                                     the pass to operate on                   
    3846                @param parentRenderable                         the object to operate on 
    … …  
    8088}; 
    8189 
    82  
    83  
     90/** 
     91        @brief RenderTechniqueFactory to create OgreConvoledCubeMapRenderTechnique instances. 
     92*/ 
    8493class OgreConvoledCubeMapRenderTechniqueFactory : public OgreCubeMapRenderTechniqueFactory 
    8594{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreCubeMapRenderTechnique.h

    r1930 r2240  
    3434                @param angleTolerance                   angle tolerance used in face skip 
    3535                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame 
     36                @param renderSelf                               sets if the object should be rendered to the cube map 
     37                @param renderEnvironment                sets if the environment should be rendered to the cube map 
     38                @param selfMaterial                             the material that should be set for the object while rendering the cubemap 
     39                @param environmentMaterial      the material that should be set for the environment while rendering the cubemap 
     40                @param layer                                    the layer of this cubemap 
     41                @param getMinMax                                sets if the minimum and maximum values of the cubemap should be computed 
     42                @param attachToTexUnit                  sets if this cubemap should be attach to a texture unit of the pass 
     43                @param minVariableName                  sets the name of the gpu shader program parameter to which the minimum value should be bound to 
     44                @param maxVariableName                  sets the name of the gpu shader program parameter to which the maximum value should be bound to 
    3645                @param pass                                             the pass to operate on                   
    3746                @param parentRenderable                 the object to operate on 
    … …  
    7382        */ 
    7483        unsigned char texID; 
     84        /** 
     85                @brief the material that should be set for the object while rendering the cubemap 
     86        */ 
    7587        String selfMaterial; 
     88        /** 
     89                @brief the material that should be set for the environment while rendering the cubemap 
     90        */ 
    7691        String environmentMaterial; 
     92        //helper string to name the created cubemaps 
    7793        String texturePostFix; 
    78  
     94        /** 
     95                @brief sets if the minimum and maximum values of the cubemap should be computed 
     96        */ 
    7997        bool getMinMax; 
     98        /** 
     99                @brief sets if this cubemap should be attach to a texture unit of the pass 
     100        */ 
    80101        bool attachToTexUnit; 
     102        /** 
     103                @brief sets the name of the gpu shader program parameter to which the minimum value should be bound to 
     104        */ 
    81105        String minVariableName; 
     106        /** 
     107                @brief sets the name of the gpu shader program parameter to which the maximum value should be bound to 
     108        */ 
    82109        String maxVariableName; 
    83110 
     111        //inherited 
    84112        RenderingRun* createCubeMapRun(); 
    85         void cubeMapRunChanged(RenderingRun* run);       
     113        //inherited 
     114        void cubeMapRunChanged(RenderingRun* run); 
     115        //inherited 
    86116        void cubeMapRunUpdated(RenderingRun* run);       
    87117}; 
    88118 
     119/** 
     120        @brief RenderTechniqueFactory to create OgreCubeMapRenderTechnique instances. 
     121*/ 
    89122class OgreCubeMapRenderTechniqueFactory : public RenderTechniqueFactory 
    90123{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDepthShadowRecieverRenderTechnique.h

    r2180 r2240  
    3939                @param shadowFragmentProgram    the fragment program to be used in the shadowing passes 
    4040                                                                                It should have one pass and the depth map of a light will be bound to the first sampler unit.  
     41                @param WorldViewProjParamName   the name of the gpu program parameter the world-view-projection matrix should be bound to 
     42                @param WorldParamName                   the name of the gpu program parameter the world matrix should be bound to 
     43                @param setLightViewMatrix               bound light space view matrix to a gpu program parameter 
     44                @param setLightViewProjMatrix   bound light space view-projection matrix to a gpu program parameter 
     45                @param setLightProjFarPlane             bound light space projection far plane to a gpu program parameter 
     46                @param lightViewProjParamName   the name of the gpu program parameter the light space view-projection matrix should be bound to 
     47                @param lightViewParamName       the name of the gpu program parameter the light space view matrix should be bound to 
     48                @param lightFarPlaneParamName   the name of the gpu program parameter the light space projection far plane should be bound to 
    4149                @param pass                                             the pass after which shadowing passes should be added 
    4250                @param parentRenderable                 the object to operate on 
    … …  
    8896        */ 
    8997        std::vector<Pass*> passes; 
     98        /** 
     99                @brief bound light space view matrix to a gpu program parameter 
     100        */ 
    90101        bool setLightViewMatrix; 
     102        /** 
     103                @brief bound light space view-projection matrix to a gpu program parameter 
     104        */ 
    91105        bool setLightViewProjMatrix; 
     106        /** 
     107                @brief bound light space projection far plane to a gpu program parameter 
     108        */ 
    92109        bool setLightProjFarPlane; 
     110        /** 
     111                @brief the name of the gpu program parameter the light space view-projection matrix should be bound to 
     112        */ 
    93113        String lightViewProjParamName; 
     114        /** 
     115                @brief the name of the gpu program parameter the light space view matrix should be bound to 
     116        */ 
    94117        String lightViewParamName; 
     118        /** 
     119                @brief the name of the gpu program parameter the light space projection far plane should be bound to 
     120        */ 
    95121        String lightFarPlaneParamName; 
     122        /** 
     123                @brief the name of the gpu program parameter the world-view-projection matrix should be bound to 
     124        */       
    96125        String WorldViewProjParamName; 
     126        /** 
     127                @brief the name of the gpu program parameter the world matrix should be bound to 
     128        */ 
    97129        String WorldParamName; 
    98130                                                                                                 
    99131}; 
    100132 
    101  
     133/** 
     134        @brief RenderTechniqueFactory to create OgreDepthShadowRecieverRenderTechnique instances. 
     135*/ 
    102136class OgreDepthShadowRecieverRenderTechniqueFactory : public RenderTechniqueFactory 
    103137{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreDistanceCubeMapRenderTechnique.h

    r1886 r2240  
    3434                @param angleTolerance                   angle tolerance used in face skip 
    3535                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame             
     36                @param renderSelf                               sets if the object should be rendered to the cube map 
     37                @param renderEnvironment                sets if the environment should be rendered to the cube map 
     38                @param selfMaterial                             the material that should be set for the object while rendering the cubemap 
     39                @param environmentMaterial      the material that should be set for the environment while rendering the cubemap 
     40                @param layer                                    the layer of this cubemap 
     41                @param getMinMax                                sets if the minimum and maximum values of the cubemap should be computed 
     42                @param attachToTexUnit                  sets if this cubemap should be attach to a texture unit of the pass 
     43                @param minVariableName                  sets the name of the gpu shader program parameter to which the minimum value should be bound to 
     44                @param maxVariableName                  sets the name of the gpu shader program parameter to which the maximum value should be bound to 
    3645                @param pass                                             the pass to operate on                   
    3746                @param parentRenderable                 the object to operate on 
    … …  
    7887}; 
    7988 
    80  
     89/** 
     90        @brief RenderTechniqueFactory to create OgreDistanceCubeMapRenderTechnique instances. 
     91*/ 
    8192class OgreDistanceCubeMapRenderTechniqueFactory : public OgreCubeMapRenderTechniqueFactory 
    8293{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreFireRenderTechnique.h

    r1055 r2240  
    2626 
    2727/** 
    28         @brief SBBRenderTechnique used in an OGRE environment. 
     28        @brief A special SBBRenderTechnique used in an OGRE environment. 
     29 
     30        Instead of rendering to the frame buffer this Technique renders into two render targets at the same time. 
     31        The firs render target will be used as it were an ordinary backbuffer. 
     32        The second rendertarget will be used to simulate heat shimmering (offset values will be written to it). 
     33        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. 
     34        Just like the spherical billboard techniqeue, this thechnique requires a depth image taken from main camera's viewpoint.         
    2935*/ 
    3036class OgreFireRenderTechnique : public OgreRenderTechnique, 
    … …  
    5258        //inherited 
    5359        virtual void update(unsigned long frameNum); 
    54  
     60        //inherited 
    5561        void  preRenderTargetUpdate (const RenderTargetEvent &evt); 
     62        //inherited 
    5663        void  postRenderTargetUpdate (const RenderTargetEvent &evt); 
     64        //inherited 
    5765        bool  frameEnded (const FrameEvent &evt); 
     66        //inherited 
    5867        void preAllUpdates(); 
    5968         
    … …  
    6776}; 
    6877 
    69  
     78/** 
     79        @brief RenderTechniqueFactory to create OgreFireRenderTechnique instances. 
     80*/ 
    7081class OgreFireRenderTechniqueFactory : public RenderTechniqueFactory 
    7182{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreHierarchicalParticleSystemTechnique.h

    r1425 r2240  
    1212 
    1313/** 
    14         @brief CausticCasterRenderTechnique used in an OGRE environment. 
     14        @brief HierarchicalParticleSystemTechnique used in an OGRE environment. 
    1515*/ 
    1616class OgreHierarchicalParticleSystemTechnique : public OgreRenderTechnique, 
    … …  
    1818{ 
    1919public: 
     20        /** 
     21                @brief Constructor. 
    2022 
     23                @param startFrame                               adds an offset to the current frame number to help evenly distribute updates between frames 
     24                @param impostorUpdateInterval   update frequency of the impostor texture (image of the smaller system) 
     25                @param impostorResolution               resolution of the impostor texture 
     26                @param impostorTexID                    the id of the texture unit state the impostor image should be bound to 
     27                @param useDistCalc                              flag to skip impostor update if object is far away (//not used) 
     28                @param perspectiveRendering             sets if the impostor should be rendered with a perspective projection or orthogonal 
     29                @param childPSysScriptName              name of the small particle system script 
     30                @param useOwnMaterial                   use the material for the smaller system that was defined in the particle script 
     31                @param impostorMaterialName             use this specific material for the small particle system 
     32                @param useVParam                                bound particle radius to a gpu vertex program parameter 
     33                @param VParamRadius                             name of the gpu vertex program parameter the particle radius should be bound to 
     34                @param useFParam                                bound particle radius to a gpu fragment program parameter 
     35                @param FParamRadius                             name of the gpu fragment program parameter the particle radius should be bound to 
     36                @param pass                                             the pass to operate on                   
     37                @param parentRenderable                 the object to operate on 
     38                @param parentTechniqueGroup             the TechniqueGroup this RenderedTechnique is attached to 
     39        */ 
    2140        OgreHierarchicalParticleSystemTechnique(unsigned long startFrame, 
    2241                                                        unsigned long impostorUpdateInterval, 
    … …  
    4362                 
    4463protected: 
    45          
     64        /** 
     65                @brief use this specific material for the small particle system 
     66        */ 
    4667        String impostorMaterialName; 
     68        /** 
     69                @brief name of the small particle system script 
     70        */ 
    4771        String childPSysScriptName; 
     72        /** 
     73                @brief name of the created child particle system 
     74        */ 
    4875        String childPSysName; 
     76        /** 
     77                @brief the id of the texture unit state the impostor image should be bound to 
     78        */ 
    4979        unsigned char impostorTexID; 
     80        /** 
     81                @brief use the material for the smaller system that was defined in the particle script 
     82        */ 
    5083        bool useOwnMaterial; 
     84        /** 
     85                @brief name of the gpu vertex program parameter the particle radius should be bound to 
     86        */ 
    5187        String VParamRadius; 
     88        /** 
     89                @brief name of the gpu fragment program parameter the particle radius should be bound to 
     90        */ 
    5291        String FParamRadius; 
     92        /** 
     93                @brief bound particle radius to a gpu vertex program parameter 
     94        */ 
    5395        bool useVParam; 
     96        /** 
     97                @brief bound particle radius to a gpu fragment program parameter 
     98        */ 
    5499        bool useFParam; 
    55100         
    56101        //inherited 
    57102        RenderingRun* createChildPSysRenderingRun(); 
     103        //inherited 
    58104        RenderingRun* createLightVolumeRenderingRun(); 
     105        //inherited 
    59106        virtual void impostorChanged(RenderingRun* run); 
     107        //inherited 
    60108        virtual void impostorUpdated(RenderingRun* run); 
    61109}; 
    62110 
     111/** 
     112        @brief RenderTechniqueFactory to create OgreHierarchicalParticleSystemTechnique instances. 
     113*/ 
    63114class OgreHierarchicalParticleSystemTechniqueFactory : public RenderTechniqueFactory 
    64115{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreIllumVolumeRenderTechnique.h

    r1425 r2240  
    1212 
    1313/** 
    14         @brief CausticCasterRenderTechnique used in an OGRE environment. 
     14        @brief IllumVolumeRenderTechnique used in an OGRE environment. 
    1515*/ 
    1616class OgreIllumVolumeRenderTechnique : public OgreRenderTechnique, 
    … …  
    1818{ 
    1919public: 
     20        /** 
     21                @brief Constructor. 
    2022 
     23                @param startFrame                                       adds an offset to the current frame number to help evenly distribute updates between frames 
     24                @param illumVolumeUpdateInterval        the update frequency of the light volume 
     25                @param illumTextureResolution           the resolution of the light volume texture 
     26                @param textureDepth                                     the number of layers to use (should be set to 1) 
     27                @param illumTexID                                       the id of the texture unit state the resulting illumevolume should be bound to 
     28                @param useDistCalc                                      flag to skip updates if the shaded particle system is far away (not used) 
     29                @param materialName                                     the name of the material that is used while rendering the light volume 
     30                @param lightMatrixGPUParamName          the name of the gpu program parameter where the light matrix should be bound to 
     31                @param useHierarchicalImpostor          set this flag to true if the particle system is a hierarchical particle system 
     32                @param impostorTexID                            the id of the texture unit state where the impostor image of the smaller system should be bound to 
     33                @param pass                                                     the pass to operate on                   
     34                @param parentRenderable                         the object to operate on 
     35                @param parentTechniqueGroup                     the TechniqueGroup this RenderedTechnique is attached to 
     36        */ 
    2137        OgreIllumVolumeRenderTechnique(unsigned long startFrame, 
    2238                                                        unsigned long illumVolumeUpdateInterval, 
    … …  
    3955         
    4056protected: 
    41          
     57        /** 
     58                @brief the name of the material that is used while rendering the light volume 
     59        */ 
    4260        String materialName; 
     61        /** 
     62                @brief the id of the texture unit state the resulting illumevolume should be bound to 
     63        */ 
    4364        unsigned char illumTexID; 
     65        /** 
     66                @brief the name of the gpu program parameter where the light matrix should be bound to 
     67        */ 
    4468        String lightMatrixGPUParamName; 
     69        /** 
     70                @brief the id of the texture unit state where the impostor image of the smaller system should be bound to 
     71        */ 
    4572        unsigned char impostorTexID; 
    4673         
    4774        //inherited 
    4875        RenderingRun* createLightVolumeRenderingRun(); 
     76        //inherited 
    4977        void lightVolumeChanged(RenderingRun* run); 
     78        //inherited 
    5079        void lightVolumeUpdated(RenderingRun* run); 
     80        //inherited 
    5181        void hierarchicalImpostorUpdated(RenderingRun* run); 
    5282}; 
    5383 
     84/** 
     85        @brief RenderTechniqueFactory to create OgreIllumVolumeRenderTechnique instances. 
     86*/ 
    5487class OgreIllumVolumeRenderTechniqueFactory : public RenderTechniqueFactory 
    5588{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgrePathMapRenderTechnique.h

    r2200 r2240  
    1515struct PathMapClusters; 
    1616/** 
    17         @brief DepthShadowRecieverRenderTechnique used in an OGRE environment. 
     17        @brief A technique that defines that the rendering of the object will use the path map technique. 
    1818 
    19         This technique defines that the object will recieve shadows with the help of depth shadow maps. 
    20         Each lightsource can have a depth map assigned to it. These are going to be refreshed only  
    21         if shadow recievers are visible. It is the shadow reciever technique's resposibility 
    22         to refresh them. 
    23  
    24         The shadows from each light are calculated in separate passes. Each pass will 
    25         modulate the shaded image, so thes should be the last passes (but before caustic passes). 
    26         The given Pass* parameter n the constructor defines the pass after which new 
    27         shadow recieving passes will be added by the technique. 
    28  
     19        This rendering technique can add indirect lighting to the scene. 
    2920*/ 
    3021class OgrePathMapRenderTechnique : public OgreRenderTechnique 
    … …  
    3425                @brief Constructor. 
    3526 
    36                 @param maxlights                                the maximum number of light sources to recieve shadow from 
    37                 @param shadowVertexProgram              the vertex program to be used in the shadowing passes 
    38                 @param shadowFragmentProgram    the fragment program to be used in the shadowing passes 
    39                                                                                 It should have one pass and the depth map of a light will be bound to the first sampler unit.  
    4027                @param pass                                             the pass after which shadowing passes should be added 
    4128                @param parentRenderable                 the object to operate on 
    … …  
    5441        virtual void update(unsigned long frameNum); 
    5542         
    56 protected:       
     43protected: 
     44        /** 
     45                @brief the new pass created by this technique 
     46        */ 
    5747        Pass* pathMapPass; 
    58         PathMapClusters* clusters;       
     48        /** 
     49                @brief the PathMapClusters structure that belongs to the subentity renderable 
     50        */ 
     51        PathMapClusters* clusters; 
     52        /** 
     53                @brief the weight index lookup map created by this technique 
     54        */ 
    5955        Texture* weightIndexTexture; 
    60  
     56        /** 
     57                @brief create a weight index lookup map 
     58        */ 
    6159        void createWeightIndexTexture(); 
    6260}; 
    6361 
    64  
     62/** 
     63        @brief RenderTechniqueFactory to create OgrePathMapRenderTechnique instances. 
     64*/ 
    6565class OgrePathMapRenderTechniqueFactory : public RenderTechniqueFactory 
    6666{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderTechniques/OgreSBBRenderTechnique.h

    r1055 r2240  
    4242        //inherited 
    4343        virtual void update(unsigned long frameNum); 
    44  
     44        //inherited 
    4545        void  preRenderTargetUpdate (const RenderTargetEvent &evt); 
     46        //inherited 
    4647        void  postRenderTargetUpdate (const RenderTargetEvent &evt); 
     48        //inherited 
    4749        bool  frameEnded (const FrameEvent &evt); 
     50        //inherited 
    4851        void preAllUpdates(); 
     52        //inherited 
    4953        void postAllUpdates(); 
    5054         
    … …  
    5963}; 
    6064 
    61  
     65/** 
     66        @brief RenderTechniqueFactory to create OgreSBBRenderTechnique instances. 
     67*/ 
    6268class OgreSBBRenderTechniqueFactory : public RenderTechniqueFactory 
    6369{ 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreCausticCubeMapRenderingRun.h

    r2142 r2240  
    1414 
    1515/** 
    16         @brief ColorCubeMapRenderingRun used in an OGRE environment. 
     16        @brief CausticCubeMapRenderingRun used in an OGRE environment. 
    1717*/ 
    1818class OgreCausticCubeMapRenderingRun : public OgreRenderingRun, 
    … …  
    3232                @param photonMapTexId                   the texture unit state id of the caustic map generation material where the photonhit map should be bound to 
    3333                @param updateAllFace                    defines if all cubemap faces should be updated in a frame or only one face per frame 
     34                @param attenuation                              attenuation distance of the caustic 
     35                @param useTriangles                             sets if triangles should be rendered into the caustic cubemap instead of sprites 
     36                @param blurMap                                  sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles) 
    3437        */       
    3538        OgreCausticCubeMapRenderingRun(OgreSharedRuns* sharedRuns, 
    … …  
    5861        //inherited 
    5962        void photonMapChanged(RenderingRun* run); 
     63        /** 
     64                @see attenuation 
     65        */ 
    6066        float getAttenuation(){return attenuation;} 
    61          
     67        //inherited 
    6268        bool canJoin(RenderingRun* run) 
    6369        { 
    … …  
    6773                return false; 
    6874        } 
    69  
     75        /** 
     76                @see blurMap 
     77        */ 
    7078        void setBlurMap(bool blur){blurMap = blur;} 
    7179 
    … …  
    95103        */ 
    96104        String materialName; 
     105        /** 
     106                @brief attenuation distance of the caustic 
     107        */ 
    97108        float attenuation; 
     109        /** 
     110                @brief sets if triangles should be rendered into the caustic cubemap instead of sprites 
     111        */ 
    98112        bool useTriangles; 
     113        /** 
     114                @brief sets if the caustic cubemap should be blurred (recommended if rendering caustic triangles) 
     115        */ 
    99116        bool blurMap; 
    100117         

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/include/RenderingRuns/OgreChildPSystemRenderingRun.h

    r1722 r2240  
    1414 
    1515/** 
    16         @brief ColorCubeMapRenderingRun used in an OGRE environment. 
     16        @brief ChildPsystemRenderingRun used in an OGRE environment. 
    1717*/ 
    1818class OgreChildPSystemRenderingRun : public OgreRenderingRun, 
    … …  
    2828                @param startFrame                       adds an offset to the current frame number to help evenly distribute updates between frames 
    2929                @param updateInterval           update frequency 
    30                 @param materialName                     the name of the material should be used when rendering the choton hit map 
     30                @param resolution                       resolution of the impostor texture 
     31                @param perspectiveRendering     sets if the impostor should be rendered with a perspective projection or orthogonal 
     32                @param childPSysScriptName      the name of the particle system script 
     33                @param useOwnMaterial           use the material that was defined in the particle script 
     34                @param materialName                     use this specific material while rendering the impostor 
     35                 
    3136*/       
    3237        OgreChildPSystemRenderingRun(OgreSharedRuns* sharedRuns, 
    … …  
    4550        */ 
    4651        String getImpostorTextureName(){return name;} 
    47          
     52        //inherited 
    4853        bool canJoin(RenderingRun* run) 
    4954        { 
    … …  
    5156                return false; 
    5257        } 
     58 
    5359        void setNode(SceneNode* n){psysNode = n;} 
    5460        Real getSmallSysRadius(){return sysRad;} 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp

    r2200 r2240  
    8484        phaseTextureSize = 256; 
    8585        useLISPSM = false; 
    86         useVSM = false; 
     86//      useVSM = false; 
    8787        blurSM = false; 
    8888        focusingSM = true; 
Note: See TracChangeset for help on using the changeset viewer.