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"
  8. #ifdef ENABLE_OBJ_SCALLING
  9. #include "../UserInterface/Locale_inc.h"
  10. #endif
  12. CDynamicPool<CGraphicThingInstance> CGraphicThingInstance::ms_kPool;
  14. CGraphicThing* CGraphicThingInstance::GetBaseThingPtr()
  15. {
  16. if (m_modelThingSetVector.empty())
  17. return NULL;
  19. TModelThingSet& rkModelThingSet=m_modelThingSetVector[0];
  20. if (rkModelThingSet.m_pLODThingRefVector.empty())
  21. return NULL;
  23. CGraphicThing::TRef* proThing=rkModelThingSet.m_pLODThingRefVector[0];
  24. if (!proThing)
  25. return NULL;
  27. CGraphicThing::TRef roThing=*proThing;
  28. return roThing.GetPointer();
  29. }
  31. bool CGraphicThingInstance::LessRenderOrder(CGraphicThingInstance* pkThingInst)
  32. {
  33. return (GetBaseThingPtr()<pkThingInst->GetBaseThingPtr());
  34. }
  36. void CGraphicThingInstance::CreateSystem(UINT uCapacity)
  37. {
  38. ms_kPool.Create(uCapacity);
  39. }
  41. void CGraphicThingInstance::DestroySystem()
  42. {
  43. ms_kPool.Destroy();
  44. }
  46. CGraphicThingInstance* CGraphicThingInstance::New()
  47. {
  48. return ms_kPool.Alloc();
  49. }
  51. void CGraphicThingInstance::Delete(CGraphicThingInstance* pkThingInst)
  52. {
  53. pkThingInst->Clear();
  54. ms_kPool.Free(pkThingInst);
  55. }
  57. void CGraphicThingInstance::SetMotionAtEnd()
  58. {
  59. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), std::void_mem_fun(&CGrannyLODController::SetMotionAtEnd));
  60. }
  62. bool CGraphicThingInstance::Picking(const D3DXVECTOR3 & v, const D3DXVECTOR3 & dir, float & out_x, float & out_y)
  63. {
  64. if (!m_pHeightAttributeInstance)
  65. return false;
  66. return m_pHeightAttributeInstance->Picking(v,dir,out_x,out_y);
  67. }
  70. void CGraphicThingInstance::OnUpdateCollisionData(const CStaticCollisionDataVector * pscdVector)
  71. {
  72. assert(pscdVector);
  73. CStaticCollisionDataVector::const_iterator it;
  74. for(it = pscdVector->begin();it!=pscdVector->end();++it)
  75. {
  76. AddCollision(&(*it),&GetTransform());
  77. }
  78. }
  80. void CGraphicThingInstance::OnUpdateHeighInstance(CAttributeInstance * pAttributeInstance)
  81. {
  82. assert(pAttributeInstance);
  83. SetHeightInstance(pAttributeInstance);
  84. }
  86. bool CGraphicThingInstance::OnGetObjectHeight(float fX, float fY, float * pfHeight)
  87. {
  88. if (m_pHeightAttributeInstance && m_pHeightAttributeInstance->GetHeight(fX, fY, pfHeight))
  89. return true;
  90. return false;
  91. }
  93. void CGraphicThingInstance::BuildBoundingSphere()
  94. {
  95. D3DXVECTOR3 v3Min, v3Max;
  96. GetBoundBox(0, &v3Min, &v3Max);
  97. m_v3Center = (v3Min + v3Max) * 0.5f;
  98. D3DXVECTOR3 vDelta = (v3Max - v3Min);
  100. m_fRadius = D3DXVec3Length(&vDelta) * 0.5f + 50.0f; // extra length for attached objects
  101. }
  103. bool CGraphicThingInstance::GetBoundingSphere(D3DXVECTOR3 & v3Center, float & fRadius)
  104. {
  105. if (m_fRadius <= 0)
  106. {
  107. BuildBoundingSphere();
  109. fRadius = m_fRadius;
  110. v3Center = m_v3Center;
  111. }
  112. else
  113. {
  114. fRadius = m_fRadius;
  115. v3Center = m_v3Center;
  116. }
  118. D3DXVec3TransformCoord(&v3Center, &v3Center, &GetTransform());
  119. return true;
  120. }
  122. void CGraphicThingInstance::BuildBoundingAABB()
  123. {
  124. D3DXVECTOR3 v3Min, v3Max;
  125. GetBoundBox(0, &v3Min, &v3Max);
  126. m_v3Center = (v3Min + v3Max) * 0.5f;
  127. m_v3Min = v3Min;
  128. m_v3Max = v3Max;
  129. }
  131. bool CGraphicThingInstance::GetBoundingAABB(D3DXVECTOR3 & v3Min, D3DXVECTOR3 & v3Max)
  132. {
  133. BuildBoundingAABB();
  135. v3Min = m_v3Min;
  136. v3Max = m_v3Max;
  138. D3DXVec3TransformCoord(&m_v3Center, &m_v3Center, &GetTransform());
  139. return true;
  140. }
  142. void CGraphicThingInstance::CalculateBBox()
  143. {
  144. GetBoundBox(&m_v3BBoxMin, &m_v3BBoxMax);
  146. m_v4TBBox[0] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMin.y, m_v3BBoxMin.z, 1.0f);
  147. m_v4TBBox[1] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMax.y, m_v3BBoxMin.z, 1.0f);
  148. m_v4TBBox[2] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMin.y, m_v3BBoxMin.z, 1.0f);
  149. m_v4TBBox[3] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMax.y, m_v3BBoxMin.z, 1.0f);
  150. m_v4TBBox[4] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMin.y, m_v3BBoxMax.z, 1.0f);
  151. m_v4TBBox[5] = D3DXVECTOR4(m_v3BBoxMin.x, m_v3BBoxMax.y, m_v3BBoxMax.z, 1.0f);
  152. m_v4TBBox[6] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMin.y, m_v3BBoxMax.z, 1.0f);
  153. m_v4TBBox[7] = D3DXVECTOR4(m_v3BBoxMax.x, m_v3BBoxMax.y, m_v3BBoxMax.z, 1.0f);
  155. const D3DXMATRIX & c_rmatTransform = GetTransform();
  157. for (DWORD i = 0; i < 8; ++i)
  158. {
  159. D3DXVec4Transform(&m_v4TBBox[i], &m_v4TBBox[i], &c_rmatTransform);
  160. if (0 == i)
  161. {
  162. m_v3TBBoxMin.x = m_v4TBBox[i].x;
  163. m_v3TBBoxMin.y = m_v4TBBox[i].y;
  164. m_v3TBBoxMin.z = m_v4TBBox[i].z;
  165. m_v3TBBoxMax.x = m_v4TBBox[i].x;
  166. m_v3TBBoxMax.y = m_v4TBBox[i].y;
  167. m_v3TBBoxMax.z = m_v4TBBox[i].z;
  168. }
  169. else
  170. {
  171. if (m_v3TBBoxMin.x > m_v4TBBox[i].x)
  172. m_v3TBBoxMin.x = m_v4TBBox[i].x;
  173. if (m_v3TBBoxMax.x < m_v4TBBox[i].x)
  174. m_v3TBBoxMax.x = m_v4TBBox[i].x;
  175. if (m_v3TBBoxMin.y > m_v4TBBox[i].y)
  176. m_v3TBBoxMin.y = m_v4TBBox[i].y;
  177. if (m_v3TBBoxMax.y < m_v4TBBox[i].y)
  178. m_v3TBBoxMax.y = m_v4TBBox[i].y;
  179. if (m_v3TBBoxMin.z > m_v4TBBox[i].z)
  180. m_v3TBBoxMin.z = m_v4TBBox[i].z;
  181. if (m_v3TBBoxMax.z < m_v4TBBox[i].z)
  182. m_v3TBBoxMax.z = m_v4TBBox[i].z;
  183. }
  184. }
  185. }
  187. bool CGraphicThingInstance::CreateDeviceObjects()
  188. {
  189. CGrannyLODController::FCreateDeviceObjects createDeviceObjects;
  190. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), createDeviceObjects);
  191. return true;
  192. }
  194. void CGraphicThingInstance::DestroyDeviceObjects()
  195. {
  196. CGrannyLODController::FDestroyDeviceObjects destroyDeviceObjects;
  197. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), destroyDeviceObjects);
  198. }
  200. bool CGraphicThingInstance::CheckModelInstanceIndex(int iModelInstance)
  201. {
  202. if (iModelInstance < 0)
  203. return false;
  205. int max = m_LODControllerVector.size();
  207. if (iModelInstance >= max)
  208. return false;
  210. return true;
  211. }
  213. bool CGraphicThingInstance::CheckModelThingIndex(int iModelThing)
  214. {
  215. if (iModelThing < 0)
  216. return false;
  218. int max = m_modelThingSetVector.size();
  220. if (iModelThing >= max)
  221. return false;
  223. return true;
  224. }
  226. bool CGraphicThingInstance::CheckMotionThingIndex(DWORD dwMotionKey)
  227. {
  228. std::map<DWORD, CGraphicThing::TRef *>::iterator itor = m_roMotionThingMap.find(dwMotionKey);
  230. if (m_roMotionThingMap.end() == itor)
  231. return false;
  233. return true;
  234. }
  236. bool CGraphicThingInstance::GetMotionThingPointer(DWORD dwKey, CGraphicThing ** ppMotion)
  237. {
  238. if (!CheckMotionThingIndex(dwKey))
  239. return false;
  241. *ppMotion = m_roMotionThingMap[dwKey]->GetPointer();
  242. return true;
  243. }
  245. bool CGraphicThingInstance::IsMotionThing()
  246. {
  247. return !m_roMotionThingMap.empty();
  248. }
  250. void CGraphicThingInstance::ReserveModelInstance(int iCount)
  251. {
  252. stl_wipe(m_LODControllerVector);
  254. for (int i = 0; i < iCount; ++i)
  255. {
  256. CGrannyLODController * pInstance = new CGrannyLODController;
  257. m_LODControllerVector.push_back(pInstance);
  258. }
  259. }
  261. void CGraphicThingInstance::ReserveModelThing(int iCount)
  262. {
  263. m_modelThingSetVector.resize(iCount);
  264. }
  266. bool CGraphicThingInstance::FindBoneIndex(int iModelInstance, const char* c_szBoneName, int* iRetBone)
  267. {
  268. assert(CheckModelInstanceIndex(iModelInstance));
  270. CGrannyModelInstance * pModelInstance = m_LODControllerVector[iModelInstance]->GetModelInstance();
  272. if (!pModelInstance)
  273. return false;
  275. return pModelInstance->GetBoneIndexByName(c_szBoneName, iRetBone);
  276. }
  278. void CGraphicThingInstance::AttachModelInstance(int iDstModelInstance, const char * c_szBoneName, int iSrcModelInstance)
  279. {
  280. if (!CheckModelInstanceIndex(iSrcModelInstance))
  281. {
  282. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  283. return;
  284. }
  285. if (!CheckModelInstanceIndex(iDstModelInstance))
  286. {
  287. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  288. return;
  289. }
  291. CGrannyLODController * pSrcLODController = m_LODControllerVector[iSrcModelInstance];
  292. CGrannyLODController * pDstLODController = m_LODControllerVector[iDstModelInstance];
  293. pDstLODController->AttachModelInstance(pSrcLODController, c_szBoneName);
  294. }
  296. void CGraphicThingInstance::AttachModelInstance(int iDstModelInstance, const char * c_szBoneName, CGraphicThingInstance & rSrcInstance, int iSrcModelInstance)
  297. {
  298. if (!CheckModelInstanceIndex(iDstModelInstance))
  299. {
  300. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  301. return;
  302. }
  303. if (!rSrcInstance.CheckModelInstanceIndex(iSrcModelInstance))
  304. {
  305. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, c_szBoneName=%s, iSrcModelInstance=%d)", iDstModelInstance, c_szBoneName, iSrcModelInstance);
  306. return;
  307. }
  309. CGrannyLODController * pDstLODController = m_LODControllerVector[iDstModelInstance];
  310. CGrannyLODController * pSrcLODController = rSrcInstance.m_LODControllerVector[iSrcModelInstance];
  311. pDstLODController->AttachModelInstance(pSrcLODController, c_szBoneName);
  312. }
  314. void CGraphicThingInstance::DetachModelInstance(int iDstModelInstance, CGraphicThingInstance & rSrcInstance, int iSrcModelInstance)
  315. {
  316. if (!CheckModelInstanceIndex(iDstModelInstance))
  317. {
  318. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, iSrcModelInstance=%d)", iDstModelInstance, iSrcModelInstance);
  319. return;
  320. }
  321. if (!rSrcInstance.CheckModelInstanceIndex(iSrcModelInstance))
  322. {
  323. TraceError("CGraphicThingInstance::AttachModelInstance(iDstModelInstance=%d, iSrcModelInstance=%d)", iDstModelInstance, iSrcModelInstance);
  324. return;
  325. }
  327. CGrannyLODController * pDstLODController = m_LODControllerVector[iDstModelInstance];
  328. CGrannyLODController * pSrcLODController = rSrcInstance.m_LODControllerVector[iSrcModelInstance];
  329. pDstLODController->DetachModelInstance(pSrcLODController);
  330. }
  332. bool CGraphicThingInstance::GetBonePosition(int iModelIndex, int iBoneIndex, float * pfx, float * pfy, float * pfz)
  333. {
  334. assert(CheckModelInstanceIndex(iModelIndex));
  336. CGrannyModelInstance * pModelInstance = m_LODControllerVector[iModelIndex]->GetModelInstance();
  338. if (!pModelInstance)
  339. return false;
  341. const float * pfMatrix = pModelInstance->GetBoneMatrixPointer(iBoneIndex);
  343. *pfx = pfMatrix[12];
  344. *pfy = pfMatrix[13];
  345. *pfz = pfMatrix[14];
  346. return true;
  347. }
  348. //iSkelInstance 가 있으면 기본 본에 Link(본이 붙는것)시키고,
  349. //없으면 기본 본에 attach(좌표만 가져다 쓰는것) 됩니다.
  350. bool CGraphicThingInstance::SetModelInstance(int iDstModelInstance, int iSrcModelThing, int iSrcModel,int iSkelInstance)
  351. {
  352. if (!CheckModelInstanceIndex(iDstModelInstance))
  353. {
  354. TraceError("CGraphicThingInstance::SetModelInstance(iDstModelInstance=%d, pModelThing=%d, iSrcModel=%d)\n", iDstModelInstance, iSrcModelThing, iSrcModel);
  355. return false;
  356. }
  357. if (!CheckModelThingIndex(iSrcModelThing))
  358. {
  359. TraceError("CGraphicThingInstance::SetModelInstance(iDstModelInstance=%d, pModelThing=%d, iSrcModel=%d)\n", iDstModelInstance, iSrcModelThing, iSrcModel);
  360. return false;
  361. }
  363. CGrannyLODController * pController = m_LODControllerVector[iDstModelInstance];
  364. if (!pController)
  365. return false;
  367. // HAIR_LINK
  368. CGrannyLODController * pSkelController = NULL;
  369. if (iSkelInstance != DONTUSEVALUE)
  370. {
  371. if (!CheckModelInstanceIndex(iSkelInstance))
  372. {
  373. TraceError("CGraphicThingInstance::SetModelInstanceByOtherSkeletonInstance(iSkelInstance=%d, iDstModelInstance=%d, pModelThing=%d, iSrcModel=%d)\n", iSkelInstance, iDstModelInstance, iSrcModelThing, iSrcModel);
  374. return false;
  375. }
  376. pSkelController = m_LODControllerVector[iSkelInstance];
  377. if (!pSkelController)
  378. return false;
  379. }
  380. // END_OF_HAIR_LINK
  382. TModelThingSet & rModelThingSet = m_modelThingSetVector[iSrcModelThing];
  384. pController->Clear();
  387. for (DWORD i = 0; i < rModelThingSet.m_pLODThingRefVector.size(); ++i)
  388. {
  389. if (rModelThingSet.m_pLODThingRefVector[i]->IsNull())
  390. return false;
  392. pController->AddModel(rModelThingSet.m_pLODThingRefVector[i]->GetPointer(), iSrcModel, pSkelController);
  393. }
  394. return true;
  395. }
  397. void CGraphicThingInstance::SetMaterialImagePointer(UINT ePart, const char* c_szImageName, CGraphicImage* pImage)
  398. {
  399. if (ePart>=m_LODControllerVector.size())
  400. {
  401. TraceError("CGraphicThingInstance::SetMaterialImagePointer(ePart(%d)<uPartCount(%d), c_szImageName=%s, pImage=%s) - ePart OUT OF RANGE",
  402. ePart, m_LODControllerVector.size(), c_szImageName, pImage->GetFileName());
  404. return;
  405. }
  407. if (!m_LODControllerVector[ePart])
  408. {
  409. TraceError("CGraphicThingInstance::SetMaterialImagePointer(ePart(%d), c_szImageName=%s, pImage=%s) - ePart Data is NULL",
  410. ePart, m_LODControllerVector.size(), c_szImageName, pImage->GetFileName());
  412. return;
  413. }
  415. m_LODControllerVector[ePart]->SetMaterialImagePointer(c_szImageName, pImage);
  416. }
  418. void CGraphicThingInstance::SetMaterialData(UINT ePart, const char* c_szImageName, SMaterialData kMaterialData)
  419. {
  420. if (ePart>=m_LODControllerVector.size())
  421. {
  422. TraceError("CGraphicThingInstance::SetMaterialData(ePart(%d)<uPartCount(%d)) - ePart OUT OF RANGE",
  423. ePart, m_LODControllerVector.size());
  425. return;
  426. }
  428. if (!m_LODControllerVector[ePart])
  429. {
  430. TraceError("CGraphicThingInstance::SetMaterialData(ePart(%d)) - ePart Data is NULL",
  431. ePart, m_LODControllerVector.size());
  433. return;
  434. }
  436. m_LODControllerVector[ePart]->SetMaterialData(c_szImageName, kMaterialData);
  437. }
  439. void CGraphicThingInstance::SetSpecularInfo(UINT ePart, const char* c_szMtrlName, BOOL bEnable, float fPower)
  440. {
  441. if (ePart>=m_LODControllerVector.size())
  442. {
  443. TraceError("CGraphicThingInstance::SetSpecularInfo(ePart(%d)<uPartCount(%d)) - ePart OUT OF RANGE",
  444. ePart, m_LODControllerVector.size());
  446. return;
  447. }
  449. if (!m_LODControllerVector[ePart])
  450. {
  451. TraceError("CGraphicThingInstance::SetSpecularInfo(ePart(%d)) - ePart Data is NULL",
  452. ePart, m_LODControllerVector.size());
  454. return;
  455. }
  457. m_LODControllerVector[ePart]->SetSpecularInfo(c_szMtrlName, bEnable, fPower);
  458. }
  460. bool CGraphicThingInstance::SetMotion(DWORD dwMotionKey, float blendTime, int loopCount, float speedRatio)
  461. {
  462. if (!CheckMotionThingIndex(dwMotionKey))
  463. return false;
  465. std::map<DWORD, CGraphicThing::TRef *>::iterator itor = m_roMotionThingMap.find(dwMotionKey);
  466. CGraphicThing::TRef * proMotionThing = itor->second;
  467. CGraphicThing * pMotionThing = proMotionThing->GetPointer();
  469. if (!pMotionThing)
  470. return false;
  472. if (!pMotionThing->CheckMotionIndex(0))
  473. return false;
  475. CGrannyLODController::FSetMotionPointer SetMotionPointer;
  476. SetMotionPointer.m_pMotion = pMotionThing->GetMotionPointer(0);
  477. SetMotionPointer.m_blendTime = blendTime;
  478. SetMotionPointer.m_loopCount = loopCount;
  479. SetMotionPointer.m_speedRatio = speedRatio;
  481. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), SetMotionPointer);
  482. return true;
  483. }
  485. bool CGraphicThingInstance::ChangeMotion(DWORD dwMotionKey, int loopCount, float speedRatio)
  486. {
  487. if (!CheckMotionThingIndex(dwMotionKey))
  488. return false;
  490. std::map<DWORD, CGraphicThing::TRef *>::iterator itor = m_roMotionThingMap.find(dwMotionKey);
  491. CGraphicThing::TRef * proMotionThing = itor->second;
  492. CGraphicThing * pMotionThing = proMotionThing->GetPointer();
  494. if (!pMotionThing)
  495. return false;
  497. if (!pMotionThing->CheckMotionIndex(0))
  498. return false;
  500. CGrannyLODController::FChangeMotionPointer ChangeMotionPointer;
  501. ChangeMotionPointer.m_pMotion = pMotionThing->GetMotionPointer(0);
  502. ChangeMotionPointer.m_loopCount = loopCount;
  503. ChangeMotionPointer.m_speedRatio = speedRatio;
  505. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), ChangeMotionPointer);
  506. return true;
  507. }
  509. void CGraphicThingInstance::SetEndStopMotion()
  510. {
  511. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), CGrannyLODController::FEndStopMotionPointer());
  512. }
  514. void CGraphicThingInstance::RegisterModelThing(int iModelThing, CGraphicThing * pModelThing)
  515. {
  516. if (!CheckModelThingIndex(iModelThing))
  517. {
  518. TraceError("CGraphicThingInstance::RegisterModelThing(iModelThing=%d, pModelThing=%s)\n", iModelThing, pModelThing->GetFileName());
  519. return;
  520. }
  522. m_modelThingSetVector[iModelThing].Clear();
  524. if (pModelThing)
  525. RegisterLODThing(iModelThing, pModelThing);
  526. }
  528. void CGraphicThingInstance::RegisterLODThing(int iModelThing, CGraphicThing * pModelThing)
  529. {
  530. assert(CheckModelThingIndex(iModelThing));
  531. CGraphicThing::TRef * pModelRef = new CGraphicThing::TRef;
  532. pModelRef->SetPointer(pModelThing);
  533. m_modelThingSetVector[iModelThing].m_pLODThingRefVector.push_back(pModelRef);
  534. }
  536. void CGraphicThingInstance::RegisterMotionThing(DWORD dwMotionKey, CGraphicThing* pMotionThing)
  537. {
  538. CGraphicThing::TRef * pMotionRef = new CGraphicThing::TRef;
  539. pMotionRef->SetPointer(pMotionThing);
  540. m_roMotionThingMap.insert(std::map<DWORD, CGraphicThing::TRef *>::value_type(dwMotionKey, pMotionRef));
  541. }
  543. void CGraphicThingInstance::ResetLocalTime()
  544. {
  545. //m_clockLast = GrannyGetSystemSeconds();
  546. m_fLastLocalTime = 0.0f;
  547. m_fLocalTime = 0.0f;
  549. CGrannyLODController::FResetLocalTime resetLocalTime;
  550. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), resetLocalTime);
  551. }
  553. /*
  554. void CGraphicThingInstance::SetMotionSpeed(float fRate)
  555. {
  556. m_fMotionTimeSpeed = fRate;
  557. }
  558. */
  559. void CGraphicThingInstance::InsertDelay(float fDelay)
  560. {
  561. m_fDelay = fDelay;
  562. }
  564. float CGraphicThingInstance::GetLastLocalTime()
  565. {
  566. return m_fLastLocalTime;
  567. }
  569. float CGraphicThingInstance::GetLocalTime()
  570. {
  571. return m_fLocalTime;
  572. }
  574. float CGraphicThingInstance::GetSecondElapsed()
  575. {
  576. return m_fSecondElapsed;
  577. }
  579. float CGraphicThingInstance::GetAverageSecondElapsed()
  580. {
  581. return m_fAverageSecondElapsed;
  582. }
  584. bool CGraphicThingInstance::Intersect(float* pu, float* pv, float* pt)
  585. {
  586. if (!CGraphicObjectInstance::isShow())
  587. return false;
  588. if (!m_bUpdated)
  589. return false;
  591. if (m_LODControllerVector.empty())
  592. {
  593. //TraceError("CGraphicThingInstance::Intersect - m_LODControllerVector is empty");
  594. return false;
  595. }
  597. return m_LODControllerVector[0]->Intersect(&GetTransform(), pu, pv, pt);
  598. }
  600. void CGraphicThingInstance::GetBoundBox(D3DXVECTOR3* vtMin, D3DXVECTOR3* vtMax)
  601. {
  602. vtMin->x = vtMin->y = vtMin->z = 100000.0f;
  603. vtMax->x = vtMax->y = vtMax->z = -100000.0f;
  604. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), CGrannyLODController::FBoundBox(vtMin, vtMax));
  605. }
  607. BOOL CGraphicThingInstance::GetBoundBox(DWORD dwModelInstanceIndex, D3DXVECTOR3 * vtMin, D3DXVECTOR3 * vtMax)
  608. {
  609. if (!CheckModelInstanceIndex(dwModelInstanceIndex))
  610. return FALSE;
  612. vtMin->x = vtMin->y = vtMin->z = 100000.0f;
  613. vtMax->x = vtMax->y = vtMax->z = -100000.0f;
  615. CGrannyLODController * pController = m_LODControllerVector[dwModelInstanceIndex];
  616. if (!pController->isModelInstance())
  617. return FALSE;
  619. CGrannyModelInstance * pModelInstance = pController->GetModelInstance();
  620. pModelInstance->GetBoundBox(vtMin, vtMax);
  621. return TRUE;
  622. }
  624. BOOL CGraphicThingInstance::GetBoneMatrix(DWORD dwModelInstanceIndex, DWORD dwBoneIndex, D3DXMATRIX ** ppMatrix)
  625. {
  626. if (!CheckModelInstanceIndex(dwModelInstanceIndex))
  627. return FALSE;
  629. CGrannyModelInstance * pModelInstance = m_LODControllerVector[dwModelInstanceIndex]->GetModelInstance();
  630. if (!pModelInstance)
  631. return FALSE;
  633. *ppMatrix = (D3DXMATRIX *)pModelInstance->GetBoneMatrixPointer(dwBoneIndex);
  634. if (!*ppMatrix)
  635. return FALSE;
  637. return TRUE;
  638. }
  640. BOOL CGraphicThingInstance::GetCompositeBoneMatrix(DWORD dwModelInstanceIndex, DWORD dwBoneIndex, D3DXMATRIX ** ppMatrix)
  641. {
  642. if (!CheckModelInstanceIndex(dwModelInstanceIndex))
  643. return FALSE;
  645. CGrannyModelInstance * pModelInstance = m_LODControllerVector[dwModelInstanceIndex]->GetModelInstance();
  646. if (!pModelInstance)
  647. {
  648. //TraceError("CGraphicThingInstance::GetCompositeBoneMatrix(dwModelInstanceIndex=%d, dwBoneIndex=%d, D3DXMATRIX ** ppMatrix)", dwModelInstanceIndex, dwBoneIndex);
  649. return FALSE;
  650. }
  652. *ppMatrix = (D3DXMATRIX *)pModelInstance->GetCompositeBoneMatrixPointer(dwBoneIndex);
  654. return TRUE;
  655. }
  657. void CGraphicThingInstance::UpdateTransform(D3DXMATRIX * pMatrix, float fSecondsElapsed, int iModelInstanceIndex)
  658. {
  659. //TraceError("%s",GetBaseThingPtr()->GetFileName());
  660. int nLODCount=m_LODControllerVector.size();
  661. if (iModelInstanceIndex>=nLODCount)
  662. {
  663. //TraceError("void CGraphicThingInstance::UpdateTransform(pMatrix, fSecondsElapsed=%f, iModelInstanceIndex=%d/nLODCount=%d)",
  664. // fSecondsElapsed, iModelInstanceIndex, nLODCount);
  665. return;
  666. }
  668. CGrannyLODController* pkLODCtrl=m_LODControllerVector[iModelInstanceIndex];
  669. if (!pkLODCtrl)
  670. {
  671. //TraceError("void CGraphicThingInstance::UpdateTransform(pMatrix, fSecondsElapsed=%f, iModelInstanceIndex=%d/nLODCount=%d) - m_LODControllerVector[iModelInstanceIndex] == NULL",
  672. // fSecondsElapsed, iModelInstanceIndex, nLODCount);
  673. return;
  674. }
  676. CGrannyModelInstance * pModelInstance = pkLODCtrl->GetModelInstance();
  677. if (!pModelInstance)
  678. {
  679. /* TraceError("void CGraphicThingInstance::UpdateTransform(pMatrix, fSecondsElapsed=%f, iModelInstanceIndex=%d/nLODCount=%d) - pkLODCtrl->GetModelInstance() == NULL",
  680. fSecondsElapsed, iModelInstanceIndex, nLODCount);*/
  681. return;
  682. }
  684. pModelInstance->UpdateTransform(pMatrix, fSecondsElapsed);
  685. }
  687. void CGraphicThingInstance::DeformAll()
  688. {
  689. m_bUpdated = true;
  691. CGrannyLODController::FDeformAll deform;
  692. deform.mc_pWorldMatrix = &m_worldMatrix;
  693. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), deform);
  694. }
  696. void CGraphicThingInstance::DeformNoSkin()
  697. {
  698. m_bUpdated = true;
  700. for (std::vector<CGrannyLODController*>::size_type iMod = 0; iMod != m_LODControllerVector.size(); iMod++)
  701. {
  702. CGrannyLODController * pkLOD = m_LODControllerVector[iMod];
  703. if (!pkLOD->isModelInstance())
  704. continue;
  706. #ifdef ENABLE_OBJ_SCALLING
  707. if (m_modelThingSetVector.size() == 1)
  708. pkLOD->DeformNoSkin(&m_TransformMatrix);
  709. #ifdef ENABLE_ACCE_COSTUME_SYSTEM
  710. else if (iMod == 5) /* CRaceData::PART_ACCE */
  711. pkLOD->DeformNoSkin(&m_TransformMatrix);
  712. #endif
  713. else
  714. #endif
  715. pkLOD->DeformNoSkin(&m_worldMatrix);
  716. }
  717. }
  719. void CGraphicThingInstance::OnDeform()
  720. {
  721. m_bUpdated = true;
  723. for (std::vector<CGrannyLODController*>::size_type iMod = 0; iMod != m_LODControllerVector.size(); iMod++)
  724. {
  725. CGrannyLODController * pkLOD = m_LODControllerVector[iMod];
  726. if (!pkLOD->isModelInstance())
  727. continue;
  729. #ifdef ENABLE_OBJ_SCALLING
  730. #ifdef ENABLE_NEW_OBJ_SCALLING
  731. if (m_modelThingSetVector.size() == 1)
  732. pkLOD->Deform(&m_TransformMatrix);
  733. #else
  734. if (m_modelThingSetVector.size() == 1)
  735. pkLOD->Deform(&m_TransformMatrix);
  736. #endif
  737. #ifdef ENABLE_ACCE_COSTUME_SYSTEM
  738. else if (iMod == 5) /* CRaceData::PART_ACCE */
  739. pkLOD->Deform(&m_TransformMatrix);
  740. #endif
  741. else
  742. #endif
  743. pkLOD->Deform(&m_worldMatrix);
  744. }
  745. }
  747. void CGraphicThingInstance::__SetLocalTime(float fLocalTime)
  748. {
  749. m_fLastLocalTime = m_fLocalTime;
  750. m_fLocalTime = fLocalTime;
  752. CGrannyLODController::FSetLocalTime SetLocalTime;
  753. SetLocalTime.fLocalTime = fLocalTime;
  754. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), SetLocalTime);
  755. }
  757. void CGraphicThingInstance::UpdateLODLevel()
  758. {
  759. CCamera * pcurCamera = CCameraManager::Instance().GetCurrentCamera();
  760. if (!pcurCamera)
  761. {
  762. TraceError("CGraphicThingInstance::UpdateLODLevel - GetCurrentCamera() == NULL");
  763. return;
  764. }
  766. const D3DXVECTOR3 & c_rv3TargetPosition = pcurCamera->GetTarget();
  767. const D3DXVECTOR3 & c_rv3CameraPosition = pcurCamera->GetEye();
  768. const D3DXVECTOR3 & c_v3Position = GetPosition();
  770. // NOTE : 중심으로부터의 거리 계산에 z값 차이는 사용하지 않는다. - [levites]
  771. CGrannyLODController::FUpdateLODLevel update;
  772. update.fDistanceFromCenter = sqrtf((c_rv3TargetPosition.x - c_v3Position.x) * (c_rv3TargetPosition.x - c_v3Position.x) +
  773. (c_rv3TargetPosition.y - c_v3Position.y) * (c_rv3TargetPosition.y - c_v3Position.y));
  774. update.fDistanceFromCamera = sqrtf((c_rv3CameraPosition.x - c_v3Position.x) * (c_rv3CameraPosition.x - c_v3Position.x) +
  775. (c_rv3CameraPosition.y - c_v3Position.y) * (c_rv3CameraPosition.y - c_v3Position.y) +
  776. (c_rv3CameraPosition.z - c_v3Position.z) * (c_rv3CameraPosition.z - c_v3Position.z));
  778. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), update);
  779. }
  781. void CGraphicThingInstance::UpdateTime()
  782. {
  783. //granny_system_clock clockNow = GrannyGetSystemSeconds();
  784. //m_fSecondElapsed = GrannyGetSecondsElapsed(&m_clockLast, &clockNow) * m_fMotionTimeSpeed;
  786. //DWORD t1=ELTimer_GetMSec();
  788. m_fSecondElapsed=CTimer::Instance().GetElapsedSecond();
  790. if (m_fDelay > m_fSecondElapsed)
  791. {
  792. m_fDelay -= m_fSecondElapsed;
  793. m_fSecondElapsed = 0.0f;
  794. }
  795. else
  796. {
  797. m_fSecondElapsed -= m_fDelay;
  798. m_fDelay = 0.0f;
  799. }
  801. m_fLastLocalTime = m_fLocalTime;
  802. m_fLocalTime += m_fSecondElapsed;
  803. m_fAverageSecondElapsed = m_fAverageSecondElapsed + (m_fSecondElapsed - m_fAverageSecondElapsed) / 4.0f;
  804. //m_clockLast = clockNow;
  806. CGrannyLODController::FUpdateTime update;
  807. update.fElapsedTime = m_fSecondElapsed;
  808. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), update);
  809. }
  811. void CGraphicThingInstance::OnUpdate()
  812. {
  813. #ifdef __PERFORMANCE_CHECKER__
  814. DWORD t1=timeGetTime();
  815. #endif
  816. UpdateLODLevel();
  817. #ifdef __PERFORMANCE_CHECKER__
  818. DWORD t2=timeGetTime();
  819. #endif
  820. UpdateTime();
  821. #ifdef __PERFORMANCE_CHECKER__
  822. DWORD t3=timeGetTime();
  823. #endif
  825. #ifdef __PERFORMANCE_CHECKER__
  826. {
  827. static FILE* fp=fopen("perf_thing_onupdate.txt", "w");
  829. if (t3-t1>3)
  830. {
  831. fprintf(fp, "GTU.Total %d (Time %f)\n",
  832. t3-t1, ELTimer_GetMSec()/1000.0f);
  833. fprintf(fp, "GTU.CAL %d\n", t2-t1);
  834. fprintf(fp, "GTU.UP %d\n", t3-t2);
  835. fprintf(fp, "-------------------------------- \n");
  836. fflush(fp);
  837. }
  838. fflush(fp);
  839. }
  840. #endif
  841. }
  843. void CGraphicThingInstance::OnRender()
  844. {
  845. RenderWithOneTexture();
  846. }
  848. void CGraphicThingInstance::OnBlendRender()
  849. {
  850. BlendRenderWithOneTexture();
  851. }
  853. void CGraphicThingInstance::RenderWithOneTexture()
  854. {
  855. //assert(m_bUpdated);
  856. if (!m_bUpdated)
  857. return;
  859. CGrannyLODController::FRenderWithOneTexture render;
  860. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), render);
  861. }
  863. void CGraphicThingInstance::BlendRenderWithOneTexture()
  864. {
  865. //assert(m_bUpdated);
  866. if (!m_bUpdated)
  867. return;
  869. CGrannyLODController::FBlendRenderWithOneTexture blendRender;
  870. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), blendRender);
  871. }
  873. void CGraphicThingInstance::RenderWithTwoTexture()
  874. {
  875. //assert(m_bUpdated);
  876. if (!m_bUpdated)
  877. return;
  879. CGrannyLODController::FRenderWithTwoTexture render;
  880. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), render);
  881. }
  883. void CGraphicThingInstance::BlendRenderWithTwoTexture()
  884. {
  885. //assert(m_bUpdated);
  886. if (!m_bUpdated)
  887. return;
  889. CGrannyLODController::FRenderWithTwoTexture blendRender;
  890. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), blendRender);
  891. }
  893. void CGraphicThingInstance::OnRenderToShadowMap()
  894. {
  895. if (!m_bUpdated)
  896. return;
  898. CGrannyLODController::FRenderToShadowMap RenderToShadowMap;
  899. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), RenderToShadowMap);
  900. }
  902. void CGraphicThingInstance::OnRenderShadow()
  903. {
  904. CGrannyLODController::FRenderShadow RenderShadow;
  905. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), RenderShadow);
  906. }
  908. void CGraphicThingInstance::OnRenderPCBlocker()
  909. {
  910. CGrannyLODController::FRenderWithOneTexture RenderPCBlocker;
  911. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), RenderPCBlocker);
  912. }
  914. DWORD CGraphicThingInstance::GetLODControllerCount() const
  915. {
  916. return m_LODControllerVector.size();
  917. }
  919. CGrannyLODController * CGraphicThingInstance::GetLODControllerPointer(DWORD dwModelIndex) const
  920. {
  921. assert(dwModelIndex < m_LODControllerVector.size());
  922. return m_LODControllerVector[dwModelIndex];
  923. }
  925. CGrannyLODController * CGraphicThingInstance::GetLODControllerPointer(DWORD dwModelIndex)
  926. {
  927. assert(dwModelIndex < m_LODControllerVector.size());
  928. return m_LODControllerVector[dwModelIndex];
  929. }
  931. BYTE CGraphicThingInstance::GetLODLevel(DWORD dwModelInstance)
  932. {
  933. assert(dwModelInstance < m_LODControllerVector.size());
  934. return (m_LODControllerVector[dwModelInstance]->GetLODLevel());
  935. }
  937. float CGraphicThingInstance::GetHeight()
  938. {
  939. if (m_LODControllerVector.empty())
  940. return 0.0f;
  942. CGrannyModelInstance * pModelInstance = m_LODControllerVector[0]->GetModelInstance();
  943. if (!pModelInstance)
  944. return 0.0f;
  946. D3DXVECTOR3 vtMin, vtMax;
  947. pModelInstance->GetBoundBox(&vtMin, &vtMax);
  949. return fabs(vtMin.z - vtMax.z);
  950. }
  952. void CGraphicThingInstance::ReloadTexture()
  953. {
  954. CGrannyLODController::FReloadTexture ReloadTexture;
  955. std::for_each(m_LODControllerVector.begin(), m_LODControllerVector.end(), ReloadTexture);
  956. }
  958. bool CGraphicThingInstance::HaveBlendThing()
  959. {
  960. for (int i = 0; i < m_LODControllerVector.size(); i++)
  961. {
  962. if (m_LODControllerVector[i]->HaveBlendThing())
  963. return true;
  964. }
  965. return false;
  966. }
  969. void CGraphicThingInstance::OnClear()
  970. {
  971. stl_wipe(m_LODControllerVector);
  972. stl_wipe_second(m_roMotionThingMap);
  974. for (DWORD d = 0; d < m_modelThingSetVector.size(); ++d)
  975. m_modelThingSetVector[d].Clear();
  976. }
  978. void CGraphicThingInstance::OnInitialize()
  979. {
  980. m_bUpdated = false;
  981. m_fLastLocalTime = 0.0f;
  982. m_fLocalTime = 0.0f;
  983. m_fDelay = 0.0;
  984. m_fSecondElapsed = 0.0f;
  985. m_fAverageSecondElapsed = 0.03f;
  986. m_fRadius = -1.0f;
  987. m_v3Center = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
  989. ResetLocalTime();
  990. }
  992. CGraphicThingInstance::CGraphicThingInstance()
  993. {
  994. Initialize();
  995. }
  997. CGraphicThingInstance::~CGraphicThingInstance()
  998. {
  999. }