D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Framework/Tools/spLightmapGenerator.hpp

Go to the documentation of this file.

/*
 * Lightmap generator header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_LIGHTMAP_GENERATOR_H__
#define __SP_LIGHTMAP_GENERATOR_H__


#include "Base/spStandard.hpp"

#ifdef SP_COMPILE_WITH_LIGHTMAPGENERATOR


#include "Base/spInputOutputString.hpp"
#include "Base/spDimension.hpp"
#include "Base/spThreadManager.hpp"
#include "SceneGraph/spSceneGraph.hpp"
#include "SceneGraph/Collision/spCollisionConfigTypes.hpp"
#include "SceneGraph/Collision/spCollisionGraph.hpp"
#include "RenderSystem/spRenderSystem.hpp"
#include "Framework/Tools/spLightmapBase.hpp"

#include <list>
#include <vector>
#include <map>


namespace sp
{
namespace tool
{


class SP_EXPORT LightmapGenerator
{
    
    public:
        
        LightmapGenerator();
        ~LightmapGenerator();
        
        bool generateLightmaps(
            const std::list<SCastShadowObject> &CastShadowObjects,
            const std::list<SGetShadowObject> &GetShadowObjects,
            const std::list<SLightmapLight> &LightSources,
            const video::color &AmbientColor = DEF_LIGHTMAP_AMBIENT,
            const u32 MaxLightmapSize = DEF_LIGHTMAP_SIZE,
            const f32 DefaultDensity = DEF_LIGHTMAP_DENSITY,
            const u8 TexelBlurRadius = DEF_LIGHTMAP_BLURRADIUS,
            const u8 ThreadCount = 0,
            const s32 Flags = 0
        );
        
        void clearScene();
        
        bool updateBluring(u8 TexelBlurRadius);
        
        bool updateAmbientColor(const video::color &AmbientColor);
        
        static void setProgressCallback(const LightmapProgressCallback &Callback);
        
        /* === Inline functions === */
        
        inline scene::Mesh* getFinalModel() const
        {
            return FinalModel_;
        }
        inline const std::list<scene::Mesh*>& getSingleModels() const
        {
            return SingleModels_;
        }
        
        inline const std::list<video::Texture*>& getLightmapTextures() const
        {
            return LightmapTextures_;
        }
        
        inline void setStateCallback(const LightmapStateCallback &Callback)
        {
            StateCallback_ = Callback;
        }
        
        inline s32 getFlags() const
        {
            return State_.Flags;
        }
        inline u8 getTexelBlurRadius() const
        {
            return State_.TexelBlurRadius;
        }
        inline u8 getThreadCount() const
        {
            return State_.ThreadCount;
        }
        inline bool hasGeneratedSuccessful() const
        {
            return State_.HasGeneratedSuccessful;
        }
        inline const video::color& getAmbientColor() const
        {
            return State_.AmbientColor;
        }
        
    private:
        
        /* === Friends === */
        
        friend struct LightmapGen::SAxisData;
        friend struct LightmapGen::SModel;
        
        friend void LMapRasterizePixelCallback(
            s32 x, s32 y, const LightmapGen::SRasterizerVertex &Vertex, void* UserData
        );
        friend void LMapBlurPixelCallback(s32 x, s32 y, void* UserData);
        
        friend THREAD_PROC(RasterizerThreadProc);
        
        /* === Structures === */
        
        struct SP_EXPORT SInternalState
        {
            SInternalState();
            ~SInternalState();
            
            /* Members */
            s32 Flags;
            video::color AmbientColor;
            u8 TexelBlurRadius;
            u8 ThreadCount;
            bool HasGeneratedSuccessful;
        };
        
        /* === Functions === */
        
        void estimateEntireProgress(bool BlurEnabled);
        
        void createFacesLightmaps(LightmapGen::SModel* Model);
        
        void generateLightTexelsSingleThreaded(LightmapGen::SLight* Light);
        void generateLightTexelsMultiThreaded(LightmapGen::SLight* Light);
        
        void rasterizeTriangle(const LightmapGen::SLight* Light, const LightmapGen::STriangle &Triangle);
        
        void processTexelLighting(
            LightmapGen::SLightmapTexel* Texel, const LightmapGen::SLight* Light,
            const dim::vector3df &Position, const dim::vector3df &Normal
        );
        
        void shadeAllLightmaps();
        void partitionScene(f32 DefaultDensity);
        
        void createNewLightmap();
        void putFaceIntoLightmap(LightmapGen::SFace* Face);
        
        void buildFinalMesh(LightmapGen::SModel* Model);
        void buildAllFinalModels();
        
        void blurLightmapTexels(LightmapGen::SModel* Model, s32 Factor);
        
        void blurAllLightmaps(u8 TexelBlurRadius);
        void createFinalLightmapTextures(const video::color &AmbientColor);
        
        void updateStateInfo(const ELightmapGenerationStates State, const io::stringc &Info = "");
        
        void clearLightmapObjects();
        
        /* === Static functions === */
        
        static bool processRunning(s32 BoostFactor = 1);
        
        /* === Members === */
        
        scene::Mesh* FinalModel_;
        std::list<scene::Mesh*> SingleModels_;
        
        scene::CollisionGraph CollSys_;
        scene::CollisionMesh* CollMesh_;
        
        std::list<SCastShadowObject> CastShadowObjects_;
        std::list<LightmapGen::SLight*> LightSources_;
        std::list<LightmapGen::SModel*> GetShadowObjects_;
        
        std::list<LightmapGen::SLightmap*> Lightmaps_;          
        std::list<video::Texture*> LightmapTextures_;           
        
        std::map<scene::Mesh*, LightmapGen::SModel*> ModelMap_;
        
        LightmapGen::SLightmap* CurLightmap_;
        LightmapGen::TRectNode* CurRectRoot_;
        
        SInternalState State_;
        
        LightmapStateCallback StateCallback_;
        
        static LightmapProgressCallback ProgressCallback_;
        
        static s32 Progress_;
        static s32 ProgressMax_;
        static s32 ProgressShadedTriangleNum_;
        
        static video::color AmbientColor_;
        static dim::size2di LightmapSize_;
        
};


} // /namespace tool

} // /namespace sp


#endif

#endif



// ================================================================================