snapshot.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
 
// Local Includes
#include "surfacedescriptor.h"
#include "renderservice.h"
#include "bitmap.h"
#include "bitmapfilebuffer.h"
#include "perspcameracomponent.h"
 
// External Includes
#include <nap/resource.h>
#include <nap/core.h>
#include <nap/signalslot.h>
 
namespace nap
{
    // Forward Declares
    class SnapshotRenderTarget;
 
    class NAPAPI Snapshot : public Resource
    {
        friend class SnapshotRenderTarget;
        RTTI_ENABLE(Resource)
    public:
 
        Snapshot(Core& core);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        void setClearColor(const RGBAColorFloat& color);
 
        void snap(PerspCameraComponentInstance& camera, std::vector<RenderableComponentInstance*>& comps);
 
 
        void snap(PerspCameraComponentInstance& camera, std::function<void(nap::SnapshotRenderTarget&)> renderCallback);
 
        glm::u32vec2 getSize() { return { mWidth, mHeight }; };
 
        uint32 mWidth = 1920;                                                       
        uint32 mHeight = 1080;                                                      
        uint32 mDivisor = 1;                                                        
        RGBAColorFloat mClearColor = { 0.0f, 0.0f, 0.0f, 0.0f };                    
        RenderTexture2D::EFormat mTextureFormat = RenderTexture2D::EFormat::RGBA8;  
        ERasterizationSamples mRequestedSamples = ERasterizationSamples::Four;      
        bool mSampleShading = true;                                                 
 
        std::string mOutputDirectory = "snapshots";                                 
        BitmapFileBuffer::EImageFileFormat mImageFileFormat = BitmapFileBuffer::EImageFileFormat::PNG;  
 
        // Triggered when a snapshot is being processed
        nap::Signal<> onSnapshot;
 
        // Triggered when a snapshot is finished being written to disk
        nap::Signal<std::string> onSnapshotSaved;
 
    protected:
        RenderService* mRenderService = nullptr;
 
    private:
        bool save();
        nap::Slot<> mSaveBitmapSlot = { [this]() -> void { save(); } };
 
        void postSnap();
 
        uint32 mNumRows = 1;
        uint32 mNumColumns = 1;
 
        uint32 mCellWidth = 1920;
        uint32 mCellHeight = 1080;
 
        uint32 mNumCells = 0;
        glm::u32vec2 mCellSize = { 0, 0 };
 
        std::vector<std::unique_ptr<RenderTexture2D>> mColorTextures;
        std::unique_ptr<SnapshotRenderTarget> mRenderTarget;
 
        std::vector<bool> mCellUpdateFlags;                                         //< List of update flags for each cell
        nap::Signal<> onCellsUpdated;                                               //< Triggered when all cells are updated
 
        std::unique_ptr<BitmapFileBuffer> mDestBitmapFileBuffer;                    //< The destination bitmap file buffer
    };
}