E:/Programming/MyProject/K_Game_hg/GameEngine/include/render/RenderManager.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _RENDER_MANAGER_H_
#define _RENDER_MANAGER_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <core/Singleton.h>
#include <render/Color.h>
#include <render/RenderOperation.h>
#include <render/Material.h>
#include <render/ShaderParamData.h>
#include <engine/Object.h>

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

namespace core
{
class matrix4;
}

namespace platform
{
class Timer;
}

namespace resource
{
class Resource;
class Serializer;
enum BufferUsage;
enum PixelFormat;
}

namespace scene
{
class Node;
}

namespace render
{

class Frustum;
class Light;
class Camera;
class Renderable;
class Model;
class Overlay;
class PanelOverlay;
class TextOverlay;
class Font;
class MeshData;
class Material;
class Viewport;
class RenderWindow;
class RenderDriver;
class FrameEventReceiver;
struct FrameEvent;
class Shader;
class VertexBuffer;
class IndexBuffer;
class PixelBuffer;
class VertexDeclaration;
class VertexBufferBinding;
class FontFactory;
class MaterialFactory;
class MeshDataFactory;
enum IndexType;
enum ShaderType;

class ENGINE_PUBLIC_EXPORT RenderManager: public engine::Object, public core::Singleton<RenderManager>
{
public:

        // Default Constructor
        RenderManager();

        ~RenderManager();

        RenderWindow* createRenderWindow(s32 width, s32 height, s32 colorDepth, bool fullScreen, s32 left = 0, s32 top = 0, bool depthBuffer = true, void* windowId = NULL);

        void setMainWindow(RenderWindow* window);

        RenderWindow* getMainWindow();

        RenderWindow* getRenderWindow(const u32& id);
        
        void removeRenderWindow(const u32& id);

        void removeAllRenderWindows();

        void start();

        void stop();

        void addFrameEventReceiver(FrameEventReceiver* newEventReceiver);
        void removeFrameEventReceiver(FrameEventReceiver* oldEventReceiver);

        s32 getViewportHeight() const;

        s32 getViewportWidth() const;

        Light* createLight(scene::Node* parent = NULL);
        Light* createLight(const std::string& name, scene::Node* parent = NULL);
        Light* getLight(const u32& id);

        u32 getNumberOfLights() const;

        void removeLight(Light *lt);
        void removeLight(const u32& id);
        void removeAllLights();

        Camera* createCamera(scene::Node* parent = NULL);
        Camera* createCamera(const std::string& name, scene::Node* parent = NULL);

        Camera* getCamera(const u32& id);

        u32 getNumberOfCameras() const;

        void removeCamera(Camera *cam);
        void removeCamera(const u32& id);
        void removeAllCameras();

        Renderable* createRenderable(scene::Node* parent = NULL);
        Renderable* createRenderable(const std::string& name, scene::Node* parent = NULL);

        Renderable* getRenderable(const u32& id);

        u32 getNumberOfRenderables() const;

        void removeRenderable(Renderable *renderable);
        void removeRenderable(const u32& id);
        void removeAllRenderables();

        Model* createModel(const std::string& meshFilename, scene::Node* parent = NULL);
        Model* createModel(const std::string& name, const std::string& meshFilename, scene::Node* parent = NULL);

        Model* createModel(MeshData* meshData, scene::Node* parent = NULL);
        Model* createModel(const std::string& name, MeshData* meshData, scene::Node* parent = NULL);

        Model* getModel(const u32& id);

        void removeModel(Model *model);
        void removeModel(const u32& id);

        PanelOverlay* createPanelOverlay();
        PanelOverlay* createPanelOverlay(const std::string& name);

        TextOverlay* createTextOverlay();
        TextOverlay* createTextOverlay(const std::string& name);

        Overlay* getOverlay(const u32& id);

        u32 getNumberOfOverlays() const;

        void removeOverlay(Overlay *overlay);
        void removeOverlay(const u32& id);
        void removeAllOverlays();

        Font* createFont(const std::string& fontFilename);

        Font* getFont(const u32& id);

        u32 getNumberOfFonts() const;

        void removeFont(Font *fnt);
        void removeFont(const u32& id);
        void removeAllFonts();

        Shader* createShader(const std::string& shaderFilename, const ShaderType& type);

        Shader* getShader(const u32& id);

        u32 getNumberOfShaders() const;

        void removeShader(Shader* shader);
        void removeShader(const u32& id);
        void removeAllShaders();

        VertexBuffer* createVertexBuffer(u32 vertexSize, u32 numVertices, resource::BufferUsage usage, bool useShadowBuffer = false);
        void removeVertexBuffer(VertexBuffer* buf);
        void removeAllVertexBuffers();
        
        IndexBuffer* createIndexBuffer(IndexType idxType, u32 numIndexes, resource::BufferUsage usage, bool useShadowBuffer = false);
        void removeIndexBuffer(IndexBuffer* buf);
        void removeAllIndexBuffers();

