677 lines
15 KiB
C++
677 lines
15 KiB
C++
#pragma once
|
|
|
|
|
|
#include "KRenderObject.h"
|
|
#include "KPrimitivePathEffect.h"
|
|
#include "KSeqModel.h"
|
|
#include "KSmartPtr.h"
|
|
|
|
|
|
#define PFX_NONX3 "nonx3"
|
|
#define PFX_NOTEX "notex"
|
|
|
|
|
|
/** 다른 Seq 시리즈들과의 통일성을 유지하기 위해 모든 시간 단위는 millsecond * 4.8
|
|
따라서 velocity 같은 것들도 millsecond * 4.8 동안 진행되는 거리로 정의한다. */
|
|
class KResEffectEmitter : public KResource
|
|
{
|
|
protected:
|
|
DWORD m_dwStartTime; ///< 에미터가 활성화되는 시간 (PathEffect의 m_dwStartTime에 상대적인 시간)
|
|
int m_nLifeTime; ///< 에미터의 활동 시간 (-값이면 부모 PathEffect가 Active인 동안 계속 Active이다.)
|
|
float m_fStartPos; ///< 에미터가 최초로 나타나는 지점 0.0f ~ 1.0f
|
|
float m_fVelocity; ///< 에미터가 패스를 따라 움직이는 속도
|
|
//bool m_bLifeAffectAlpha; // 시간이 지나면서 알파값도 같이 감소시킬 것인가?
|
|
//int m_nSeqModel; // SeqModel ID
|
|
BOOL m_bDirectional; ///< 이펙트가 방향성을 갖을 것인가?
|
|
std::vector<std::string> m_vAniNames;
|
|
std::vector<std::string> m_vAniFileNames;
|
|
|
|
public:
|
|
KResEffectEmitter()
|
|
{
|
|
m_dwStartTime = 0;
|
|
m_nLifeTime = -1;
|
|
m_fStartPos = 0.0f;
|
|
m_fVelocity = 0.0f;
|
|
//m_nSeqModel = -1;
|
|
m_bDirectional = FALSE;
|
|
|
|
std::string str = PFX_NONX3;
|
|
m_vAniNames.push_back(str);
|
|
m_vAniFileNames.push_back(str);
|
|
}
|
|
|
|
virtual ~KResEffectEmitter()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
virtual void Clear()
|
|
{
|
|
DelAniNames();
|
|
}
|
|
|
|
virtual void DelAniNames()
|
|
{
|
|
m_vAniNames.erase(m_vAniNames.begin(), m_vAniNames.end());
|
|
m_vAniFileNames.erase(m_vAniFileNames.begin(), m_vAniFileNames.end());
|
|
|
|
std::string str = PFX_NONX3;
|
|
m_vAniNames.push_back(str);
|
|
m_vAniFileNames.push_back(str);
|
|
}
|
|
|
|
virtual KResource* Clone();
|
|
|
|
virtual bool Reload()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void SetStartTime(DWORD dwTime)
|
|
{
|
|
m_dwStartTime = dwTime;
|
|
}
|
|
|
|
DWORD GetStartTime()
|
|
{
|
|
return m_dwStartTime;
|
|
}
|
|
|
|
void SetLifeTime(int nTime)
|
|
{
|
|
m_nLifeTime = nTime;
|
|
}
|
|
|
|
int GetLifeTime()
|
|
{
|
|
return m_nLifeTime;
|
|
}
|
|
|
|
void SetStartPos(float fPos)
|
|
{
|
|
m_fStartPos = fPos;
|
|
}
|
|
|
|
float GetStartPos()
|
|
{
|
|
return m_fStartPos;
|
|
}
|
|
|
|
void SetVelocity(float fVel)
|
|
{
|
|
m_fVelocity = fVel;
|
|
}
|
|
|
|
float GetVelocity()
|
|
{
|
|
return m_fVelocity;
|
|
}
|
|
|
|
//void SetSeqModel(int nId)
|
|
//{
|
|
// m_nSeqModel = nId;
|
|
//}
|
|
|
|
//int GetSeqModel()
|
|
//{
|
|
// return m_nSeqModel;
|
|
//}
|
|
|
|
void AddAniName(const char* szName, const char* szFileName)
|
|
{
|
|
// 현재는 애니메이션 한개만 지원 - 여러개 지원하게 되면 "nonx3" 일때 덮어쓰는 코드 필요
|
|
if(GetNumAnis() > 0)
|
|
{
|
|
DelAniNames();
|
|
}
|
|
|
|
std::string strName = szName;
|
|
m_vAniNames.push_back(strName);
|
|
|
|
std::string strFileName = szFileName;
|
|
m_vAniFileNames.push_back(strFileName);
|
|
}
|
|
|
|
const char* GetAniName(int nId)
|
|
{
|
|
return m_vAniNames[nId].c_str();
|
|
}
|
|
|
|
const char* GetAniFileName(int nId)
|
|
{
|
|
return m_vAniFileNames[nId].c_str();
|
|
}
|
|
|
|
int GetNumAnis()
|
|
{
|
|
return (int)m_vAniNames.size();
|
|
}
|
|
|
|
void SetDirectional(BOOL bDirectional)
|
|
{
|
|
m_bDirectional = bDirectional;
|
|
}
|
|
|
|
BOOL IsDirectional()
|
|
{
|
|
return m_bDirectional;
|
|
}
|
|
};
|
|
DECL_SPTR(KResEffectEmitter)
|
|
|
|
class KResPathEffect : public KResource
|
|
{
|
|
protected:
|
|
std::vector<K3DPoint> m_vPoints;
|
|
float m_fOfsZ;
|
|
float m_fTotalPointVectorLength; ///< vPoints로 이루어진 벡터 길이의 총합
|
|
std::vector<KResEffectEmitterSPtr> m_vEmitters; ///< primitive와 polyline을 그리기 위해 최소한 두 개 (start, end) 는 있어야 한다
|
|
DWORD m_dwStartTime;
|
|
DWORD m_dwLifeTime;
|
|
BOOL m_bHasPolyLine; ///< 폴리라인을 갖고 있는가?
|
|
float m_fPolyLineWidth; ///< 폴리라인 폭
|
|
DWORD m_dwPolyLineColor; ///< 폴리라인 컬러
|
|
std::string m_strPolyLineTexName; ///< 폴리라인 텍스쳐 파일 이름
|
|
|
|
public:
|
|
KResPathEffect()
|
|
{
|
|
m_fOfsZ = 1.0f;
|
|
m_fTotalPointVectorLength = 0.0f;
|
|
m_dwStartTime = 0;
|
|
m_dwLifeTime = 0;
|
|
m_bHasPolyLine = FALSE;
|
|
m_fPolyLineWidth = 1.0f;
|
|
m_dwPolyLineColor = 0xFFFFFFFF;
|
|
m_strPolyLineTexName = PFX_NOTEX;
|
|
}
|
|
|
|
virtual ~KResPathEffect()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
virtual void DelEmitters();
|
|
virtual void DelEmitters(int nId, int numEmitters);
|
|
virtual void DelPoints();
|
|
virtual void DelPoints(int nId, int numPoint);
|
|
|
|
virtual void Clear()
|
|
{
|
|
DelEmitters();
|
|
DelPoints();
|
|
m_strPolyLineTexName = PFX_NOTEX;
|
|
}
|
|
|
|
virtual KResource* Clone();
|
|
|
|
virtual bool Reload()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void AddPoints(K3DPoint* pPoints, int numPoints);
|
|
void InsertPoints(int nId, K3DPoint* pPoints, int numPoints);
|
|
float CalcPointVectorLength(int nStart, int nEnd);
|
|
|
|
K3DPoint* GetPoints()
|
|
{
|
|
if(m_vPoints.size() > 0)
|
|
{
|
|
return &m_vPoints[0];
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
K3DPoint GetPoint(int nId)
|
|
{
|
|
return m_vPoints[nId];
|
|
}
|
|
|
|
int GetNumPoints()
|
|
{
|
|
return (int)m_vPoints.size();
|
|
}
|
|
|
|
K3DPoint& GetPointRef(int nId)
|
|
{
|
|
return m_vPoints.at(nId);
|
|
}
|
|
|
|
void SetStartTime(DWORD dwTime)
|
|
{
|
|
m_dwStartTime = dwTime;
|
|
}
|
|
|
|
DWORD GetStartTime()
|
|
{
|
|
return m_dwStartTime;
|
|
}
|
|
|
|
void SetLifeTime(DWORD dwTime)
|
|
{
|
|
m_dwLifeTime = dwTime;
|
|
}
|
|
|
|
DWORD GetLifeTime()
|
|
{
|
|
return m_dwLifeTime;
|
|
}
|
|
|
|
void SetOfsZ(float fOfsZ)
|
|
{
|
|
m_fOfsZ = fOfsZ;
|
|
}
|
|
|
|
float GetOfsZ()
|
|
{
|
|
return m_fOfsZ;
|
|
}
|
|
|
|
void SetTotalPointVectorLength(float fLen)
|
|
{
|
|
m_fTotalPointVectorLength = fLen;
|
|
}
|
|
|
|
float GetTotalPointVectorLength()
|
|
{
|
|
return m_fTotalPointVectorLength;
|
|
}
|
|
|
|
void AddEmitter(KResEffectEmitter* pEmitter)
|
|
{
|
|
m_vEmitters.push_back(KResEffectEmitterSPtr(pEmitter) );
|
|
}
|
|
|
|
KResEffectEmitter* GetEmitter(int nIdEmitter)
|
|
{
|
|
return m_vEmitters[nIdEmitter];
|
|
}
|
|
|
|
int GetNumEmitters()
|
|
{
|
|
return (int)m_vEmitters.size();
|
|
}
|
|
|
|
int GetPoint(float fPos, K3DPoint& pRes);
|
|
|
|
//void SetSeqModel(int nIdEmitter, int nIdModel)
|
|
//{
|
|
// int nSizeEmitter = m_vEmitters.size();
|
|
// if(nSizeEmitter <= nIdEmitter) return;
|
|
// //int nSizeModel = m_vSeqModelNames.size();
|
|
// //if(nSizeModel <= nIdModel) return;
|
|
|
|
// m_vEmitters[nIdEmitter].SetSeqModel(nIdModel);
|
|
//}
|
|
|
|
void SetHasPolyLine(BOOL bHasPolyLine)
|
|
{
|
|
m_bHasPolyLine = bHasPolyLine;
|
|
}
|
|
|
|
BOOL HasPolyLine()
|
|
{
|
|
return m_bHasPolyLine;
|
|
}
|
|
|
|
void SetPolyLineWidth(float fWidth)
|
|
{
|
|
m_fPolyLineWidth = fWidth;
|
|
}
|
|
|
|
float GetPolyLineWidth()
|
|
{
|
|
return m_fPolyLineWidth;
|
|
}
|
|
|
|
void SetPolyLineColor(DWORD dwColor)
|
|
{
|
|
m_dwPolyLineColor = dwColor;
|
|
}
|
|
|
|
DWORD GetPolyLineColor()
|
|
{
|
|
return m_dwPolyLineColor;
|
|
}
|
|
|
|
void SetPolyLineTexName(const char* szTexName)
|
|
{
|
|
m_strPolyLineTexName = szTexName;
|
|
}
|
|
|
|
const char* GetPolyLineTexName()
|
|
{
|
|
return m_strPolyLineTexName.c_str();
|
|
}
|
|
};
|
|
DECL_SPTR(KResPathEffect)
|
|
|
|
class KResPathEffectChain : public KResource
|
|
{
|
|
protected:
|
|
//std::vector<std::string> m_vSeqModelNames;
|
|
std::vector<KResPathEffectSPtr> m_vPathEffects;
|
|
BOOL m_bDirectional; ///< PathEffectChain이 방향성을 갖을 것인가?
|
|
float m_fMag; ///< PathEffectChain의 크기 (방향 벡터의 크기)
|
|
BOOL m_bEndTogether;
|
|
|
|
public:
|
|
KResPathEffectChain()
|
|
{
|
|
m_bDirectional = FALSE;
|
|
m_fMag = 0.0f;
|
|
m_bEndTogether = TRUE;
|
|
}
|
|
|
|
virtual ~KResPathEffectChain()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
//virtual void Clear();
|
|
|
|
/// 다~ 지운다
|
|
virtual void DelPathEffects()
|
|
{
|
|
m_vPathEffects.erase(m_vPathEffects.begin(), m_vPathEffects.end());
|
|
}
|
|
|
|
/// 일부만 지운다
|
|
virtual void DelPathEffects(int nId, int numPathEffects)
|
|
{
|
|
m_vPathEffects.erase(m_vPathEffects.begin() + nId, m_vPathEffects.begin() + nId + numPathEffects);
|
|
}
|
|
|
|
virtual void Clear()
|
|
{
|
|
DelPathEffects();
|
|
}
|
|
|
|
virtual bool Reload()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
virtual void AddPathEffect(KResPathEffect* pPathEffect)
|
|
{
|
|
//int oldCap = m_vPoints.capacity();
|
|
//int newCap = m_vPoints.size() + numPoints;
|
|
//if(oldCap < newCap) m_vPoints.reserve(newCap);
|
|
|
|
m_vPathEffects.push_back(KResPathEffectSPtr(pPathEffect) );
|
|
}
|
|
|
|
virtual KResPathEffect* GetPathEffect(int nId)
|
|
{
|
|
return m_vPathEffects[nId];
|
|
}
|
|
|
|
virtual int GetNumPathEffects()
|
|
{
|
|
return (int)m_vPathEffects.size();
|
|
}
|
|
|
|
//KResPathEffect* GetPathEffect(int nIdPathEffect)
|
|
//{
|
|
// return m_vPathEffects[nIdPathEffect];
|
|
//}
|
|
|
|
//void AddSeqModel(const char* szName)
|
|
//{
|
|
// std::string strName = szName;
|
|
// m_vSeqModelNames.push_back(strName); // 이거 나중에 해제 안해줘도 되나?
|
|
//}
|
|
|
|
//void SetSeqModel(int nIdPathEffect, int nIdEmitter, int nIdModel)
|
|
//{
|
|
// size = m_vSeqModelNames.size();
|
|
// if(size <= nIdModel) return;
|
|
|
|
// int size = m_vPathEffects.size();
|
|
// if(size <= nIdPathEffect) return;
|
|
|
|
// m_vPathEffects[nIdPathEffect].SetSeqModel(nIdEmitter, nIdModel);
|
|
//}
|
|
|
|
//const char* GetSeqModelName(int nModel)
|
|
//{
|
|
// return m_vSeqModelNames[nModel].c_str();
|
|
//}
|
|
|
|
//int GetNumSeqModels()
|
|
//{
|
|
// return m_vSeqModelNames.size();
|
|
//}
|
|
|
|
void SetDirectional(BOOL bDirectional)
|
|
{
|
|
m_bDirectional = bDirectional;
|
|
}
|
|
|
|
BOOL IsDirectional()
|
|
{
|
|
return m_bDirectional;
|
|
}
|
|
|
|
void SetMag(float fMag)
|
|
{
|
|
m_fMag = fMag;
|
|
}
|
|
|
|
float GetMag()
|
|
{
|
|
return m_fMag;
|
|
}
|
|
|
|
void SetEndTogether(BOOL bEndTogether)
|
|
{
|
|
m_bEndTogether = bEndTogether;
|
|
}
|
|
|
|
BOOL DoesEndTogether()
|
|
{
|
|
return m_bEndTogether;
|
|
}
|
|
};
|
|
DECL_SPTR(KResPathEffectChain)
|
|
|
|
class KEffectEmitter
|
|
{
|
|
public:
|
|
KEffectEmitter();
|
|
~KEffectEmitter();
|
|
void Clear();
|
|
void SetRes(KResEffectEmitter* pRes);
|
|
KResEffectEmitter* GetRes();
|
|
void Update(DWORD dwTime);
|
|
BOOL IsActive();
|
|
//void SetActive(BOOL bActive); // 에디터용
|
|
float GetPos();
|
|
void SetPos(float fPos);
|
|
//float GetAlpha();
|
|
//void SetSeqModel(KSeqModel* pSeqModel);
|
|
KSeqModel* GetSeqModel();
|
|
void CreateSeqModel();
|
|
void DelSeqModel();
|
|
DWORD GetCurrTime();
|
|
void CalcTimes(float fScale);
|
|
DWORD GetStartTime();
|
|
int GetLifeTime();
|
|
|
|
private:
|
|
KResEffectEmitterSPtr m_spRes;
|
|
BOOL m_bActive; ///< 현재 활성화 되있는가?
|
|
DWORD m_dwCurrTime;
|
|
float m_fCurrPos; ///< 0.0f ~ 1.0f
|
|
KSeqModel* m_pSeqModel;
|
|
DWORD m_dwStartTime;
|
|
int m_nLifeTime;
|
|
};
|
|
|
|
class _KSeqPathEffect : public KSeqObject
|
|
{
|
|
public:
|
|
//struct SPathVertex
|
|
//{
|
|
// K3DVector vPos;
|
|
// float fLength; // 누적된 길이 - 마지막 점의 fLength는 PatheEffect의 m_fTotalVertVectorLength와 같아야 한다. 실제 게임상의 좌표 단위.
|
|
//};
|
|
|
|
enum EPathDrawMode
|
|
{
|
|
DRAW_POINT = 1 << 0, ///< 에디터용 - 버텍스와 에미터의 위치에 작은 쿼드를 그린다.
|
|
DRAW_LINE = 1 << 1, ///< 에디터용
|
|
DRAW_ALLPR = 1 << 2, ///< 에디터용
|
|
DRAW_EMITTER = 1 << 3,
|
|
DRAW_POLYLINE = 1 << 4,
|
|
};
|
|
|
|
_KSeqPathEffect();
|
|
virtual ~_KSeqPathEffect();
|
|
//void Init(K3DPoint* pPoints, int numPoints);
|
|
void Clear();
|
|
virtual void DelEmitters();
|
|
//virtual void Init();
|
|
virtual void SetRes(KResPathEffect* pRes);
|
|
virtual KResPathEffect* GetRes();
|
|
//virtual KSeqObject* Clone();
|
|
virtual void SetTime(DWORD dwTime);
|
|
virtual void realizeTime();
|
|
//virtual BOOL IsActive();
|
|
virtual void Update() = 0;
|
|
//virtual void SetPrDrawMode(bool bPrDrawMode);
|
|
virtual void SetDrawMode(DWORD dwDrawMode);
|
|
//virtual void AttachToTerrain(class CTerrainMapEngine* pTerrain);
|
|
//virtual void AttachToTerrain(CTerrainMapEngine* pTerrain, K3DPoint p1, K3DPoint p2);
|
|
virtual void UpdatePr();
|
|
virtual void Render( KViewportObject *viewport, DWORD flag = RENDEREFX_NONE, const K3DMatrix * pAttachMat = NULL );
|
|
//virtual void AddEmitters(KEffectEmitter* pEmitters, int numEmitters);
|
|
virtual int GetVert(float fPos, K3DVertex& vRes);
|
|
virtual void AddVert(K3DVector vPos);
|
|
//int GetCurrLifeTime(DWORD dwTime);
|
|
//virtual BOOL AddSeqModel(int nEmitter, const char* szFileName);
|
|
//virtual BOOL SetSeqModel(int nEmitter, int nModel);
|
|
virtual void RenderEmitter(int nEmitter, KViewportObject* viewport);
|
|
virtual void RenderPolyLine(KViewportObject* viewport);
|
|
//virtual void DelSeqModels();
|
|
static void SetTerrainEngine(class CTerrainMapEngine* pTerrain);
|
|
virtual void SetMat(K3DMatrix* pMat);
|
|
void CreatePolyLineTex();
|
|
void DelPolyLineTex();
|
|
void CalcTimes();
|
|
DWORD GetStartTime();
|
|
DWORD GetLifeTime();
|
|
/// m_bEndTogether == TRUE 일때만 사용
|
|
void SetLifeTime(DWORD dwLifeTime);
|
|
|
|
protected:
|
|
KResPathEffectSPtr m_spRes;
|
|
std::vector<PfxPathVertex> m_vVerts;
|
|
KQuadPrimitive m_prQuad;
|
|
KLinePrimitive m_prLine;
|
|
KPolyLinePrimitive m_prPolyLine;
|
|
float m_fTotalVertVectorLength; ///< vVerts로 이루어진 벡터 길이의 총합
|
|
std::vector<KEffectEmitter*> m_vEmitters; ///< primitive와 polyline을 그리기 위해 최소한 두 개 (start, end) 는 있어야 한다
|
|
//DWORD m_dwStartTime; // 최초로 생성된 시간을 기억한다.
|
|
DWORD m_dwDrawMode;
|
|
//std::vector<KSeqModel*> m_vSeqModels;
|
|
static class CTerrainMapEngine* m_pTerrainEngine;
|
|
BOOL m_bActive;
|
|
K3DMatrix* m_pMat;
|
|
K3DTextureSPtr m_spPolyLineTex;
|
|
DWORD m_dwStartTime;
|
|
DWORD m_dwLifeTime;
|
|
};
|
|
|
|
class KSeqPathEffect : public _KSeqPathEffect
|
|
{
|
|
public:
|
|
KSeqPathEffect();
|
|
virtual ~KSeqPathEffect();
|
|
virtual KSeqObject* Clone();
|
|
//virtual void realizeTime();
|
|
virtual void Update();
|
|
virtual void PointsToVerts();
|
|
//void SetPrDrawMode(bool bPrDrawMode);
|
|
//void AttachToTerrain(class CTerrainMapEngine* pTerrain);
|
|
//void AttachToTerrain(CTerrainMapEngine* pTerrain, K3DPoint p1, K3DPoint p2);
|
|
//virtual void UpdatePr();
|
|
//virtual void Render( KViewportObject *viewport, DWORD flag = RENDEREFX_NONE, const K3DMatrix * pAttachMat = NULL );
|
|
//virtual void AddEmitters(KEffectEmitter* pEmitters, int numEmitters);
|
|
//virtual int GetVert(float fPos, K3DVertex& vRes);
|
|
//virtual void AddVert(K3DVector vPos);
|
|
//int GetCurrLifeTime(DWORD dwTime);
|
|
//virtual BOOL AddSeqModel(int nEmitter, const char* szFileName);
|
|
//virtual void RenderEmitter(int nEmitter, KViewportObject* viewport);
|
|
//virtual void DelSeqModels();
|
|
};
|
|
|
|
class KSeqPathEffectGround : public _KSeqPathEffect
|
|
{
|
|
public:
|
|
KSeqPathEffectGround();
|
|
virtual ~KSeqPathEffectGround();
|
|
//void Init(K3DPoint* pPoints, int numPoints);
|
|
//void Clear();
|
|
virtual KSeqObject* Clone();
|
|
//virtual void realizeTime();
|
|
virtual void Update();
|
|
//void SetPrDrawMode(bool bPrDrawMode);
|
|
virtual void AttachToTerrain();
|
|
virtual void AttachToTerrain(K3DPoint p1, K3DPoint p2);
|
|
//virtual void UpdatePr();
|
|
//virtual void Render( KViewportObject *viewport, DWORD flag = RENDEREFX_NONE, const K3DMatrix * pAttachMat = NULL );
|
|
//virtual void AddEmitters(KEffectEmitter* pEmitters, int numEmitters);
|
|
//virtual int GetVert(float fPos, K3DVertex& vRes);
|
|
//virtual void AddVert(K3DVector vPos);
|
|
//int GetCurrLifeTime(DWORD dwTime);
|
|
//virtual BOOL AddSeqModel(int nEmitter, const char* szFileName);
|
|
//virtual void RenderEmitter(int nEmitter, KViewportObject* viewport);
|
|
//virtual void DelSeqModels();
|
|
};
|
|
|
|
class KSeqPathEffectChain : public KSeqObject
|
|
{
|
|
public:
|
|
enum EPathType
|
|
{
|
|
TYPE_ORDINARY = 0,
|
|
TYPE_GROUND,
|
|
};
|
|
|
|
KSeqPathEffectChain();
|
|
virtual ~KSeqPathEffectChain();
|
|
virtual void Clear();
|
|
virtual void SetRes(KResPathEffectChain* pRes);
|
|
virtual KResPathEffectChain* GetRes();
|
|
virtual KSeqObject* Clone();
|
|
virtual void SetTime(DWORD dwTime);
|
|
virtual void Update();
|
|
virtual void realizeTime();
|
|
virtual void Render( KViewportObject *viewport, DWORD flag = RENDEREFX_NONE, const K3DMatrix * pAttachMat = NULL );
|
|
static void SetTerrainEngine(class CTerrainMapEngine* pTerrain);
|
|
virtual void SetDrawMode(DWORD dwDrawMode);
|
|
//virtual void SetDrawMode();
|
|
virtual void DelPathEffects();
|
|
virtual void SetType(DWORD dwType);
|
|
virtual void SetPos(K3DVector vOrigin);
|
|
virtual void SetPos(K3DVector vOrigin, K3DVector vTarget);
|
|
virtual void CalcTimes();
|
|
|
|
protected:
|
|
KResPathEffectChainSPtr m_spRes;
|
|
std::vector<_KSeqPathEffect*> m_vPathEffects;
|
|
//DWORD m_dwStartTime;
|
|
DWORD m_dwDrawMode;
|
|
static class CTerrainMapEngine* m_pTerrainEngine;
|
|
// std::vector<KSeqModel*> m_vSeqModels;
|
|
DWORD m_dwType;
|
|
//BOOL m_bDirectional;
|
|
K3DMatrix m_Mat;
|
|
};
|