EffekseerRendererDX9.h

 
#ifndef __EFFEKSEERRENDERER_DX9_BASE_PRE_H__
#define __EFFEKSEERRENDERER_DX9_BASE_PRE_H__
 
//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include <Effekseer.h>
 
#include <d3d9.h>
#include <windows.h>
 
#if _WIN32
#pragma comment(lib, "d3d9.lib")
#endif
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace EffekseerRendererDX9
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Renderer;
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
} // namespace EffekseerRendererDX9
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif // __EFFEKSEERRENDERER_DX9_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_DX9_RENDERER_H__
#define __EFFEKSEERRENDERER_DX9_RENDERER_H__
 
//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace EffekseerRendererDX9
{
 
::Effekseer::Backend::GraphicsDeviceRef CreateGraphicsDevice(LPDIRECT3DDEVICE9 device);
 
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);
 
    static RendererRef Create(LPDIRECT3DDEVICE9 device, int32_t squareMaxCount);
 
    virtual LPDIRECT3DDEVICE9 GetDevice() = 0;
 
    virtual void ChangeDevice(LPDIRECT3DDEVICE9 device) = 0;
 
    virtual void SetBackground(IDirect3DTexture9* background) = 0;
};
 
} // namespace EffekseerRendererDX9
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif // __EFFEKSEERRENDERER_DX9_RENDERER_H__