EffekseerRendererDX11.h

 
#ifndef __EFFEKSEERRENDERER_DX11_BASE_PRE_H__
#define __EFFEKSEERRENDERER_DX11_BASE_PRE_H__
 
//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include <Effekseer.h>
 
#include <d3d11.h>
#include <windows.h>
 
#if _WIN32
#pragma comment(lib, "d3d11.lib")
#endif
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace EffekseerRendererDX11
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Renderer;
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
} // namespace EffekseerRendererDX11
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif // __EFFEKSEERRENDERER_DX11_PRE_BASE_H__
 
#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_DX11_RENDERER_H__
#define __EFFEKSEERRENDERER_DX11_RENDERER_H__
 
//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace EffekseerRendererDX11
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 
::Effekseer::Backend::GraphicsDeviceRef CreateGraphicsDevice(ID3D11Device* device,
                                                             ID3D11DeviceContext* context);
 
::Effekseer::MaterialLoaderRef CreateMaterialLoader(::Effekseer::Backend::GraphicsDeviceRef graphicsDevice, ::Effekseer::FileInterfaceRef fileInterface = nullptr);
 
::Effekseer::Backend::TextureRef CreateTexture(::Effekseer::Backend::GraphicsDeviceRef gprahicsDevice, ID3D11ShaderResourceView* srv, ID3D11RenderTargetView* rtv, ID3D11DepthStencilView* dsv);
 
struct TextureProperty
{
    ID3D11ShaderResourceView* ShaderResourceViewPtr = nullptr;
    ID3D11RenderTargetView* RenderTargetViewPtr = nullptr;
    ID3D11DepthStencilView* DepthStencilViewPtr = nullptr;
};
 
TextureProperty GetTextureProperty(::Effekseer::Backend::TextureRef texture);
 
class Renderer;
using RendererRef = ::Effekseer::RefPtr<Renderer>;
 
class Renderer : public ::EffekseerRenderer::Renderer
{
protected:
    Renderer()
    {
    }
    virtual ~Renderer()
    {
    }
 
public:
    static RendererRef Create(::Effekseer::Backend::GraphicsDeviceRef graphicsDevice,
                              int32_t squareMaxCount,
                              D3D11_COMPARISON_FUNC depthFunc = D3D11_COMPARISON_LESS_EQUAL,
                              bool isMSAAEnabled = false);
    static RendererRef Create(ID3D11Device* device,
                              ID3D11DeviceContext* context,
                              int32_t squareMaxCount,
                              D3D11_COMPARISON_FUNC depthFunc = D3D11_COMPARISON_LESS_EQUAL,
                              bool isMSAAEnabled = false);
 
    virtual ID3D11Device* GetDevice() = 0;
 
    virtual ID3D11DeviceContext* GetContext() = 0;
 
    [[deprecated("please use EffekseerRenderer::SetBackground")]] virtual void SetBackground(ID3D11ShaderResourceView* background) = 0;
 
    virtual void ResetStateForDefferedContext() = 0;
};
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
} // namespace EffekseerRendererDX11
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif // __EFFEKSEERRENDERER_DX11_RENDERER_H__