        PixelBuffer* createPixelBuffer(u32 width, u32 height, u32 depth, resource::PixelFormat format, resource::BufferUsage usage, bool useShadowBuffer = false);
        void removePixelBuffer(PixelBuffer* buf);
        void removeAllPixelBuffer();

        VertexDeclaration* createVertexDeclaration();
        void removeVertexDeclaration(VertexDeclaration* decl);
        void removeAllVertexDeclarations();

        VertexBufferBinding* createVertexBufferBinding();
        void removeVertexBufferBinding(VertexBufferBinding* binding);
        void removeAllVertexBufferBindings();

        void setAmbientLight(const Color& ambient = Color::White);

        void setFog(FogMode mode = FM_NONE, const Color& color = Color::White, f32 density = 0.001f, f32 start = 0.0f, f32 end = 1.0f);

        void convertProjectionMatrix(const core::matrix4& matrix, core::matrix4& dest);

        f32 getMinimumDepthInputValue();
        f32 getMaximumDepthInputValue();

        f32 getHorizontalTexelOffset();
        f32 getVerticalTexelOffset();

        void registerDefaultFactories();
        void removeDefaultFactories();

        void setRenderDriver(RenderDriver* driver);
        void removeRenderDriver();

        static RenderManager* getInstance();

private:

        static void ENGINE_CALLBACK releaseFontImpl(resource::Resource* resource);
        static void ENGINE_CALLBACK releaseMeshDataImpl(resource::Resource* resource);
        static void ENGINE_CALLBACK releaseMaterialImpl(resource::Resource* resource);

protected:

        void initializeImpl();
        void uninitializeImpl();
        void updateImpl(f32 elapsedTime);

        FontFactory* mDefaultFontFactory;
        MaterialFactory* mDefaultMaterialFactory;
        MeshDataFactory* mDefaultMeshDataFactory;

        RenderDriver* mRenderDriver;

        static std::list<FrameEventReceiver*> mFrameEventReceivers;

        // Available rendering windows
        std::map<u32, RenderWindow*> mRenderWindows;
        RenderWindow* mMainWindow;

        std::map<u32, Light*> mLights;

        std::map<u32, Renderable*> mRenderables;

        std::map<u32, Overlay*> mOverlays;

        std::map<u32, Font*> mFonts;

        std::map<u32, Camera*> mCameras;

        std::map<u32, Shader*> mShaders;

        std::list<VertexDeclaration*> mVertexDeclarations;
        std::list<VertexBufferBinding*> mVertexBufferBindings;
        std::list<VertexBuffer*> mVertexBuffers;
        std::list<IndexBuffer*> mIndexBuffers;
        std::list<PixelBuffer*> mPixelBuffers;

        struct SolidRenderable
        {
                SolidRenderable()
                {
                        renderable = NULL;
                        materialID = 0;
                }

                bool operator < (const SolidRenderable& other) const
                {
                        return (materialID < other.materialID);
                }

                Renderable* renderable;
                u32 materialID;//Renderable material ID
        };

        struct TransparentRenderable
        {
                TransparentRenderable()
                {
                        renderable = NULL;
                        distance = 0;
                }

                bool operator < (const TransparentRenderable& other) const
                {
                        return (distance > other.distance);
                }

                Renderable* renderable;
                f32 distance;//Renderable distance to camera
        };

        struct DistanceLight
        {
                DistanceLight()
                {
                        light = NULL;
                        distance = 0;
                }

                bool operator < (const DistanceLight& other) const
                {
                        return (distance < other.distance);
                }

                Light* light;
                f32 distance;//Light distance to renderable
        };
        
        std::vector<SolidRenderable> mSolidRenderables;
        std::vector<TransparentRenderable> mTransparentRenderables;
        std::vector<DistanceLight> mDistanceLights;

        std::list<Light*> mLightsAffectingFrustum;

        bool mUpdateRender;

        Color mAmbientLight;

        ShaderParamData mShaderParamData;

        Material* mDefaultMaterial;

        Viewport* mCurrentViewport;

        Frustum* mFrustum;

        RenderOperation mRenderOperation;

        // Fog
        FogMode mFogMode;
        Color mFogColor;
        f32 mFogDensity;
        f32 mFogStart;
        f32 mFogEnd;

        // Internal timer
        platform::Timer* mTimer;

        u32 mLastStartTime;
        u32 mLastEndTime;

        s32 mLastViewportWidth;
        s32 mLastViewportHeight;

        void fireFrameStarted();

        void fireFrameEnded();

        void render(Camera* cam, Viewport *vp);

        void setCurrentViewport(Viewport *vp);

        void beginFrame(Viewport *vp);

        void findLightsAffectingFrustum(Camera* cam);

        void findLightsAffectingRenderables(Renderable* renderable);

        void findVisibleRenderables(Camera* cam);

        void renderVisibleRenderables();

        void renderVisibleOverlays(Camera* cam, Viewport *vp);
        void renderSingleOverlay(Overlay* overlay, Camera* cam, Viewport *vp);

        void renderSingleRenderable(Renderable* renderable);

        void setMaterial(Material* mat);

        void endFrame();
};

} // end namespace render

#endif