Effekseer.h

Go to the documentation of this file.

#ifndef __EFFEKSEER_BASE_PRE_H__
#define __EFFEKSEER_BASE_PRE_H__

//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
#include <atomic>
#include <stdint.h>
#include <climits>
#include <vector>
#include <cfloat>
#include <array>
#include <memory>

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#ifdef _WIN32
#define EFK_STDCALL     __stdcall
#else
#define EFK_STDCALL
#endif

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

#ifdef _WIN32
//#include <windows.h>
#elif defined(_PSVITA)
#include "Effekseer.PSVita.h"
#elif defined(_PS4)
#include "Effekseer.PS4.h"
#elif defined(_SWITCH)
#include "Effekseer.Switch.h"
#elif defined(_XBOXONE)
#include "Effekseer.XBoxOne.h"
#else
#include <unistd.h>
#include <pthread.h>
#include <sys/time.h>
#endif

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
typedef char16_t                        EFK_CHAR;

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
struct Vector2D;
struct Vector3D;
struct Matrix43;
struct Matrix44;
struct RectF;

class Manager;
class Effect;
class EffectNode;

class ParticleRenderer;
class SpriteRenderer;
class RibbonRenderer;
class RingRenderer;
class ModelRenderer;
class TrackRenderer;

class Setting;
class EffectLoader;
class TextureLoader;
class MaterialLoader;

class SoundPlayer;
class SoundLoader;

class ModelLoader;

class Model;

typedef int     Handle;

typedef void*(EFK_STDCALL* MallocFunc)(unsigned int size);

typedef void(EFK_STDCALL* FreeFunc)(void* p, unsigned int size);

typedef void*(EFK_STDCALL* AlignedMallocFunc)(unsigned int size, unsigned int alignment);

typedef void(EFK_STDCALL* AlignedFreeFunc)(void* p, unsigned int size);

typedef int(EFK_STDCALL* RandFunc)(void);

typedef void ( EFK_STDCALL *EffectInstanceRemovingCallback ) ( Manager* manager, Handle handle, bool isRemovingManager );

#define ES_SAFE_ADDREF(val)                                             if ( (val) != NULL ) { (val)->AddRef(); }
#define ES_SAFE_RELEASE(val)                                    if ( (val) != NULL ) { (val)->Release(); (val) = NULL; }
#define ES_SAFE_DELETE(val)                                             if ( (val) != NULL ) { delete (val); (val) = NULL; }
#define ES_SAFE_DELETE_ARRAY(val)                               if ( (val) != NULL ) { delete [] (val); (val) = NULL; }

#define EFK_ASSERT(x) assert(x)

const int32_t UserTextureSlotMax = 6;

const int32_t TextureSlotMax = 8;

const int32_t LocalFieldSlotMax = 4;

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
enum class AlphaBlendType : int32_t
{
        Opacity = 0,
        Blend = 1,
        Add = 2,
        Sub = 3,
        Mul = 4,
};

enum class TextureFilterType : int32_t
{
        Nearest = 0,
        Linear = 1,
};

enum class TextureWrapType : int32_t
{
        Repeat = 0,
        Clamp = 1,
};

enum class CullingType : int32_t
{
        Front = 0,
        Back = 1,
        Double = 2,
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
enum class BillboardType : int32_t
{
        Billboard = 0,
        YAxisFixed = 1,
        Fixed = 2,
        RotatedBillboard = 3,
};

enum class CoordinateSystem : int32_t
{
        LH,
        RH,
};

enum class CullingShape : int32_t
{
        NoneShape = 0,
        Sphere = 1,
};

enum class TextureType : int32_t
{
        Color,
        Normal,
        Distortion,
};

enum class MaterialFileType : int32_t
{
        Code,
        Compiled,
};

enum class TextureFormatType : int32_t
{
        ABGR8,
        BC1,
        BC2,
        BC3,
};

enum class ZSortType : int32_t
{
        None,
        NormalOrder,
        ReverseOrder,
};

//-----------------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------------
enum class RenderMode : int32_t
{
        Normal,                         // 通常描画
        Wireframe,                      // ワイヤーフレーム描画
};

enum class ReloadingThreadType
{
        Main,
        Render,
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
template <typename T,typename U>
T Max( T t, U u )
{
        if( t > (T)u )
        {
                return t;
        }
        return u;
}

template <typename T,typename U>
T Min( T t, U u )
{
        if( t < (T)u )
        {
                return t;
        }
        return u;
}

template <typename T,typename U,typename V>
T Clamp( T t, U max_, V min_ )
{
        if( t > (T)max_ )
        {
                t = (T)max_;
        }

        if( t < (T)min_ )
        {
                t = (T)min_;
        }

        return t;
}

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
inline int32_t ConvertUtf16ToUtf8( int8_t* dst, int32_t dst_size, const int16_t* src )
{
        int32_t cnt = 0;
        const int16_t* wp = src;
        int8_t* cp = dst;

        if (dst_size == 0) return 0;
        
        dst_size -= 3;

        for (cnt = 0; cnt < dst_size; )
        {
                int16_t wc = *wp++;
                if (wc == 0)
                {
                        break;
                }
                if ((wc & ~0x7f) == 0)
                {
                        *cp++ = wc & 0x7f;
                        cnt += 1;
                } else if ((wc & ~0x7ff) == 0)
                {
                        *cp++ = ((wc >>  6) & 0x1f) | 0xc0;
                        *cp++ = ((wc)       & 0x3f) | 0x80;
                        cnt += 2;
                } else {
                        *cp++ = ((wc >> 12) &  0xf) | 0xe0;
                        *cp++ = ((wc >>  6) & 0x3f) | 0x80;
                        *cp++ = ((wc)       & 0x3f) | 0x80;
                        cnt += 3;
                }
        }
        *cp = '\0';
        return cnt;
}

inline int32_t ConvertUtf8ToUtf16( int16_t* dst, int32_t dst_size, const int8_t* src )
{
        int32_t i, code;
        int8_t c0, c1, c2;

        if (dst_size == 0) return 0;
        
        dst_size -= 1;

        for (i = 0; i < dst_size; i++)
        {
                int16_t wc;
                
                c0 = *src++;
                if (c0 == '\0')
                {
                        break;
                }
                // UTF8からUTF16に変換
                code = (uint8_t)c0 >> 4;
                if (code <= 7)
                {
                        // 8bit文字
                        wc = c0;
                } 
                else if (code >= 12 && code <= 13)
                {
                        // 16bit文字
                        c1 = *src++;
                        wc = ((c0 & 0x1F) << 6) | (c1 & 0x3F);
                } 
                else if (code == 14)
                {
                        // 24bit文字
                        c1 = *src++;
                        c2 = *src++;
                        wc = ((c0 & 0x0F) << 12) | ((c1 & 0x3F) << 6) | (c2 & 0x3F);
                } 
                else
                {
                        continue;
                }
                dst[i] = wc;
        }
        dst[i] = 0;
        return i;
}


//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class IReference
{
public:
        virtual int AddRef() = 0;

        virtual int GetRef() = 0;

        virtual int Release() = 0;
};

template <typename T>
struct ReferenceDeleter
{
        void operator()(T* ptr) const
        { 
                if (ptr != nullptr)
                {
                        ptr->Release();
                }
        }
};

template<typename T> 
inline std::unique_ptr<T, ReferenceDeleter<T>> CreateUniqueReference(T* ptr, bool addRef = false)
{ 
        if (ptr == nullptr)
                return std::unique_ptr<T, ReferenceDeleter<T>>(nullptr); 

        if (addRef)
        {
                ptr->AddRef();
        }

        return std::unique_ptr<T, ReferenceDeleter<T>>(ptr); 
}

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class ReferenceObject
        : public IReference
{
private:
        mutable std::atomic<int32_t> m_reference;

public:
        ReferenceObject()
                : m_reference(1)
        {
        }

        virtual ~ReferenceObject()
        {}

        virtual int AddRef()
        {
                std::atomic_fetch_add_explicit(&m_reference, 1, std::memory_order_consume);

                return m_reference;
        }

        virtual int GetRef()
        {
                return m_reference;
        }

        virtual int Release()
        {
                bool destroy = std::atomic_fetch_sub_explicit(&m_reference, 1, std::memory_order_consume) == 1;
                if (destroy)
                {
                        delete this;
                        return 0;
                }

                return m_reference;
        }
};

class IRandObject
{
public:
        IRandObject() = default;
        virtual ~IRandObject() = default;

