EffekseerRendererDX9.h

Go to the documentation of this file.

#ifndef __EFFEKSEERRENDERER_DX9_BASE_PRE_H__
#define __EFFEKSEERRENDERER_DX9_BASE_PRE_H__

//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include <Effekseer.h>

#include <windows.h>
#include <d3d9.h>

#if _WIN32
#pragma comment(lib, "gdiplus.lib")
#pragma comment(lib, "d3d9.lib" )
#endif

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace EffekseerRendererDX9
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Renderer;

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEERRENDERER_DX9_PRE_BASE_H__

#ifndef __EFFEKSEERRENDERER_RENDERER_H__
#define __EFFEKSEERRENDERER_RENDERER_H__

//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include <Effekseer.h>

//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
namespace EffekseerRenderer
{
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------

class DistortingCallback
{
public:
        DistortingCallback() {}
        virtual ~DistortingCallback() {}

        virtual bool OnDistorting() { return false; }
};

enum class UVStyle
{
        Normal,
        VerticalFlipped,
};

enum class ProxyTextureType
{
        White,
        Normal,
};

class GraphicsDevice : public ::Effekseer::IReference
{
public:
        GraphicsDevice() = default;
        virtual ~GraphicsDevice() = default;
};      
        
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() {}
};

class Renderer
        : public ::Effekseer::IReference
{
protected:
        Renderer();
        virtual ~Renderer();

        class Impl;
        Impl* impl = nullptr;

public:

        Impl* GetImpl();

        virtual void OnLostDevice() = 0;

        virtual void OnResetDevice() = 0;

        virtual void Destroy() = 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::SpriteRenderer* CreateSpriteRenderer() = 0;

        virtual ::Effekseer::RibbonRenderer* CreateRibbonRenderer() = 0;

        virtual ::Effekseer::RingRenderer* CreateRingRenderer() = 0;

        virtual ::Effekseer::ModelRenderer* CreateModelRenderer() = 0;

        virtual ::Effekseer::TrackRenderer* CreateTrackRenderer() = 0;

        virtual ::Effekseer::TextureLoader* CreateTextureLoader( ::Effekseer::FileInterface* fileInterface = NULL ) = 0;

        virtual ::Effekseer::ModelLoader* CreateModelLoader( ::Effekseer::FileInterface* fileInterface = NULL ) = 0;

        virtual ::Effekseer::MaterialLoader* CreateMaterialLoader(::Effekseer::FileInterface* 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(CommandList* commandList) {}

        virtual void SetBackgroundTexture(::Effekseer::TextureData* textureData);

        virtual Effekseer::TextureData* CreateProxyTexture(ProxyTextureType type) { return nullptr; }

        virtual void DeleteProxyTexture(Effekseer::TextureData* data) { }
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEERRENDERER_RENDERER_H__

#ifndef __EFFEKSEERRENDERER_DX9_RENDERER_H__
#define __EFFEKSEERRENDERER_DX9_RENDERER_H__

//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace EffekseerRendererDX9
{

::Effekseer::TextureLoader* CreateTextureLoader(LPDIRECT3DDEVICE9 device, ::Effekseer::FileInterface* fileInterface = NULL);

::Effekseer::ModelLoader* CreateModelLoader(LPDIRECT3DDEVICE9 device, ::Effekseer::FileInterface* fileInterface = NULL);

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Renderer
        : public ::EffekseerRenderer::Renderer
{
protected:
        Renderer() {}
        virtual ~Renderer() {}

public:
        static Renderer* Create( LPDIRECT3DDEVICE9 device, int32_t squareMaxCount );

        virtual LPDIRECT3DDEVICE9 GetDevice() = 0;

        virtual void ChangeDevice( LPDIRECT3DDEVICE9 device ) = 0;

        virtual Effekseer::TextureData* GetBackground() = 0;

        virtual void SetBackground(IDirect3DTexture9* background) = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Model : public Effekseer::Model
{
private:

public:

        struct InternalModel
        {
                IDirect3DVertexBuffer9*         VertexBuffer;
                IDirect3DIndexBuffer9*          IndexBuffer;
                int32_t                                         VertexCount;
                int32_t                                         IndexCount;
                int32_t                                         FaceCount;

                InternalModel()
                {
                        VertexBuffer = nullptr;
                        IndexBuffer = nullptr;
                        VertexCount = 0;
                        IndexCount = 0;
                        FaceCount = 0;
                }

                virtual ~InternalModel()
                {
                        ES_SAFE_RELEASE(VertexBuffer);
                        ES_SAFE_RELEASE(IndexBuffer);
                }
        };

        InternalModel*                          InternalModels = nullptr;
        int32_t                                         ModelCount;

        Model( uint8_t* data, int32_t size )
                : Effekseer::Model      ( data, size )
                , InternalModels        (nullptr)
                , ModelCount            ( 0 )
        {
                this->m_vertexSize = sizeof(VertexWithIndex);
        }

        virtual ~Model()
        {
                ES_SAFE_DELETE_ARRAY(InternalModels);
        }
};


//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEERRENDERER_DX9_RENDERER_H__