1. #include "StdAfx.h"
  2. #include "GrpObjectInstance.h"
  3. #include "../eterBase/Timer.h"
  5. void CGraphicObjectInstance::OnInitialize()
  6. {
  7. ZeroMemory(m_abyPortalID, sizeof(m_abyPortalID));
  8. }
  10. void CGraphicObjectInstance::Clear()
  11. {
  12. if (m_CullingHandle)
  13. {
  14. CCullingManager::Instance().Unregister(m_CullingHandle);
  15. m_CullingHandle = NULL;
  16. }
  18. ClearHeightInstance();
  20. m_isVisible = TRUE;
  22. m_v3Position.x = m_v3Position.y = m_v3Position.z = 0.0f;
  23. m_v3Scale.x = m_v3Scale.y = m_v3Scale.z = 0.0f;
  24. //m_fRotation = 0.0f;
  25. m_fYaw = m_fPitch = m_fRoll = 0.0f;
  26. D3DXMatrixIdentity(&m_worldMatrix);
  28. m_vecScalePos.x = m_vecScalePos.y = m_vecScalePos.z = 0.0f;
  29. m_vecScaleNew.x = m_vecScaleNew.y = m_vecScaleNew.z = 0.0f;
  31. D3DXMatrixIdentity(&m_matAbsoluteTrans);
  32. D3DXMatrixIdentity(&m_matScale);
  33. D3DXMatrixIdentity(&m_matPositon);
  36. ZeroMemory(m_abyPortalID, sizeof(m_abyPortalID));
  38. OnClear();
  39. }
  41. bool CGraphicObjectInstance::Render()
  42. {
  43. /*
  44. if (m_CullingHandle)
  45. {
  46. SpherePack * ps = m_CullingHandle->GetParent();
  47. CScreen s;
  48. s.SetColorOperation();
  49. //s.SetDiffuseColor(1,isShow()?1:0,0);
  50. //s.RenderCircle2d(m_CullingHandle->GetCenter().x,m_CullingHandle->GetCenter().y,m_CullingHandle->GetCenter().z,m_CullingHandle->GetRadius());
  51. s.SetDiffuseColor(1,isShow()?1:0,ps->HasSpherePackFlag(SPF_PARTIAL)?1:0);
  52. s.RenderCircle2d(ps->GetCenter().x,ps->GetCenter().y,ps->GetCenter().z,ps->GetRadius());
  53. }
  54. //*/
  55. if (!isShow())
  56. return false;
  58. OnRender();
  59. return true;
  60. }
  62. void CGraphicObjectInstance::BlendRender()
  63. {
  64. if (!isShow())
  65. return;
  67. OnBlendRender();
  68. }
  70. void CGraphicObjectInstance::RenderToShadowMap()
  71. {
  72. if (!isShow())
  73. return;
  75. OnRenderToShadowMap();
  76. }
  78. void CGraphicObjectInstance::RenderShadow()
  79. {
  80. if (!isShow())
  81. return;
  83. OnRenderShadow();
  84. }
  86. void CGraphicObjectInstance::RenderPCBlocker()
  87. {
  88. if (!isShow())
  89. return;
  91. OnRenderPCBlocker();
  92. }
  94. void CGraphicObjectInstance::Update()
  95. {
  96. OnUpdate();
  98. UpdateBoundingSphere();
  99. }
  101. void CGraphicObjectInstance::Deform()
  102. {
  103. if (!isShow())
  104. return;
  106. OnDeform();
  107. }
  110. void CGraphicObjectInstance::Transform()
  111. {
  112. D3DXMATRIX out;
  113. D3DXMATRIX scale;
  114. if (m_v3Scale.x > 0.0f)
  115. {
  116. D3DXMatrixIdentity(&scale);
  117. scale._11 = m_v3Scale.x;
  118. scale._22 = m_v3Scale.y;
  119. scale._33 = m_v3Scale.z;
  120. D3DXMatrixMultiply(&out, &m_mRotation, &scale);
  121. }
  122. else
  123. out = m_mRotation;
  125. D3DXMATRIX temp;
  126. D3DXMatrixMultiply(&temp, &m_matPositon, &out);
  128. m_worldMatrix = temp;
  130. m_worldMatrix._41 += m_v3Position.x;
  131. m_worldMatrix._42 += m_v3Position.y;
  132. m_worldMatrix._43 += m_v3Position.z;
  134. D3DXMatrixMultiply(&temp, &m_matPositon, &m_matScale);
  136. D3DXMATRIX temp2;
  137. D3DXMatrixMultiply(&temp2, &temp, &m_mRotation);
  139. m_matAbsoluteTrans = temp2;
  140. m_matAbsoluteTrans._41 = m_vecScalePos.x + m_v3Position.x + m_matAbsoluteTrans._41;
  141. m_matAbsoluteTrans._42 = m_vecScalePos.y + m_v3Position.y + m_matAbsoluteTrans._42;
  142. m_matAbsoluteTrans._43 = m_vecScalePos.z + m_v3Position.z + m_matAbsoluteTrans._43;
  143. }
  145. const D3DXVECTOR3 & CGraphicObjectInstance::GetPosition() const
  146. {
  147. return m_v3Position;
  148. }
  150. const D3DXVECTOR3 & CGraphicObjectInstance::GetScale() const
  151. {
  152. return m_v3Scale;
  153. }
  155. float CGraphicObjectInstance::GetRotation()
  156. {
  157. return GetRoll();
  158. }
  160. float CGraphicObjectInstance::GetYaw()
  161. {
  162. return m_fYaw;
  163. }
  165. float CGraphicObjectInstance::GetPitch()
  166. {
  167. return m_fPitch;
  168. }
  170. float CGraphicObjectInstance::GetRoll()
  171. {
  172. return m_fRoll;
  173. }
  175. D3DXMATRIX & CGraphicObjectInstance::GetTransform()
  176. {
  177. return m_worldMatrix;
  178. }
  180. void CGraphicObjectInstance::SetRotationQuaternion(const D3DXQUATERNION &q)
  181. {
  182. D3DXMatrixRotationQuaternion(&m_mRotation, &q);
  183. }
  185. void CGraphicObjectInstance::SetRotationMatrix(const D3DXMATRIX & m)
  186. {
  187. m_mRotation = m;
  188. }
  190. void CGraphicObjectInstance::SetRotation(float fRotation)
  191. {
  192. m_fYaw = 0;
  193. m_fPitch = 0;
  194. m_fRoll = fRotation;
  196. D3DXMatrixRotationZ(&m_mRotation, D3DXToRadian(fRotation));
  197. }
  199. void CGraphicObjectInstance::SetRotation(float fYaw, float fPitch, float fRoll)
  200. {
  201. //m_fRotation = fRotation;
  202. m_fYaw = fYaw;
  203. m_fPitch = fPitch;
  204. m_fRoll = fRoll;
  206. D3DXMatrixRotationYawPitchRoll(&m_mRotation, D3DXToRadian(fYaw), D3DXToRadian(fPitch), D3DXToRadian(fRoll));
  207. }
  209. void CGraphicObjectInstance::SetPosition(float x, float y, float z)
  210. {
  211. m_v3Position.x = x;
  212. m_v3Position.y = y;
  213. m_v3Position.z = z;
  214. }
  216. void CGraphicObjectInstance::SetPosition(const D3DXVECTOR3 & newposition)
  217. {
  218. m_v3Position = newposition;
  219. }
  221. void CGraphicObjectInstance::SetScale(float x, float y, float z)
  222. {
  223. m_v3Scale.x = x;
  224. m_v3Scale.y = y;
  225. m_v3Scale.z = z;
  226. }
  228. void CGraphicObjectInstance::Show()
  229. {
  230. m_isVisible = true;
  231. }
  233. void CGraphicObjectInstance::Hide()
  234. {
  235. m_isVisible = false;
  236. }
  237. bool CGraphicObjectInstance::isShow()
  238. {
  239. return m_isVisible;
  240. }
  242. //
  244. //////////////////////////////////////////////////////////////////////////
  246. D3DXVECTOR4 & CGraphicObjectInstance::GetWTBBoxVertex(const unsigned char & c_rucNumTBBoxVertex)
  247. {
  248. return m_v4TBBox[c_rucNumTBBoxVertex];
  249. }
  251. bool CGraphicObjectInstance::isIntersect(const CRay & c_rRay, float * pu, float * pv, float * pt)
  252. {
  253. D3DXVECTOR3 v3Start, v3Dir;
  254. float fRayRange;
  255. c_rRay.GetStartPoint(&v3Start);
  256. c_rRay.GetDirection(&v3Dir, &fRayRange);
  258. TPosition posVertices[8];
  260. posVertices[0] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMin.y, m_v3TBBoxMin.z);
  261. posVertices[1] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMin.y, m_v3TBBoxMin.z);
  262. posVertices[2] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMax.y, m_v3TBBoxMin.z);
  263. posVertices[3] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMax.y, m_v3TBBoxMin.z);
  264. posVertices[4] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMin.y, m_v3TBBoxMax.z);
  265. posVertices[5] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMin.y, m_v3TBBoxMax.z);
  266. posVertices[6] = TPosition(m_v3TBBoxMin.x, m_v3TBBoxMax.y, m_v3TBBoxMax.z);
  267. posVertices[7] = TPosition(m_v3TBBoxMax.x, m_v3TBBoxMax.y, m_v3TBBoxMax.z);
  269. TIndex Indices[36] = {0, 1, 2, 1, 3, 2,
  270. 2, 0, 6, 0, 4, 6,
  271. 0, 1, 4, 1, 5, 4,
  272. 1, 3, 5, 3, 7, 5,
  273. 3, 2, 7, 2, 6, 7,
  274. 4, 5, 6, 5, 7, 6};
  276. int triCount = 12;
  277. WORD* pcurIdx = (WORD*)Indices;
  279. while (triCount--)
  280. {
  281. if (IntersectTriangle(v3Start, v3Dir,
  282. posVertices[pcurIdx[0]],
  283. posVertices[pcurIdx[1]],
  284. posVertices[pcurIdx[2]],
  285. pu, pv, pt))
  286. {
  287. return true;
  288. }
  290. pcurIdx += 3;
  291. }
  293. return false;
  294. }
  297. void CGraphicObjectInstance::SetScaleNew(float x, float y, float z)
  298. {
  299. m_vecScaleNew.x = x;
  300. m_vecScaleNew.y = y;
  301. m_vecScaleNew.z = z;
  303. D3DXMatrixScaling(&m_matScale, x, y, z);
  304. }
  306. void CGraphicObjectInstance::SetScaleNew(const D3DXVECTOR3 & newscale)
  307. {
  308. m_vecScaleNew = newscale;
  309. D3DXMatrixScaling(&m_matScale, m_vecScaleNew.x, m_vecScaleNew.y, m_vecScaleNew.z);
  310. }
  312. void CGraphicObjectInstance::SetScalePosition(float x, float y, float z)
  313. {
  314. m_vecScalePos.x = x;
  315. m_vecScalePos.y = y;
  316. m_vecScalePos.z = z;
  317. }
  319. void CGraphicObjectInstance::SetScalePosition(const D3DXVECTOR3 & newposition)
  320. {
  321. m_vecScalePos = newposition;
  322. }
  326. CGraphicObjectInstance::CGraphicObjectInstance()
  327. {
  328. m_CullingHandle = 0;
  329. Initialize();
  330. }
  332. void CGraphicObjectInstance::Initialize()
  333. {
  334. if (m_CullingHandle)
  335. CCullingManager::Instance().Unregister(m_CullingHandle);
  336. m_CullingHandle = 0;
  338. m_pHeightAttributeInstance = NULL;
  340. m_isVisible = TRUE;
  342. m_BlockCamera = false;
  344. m_v3Position.x = m_v3Position.y = m_v3Position.z = 0.0f;
  345. m_v3Scale.x = m_v3Scale.y = m_v3Scale.z = 0.0f;
  346. m_fYaw = m_fPitch = m_fRoll = 0.0f;
  348. D3DXMatrixIdentity(&m_worldMatrix);
  349. D3DXMatrixIdentity(&m_mRotation);
  351. m_vecScalePos.x = m_vecScalePos.y = m_vecScalePos.z = 0.0f;
  352. m_vecScaleNew.x = m_vecScaleNew.y = m_vecScaleNew.z = 0.0f;
  354. D3DXMatrixIdentity(&m_matAbsoluteTrans);
  355. D3DXMatrixIdentity(&m_matScale);
  356. D3DXMatrixIdentity(&m_matPositon);
  358. OnInitialize();
  359. }
  361. CGraphicObjectInstance::~CGraphicObjectInstance()
  362. {
  363. Initialize();
  364. }
  366. void CGraphicObjectInstance::UpdateBoundingSphere()
  367. {
  368. if (m_CullingHandle)
  369. {
  370. Vector3d center;
  371. float radius;
  372. GetBoundingSphere(center,radius);
  373. if (radius != m_CullingHandle->GetRadius())
  374. m_CullingHandle->NewPosRadius(center,radius);
  375. else
  376. m_CullingHandle->NewPos(center);
  377. }
  378. }
  380. void CGraphicObjectInstance::RegisterBoundingSphere()
  381. {
  382. if (m_CullingHandle)
  383. CCullingManager::Instance().Unregister(m_CullingHandle);
  385. m_CullingHandle = CCullingManager::Instance().Register(this);
  386. }
  388. void CGraphicObjectInstance::AddCollision(const CStaticCollisionData * pscd, const D3DXMATRIX* pMat)
  389. {
  390. m_StaticCollisionInstanceVector.push_back(CBaseCollisionInstance::BuildCollisionInstance(pscd, pMat));
  391. }
  393. void CGraphicObjectInstance::ClearCollision()
  394. {
  395. CCollisionInstanceVector::iterator it;
  396. for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
  397. {
  398. (*it)->Destroy();
  399. }
  400. m_StaticCollisionInstanceVector.clear();
  401. }
  403. bool CGraphicObjectInstance::CollisionDynamicSphere(const CDynamicSphereInstance & s) const
  404. {
  405. CCollisionInstanceVector::const_iterator it;
  406. for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
  407. {
  408. if ((*it)->CollisionDynamicSphere(s))
  409. return true;
  410. }
  411. return false;
  412. }
  414. bool CGraphicObjectInstance::MovementCollisionDynamicSphere(const CDynamicSphereInstance & s) const
  415. {
  416. CCollisionInstanceVector::const_iterator it;
  417. for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
  418. {
  419. if ((*it)->MovementCollisionDynamicSphere(s))
  420. return true;
  421. }
  422. return false;
  423. }
  425. D3DXVECTOR3 CGraphicObjectInstance::GetCollisionMovementAdjust(const CDynamicSphereInstance & s) const
  426. {
  427. CCollisionInstanceVector::const_iterator it;
  428. for(it = m_StaticCollisionInstanceVector.begin();it!=m_StaticCollisionInstanceVector.end();++it)
  429. {
  430. if ((*it)->MovementCollisionDynamicSphere(s))
  431. return (*it)->GetCollisionMovementAdjust(s);
  432. }
  434. return D3DXVECTOR3(0.0f,0.0f,0.0f);
  435. }
  437. void CGraphicObjectInstance::UpdateCollisionData(const CStaticCollisionDataVector * pscdVector)
  438. {
  439. ClearCollision();
  440. OnUpdateCollisionData(pscdVector);
  441. }
  443. DWORD CGraphicObjectInstance::GetCollisionInstanceCount()
  444. {
  445. return m_StaticCollisionInstanceVector.size();
  446. }
  448. CBaseCollisionInstance * CGraphicObjectInstance::GetCollisionInstanceData(DWORD dwIndex)
  449. {
  450. if (dwIndex>m_StaticCollisionInstanceVector.size())
  451. {
  452. return 0;
  453. }
  454. return m_StaticCollisionInstanceVector[dwIndex];
  455. }
  457. //////////////////////////////////////////////////////////////////////////
  458. // Height
  460. void CGraphicObjectInstance::SetHeightInstance(CAttributeInstance * pAttributeInstance)
  461. {
  462. m_pHeightAttributeInstance = pAttributeInstance;
  463. }
  465. void CGraphicObjectInstance::ClearHeightInstance()
  466. {
  467. m_pHeightAttributeInstance = NULL;
  468. }
  470. void CGraphicObjectInstance::UpdateHeightInstance(CAttributeInstance * pAttributeInstance)
  471. {
  472. ClearHeightInstance();
  473. OnUpdateHeighInstance(pAttributeInstance);
  474. }
  476. bool CGraphicObjectInstance::IsObjectHeight()
  477. {
  478. if (m_pHeightAttributeInstance)
  479. return true;
  481. return false;
  482. }
  484. bool CGraphicObjectInstance::GetObjectHeight(float fX, float fY, float * pfHeight)
  485. {
  486. if (!m_pHeightAttributeInstance)
  487. return false;
  489. return OnGetObjectHeight(fX, fY, pfHeight);
  490. }
  492. void CGraphicObjectInstance::SetPortal(DWORD dwIndex, int iID)
  493. {
  494. if (dwIndex >= PORTAL_ID_MAX_NUM)
  495. {
  496. assert(dwIndex < PORTAL_ID_MAX_NUM);
  497. return;
  498. }
  500. m_abyPortalID[dwIndex] = iID;
  501. }
  503. int CGraphicObjectInstance::GetPortal(DWORD dwIndex)
  504. {
  505. if (dwIndex >= PORTAL_ID_MAX_NUM)
  506. {
  507. assert(dwIndex < PORTAL_ID_MAX_NUM);
  508. return 0;
  509. }
  511. return m_abyPortalID[dwIndex];
  512. }