        virtual float GetRand() = 0;

        virtual float GetRand(float min_, float max_) = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

enum class ColorSpaceType : int32_t
{
        Gamma,
        Linear,
};

struct TextureData
{
        int32_t Width;
        int32_t Height;
        TextureFormatType       TextureFormat;
        void*   UserPtr;
        int64_t UserID;

        bool HasMipmap = true;
};

enum class ShadingModelType : int32_t
{
        Lit,
        Unlit,
};

enum class RendererMaterialType : int32_t
{
        Default = 0,
        BackDistortion = 6,
        Lighting = 7,
        File = 128,
};

class MaterialData
{
public:
        ShadingModelType ShadingModel = ShadingModelType::Lit;
        bool IsSimpleVertex = false;
        bool IsRefractionRequired = false;
        int32_t CustomData1 = 0;
        int32_t CustomData2 = 0;
        int32_t TextureCount = 0;
        int32_t UniformCount = 0;
        std::array<TextureWrapType, UserTextureSlotMax> TextureWrapTypes;
        void* UserPtr = nullptr;
        void* ModelUserPtr = nullptr;
        void* RefractionUserPtr = nullptr;
        void* RefractionModelUserPtr = nullptr;

        MaterialData() = default;
        virtual ~MaterialData() = default;
};

struct MaterialTextureParameter
{
        int32_t Type = 0;
        int32_t Index = 0;
};

struct MaterialParameter
{
        int32_t MaterialIndex = -1;

        std::vector<MaterialTextureParameter> MaterialTextures;

        std::vector<std::array<float, 4>> MaterialUniforms;
};

struct NodeRendererDepthParameter
{
        float DepthOffset = 0.0f;
        bool IsDepthOffsetScaledWithCamera = false;
        bool IsDepthOffsetScaledWithParticleScale = false;
        ZSortType ZSort = ZSortType::None;
        float SuppressionOfScalingByDepth = 1.0f;
        float DepthClipping = FLT_MAX;
};

struct NodeRendererBasicParameter
{
        RendererMaterialType MaterialType = RendererMaterialType::Default;
        int32_t Texture1Index = -1;
        int32_t Texture2Index = -1;
#ifdef __EFFEKSEER_BUILD_VERSION16__
        int32_t Texture3Index = -1;
#endif
        float DistortionIntensity = 0.0f;
        MaterialParameter* MaterialParameterPtr = nullptr;
        AlphaBlendType AlphaBlend = AlphaBlendType::Blend;

        TextureFilterType TextureFilter1 = TextureFilterType::Nearest;
        TextureWrapType TextureWrap1 = TextureWrapType::Repeat;
        TextureFilterType TextureFilter2 = TextureFilterType::Nearest;
        TextureWrapType TextureWrap2 = TextureWrapType::Repeat;
#ifdef __EFFEKSEER_BUILD_VERSION16__
        TextureFilterType TextureFilter3 = TextureFilterType::Nearest;
        TextureWrapType TextureWrap3 = TextureWrapType::Repeat;

        bool EnableInterpolation = false;
        int32_t UVLoopType = 0;
        int32_t InterpolationType = 0;
        int32_t FlipbookDivideX = 1;
        int32_t FlipbookDivideY = 1;
#endif
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_BASE_PRE_H__
#ifndef __EFFEKSEER_CUSTOM_ALLOCATOR_H__
#define __EFFEKSEER_CUSTOM_ALLOCATOR_H__

#include <list>
#include <map>
#include <new>
#include <set>
#include <vector>

namespace Effekseer
{
MallocFunc GetMallocFunc();

void SetMallocFunc(MallocFunc func);

FreeFunc GetFreeFunc();

void SetFreeFunc(FreeFunc func);

AlignedMallocFunc GetAlignedMallocFunc();

void SetAlignedMallocFunc(AlignedMallocFunc func);

AlignedFreeFunc GetAlignedFreeFunc();

void SetAlignedFreeFunc(AlignedFreeFunc func);

MallocFunc GetMallocFunc();

void SetMallocFunc(MallocFunc func);

FreeFunc GetFreeFunc();

void SetFreeFunc(FreeFunc func);

template <class T> struct CustomAllocator
{
        using value_type = T;

        CustomAllocator() {}

        template <class U> CustomAllocator(const CustomAllocator<U>&) {}

        T* allocate(std::size_t n) { return reinterpret_cast<T*>(GetMallocFunc()(sizeof(T) * n)); }
        void deallocate(T* p, std::size_t n) { GetFreeFunc()(p, sizeof(T) * n); }
};

template <class T> struct CustomAlignedAllocator
{
        using value_type = T;

        CustomAlignedAllocator() {}

        template <class U> CustomAlignedAllocator(const CustomAlignedAllocator<U>&) {}

        T* allocate(std::size_t n) { return reinterpret_cast<T*>(GetAlignedMallocFunc()(sizeof(T) * n, 16)); }
        void deallocate(T* p, std::size_t n) { GetAlignedFreeFunc()(p, sizeof(T) * n); }
};

template <class T, class U> bool operator==(const CustomAllocator<T>&, const CustomAllocator<U>&) { return true; }

template <class T, class U> bool operator!=(const CustomAllocator<T>&, const CustomAllocator<U>&) { return false; }

template <class T> using CustomVector = std::vector<T, CustomAllocator<T>>;
template <class T> using CustomAlignedVector = std::vector<T, CustomAlignedAllocator<T>>;
template <class T> using CustomList = std::list<T, CustomAllocator<T>>;
template <class T> using CustomSet = std::set<T, std::less<T>, CustomAllocator<T>>;
template <class T, class U> using CustomMap = std::map<T, U, std::less<T>, CustomAllocator<std::pair<const T, U>>>;

} // namespace Effekseer

#endif // __EFFEKSEER_BASE_PRE_H__
#ifndef __EFFEKSEER_VECTOR2D_H__
#define __EFFEKSEER_VECTOR2D_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
struct Vector2D
{
public:
        float   X;

