dynamicshadowsrender.h

Go to the documentation of this file.

// Luanti
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2021 Liso <anlismon@gmail.com>
 
#pragma once
 
#include <string>
#include <vector>
#include <memory>
#include <IrrlichtDevice.h>
#include "client/shadows/dynamicshadows.h"
#include <ISceneNode.h>
#include <ISceneManager.h>
 
class ShadowDepthUniformSetter;
class ShadowScreenQuad;
class ShadowScreenQuadUniformSetter;
class IWritableShaderSource;
 
enum E_SHADOW_MODE : u8
{
        ESM_RECEIVE = 0,
        ESM_BOTH,
};
 
struct NodeToApply
{
        NodeToApply(scene::ISceneNode *n,
                        E_SHADOW_MODE m = E_SHADOW_MODE::ESM_BOTH) :
                        node(n),
                        shadowMode(m){};
 
        bool operator==(scene::ISceneNode *n) const { return node == n; }
 
        scene::ISceneNode *node;
 
        E_SHADOW_MODE shadowMode{E_SHADOW_MODE::ESM_BOTH};
        bool dirty{false};
};
 
class ShadowRenderer
{
public:
        static const int TEXTURE_LAYER_SHADOW = 3;
 
        ShadowRenderer(IrrlichtDevice *device, Client *client);
        ~ShadowRenderer();
 
        // Call before generating any shaders
        // This is required because this class is initialized much later than all
        // the shaders are dealt with.
        static void preInit(IWritableShaderSource *shsrc);
 
        bool initialize();
 
        size_t addDirectionalLight();
        DirectionalLight &getDirectionalLight(u32 index = 0);
        size_t getDirectionalLightCount() const;
        f32 getMaxShadowFar() const;
 
        void addNodeToShadowList(scene::ISceneNode *node,
                        E_SHADOW_MODE shadowMode = ESM_BOTH);
        void removeNodeFromShadowList(scene::ISceneNode *node);
 
        void update(video::ITexture *outputTarget = nullptr);
        void setForceUpdateShadowMap() { m_force_update_shadow_map = true; }
        void drawDebug();
 
        video::ITexture *get_texture()
        {
                return shadowMapTextureFinal;
        }
 
 
        bool is_active() const { return m_shadows_enabled && shadowMapTextureFinal != nullptr; }
        void setTimeOfDay(float isDay) { m_time_day = isDay; };
        void setShadowIntensity(float shadow_intensity);
        void setShadowTint(video::SColor shadow_tint) { m_shadow_tint = shadow_tint; }
 
        float getShadowStrength() const { return m_shadows_enabled ? m_shadow_strength : 0.0f; }
        video::SColor getShadowTint() const { return m_shadow_tint; }
        float getTimeOfDay() const { return m_time_day; }
 
        f32 getPerspectiveBiasXY() { return m_perspective_bias_xy; }
        f32 getPerspectiveBiasZ() { return m_perspective_bias_z; }
 
        static bool isSupported(video::IVideoDriver *driver);
 
private:
        video::ITexture *getSMTexture(const std::string &shadow_map_name,
                        video::ECOLOR_FORMAT texture_format,
                        bool force_creation = false);
 
        void renderShadowMap(video::ITexture *target, DirectionalLight &light,
                        scene::E_SCENE_NODE_RENDER_PASS pass =
                                        scene::ESNRP_SOLID);
        void renderShadowObjects(video::ITexture *target, DirectionalLight &light);
        void updateSMTextures();
 
        void disable();
        void enable() { m_shadows_enabled = m_shadows_supported; }
 
        // a bunch of variables
        scene::ISceneManager *m_smgr{nullptr};
        video::IVideoDriver *m_driver{nullptr};
        Client *m_client{nullptr};
        video::ITexture *shadowMapClientMap{nullptr};
        video::ITexture *shadowMapClientMapFuture{nullptr};
        video::ITexture *shadowMapTextureFinal{nullptr};
        video::ITexture *shadowMapTextureDynamicObjects{nullptr};
        video::ITexture *shadowMapTextureColors{nullptr};
 
        std::vector<DirectionalLight> m_light_list;
        std::vector<NodeToApply> m_shadow_node_array;
 
        float m_shadow_strength;
        video::SColor m_shadow_tint;
        float m_shadow_strength_gamma;
        float m_shadow_map_max_distance;
        u32 m_shadow_map_texture_size;
        float m_time_day;
        bool m_shadow_map_texture_32bit;
        bool m_shadows_enabled;
        bool m_shadows_supported;
        bool m_shadow_map_colored;
        bool m_force_update_shadow_map;
        u8 m_map_shadow_update_frames; /* Use this number of frames to update map shaodw */
        u8 m_current_frame; /* Current frame */
        f32 m_perspective_bias_xy;
        f32 m_perspective_bias_z;
 
        video::ECOLOR_FORMAT m_texture_format{video::ECF_R16F};
        video::ECOLOR_FORMAT m_texture_format_color{video::ECF_R16G16};
 
        // Shadow Shader stuff
 
        void createShaders();
 
        // _a suffix is with support for array textures
        video::E_MATERIAL_TYPE depth_shader{video::EMT_INVALID},
                depth_shader_a{video::EMT_INVALID};
        video::E_MATERIAL_TYPE depth_shader_trans{video::EMT_INVALID},
                depth_shader_trans_a{video::EMT_INVALID};
 
        std::vector<ShadowDepthUniformSetter*> m_shadow_depth_cb;
 
        ShadowScreenQuad *m_screen_quad{nullptr};
};
 
std::unique_ptr<ShadowRenderer> createShadowRenderer(IrrlichtDevice *device, Client *client);