300 lines
7.0 KiB
C++
300 lines
7.0 KiB
C++
#pragma once
|
|
#include <d3dx9math.h>
|
|
|
|
#define Clamp(x, min, max) x = (x<min ? min : x<max ? x : max);
|
|
#define GRAVITY D3DXVECTOR3(0.0f, 0.0f, -9.8f)
|
|
|
|
#define MAX_FRAME 20
|
|
#define MAX_TEXTURE 20
|
|
|
|
typedef struct _FVF_POINT
|
|
{
|
|
float x, y, z;
|
|
} FVF_POINT;
|
|
|
|
#ifndef D3DFVF_POINT
|
|
#define D3DFVF_POINT (D3DFVF_XYZ)
|
|
#endif
|
|
|
|
|
|
typedef struct _FVF_PT
|
|
{
|
|
float x, y, z;
|
|
float tu, tv;
|
|
} FVF_PT;
|
|
|
|
#ifndef D3DFVF_PT
|
|
#define D3DFVF_PT (D3DFVF_XYZ|D3DFVF_TEX1)
|
|
#endif
|
|
|
|
typedef struct _FVF_PDT
|
|
{
|
|
float x, y, z;
|
|
DWORD color;
|
|
float tu, tv;
|
|
} FVF_PDT;
|
|
|
|
#ifndef D3DFVF_PDT
|
|
#define D3DFVF_PDT (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)
|
|
#endif
|
|
|
|
inline FVF_PDT _FVF_PDT(float x, float y, float z, DWORD dif, float u, float v)
|
|
{
|
|
FVF_PDT result;
|
|
result.x = x; result.y = y; result.z = z; result.color = dif; result.tu = u; result.tv = v;
|
|
return result;
|
|
}
|
|
|
|
enum EEffectType
|
|
{
|
|
EFFECT_TYPE_PARTICLE = 1,
|
|
EFFECT_TYPE_ANIMATION_TEXTURE = 2,
|
|
EFFECT_TYPE_MESH = 3,
|
|
EFFECT_TYPE_SIMPLE_LIGHT = 4,
|
|
};
|
|
|
|
|
|
|
|
enum EMeshBillBoardType
|
|
{
|
|
MESH_BILLBOARD_TYPE_NONE,
|
|
|
|
MESH_BILLBOARD_TYPE_ALL,
|
|
MESH_BILLBOARD_TYPE_Y,
|
|
|
|
MESH_BILLBOARD_TYPE_MOVE
|
|
};
|
|
|
|
enum EBillBoardType
|
|
{
|
|
BILLBOARD_TYPE_NONE,
|
|
|
|
BILLBOARD_TYPE_ALL,
|
|
BILLBOARD_TYPE_Y,
|
|
|
|
BILLBOARD_TYPE_LIE, // 바닥에 누은 형상
|
|
|
|
BILLBOARD_TYPE_2FACE, // / and \
|
|
BILLBOARD_TYPE_3FACE, // / and \ and -
|
|
|
|
//BILLBOARD_TYPE_RAY, // 잔상
|
|
|
|
};
|
|
|
|
enum EMovingType
|
|
{
|
|
MOVING_TYPE_DIRECT,
|
|
MOVING_TYPE_BEZIER_CURVE,
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <typename T>
|
|
struct CTimeEvent
|
|
{
|
|
typedef T value_type;
|
|
|
|
float m_fTime;
|
|
T m_Value;
|
|
};
|
|
|
|
template <typename T>
|
|
bool operator<(const CTimeEvent<T>& lhs, const CTimeEvent<T>& rhs)
|
|
{
|
|
return lhs.m_fTime < rhs.m_fTime;
|
|
}
|
|
|
|
template <typename T>
|
|
bool operator<(const CTimeEvent<T>& lhs, const float& rhs)
|
|
{
|
|
return lhs.m_fTime < rhs;
|
|
}
|
|
|
|
template <typename T>
|
|
bool operator<(const float& lhs, const CTimeEvent<T>& rhs)
|
|
{
|
|
return lhs < rhs.m_fTime;
|
|
}
|
|
|
|
typedef struct SEffectPosition : public CTimeEvent<D3DXVECTOR3>
|
|
{
|
|
// For Bezier Curve
|
|
int m_iMovingType;
|
|
D3DXVECTOR3 m_vecControlPoint;
|
|
} TEffectPosition;
|
|
|
|
#define AG_MASK 0xff00ff00
|
|
#define RB_MASK 0x00ff00ff
|
|
|
|
struct DWORDCOLOR
|
|
{
|
|
DWORD m_dwColor;
|
|
|
|
DWORDCOLOR()
|
|
{
|
|
}
|
|
DWORDCOLOR(const DWORDCOLOR& r)
|
|
: m_dwColor(r.m_dwColor)
|
|
{
|
|
}
|
|
DWORDCOLOR(DWORD dwColor)
|
|
: m_dwColor(dwColor)
|
|
{
|
|
}
|
|
|
|
DWORDCOLOR& operator = (const DWORDCOLOR& r)
|
|
{
|
|
m_dwColor = r.m_dwColor;
|
|
return *this;
|
|
}
|
|
|
|
DWORDCOLOR& operator *= (float f)
|
|
{
|
|
DWORD idx = DWORD(f * 256);
|
|
m_dwColor =
|
|
(((DWORD)(((m_dwColor & AG_MASK) >> 8) * idx)) & AG_MASK)
|
|
+ ((DWORD)(((m_dwColor & RB_MASK) * idx) >> 8) & RB_MASK);
|
|
return *this;
|
|
}
|
|
DWORDCOLOR& operator += (const DWORDCOLOR& r)
|
|
{
|
|
m_dwColor += r.m_dwColor;
|
|
return *this;
|
|
}
|
|
|
|
operator DWORD()
|
|
{
|
|
return m_dwColor;
|
|
}
|
|
};
|
|
|
|
#undef AG_MASK
|
|
#undef RB_MASK
|
|
|
|
inline DWORDCOLOR operator * (DWORDCOLOR dc, float f)
|
|
{
|
|
DWORDCOLOR tmp(dc);
|
|
tmp *= f;
|
|
return tmp;
|
|
}
|
|
|
|
inline DWORDCOLOR operator * (float f, DWORDCOLOR dc)
|
|
{
|
|
DWORDCOLOR tmp(dc);
|
|
tmp *= f;
|
|
return tmp;
|
|
}
|
|
|
|
typedef CTimeEvent<char> TTimeEventTypeCharacter;
|
|
typedef CTimeEvent<short> TTimeEventTypeShort;
|
|
typedef CTimeEvent<float> TTimeEventTypeFloat;
|
|
typedef CTimeEvent<WORD> TTimeEventTypeWord;
|
|
typedef CTimeEvent<DWORD> TTimeEventTypeDoubleWord;
|
|
typedef CTimeEvent<D3DXCOLOR> TTimeEventTypeColor;
|
|
typedef CTimeEvent<D3DXVECTOR2> TTimeEventTypeVector2;
|
|
typedef CTimeEvent<D3DXVECTOR3> TTimeEventTypeVector3;
|
|
|
|
typedef std::vector<float> TTimeEventTable;
|
|
typedef std::vector<TEffectPosition> TTimeEventTablePosition;
|
|
typedef std::vector<TTimeEventTypeCharacter> TTimeEventTableCharacter;
|
|
typedef std::vector<TTimeEventTypeShort> TTimeEventTableShort;
|
|
typedef std::vector<TTimeEventTypeFloat> TTimeEventTableFloat;
|
|
typedef std::vector<TTimeEventTypeWord> TTimeEventTableWord;
|
|
typedef std::vector<TTimeEventTypeDoubleWord> TTimeEventTableDoubleWord;
|
|
typedef std::vector<TTimeEventTypeColor> TTimeEventTableColor;
|
|
typedef std::vector<TTimeEventTypeVector2> TTimeEventTableVector2;
|
|
typedef std::vector<TTimeEventTypeVector3> TTimeEventTableVector3;
|
|
|
|
template <typename T>
|
|
T BlendSingleValue(float time,
|
|
const CTimeEvent<T>& low,
|
|
const CTimeEvent<T>& high)
|
|
{
|
|
const float timeDiff = high.m_fTime - low.m_fTime;
|
|
const float perc = (time - low.m_fTime) / timeDiff;
|
|
|
|
const T valueDiff = high.m_Value - low.m_Value;
|
|
return static_cast<T>(low.m_Value + perc * valueDiff);
|
|
}
|
|
|
|
inline D3DXVECTOR3 BlendSingleValue(float time, const TEffectPosition& low, const TEffectPosition& high)
|
|
{
|
|
const float timeDiff = high.m_fTime - low.m_fTime;
|
|
const float perc = (time - low.m_fTime) / timeDiff;
|
|
|
|
if (low.m_iMovingType == MOVING_TYPE_DIRECT)
|
|
return low.m_Value + ((high.m_Value - low.m_Value) * perc);
|
|
|
|
if (low.m_iMovingType == MOVING_TYPE_BEZIER_CURVE)
|
|
{
|
|
const float invPerc = 1.0f - perc;
|
|
|
|
return low.m_Value * invPerc * invPerc +
|
|
(low.m_Value + low.m_vecControlPoint) * invPerc * perc * 2.0f +
|
|
high.m_Value * perc * perc;
|
|
}
|
|
|
|
// Unknown moving type - impossible(?)
|
|
return D3DXVECTOR3();
|
|
}
|
|
|
|
inline DWORDCOLOR BlendSingleValue(float time, const TTimeEventTypeColor& low, const TTimeEventTypeColor& high)
|
|
{
|
|
const float timeDiff = high.m_fTime - low.m_fTime;
|
|
const float perc = (time - low.m_fTime) / timeDiff;
|
|
|
|
return low.m_Value * (1.0f - perc) + high.m_Value * perc;
|
|
}
|
|
|
|
template <typename T>
|
|
auto GetTimeEventBlendValue(float time,
|
|
const std::vector<T>& vec) -> typename T::value_type
|
|
{
|
|
if (vec.empty())
|
|
return typename T::value_type();
|
|
|
|
// Single element is easy...
|
|
if (vec.begin() + 1 == vec.end())
|
|
return vec.front().m_Value;
|
|
|
|
// All elements are greater than |time| - pick the smallest
|
|
if (time < vec.front().m_fTime)
|
|
return vec.front().m_Value;
|
|
|
|
// All elements are smaller than |time| - pick the greatest
|
|
if (time > vec.back().m_fTime)
|
|
return vec.back().m_Value;
|
|
|
|
// The two checks above make sure that result doesn't contain vec.end()
|
|
// (We could simply check for vec.end() ourself, but above code lets us
|
|
// skip std::equal_range() altogether, making it faster.)
|
|
auto result = std::equal_range(vec.begin(), vec.end(), time);
|
|
|
|
// We have one or more equal elements - pick the first
|
|
if (result.first != result.second)
|
|
return result.first->m_Value;
|
|
|
|
// We need first to point to an element smaller than |time|
|
|
// (Note that decrementing first is safe here, we already accounted for
|
|
// vec.begin() being greater-or-equal to |time|.)
|
|
--result.first;
|
|
return BlendSingleValue(time, *result.first, *result.second);
|
|
}
|
|
|
|
extern BOOL GetTokenTimeEventFloat(CTextFileLoader & rTextFileLoader, const char * c_szKey, TTimeEventTableFloat * pTimeEventTableFloat);
|
|
//extern void InsertItemTimeEventFloat(TTimeEventTableFloat * pTable, float fTime, float fValue);
|
|
|
|
template <typename T>
|
|
void InsertItemTimeEvent(std::vector<CTimeEvent<T> >* pTable, float fTime, T fValue)
|
|
{
|
|
typedef std::vector<CTimeEvent<T> >::iterator iterator;
|
|
|
|
iterator itor = std::lower_bound(pTable->begin(), pTable->end(), fTime);
|
|
|
|
CTimeEvent<T> TimeEvent;
|
|
TimeEvent.m_fTime = fTime;
|
|
TimeEvent.m_Value = fValue;
|
|
|
|
pTable->insert(itor, TimeEvent);
|
|
}
|