Swapcain.h

浏览该文件的文档.

#ifndef FCT_SWAPCAIN_H
#define FCT_SWAPCAIN_H
#include "../Type/type.h"
#include "Fence.h"
#include "../MutilThreadBase/RefCount.h"
#include "../Context/ImageRenderTarget.h"
#include "../RHI/Semaphore.h"
#include "../Base/IEventSystem.h"
#include "SwapchainEvent.h"
namespace FCT
{
    namespace RHI
    {
        class Swapchain : public RefCount,public IEventSystem<EventSystemConfig::TriggerOnly>
        {
        public:
            Swapchain()
            {
                m_nativeHandle = nullptr;
                m_width = 0;
                m_height = 0;
                m_hasRecreatedInThisFrame = false;
            }

            virtual uint32_t getImageCount() const = 0;
            virtual Samples getSampleCount() const = 0;
            virtual ~Swapchain() = default;
            void nativeHandle(void* handle)
            {
                m_nativeHandle = handle;
            }

            void size(int width,int height)
            {
                m_dstWidth = width;
                m_dstHeight = height;
            }

            virtual FCT::Image* image() const = 0;
            virtual void enableDepthBuffer(Format format) = 0;
            virtual void create() = 0;
            virtual void present() = 0;
            virtual Format getFormat() const = 0;
            virtual Samples getSamples() const = 0;
            virtual bool acquireFirstImage() = 0;
            virtual ImageRenderTarget* target() const = 0;
            virtual RHI::Semaphore* getImageAvailableSemaphore() = 0;
            virtual void setPresentFinshSemaphore(RHI::Semaphore* semaphore) = 0;
            virtual void needRecreate(int width,int height) = 0;
            void addRenderFinshFence(RHI::Fence* fence)
            {
                m_renderFinshFences.push_back(fence);
            }
            void clearRenderFinshFences()
            {
                m_renderFinshFences.clear();
            }

            void addRenderFinshSemaphore(RHI::Semaphore* semaphore)  {
                m_renderFinshSemaphores.push_back(semaphore);
            }
            void clearRenderFinshSemaphores()  {
                m_renderFinshSemaphores.clear();
            }
            virtual void sync() = 0;
            bool hasRecreatedInThisFrame() const
            {
                return m_hasRecreatedInThisFrame;
            }

            uint32_t width() const
            {
                return m_width;
            }

            uint32_t height() const
            {
                return m_height;
            }
        protected:
            std::vector<RHI::Fence*> m_renderFinshFences;
            std::vector<RHI::Semaphore*> m_renderFinshSemaphores;
            void* m_nativeHandle;
            uint32_t m_width;
            uint32_t m_height;
            uint32_t m_dstWidth = 0;
            uint32_t m_dstHeight = 0;
            bool m_hasRecreatedInThisFrame;
        };
    }
}
#endif //FCT_SWAPCAIN_H