开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
AnimWobble.cpp
资源名称：gloop.zip　[点击查看]
上传用户：shxiangxiu
上传日期：2007-01-03
资源大小：1101k
文件大小：9k
源码类别：

OpenGL

开发平台：

Visual C++

AnimWobble.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // AnimWobble.cpp : implementation file
  3. //
  4. // glOOP (OpenGL Object Oriented Programming library)
  5. // Copyright (c) Craig Fahrnbach 1997, 1998
  6. //
  7. // OpenGL is a registered trademark of Silicon Graphics
  8. //
  9. //
  10. // This program is provided for educational and personal use only and
  11. // is provided without guarantee or warrantee expressed or implied.
  12. //
  13. // Commercial use is strickly prohibited without written permission
  14. // from ImageWare Development.
  15. //
  16. // This program is -not- in the public domain.
  17. //
  18. /////////////////////////////////////////////////////////////////////////////
  20. #include "stdafx.h"
  21. #include "glOOP.h"
  22. #include "AnimationDialog.h"
  25. #ifdef _DEBUG
  26. #define new DEBUG_NEW
  27. #undef THIS_FILE
  28. static char THIS_FILE[] = __FILE__;
  29. #endif
  33. /////////////////////////////////////////////////////////////////////////////
  34. // CAnimWobble
  36. IMPLEMENT_DYNAMIC(CAnimWobble, CAnimation)
  39. /////////////////////////////////////////////////////////////////////////////
  40. // CAnimWobble construction
  42. CAnimWobble::CAnimWobble()
  43. {
  44. // Set the attributes to default values..
  45. m_szName = SZ_ANIMATE_WOBBLE;
  47. m_bFirst = TRUE;
  49. m_fWobbleX = 2.0f;
  50. m_fWobbleY = 2.0f;
  51. m_fWobbleZ = 2.0f;
  53. m_fLimitX = 45.0f;
  54. m_fLimitY = 45.0f;
  55. m_fLimitZ = 45.0f;
  57. m_dSpeedX = 0.0f;
  58. m_dSpeedY = 0.0f;
  59. m_dSpeedZ = 0.0f;
  61. m_bIncX = TRUE;
  62. m_bIncY = TRUE;
  63. m_bIncZ = TRUE;
  64. }
  66. /////////////////////////////////////////////////////////////////////////////
  67. // CAnimWobble Destructor
  69. CAnimWobble::~CAnimWobble()
  70. {
  71. }
  74. /////////////////////////////////////////////////////////////////////////////
  75. // CAnimWobble Methods or virtual function implimentation
  77. void CAnimWobble::AddAnimationPage(LPVOID pSht, C3dObject* pObject, C3dCamera* pCamera, C3dWorld* pWorld)
  78. {
  79. CAnimPropSheet* pSheet = (CAnimPropSheet*)pSht;
  80. ASSERT(pSheet);
  82. // Add the page to the property sheet
  83. pSheet->AddPage(&pSheet->m_WobblePage);
  85. // Save the address of this animation procedure in the page
  86. pSheet->m_WobblePage.m_pAnimation = this;
  87. }
  89. void CAnimWobble::AnimateCamera(C3dCamera* pCamera, double dTime)
  90. {
  91. GLfloat fXIncrement; // Rotation incremental values
  92. GLfloat fYIncrement;
  93. GLfloat fZIncrement;
  95. // Ensure that we have a vaild pointer..
  96. if(!pCamera)
  97. return;
  99. // First pass through, just save the objects original
  100. // parameters
  101. if(m_bFirst)
  102. {
  103. m_bFirst = FALSE;
  104. SaveCameraAttributes(pCamera);
  106. return;
  107. }
  109. // Calculate the incremental index values
  110. if(m_dSpeedX)
  111. fXIncrement = (GLfloat)(m_fWobbleX/(m_dSpeedX/(dTime-m_dTimePrevious)));
  112. else
  113. fXIncrement = m_fWobbleX;
  115. if(m_dSpeedY)
  116. fYIncrement = (GLfloat)(m_fWobbleY/(m_dSpeedY/(dTime-m_dTimePrevious)));
  117. else
  118. fYIncrement = m_fWobbleY;
  120. if(m_dSpeedZ)
  121. fZIncrement = (GLfloat)(m_fWobbleZ/(m_dSpeedZ/(dTime-m_dTimePrevious)));
  122. else
  123. fZIncrement = m_fWobbleZ;
  126. // Wobble the shape
  127. if(m_fWobbleX)
  128. {
  129. if(m_bIncX)
  130. {
  131. pCamera->m_fRotation[X] += fXIncrement;
  132. if(pCamera->m_fRotation[X] > (m_fRotation[X]+m_fLimitX))
  133. {
  134. pCamera->m_fRotation[X] -= fXIncrement;
  135. m_bIncX = FALSE;
  136. }
  137. }
  138. else
  139. {
  140. pCamera->m_fRotation[X] -= fXIncrement;
  141. if(pCamera->m_fRotation[X] < (m_fRotation[X]-m_fLimitX))
  142. {
  143. pCamera->m_fRotation[X] += fXIncrement;
  144. m_bIncX = TRUE;
  145. }
  146. }
  147. }
  149. if(m_fWobbleY)
  150. {
  151. if(m_bIncY)
  152. {
  153. pCamera->m_fRotation[Y] += fYIncrement;
  154. if(pCamera->m_fRotation[Y] > (m_fRotation[Y]+m_fLimitY))
  155. {
  156. pCamera->m_fRotation[Y] -= fYIncrement;
  157. m_bIncY = FALSE;
  158. }
  159. }
  160. else
  161. {
  162. pCamera->m_fRotation[Y] -= fYIncrement;
  163. if(pCamera->m_fRotation[Y] < (m_fRotation[Y]-m_fLimitY))
  164. {
  165. pCamera->m_fRotation[Y] += fYIncrement;
  166. m_bIncY = TRUE;
  167. }
  168. }
  169. }
  171. if(m_fWobbleZ)
  172. {
  173. if(m_bIncZ)
  174. {
  175. pCamera->m_fRotation[Z] += fZIncrement;
  176. if(pCamera->m_fRotation[Z] > (m_fRotation[Z]+m_fLimitZ))
  177. {
  178. pCamera->m_fRotation[Z] -= fZIncrement;
  179. m_bIncZ = FALSE;
  180. }
  181. }
  182. else
  183. {
  184. pCamera->m_fRotation[Z] -= fZIncrement;
  185. if(pCamera->m_fRotation[Z] < (m_fRotation[Z]-m_fLimitZ))
  186. {
  187. pCamera->m_fRotation[Z] += fZIncrement;
  188. m_bIncZ = TRUE;
  189. }
  190. }
  191. }
  193. // Save the time of the last iteration
  194. m_dTimePrevious = dTime;
  195. }
  197. void CAnimWobble::AnimateObject(C3dObject* pObject, double dTime)
  198. {
  199. GLfloat fXIncrement; // Rotation incremental values
  200. GLfloat fYIncrement;
  201. GLfloat fZIncrement;
  203. // Ensure that we have a vaild pointer..
  204. if(!pObject)
  205. return;
  207. // First pass through, just save the objects original
  208. // parameters
  209. if(m_bFirst)
  210. {
  211. m_bFirst = FALSE;
  212. SaveObjectAttributes(pObject);
  214. return;
  215. }
  218. // Calculate the incremental index values
  219. if(m_dSpeedX)
  220. fXIncrement = (GLfloat)(m_fWobbleX/(m_dSpeedX/(dTime-m_dTimePrevious)));
  221. else
  222. fXIncrement = m_fWobbleX;
  224. if(m_dSpeedY)
  225. fYIncrement = (GLfloat)(m_fWobbleY/(m_dSpeedY/(dTime-m_dTimePrevious)));
  226. else
  227. fYIncrement = m_fWobbleY;
  229. if(m_dSpeedZ)
  230. fZIncrement = (GLfloat)(m_fWobbleZ/(m_dSpeedZ/(dTime-m_dTimePrevious)));
  231. else
  232. fZIncrement = m_fWobbleZ;
  235. // Wobble the shape
  236. if(m_fWobbleX)
  237. {
  238. if(m_bIncX)
  239. {
  240. pObject->m_fRotation[X] += fXIncrement;
  241. if(pObject->m_fRotation[X] > (m_fRotation[X]+m_fLimitX))
  242. {
  243. pObject->m_fRotation[X] -= fXIncrement;
  244. m_bIncX = FALSE;
  245. }
  246. }
  247. else
  248. {
  249. pObject->m_fRotation[X] -= fXIncrement;
  250. if(pObject->m_fRotation[X] < (m_fRotation[X]-m_fLimitX))
  251. {
  252. pObject->m_fRotation[X] += fXIncrement;
  253. m_bIncX = TRUE;
  254. }
  255. }
  256. }
  258. if(m_fWobbleY)
  259. {
  260. if(m_bIncY)
  261. {
  262. pObject->m_fRotation[Y] += fYIncrement;
  263. if(pObject->m_fRotation[Y] > (m_fRotation[Y]+m_fLimitY))
  264. {
  265. pObject->m_fRotation[Y] -= fYIncrement;
  266. m_bIncY = FALSE;
  267. }
  268. }
  269. else
  270. {
  271. pObject->m_fRotation[Y] -= fYIncrement;
  272. if(pObject->m_fRotation[Y] < (m_fRotation[Y]-m_fLimitY))
  273. {
  274. pObject->m_fRotation[Y] += fYIncrement;
  275. m_bIncY = TRUE;
  276. }
  277. }
  278. }
  280. if(m_fWobbleZ)
  281. {
  282. if(m_bIncZ)
  283. {
  284. pObject->m_fRotation[Z] += fZIncrement;
  285. if(pObject->m_fRotation[Z] > (m_fRotation[Z]+m_fLimitZ))
  286. {
  287. pObject->m_fRotation[Z] -= fZIncrement;
  288. m_bIncZ = FALSE;
  289. }
  290. }
  291. else
  292. {
  293. pObject->m_fRotation[Z] -= fZIncrement;
  294. if(pObject->m_fRotation[Z] < (m_fRotation[Z]-m_fLimitZ))
  295. {
  296. pObject->m_fRotation[Z] += fZIncrement;
  297. m_bIncZ = TRUE;
  298. }
  299. }
  300. }
  302. // Save the time of the last iteration
  303. m_dTimePrevious = dTime;
  304. }
  306. void CAnimWobble::Serialize(CArchive& ar, int iVersion)
  307. {
  308. CString szBuffer;
  309. CString szName;
  311. szBuffer.GetBuffer(256);
  312. szName.GetBuffer(128);
  314. if (ar.IsStoring())
  315. {
  316. // Save the CAnimation derived class header...
  317. szBuffer.Format("%sCAnimWobble {n", szIndent);
  318. ar.WriteString(szBuffer);
  320. // Save the this animation procedures' specific data...
  321. szBuffer.Format("%stWobbleX       < %f >n", szIndent, m_fWobbleX);
  322. ar.WriteString(szBuffer);
  323. szBuffer.Format("%stWobbleY       < %f >n", szIndent, m_fWobbleY);
  324. ar.WriteString(szBuffer);
  325. szBuffer.Format("%stWobbleZ       < %f >n", szIndent, m_fWobbleZ);
  326. ar.WriteString(szBuffer);
  328. szBuffer.Format("%stLimitX        < %f >n", szIndent, m_fLimitX);
  329. ar.WriteString(szBuffer);
  330. szBuffer.Format("%stLimitY        < %f >n", szIndent, m_fLimitY);
  331. ar.WriteString(szBuffer);
  332. szBuffer.Format("%stLimitZ        < %f >n", szIndent, m_fLimitZ);
  333. ar.WriteString(szBuffer);
  335. szBuffer.Format("%stSpinSpeedX    < %f >n", szIndent, m_dSpeedX);
  336. ar.WriteString(szBuffer);
  337. szBuffer.Format("%stSpinSpeedY    < %f >n", szIndent, m_dSpeedY);
  338. ar.WriteString(szBuffer);
  339. szBuffer.Format("%stSpinSpeedZ    < %f >n", szIndent, m_dSpeedZ);
  340. ar.WriteString(szBuffer);
  342. // Save the base class data...
  343. CAnimation::Serialize(ar, iVersion);
  345. szBuffer.Format("%s}n", szIndent); // end of animation def
  346. ar.WriteString(szBuffer);
  347. }
  348. else
  349. {
  350. // Read the derived class data..
  351. ar.ReadString(szBuffer);
  352. szBuffer.TrimLeft(); // Remove leading white spaces
  353. sscanf(szBuffer, "WobbleX       < %f >n", &m_fWobbleX);
  354. ar.ReadString(szBuffer);
  355. szBuffer.TrimLeft();
  356. sscanf(szBuffer, "WobbleY       < %f >n", &m_fWobbleY);
  357. ar.ReadString(szBuffer);
  358. szBuffer.TrimLeft();
  359. sscanf(szBuffer, "WobbleZ       < %f >n", &m_fWobbleZ);
  361. ar.ReadString(szBuffer);
  362. szBuffer.TrimLeft();
  363. sscanf(szBuffer, "LimitX        < %f >n", &m_fLimitX);
  364. ar.ReadString(szBuffer);
  365. szBuffer.TrimLeft();
  366. sscanf(szBuffer, "LimitY        < %f >n", &m_fLimitY);
  367. ar.ReadString(szBuffer);
  368. szBuffer.TrimLeft();
  369. sscanf(szBuffer, "LimitZ        < %f >n", &m_fLimitZ);
  371. ar.ReadString(szBuffer);
  372. szBuffer.TrimLeft();
  373. sscanf(szBuffer, "SpinSpeedX    < %lf >n", (float*)&m_dSpeedX);
  374. ar.ReadString(szBuffer);
  375. szBuffer.TrimLeft();
  376. sscanf(szBuffer, "SpinSpeedY    < %lf >n", (float*)&m_dSpeedY);
  377. ar.ReadString(szBuffer);
  378. szBuffer.TrimLeft();
  379. sscanf(szBuffer, "SpinSpeedZ    < %lf >n", (float*)&m_dSpeedZ);
  381. // Read the base class data...
  382. CAnimation::Serialize(ar, iVersion);
  383. }
  384. }
  386. void CAnimWobble::Reset()
  387. {
  388. // TODO:  Add any CAnimWobble reset code here..
  389. }
  392. /////////////////////////////////////////////////////////////////////////////
  393. // CAnimWobble function implimentation