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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
BilliardView.cpp
资源名称：taiqiu.rar　[点击查看]
上传用户：owen_mei
上传日期：2022-08-09
资源大小：2263k
文件大小：32k
源码类别：

OpenGL

开发平台：

Visual C++

BilliardView.cpp：源码内容
  1. // BilliardView.cpp : implementation of the CBilliardView class
  2. //
  4. #include "stdafx.h"
  5. #include "Billiard.h"
  7. #include "BilliardDoc.h"
  8. #include "BilliardView.h"
  9. #include "model.h"
  12. #ifdef _DEBUG
  13. #define new DEBUG_NEW
  14. #undef THIS_FILE
  15. static char THIS_FILE[] = __FILE__;
  16. #endif
  18. /////////////////////////////////////////////////////////////////////////////
  19. // CBilliardView
  21. IMPLEMENT_DYNCREATE(CBilliardView, CView)
  23. BEGIN_MESSAGE_MAP(CBilliardView, CView)
  24. //{{AFX_MSG_MAP(CBilliardView)
  25. ON_WM_CREATE()
  26. ON_WM_DESTROY()
  27. ON_WM_SIZE()
  28. ON_WM_TIMER()
  29. ON_WM_LBUTTONDOWN()
  30. ON_WM_LBUTTONUP()
  31. ON_WM_MOUSEMOVE()
  32. ON_WM_RBUTTONDOWN()
  33. ON_WM_RBUTTONUP()
  34. ON_WM_KEYDOWN()
  35. //}}AFX_MSG_MAP
  36. // Standard printing commands
  37. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  38. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  39. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  40. END_MESSAGE_MAP()
  42. /////////////////////////////////////////////////////////////////////////////
  43. // CBilliardView construction/destruction
  45. CBilliardView::CBilliardView()
  46. {
  47. // TODO: add construction code here
  48. g_Dragging = FALSE; //  鼠标的初始状态不是拖动状态
  49. g_DrawingStick = FALSE; //  球杆在初始时不随场景一起绘制
  50. g_LastTime = 0;
  51. g_SimRunning = TRUE; //  初始时即进入游戏
  52. g_TimeIterations = 10;
  53. g_UseFixedTimeStep = FALSE; //  不使用固定的时间步长
  54. g_MaxTimeStep = 0.01f;
  55. g_CollisionRootFinding = FALSE;
  56. g_UseDamping = TRUE; // 初始时应用阻尼
  57. g_UseFriction = TRUE; // 初始时应用摩擦
  58. g_CueHitBall = FALSE; // 初始时球杆没有击中球
  59. g_BallInPlay = FALSE; // 初始时没有球在运动
  61. }
  63. CBilliardView::~CBilliardView()
  64. {
  65. }
  67. BOOL CBilliardView::PreCreateWindow(CREATESTRUCT& cs)
  68. {
  69. // TODO: Modify the Window class or styles here by modifying
  70. //  the CREATESTRUCT cs
  71. ////////////////////////////////////////////////////////////////
  72. //设置窗口类型
  73. cs.style |=WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
  74. ////////////////////////////////////////////////////////////////
  75. return CView::PreCreateWindow(cs);
  76. }
  78. /////////////////////////////////////////////////////////////////////////////
  79. // CBilliardView drawing
  81. void CBilliardView::OnDraw(CDC* pDC)
  82. {
  83. CBilliardDoc* pDoc = GetDocument();
  84. ASSERT_VALID(pDoc);
  85. // TODO: add draw code for native data here
  86. //////////////////////////////////////////////////////////////////
  87. RenderWorld(); //渲染场景
  88. //////////////////////////////////////////////////////////////////
  90. }
  92. /////////////////////////////////////////////////////////////////////////////
  93. // CBilliardView printing
  95. BOOL CBilliardView::OnPreparePrinting(CPrintInfo* pInfo)
  96. {
  97. // default preparation
  98. return DoPreparePrinting(pInfo);
  99. }
  101. void CBilliardView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  102. {
  103. // TODO: add extra initialization before printing
  104. }
  106. void CBilliardView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  107. {
  108. // TODO: add cleanup after printing
  109. }
  111. /////////////////////////////////////////////////////////////////////////////
  112. // CBilliardView diagnostics
  114. #ifdef _DEBUG
  115. void CBilliardView::AssertValid() const
  116. {
  117. CView::AssertValid();
  118. }
  120. void CBilliardView::Dump(CDumpContext& dc) const
  121. {
  122. CView::Dump(dc);
  123. }
  125. CBilliardDoc* CBilliardView::GetDocument() // non-debug version is inline
  126. {
  127. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CBilliardDoc)));
  128. return (CBilliardDoc*)m_pDocument;
  129. }
  130. #endif //_DEBUG
  132. /////////////////////////////////////////////////////////////////////////////
  133. // CBilliardView message handlers
  135. int CBilliardView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  136. {
  137. if (CView::OnCreate(lpCreateStruct) == -1)
  138. return -1;
  140. // TODO: Add your specialized creation code here
  141. //////////////////////////////////////////////////////////////////
  142. //初始化OpenGL和设置定时器
  143. m_pDC = new CClientDC(this);
  144. SetTimer(1, 20, NULL);
  145. InitializeOpenGL(m_pDC);
  146. //////////////////////////////////////////////////////////////////
  147. SetupViewRC();
  148. g_LastTime = GetTime();
  149. InitRender();
  150. if(!InitGame())
  151. return -1;
  152. return 0;
  153. }
  155. void CBilliardView::OnDestroy() 
  156. {
  157. CView::OnDestroy();
  159. // TODO: Add your message handler code here
  160. /////////////////////////////////////////////////////////////////
  161. //删除调色板和渲染上下文、定时器
  162. ::wglMakeCurrent(0,0);
  163. ::wglDeleteContext( m_hRC);
  164. if (m_hPalette)
  165.     DeleteObject(m_hPalette);
  166. if ( m_pDC )
  167. {
  168. delete m_pDC;
  169. }
  170. KillTimer(1);
  171. /////////////////////////////////////////////////////////////////
  173. }
  175. void CBilliardView::OnSize(UINT nType, int cx, int cy) 
  176. {
  177. CView::OnSize(nType, cx, cy);
  179. // TODO: Add your message handler code here
  180. if(cy == 0)   // 避免被0除
  181. cy = 1;
  182. double dAspect = (double)cx/(double)cy;
  183. // 设置视口
  184.     glViewport(0, 0, cx, cy);
  185. // 设置投影矩阵
  186. glMatrixMode(GL_PROJECTION);
  187. glLoadIdentity();
  188. // 设置投影变换
  189. gluPerspective(60.0, dAspect,0.2f, 2000);
  190. //  设置模型矩阵
  191. glMatrixMode(GL_MODELVIEW);
  192. glLoadIdentity();
  194. }
  196. void CBilliardView::OnTimer(UINT nIDEvent) 
  197. {
  198. // TODO: Add your message handler code here and/or call default
  199. /////////////////////////////////////////////////////////////////
  200. //添加定时器响应函数和场景更新函数
  201. Invalidate(FALSE);
  202. /////////////////////////////////////////////////////////////////
  204. CView::OnTimer(nIDEvent);
  205. }
  207. /////////////////////////////////////////////////////////////////////
  208. //                   设置逻辑调色板
  209. //////////////////////////////////////////////////////////////////////
  210. void CBilliardView::SetLogicalPalette(void)
  211. {
  212.     struct
  213.     {
  214.         WORD Version;
  215.         WORD NumberOfEntries;
  216.         PALETTEENTRY aEntries[256];
  217.     } logicalPalette = { 0x300, 256 };
  219. BYTE reds[] = {0, 36, 72, 109, 145, 182, 218, 255};
  220. BYTE greens[] = {0, 36, 72, 109, 145, 182, 218, 255};
  221. BYTE blues[] = {0, 85, 170, 255};
  223.     for (int colorNum=0; colorNum<256; ++colorNum)
  224.     {
  225.         logicalPalette.aEntries[colorNum].peRed =
  226.             reds[colorNum & 0x07];
  227.         logicalPalette.aEntries[colorNum].peGreen =
  228.             greens[(colorNum >> 0x03) & 0x07];
  229.         logicalPalette.aEntries[colorNum].peBlue =
  230.             blues[(colorNum >> 0x06) & 0x03];
  231.         logicalPalette.aEntries[colorNum].peFlags = 0;
  232.     }
  234.     m_hPalette = CreatePalette ((LOGPALETTE*)&logicalPalette);
  235. }
  238. //////////////////////////////////////////////////////////
  239. // 初始化openGL场景
  240. //////////////////////////////////////////////////////////
  241. BOOL CBilliardView::InitializeOpenGL(CDC* pDC)
  242. {
  243. m_pDC = pDC;
  244. SetupPixelFormat();
  245. //生成绘制描述表
  246. m_hRC = ::wglCreateContext(m_pDC->GetSafeHdc());
  247. //置当前绘制描述表
  248. ::wglMakeCurrent(m_pDC->GetSafeHdc(), m_hRC);
  250. return TRUE;
  251. }
  253. //////////////////////////////////////////////////////////
  254. // 设置像素格式
  255. //////////////////////////////////////////////////////////
  256. BOOL CBilliardView::SetupPixelFormat()
  257. {
  258. PIXELFORMATDESCRIPTOR pfd = { 
  259.     sizeof(PIXELFORMATDESCRIPTOR),    // pfd结构的大小 
  260.     1,                                // 版本号 
  261.     PFD_DRAW_TO_WINDOW |              // 支持在窗口中绘图 
  262.     PFD_SUPPORT_OPENGL |              // 支持 OpenGL 
  263.     PFD_DOUBLEBUFFER,                 // 双缓存模式 
  264.     PFD_TYPE_RGBA,                    // RGBA 颜色模式 
  265.     24,                               // 24 位颜色深度 
  266.     0, 0, 0, 0, 0, 0,                 // 忽略颜色位 
  267.     0,                                // 没有非透明度缓存 
  268.     0,                                // 忽略移位位 
  269.     0,                                // 无累加缓存 
  270.     0, 0, 0, 0,                       // 忽略累加位 
  271.     32,                               // 32 位深度缓存     
  272.     0,                                // 无模板缓存 
  273.     0,                                // 无辅助缓存 
  274.     PFD_MAIN_PLANE,                   // 主层 
  275.     0,                                // 保留 
  276.     0, 0, 0                           // 忽略层,可见性和损毁掩模 
  277. }; 
  278. int pixelformat;
  279. pixelformat = ::ChoosePixelFormat(m_pDC->GetSafeHdc(), &pfd);//选择像素格式
  280. ::SetPixelFormat(m_pDC->GetSafeHdc(), pixelformat, &pfd); //设置像素格式
  281. if(pfd.dwFlags & PFD_NEED_PALETTE)
  282. SetLogicalPalette(); //设置逻辑调色板
  283. return TRUE;
  284. }
  288. //////////////////////////////////////////////////////////
  289. // 场景绘制与渲染
  290. //////////////////////////////////////////////////////////
  291. BOOL CBilliardView::RenderWorld() 
  292. {
  293. float Time;
  294. float DeltaTime;
  296.     if (g_UseFixedTimeStep) //  如果使用固定步长
  297. Time = g_LastTime + (g_MaxTimeStep * g_TimeIterations);
  298. else
  299. Time = GetTime();
  301. if (g_SimRunning)
  302. {
  303. while(g_LastTime < Time)
  304. {
  305. DeltaTime = Time - g_LastTime;
  306. if(DeltaTime > g_MaxTimeStep)
  307. {
  308. DeltaTime = g_MaxTimeStep;
  309. }
  311.   Simulate(DeltaTime,g_SimRunning);
  312. g_LastTime += DeltaTime;
  313. }
  314. g_LastTime = Time;
  315. }
  316. else
  317. {
  318. DeltaTime = 0;
  319. Simulate(DeltaTime,g_SimRunning);
  320. }
  322. ////////////////////////////////////////////////////////////////
  323. //  清除颜色缓存和深度缓存
  324. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  325. glPushMatrix();
  326. g_CueStick.yaw = -g_POV.rot.y; // 设置球杆始终位于视场中心
  327. //  设置摄像机平移
  328. glTranslatef(-g_POV.trans.x, -g_POV.trans.y, -g_POV.trans.z);
  329. //  设置摄像机旋转
  330. glRotatef(g_POV.rot.z, 0.0f, 0.0f, 1.0f);
  331. glRotatef(g_POV.rot.x, 1.0f, 0.0f, 0.0f); 
  332. glRotatef(g_POV.rot.y, 0.0f, 1.0f, 0.0f);
  333. glTranslatef(-g_CueStick.pos.x, -g_CueStick.pos.y, -g_CueStick.pos.z);
  334. RenderScene(); //  绘制静止的场景
  335. RenderCueAndBalls(); //  绘制球杆和球
  336. glPopMatrix();
  337. ::SwapBuffers(m_pDC->GetSafeHdc()); //交互缓冲区
  338. return TRUE;
  339. }
  341. void CBilliardView::OnLButtonDown(UINT nFlags, CPoint point) 
  342. {
  343. // TODO: Add your message handler code here and/or call default
  344. g_Dragging = TRUE; //  按下鼠标左键，将鼠标设置为拖动状态
  345. g_LastYaw = g_POV.rot.y; //  保存摄像机绕Y轴旋转的位置
  346. g_LastPitch = g_POV.rot.x; //  保存摄像机绕X轴旋转的位置
  347. g_MouseHitX = point.x; //  鼠标单击的X坐标 
  348. g_MouseHitY = point.y; //  鼠标单击的Y坐标 
  349. // 设置球杆的位置
  350. g_CueStick.pos.x = g_CurrentSys->pos.x;
  351. g_CueStick.pos.z = g_CurrentSys->pos.z;
  352. SetCapture();
  353. CView::OnLButtonDown(nFlags, point);
  354. }
  356. void CBilliardView::OnLButtonUp(UINT nFlags, CPoint point) 
  357. {
  358. // TODO: Add your message handler code here and/or call default
  359. g_Dragging = FALSE; //  释放鼠标左键，解除鼠标的拖动状态
  360. ReleaseCapture();
  362. CView::OnLButtonUp(nFlags, point);
  363. }
  365. void CBilliardView::OnMouseMove(UINT nFlags, CPoint point) 
  366. {
  367. // TODO: Add your message handler code here and/or call default
  368. tx = point.x; //  记下当前鼠标的X坐标 
  369. ty = point.y; //  记下当前鼠标的Y坐标 
  370. if (g_Dragging) //  当鼠标处于拖动状态
  371. {
  372. if (tx != g_MouseHitX)
  373. {
  374. //  摄像机绕Y轴旋转
  375. g_POV.rot.y = g_LastYaw + (float)(tx - g_MouseHitX);
  376. Invalidate(FALSE);;
  377. }
  378. if (ty != g_MouseHitY)
  379. {
  380. //  摄像机绕X轴旋转
  381. g_POV.rot.x = g_LastPitch + (float)(ty - g_MouseHitY);
  382. if (g_POV.rot.x < 0.0f) 
  383. g_POV.rot.x = 0.0f;
  384. if (g_POV.rot.x > 90.0f) 
  385. g_POV.rot.x = 90.0f;
  386. Invalidate(FALSE);;
  387. }
  389. }
  390. // 如果球杆处于绘制状态(即拖动是鼠标右键),并且球的运动没有结束
  391. if (g_DrawingStick && !g_BallInPlay)
  392. {
  393. if (ty != g_MouseHitY)
  394. {
  395. g_CueStick.draw = g_LastDraw + ((float)(ty - g_MouseHitY) * 0.1f);
  396. // 向后移动球杆
  397. if (g_LastDraw < g_CueStick.draw)
  398. {
  399. g_CueStick.old_draw = g_CueStick.draw;
  400. g_CueStick.drawtime = GetTime();
  401. }
  402. // 如果球杆接触到球，则击中球
  403. else if (g_CueStick.draw < 0.0f)
  404. {
  406. g_CueHitBall = TRUE; // 设置球击中标志为TRUE
  407. magnitude = -CUE_STICK_FORCE * ((g_CueStick.old_draw - g_CueStick.draw) / (GetTime() - g_CueStick.drawtime));
  408. g_CueForce.x = magnitude * sin(DEGTORAD(g_CueStick.yaw));
  409. g_CueForce.z = magnitude * cos(DEGTORAD(g_CueStick.yaw));
  410. g_CueStick.draw = 0.2f;
  411. g_BallInPlay = TRUE; //  击中球后，球开始运动
  412. g_DrawingStick = FALSE; //  不绘制球杆
  413. }
  414. Invalidate(FALSE);;
  415. }
  416. }
  417. CView::OnMouseMove(nFlags, point);
  418. }
  420. void CBilliardView::OnRButtonDown(UINT nFlags, CPoint point) 
  421. {
  422. // TODO: Add your message handler code here and/or call default
  423. g_DrawingStick = TRUE; //  绘制球杆
  424. g_LastDraw = g_CueStick.draw; //  保存球杆与球之间的距离
  425. g_CueStick.old_draw = g_CueStick.draw; //  保存球杆与球之间的距离
  426. g_MouseHitX = point.x; //  鼠标单击的X坐标 
  427. g_MouseHitY = point.y; //  鼠标单击的Y坐标 
  428. // 重新设置球杆的位置
  429. g_CueStick.pos.x = g_CurrentSys->pos.x;
  430. g_CueStick.pos.z = g_CurrentSys->pos.z;
  431. SetCapture();
  432. CView::OnRButtonDown(nFlags, point);
  433. }
  435. void CBilliardView::OnRButtonUp(UINT nFlags, CPoint point) 
  436. {
  437. // TODO: Add your message handler code here and/or call default
  438. g_DrawingStick = FALSE; //  不绘制球杆
  439. ReleaseCapture();
  441. CView::OnRButtonUp(nFlags, point);
  442. }
  444. void CBilliardView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  445. {
  446. // TODO: Add your message handler code here and/or call default
  447. switch(nChar)
  448. {
  449. case VK_UP:
  450. {
  451. if (g_POV.rot.x > 0.0f) 
  452. g_POV.rot.x -= 1.0; //  绕X轴负方向旋转
  453. Invalidate(FALSE);;
  454. break;
  455. }
  456. case VK_DOWN: 
  457. {
  458. if (g_POV.rot.x < 90.0f) 
  459. g_POV.rot.x += 1.0; //  绕X轴正方向旋转
  460. Invalidate(FALSE);;
  461. break;
  462. }
  463. case VK_LEFT:
  464. {
  465. g_POV.rot.y += 1.0; //  绕Y轴正方向旋转
  466. Invalidate(FALSE);;
  467. break;
  468. }
  470. case VK_RIGHT:
  471. {
  472. g_POV.rot.y -= 1.0; //  绕Y轴负方向旋转
  473. Invalidate(FALSE);;
  474. break;
  475. }
  476. case VK_PRIOR: // 场景放大
  477. {
  478. if (g_POV.trans.z > 1.0f)
  479. //  摄像机向z轴的负方向平移
  480. g_POV.trans.z -= 1.0;
  481. Invalidate(FALSE);;
  482. break;
  483. }
  484. case VK_NEXT: // 场景缩小
  485. {
  486. if (g_POV.trans.z < 9.0f) 
  487. //  摄像机向z轴方向平移
  488. g_POV.trans.z += 1.0;
  489. Invalidate(FALSE);;
  490. break;
  491. }
  492. }
  494. CView::OnKeyDown(nChar, nRepCnt, nFlags);
  495. }
  497. //  下面的函数的功能是对游戏进行初始化
  498. BOOL CBilliardView::InitGame(void)
  499. {
  500. g_CueStick.draw = g_CueStick.old_draw = 0.2f;
  501. g_CueStick.yaw = 0.0f;
  502. g_CueStick.pos.x = -4.0f;
  503. g_CueStick.pos.y = TABLE_POSITION;
  504. g_CueStick.pos.z = 0.0f;
  505. g_Kd = 0.02f; // 阻尼因子
  506. g_Kr_Bumper = 0.8f; // 球与边界之间碰撞的恢复系数
  507. g_Kr_Ball = 0.2f; // 球与球之间碰撞的恢复系数
  508. g_Csf = 0.2f; // 缺省的静摩擦
  509. g_Ckf = 0.1f; // 缺省的动摩擦
  510. MAKEVECTOR(g_Gravity, 0.0f, -32.0f, 0.0f)
  511. g_IntegratorType = EULER_INTEGRATOR;
  512. g_CollisionRootFinding = FALSE; // ONLY SET WHEN FINDING A COLLISION
  513. g_ContactCnt = 0;
  514. SetupBalls();
  515. g_CurrentSys = g_GameSys[0];
  516. g_TargetSys = g_GameSys[1];
  517. g_CollisionPlaneCnt = 4;
  518. // 左边的碰撞平面
  519. MAKEVECTOR(g_CollisionPlane[0].normal,1.0f, 0.0f, 0.0f)
  520. g_CollisionPlane[0].d = LEFT_BUMPER;
  521. // 右边的碰撞平面
  522. MAKEVECTOR(g_CollisionPlane[1].normal,-1.0f, 0.0f, 0.0f)
  523. g_CollisionPlane[1].d = RIGHT_BUMPER;
  524. // 上边的碰撞平面
  525. MAKEVECTOR(g_CollisionPlane[2].normal, 0.0f, 0.0f, -1.0f)
  526. g_CollisionPlane[2].d = TOP_BUMPER;
  527. // 下边的碰撞平面
  528. MAKEVECTOR(g_CollisionPlane[3].normal, 0.0f, 0.0f, 1.0f)
  529. g_CollisionPlane[3].d = BOTTOM_BUMPER;
  530. return TRUE;
  531. }
  534. void CBilliardView::InitRender(void)
  535. {
  536. int loop;
  537. // 初始化摄像机的位置
  538. g_POV.trans.x = 0.0f;
  539. g_POV.trans.y = 0.0f;
  540. g_POV.trans.z = 8.0f;
  541. g_POV.rot.x = 20.0f;
  542. g_POV.rot.y = 90.0f;
  543. g_POV.rot.z = 0.0f;
  544. //  定义白球的显示列表
  545. glNewList(OGL_WBALL_DLIST,GL_COMPILE);
  546. // 定义数据序列
  547. glInterleavedArrays(WBALLFORMAT,0,(GLvoid *)&WBALLMODEL);
  548. glBegin(GL_TRIANGLES);
  549. for (loop = 0; loop < WBALLPOLYCNT * 3; loop++)
  550. {
  551. glArrayElement(loop);
  552. }
  553. glEnd();
  554. glEndList();
  555. //  定义黄球的显示列表
  556. glNewList(OGL_YBALL_DLIST,GL_COMPILE);
  557. // 定义数据序列
  558. glInterleavedArrays(YBALLFORMAT,0,(GLvoid *)&YBALLMODEL);
  559. glBegin(GL_TRIANGLES);
  560. for (loop = 0; loop < YBALLPOLYCNT * 3; loop++)
  561. {
  562. glArrayElement(loop);
  563. }
  564. glEnd();
  565. glEndList();
  566. //  定义球杆的显示列表
  567. glNewList(OGL_CUE_DLIST,GL_COMPILE);
  568. // 定义数据序列
  569. glInterleavedArrays(CUEFORMAT,0,(GLvoid *)&CUEMODEL);
  570. glBegin(GL_TRIANGLES);
  571. for (loop = 0; loop < CUEPOLYCNT * 3; loop++)
  572. {
  573. glArrayElement(loop);
  574. }
  575. glEnd();
  576. glEndList();
  578. LoadTextures();
  580. LoadSceneFile("Pool.ros"); // 装入场景数据
  581. }
  583. //  下面的函数的功能是将所有的TGA图像数据读入到纹理中
  584. void CBilliardView::LoadTextures()
  585. {
  586. GLubyte *rgb;
  587. char texName[80];
  588. tTGAHeader_s tgaHeader;
  589. HANDLE specHandle;
  590. WIN32_FIND_DATA fileData;
  591. int rv;
  593. g_TextureCnt = 0;
  594. sprintf(texName,"%s*.tga",ART_PATH);
  595. if ((specHandle=FindFirstFile(texName,&fileData))!= INVALID_HANDLE_VALUE)
  596. {
  597. do
  598. {
  599. sprintf(g_TexPool[g_TextureCnt].map,"%s%s",ART_PATH,fileData.cFileName);
  600. glGenTextures(1,&g_TexPool[g_TextureCnt].glTex);
  602. rgb = m_LoadTGA.LoadTGAFile( g_TexPool[g_TextureCnt].map,&tgaHeader);
  603. if (rgb == NULL)
  604. {
  605. MessageBox("Unable to Open File...",g_TexPool[g_TextureCnt].map,MB_OK);
  606. g_TexPool[g_TextureCnt].glTex = 0;
  607. return;
  608. }
  610. glBindTexture(GL_TEXTURE_2D, g_TexPool[g_TextureCnt].glTex);
  612. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  613. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  614. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  615. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  616. //  定义2D纹理像素格式
  617. glPixelStorei(GL_UNPACK_ALIGNMENT, 4); /* Force 4-byte alignment */
  618. glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  619. glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
  620. glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
  622. if (tgaHeader.d_pixel_size == 32)
  623. {
  624. glTexImage2D(GL_TEXTURE_2D, 0, 4, tgaHeader.d_width, tgaHeader.d_height, 0,
  625.  GL_RGBA , GL_UNSIGNED_BYTE, rgb);
  626. rv = gluBuild2DMipmaps( GL_TEXTURE_2D, 4, tgaHeader.d_width, tgaHeader.d_height, 
  627. GL_RGBA, GL_UNSIGNED_BYTE, rgb );
  628. }
  629. else
  630. {
  631. glTexImage2D(GL_TEXTURE_2D, 0, 3, tgaHeader.d_width, tgaHeader.d_height, 0,
  632.  GL_RGB, GL_UNSIGNED_BYTE, rgb);
  633. rv = gluBuild2DMipmaps( GL_TEXTURE_2D, 3, tgaHeader.d_width, tgaHeader.d_height, GL_RGB, 
  634. GL_UNSIGNED_BYTE, rgb );
  635. }
  636. //  释放位图和RGB图像数据
  637. free(rgb);
  639. g_TextureCnt++;
  640. }while (FindNextFile(specHandle,&fileData));
  641. FindClose(specHandle);
  642. }
  643. }
  645. void CBilliardView::LoadSceneFile(char *filename)
  646. {
  647. FILE *fp;
  648. char tempstr[80];
  649. t_Visual *visual;
  651. fp = fopen(filename,"rb");
  652. if (fp != NULL)
  653. {
  654. fread(tempstr,1,4,fp);
  655. if (strncmp(tempstr,"ROSC",4)!= 0)
  656. {
  657. MessageBox("Not a Valid Data File","Load File", MB_OK|MB_ICONEXCLAMATION);
  658. return;
  659. }
  661. visual = &g_Scene;
  662. fread(&visual->vertexCnt,sizeof(long),1,fp);
  663. visual->vertex = (tVector *)malloc(sizeof(tVector) * visual->vertexCnt);
  664. fread(visual->vertex,sizeof(tVector),visual->vertexCnt,fp);
  665. fread(&visual->triCnt,sizeof(long),1,fp);
  666. visual->tri = (tPrimPoly *)malloc(sizeof(tPrimPoly) * (visual->triCnt));
  667. fread(visual->tri,sizeof(tPrimPoly),visual->triCnt,fp);
  668. fread(&visual->quadCnt,sizeof(long),1,fp);
  669. visual->quad = (tPrimPoly *)malloc(sizeof(tPrimPoly) * (visual->quadCnt));
  670. fread(visual->quad,sizeof(tPrimPoly),visual->quadCnt,fp);
  672. fclose(fp);
  673. }
  674. }
  676. //  设置OpenGL绘制环境
  677. void CBilliardView::SetupViewRC(void)
  678. {
  679. // 设置黑色背景
  680. glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
  681. glCullFace(GL_BACK);
  682. glFrontFace(GL_CCW);
  683. glEnable(GL_CULL_FACE);
  684. // 使用深度测试
  685. glEnable(GL_DEPTH_TEST);
  686. glDisable(GL_TEXTURE_2D);
  687. // 无光照
  688. glDisable(GL_LIGHTING);
  689. glDisable(GL_LIGHT0);
  691. glPolygonMode(GL_FRONT,GL_FILL);
  692. glDepthFunc(GL_LESS);
  693. glEnable(GL_BLEND);
  694. glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  696. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  698.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  699.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  700. }
  703. void CBilliardView::RenderCueAndBalls()
  704. {
  705. // 绘制白球
  706. glPushMatrix();
  707. glTranslatef(g_CurrentSys[0].pos.x,g_CurrentSys[0].pos.y,g_CurrentSys[0].pos.z);
  708. glCallList(OGL_WBALL_DLIST);
  709. glPopMatrix();
  711. // 绘制黄球
  712. glPushMatrix();
  713. glTranslatef(g_CurrentSys[1].pos.x,g_CurrentSys[1].pos.y,g_CurrentSys[1].pos.z);
  714. glCallList(OGL_YBALL_DLIST);
  715. glPopMatrix();
  717. // 绘制球杆
  718. glPushMatrix();
  719. //  球杆的位置
  720. glTranslatef(g_CueStick.pos.x,g_CueStick.pos.y,g_CueStick.pos.z);
  721. //  绕Y轴旋转
  722. glRotatef(g_CueStick.yaw, 0.0f, 1.0f, 0.0f); 
  723. //  绕X轴旋转一个固定角度，即略向上抬
  724. glRotatef(-5.0f, 1.0f, 0.0f, 0.0f);
  725. //  击球时向后移动球杆
  726. glTranslatef(0,0,g_CueStick.draw);
  727. glCallList(OGL_CUE_DLIST);
  728. glPopMatrix();
  729. }
  731. void CBilliardView::RenderScene()
  732. {
  733.     int loop,loop2;
  734. t_Visual *visual;
  735. tPrimPoly *poly;
  737. glEnable(GL_TEXTURE_2D);
  738. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  740. visual = &g_Scene;
  741. for (loop2 = 0; loop2 < g_TextureCnt; loop2++)
  742. {
  743. poly = visual->quad;
  744. glBindTexture(GL_TEXTURE_2D, g_TexPool[loop2].glTex);
  746. for (loop = 0; loop < visual->quadCnt; loop++)
  747. {
  748. if ((poly->type & POLY_TEXTURED) > 0 && poly->TexNdx1 == (uint)loop2)
  749. {
  750. glBegin(GL_QUADS);
  751. glTexCoord2fv((float *)&poly->t1[0]);
  752. glColor3ubv((unsigned char *)&poly->color[0]);
  753. glVertex3fv((float *)&visual->vertex[poly->index[0]]);
  754. glTexCoord2fv((float *)&poly->t1[1]);
  755. glColor3ubv((unsigned char *)&poly->color[1]);
  756. glVertex3fv((float *)&visual->vertex[poly->index[1]]);
  757. glTexCoord2fv((float *)&poly->t1[2]);
  758. glColor3ubv((unsigned char *)&poly->color[2]);
  759. glVertex3fv((float *)&visual->vertex[poly->index[2]]);
  760. glTexCoord2fv((float *)&poly->t1[3]);
  761. glColor3ubv((unsigned char *)&poly->color[3]);
  762. glVertex3fv((float *)&visual->vertex[poly->index[3]]);
  763. glEnd();
  764. }
  765. poly++;
  766. }
  768. poly = visual->tri;
  769. for (loop = 0; loop < visual->triCnt; loop++)
  770. {
  771. if ((poly->type & POLY_TEXTURED) > 0 && poly->TexNdx1 == (uint)loop2)
  772. {
  773. glBegin(GL_TRIANGLES);
  774. glTexCoord2fv((float *)&poly->t1[0]);
  775. glColor3ubv((unsigned char *)&poly->color[0]);
  776. glVertex3fv((float *)&visual->vertex[poly->index[0]]);
  777. glTexCoord2fv((float *)&poly->t1[1]);
  778. glColor3ubv((unsigned char *)&poly->color[1]);
  779. glVertex3fv((float *)&visual->vertex[poly->index[1]]);
  780. glTexCoord2fv((float *)&poly->t1[2]);
  781. glColor3ubv((unsigned char *)&poly->color[2]);
  782. glVertex3fv((float *)&visual->vertex[poly->index[2]]);
  783. glEnd();
  784. }
  785. poly++;
  786. }
  787. }
  788. glDisable(GL_TEXTURE_2D);
  789. }
  791. void CBilliardView::SetupBalls()
  792. {
  793. int loop, loop2;
  794. for (loop = 0; loop < SYSTEM_COUNT; loop++)
  795. {
  796. for (loop2 = 0; loop2 < BALL_COUNT; loop2++)
  797. {
  798. switch (loop2)
  799. {
  800. // 球1是球杆需要击中的球
  801. case 0:
  802. MAKEVECTOR(g_GameSys[loop][loop2].pos,-4.0f, TABLE_POSITION, 0.0f)
  803. break;
  804. case 1:
  805. MAKEVECTOR(g_GameSys[loop][loop2].pos,4.0f, TABLE_POSITION, 0.0f)
  806. break;
  807. }
  808. MAKEVECTOR(g_GameSys[loop][loop2].v,0.0f, 0.0f, 0.0f)
  809. MAKEVECTOR(g_GameSys[loop][loop2].f,0.0f, 0.0f, 0.0f)
  810. g_GameSys[loop][loop2].oneOverM = 1.0f / 0.34f;
  811. MAKEVECTOR(g_GameSys[loop][loop2].angMom,0.0f, 0.0f, 0.0f)
  812. MAKEVECTOR(g_GameSys[loop][loop2].torque,0.0f, 0.0f, 0.0f)
  814. // 四元数清零
  815. MAKEVECTOR(g_GameSys[loop][loop2].orientation,0.0f, 0.0f, 0.0f)
  816. g_GameSys[loop][loop2].orientation.w = 1.0f;
  818. g_GameSys[loop][loop2].flags = 0;
  819. g_GameSys[loop][loop2].flags = 0;
  820. }
  821. }
  822. }
  825. #define STATIC_THRESHOLD 0.03f //  速度的阈值，用于判断使用何种摩擦
  827. void CBilliardView::ComputeForces( t_Ball *system)
  828. {
  829. int loop;
  830. t_Ball *curBall;
  831. tVector contactN;
  832. float FdotN,VdotN,Vmag;
  833. tVector Vn,Vt;
  835. curBall = system;
  836. for (loop = 0; loop < BALL_COUNT; loop++)
  837. {
  838. MAKEVECTOR(curBall->f,0.0f,0.0f,0.0f) // 清除力
  839. MAKEVECTOR(curBall->torque,0.0f, 0.0f, 0.0f) // 清除力矩
  841. if (g_UseDamping) //  如果用户定义阻尼
  842. {
  843. curBall->f.x += (-g_Kd * curBall->v.x);
  844. curBall->f.y += (-g_Kd * curBall->v.y);
  845. curBall->f.z += (-g_Kd * curBall->v.z);
  846. }
  847. else //  否则使用缺省阻尼
  848. {
  849. curBall->f.x += (-DEFAULT_DAMPING * curBall->v.x);
  850. curBall->f.y += (-DEFAULT_DAMPING * curBall->v.y);
  851. curBall->f.z += (-DEFAULT_DAMPING * curBall->v.z);
  852. }
  854. //  下面处理球与桌面之间的摩擦问题
  855. if (g_UseFriction)
  856. {
  857. // 计算正压力，即重力
  858. FdotN = g_Gravity.y / curBall->oneOverM;
  859. // 计算垂直于法向平面的速度
  860. MAKEVECTOR(contactN,0.0f, 1.0f, 0.0f)
  861. VdotN = m_MathDefs.DotProduct(&contactN,&curBall->v);
  862. m_MathDefs.ScaleVector(&contactN, VdotN, &Vn);
  863. m_MathDefs.VectorDifference(&curBall->v, &Vn, &Vt);
  864. Vmag = m_MathDefs.VectorSquaredLength(&Vt);
  865. // 判断速度是否大于阈值
  866. if (Vmag > STATIC_THRESHOLD) // 大于阈值，使用动摩擦模型
  867. {
  868. m_MathDefs.NormalizeVector(&Vt);
  869. m_MathDefs.ScaleVector(&Vt, (FdotN * g_Ckf), &Vt);
  870. m_MathDefs.VectorSum(&curBall->f,&Vt,&curBall->f);
  871. }
  872. else // 小于阈值，使用静摩擦模型
  873. {
  874. Vmag = Vmag / STATIC_THRESHOLD;
  875. m_MathDefs.NormalizeVector(&Vt);
  876. m_MathDefs.ScaleVector(&Vt, (FdotN * g_Csf * Vmag), &Vt);  // Scale Friction by Velocity
  877. m_MathDefs.VectorSum(&curBall->f,&Vt,&curBall->f);
  878. if (loop == 0)
  879. {
  880. g_BallInPlay = FALSE;
  881. }
  882. }
  883. }
  885. curBall++;
  886. }
  888. //  用户是否定义了球杆撞击球的力
  889. if (g_CueHitBall)
  890. {
  891. m_MathDefs.VectorSum(&system[0].f,&g_CueForce,&system[0].f);
  892. }
  893. }   
  896. void CBilliardView::IntegrateSysOverTime(t_Ball *initial,t_Ball *source, t_Ball *target, float deltaTime)
  897. {
  898. int loop;
  899. float deltaTimeMass;
  901. for (loop = 0; loop < BALL_COUNT; loop++)
  902. {
  903. deltaTimeMass = deltaTime * initial->oneOverM;
  904. // 获得新的速度
  905. target->v.x = initial->v.x + (source->f.x * deltaTimeMass);
  906. target->v.y = initial->v.y + (source->f.y * deltaTimeMass);
  907. target->v.z = initial->v.z + (source->f.z * deltaTimeMass);
  909. target->oneOverM = initial->oneOverM;
  911. // 获得新的位置坐标
  912. target->pos.x = initial->pos.x + (deltaTime * source->v.x);
  913. target->pos.y = initial->pos.y + (deltaTime * source->v.y);
  914. target->pos.z = initial->pos.z + (deltaTime * source->v.z);
  916. initial++;
  917. source++;
  918. target++;
  919. }
  920. }
  922. //  欧拉积分
  923. void CBilliardView::EulerIntegrate( float DeltaTime)
  924. {
  925. IntegrateSysOverTime(g_CurrentSys,g_CurrentSys, g_TargetSys,DeltaTime);
  926. }
  928. //  中点方法
  929. void CBilliardView::MidPointIntegrate( float DeltaTime)
  930. {
  931. float halfDeltaT;
  933. halfDeltaT = DeltaTime / 2.0f;
  934. //  计算半步长
  935. IntegrateSysOverTime(g_CurrentSys,g_CurrentSys,&g_GameSys[2][0],halfDeltaT);
  936. //  使用新的位置和速度计算力
  937. ComputeForces(&g_GameSys[2][0]);
  938. //  计算全步长
  939. IntegrateSysOverTime(g_CurrentSys,&g_GameSys[2][0],g_TargetSys,DeltaTime);
  940. }
  942. int CBilliardView::CheckForCollisions( t_Ball *system )
  943. {
  944. int collisionState = NOT_COLLIDING;
  945.     float const depthEpsilon = 0.001f;
  946.     float const ballDepthEpsilon = 0.0001f;
  947. int loop,loop2,planeIndex;
  948. t_Ball *curBall,*ball2;
  949. t_CollisionPlane *plane;
  950. float axbyczd,dist,relativeVelocity;
  951. tVector distVect;
  952. g_ContactCnt = 0; // 目前的碰撞次数为0
  953. curBall = system;
  954. for (loop = 0; 
  955. (loop < BALL_COUNT) && (collisionState != PENETRATING); 
  956. loop++,curBall++)
  957. {
  958. //  判断球与边界面之间的碰撞
  959.         for(planeIndex = 0;
  960. (planeIndex < g_CollisionPlaneCnt) && (collisionState != PENETRATING);
  961. planeIndex++)
  962.         {
  963. plane = &g_CollisionPlane[planeIndex];
  965.             axbyczd = m_MathDefs.DotProduct(&curBall->pos,&plane->normal) + plane->d;
  967.             if(axbyczd < -depthEpsilon)
  968.             {
  969. // 任何球穿过边界面，退出循环
  970. collisionState = PENETRATING;
  971.             }
  972.             else
  973.             if(axbyczd < depthEpsilon)
  974.             {
  975.                 relativeVelocity = m_MathDefs.DotProduct(&plane->normal,&curBall->v);
  976. if(relativeVelocity < 0.0f)
  977.                 {
  978.                     collisionState = COLLIDING_WITH_WALL;
  979. g_Contact[g_ContactCnt].type = COLLIDING_WITH_WALL;
  980. g_Contact[g_ContactCnt].ball = loop; 
  981. g_Contact[g_ContactCnt].Kr = g_Kr_Bumper; // Ball to bumper Kr
  982. memcpy(&g_Contact[g_ContactCnt].normal,&plane->normal,sizeof(tVector));
  983. g_ContactCnt++;
  984.                 }
  985.             }
  986.         }
  987. // 现在判断球与球之间的碰撞  
  988. ball2 = system;
  989. for (loop2 = 0; (loop2 < BALL_COUNT) && (collisionState != PENETRATING); 
  990. loop2++,ball2++)
  991. {
  992. if (loop2 == loop) continue; // 不与自身比较
  993. if (curBall->flags) continue; // 如果当前球是碰撞球
  995. m_MathDefs.VectorDifference(&curBall->pos, &ball2->pos, &distVect);
  996. //  获得两球心之间的距离
  997. dist = m_MathDefs.VectorSquaredLength(&distVect);
  999. dist = dist - (BALL_DIAMETER * BALL_DIAMETER);  
  1000. //  判断两球之间是否穿过
  1001. if(dist < -ballDepthEpsilon)
  1002. {
  1003. // 如果穿过，则退出
  1004. collisionState = PENETRATING;
  1005. }
  1006. else
  1007. if(dist < ballDepthEpsilon)
  1008. {
  1009. m_MathDefs.NormalizeVector(&distVect);
  1010. //  获得相对速度
  1011. relativeVelocity = m_MathDefs.DotProduct(&distVect,&curBall->v);
  1012. //  如果相对速度小于0
  1013. if(relativeVelocity < 0.0f)
  1014. {
  1015. collisionState = COLLIDING_WITH_BALL;
  1016. g_Contact[g_ContactCnt].type = COLLIDING_WITH_BALL;
  1017. g_Contact[g_ContactCnt].ball = loop; 
  1018. g_Contact[g_ContactCnt].ball2 = loop2; 
  1019. g_Contact[g_ContactCnt].Kr = g_Kr_Ball;
  1020. memcpy(&g_Contact[g_ContactCnt].normal,&distVect,sizeof(tVector));
  1021. ball2->flags = 1;
  1022. g_ContactCnt++;
  1023. }
  1024. }
  1025. }
  1026. }
  1027.     return collisionState;
  1028. }
  1030. void CBilliardView::ResolveCollisions( t_Ball  *system )
  1031. {
  1032. t_Contact *contact;
  1033. t_Ball *ball,*ball2;
  1034. float VdotN;
  1035. tVector Vn,Vt,Vn1;
  1036. int loop;
  1038. contact = g_Contact;
  1039. for (loop = 0; loop < g_ContactCnt; loop++,contact++)
  1040. {
  1041. ball = &system[contact->ball];
  1042. // 计算 Vn
  1043. VdotN = m_MathDefs.DotProduct(&contact->normal,&ball->v);
  1044. m_MathDefs.ScaleVector(&contact->normal, VdotN, &Vn);
  1045. // 计算 Vt
  1046. m_MathDefs.VectorDifference(&ball->v, &Vn, &Vt);
  1047. // 判断碰撞类型
  1048. if (contact->type == COLLIDING_WITH_WALL) //  如果球与边界碰撞
  1049. {
  1050. //  Vn乘以恢复系数
  1051. m_MathDefs.ScaleVector(&Vn, contact->Kr, &Vn);
  1052. //  设置新的速度
  1053. m_MathDefs.VectorDifference(&Vt, &Vn, &ball->v);
  1054. }
  1055. else // 球与球之间碰撞
  1056. {
  1057. // Vn乘以恢复系数
  1058. m_MathDefs.ScaleVector(&Vn, contact->Kr, &Vn1);
  1059. // 设置新的速度
  1060. m_MathDefs.VectorDifference(&Vt, &Vn1, &ball->v);
  1062. ball2 = &system[contact->ball2];
  1063. // 球2的Vn乘以恢复系数
  1064. m_MathDefs.ScaleVector(&Vn, 1.0f - contact->Kr, &Vn1);
  1065. // 设置球2的速度
  1066. m_MathDefs.VectorSum(&Vn1,&ball2->v,&ball2->v);
  1068. ball->flags = 0;
  1069. ball2->flags = 0;
  1070. }
  1071. }
  1072. }
  1074. void CBilliardView::Simulate(float DeltaTime, BOOL running)
  1075. {
  1076.     float CurrentTime = 0.0f;
  1077.     float TargetTime = DeltaTime;
  1078. t_Ball *tempSys;
  1079. int collisionState;
  1081.     while(CurrentTime < DeltaTime)
  1082.     {
  1083. if (running)
  1084. {
  1085. //  定义各球的作用力
  1086. ComputeForces(g_CurrentSys);
  1088. //  如果出现碰撞穿透的现象，强制使用欧拉方法，否则提供选择
  1089. if (g_CollisionRootFinding)
  1090. {
  1091. EulerIntegrate(TargetTime-CurrentTime);
  1092. }
  1093. else
  1094. {
  1095. switch (g_IntegratorType)
  1096. {
  1097. case EULER_INTEGRATOR:
  1098. EulerIntegrate(TargetTime-CurrentTime);
  1099. break;
  1100. case MIDPOINT_INTEGRATOR:
  1101. MidPointIntegrate(TargetTime-CurrentTime);
  1102. break;
  1103. }
  1104. }
  1105. }
  1107. collisionState = CheckForCollisions(g_TargetSys);
  1109.         if(collisionState == PENETRATING)
  1110.         {
  1111. // 将使用欧拉方法
  1112. g_CollisionRootFinding = TRUE;
  1113.             // 将时间步长缩短
  1114.             TargetTime = (CurrentTime + TargetTime) / 2.0f;
  1116.             assert(fabs(TargetTime - CurrentTime) > EPSILON);
  1117.         }
  1118.         else
  1119.         {
  1120.             if(collisionState == COLLIDING_WITH_WALL || collisionState == COLLIDING_WITH_BALL)
  1121.             {
  1122.                 int Counter = 0;
  1123.                 do
  1124.                 {
  1125.                     ResolveCollisions(g_TargetSys);
  1126.                     Counter++;
  1127.                 } while((CheckForCollisions(g_TargetSys) >= COLLIDING_WITH_WALL) && (Counter < 500));
  1129.                 assert(Counter < 500);
  1130. g_CollisionRootFinding = FALSE;
  1131.             }
  1133.   //  进入下一步
  1134. CurrentTime = TargetTime;
  1135. TargetTime = DeltaTime;
  1137. MAKEVECTOR(g_CueForce,0.0f,0.0f,0.0f); // 清除球杆的力
  1139. // SWAP MY TWO SYSTEM BUFFERS SO I CAN DO IT AGAIN
  1140. tempSys = g_CurrentSys;
  1141. g_CurrentSys = g_TargetSys;
  1142. g_TargetSys = tempSys;
  1143.         }
  1144.     }
  1145. }
  1147. float CBilliardView::GetTime( void )
  1148. {
  1149.     static long StartMilliseconds;
  1150. long CurrentMilliseconds;
  1151.     if(!StartMilliseconds)
  1152.     {
  1153.         StartMilliseconds = timeGetTime();
  1154.     }
  1156.     CurrentMilliseconds = timeGetTime();
  1157.     return (float)(CurrentMilliseconds - StartMilliseconds) / 1000.0f;
  1158. }