EffekseerRendererVulkan.h

 
#ifndef __EFFEKSEERRENDERER_VULKAN_BASE_PRE_H__
#define __EFFEKSEERRENDERER_VULKAN_BASE_PRE_H__
 
#include <Effekseer.h>
 
#ifdef _WIN32
#define VK_USE_PLATFORM_WIN32_KHR
#endif
#include <vulkan/vulkan.h>
 
#endif
 
#ifndef __EFFEKSEERRENDERER_RENDERER_H__
#define __EFFEKSEERRENDERER_RENDERER_H__
 
//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include <Effekseer.h>
 
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
 
namespace Effekseer
{
namespace Backend
{
class VertexBuffer;
class IndexBuffer;
class GraphicsDevice;
} // namespace Backend
} // namespace Effekseer
 
namespace EffekseerRenderer
{
 
class Renderer;
using RendererRef = ::Effekseer::RefPtr<Renderer>;
 
struct ExternalShaderSettings
{
    Effekseer::Backend::ShaderRef StandardShader;
    Effekseer::Backend::ShaderRef ModelShader;
    Effekseer::AlphaBlendType Blend;
};
 
class DistortingCallback
{
public:
    DistortingCallback()
    {
    }
    virtual ~DistortingCallback()
    {
    }
 
    virtual bool OnDistorting(Renderer* renderer)
    {
        return false;
    }
};
 
enum class UVStyle
{
    Normal,
    VerticalFlipped,
};
 
enum class ProxyTextureType
{
    White,
    Normal,
};
 
class CommandList : public ::Effekseer::IReference
{
public:
    CommandList() = default;
    virtual ~CommandList() = default;
};
 
class SingleFrameMemoryPool : public ::Effekseer::IReference
{
public:
    SingleFrameMemoryPool() = default;
    virtual ~SingleFrameMemoryPool() = default;
 
    virtual void NewFrame()
    {
    }
};
 
struct DepthReconstructionParameter
{
    float DepthBufferScale = 1.0f;
    float DepthBufferOffset = 0.0f;
    float ProjectionMatrix33 = 0.0f;
    float ProjectionMatrix34 = 0.0f;
    float ProjectionMatrix43 = 0.0f;
    float ProjectionMatrix44 = 0.0f;
};
 
::Effekseer::ModelLoaderRef CreateModelLoader(::Effekseer::Backend::GraphicsDeviceRef gprahicsDevice, ::Effekseer::FileInterfaceRef fileInterface = nullptr);
 
class Renderer : public ::Effekseer::IReference
{
protected:
    Renderer();
    virtual ~Renderer();
 
    class Impl;
    std::unique_ptr<Impl> impl;
 
public:
    Impl* GetImpl();
 
    virtual void OnLostDevice() = 0;
 
    virtual void OnResetDevice() = 0;
 
    virtual void SetRestorationOfStatesFlag(bool flag) = 0;
 
    virtual bool BeginRendering() = 0;
 
    virtual bool EndRendering() = 0;
 
    virtual ::Effekseer::Vector3D GetLightDirection() const;
 
    virtual void SetLightDirection(const ::Effekseer::Vector3D& direction);
 
    virtual const ::Effekseer::Color& GetLightColor() const;
 
    virtual void SetLightColor(const ::Effekseer::Color& color);
 
    virtual const ::Effekseer::Color& GetLightAmbientColor() const;
 
    virtual void SetLightAmbientColor(const ::Effekseer::Color& color);
 
    virtual int32_t GetSquareMaxCount() const = 0;
 
    virtual ::Effekseer::Matrix44 GetProjectionMatrix() const;
 
    virtual void SetProjectionMatrix(const ::Effekseer::Matrix44& mat);
 
    virtual ::Effekseer::Matrix44 GetCameraMatrix() const;
 
    virtual void SetCameraMatrix(const ::Effekseer::Matrix44& mat);
 
    virtual ::Effekseer::Matrix44 GetCameraProjectionMatrix() const;
 
    virtual ::Effekseer::Vector3D GetCameraFrontDirection() const;
 
    virtual ::Effekseer::Vector3D GetCameraPosition() const;
 
    virtual void SetCameraParameter(const ::Effekseer::Vector3D& front, const ::Effekseer::Vector3D& position);
 
    virtual ::Effekseer::SpriteRendererRef CreateSpriteRenderer() = 0;
 
    virtual ::Effekseer::RibbonRendererRef CreateRibbonRenderer() = 0;
 
    virtual ::Effekseer::RingRendererRef CreateRingRenderer() = 0;
 
    virtual ::Effekseer::ModelRendererRef CreateModelRenderer() = 0;
 
    virtual ::Effekseer::TrackRendererRef CreateTrackRenderer() = 0;
 
    virtual ::Effekseer::TextureLoaderRef CreateTextureLoader(::Effekseer::FileInterfaceRef fileInterface = nullptr) = 0;
 
    virtual ::Effekseer::ModelLoaderRef CreateModelLoader(::Effekseer::FileInterfaceRef fileInterface = nullptr) = 0;
 
    virtual ::Effekseer::MaterialLoaderRef CreateMaterialLoader(::Effekseer::FileInterfaceRef fileInterface = nullptr) = 0;
 
    virtual void ResetRenderState() = 0;
 
    virtual DistortingCallback* GetDistortingCallback() = 0;
 
    virtual void SetDistortingCallback(DistortingCallback* callback) = 0;
 
    virtual int32_t GetDrawCallCount() const;
 
    virtual int32_t GetDrawVertexCount() const;
 
    virtual void ResetDrawCallCount();
 
    virtual void ResetDrawVertexCount();
 
    virtual Effekseer::RenderMode GetRenderMode() const;
 
