renderadvancedservice.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// External Includes
#include <nap/service.h>
#include <depthrendertarget.h>
#include <rendertexturecube.h>
#include <materialinstance.h>
#include <renderablemesh.h>
#include <scene.h>
 
// Local includes
#include "cuberendertarget.h"
#include "cubedepthrendertarget.h"
#include "lightcomponent.h"
#include "lightflags.h"
#include "rendertag.h"
#include "emptymesh.h"
#include "cubemapfromfile.h"
 
namespace nap
{
    // Forward declares
    class RenderService;
    class RenderableComponentInstance;
    class Material;
 
    // Light scene identifier
    namespace scene
    {
        namespace light
        {
            inline constexpr const char* id = "lightscene";
        }
    }
 
 
    // Render Advanced Service
 
    class NAPAPI RenderAdvancedServiceConfiguration : public ServiceConfiguration
    {
        RTTI_ENABLE(ServiceConfiguration)
        friend class PreRenderCubeMapsCommand;
    public:
        virtual rtti::TypeInfo getServiceType() const;
 
        DepthRenderTexture2D::EDepthFormat mDepthFormat         = DepthRenderTexture2D::EDepthFormat::D16;      
        DepthRenderTextureCube::EDepthFormat mDepthFormatCube   = DepthRenderTextureCube::EDepthFormat::D16;    
        bool mEnableShadowMapping                               = true;                                         
    };
 
 
    class NAPAPI RenderAdvancedService : public Service
    {
        friend class LightComponentInstance;
        friend class CubeMapFromFile;
        RTTI_ENABLE(Service)
    public:
        // Default Constructor
        RenderAdvancedService(ServiceConfiguration* configuration);
 
        bool isShadowMappingEnabled() const                                                 { return mShadowMappingEnabled; }
 
       const std::vector<LightComponentInstance*>& getLights()                              { return mLightComponents; }
 
        void renderShadows(const std::vector<RenderableComponentInstance*>& renderComps, bool updateMaterials = true, RenderMask renderMask = 0);
 
        void renderLocators(IRenderTarget& renderTarget, CameraComponentInstance& camera, bool drawFrustrum);
 
        void pushLights(const std::vector<RenderableComponentInstance*>& renderComps);
 
        static uint getMaximumLightCount()                                                  { return mMaxLightCount; }
 
    protected:
        virtual void getDependentServices(std::vector<rtti::TypeInfo>& dependencies) override;
 
        virtual bool init(nap::utility::ErrorState& errorState) override;
 
        virtual void preShutdown() override;
 
        virtual void shutdown() override;
 
        virtual void preResourcesLoaded() override;
 
        virtual void postResourcesLoaded() override;
 
        SpawnedEntityInstance spawn(const nap::Entity& entity, nap::utility::ErrorState& error);
 
        void destroy(SpawnedEntityInstance& entityInstance);
 
        virtual void postUpdate(double deltaTime);
 
    private:
        void pushLightsInternal(const std::vector<MaterialInstance*>& materials);
        void registerLightComponent(LightComponentInstance& light);
        void removeLightComponent(LightComponentInstance& light);
        void registerCubeMap(CubeMapFromFile& cubemap);
        void removeCubeMap(CubeMapFromFile& cubemap);
        bool initServiceResources(utility::ErrorState& errorState);
 
        struct ShadowMapEntry
        {
            ShadowMapEntry(std::unique_ptr<DepthRenderTarget> target, std::unique_ptr<DepthRenderTexture2D> texture) :
                mTarget(std::move(target)), mTexture(std::move(texture))
            {
                mTarget->mDepthTexture = mTexture.get();
            }
 
            std::unique_ptr<DepthRenderTarget> mTarget;
            std::unique_ptr<DepthRenderTexture2D> mTexture;
        };
 
        struct CubeMapEntry
        {
            CubeMapEntry(std::unique_ptr<CubeDepthRenderTarget> target, std::unique_ptr<DepthRenderTextureCube> texture) :
                mTarget(std::move(target)), mTexture(std::move(texture))
            {
                mTarget->mCubeDepthTexture = mTexture.get();
            }
 
            std::unique_ptr<CubeDepthRenderTarget> mTarget;
            std::unique_ptr<DepthRenderTextureCube> mTexture;
        };
 
        // Reference to render service
        RenderService* mRenderService = nullptr;                                        
 
        // Registered light component instances
        std::vector<LightComponentInstance*> mLightComponents;                          
 
        // Shadow mapping
        std::unordered_map<LightComponentInstance*, std::unique_ptr<ShadowMapEntry>> mLightDepthMap;    
        std::unordered_map<LightComponentInstance*, std::unique_ptr<CubeMapEntry>> mLightCubeMap;       
        std::unordered_map<LightComponentInstance*, LightFlags> mLightFlagsMap;                         
 
        std::unique_ptr<Sampler2DArray> mSampler2DResource;                             
        std::unique_ptr<SamplerCubeArray> mSamplerCubeResource;                         
        std::unique_ptr<DepthRenderTexture2D> mShadowTextureDummy;                      
        std::unique_ptr<nap::Scene> mLightScene = nullptr;                              
 
        bool mShadowMappingEnabled = true;                                              
        bool mShadowResourcesCreated = false;                                           
 
        // Cube maps from file
        std::unordered_map<CubeMapFromFile*, std::unique_ptr<CubeRenderTarget>> mCubeMapTargets;        
 
        std::unique_ptr<EmptyMesh>                  mNoMesh;                            
        std::unique_ptr<MaterialInstanceResource>   mCubeMaterialInstanceResource;      
        std::unique_ptr<MaterialInstance>           mCubeMaterialInstance;              
        Material*                                   mCubeMapMaterial = nullptr;         
 
        static constexpr const uint mRequiredVulkanVersionMajor = 1;                    
        static constexpr const uint mRequiredVulkanVersionMinor = 0;                    
        static constexpr const uint mMaxLightCount = 8;                                 
    };
}