        float   Y;

        Vector2D();

        Vector2D( float x, float y );

        Vector2D& operator+=( const Vector2D& value );
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_VECTOR3D_H__

#ifndef __EFFEKSEER_VECTOR3D_H__
#define __EFFEKSEER_VECTOR3D_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
struct Vector3D
{
public:
        float   X;

        float   Y;

        float   Z;

        Vector3D();

        Vector3D( float x, float y, float z );

        Vector3D operator-();

        Vector3D operator + ( const Vector3D& o ) const;

        Vector3D operator - ( const Vector3D& o ) const;

        Vector3D operator * ( const float& o ) const;

        Vector3D operator / ( const float& o ) const;

        Vector3D operator * (const Vector3D& o) const;

        Vector3D operator / (const Vector3D& o) const;

        Vector3D& operator += ( const Vector3D& o );

        Vector3D& operator -= ( const Vector3D& o );

        Vector3D& operator *= ( const float& o );

        Vector3D& operator /= ( const float& o );

        bool operator == (const Vector3D& o);

        static void Add( Vector3D* pOut, const Vector3D* pIn1, const Vector3D* pIn2 );

        static Vector3D& Sub( Vector3D& o, const Vector3D& in1, const Vector3D& in2 );

        static float Length( const Vector3D& in );

        static float LengthSq( const Vector3D& in );

        static float Dot( const Vector3D& in1, const Vector3D& in2 );

        static void Normal( Vector3D& o, const Vector3D& in );

        static Vector3D& Cross( Vector3D& o, const Vector3D& in1, const Vector3D& in2 );

        static Vector3D& Transform( Vector3D& o, const Vector3D& in, const Matrix43& mat );

        static Vector3D& Transform( Vector3D& o, const Vector3D& in, const Matrix44& mat );

        static Vector3D& TransformWithW(Vector3D& o, const Vector3D& in, const Matrix44& mat);
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_VECTOR3D_H__

#ifndef __EFFEKSEER_COLOR_H__
#define __EFFEKSEER_COLOR_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
enum ColorMode
{
        COLOR_MODE_RGBA,
        COLOR_MODE_HSVA,
        COLOR_MODE_DWORD = 0x7FFFFFFF
};

#pragma pack(push,1)
struct Color
{
        uint8_t         R;

        uint8_t         G;

        uint8_t         B;
        
        uint8_t         A;

        Color() = default;

        Color( uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255 );

        static Color Mul( Color in1, Color in2 );
        static Color Mul( Color in1, float in2 );
        
        static Color Lerp( const Color in1, const Color in2, float t );
};
#pragma pack(pop)
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_COLOR_H__

#ifndef __EFFEKSEER_RECTF_H__
#define __EFFEKSEER_RECTF_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
struct RectF
{
private:

public:
        float   X;

        float   Y;

        float   Width;

        float   Height;

        RectF();

        RectF( float x, float y, float width, float height );

        Vector2D Position() const;

        Vector2D Size() const;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_RECTF_H__

#ifndef __EFFEKSEER_MATRIX43_H__
#define __EFFEKSEER_MATRIX43_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

struct Matrix44;

struct Matrix43
{
private:

public:
        float   Value[4][3];
        
        void Indentity();

        void Scaling( float x, float y, float z );

        void RotationX( float angle );

        void RotationY( float angle );

        void RotationZ( float angle );
        
        void RotationXYZ( float rx, float ry, float rz );
        
        void RotationZXY( float rz, float rx, float ry );

        void RotationAxis( const Vector3D& axis, float angle );

        void RotationAxis( const Vector3D& axis, float s, float c );

        void Translation( float x, float y, float z );

        void GetSRT( Vector3D& s, Matrix43& r, Vector3D& t ) const; 
        
        void GetScale( Vector3D& s ) const;
        
        void GetRotation( Matrix43& r ) const;

        void GetTranslation( Vector3D& t ) const;
        
        void SetSRT( const Vector3D& s, const Matrix43& r, const Vector3D& t );

        void ToMatrix44(Matrix44& dst);

        bool IsValid() const;

        static void Multiple( Matrix43& out, const Matrix43& in1, const Matrix43& in2 );
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_MATRIX43_H__

#ifndef __EFFEKSEER_MATRIX44_H__
#define __EFFEKSEER_MATRIX44_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

#pragma pack(push,1)
struct Matrix44
{
private:

public:

        Matrix44();

        float   Values[4][4];

        Matrix44& Indentity();

        Matrix44& Transpose();

        Matrix44& LookAtRH( const Vector3D& eye, const Vector3D& at, const Vector3D& up );

        Matrix44& LookAtLH( const Vector3D& eye, const Vector3D& at, const Vector3D& up );

        Matrix44& PerspectiveFovRH( float ovY, float aspect, float zn, float zf );

        Matrix44& PerspectiveFovRH_OpenGL( float ovY, float aspect, float zn, float zf );

        Matrix44& PerspectiveFovLH( float ovY, float aspect, float zn, float zf );
        
        Matrix44& PerspectiveFovLH_OpenGL( float ovY, float aspect, float zn, float zf );
        
        Matrix44& OrthographicRH( float width, float height, float zn, float zf );

        Matrix44& OrthographicLH( float width, float height, float zn, float zf );

        void Scaling( float x, float y, float z );

        void RotationX( float angle );

        void RotationY( float angle );

        void RotationZ( float angle );

        void Translation( float x, float y, float z );

        void RotationAxis( const Vector3D& axis, float angle );

        void Quaternion( float x, float y, float z, float w );

        static Matrix44& Mul( Matrix44& o, const Matrix44& in1, const Matrix44& in2 );