    virtual void SetRenderMode(Effekseer::RenderMode renderMode);
 
    virtual UVStyle GetTextureUVStyle() const;
 
    virtual void SetTextureUVStyle(UVStyle style);
 
    virtual UVStyle GetBackgroundTextureUVStyle() const;
 
    virtual void SetBackgroundTextureUVStyle(UVStyle style);
 
    virtual float GetTime() const;
 
    virtual void SetTime(float time);
 
    virtual void SetCommandList(Effekseer::RefPtr<CommandList> commandList)
    {
    }
 
    virtual const ::Effekseer::Backend::TextureRef& GetBackground();
 
    virtual void SetBackground(::Effekseer::Backend::TextureRef texture);
 
    virtual ::Effekseer::Backend::TextureRef CreateProxyTexture(ProxyTextureType type);
 
    virtual void DeleteProxyTexture(Effekseer::Backend::TextureRef& texture);
 
    virtual void GetDepth(::Effekseer::Backend::TextureRef& texture, DepthReconstructionParameter& reconstructionParam);
 
    virtual void SetDepth(::Effekseer::Backend::TextureRef texture, const DepthReconstructionParameter& reconstructionParam);
 
    virtual void SetMaintainGammaColorInLinearColorSpace(bool value);
 
    virtual Effekseer::Backend::GraphicsDeviceRef GetGraphicsDevice() const;
 
    virtual std::shared_ptr<ExternalShaderSettings> GetExternalShaderSettings() const;
 
    virtual void SetExternalShaderSettings(const std::shared_ptr<ExternalShaderSettings>& settings);
};
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
} // namespace EffekseerRenderer
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif // __EFFEKSEERRENDERER_RENDERER_H__
#ifndef __EFFEKSEERRENDERER_TEXTURELOADER_H__
#define __EFFEKSEERRENDERER_TEXTURELOADER_H__
 
#include <Effekseer.h>
 
namespace EffekseerRenderer
{
 
::Effekseer::TextureLoaderRef CreateTextureLoader(::Effekseer::Backend::GraphicsDeviceRef gprahicsDevice,
                                                  ::Effekseer::FileInterfaceRef fileInterface = nullptr,
                                                  ::Effekseer::ColorSpaceType colorSpaceType = ::Effekseer::ColorSpaceType::Gamma);
 
} // namespace EffekseerRenderer
 
#endif // __EFFEKSEERRENDERER_TEXTURELOADER_H__
 
#ifndef __EFFEKSEERRENDERER_VULKAN_RENDERER_H__
#define __EFFEKSEERRENDERER_VULKAN_RENDERER_H__
 
#include <functional>
 
namespace EffekseerRendererVulkan
{
 
struct VulkanImageInfo
{
    VkImage image;
    VkImageAspectFlags aspect;
    VkFormat format;
};
 
struct RenderPassInformation
{
    bool DoesPresentToScreen = false;
    std::array<VkFormat, 8> RenderTextureFormats;
    int32_t RenderTextureCount = 1;
    VkFormat DepthFormat = VK_FORMAT_UNDEFINED;
};
 
::Effekseer::Backend::GraphicsDeviceRef CreateGraphicsDevice(
    VkPhysicalDevice physicalDevice, VkDevice device, VkQueue transfarQueue, VkCommandPool transfarCommandPool, int32_t swapBufferCount);
 
::EffekseerRenderer::RendererRef
Create(::Effekseer::Backend::GraphicsDeviceRef graphicsDevice, RenderPassInformation renderPassInformation, int32_t squareMaxCount);
 
::EffekseerRenderer::RendererRef Create(VkPhysicalDevice physicalDevice,
                                      VkDevice device,
                                      VkQueue transfarQueue,
                                      VkCommandPool transfarCommandPool,
                                      int32_t swapBufferCount,
                                      RenderPassInformation renderPassInformation,
                                      int32_t squareMaxCount);
 
Effekseer::Backend::TextureRef CreateTexture(::Effekseer::Backend::GraphicsDeviceRef graphicsDevice, const VulkanImageInfo& info);
 
void BeginCommandList(Effekseer::RefPtr<EffekseerRenderer::CommandList> commandList, VkCommandBuffer nativeCommandList);
 
void EndCommandList(Effekseer::RefPtr<EffekseerRenderer::CommandList> commandList);
 
} // namespace EffekseerRendererVulkan
 
#endif
 
#ifndef __EFFEKSEERRENDERER_LLGI_COMMON_H__
#define __EFFEKSEERRENDERER_LLGI_COMMON_H__
 
#include <Effekseer.h>
 
namespace EffekseerRenderer
{
 
struct RenderPassPipelineStateKey
{
    std::array<Effekseer::Backend::TextureFormatType, 8> RenderTargetFormats;
    int32_t RenderTargetCount = 0;
    Effekseer::Backend::TextureFormatType DepthFormat = Effekseer::Backend::TextureFormatType::Unknown;
};
 
void ChangeRenderPassPipelineState(EffekseerRenderer::RendererRef renderer, RenderPassPipelineStateKey key);
 
void FlushAndWait(::Effekseer::Backend::GraphicsDeviceRef graphicsDevice);
 
Effekseer::RefPtr<EffekseerRenderer::CommandList> CreateCommandList(::Effekseer::Backend::GraphicsDeviceRef graphicsDevice,
                                                                    Effekseer::RefPtr<::EffekseerRenderer::SingleFrameMemoryPool> memoryPool);
 
Effekseer::RefPtr<EffekseerRenderer::SingleFrameMemoryPool> CreateSingleFrameMemoryPool(::Effekseer::Backend::GraphicsDeviceRef renderer);
 
} // namespace EffekseerRenderer
 
#endif