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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
CInputManager.cpp
资源名称：terrain_editing.rar　[点击查看]
上传用户：jinmajixie
上传日期：2022-07-12
资源大小：435k
文件大小：12k
源码类别：

OpenGL

开发平台：

Visual C++

CInputManager.cpp：源码内容
  2. #include "main.h"
  7. /*******************************************************************************
  8. * INPUT MANAGER
  9. *******************************************************************************/
  12. ////////////////////////////////////////////////////////////////////////////////
  13. CInputManager::CInputManager()
  14. {
  15. mouse_initialized = true;
  16. mouse_active = true;
  17. filter = true;
  18. window_center_x = 1024/2;
  19. window_center_y = 768/2;
  20. sensitivity = 0.5f;
  21. yaw = 0.5f;
  22. pitch = 0.5f;
  23. action = 0;
  25. rotation = &nullv;
  26. position = &nullv;
  27. lookat = &nullv;
  28. mcontrol_x = &nullv.x;
  29. mcontrol_y = &nullv.x;
  30. // scene_m = NULL;
  31. // ssp = NULL;
  32. }
  35. ////////////////////////////////////////////////////////////////////////////////
  38. void CInputManager::Init(CTerrainEdit *te)
  39. {
  40. if (te != 0)
  41. mouse_initialized = true;
  42. tedit = te;
  43. }
  44. /*
  45. void CInputManager::Init(CSceneManager *s, CSystemStuff *sp)
  46. {
  47. scene_m = s;
  48. ssp = sp;
  49. SetMousePointers(scene_m->cp->rotation_p, &scene_m->cp->look_vector);
  50. }
  51. */
  55. ////////////////////////////////////////////////////////////////////////////////
  56. void CInputManager::SetMousePointers(CVector *p, CVector *r, CVector *l)
  57. {
  58. if (r == NULL || l == NULL || p == NULL)
  59. {
  60. err("CInput", "null pointer");
  61. return;
  62. }
  63. position = p;
  64. rotation = r;
  65. lookat = l;
  66. mouse_initialized = true;
  67. rotate_camera = true;
  68. }
  69. ////////////////////////////////////////////////////////////////////////////////
  73. ////////////////////////////////////////////////////////////////////////////////
  74. ////////////////////////////////////////////////////////////////////////////////
  75. void CInputManager::MouseMove()
  76. {
  77. if (!mouse_initialized)
  78. {
  79. errf("mouse not initialized", "!!!");
  80. return;
  81. }
  82. if (rotate_camera) CameraRotation();
  83. switch (action)
  84. {
  85. case 0:
  86. FloatModify();
  87. break;
  88. case 1:
  89. MovingObject();
  90. break;
  91. default: err("bad action in CInput"); break;
  92. }
  93. if (mx || my) SetCursorPos(window_center_x, window_center_y);
  94. }
  95. ////////////////////////////////////////////////////////////////////////////////
  99. void CInputManager::KeyDown(WPARAM k)
  100. {
  101. keys[k] = true;
  102. }
  104. void CInputManager::KeyUp(WPARAM k)
  105. {
  106. keys[k] = false;
  107. }
  109. void CInputManager::ProcessInput()
  110. {
  111. if (keys['C'])
  112. {
  113. rotate_camera = !rotate_camera;
  114. keys['C'] = false;
  115. }
  116. if (keys[VK_ESCAPE]) PostQuitMessage(0);
  117. }
  118. ////////////////////////////////////////////////////////////////////////////////
  119. ////////////////////////////////////////////////////////////////////////////////
  120. void CInputManager::MovingObject()
  121. {
  122. mx = my = 0;
  123. float mouse_x, mouse_y;
  124. if (!mouse_active) return;
  125. if (!GetCursorPos(&current_pos)) return;
  127. mx = current_pos.x - window_center_x;
  128. my = current_pos.y - window_center_y;
  130. if (filter) // zistit na co to je
  131. {
  132. mouse_x = (mx + old_mouse_x) * 0.5f;
  133. mouse_y = (my + old_mouse_y) * 0.5f;
  134. }
  135. else
  136. {
  137. mouse_x = mx;
  138. mouse_y = my;
  139. }
  141. old_mouse_x = mx;
  142. old_mouse_y = my;
  144. mouse_x *= sensitivity;
  145. mouse_y *= sensitivity;
  147. float add_z = yaw * mouse_x;
  149. if (rotation->y - add_z > 45 && add_z > 0)
  150. {
  151. rotation->y -= add_z;
  152. }
  153. if (rotation->y - add_z  < 135 && add_z < 0)
  154. {
  155. rotation->y -= add_z;
  156. }
  158. if (rotation->x >= 360) rotation->x -= 360;
  159. if (rotation->x < 0) rotation->x += 360;
  161. float add_y = pitch * mouse_y * -1;
  163. if (rotation->z - add_y > 20 && add_y > 0)
  164. {
  165. rotation->z -= add_y;
  166. }
  167. if (rotation->z - add_y  < 70 && add_y < 0)
  168. {
  169. rotation->z -= add_y;
  170. }
  172. lookat->x -= add_z;
  173. lookat->z += add_y;
  175. /*
  176. lookat->z = sin(rotation->x/div180byPI);
  177. lookat->x = cos(rotation->x/div180byPI);
  179. float xy = sqrt(rotation->x*rotation->x+rotation->y*rotation->y);
  180. lookat->y = tan(rotation->y/div180byPI);
  181. */
  182. // errfi("lookat", lookat->x*1000, lookat->y*1000, lookat->z*1000);
  183. }
  184. ////////////////////////////////////////////////////////////////////////////////
  189. ////////////////////////////////////////////////////////////////////////////////
  190. ////////////////////////////////////////////////////////////////////////////////
  191. void CInputManager::CameraRotation()
  192. {
  193. mx = my = 0;
  194. float mouse_x, mouse_y;
  195. if (!mouse_active) return;
  196. if (!GetCursorPos(&current_pos)) return;
  198. mx = current_pos.x - window_center_x;
  199. my = current_pos.y - window_center_y;
  201. if (filter) // zistit na co to je
  202. {
  203. mouse_x = (mx + old_mouse_x) * 0.5f;
  204. mouse_y = (my + old_mouse_y) * 0.5f;
  205. }
  206. else
  207. {
  208. mouse_x = mx;
  209. mouse_y = my;
  210. }
  212. old_mouse_x = mx;
  213. old_mouse_y = my;
  215. mouse_x *= sensitivity;
  216. mouse_y *= sensitivity;
  217. float add_x = yaw * mouse_x;
  218. rotation->x += add_x;
  220. // errfi("rotation", rotation->x, rotation->y, rotation->z);
  222. if (rotation->x >= 360) rotation->x -= 360;
  223. if (rotation->x < 0) rotation->x += 360;
  225. float add_y = pitch * mouse_y;
  227. rotation->y -= add_y;
  229. /*
  230. if (rotation->y - add_y > -90 && add_y > 0)
  231. {
  232. rotation->y -= add_y;
  233. }
  234. if (rotation->y - add_y  < 90 && add_y < 0)
  235. {
  236. rotation->y -= add_y;
  237. }
  238. */
  240. lookat->z = sin(rotation->x/div180byPI);
  241. lookat->x = cos(rotation->x/div180byPI);
  243. float xy = sqrt(rotation->x*rotation->x+rotation->y*rotation->y);
  244. lookat->y = tan(rotation->y/div180byPI);
  246. // errfi("lookat", lookat->x*1000, lookat->y*1000, lookat->z*1000);
  247. }
  248. ////////////////////////////////////////////////////////////////////////////////
  249. ////////////////////////////////////////////////////////////////////////////////
  256. ////////////////////////////////////////////////////////////////////////////////
  257. ////////////////////////////////////////////////////////////////////////////////
  258. void CInputManager::FloatModify()
  259. {
  260. mx = my = 0;
  261. float mouse_x, mouse_y;
  262. if (!mouse_active) return;
  263. if (!GetCursorPos(&current_pos)) return;
  265. mx = current_pos.x - window_center_x;
  266. my = current_pos.y - window_center_y;
  268. if (filter) // zistit na co to je
  269. {
  270. mouse_x = (mx + old_mouse_x) * 0.5f;
  271. mouse_y = (my + old_mouse_y) * 0.5f;
  272. }
  273. else
  274. {
  275. mouse_x = mx;
  276. mouse_y = my;
  277. }
  279. old_mouse_x = mx;
  280. old_mouse_y = my;
  282. mouse_x *= sensitivity;
  283. mouse_y *= sensitivity;
  285. float add_x = yaw * mouse_x * 1;
  286. float add_y = pitch * mouse_y * -1;
  288. *mcontrol_x += add_x;
  289. *mcontrol_y += add_y;
  291. if (*mcontrol_x < 0) *mcontrol_x = 0;
  292. if (*mcontrol_y < 0) *mcontrol_y = 0;
  293. if (*mcontrol_x > 128) *mcontrol_x = 128;
  294. if (*mcontrol_y > 128) *mcontrol_y = 128;
  296. }
  297. ////////////////////////////////////////////////////////////////////////////////
  303. ////////////////////////////////////////////////////////////////////////////////
  304. ////////////////////////////////////////////////////////////////////////////////
  305. //void CInputManager::ProcessInput()
  306. //{
  307. /*
  308. if (keys[VK_ESCAPE])
  309. {
  310. menu = !menu;
  311. if (menu)
  312. {
  313. float colour[4] = {-10.0, -10.0, -10.0, 0.5};
  314. glLightfv(GL_LIGHT0, GL_AMBIENT, colour);
  315. glEnable(GL_BLEND);
  317. }
  318. else
  319. {
  320. glLightfv(GL_LIGHT0, GL_AMBIENT, scene.ambient_colour);
  321. glDisable(GL_BLEND);
  322. }
  323. keys[VK_ESCAPE] = false;
  324. }
  326. if (keys['7'])
  327. {
  328. scene.ambient_colour[0] += 0.05f;
  329. scene.ambient_colour[1] += 0.05f;
  330. scene.ambient_colour[2] += 0.05f;
  331. scene.fog_colour[0] = scene.ambient_colour[0]*dif*0.45;
  332. scene.fog_colour[1] = scene.ambient_colour[1]*dif*0.55;
  333. scene.fog_colour[2] = scene.ambient_colour[2]*dif*0.72;
  334. glFogfv(GL_FOG_COLOR, scene.fog_colour);
  335. glLightfv(GL_LIGHT0, GL_AMBIENT, scene.ambient_colour);
  336. }
  337. if (keys['U'])
  338. {
  339. scene.ambient_colour[0] -= 0.05f;
  340. scene.ambient_colour[1] -= 0.05f;
  341. scene.ambient_colour[2] -= 0.05f;
  342. scene.fog_colour[0] = scene.ambient_colour[0]*dif*0.45;
  343. scene.fog_colour[1] = scene.ambient_colour[1]*dif*0.55;
  344. scene.fog_colour[2] = scene.ambient_colour[2]*dif*0.72;
  345. glFogfv(GL_FOG_COLOR, scene.fog_colour);
  346. glLightfv(GL_LIGHT0, GL_AMBIENT, scene.ambient_colour);
  347. }
  349. if (!menu)
  350. {
  351. // if (selected)
  352. // {
  354. if (keys[VK_UP]) statics.obj[last_collision].position.z += spd/10;
  355. if (keys[VK_DOWN]) statics.obj[last_collision].position.z -= spd/10;
  356. if (keys[VK_LEFT]) statics.obj[last_collision].position.x += spd/10;
  357. if (keys[VK_RIGHT]) statics.obj[last_collision].position.x -= spd/10;
  358. if (keys[VK_PRIOR]) statics.obj[last_collision].rotation.y += spd/10;
  359. if (keys[VK_NEXT]) statics.obj[last_collision].rotation.y -= spd/10;
  360. if (keys[VK_INSERT])
  361. {  }
  362. if (keys[VK_DELETE])
  363. {  }
  364. // } // selected
  365. // else
  366. {
  367. // if (keys[VK_UP]) statics.obj[15].rotation.x += spd/10;
  368. // if (keys[VK_DOWN]) statics.obj[15].rotation.x -= spd/10;
  369. // if (keys[VK_LEFT]) statics.obj[15].rotation.z += spd/10;
  370. // if (keys[VK_RIGHT]) statics.obj[15].rotation.z -= spd/10;
  371. // if (keys[VK_PRIOR]) statics.obj[15].rotation.y += spd/10;
  372. // if (keys[VK_NEXT]) statics.obj[15].rotation.y -= spd/10;
  373. }
  375. if (keys['1']) cam.max_speed = 0.1;
  376. if (keys['2']) cam.max_speed = 1.0;
  377. if (keys['3']) cam.max_speed = 5.0;
  378. if (keys['4']) cam.max_speed = 30.0;
  379. if (keys['H']) { help = !help; keys['H'] = false; }
  380. if (keys['R'])
  381. {
  382. selected = !selected;
  383. keys['R'] = false;
  384. }
  386. if (keys[VK_F5])
  387. {
  388. SaveWorld();
  389. keys[VK_F5]=false;
  390. }
  392. if (keys[VK_F9])
  393. {
  394. LoadWorld();
  395. keys[VK_F9]=false;
  396. }
  398. if (keys[' '])
  399. {
  400. cam.Jump();
  401. }
  402. if (keys['W'])
  403. {
  404. cam.Accelerate();
  405. }
  406. if (keys['S'])
  407. {
  408. cam.Deccelerate();
  409. }
  410. if (keys['A'])
  411. {
  412. cam.StrafeLeft();
  413. }
  414. if (keys['D'])
  415. {
  416. cam.StrafeRight();
  417. }
  418. if (keys['E']) { cam.velocity.y += spd/1000; }
  419. if (keys['Q']) { cam.velocity.y -= spd/1000; }
  420. if (keys['F'])
  421. {
  422. for (int i = 0 ; i < 128 ; i++)
  423. {
  424. CVector q(cam.GetLookVector());
  425. CVector vect(q);
  426. vect.Normal();
  427. vect.NoiseAngle();
  428. vect *= 5;
  429. int idn = 12+rand()%1;
  430. sel_obj = CreateDynamicObject(idn, cam.position+q, vect, true);
  431. gui.AddFadeText(dynamics.obj[sel_obj].model_id, 300, 200, 3);
  432. // sel_obj = CreateDynamicObject("arrow", cam.position+q, vect, false);
  433. }
  434. keys['F'] = false;
  435. }
  436. if (keys[VK_F15])
  437. {
  438. // if (arrow_released)
  439. // {
  440. // gui.AddFadeText(":: using arrow", 30, 100, 1);
  441. CVector q;
  442. q = 3;
  443. q *= cam.GetLookVector();
  444. sel_obj = CreateDynamicObject("arrow", q, q, false);
  445. // }
  446. brmbrm();
  447. arrow_released = false;
  448. }
  449. if (!keys[VK_F15])
  450. {
  451. // brmbrm();
  452. arrow_released = true;
  453. }
  454. if (keys['G'])
  455. {
  456. CVector accel(0.0, 0.01, 0.0);
  457. dynamics.obj[sel_obj].velocity += accel;
  458. }
  460. if (keys[VK_CONTROL])
  461. {
  462. cam.ToggleDuck();
  463. keys[VK_CONTROL] = false;
  464. }
  466. if (keys['C'])
  467. {
  468. show_collision = !show_collision;
  469. keys['C'] = false;
  470. }
  471. if (keys[VK_TAB])
  472. {
  473. culled = !culled;
  474. for (int i = 0 ; i < dynamics.count ; i++)
  475. dynamics.obj[i].culled = culled;
  476. for (int i = 0 ; i < statics.count ; i++)
  477. statics.obj[i].culled = culled;
  478. for (int i = 0 ; i < items.count ; i++)
  479. items.obj[i].culled = culled;
  480. keys[VK_TAB] = false;
  481. }
  483. if (keys['N'])
  484. {
  485. wireframe = !wireframe;
  486. for (int i = 0 ; i < statics.count ; i++)
  487. {
  488. if (statics.obj[i].pM != NULL)
  489. {
  490. if (wireframe)
  491. statics.obj[i].pM->render_mode = GL_LINES;
  492. else
  493. statics.obj[i].pM->render_mode = GL_TRIANGLES;
  494. }
  495. }
  496. for (int i = 0 ; i < dynamics.count ; i++)
  497. {
  498. if (dynamics.obj[i].pM != NULL)
  499. {
  500. if (wireframe)
  501. dynamics.obj[i].pM->render_mode = GL_LINES;
  502. else
  503. dynamics.obj[i].pM->render_mode = GL_TRIANGLES;
  504. }
  505. }
  506. keys['N'] = false;
  507. }
  509. if (keys['B'])
  510. {
  511. activated = !activated;
  512. for (int i = 0 ; i < dynamics.count ; i++)
  513. dynamics.obj[i].active = activated;
  514. keys['B'] = false;
  515. }
  516. if (keys['X'])
  517. {
  518. gui.ClearFadeTexts();
  519. for (int i=0 ; i < dynamics.count ; i++)
  520. {
  521. dynamics.obj[i].pM = NULL;
  522. }
  523. dynamics.count = 0;
  524. keys['X'] = false;
  525. }
  526. }
  527. else
  528. {
  529. if (keys['X']) ss.Umri();
  530. }
  531. */
  532. //}