1. #include "StdAfx.h"
  2. #include "../eterbase/Debug.h"
  3. #include "../eterlib/Camera.h"
  4. #include "../eterBase/Timer.h"
  5. #include "ThingInstance.h"
  6. #include "Thing.h"
  7. #include "ModelInstance.h"
  9. CDynamicPool<CGraphicThingInstance> CGraphicThingInstance::ms_kPool;
  11. CGraphicThing* CGraphicThingInstance::GetBaseThingPtr()
  12. {
  13. if (m_modelThingSetVector.empty())
  14. return NULL;
  16. TModelThingSet& rkModelThingSet=m_modelThingSetVector[0];
  17. if (rkModelThingSet.m_pLODThingRefVector.empty())
  18. return NULL;
  20. CGraphicThing::TRef* proThing=rkModelThingSet.m_pLODThingRefVector[0];
  21. if (!proThing)
  22. return NULL;
  24. CGraphicThing::TRef roThing=*proThing;
  25. return roThing.GetPointer();
  26. }
  28. bool CGraphicThingInstance::LessRenderOrder(CGraphicThingInstance* pkThingInst)
  29. {
  30. return (GetBaseThingPtr()<pkThingInst->GetBaseThingPtr());
  31. }
  33. void CGraphicThingInstance::CreateSystem(UINT uCapacity)
  34. {
  35. ms_kPool.Create(uCapacity);
  36. }
  38. void CGraphicThingInstance::DestroySystem()
  39. {
  40. ms_kPool.Destroy();
  41. }
  43. CGraphicThingInstance* CGraphicThingInstance::New()
  44. {
  45. return ms_kPool.Alloc();
  46. }
  48. void CGraphicThingInstance::Delete(CGraphicThingInstance* pkThingInst)
  49. {
  50. pkThingInst->Clear();
  51. ms_kPool.Free(pkThingInst);
  52. }
  54. void CGraphicThingInstance::SetMotionAtEnd()
  55. {
  56. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), std::void_mem_fun(&CGrannyLODController::SetMotionAtEnd));
  57. }
  59. bool CGraphicThingInstance::Picking(const D3DXVECTOR3 & v, const D3DXVECTOR3 & dir, float & out_x, float & out_y)
  60. {
  61. if (!m_pHeightAttributeInstance)
  62. return false;
  63. return m_pHeightAttributeInstance->Picking(v,dir,out_x,out_y);
  64. }
  67. void CGraphicThingInstance::OnUpdateCollisionData(const CStaticCollisionDataVector * pscdVector)
  68. {
  69. assert(pscdVector);
  70. CStaticCollisionDataVector::const_iterator it;
  71. for(it = pscdVector->begin();it!=pscdVector->end();++it)
  72. {
  73. AddCollision(&(*it),&GetTransform());
  74. }
  75. }
  77. void CGraphicThingInstance::OnUpdateHeighInstance(CAttributeInstance * pAttributeInstance)
  78. {
  79. assert(pAttributeInstance);
  80. SetHeightInstance(pAttributeInstance);
  81. }
  83. bool CGraphicThingInstance::OnGetObjectHeight(float fX, float fY, float * pfHeight)
  84. {
  85. if (m_pHeightAttributeInstance && m_pHeightAttributeInstance->GetHeight(fX, fY, pfHeight))
  86. return true;
  87. return false;
  88. }
  90. void CGraphicThingInstance::BuildBoundingSphere()
  91. {
  92. D3DXVECTOR3 v3Min, v3Max;
  93. GetBoundBox(0, &v3Min, &v3Max);
  94. m_v3Center = (v3Min + v3Max) * 0.5f;
  95. D3DXVECTOR3 vDelta = (v3Max - v3Min);
  97. m_fRadius = D3DXVec3Length(&vDelta) * 0.5f + 50.0f; // extra length for attached objects
  98. }
  100. bool CGraphicThingInstance::GetBoundingSphere(D3DXVECTOR3 & v3Center, float & fRadius)
  101. {
  102. if (m_fRadius <= 0)
  103. {
  104. BuildBoundingSphere();
  106. fRadius = m_fRadius;
  107. v3Center = m_v3Center;
  108. }
  109. else
  110. {
  111. fRadius = m_fRadius;
  112. v3Center = m_v3Center;
  113. }
  115. D3DXVec3TransformCoord(&v3Center, &v3Center, &GetTransform());
  116. return true;
  117. }
  119. void CGraphicThingInstance::BuildBoundingAABB()
  120. {
  121. D3DXVECTOR3 v3Min, v3Max;
  122. GetBoundBox(0, &v3Min, &v3Max);
  123. m_v3Center = (v3Min + v3Max) * 0.5f;
  124. m_v3Min = v3Min;
  125. m_v3Max = v3Max;
  126. }
  128. bool CGraphicThingInstance::GetBoundingAABB(D3DXVECTOR3 & v3Min, D3DXVECTOR3 & v3Max)
  129. {
  130. BuildBoundingAABB();
  132. v3Min = m_v3Min;
  133. v3Max = m_v3Max;
  135. D3DXVec3TransformCoord(&m_v3Center, &m_v3Center, &GetTransform());
  136. return true;
  137. }
  139. void CGraphicThingInstance::CalculateBBox()
  140. {
  141. GetBoundBox(&m_v3BBoxMin, &m_v3BBoxMax);
  143. m_v4TBBox[0] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMin.y, m_v3BBoxMin.z, 1.0f);
  144. m_v4TBBox[1] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMax.y, m_v3BBoxMin.z, 1.0f);
  145. m_v4TBBox[2] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMin.y, m_v3BBoxMin.z, 1.0f);
  146. m_v4TBBox[3] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMax.y, m_v3BBoxMin.z, 1.0f);
  147. m_v4TBBox[4] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMin.y, m_v3BBoxMax.z, 1.0f);
  148. m_v4TBBox[5] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMax.y, m_v3BBoxMax.z, 1.0f);
  149. m_v4TBBox[6] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMin.y, m_v3BBoxMax.z, 1.0f);
  150. m_v4TBBox[7] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMax.y, m_v3BBoxMax.z, 1.0f);
  152. const D3DXMATRIX & c_rmatTransform = GetTransform();
  154. for (DWORD i = 0; i < 8; ++i)
  155. {
  156. D3DXVec4Transform(&m_v4TBBox[i], &m_v4TBBox[i], &c_rmatTransform);
  157. if (0 == i)
  158. {
  159. m_v3TBBoxMin.x = m_v4TBBox[i].x;
  160. m_v3TBBoxMin.y = m_v4TBBox[i].y;
  161. m_v3TBBoxMin.z = m_v4TBBox[i].z;
  162. m_v3TBBoxMax.x = m_v4TBBox[i].x;
  163. m_v3TBBoxMax.y = m_v4TBBox[i].y;
  164. m_v3TBBoxMax.z = m_v4TBBox[i].z;
  165. }
  166. else
  167. {
  168. if (m_v3TBBoxMin.x > m_v4TBBox[i].x)
  169. m_v3TBBoxMin.x = m_v4TBBox[i].x;
  170. if (m_v3TBBoxMax.x < m_v4TBBox[i].x)
  171. m_v3TBBoxMax.x = m_v4TBBox[i].x;
  172. if (m_v3TBBoxMin.y > m_v4TBBox[i].y)
  173. m_v3TBBoxMin.y = m_v4TBBox[i].y;
  174. if (m_v3TBBoxMax.y < m_v4TBBox[i].y)
  175. m_v3TBBoxMax.y = m_v4TBBox[i].y;
  176. if (m_v3TBBoxMin.z > m_v4TBBox[i].z)
  177. m_v3TBBoxMin.z = m_v4TBBox[i].z;
  178. if (m_v3TBBoxMax.z < m_v4TBBox[i].z)
  179. m_v3TBBoxMax.z = m_v4TBBox[i].z;
  180. }
  181. }
  182. }
  184. bool CGraphicThingInstance::CreateDeviceObjects()
  185. {
  186. CGrannyLODController::FCreateDeviceObjects createDeviceObjects;
  187. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), createDeviceObjects);
  188. return true;
  189. }
  191. void CGraphicThingInstance::DestroyDeviceObjects()
  192. {
  193. CGrannyLODController::FDestroyDeviceObjects destroyDeviceObjects;
  194. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), destroyDeviceObjects);
  195. }
  197. bool CGraphicThingInstance::CheckModelInstanceIndex(int iModelInstance)
  198. {
  199. if (iModelInstance < 0)
  200. return false;
  202. int max = m_LODControllerVector.size();
  204. if (iModelInstance >= max)
  205. return false;
  207. return true;
  208. }
  210. bool CGraphicThingInstance::CheckModelThingIndex(int iModelThing)
  211. {
  212. if (iModelThing < 0)
  213. return false;
  215. int max = m_modelThingSetVector.size();
  217. if (iModelThing >= max)
  218. return false;
  220. return true;
  221. }
  223. bool CGraphicThingInstance::CheckMotionThingIndex(DWORD dwMotionKey)
  224. {
  225. std::map<DWORD, CGraphicThing::TRef *>::iterator itor = m_roMotionThingMap.find(dwMotionKey);
  227. if (m_roMotionThingMap.end() == itor)
  228. return false;
  230. return true;
  231. }
  233. bool CGraphicThingInstance::GetMotionThingPointer(DWORD dwKey, CGraphicThing ** ppMotion)
  234. {
  235. if (!CheckMotionThingIndex(dwKey))
  236. return false;
  238. *ppMotion = m_roMotionThingMap[dwKey]->GetPointer();
  239. return true;
  240. }
  242. bool CGraphicThingInstance::IsMotionThing()
  243. {
  244. return !m_roMotionThingMap.empty();
  245. }
  247. void CGraphicThingInstance::ReserveModelInstance(int iCount)
  248. {
  249. stl_wipe(m_LODControllerVector);
  251. for (int i = 0; i < iCount; ++i)
  252. {
  253. CGrannyLODController * pInstance = new CGrannyLODController;
  254. m_LODControllerVector.push_back(pInstance);
  255. }
  256. }
  258. void CGraphicThingInstance::ReserveModelThing(int iCount)
  259. {
  260. m_modelThingSetVector.resize(iCount);
  261. }
  263. bool CGraphicThingInstance::FindBoneIndex(int iModelInstance, const char* c_szBoneName, int* iRetBone)
  264. {
  265. assert(CheckModelInstanceIndex(iModelInstance));
  267. CGrannyModelInstance * pModelInstance = m_LODControllerVector[iModelInstance]->GetModelInstance();
  269. if (!pModelInstance)
  270. return false;
  272. return pModelInstance->GetBoneIndexByName(c_szBoneName, iRetBone);
  273. }
  275. void CGraphicThingInstance::AttachModelInstance(int iDstModelInstance, const char * c_szBoneName, int iSrcModelInstance)
  276. {
  277. if (!CheckModelInstanceIndex(iSrcModelInstance))
  278. {
  279. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  280. return;
  281. }
  282. if (!CheckModelInstanceIndex(iDstModelInstance))
  283. {
  284. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  285. return;
  286. }
  288. CGrannyLODController * pSrcLODController = m_LODControllerVector[iSrcModelInstance];
  289. CGrannyLODController * pDstLODController = m_LODControllerVector[iDstModelInstance];
  290. pDstLODController->AttachModelInstance(pSrcLODController, c_szBoneName);
  291. }
  293. void CGraphicThingInstance::AttachModelInstance(int iDstModelInstance, const char * c_szBoneName, CGraphicThingInstance & rSrcInstance, int iSrcModelInstance)
  294. {
  295. if (!CheckModelInstanceIndex(iDstModelInstance))
  296. {
  297. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  298. return;
  299. }
  300. if (!rSrcInstance.CheckModelInstanceIndex(iSrcModelInstance))
  301. {
  302. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  303. return;
  304. }
  306. CGrannyLODController * pDstLODController = m_LODControllerVector[iDstModelInstance];
  307. CGrannyLODController * pSrcLODController = rSrcInstance.m_LODControllerVector[iSrcModelInstance];
  308. pDstLODController->AttachModelInstance(pSrcLODController, c_szBoneName);
  309. }
  311. void CGraphicThingInstance::DetachModelInstance(int iDstModelInstance, CGraphicThingInstance & rSrcInstance, int iSrcModelInstance)
  312. {
  313. if (!CheckModelInstanceIndex(iDstModelInstance))
  314. {
  315. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, iSrcModelInstance=%d)", iDstModelInstance, iSrcModelInstance);
  316. return;
  317. }
  318. if (!rSrcInstance.CheckModelInstanceIndex(iSrcModelInstance))
  319. {
  320. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, iSrcModelInstance=%d)", iDstModelInstance, iSrcModelInstance);
  321. return;
  322. }
  324. CGrannyLODController * pDstLODController = m_LODControllerVector[iDstModelInstance];
  325. CGrannyLODController * pSrcLODController = rSrcInstance.m_LODControllerVector[iSrcModelInstance];
  326. pDstLODController->DetachModelInstance(pSrcLODController);
  327. }
  329. bool CGraphicThingInstance::GetBonePosition(int iModelIndex, int iBoneIndex, float * pfx, float * pfy, float * pfz)
  330. {
  331. assert(CheckModelInstanceIndex(iModelIndex));
  333. CGrannyModelInstance * pModelInstance = m_LODControllerVector[iModelIndex]->GetModelInstance();
  335. if (!pModelInstance)
  336. return false;
  338. const float * pfMatrix = pModelInstance->GetBoneMatrixPointer(iBoneIndex);
  340. *pfx = pfMatrix[12];
  341. *pfy = pfMatrix[13];
  342. *pfz = pfMatrix[14];
  343. return true;
  344. }
  345. //iSkelInstance °¡ ÀÖÀ¸¸é ±âº» º»¿¡ Link(º»ÀÌ ºÙ´Â°Í)½ÃÅ°°í,
  346. //¾øÀ¸¸é ±âº» º»¿¡ attach(ÁÂÇ¥¸¸ °¡Á®´Ù ¾²´Â°Í) µË´Ï´Ù.
  347. bool CGraphicThingInstance::SetModelInstance(int iDstModelInstance, int iSrcModelThing, int iSrcModel,int iSkelInstance)
  348. {
  349. if (!CheckModelInstanceIndex(iDstModelInstance))
  350. {
  351. TraceError("CGraphicThingInstance::SetModelInstance(iDstModelInstance=%d, pModelThing=%d, iSrcModel=%d)\n", iDstModelInstance, iSrcModelThing, iSrcModel);
  352. return false;
  353. }
  354. if (!CheckModelThingIndex(iSrcModelThing))
  355. {
  356. TraceError("CGraphicThingInstance::SetModelInstance(iDstModelInstance=%d, pModelThing=%d, iSrcModel=%d)\n", iDstModelInstance, iSrcModelThing, iSrcModel);
  357. return false;
  358. }
  360. CGrannyLODController * pController = m_LODControllerVector[iDstModelInstance];
  361. if (!pController)
  362. return false;
  364. // HAIR_LINK
  365. CGrannyLODController * pSkelController = NULL;
  366. if (iSkelInstance != DONTUSEVALUE)
  367. {
  368. if (!CheckModelInstanceIndex(iSkelInstance))
  369. {
  370. TraceError("CGraphicThingInstance::SetModelInstanceByOtherSkeletonInstance(iSkelInstance=%d, iDstModelInstance=%d, pModelThing=%d, iSrcModel=%d)\n", iSkelInstance, iDstModelInstance, iSrcModelThing, iSrcModel);
  371. return false;
  372. }
  373. pSkelController = m_LODControllerVector[iSkelInstance];
  374. if (!pSkelController)
  375. return false;
  376. }
  377. // END_OF_HAIR_LINK
  379. TModelThingSet & rModelThingSet = m_modelThingSetVector[iSrcModelThing];
  381. pController->Clear();
  384. for (DWORD i = 0; i < rModelThingSet.m_pLODThingRefVector.size(); ++i)
  385. {
  386. if (rModelThingSet.m_pLODThingRefVector[i]->IsNull())
  387. return false;
  389. pController->AddModel(rModelThingSet.m_pLODThingRefVector[i]->GetPointer(), iSrcModel, pSkelController);
  390. }
  391. return true;
  392. }
  394. void CGraphicThingInstance::SetMaterialImagePointer(UINT ePart, const char* c_szImageName, CGraphicImage* pImage)
  395. {
  396. if (ePart>=m_LODControllerVector.size())
  397. {
  398. TraceError("CGraphicThingInstance::SetMaterialImagePointer(ePart(%d)<uPartCount(%d), c_szImageName=%s, pImage=%s) - ePart OUT OF RANGE",
  399. ePart, m_LODControllerVector.size(), c_szImageName, pImage->GetFileName());
  401. return;
  402. }
  404. if (!m_LODControllerVector[ePart])
  405. {
  406. TraceError("CGraphicThingInstance::SetMaterialImagePointer(ePart(%d), c_szImageName=%s, pImage=%s) - ePart Data is NULL",
  407. ePart, m_LODControllerVector.size(), c_szImageName, pImage->GetFileName());
  409. return;
  410. }
  412. m_LODControllerVector[ePart]->SetMaterialImagePointer(c_szImageName, pImage);
  413. }
  415. void CGraphicThingInstance::SetMaterialData(UINT ePart, const char* c_szImageName, SMaterialData kMaterialData)
  416. {
  417. if (ePart>=m_LODControllerVector.size())
  418. {
  419. TraceError("CGraphicThingInstance::SetMaterialData(ePart(%d)<uPartCount(%d)) - ePart OUT OF RANGE",
  420. ePart, m_LODControllerVector.size());
  422. return;
  423. }
  425. if (!m_LODControllerVector[ePart])
  426. {
  427. TraceError("CGraphicThingInstance::SetMaterialData(ePart(%d)) - ePart Data is NULL",
  428. ePart, m_LODControllerVector.size());
  430. return;
  431. }
  433. m_LODControllerVector[ePart]->SetMaterialData(c_szImageName, kMaterialData);
  434. }
  436. void CGraphicThingInstance::SetSpecularInfo(UINT ePart, const char* c_szMtrlName, BOOL bEnable, float fPower)
  437. {
  438. if (ePart>=m_LODControllerVector.size())
  439. {
  440. TraceError("CGraphicThingInstance::SetSpecularInfo(ePart(%d)<uPartCount(%d)) - ePart OUT OF RANGE",
  441. ePart, m_LODControllerVector.size());
  443. return;
  444. }
  446. if (!m_LODControllerVector[ePart])
  447. {
  448. TraceError("CGraphicThingInstance::SetSpecularInfo(ePart(%d)) - ePart Data is NULL",
  449. ePart, m_LODControllerVector.size());
  451. return;
  452. }
  454. m_LODControllerVector[ePart]->SetSpecularInfo(c_szMtrlName, bEnable, fPower);
  455. }
  457. bool CGraphicThingInstance::SetMotion(DWORD dwMotionKey, float blendTime, int loopCount, float speedRatio)
  458. {
  459. if (!CheckMotionThingIndex(dwMotionKey))
  460. return false;
  462. std::map<DWORD, CGraphicThing::TRef *>::iterator itor = m_roMotionThingMap.find(dwMotionKey);
  463. CGraphicThing::TRef * proMotionThing = itor->second;
  464. CGraphicThing * pMotionThing = proMotionThing->GetPointer();
  466. if (!pMotionThing)
  467. return false;
  469. if (!pMotionThing->CheckMotionIndex(0))
  470. return false;
  472. CGrannyLODController::FSetMotionPointer SetMotionPointer;
  473. SetMotionPointer.m_pMotion = pMotionThing->GetMotionPointer(0);
  474. SetMotionPointer.m_blendTime = blendTime;
  475. SetMotionPointer.m_loopCount = loopCount;
  476. SetMotionPointer.m_speedRatio = speedRatio;
  478. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), SetMotionPointer);
  479. return true;
  480. }
  482. bool CGraphicThingInstance::ChangeMotion(DWORD dwMotionKey, int loopCount, float speedRatio)
  483. {
  484. if (!CheckMotionThingIndex(dwMotionKey))
  485. return false;
  487. std::map<DWORD, CGraphicThing::TRef *>::iterator itor = m_roMotionThingMap.find(dwMotionKey);
  488. CGraphicThing::TRef * proMotionThing = itor->second;
  489. CGraphicThing * pMotionThing = proMotionThing->GetPointer();
  491. if (!pMotionThing)
  492. return false;
  494. if (!pMotionThing->CheckMotionIndex(0))
  495. return false;
  497. CGrannyLODController::FChangeMotionPointer ChangeMotionPointer;
  498. ChangeMotionPointer.m_pMotion = pMotionThing->GetMotionPointer(0);
  499. ChangeMotionPointer.m_loopCount = loopCount;
  500. ChangeMotionPointer.m_speedRatio = speedRatio;
  502. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), ChangeMotionPointer);
  503. return true;
  504. }
  506. void CGraphicThingInstance::SetEndStopMotion()
  507. {
  508. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), CGrannyLODController::FEndStopMotionPointer());
  509. }
  511. void CGraphicThingInstance::RegisterModelThing(int iModelThing, CGraphicThing * pModelThing)
  512. {
  513. if (!CheckModelThingIndex(iModelThing))
  514. {
  515. TraceError("CGraphicThingInstance::RegisterModelThing(iModelThing=%d, pModelThing=%s)\n", iModelThing, pModelThing->GetFileName());
  516. return;
  517. }
  519. m_modelThingSetVector[iModelThing].Clear();
  521. if (pModelThing)
  522. RegisterLODThing(iModelThing, pModelThing);
  523. }
  525. void CGraphicThingInstance::RegisterLODThing(int iModelThing, CGraphicThing * pModelThing)
  526. {
  527. assert(CheckModelThingIndex(iModelThing));
  528. CGraphicThing::TRef * pModelRef = new CGraphicThing::TRef;
  529. pModelRef->SetPointer(pModelThing);
  530. m_modelThingSetVector[iModelThing].m_pLODThingRefVector.push_back(pModelRef);
  531. }
  533. void CGraphicThingInstance::RegisterMotionThing(DWORD dwMotionKey, CGraphicThing* pMotionThing)
  534. {
  535. CGraphicThing::TRef * pMotionRef = new CGraphicThing::TRef;
  536. pMotionRef->SetPointer(pMotionThing);
  537. m_roMotionThingMap.insert(std::map<DWORD, CGraphicThing::TRef *>::value_type(dwMotionKey, pMotionRef));
  538. }
  540. void CGraphicThingInstance::ResetLocalTime()
  541. {
  542. //m_clockLast = GrannyGetSystemSeconds();
  543. m_fLastLocalTime = 0.0f;
  544. m_fLocalTime = 0.0f;
  546. CGrannyLODController::FResetLocalTime resetLocalTime;
  547. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), resetLocalTime);
  548. }
  550. /*
  551. void CGraphicThingInstance::SetMotionSpeed(float fRate)
  552. {
  553. m_fMotionTimeSpeed = fRate;
  554. }
  555. */
  556. void CGraphicThingInstance::InsertDelay(float fDelay)
  557. {
  558. m_fDelay = fDelay;
  559. }
  561. float CGraphicThingInstance::GetLastLocalTime()
  562. {
  563. return m_fLastLocalTime;
  564. }
  566. float CGraphicThingInstance::GetLocalTime()
  567. {
  568. return m_fLocalTime;
  569. }
  571. float CGraphicThingInstance::GetSecondElapsed()
  572. {
  573. return m_fSecondElapsed;
  574. }
  576. float CGraphicThingInstance::GetAverageSecondElapsed()
  577. {
  578. return m_fAverageSecondElapsed;
  579. }
  581. bool CGraphicThingInstance::Intersect(float* pu, float* pv, float* pt)
  582. {
  583. if (!CGraphicObjectInstance::isShow())
  584. return false;
  585. if (!m_bUpdated)
  586. return false;
  588. if (m_LODControllerVector.empty())
  589. {
  590. //TraceError("CGraphicThingInstance::Intersect - m_LODControllerVector is empty");
  591. return false;
  592. }
  594. return m_LODControllerVector[0]->Intersect(&GetTransform(), pu, pv, pt);
  595. }
  597. void CGraphicThingInstance::GetBoundBox(D3DXVECTOR3* vtMin, D3DXVECTOR3* vtMax)
  598. {
  599. vtMin->x = vtMin->y = vtMin->z = 100000.0f;
  600. vtMax->x = vtMax->y = vtMax->z = -100000.0f;
  601. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), CGrannyLODController::FBoundBox(vtMin, vtMax));
  602. }
  604. BOOL CGraphicThingInstance::GetBoundBox(DWORD dwModelInstanceIndex, D3DXVECTOR3 * vtMin, D3DXVECTOR3 * vtMax)
  605. {
  606. if (!CheckModelInstanceIndex(dwModelInstanceIndex))
  607. return FALSE;
  609. vtMin->x = vtMin->y = vtMin->z = 100000.0f;
  610. vtMax->x = vtMax->y = vtMax->z = -100000.0f;
  612. CGrannyLODController * pController = m_LODControllerVector[dwModelInstanceIndex];
  613. if (!pController->isModelInstance())
  614. return FALSE;
  616. CGrannyModelInstance * pModelInstance = pController->GetModelInstance();
  617. pModelInstance->GetBoundBox(vtMin, vtMax);
  618. return TRUE;
  619. }
  621. BOOL CGraphicThingInstance::GetBoneMatrix(DWORD dwModelInstanceIndex, DWORD dwBoneIndex, D3DXMATRIX ** ppMatrix)
  622. {
  623. if (!CheckModelInstanceIndex(dwModelInstanceIndex))
  624. return FALSE;
  626. CGrannyModelInstance * pModelInstance = m_LODControllerVector[dwModelInstanceIndex]->GetModelInstance();
  627. if (!pModelInstance)
  628. return FALSE;
  630. *ppMatrix = (D3DXMATRIX *)pModelInstance->GetBoneMatrixPointer(dwBoneIndex);
  631. if (!*ppMatrix)
  632. return FALSE;
  634. return TRUE;
  635. }
  637. BOOL CGraphicThingInstance::GetCompositeBoneMatrix(DWORD dwModelInstanceIndex, DWORD dwBoneIndex, D3DXMATRIX ** ppMatrix)
  638. {
  639. if (!CheckModelInstanceIndex(dwModelInstanceIndex))
  640. return FALSE;
  642. CGrannyModelInstance * pModelInstance = m_LODControllerVector[dwModelInstanceIndex]->GetModelInstance();
  643. if (!pModelInstance)
  644. {
  645. //TraceError("CGraphicThingInstance::GetCompositeBoneMatrix(dwModelInstanceIndex=%d, dwBoneIndex=%d, D3DXMATRIX ** ppMatrix)", dwModelInstanceIndex, dwBoneIndex);
  646. return FALSE;
  647. }
  649. *ppMatrix = (D3DXMATRIX *)pModelInstance->GetCompositeBoneMatrixPointer(dwBoneIndex);
  651. return TRUE;
  652. }
  654. void CGraphicThingInstance::UpdateTransform(D3DXMATRIX * pMatrix, float fSecondsElapsed, int iModelInstanceIndex)
  655. {
  656. //TraceError("%s",GetBaseThingPtr()->GetFileName());
  657. int nLODCount=m_LODControllerVector.size();
  658. if (iModelInstanceIndex>=nLODCount)
  659. {
  660. //TraceError("void CGraphicThingInstance::UpdateTransform(pMatrix, fSecondsElapsed=%f, iModelInstanceIndex=%d/nLODCount=%d)",
  661. // fSecondsElapsed, iModelInstanceIndex, nLODCount);
  662. return;
  663. }
  665. CGrannyLODController* pkLODCtrl=m_LODControllerVector[iModelInstanceIndex];
  666. if (!pkLODCtrl)
  667. {
  668. //TraceError("void CGraphicThingInstance::UpdateTransform(pMatrix, fSecondsElapsed=%f, iModelInstanceIndex=%d/nLODCount=%d) - m_LODControllerVector[iModelInstanceIndex] == NULL",
  669. // fSecondsElapsed, iModelInstanceIndex, nLODCount);
  670. return;
  671. }
  673. CGrannyModelInstance * pModelInstance = pkLODCtrl->GetModelInstance();
  674. if (!pModelInstance)
  675. {
  676. /* TraceError("void CGraphicThingInstance::UpdateTransform(pMatrix, fSecondsElapsed=%f, iModelInstanceIndex=%d/nLODCount=%d) - pkLODCtrl->GetModelInstance() == NULL",
  677. fSecondsElapsed, iModelInstanceIndex, nLODCount);*/
  678. return;
  679. }
  681. pModelInstance->UpdateTransform(pMatrix, fSecondsElapsed);
  682. }
  684. void CGraphicThingInstance::DeformAll()
  685. {
  686. m_bUpdated = true;
  688. CGrannyLODController::FDeformAll deform;
  689. deform.mc_pWorldMatrix = &m_worldMatrix;
  690. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), deform);
  691. }
  693. void CGraphicThingInstance::DeformNoSkin()
  694. {
  695. m_bUpdated = true;
  697. for (std::vector<CGrannyLODController*>::size_type i = 0; i != m_LODControllerVector.size(); i++)
  698. {
  699. if (i == 5)
  700. {
  701. CGrannyLODController* pkLOD = m_LODControllerVector[i];
  702. if (pkLOD->isModelInstance())
  703. pkLOD->DeformNoSkin(&m_matAbsoluteTrans);
  704. }
  705. else
  706. {
  707. CGrannyLODController* pkLOD = m_LODControllerVector[i];
  708. if (pkLOD->isModelInstance())
  709. pkLOD->DeformNoSkin(&m_worldMatrix);
  710. }
  711. }
  712. }
  714. void CGraphicThingInstance::OnDeform()
  715. {
  716. m_bUpdated = true;
  718. for (std::vector<CGrannyLODController*>::size_type i = 0; i != m_LODControllerVector.size(); i++)
  719. {
  720. if (i == 5)
  721. {
  722. CGrannyLODController* pkLOD = m_LODControllerVector[i];
  723. if (pkLOD->isModelInstance())
  724. pkLOD->Deform(&m_matAbsoluteTrans);
  725. }
  726. else
  727. {
  728. CGrannyLODController* pkLOD = m_LODControllerVector[i];
  729. if (pkLOD->isModelInstance())
  730. pkLOD->Deform(&m_worldMatrix);
  731. }
  732. }
  733. }
  735. void CGraphicThingInstance::__SetLocalTime(float fLocalTime)
  736. {
  737. m_fLastLocalTime = m_fLocalTime;
  738. m_fLocalTime = fLocalTime;
  740. CGrannyLODController::FSetLocalTime SetLocalTime;
  741. SetLocalTime.fLocalTime = fLocalTime;
  742. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), SetLocalTime);
  743. }
  745. void CGraphicThingInstance::UpdateLODLevel()
  746. {
  747. CCamera * pcurCamera = CCameraManager::Instance().GetCurrentCamera();
  748. if (!pcurCamera)
  749. {
  750. TraceError("CGraphicThingInstance::UpdateLODLevel - GetCurrentCamera() == NULL");
  751. return;
  752. }
  754. const D3DXVECTOR3 & c_rv3TargetPosition = pcurCamera->GetTarget();
  755. const D3DXVECTOR3 & c_rv3CameraPosition = pcurCamera->GetEye();
  756. const D3DXVECTOR3 & c_v3Position = GetPosition();
  758. // NOTE : Áß½ÉÀ¸·ÎºÎÅÍÀÇ °Å¸® °è»ê¿¡ z°ª Â÷ÀÌ´Â »ç¿ëÇÏÁö ¾Ê´Â´Ù. - [levites]
  759. CGrannyLODController::FUpdateLODLevel update;
  760. update.fDistanceFromCenter = sqrtf((c_rv3TargetPosition.x - c_v3Position.x) * (c_rv3TargetPosition.x - c_v3Position.x) +
  761. (c_rv3TargetPosition.y - c_v3Position.y) * (c_rv3TargetPosition.y - c_v3Position.y));
  762. update.fDistanceFromCamera = sqrtf((c_rv3CameraPosition.x - c_v3Position.x) * (c_rv3CameraPosition.x - c_v3Position.x) +
  763. (c_rv3CameraPosition.y - c_v3Position.y) * (c_rv3CameraPosition.y - c_v3Position.y) +
  764. (c_rv3CameraPosition.z - c_v3Position.z) * (c_rv3CameraPosition.z - c_v3Position.z));
  766. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), update);
  767. }
  769. void CGraphicThingInstance::UpdateTime()
  770. {
  771. //granny_system_clock clockNow = GrannyGetSystemSeconds();
  772. //m_fSecondElapsed = GrannyGetSecondsElapsed(&m_clockLast, &clockNow) * m_fMotionTimeSpeed;
  774. //DWORD t1=ELTimer_GetMSec();
  776. m_fSecondElapsed=CTimer::Instance().GetElapsedSecond();
  778. if (m_fDelay > m_fSecondElapsed)
  779. {
  780. m_fDelay -= m_fSecondElapsed;
  781. m_fSecondElapsed = 0.0f;
  782. }
  783. else
  784. {
  785. m_fSecondElapsed -= m_fDelay;
  786. m_fDelay = 0.0f;
  787. }
  789. m_fLastLocalTime = m_fLocalTime;
  790. m_fLocalTime += m_fSecondElapsed;
  791. m_fAverageSecondElapsed = m_fAverageSecondElapsed + (m_fSecondElapsed - m_fAverageSecondElapsed) / 4.0f;
  792. //m_clockLast = clockNow;
  794. CGrannyLODController::FUpdateTime update;
  795. update.fElapsedTime = m_fSecondElapsed;
  796. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), update);
  797. }
  799. void CGraphicThingInstance::OnUpdate()
  800. {
  801. #ifdef __PERFORMANCE_CHECKER__
  802. DWORD t1=timeGetTime();
  803. #endif
  804. UpdateLODLevel();
  805. #ifdef __PERFORMANCE_CHECKER__
  806. DWORD t2=timeGetTime();
  807. #endif
  808. UpdateTime();
  809. #ifdef __PERFORMANCE_CHECKER__
  810. DWORD t3=timeGetTime();
  811. #endif
  813. #ifdef __PERFORMANCE_CHECKER__
  814. {
  815. static FILE* fp=fopen("perf_thing_onupdate.txt", "w");
  817. if (t3-t1>3)
  818. {
  819. fprintf(fp, "GTU.Total %d (Time %f)\n",
  820. t3-t1, ELTimer_GetMSec()/1000.0f);
  821. fprintf(fp, "GTU.CAL %d\n", t2-t1);
  822. fprintf(fp, "GTU.UP %d\n", t3-t2);
  823. fprintf(fp, "-------------------------------- \n");
  824. fflush(fp);
  825. }
  826. fflush(fp);
  827. }
  828. #endif
  829. }
  831. void CGraphicThingInstance::OnRender()
  832. {
  833. RenderWithOneTexture();
  834. }
  836. void CGraphicThingInstance::OnBlendRender()
  837. {
  838. BlendRenderWithOneTexture();
  839. }
  841. void CGraphicThingInstance::RenderWithOneTexture()
  842. {
  843. //assert(m_bUpdated);
  844. if (!m_bUpdated)
  845. return;
  847. CGrannyLODController::FRenderWithOneTexture render;
  848. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), render);
  849. }
  851. void CGraphicThingInstance::BlendRenderWithOneTexture()
  852. {
  853. //assert(m_bUpdated);
  854. if (!m_bUpdated)
  855. return;
  857. CGrannyLODController::FBlendRenderWithOneTexture blendRender;
  858. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), blendRender);
  859. }
  861. void CGraphicThingInstance::RenderWithTwoTexture()
  862. {
  863. //assert(m_bUpdated);
  864. if (!m_bUpdated)
  865. return;
  867. CGrannyLODController::FRenderWithTwoTexture render;
  868. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), render);
  869. }
  871. void CGraphicThingInstance::BlendRenderWithTwoTexture()
  872. {
  873. //assert(m_bUpdated);
  874. if (!m_bUpdated)
  875. return;
  877. CGrannyLODController::FRenderWithTwoTexture blendRender;
  878. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), blendRender);
  879. }
  881. void CGraphicThingInstance::OnRenderToShadowMap()
  882. {
  883. if (!m_bUpdated)
  884. return;
  886. CGrannyLODController::FRenderToShadowMap RenderToShadowMap;
  887. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), RenderToShadowMap);
  888. }
  890. void CGraphicThingInstance::OnRenderShadow()
  891. {
  892. CGrannyLODController::FRenderShadow RenderShadow;
  893. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), RenderShadow);
  894. }
  896. void CGraphicThingInstance::OnRenderPCBlocker()
  897. {
  898. CGrannyLODController::FRenderWithOneTexture RenderPCBlocker;
  899. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), RenderPCBlocker);
  900. }
  902. DWORD CGraphicThingInstance::GetLODControllerCount() const
  903. {
  904. return m_LODControllerVector.size();
  905. }
  907. CGrannyLODController * CGraphicThingInstance::GetLODControllerPointer(DWORD dwModelIndex) const
  908. {
  909. assert(dwModelIndex < m_LODControllerVector.size());
  910. return m_LODControllerVector[dwModelIndex];
  911. }
  913. CGrannyLODController * CGraphicThingInstance::GetLODControllerPointer(DWORD dwModelIndex)
  914. {
  915. assert(dwModelIndex < m_LODControllerVector.size());
  916. return m_LODControllerVector[dwModelIndex];
  917. }
  919. BYTE CGraphicThingInstance::GetLODLevel(DWORD dwModelInstance)
  920. {
  921. assert(dwModelInstance < m_LODControllerVector.size());
  922. return (m_LODControllerVector[dwModelInstance]->GetLODLevel());
  923. }
  925. float CGraphicThingInstance::GetHeight()
  926. {
  927. if (m_LODControllerVector.empty())
  928. return 0.0f;
  930. CGrannyModelInstance * pModelInstance = m_LODControllerVector[0]->GetModelInstance();
  931. if (!pModelInstance)
  932. return 0.0f;
  934. D3DXVECTOR3 vtMin, vtMax;
  935. pModelInstance->GetBoundBox(&vtMin, &vtMax);
  937. return fabs(vtMin.z - vtMax.z);
  938. }
  940. void CGraphicThingInstance::ReloadTexture()
  941. {
  942. CGrannyLODController::FReloadTexture ReloadTexture;
  943. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), ReloadTexture);
  944. }
  946. bool CGraphicThingInstance::HaveBlendThing()
  947. {
  948. for (int i = 0; i < m_LODControllerVector.size(); i++)
  949. {
  950. if (m_LODControllerVector[i]->HaveBlendThing())
  951. return true;
  952. }
  953. return false;
  954. }
  957. void CGraphicThingInstance::OnClear()
  958. {
  959. stl_wipe(m_LODControllerVector);
  960. stl_wipe_second(m_roMotionThingMap);
  962. for (DWORD d = 0; d < m_modelThingSetVector.size(); ++d)
  963. m_modelThingSetVector[d].Clear();
  964. }
  966. void CGraphicThingInstance::OnInitialize()
  967. {
  968. m_bUpdated = false;
  969. m_fLastLocalTime = 0.0f;
  970. m_fLocalTime = 0.0f;
  971. m_fDelay = 0.0;
  972. m_fSecondElapsed = 0.0f;
  973. m_fAverageSecondElapsed = 0.03f;
  974. m_fRadius = -1.0f;
  975. m_v3Center = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
  977. ResetLocalTime();
  978. }
  980. CGraphicThingInstance::CGraphicThingInstance()
  981. {
  982. Initialize();
  983. }
  985. CGraphicThingInstance::~CGraphicThingInstance()
  986. {
  987. }