        static Matrix44& Inverse( Matrix44& o, const Matrix44& in );
};

#pragma pack(pop)
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_MATRIX44_H__

#ifndef __EFFEKSEER_FILE_H__
#define __EFFEKSEER_FILE_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class FileReader
{
private:

public:
        FileReader() {}

        virtual ~FileReader() {}

        virtual size_t Read( void* buffer, size_t size ) = 0;

        virtual void Seek(int position) = 0;

        virtual int GetPosition() = 0;

        virtual size_t GetLength() = 0;
};

class FileWriter
{
private:

public:
        FileWriter() {}

        virtual ~FileWriter() {}

        virtual size_t Write( const void* buffer, size_t size ) = 0;

        virtual void Flush() = 0;

        virtual void Seek(int position) = 0;

        virtual int GetPosition() = 0;

        virtual size_t GetLength() = 0;
};

class FileInterface
{
private:
public:
        FileInterface() = default;
        virtual ~FileInterface() = default;

        virtual FileReader* OpenRead(const EFK_CHAR* path) = 0;

        virtual FileReader* TryOpenRead(const EFK_CHAR* path) { return OpenRead(path); }

        virtual FileWriter* OpenWrite(const EFK_CHAR* path) = 0;
};


 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_FILE_H__

#ifndef __EFFEKSEER_DEFAULT_FILE_H__
#define __EFFEKSEER_DEFAULT_FILE_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class DefaultFileReader : public FileReader
{
private:
        FILE* m_filePtr;

public:
        DefaultFileReader( FILE* filePtr );

        ~DefaultFileReader();

        size_t Read( void* buffer, size_t size );

        void Seek( int position );

        int GetPosition();

        size_t GetLength();
};

class DefaultFileWriter : public FileWriter
{
private:
        FILE* m_filePtr;

public:
        DefaultFileWriter( FILE* filePtr );

        ~DefaultFileWriter();

        size_t Write( const void* buffer, size_t size );

        void Flush();

        void Seek( int position );

        int GetPosition();

        size_t GetLength();
};

class DefaultFileInterface : public FileInterface
{
private:

public:
        FileReader* OpenRead( const EFK_CHAR* path );

        FileWriter* OpenWrite( const EFK_CHAR* path );
};


//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_DEFAULT_FILE_H__

#ifndef __EFFEKSEER_EFFECT_H__
#define __EFFEKSEER_EFFECT_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

struct EffectTerm
{
        int32_t TermMin;

        int32_t TermMax;
};

struct EffectInstanceTerm
{
        int32_t FirstInstanceStartMin = 0;

        int32_t FirstInstanceStartMax = 0;

        int32_t FirstInstanceEndMin = INT_MAX;

        int32_t FirstInstanceEndMax = INT_MAX;

        int32_t LastInstanceStartMin = 0;

        int32_t LastInstanceStartMax = 0;

        int32_t LastInstanceEndMin = INT_MAX;

        int32_t LastInstanceEndMax = INT_MAX;
};

class EffectFactory : public ReferenceObject
{
public:
        EffectFactory();

        virtual ~EffectFactory();

        bool LoadBody(Effect* effect, const void* data, int32_t size, float magnification, const EFK_CHAR* materialPath);

        void SetTexture(Effect* effect, int32_t index, TextureType type, TextureData* data);

        void SetSound(Effect* effect, int32_t index, void* data);

        void SetModel(Effect* effect, int32_t index, void* data);

        void SetMaterial(Effect* effect, int32_t index, MaterialData* data);

        void SetLoadingParameter(Effect* effect, ReferenceObject* obj);

        virtual bool OnCheckIsBinarySupported(const void* data, int32_t size);

        virtual bool OnCheckIsReloadSupported();

        virtual bool OnLoading(Effect* effect, const void* data, int32_t size, float magnification, const EFK_CHAR* materialPath);

        virtual void OnLoadingResource(Effect* effect, const void* data, int32_t size, const EFK_CHAR* materialPath);

        virtual void OnUnloadingResource(Effect* effect);

        virtual const char* GetName() const;

        virtual bool GetIsResourcesLoadedAutomatically() const;
};

class Effect
        : public IReference
{
protected:
        Effect() {}
    virtual ~Effect() {}

public:

        static Effect* Create( Manager* manager, void* data, int32_t size, float magnification = 1.0f, const EFK_CHAR* materialPath = NULL );

        static Effect* Create( Manager* manager, const EFK_CHAR* path, float magnification = 1.0f, const EFK_CHAR* materialPath = NULL );

        static Effect* Create( Setting* setting, void* data, int32_t size, float magnification = 1.0f, const EFK_CHAR* materialPath = NULL );

        static Effect* Create( Setting* setting, const EFK_CHAR* path, float magnification = 1.0f, const EFK_CHAR* materialPath = NULL );

        static ::Effekseer::EffectLoader* CreateEffectLoader(::Effekseer::FileInterface* fileInterface = NULL);

        virtual const char16_t* GetName() const = 0;

        virtual void SetName(const char16_t* name) = 0;

        virtual Setting* GetSetting() const = 0;

        virtual float GetMaginification() const = 0;
        
        virtual int GetVersion() const = 0;

        virtual ReferenceObject* GetLoadingParameter() const = 0;

        virtual TextureData* GetColorImage( int n ) const = 0;

        virtual int32_t GetColorImageCount() const = 0;

        virtual const EFK_CHAR* GetColorImagePath(int n) const = 0;

        virtual TextureData* GetNormalImage(int n) const = 0;

        virtual int32_t GetNormalImageCount() const = 0;

        virtual const EFK_CHAR* GetNormalImagePath(int n) const = 0;
        
        virtual TextureData* GetDistortionImage(int n) const = 0;

        virtual int32_t GetDistortionImageCount() const = 0;

        virtual const EFK_CHAR* GetDistortionImagePath(int n) const = 0;
        
        virtual void* GetWave( int n ) const = 0;

        virtual int32_t GetWaveCount() const = 0;

        virtual const EFK_CHAR* GetWavePath(int n) const = 0;
        
        virtual void* GetModel( int n ) const = 0;

        virtual int32_t GetModelCount() const = 0;

        virtual const EFK_CHAR* GetModelPath(int n) const = 0;
        
        virtual MaterialData* GetMaterial(int n) const = 0;

        virtual int32_t GetMaterialCount() const = 0;

        virtual const EFK_CHAR* GetMaterialPath(int n) const = 0;

        virtual bool Reload( void* data, int32_t size, const EFK_CHAR* materialPath = nullptr, ReloadingThreadType reloadingThreadType = ReloadingThreadType::Main) = 0;

        virtual bool Reload( const EFK_CHAR* path, const EFK_CHAR* materialPath = nullptr, ReloadingThreadType reloadingThreadType = ReloadingThreadType::Main) = 0;

        virtual bool Reload( Manager** managers, int32_t managersCount, void* data, int32_t size, const EFK_CHAR* materialPath = nullptr, ReloadingThreadType reloadingThreadType = ReloadingThreadType::Main) = 0;

        virtual bool Reload( Manager** managers, int32_t managersCount,const EFK_CHAR* path, const EFK_CHAR* materialPath = nullptr, ReloadingThreadType reloadingThreadType = ReloadingThreadType::Main) = 0;

        virtual void ReloadResources( const void* data = nullptr, int32_t size = 0, const EFK_CHAR* materialPath = nullptr ) = 0;

        virtual void UnloadResources() = 0;

        virtual EffectNode* GetRoot() const = 0;

        virtual EffectTerm CalculateTerm() const = 0;
};

struct EffectBasicRenderParameter
{
        int32_t                         ColorTextureIndex;
        AlphaBlendType          AlphaBlend;
        TextureFilterType       FilterType;
        TextureWrapType         WrapType;
        bool                            ZWrite;
        bool                            ZTest;
        bool                            Distortion;
        float                           DistortionIntensity;
};

struct EffectModelParameter
{
        bool                            Lighting;
};

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

