Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.

666 строки
23 KiB

  1. //
  2. // Lol Engine - EasyMesh tutorial
  3. //
  4. // Copyright: (c) 2011-2013 Sam Hocevar <sam@hocevar.net>
  5. // (c) 2012-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
  6. // This program is free software; you can redistribute it and/or
  7. // modify it under the terms of the Do What The Fuck You Want To
  8. // Public License, Version 2, as published by Sam Hocevar. See
  9. // http://www.wtfpl.net/ for more details.
  10. //
  11. #if defined HAVE_CONFIG_H
  12. # include "config.h"
  13. #endif
  14. #include <cfloat> /* for FLT_MAX */
  15. #include "core.h"
  16. #include "scenesetup.h"
  17. using namespace std;
  18. using namespace lol;
  19. static int const TEXTURE_WIDTH = 256;
  20. #define R_M 1.f
  21. #define DEFAULT_WIDTH (770.f * R_M)
  22. #define DEFAULT_HEIGHT (200.f * R_M)
  23. #define WIDTH ((float)Video::GetSize().x)
  24. #define HEIGHT ((float)Video::GetSize().y)
  25. #define SCREEN_W (10.f / WIDTH)
  26. #define SCREEN_LIMIT 1.1f
  27. #define RATIO_HW (HEIGHT / WIDTH)
  28. #define RATIO_WH (WIDTH / HEIGHT)
  29. #define RESET_TIMER .2f
  30. #define ROT_SPEED vec2(50.f)
  31. #define ROT_CLAMP 89.f
  32. #define POS_SPEED vec2(1.2f)
  33. #define POS_CLAMP 1.f
  34. #define FOV_SPEED 20.f
  35. #define FOV_CLAMP 120.f
  36. #define ZOM_SPEED 3.f
  37. #define ZOM_CLAMP 20.f
  38. #define HST_SPEED .5f
  39. #define HST_CLAMP 1.f
  40. #define WITH_TEXTURE 0
  41. #define NO_NACL_EM (!__native_client__ && !EMSCRIPTEN)
  42. #define NACL_EM (__native_client__ || EMSCRIPTEN)
  43. #define HAS_KBOARD (m_input_usage & (1<<IPT_MV_KBOARD))
  44. #define HAS_MOUSE (m_input_usage & (1<<IPT_MV_MOUSE))
  45. LOLFX_RESOURCE_DECLARE(shinyfur);
  46. LOLFX_RESOURCE_DECLARE(shinymvtexture);
  47. enum
  48. {
  49. IPT_MV_KBOARD = 0,
  50. IPT_MV_MOUSE,
  51. INPUT_MAX
  52. };
  53. enum MVKeyboardList
  54. {
  55. KEY_CAM_RESET = 0,
  56. KEY_CAM_POS,
  57. KEY_CAM_FOV,
  58. KEY_CAM_UP,
  59. KEY_CAM_DOWN,
  60. KEY_CAM_LEFT,
  61. KEY_CAM_RIGHT,
  62. KEY_MESH_NEXT,
  63. KEY_MESH_PREV,
  64. KEY_F1,
  65. KEY_F2,
  66. KEY_F3,
  67. KEY_F4,
  68. KEY_F5,
  69. KEY_ESC,
  70. KEY_MAX
  71. };
  72. enum MVMouseKeyList
  73. {
  74. MSE_CAM_ROT = KEY_MAX,
  75. MSE_CAM_POS,
  76. MSE_CAM_FOV,
  77. MSE_MAX
  78. };
  79. enum MVMouseAxisList
  80. {
  81. MSEX_CAM_Y = 0,
  82. MSEX_CAM_X,
  83. MSEX_MAX
  84. };
  85. #define MAX_KEYS MSE_MAX
  86. #define MAX_AXIS MSEX_MAX
  87. enum MessageType
  88. {
  89. MSG_IN,
  90. MSG_OUT,
  91. MSG_MAX
  92. };
  93. class MeshViewer : public WorldEntity
  94. {
  95. public:
  96. MeshViewer(char const *file_name = "data/mesh-buffer.txt")
  97. : m_file_name(file_name)
  98. {
  99. m_init = false;
  100. }
  101. ~MeshViewer()
  102. {
  103. if (m_camera)
  104. g_scene->PopCamera(m_camera);
  105. if (m_ssetup)
  106. delete(m_ssetup);
  107. MessageService::Destroy();
  108. m_ssetup = nullptr;
  109. m_camera = nullptr;
  110. }
  111. #if NO_NACL_EM
  112. bool KeyReleased(MVKeyboardList index) { return (HAS_KBOARD && m_controller->GetKey(index).IsReleased()); }
  113. bool KeyPressed(MVKeyboardList index) { return (HAS_KBOARD && m_controller->GetKey(index).IsPressed()); }
  114. bool KeyDown(MVKeyboardList index) { return (HAS_KBOARD && m_controller->GetKey(index).IsDown()); }
  115. bool KeyReleased(MVMouseKeyList index) { return (HAS_MOUSE && m_controller->GetKey(index).IsReleased()); }
  116. bool KeyPressed(MVMouseKeyList index) { return (HAS_MOUSE && m_controller->GetKey(index).IsPressed()); }
  117. bool KeyDown(MVMouseKeyList index) { return (HAS_MOUSE && m_controller->GetKey(index).IsDown()); }
  118. float AxisValue(MVMouseAxisList index) { return (HAS_MOUSE)?(m_controller->GetAxis(index).GetValue()):(0.f); }
  119. #endif //NO_NACL_EM
  120. void Init()
  121. {
  122. m_init = true;
  123. m_input_usage = 0;
  124. #if NO_NACL_EM
  125. /* Register an input controller for the keyboard */
  126. m_controller = new Controller("Default", MAX_KEYS, MAX_AXIS);
  127. if (InputDevice::Get("Mouse"))
  128. {
  129. m_input_usage |= (1<<IPT_MV_MOUSE);
  130. m_controller->GetKey(MSE_CAM_ROT).Bind("Mouse", "Left");
  131. m_controller->GetKey(MSE_CAM_POS).Bind("Mouse", "Right");
  132. m_controller->GetKey(MSE_CAM_FOV).Bind("Mouse", "Middle");
  133. m_controller->GetAxis(MSEX_CAM_Y).Bind("Mouse", "Y");
  134. m_controller->GetAxis(MSEX_CAM_X).Bind("Mouse", "X");
  135. }
  136. if (InputDevice::Get("Keyboard"))
  137. {
  138. m_input_usage |= (1<<IPT_MV_KBOARD);
  139. //Camera keyboard rotation
  140. m_controller->GetKey(KEY_CAM_UP ).Bind("Keyboard", "Up");
  141. m_controller->GetKey(KEY_CAM_DOWN ).Bind("Keyboard", "Down");
  142. m_controller->GetKey(KEY_CAM_LEFT ).Bind("Keyboard", "Left");
  143. m_controller->GetKey(KEY_CAM_RIGHT).Bind("Keyboard", "Right");
  144. //Camera keyboard position switch
  145. m_controller->GetKey(KEY_CAM_POS ).Bind("Keyboard", "LeftShift");
  146. m_controller->GetKey(KEY_CAM_FOV ).Bind("Keyboard", "LeftCtrl");
  147. //Camera unzoom switch
  148. m_controller->GetKey(KEY_CAM_RESET).Bind("Keyboard", "Space");
  149. //Mesh change
  150. m_controller->GetKey(KEY_MESH_NEXT).Bind("Keyboard", "PageUp");
  151. m_controller->GetKey(KEY_MESH_PREV).Bind("Keyboard", "PageDown");
  152. //Base setup
  153. m_controller->GetKey(KEY_F1).Bind("Keyboard", "F1");
  154. m_controller->GetKey(KEY_F2).Bind("Keyboard", "F2");
  155. m_controller->GetKey(KEY_F3).Bind("Keyboard", "F3");
  156. m_controller->GetKey(KEY_F4).Bind("Keyboard", "F4");
  157. m_controller->GetKey(KEY_F5).Bind("Keyboard", "F5");
  158. m_controller->GetKey(KEY_ESC).Bind("Keyboard", "Escape");
  159. }
  160. #endif //NO_NACL_EM
  161. // Message Service
  162. MessageService::Setup();
  163. // Mesh Setup
  164. m_render_max = vec2(-.9f, 6.1f);
  165. m_mesh_id = 0;
  166. m_mesh_id1 = 0.f;
  167. m_default_texture = NULL;
  168. //Camera Setup
  169. m_reset_timer = -1.f;
  170. m_fov = -100.f;
  171. m_fov_mesh = 0.f;
  172. m_fov_speed = 0.f;
  173. m_zoom = -100.f;
  174. m_zoom_mesh = 0.f;
  175. m_zoom_speed = 0.f;
  176. m_rot = vec2(45.f);
  177. m_rot_mesh = vec2::zero;
  178. m_rot_speed = vec2::zero;
  179. m_pos = vec2::zero;
  180. m_pos_mesh = vec2::zero;
  181. m_pos_speed = vec2::zero;
  182. m_screen_offset = vec2::zero;
  183. m_hist_scale = vec2(.13f, .03f);
  184. m_hist_scale_mesh = vec2(.0f);
  185. m_hist_scale_speed = vec2(.0f);
  186. m_mat_prev = mat4(quat::fromeuler_xyz(vec3::zero));
  187. m_mat = mat4(quat::fromeuler_xyz(vec3(m_rot_mesh, .0f)));
  188. m_camera = new Camera();
  189. m_camera->SetView(vec3(0.f, 0.f, 10.f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f));
  190. m_camera->SetProjection(0.f, .0001f, 2000.f, WIDTH * SCREEN_W, RATIO_HW);
  191. m_camera->UseShift(true);
  192. g_scene->PushCamera(m_camera);
  193. //Lights setup
  194. m_ssetup = new SceneSetup();
  195. m_ssetup->Compile(" addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1)"
  196. " addlight 0.0 position (8 2 6) color #ffff"
  197. " custom setmesh \"sc#fff ab 1\"");
  198. m_ssetup->Startup();
  199. //stream update
  200. m_stream_update_time = 2.0f;
  201. m_stream_update_timer = 1.0f;
  202. }
  203. virtual void TickGame(float seconds)
  204. {
  205. WorldEntity::TickGame(seconds);
  206. if (!m_init && g_scene)
  207. {
  208. Init();
  209. return;
  210. }
  211. if (!m_init)
  212. return;
  213. //TODO : This should probably be "standard LoL behaviour"
  214. #if NO_NACL_EM
  215. {
  216. //Shutdown logic
  217. if (KeyReleased(KEY_ESC))
  218. Ticker::Shutdown();
  219. }
  220. #endif //NO_NACL_EM
  221. //Mesh Change
  222. #if NO_NACL_EM
  223. m_mesh_id = clamp(m_mesh_id + ((int)KeyPressed(KEY_MESH_PREV) - (int)KeyPressed(KEY_MESH_NEXT)), 0, m_meshes.Count() - 1);
  224. #endif //NO_NACL_EM
  225. m_mesh_id1 = damp(m_mesh_id1, (float)m_mesh_id, .2f, seconds);
  226. //Update light position
  227. for (int i = 0; i < m_ssetup->m_lights.Count(); ++i)
  228. {
  229. vec4 v = m_ssetup->m_lights[i]->GetPosition();
  230. m_ssetup->m_lights[i]->SetPosition(vec4((m_mat * inverse(m_mat_prev) * vec4(v.xyz, 1.f)).xyz, v.w));
  231. }
  232. //Camera update
  233. bool is_pos = false;
  234. bool is_fov = false;
  235. bool is_hsc = false;
  236. vec2 tmp = vec2::zero;
  237. #if NO_NACL_EM
  238. is_pos = KeyDown(KEY_CAM_POS) || KeyDown(MSE_CAM_POS);
  239. is_fov = KeyDown(KEY_CAM_FOV) || KeyDown(MSE_CAM_FOV);
  240. if (KeyDown(MSE_CAM_ROT) || KeyDown(MSE_CAM_POS) || KeyDown(MSE_CAM_FOV))
  241. {
  242. tmp += vec2(AxisValue(MSEX_CAM_Y), AxisValue(MSEX_CAM_X));
  243. if (KeyDown(MSE_CAM_ROT))
  244. tmp *= 6.f;
  245. if (KeyDown(MSE_CAM_POS))
  246. tmp *= vec2(1.f, -1.f) * 3.f;
  247. if (KeyDown(MSE_CAM_FOV))
  248. tmp = vec2(tmp.y * 4.f, tmp.x * 6.f);
  249. }
  250. tmp += vec2((float)KeyDown(KEY_CAM_UP ) - (float)KeyDown(KEY_CAM_DOWN),
  251. (float)KeyDown(KEY_CAM_RIGHT) - (float)KeyDown(KEY_CAM_LEFT));
  252. #endif //NO_NACL_EM
  253. //Base data
  254. vec2 rot = (!is_pos && !is_fov)?(tmp):(vec2(.0f)); rot = vec2(rot.x, rot.y);
  255. vec2 pos = ( is_pos && !is_fov)?(tmp):(vec2(.0f)); pos = -vec2(pos.y, pos.x);
  256. vec2 fov = (!is_pos && is_fov )?(tmp):(vec2(.0f)); fov = vec2(-fov.x, fov.y);
  257. vec2 hsc = (is_hsc)?(vec2(0.f)):(vec2(0.f));
  258. //speed
  259. m_rot_speed = damp(m_rot_speed, rot * ROT_SPEED, .2f, seconds);
  260. float pos_factor = 1.f / (1.f + m_zoom_mesh * .5f);
  261. m_pos_speed = damp(m_pos_speed, pos * POS_SPEED * pos_factor, .2f, seconds);
  262. float fov_factor = 1.f + lol::pow((m_fov_mesh / FOV_CLAMP) * 1.f, 2.f);
  263. m_fov_speed = damp(m_fov_speed, fov.x * FOV_SPEED * fov_factor, .2f, seconds);
  264. float zom_factor = 1.f + lol::pow((m_zoom_mesh / ZOM_CLAMP) * 1.f, 2.f);
  265. m_zoom_speed = damp(m_zoom_speed, fov.y * ZOM_SPEED * zom_factor, .2f, seconds);
  266. m_hist_scale_speed = damp(m_hist_scale_speed, hsc * HST_SPEED, .2f, seconds);
  267. m_rot += m_rot_speed * seconds;
  268. #if NO_NACL_EM
  269. if (m_reset_timer >= 0.f)
  270. m_reset_timer -= seconds;
  271. if (KeyPressed(KEY_CAM_RESET))
  272. {
  273. if (m_reset_timer >= 0.f)
  274. {
  275. m_pos = vec2(0.f);
  276. m_zoom = -100.f;
  277. }
  278. else
  279. m_reset_timer = RESET_TIMER;
  280. }
  281. //Transform update
  282. if (!KeyDown(KEY_CAM_RESET))
  283. {
  284. m_pos += m_pos_speed * seconds;
  285. m_fov += m_fov_speed * seconds;
  286. m_zoom += m_zoom_speed * seconds;
  287. m_hist_scale += m_hist_scale_speed * seconds;
  288. }
  289. #endif //NO_NACL_EM
  290. //clamp
  291. vec2 rot_mesh = vec2(SmoothClamp(m_rot.x, -ROT_CLAMP, ROT_CLAMP, ROT_CLAMP * .1f), m_rot.y);
  292. vec2 pos_mesh = vec2(SmoothClamp(m_pos.x, -POS_CLAMP, POS_CLAMP, POS_CLAMP * .1f),
  293. SmoothClamp(m_pos.y, -POS_CLAMP, POS_CLAMP, POS_CLAMP * .1f));
  294. float fov_mesh = SmoothClamp(m_fov, 0.f, FOV_CLAMP, FOV_CLAMP * .1f);
  295. float zoom_mesh = SmoothClamp(m_zoom, 0.f, ZOM_CLAMP, ZOM_CLAMP * .1f);
  296. vec2 hist_scale_mesh = vec2(SmoothClamp(m_hist_scale.x, 0.f, HST_CLAMP, HST_CLAMP * .1f),
  297. SmoothClamp(m_hist_scale.y, 0.f, HST_CLAMP, HST_CLAMP * .1f));
  298. #if NO_NACL_EM
  299. if (KeyDown(KEY_CAM_RESET) && m_reset_timer < 0.f)
  300. {
  301. pos_mesh = vec2::zero;
  302. zoom_mesh = 0.f;
  303. }
  304. #endif //NO_NACL_EM
  305. m_rot_mesh = vec2(damp(m_rot_mesh.x, rot_mesh.x, .2f, seconds), damp(m_rot_mesh.y, rot_mesh.y, .2f, seconds));
  306. m_pos_mesh = vec2(damp(m_pos_mesh.x, pos_mesh.x, .2f, seconds), damp(m_pos_mesh.y, pos_mesh.y, .2f, seconds));
  307. m_fov_mesh = damp(m_fov_mesh, fov_mesh, .2f, seconds);
  308. m_zoom_mesh = damp(m_zoom_mesh, zoom_mesh, .2f, seconds);
  309. m_hist_scale_mesh = damp(m_hist_scale_mesh, hist_scale_mesh, .2f, seconds);
  310. //Mesh mat calculation
  311. m_mat_prev = m_mat;
  312. m_mat = mat4(quat::fromeuler_xyz(vec3(m_rot_mesh, .0f)));
  313. //Target List Setup
  314. Array<vec3> target_list;
  315. if (m_meshes.Count() && m_mesh_id >= 0)
  316. for (int i = 0; i < m_meshes[m_mesh_id]->GetVertexCount(); i++)
  317. target_list << (m_mat * mat4::translate(m_meshes[m_mesh_id]->GetVertexLocation(i))).v3.xyz;
  318. //--
  319. //Update mesh screen location - Get the Min/Max needed
  320. //--
  321. vec2 cam_center(0.f);
  322. float cam_factor = .0f;
  323. vec3 local_min_max[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
  324. vec2 screen_min_max[2] = { vec2(FLT_MAX), vec2(-FLT_MAX) };
  325. mat4 world_cam = m_camera->GetView();
  326. mat4 cam_screen = m_camera->GetProjection();
  327. //target on-screen computation
  328. for (int i = 0; i < target_list.Count(); i++)
  329. {
  330. vec3 obj_loc = target_list[i];
  331. {
  332. //Debug::DrawBox(obj_loc - vec3(4.f), obj_loc + vec3(4.f), vec4(1.f, 0.f, 0.f, 1.f));
  333. mat4 target_mx = mat4::translate(obj_loc);
  334. vec3 vpos;
  335. //Get location in cam coordinates
  336. target_mx = world_cam * target_mx;
  337. vpos = target_mx.v3.xyz;
  338. local_min_max[0] = min(vpos.xyz, local_min_max[0]);
  339. local_min_max[1] = max(vpos.xyz, local_min_max[1]);
  340. //Get location in screen coordinates
  341. target_mx = cam_screen * target_mx;
  342. vpos = (target_mx.v3 / target_mx.v3.w).xyz;
  343. screen_min_max[0] = min(screen_min_max[0], vpos.xy * vec2(RATIO_WH, 1.f));
  344. screen_min_max[1] = max(screen_min_max[1], vpos.xy * vec2(RATIO_WH, 1.f));
  345. //Build Barycenter
  346. cam_center += vpos.xy;
  347. cam_factor += 1.f;
  348. }
  349. }
  350. float screen_ratio = max(max(lol::abs(local_min_max[0].x), lol::abs(local_min_max[0].y)),
  351. max(lol::abs(local_min_max[1].x), lol::abs(local_min_max[1].y)));
  352. float scale_ratio = max(max(lol::abs(screen_min_max[0].x), lol::abs(screen_min_max[0].y)),
  353. max(lol::abs(screen_min_max[1].x), lol::abs(screen_min_max[1].y)));
  354. vec2 screen_offset = vec2(0.f, -(screen_min_max[1].y + screen_min_max[0].y) * .5f);
  355. m_screen_offset = damp(m_screen_offset, screen_offset, .9f, seconds);
  356. float z_pos = (inverse(world_cam) * mat4::translate(vec3(0.f, 0.f, max(local_min_max[0].z, local_min_max[1].z)))).v3.z;
  357. if (cam_factor > 0.f)
  358. {
  359. vec2 new_screen_scale = m_camera->GetScreenScale();
  360. m_camera->SetScreenScale(max(vec2(0.001f), new_screen_scale * ((1.0f + m_zoom_mesh) / (scale_ratio * SCREEN_LIMIT))));
  361. m_camera->SetPosition(vec3(vec2::zero, damp(m_camera->m_position.z, z_pos + screen_ratio * 2.f, .1f, seconds)), true);
  362. m_camera->SetFov(m_fov_mesh);
  363. m_camera->SetScreenInfos(damp(m_camera->GetScreenSize(), max(1.f, screen_ratio), 1.2f, seconds));
  364. }
  365. //--
  366. //Message Service
  367. //--
  368. String mesh("");
  369. int u = 4;
  370. while (u-- > 0 && MessageService::FetchFirst(MessageBucket::AppIn, mesh))
  371. {
  372. int o = 1;
  373. while (o-- > 0)
  374. {
  375. SceneSetup* new_ssetup = new SceneSetup();
  376. if (new_ssetup->Compile(mesh.C()))
  377. {
  378. delete(m_ssetup);
  379. m_ssetup = new_ssetup;
  380. m_ssetup->Startup();
  381. m_mat_prev = mat4(quat::fromeuler_xyz(vec3::zero));
  382. for (int i = 0; i < m_ssetup->m_custom_cmd.Count(); ++i)
  383. {
  384. if (m_ssetup->m_custom_cmd[i].m1 == "setmesh")
  385. {
  386. //Create a new mesh
  387. EasyMesh* em = new EasyMesh();
  388. if (em->Compile(m_ssetup->m_custom_cmd[i].m2.C()))
  389. {
  390. if (m_mesh_id == m_meshes.Count() - 1)
  391. m_mesh_id++;
  392. m_meshes.Push(em);
  393. }
  394. else
  395. delete(em);
  396. }
  397. }
  398. m_ssetup->m_custom_cmd.Empty();
  399. }
  400. }
  401. }
  402. #if NACL_EM
  403. if (m_stream_update_time > .0f)
  404. {
  405. m_stream_update_time = -1.f;
  406. MessageService::Send(MessageBucket::AppIn,
  407. " addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1) \
  408. addlight 0.0 position (8 2 6) color #ffff \
  409. custom setmesh \"[sc#f8f ab 1]\"");
  410. // MessageService::Send(MessageBucket::AppIn, "[sc#f8f ab 1]");
  411. // MessageService::Send(MessageBucket::AppIn, "[sc#f8f ab 1 splt 4 twy 90]");
  412. // MessageService::Send(MessageBucket::AppIn, "[sc#8ff afcb 1 1 1 0]");
  413. // MessageService::Send(MessageBucket::AppIn, "[sc#ff8 afcb 1 1 1 0]");
  414. }
  415. #elif WIN32
  416. //--
  417. //File management
  418. //--
  419. m_stream_update_time += seconds;
  420. if (m_stream_update_time > m_stream_update_timer)
  421. {
  422. m_stream_update_time = 0.f;
  423. File f;
  424. f.Open(m_file_name.C(), FileAccess::Read);
  425. String cmd = f.ReadString();
  426. f.Close();
  427. if (cmd.Count()
  428. && (!m_cmdlist.Count() || cmd != m_cmdlist.Last()))
  429. {
  430. m_cmdlist << cmd;
  431. /*
  432. cmd = String(" addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1) \
  433. addlight 0.0 position (8 2 6) color #ffff \
  434. custom setmesh \"") + cmd + "\"";
  435. */
  436. MessageService::Send(MessageBucket::AppIn, cmd);
  437. }
  438. }
  439. #endif //WINDOWS
  440. }
  441. virtual void TickDraw(float seconds)
  442. {
  443. WorldEntity::TickDraw(seconds);
  444. if (!m_init)
  445. return;
  446. //TODO : This should probably be "standard LoL behaviour"
  447. #if NO_NACL_EM
  448. {
  449. if (KeyReleased(KEY_F1))
  450. Video::SetDebugRenderMode(DebugRenderMode::Default);
  451. if (KeyReleased(KEY_F2))
  452. Video::SetDebugRenderMode(DebugRenderMode::Wireframe);
  453. if (KeyReleased(KEY_F3))
  454. Video::SetDebugRenderMode(DebugRenderMode::Lighting);
  455. if (KeyReleased(KEY_F4))
  456. Video::SetDebugRenderMode(DebugRenderMode::Normal);
  457. if (KeyReleased(KEY_F5))
  458. Video::SetDebugRenderMode(DebugRenderMode::UV);
  459. }
  460. #endif //NO_NACL_EM
  461. #if NO_NACL_EM
  462. if (!m_default_texture)
  463. {
  464. m_texture_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinymvtexture));
  465. m_texture_uni = m_texture_shader->GetUniformLocation("u_Texture");
  466. m_default_texture = Tiler::Register("data/test-texture.png", ivec2::zero, ivec2(0,1));
  467. }
  468. else if (m_texture && m_default_texture)
  469. m_texture_shader->SetUniform(m_texture_uni, m_default_texture->GetTexture(), 0);
  470. #endif //NO_NACL_EM
  471. g_renderer->SetClearColor(vec4(0.0f, 0.0f, 0.0f, 1.0f));
  472. vec3 x = vec3(1.f,0.f,0.f);
  473. vec3 y = vec3(0.f,1.f,0.f);
  474. for (int i = 0; i < m_meshes.Count(); i++)
  475. {
  476. {
  477. if (m_meshes[i]->GetMeshState() == MeshRender::NeedConvert)
  478. {
  479. #if WITH_TEXTURE
  480. m_meshes[i]->MeshConvert(new DefaultShaderData(((1 << VertexUsage::Position) | (1 << VertexUsage::Normal) |
  481. (1 << VertexUsage::Color) | (1 << VertexUsage::TexCoord)),
  482. m_texture_shader, true));
  483. #else
  484. m_meshes[i]->MeshConvert();
  485. #endif //WITH_TEXTURE
  486. }
  487. mat4 save_proj = m_camera->GetProjection();
  488. float j = -(float)(m_meshes.Count() - (i + 1)) + (-m_mesh_id1 + (float)(m_meshes.Count() - 1));
  489. if (m_mesh_id1 - m_render_max[0] > (float)i && m_mesh_id1 - m_render_max[1] < (float)i &&
  490. m_meshes[i]->GetMeshState() > MeshRender::NeedConvert)
  491. {
  492. float a_j = lol::abs(j);
  493. float i_trans = (a_j * a_j * m_hist_scale_mesh.x + a_j * m_hist_scale_mesh.x) * .5f;
  494. float i_scale = clamp(1.f - (m_hist_scale_mesh.y * (m_mesh_id1 - (float)i)), 0.f, 1.f);
  495. mat4 new_proj =
  496. //Y object Offset
  497. mat4::translate(x * m_screen_offset.x + y * m_screen_offset.y) *
  498. //Mesh Pos Offset
  499. mat4::translate((x * m_pos_mesh.x * RATIO_HW + y * m_pos_mesh.y) * 2.f * (1.f + .5f * m_zoom_mesh / SCREEN_LIMIT)) *
  500. //Mesh count offset
  501. mat4::translate(x * RATIO_HW * 2.f * (j + i_trans)) *
  502. //Align right meshes
  503. mat4::translate(x - x * RATIO_HW) *
  504. //Mesh count scale
  505. mat4::scale(vec3(vec2(i_scale), 1.f)) *
  506. //Camera projection
  507. save_proj;
  508. m_camera->SetProjection(new_proj);
  509. //#if NO_NACL_EM
  510. m_meshes[i]->Render(m_mat);
  511. //#endif //NO_NACL_EM
  512. g_renderer->Clear(ClearMask::Depth);
  513. }
  514. m_camera->SetProjection(save_proj);
  515. }
  516. }
  517. }
  518. private:
  519. SceneSetup* m_ssetup;
  520. short m_input_usage;
  521. Controller* m_controller;
  522. mat4 m_mat;
  523. mat4 m_mat_prev;
  524. bool m_init;
  525. //Camera Setup
  526. Camera * m_camera;
  527. float m_reset_timer;
  528. float m_fov;
  529. float m_fov_mesh;
  530. float m_fov_speed;
  531. float m_zoom;
  532. float m_zoom_mesh;
  533. float m_zoom_speed;
  534. vec2 m_rot;
  535. vec2 m_rot_mesh;
  536. vec2 m_rot_speed;
  537. vec2 m_pos;
  538. vec2 m_pos_mesh;
  539. vec2 m_pos_speed;
  540. vec2 m_hist_scale;
  541. vec2 m_hist_scale_mesh;
  542. vec2 m_hist_scale_speed;
  543. vec2 m_screen_offset;
  544. //Mesh infos
  545. vec2 m_render_max;
  546. int m_mesh_id;
  547. float m_mesh_id1;
  548. Array<EasyMesh*> m_meshes;
  549. //File data
  550. String m_file_name;
  551. Array<String> m_cmdlist;
  552. float m_stream_update_time;
  553. float m_stream_update_timer;
  554. //misc datas
  555. Shader * m_texture_shader;
  556. TileSet * m_default_texture;
  557. Texture * m_texture;
  558. ShaderUniform m_texture_uni;
  559. Image * m_image;
  560. };
  561. //The basic main :
  562. int main(int argc, char **argv)
  563. {
  564. System::Init(argc, argv);
  565. Application app("MeshViewer", ivec2((int)DEFAULT_WIDTH, (int)DEFAULT_HEIGHT), 60.0f);
  566. if (argc > 1)
  567. new MeshViewer(argv[1]);
  568. else
  569. new MeshViewer();
  570. app.Run();
  571. return EXIT_SUCCESS;
  572. }