        virtual Effect* GetEffect() const = 0;

        virtual int GetGeneration() const = 0;

        virtual int GetChildrenCount() const = 0;

        virtual EffectNode* GetChild(int index) const = 0;

        virtual EffectBasicRenderParameter GetBasicRenderParameter() = 0;

        virtual void SetBasicRenderParameter(EffectBasicRenderParameter param) = 0;

        virtual EffectModelParameter GetEffectModelParameter() = 0;

        virtual EffectInstanceTerm CalculateInstanceTerm(EffectInstanceTerm& parentTerm) const = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_EFFECT_H__

#ifndef __EFFEKSEER_MANAGER_H__
#define __EFFEKSEER_MANAGER_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

class Manager
        : public IReference
{
public:
        struct DrawParameter
        {
                Vector3D CameraPosition;
                Vector3D CameraDirection;

                int32_t CameraCullingMask;

                DrawParameter();
        };

protected:
        Manager() {}
    virtual ~Manager() { }

public:
        static Manager* Create( int instance_max, bool autoFlip = true );

        virtual void Destroy() = 0;

        virtual MallocFunc GetMallocFunc() const = 0;

        virtual void SetMallocFunc(MallocFunc func) = 0;

        virtual FreeFunc GetFreeFunc() const = 0;

        virtual void SetFreeFunc(FreeFunc func) = 0;

        virtual RandFunc GetRandFunc() const = 0;

        virtual void SetRandFunc( RandFunc func ) = 0;

        virtual int GetRandMax() const = 0;

        virtual void SetRandMax( int max_ ) = 0;

        virtual CoordinateSystem GetCoordinateSystem() const = 0;

        virtual void SetCoordinateSystem( CoordinateSystem coordinateSystem ) = 0;

        virtual SpriteRenderer* GetSpriteRenderer() = 0;

        virtual void SetSpriteRenderer( SpriteRenderer* renderer ) = 0;

        virtual RibbonRenderer* GetRibbonRenderer() = 0;

        virtual void SetRibbonRenderer( RibbonRenderer* renderer ) = 0;

        virtual RingRenderer* GetRingRenderer() = 0;

        virtual void SetRingRenderer( RingRenderer* renderer ) = 0;

        virtual ModelRenderer* GetModelRenderer() = 0;

        virtual void SetModelRenderer( ModelRenderer* renderer ) = 0;

        virtual TrackRenderer* GetTrackRenderer() = 0;

        virtual void SetTrackRenderer( TrackRenderer* renderer ) = 0;

        virtual Setting* GetSetting() = 0;

        virtual void SetSetting(Setting* setting) = 0;

        virtual EffectLoader* GetEffectLoader() = 0;

        virtual void SetEffectLoader( EffectLoader* effectLoader ) = 0;

        virtual TextureLoader* GetTextureLoader() = 0;

        virtual void SetTextureLoader( TextureLoader* textureLoader ) = 0;
        
        virtual SoundPlayer* GetSoundPlayer() = 0;

        virtual void SetSoundPlayer( SoundPlayer* soundPlayer ) = 0;
        
        virtual SoundLoader* GetSoundLoader() = 0;
        
        virtual void SetSoundLoader( SoundLoader* soundLoader ) = 0;

        virtual ModelLoader* GetModelLoader() = 0;

        virtual void SetModelLoader( ModelLoader* modelLoader ) = 0;

        virtual MaterialLoader* GetMaterialLoader() = 0;

        virtual void SetMaterialLoader(MaterialLoader* loader) = 0;

        virtual void StopEffect( Handle handle ) = 0;

        virtual void StopAllEffects() = 0;

        virtual void StopRoot( Handle handle ) = 0;

        virtual void StopRoot( Effect* effect ) = 0;

        virtual bool Exists( Handle handle ) = 0;

        virtual int32_t GetInstanceCount( Handle handle ) = 0;
        
        virtual int32_t GetTotalInstanceCount() const = 0;

        virtual Matrix43 GetMatrix( Handle handle ) = 0;

        virtual void SetMatrix( Handle handle, const Matrix43& mat ) = 0;

        virtual Vector3D GetLocation( Handle handle ) = 0;

        virtual void SetLocation( Handle handle, float x, float y, float z ) = 0;

        virtual void SetLocation( Handle handle, const Vector3D& location ) = 0;

        virtual void AddLocation( Handle handle, const Vector3D& location ) = 0;

        virtual void SetRotation( Handle handle, float x, float y, float z ) = 0;

        virtual void SetRotation( Handle handle, const Vector3D& axis, float angle ) = 0;
        
        virtual void SetScale( Handle handle, float x, float y, float z ) = 0;

        virtual void SetAllColor(Handle handle, Color color) = 0;

        virtual void SetTargetLocation( Handle handle, float x, float y, float z ) = 0;

        virtual void SetTargetLocation( Handle handle, const Vector3D& location ) = 0;

        virtual float GetDynamicInput(Handle handle, int32_t index) = 0;

        virtual void SetDynamicInput(Handle handle, int32_t index, float value) = 0;

        virtual Matrix43 GetBaseMatrix( Handle handle ) = 0;

        virtual void SetBaseMatrix( Handle handle, const Matrix43& mat ) = 0;

        virtual void SetRemovingCallback( Handle handle, EffectInstanceRemovingCallback callback ) = 0;

        virtual bool GetShown(Handle handle) = 0;

        virtual void SetShown( Handle handle, bool shown ) = 0;

        virtual bool GetPaused(Handle handle) = 0;

        virtual void SetPaused( Handle handle, bool paused ) = 0;

        virtual void SetPausedToAllEffects(bool paused) = 0;

        virtual int GetLayer(Handle handle) = 0;

        virtual void SetLayer(Handle handle, int32_t layer) = 0;

        virtual float GetSpeed(Handle handle) const = 0;

        virtual void SetSpeed( Handle handle, float speed ) = 0;

        virtual void SetAutoDrawing( Handle handle, bool autoDraw ) = 0;

        virtual void Flip() = 0;

        virtual void Update( float deltaFrame = 1.0f ) = 0;

        virtual void BeginUpdate() = 0;

        virtual void EndUpdate() = 0;

        virtual void UpdateHandle( Handle handle, float deltaFrame = 1.0f ) = 0;

        virtual void Draw(const Manager::DrawParameter& drawParameter = Manager::DrawParameter()) = 0;
        
        virtual void DrawBack(const Manager::DrawParameter& drawParameter = Manager::DrawParameter()) = 0;

        virtual void DrawFront(const Manager::DrawParameter& drawParameter = Manager::DrawParameter()) = 0;

        virtual void DrawHandle(Handle handle, const Manager::DrawParameter& drawParameter = Manager::DrawParameter()) = 0;

        virtual void DrawHandleBack(Handle handle, const Manager::DrawParameter& drawParameter = Manager::DrawParameter()) = 0;
        
        virtual void DrawHandleFront(Handle handle, const Manager::DrawParameter& drawParameter = Manager::DrawParameter()) = 0;

        virtual Handle Play( Effect* effect, float x, float y, float z ) = 0;
        
        virtual Handle Play(Effect* effect, const Vector3D& position, int32_t startFrame = 0) = 0;

        virtual int GetCameraCullingMaskToShowAllEffects() = 0;

        virtual int GetUpdateTime() const = 0;
        
        virtual int GetDrawTime() const = 0;

        virtual int32_t GetRestInstancesCount() const = 0;

        virtual void CreateCullingWorld( float xsize, float ysize, float zsize, int32_t layerCount) = 0;

        virtual void CalcCulling(const Matrix44& cameraProjMat, bool isOpenGL) = 0;

        virtual void RessignCulling() = 0;
};
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_MANAGER_H__

#ifndef __EFFEKSEER_EFFECTLOADER_H__
#define __EFFEKSEER_EFFECTLOADER_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class EffectLoader
{
public:
        EffectLoader() {}

        virtual ~EffectLoader() {}

        virtual bool Load( const EFK_CHAR* path, void*& data, int32_t& size ) = 0;

        virtual void Unload( void* data, int32_t size ) = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_EFFECTLOADER_H__

#ifndef __EFFEKSEER_TEXTURELOADER_H__
#define __EFFEKSEER_TEXTURELOADER_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class TextureLoader
{
public:
        TextureLoader() {}

        virtual ~TextureLoader() {}

        virtual TextureData* Load( const EFK_CHAR* path, TextureType textureType ) { return nullptr; }

        virtual TextureData* Load(const void* data, int32_t size, TextureType textureType) { return nullptr; }

        virtual void Unload(TextureData* data ) {}
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_TEXTURELOADER_H__

#ifndef __EFFEKSEER_MODELLOADER_H__
#define __EFFEKSEER_MODELLOADER_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class ModelLoader
{
public:
        ModelLoader() {}

        virtual ~ModelLoader() {}

        virtual void* Load( const EFK_CHAR* path ) { return NULL; }

        virtual void* Load(const void* data, int32_t size) { return nullptr; }

        virtual void Unload( void* data ) {}
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_MODELLOADER_H__

#ifndef __EFFEKSEER_MATERIALLOADER_H__
#define __EFFEKSEER_MATERIALLOADER_H__


namespace Effekseer
{

class MaterialLoader
{
public:
        MaterialLoader() = default;

        virtual ~MaterialLoader() = default;

        virtual MaterialData* Load(const EFK_CHAR* path) { return nullptr; }

        virtual MaterialData* Load(const void* data, int32_t size, MaterialFileType fileType) { return nullptr; }

        virtual void Unload(MaterialData* data) {}
};

} // namespace Effekseer

#endif // __EFFEKSEER_TEXTURELOADER_H__

#ifndef __EFFEKSEER_MODEL_H__
#define __EFFEKSEER_MODEL_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Model
{
public:
        static const int32_t    Version = 1;

        struct Vertex
        {
                Vector3D Position;
                Vector3D Normal;
                Vector3D Binormal;
                Vector3D Tangent;
                Vector2D UV;
                Color VColor;
        };

        struct VertexWithIndex
        {
                Vector3D Position;
                Vector3D Normal;
                Vector3D Binormal;
                Vector3D Tangent;
                Vector2D UV;
                Color VColor;
                uint8_t Index[4];
        };

        struct Face
        {
                int32_t Indexes[3];
        };

        struct Emitter
        {
                Vector3D        Position;
                Vector3D        Normal;
                Vector3D        Binormal;
                Vector3D        Tangent;
        };

private:
        uint8_t*        m_data;
        int32_t         m_size;

        int32_t         m_version;

        struct InternalModel
        {
                int32_t         m_vertexCount;
                Vertex*         m_vertexes;

                int32_t         m_faceCount;
                Face*           m_faces;
        };

        InternalModel*  models;

        int32_t         m_modelCount;
        int32_t         m_frameCount;

protected:
        int32_t         m_vertexSize = sizeof(Vertex);
public:

        Model(void* data, int32_t size)
                : m_data(NULL)
                , m_size(size)
                , m_version(0)
                , models(nullptr)
        {
                m_data = new uint8_t[m_size];
                memcpy(m_data, data, m_size);

                uint8_t* p = (uint8_t*) m_data;

                memcpy(&m_version, p, sizeof(int32_t));
                p += sizeof(int32_t);

                // load scale except version 3(for compatibility)
                if (m_version == 2 || m_version >= 5)
                {
                        // Scale
                        p += sizeof(int32_t);
                }

                memcpy(&m_modelCount, p, sizeof(int32_t));
                p += sizeof(int32_t);

                if (m_version >= 5)
                {
                        memcpy(&m_frameCount, p, sizeof(int32_t));
                        p += sizeof(int32_t);
                }
                else
                {
                        m_frameCount = 1;
                }

                models = new InternalModel[m_frameCount];

                for (int32_t f = 0; f < m_frameCount; f++)
                {
                        memcpy(&models[f].m_vertexCount, p, sizeof(int32_t));
                        p += sizeof(int32_t);

                        if (m_version >= 1)
                        {
                                models[f].m_vertexes = (Vertex*) p;
                                p += (sizeof(Vertex) * models[f].m_vertexCount);
                        }
                        else
                        {
                                // allocate new buffer
                                models[f].m_vertexes = new Vertex[models[f].m_vertexCount];

                                for (int32_t i = 0; i < models[f].m_vertexCount; i++)
                                {
                                        memcpy((void*)&models[f].m_vertexes[i], p, sizeof(Vertex) - sizeof(Color));
                                        models[f].m_vertexes[i].VColor = Color(255, 255, 255, 255);

                                        p += sizeof(Vertex) - sizeof(Color);
                                }
                        }

                        memcpy(&models[f].m_faceCount, p, sizeof(int32_t));
                        p += sizeof(int32_t);

                        models[f].m_faces = (Face*) p;
                        p += (sizeof(Face) * models[f].m_faceCount);
                }
        }

        Vertex* GetVertexes(int32_t index = 0) const { return models[index].m_vertexes; }
        int32_t GetVertexCount(int32_t index = 0) { return models[index].m_vertexCount; }

        Face* GetFaces(int32_t index = 0) const { return models[index].m_faces; }
        int32_t GetFaceCount(int32_t index = 0) { return models[index].m_faceCount; }

        int32_t GetFrameCount() const { return m_frameCount; }

        int32_t GetModelCount() { return m_modelCount; }

        int32_t GetVertexSize() const { return m_vertexSize; }

        virtual ~Model()
        {
                if (m_version == 0)
                {
                        ES_SAFE_DELETE_ARRAY(models[0].m_vertexes);
                }

                ES_SAFE_DELETE_ARRAY(models);
                ES_SAFE_DELETE_ARRAY(m_data);
        }

        Emitter GetEmitter(IRandObject* g, int32_t time, CoordinateSystem coordinate, float magnification )
        {
                time = time % GetFrameCount();

                int32_t faceInd = (int32_t) ((GetFaceCount(time) - 1) * (g->GetRand()));
                faceInd = Clamp(faceInd, GetFaceCount(time) - 1, 0);
                Face& face = GetFaces(time)[faceInd];
                Vertex& v0 = GetVertexes(time)[face.Indexes[0]];
                Vertex& v1 = GetVertexes(time)[face.Indexes[1]];
                Vertex& v2 = GetVertexes(time)[face.Indexes[2]];

                float p1 = g->GetRand();
                float p2 = g->GetRand();

                // Fit within plane
                if( p1 + p2 > 1.0f )
                {
                        p1 = 1.0f - p1;
                        p2 = 1.0f - p2;                 
                }

                float p0 = 1.0f - p1 - p2;
                
                Emitter emitter;
                emitter.Position = (v0.Position * p0 + v1.Position * p1 + v2.Position * p2) * magnification;
                emitter.Normal = v0.Normal * p0 + v1.Normal * p1 + v2.Normal * p2;
                emitter.Binormal = v0.Binormal * p0 + v1.Binormal * p1 + v2.Binormal * p2;
                emitter.Tangent = v0.Tangent * p0 + v1.Tangent * p1 + v2.Tangent * p2;

                if( coordinate == CoordinateSystem::LH )
                {
                        emitter.Position.Z = - emitter.Position.Z;
                        emitter.Normal.Z = - emitter.Normal.Z;
                        emitter.Binormal.Z = - emitter.Binormal.Z;
                        emitter.Tangent.Z = - emitter.Tangent.Z;
                }

                return emitter;
        }

        Emitter GetEmitterFromVertex(IRandObject* g, int32_t time, CoordinateSystem coordinate, float magnification)
        {
                time = time % GetFrameCount();

                int32_t vertexInd = (int32_t) ((GetVertexCount(time) - 1) * (g->GetRand()));
                vertexInd = Clamp(vertexInd, GetVertexCount(time) - 1, 0);
                Vertex& v = GetVertexes(time)[vertexInd];
                
                Emitter emitter;
                emitter.Position = v.Position * magnification;
                emitter.Normal = v.Normal;
                emitter.Binormal = v.Binormal;
                emitter.Tangent = v.Tangent;

                if( coordinate == CoordinateSystem::LH )
                {
                        emitter.Position.Z = - emitter.Position.Z;
                        emitter.Normal.Z = - emitter.Normal.Z;
                        emitter.Binormal.Z = - emitter.Binormal.Z;
                        emitter.Tangent.Z = - emitter.Tangent.Z;
                }

                return emitter;
        }

        Emitter GetEmitterFromVertex(int32_t index, int32_t time, CoordinateSystem coordinate, float magnification)
        {
                time = time % GetFrameCount();

                int32_t vertexInd = index % GetVertexCount(time);
                Vertex& v = GetVertexes(time)[vertexInd];
                
                Emitter emitter;
                emitter.Position = v.Position * magnification;
                emitter.Normal = v.Normal;
                emitter.Binormal = v.Binormal;
                emitter.Tangent = v.Tangent;

                if( coordinate == CoordinateSystem::LH )
                {
                        emitter.Position.Z = - emitter.Position.Z;
                        emitter.Normal.Z = - emitter.Normal.Z;
                        emitter.Binormal.Z = - emitter.Binormal.Z;
                        emitter.Tangent.Z = - emitter.Tangent.Z;
                }

                return emitter;
        }

        Emitter GetEmitterFromFace(IRandObject* g, int32_t time, CoordinateSystem coordinate, float magnification)
        {
                time = time % GetFrameCount();

                int32_t faceInd = (int32_t) ((GetFaceCount(time) - 1) * (g->GetRand()));
                faceInd = Clamp(faceInd, GetFaceCount(time) - 1, 0);
                Face& face = GetFaces(time)[faceInd];
                Vertex& v0 = GetVertexes(time)[face.Indexes[0]];
                Vertex& v1 = GetVertexes(time)[face.Indexes[1]];
                Vertex& v2 = GetVertexes(time)[face.Indexes[2]];

                float p0 = 1.0f / 3.0f;
                float p1 = 1.0f / 3.0f;
                float p2 = 1.0f / 3.0f;

                Emitter emitter;
                emitter.Position = (v0.Position * p0 + v1.Position * p1 + v2.Position * p2) * magnification;
                emitter.Normal = v0.Normal * p0 + v1.Normal * p1 + v2.Normal * p2;
                emitter.Binormal = v0.Binormal * p0 + v1.Binormal * p1 + v2.Binormal * p2;
                emitter.Tangent = v0.Tangent * p0 + v1.Tangent * p1 + v2.Tangent * p2;

                if( coordinate == CoordinateSystem::LH )
                {
                        emitter.Position.Z = - emitter.Position.Z;
                        emitter.Normal.Z = - emitter.Normal.Z;
                        emitter.Binormal.Z = - emitter.Binormal.Z;
                        emitter.Tangent.Z = - emitter.Tangent.Z;
                }

                return emitter;
        }

        Emitter GetEmitterFromFace(int32_t index, int32_t time, CoordinateSystem coordinate, float magnification)
        {
                time = time % GetFrameCount();

                int32_t faceInd = index % (GetFaceCount(time) - 1);
                Face& face = GetFaces(time)[faceInd];
                Vertex& v0 = GetVertexes(time)[face.Indexes[0]];
                Vertex& v1 = GetVertexes(time)[face.Indexes[1]];
                Vertex& v2 = GetVertexes(time)[face.Indexes[2]];

                float p0 = 1.0f / 3.0f;
                float p1 = 1.0f / 3.0f;
                float p2 = 1.0f / 3.0f;

                Emitter emitter;
                emitter.Position = (v0.Position * p0 + v1.Position * p1 + v2.Position * p2) * magnification;
                emitter.Normal = v0.Normal * p0 + v1.Normal * p1 + v2.Normal * p2;
                emitter.Binormal = v0.Binormal * p0 + v1.Binormal * p1 + v2.Binormal * p2;
                emitter.Tangent = v0.Tangent * p0 + v1.Tangent * p1 + v2.Tangent * p2;

                if( coordinate == CoordinateSystem::LH )
                {
                        emitter.Position.Z = - emitter.Position.Z;
                        emitter.Normal.Z = - emitter.Normal.Z;
                        emitter.Binormal.Z = - emitter.Binormal.Z;
                        emitter.Tangent.Z = - emitter.Tangent.Z;
                }

                return emitter;
        }
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_MODEL_H__

#ifndef __EFFEKSEER_SOUND_PLAYER_H__
#define __EFFEKSEER_SOUND_PLAYER_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer
{
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

typedef void* SoundHandle;
typedef void* SoundTag;

class SoundPlayer
{
public:
        struct InstanceParameter
        {
                void*           Data;
                float           Volume;
                float           Pan;
                float           Pitch;
                bool            Mode3D;
                Vector3D        Position;
                float           Distance;
        };

public:
        SoundPlayer() {}

        virtual ~SoundPlayer() {}

        virtual SoundHandle Play( SoundTag tag, const InstanceParameter& parameter ) = 0;
        
        virtual void Stop( SoundHandle handle, SoundTag tag ) = 0;

        virtual void Pause( SoundHandle handle, SoundTag tag, bool pause ) = 0;

        virtual bool CheckPlaying( SoundHandle handle, SoundTag tag ) = 0;

        virtual void StopTag( SoundTag tag ) = 0;

        virtual void PauseTag( SoundTag tag, bool pause ) = 0;

        virtual bool CheckPlayingTag( SoundTag tag ) = 0;

        virtual void StopAll() = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_SOUND_PLAYER_H__

#ifndef __EFFEKSEER_SOUNDLOADER_H__
#define __EFFEKSEER_SOUNDLOADER_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer {
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class SoundLoader
{
public:
        SoundLoader() {}

        virtual ~SoundLoader() {}

        virtual void* Load( const EFK_CHAR* path ) { return NULL; }

        virtual void* Load(const void* data, int32_t size) { return nullptr; }

        virtual void Unload( void* source ) {}
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_SOUNDLOADER_H__

#ifndef __EFFEKSEER_LOADER_H__
#define __EFFEKSEER_LOADER_H__

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer { 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

class EffectFactory;

        class Setting
                : public ReferenceObject
        {
        private:
                CoordinateSystem                m_coordinateSystem;

                EffectLoader*   m_effectLoader;
                TextureLoader*  m_textureLoader;
                SoundLoader*    m_soundLoader;
                ModelLoader*    m_modelLoader;
                MaterialLoader* m_materialLoader = nullptr;

                std::vector<EffectFactory*> effectFactories;

        protected:
                Setting();

                 ~Setting();
        public:

                static Setting* Create();

                CoordinateSystem GetCoordinateSystem() const;

                void SetCoordinateSystem(CoordinateSystem coordinateSystem);

                EffectLoader* GetEffectLoader();

                void SetEffectLoader(EffectLoader* loader);

                TextureLoader* GetTextureLoader();

                void SetTextureLoader(TextureLoader* loader);

                ModelLoader* GetModelLoader();

                void SetModelLoader(ModelLoader* loader);

                SoundLoader* GetSoundLoader();

                void SetSoundLoader(SoundLoader* loader);

                MaterialLoader* GetMaterialLoader();

                void SetMaterialLoader(MaterialLoader* loader);

                void AddEffectFactory(EffectFactory* effectFactory);

                EffectFactory* GetEffectFactory(int32_t ind) const;

                void ClearEffectFactory();

                int32_t GetEffectFactoryCount() const;
        };

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEER_LOADER_H__

#ifndef __EFFEKSEER_SERVER_H__
#define __EFFEKSEER_SERVER_H__

#if !( defined(_PSVITA) || defined(_XBOXONE) )

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer {
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Server
{
public:

        Server() {}
        virtual ~Server() {}

        static Server* Create();

        virtual bool Start( uint16_t port ) = 0;

        virtual void Stop() = 0;

        virtual void Register(const EFK_CHAR* key, Effect* effect) = 0;

        virtual void Unregister(Effect* effect) = 0;

        virtual void Update(Manager** managers = nullptr, int32_t managerCount = 0, ReloadingThreadType reloadingThreadType = ReloadingThreadType::Main) = 0;

        virtual void SetMaterialPath( const EFK_CHAR* materialPath ) = 0;

        virtual void Regist(const EFK_CHAR* key, Effect* effect) = 0;

        virtual void Unregist(Effect* effect) = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

#endif  // #if !( defined(_PSVITA) || defined(_XBOXONE) )

#endif  // __EFFEKSEER_SERVER_H__

#ifndef __EFFEKSEER_CLIENT_H__
#define __EFFEKSEER_CLIENT_H__

#if !( defined(_PSVITA) || defined(_PS4) || defined(_SWITCH) || defined(_XBOXONE) )

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

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace Effekseer {
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Client
{
public:
        Client() {}
        virtual ~Client() {}

        static Client* Create();

        virtual bool Start( char* host, uint16_t port ) = 0;
        virtual void Stop()= 0;

        virtual void Reload( const EFK_CHAR* key, void* data, int32_t size ) = 0;
        virtual void Reload( Manager* manager, const EFK_CHAR* path, const EFK_CHAR* key ) = 0;
        virtual bool IsConnected() = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
 } 
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

#endif  // #if !( defined(_PSVITA) || defined(_PS4) || defined(_SWITCH) || defined(_XBOXONE) )

#endif  // __EFFEKSEER_CLIENT_H__