No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.

meshviewer.cpp 22 KiB

hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
hace 11 años
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644
  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. bool KeyReleased(MVKeyboardList index) { return (HAS_KBOARD && m_controller->GetKey(index).IsReleased()); }
  112. bool KeyPressed(MVKeyboardList index) { return (HAS_KBOARD && m_controller->GetKey(index).IsPressed()); }
  113. bool KeyDown(MVKeyboardList index) { return (HAS_KBOARD && m_controller->GetKey(index).IsDown()); }
  114. bool KeyReleased(MVMouseKeyList index) { return (HAS_MOUSE && m_controller->GetKey(index).IsReleased()); }
  115. bool KeyPressed(MVMouseKeyList index) { return (HAS_MOUSE && m_controller->GetKey(index).IsPressed()); }
  116. bool KeyDown(MVMouseKeyList index) { return (HAS_MOUSE && m_controller->GetKey(index).IsDown()); }
  117. float AxisValue(MVMouseAxisList index) { return (HAS_MOUSE)?(m_controller->GetAxis(index).GetValue()):(0.f); }
  118. void Init()
  119. {
  120. m_init = true;
  121. m_input_usage = 0;
  122. #if NO_NACL_EM
  123. /* Register an input controller for the keyboard */
  124. m_controller = new Controller("Default", MAX_KEYS, MAX_AXIS);
  125. if (InputDevice::Get("Mouse"))
  126. {
  127. m_input_usage |= (1<<IPT_MV_MOUSE);
  128. m_controller->GetKey(MSE_CAM_ROT).Bind("Mouse", "Left");
  129. m_controller->GetKey(MSE_CAM_POS).Bind("Mouse", "Right");
  130. m_controller->GetKey(MSE_CAM_FOV).Bind("Mouse", "Middle");
  131. m_controller->GetAxis(MSEX_CAM_Y).Bind("Mouse", "Y");
  132. m_controller->GetAxis(MSEX_CAM_X).Bind("Mouse", "X");
  133. }
  134. if (InputDevice::Get("Keyboard"))
  135. {
  136. m_input_usage |= (1<<IPT_MV_KBOARD);
  137. //Camera keyboard rotation
  138. m_controller->GetKey(KEY_CAM_UP ).Bind("Keyboard", "Up");
  139. m_controller->GetKey(KEY_CAM_DOWN ).Bind("Keyboard", "Down");
  140. m_controller->GetKey(KEY_CAM_LEFT ).Bind("Keyboard", "Left");
  141. m_controller->GetKey(KEY_CAM_RIGHT).Bind("Keyboard", "Right");
  142. //Camera keyboard position switch
  143. m_controller->GetKey(KEY_CAM_POS ).Bind("Keyboard", "LeftShift");
  144. m_controller->GetKey(KEY_CAM_FOV ).Bind("Keyboard", "LeftCtrl");
  145. //Camera unzoom switch
  146. m_controller->GetKey(KEY_CAM_RESET).Bind("Keyboard", "Space");
  147. //Mesh change
  148. m_controller->GetKey(KEY_MESH_NEXT).Bind("Keyboard", "PageUp");
  149. m_controller->GetKey(KEY_MESH_PREV).Bind("Keyboard", "PageDown");
  150. //Base setup
  151. m_controller->GetKey(KEY_F1).Bind("Keyboard", "F1");
  152. m_controller->GetKey(KEY_F2).Bind("Keyboard", "F2");
  153. m_controller->GetKey(KEY_F3).Bind("Keyboard", "F3");
  154. m_controller->GetKey(KEY_F4).Bind("Keyboard", "F4");
  155. m_controller->GetKey(KEY_F5).Bind("Keyboard", "F5");
  156. m_controller->GetKey(KEY_ESC).Bind("Keyboard", "Escape");
  157. }
  158. #endif //NO_NACL_EM
  159. // Message Service
  160. MessageService::Setup();
  161. // Mesh Setup
  162. m_render_max = vec2(-.9f, 6.1f);
  163. m_mesh_id = 0;
  164. m_mesh_id1 = 0.f;
  165. m_default_texture = NULL;
  166. //Camera Setup
  167. m_reset_timer = -1.f;
  168. m_fov = -100.f;
  169. m_fov_mesh = 0.f;
  170. m_fov_speed = 0.f;
  171. m_zoom = -100.f;
  172. m_zoom_mesh = 0.f;
  173. m_zoom_speed = 0.f;
  174. m_rot = vec2(45.f);
  175. m_rot_mesh = vec2::zero;
  176. m_rot_speed = vec2::zero;
  177. m_pos = vec2::zero;
  178. m_pos_mesh = vec2::zero;
  179. m_pos_speed = vec2::zero;
  180. m_screen_offset = vec2::zero;
  181. m_hist_scale = vec2(.13f, .03f);
  182. m_hist_scale_mesh = vec2(.0f);
  183. m_hist_scale_speed = vec2(.0f);
  184. m_camera = new Camera();
  185. m_camera->SetView(vec3(0.f, 0.f, 10.f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f));
  186. m_camera->SetProjection(0.f, .0001f, 2000.f, WIDTH * SCREEN_W, RATIO_HW);
  187. m_camera->UseShift(true);
  188. g_scene->PushCamera(m_camera);
  189. //Lights setup
  190. m_ssetup = new SceneSetup();
  191. m_ssetup->Compile(" addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1)"
  192. " addlight 0.0 position (8 2 6) color #ffff"
  193. " custom setmesh \"sc#fff ab 1\"");
  194. m_ssetup->Startup();
  195. //stream update
  196. m_stream_update_time = 2.0f;
  197. m_stream_update_timer = 1.0f;
  198. }
  199. virtual void TickGame(float seconds)
  200. {
  201. WorldEntity::TickGame(seconds);
  202. if (!m_init && g_scene)
  203. {
  204. Init();
  205. return;
  206. }
  207. if (!m_init)
  208. return;
  209. //TODO : This should probably be "standard LoL behaviour"
  210. #if NO_NACL_EM
  211. {
  212. //Shutdown logic
  213. if (KeyReleased(KEY_ESC))
  214. Ticker::Shutdown();
  215. }
  216. #endif //NO_NACL_EM
  217. //Mesh Change
  218. #if NO_NACL_EM
  219. m_mesh_id = clamp(m_mesh_id + ((int)KeyPressed(KEY_MESH_PREV) - (int)KeyPressed(KEY_MESH_NEXT)), 0, m_meshes.Count() - 1);
  220. #endif //NO_NACL_EM
  221. m_mesh_id1 = damp(m_mesh_id1, (float)m_mesh_id, .2f, seconds);
  222. //Camera update
  223. bool is_pos = false;
  224. bool is_fov = false;
  225. bool is_hsc = false;
  226. vec2 tmp = vec2::zero;
  227. #if NO_NACL_EM
  228. is_pos = KeyDown(KEY_CAM_POS) || KeyDown(MSE_CAM_POS);
  229. is_fov = KeyDown(KEY_CAM_FOV) || KeyDown(MSE_CAM_FOV);
  230. if (KeyDown(MSE_CAM_ROT) || KeyDown(MSE_CAM_POS) || KeyDown(MSE_CAM_FOV))
  231. {
  232. tmp += vec2(AxisValue(MSEX_CAM_Y), AxisValue(MSEX_CAM_X));
  233. if (KeyDown(MSE_CAM_ROT))
  234. tmp *= 6.f;
  235. if (KeyDown(MSE_CAM_POS))
  236. tmp *= vec2(1.f, -1.f) * 3.f;
  237. if (KeyDown(MSE_CAM_FOV))
  238. tmp = vec2(tmp.y * 4.f, tmp.x * 6.f);
  239. }
  240. tmp += vec2((float)KeyDown(KEY_CAM_UP ) - (float)KeyDown(KEY_CAM_DOWN),
  241. (float)KeyDown(KEY_CAM_RIGHT) - (float)KeyDown(KEY_CAM_LEFT));
  242. #endif //NO_NACL_EM
  243. //Base data
  244. vec2 rot = (!is_pos && !is_fov)?(tmp):(vec2(.0f)); rot = vec2(rot.x, rot.y);
  245. vec2 pos = ( is_pos && !is_fov)?(tmp):(vec2(.0f)); pos = -vec2(pos.y, pos.x);
  246. vec2 fov = (!is_pos && is_fov )?(tmp):(vec2(.0f)); fov = vec2(-fov.x, fov.y);
  247. vec2 hsc = (is_hsc)?(vec2(0.f)):(vec2(0.f));
  248. //speed
  249. m_rot_speed = damp(m_rot_speed, rot * ROT_SPEED, .2f, seconds);
  250. float pos_factor = 1.f / (1.f + m_zoom_mesh * .5f);
  251. m_pos_speed = damp(m_pos_speed, pos * POS_SPEED * pos_factor, .2f, seconds);
  252. float fov_factor = 1.f + lol::pow((m_fov_mesh / FOV_CLAMP) * 1.f, 2.f);
  253. m_fov_speed = damp(m_fov_speed, fov.x * FOV_SPEED * fov_factor, .2f, seconds);
  254. float zom_factor = 1.f + lol::pow((m_zoom_mesh / ZOM_CLAMP) * 1.f, 2.f);
  255. m_zoom_speed = damp(m_zoom_speed, fov.y * ZOM_SPEED * zom_factor, .2f, seconds);
  256. m_hist_scale_speed = damp(m_hist_scale_speed, hsc * HST_SPEED, .2f, seconds);
  257. m_rot += m_rot_speed * seconds;
  258. #if NO_NACL_EM
  259. if (m_reset_timer >= 0.f)
  260. m_reset_timer -= seconds;
  261. if (KeyPressed(KEY_CAM_RESET))
  262. {
  263. if (m_reset_timer >= 0.f)
  264. {
  265. m_pos = vec2(0.f);
  266. m_zoom = -100.f;
  267. }
  268. else
  269. m_reset_timer = RESET_TIMER;
  270. }
  271. //Transform update
  272. if (!KeyDown(KEY_CAM_RESET))
  273. {
  274. m_pos += m_pos_speed * seconds;
  275. m_fov += m_fov_speed * seconds;
  276. m_zoom += m_zoom_speed * seconds;
  277. m_hist_scale += m_hist_scale_speed * seconds;
  278. }
  279. #endif //NO_NACL_EM
  280. //clamp
  281. vec2 rot_mesh = vec2(SmoothClamp(m_rot.x, -ROT_CLAMP, ROT_CLAMP, ROT_CLAMP * .1f), m_rot.y);
  282. vec2 pos_mesh = vec2(SmoothClamp(m_pos.x, -POS_CLAMP, POS_CLAMP, POS_CLAMP * .1f),
  283. SmoothClamp(m_pos.y, -POS_CLAMP, POS_CLAMP, POS_CLAMP * .1f));
  284. float fov_mesh = SmoothClamp(m_fov, 0.f, FOV_CLAMP, FOV_CLAMP * .1f);
  285. float zoom_mesh = SmoothClamp(m_zoom, 0.f, ZOM_CLAMP, ZOM_CLAMP * .1f);
  286. vec2 hist_scale_mesh = vec2(SmoothClamp(m_hist_scale.x, 0.f, HST_CLAMP, HST_CLAMP * .1f),
  287. SmoothClamp(m_hist_scale.y, 0.f, HST_CLAMP, HST_CLAMP * .1f));
  288. #if NO_NACL_EM
  289. if (KeyDown(KEY_CAM_RESET) && m_reset_timer < 0.f)
  290. {
  291. pos_mesh = vec2::zero;
  292. zoom_mesh = 0.f;
  293. }
  294. #endif //NO_NACL_EM
  295. m_rot_mesh = vec2(damp(m_rot_mesh.x, rot_mesh.x, .2f, seconds), damp(m_rot_mesh.y, rot_mesh.y, .2f, seconds));
  296. m_pos_mesh = vec2(damp(m_pos_mesh.x, pos_mesh.x, .2f, seconds), damp(m_pos_mesh.y, pos_mesh.y, .2f, seconds));
  297. m_fov_mesh = damp(m_fov_mesh, fov_mesh, .2f, seconds);
  298. m_zoom_mesh = damp(m_zoom_mesh, zoom_mesh, .2f, seconds);
  299. m_hist_scale_mesh = damp(m_hist_scale_mesh, hist_scale_mesh, .2f, seconds);
  300. //Mesh mat calculation
  301. m_mat = mat4(quat::fromeuler_xyz(vec3(m_rot_mesh, .0f)));
  302. //Target List Setup
  303. Array<vec3> target_list;
  304. if (m_meshes.Count() && m_mesh_id >= 0)
  305. for (int i = 0; i < m_meshes[m_mesh_id]->GetVertexCount(); i++)
  306. target_list << (m_mat * mat4::translate(m_meshes[m_mesh_id]->GetVertexLocation(i))).v3.xyz;
  307. //--
  308. //Update mesh screen location - Get the Min/Max needed
  309. //--
  310. vec2 cam_center(0.f);
  311. float cam_factor = .0f;
  312. vec3 local_min_max[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
  313. vec2 screen_min_max[2] = { vec2(FLT_MAX), vec2(-FLT_MAX) };
  314. mat4 world_cam = m_camera->GetView();
  315. mat4 cam_screen = m_camera->GetProjection();
  316. //target on-screen computation
  317. for (int i = 0; i < target_list.Count(); i++)
  318. {
  319. vec3 obj_loc = target_list[i];
  320. {
  321. //Debug::DrawBox(obj_loc - vec3(4.f), obj_loc + vec3(4.f), vec4(1.f, 0.f, 0.f, 1.f));
  322. mat4 target_mx = mat4::translate(obj_loc);
  323. vec3 vpos;
  324. //Get location in cam coordinates
  325. target_mx = world_cam * target_mx;
  326. vpos = target_mx.v3.xyz;
  327. local_min_max[0] = min(vpos.xyz, local_min_max[0]);
  328. local_min_max[1] = max(vpos.xyz, local_min_max[1]);
  329. //Get location in screen coordinates
  330. target_mx = cam_screen * target_mx;
  331. vpos = (target_mx.v3 / target_mx.v3.w).xyz;
  332. screen_min_max[0] = min(screen_min_max[0], vpos.xy * vec2(RATIO_WH, 1.f));
  333. screen_min_max[1] = max(screen_min_max[1], vpos.xy * vec2(RATIO_WH, 1.f));
  334. //Build Barycenter
  335. cam_center += vpos.xy;
  336. cam_factor += 1.f;
  337. }
  338. }
  339. float screen_ratio = max(max(lol::abs(local_min_max[0].x), lol::abs(local_min_max[0].y)),
  340. max(lol::abs(local_min_max[1].x), lol::abs(local_min_max[1].y)));
  341. float scale_ratio = max(max(lol::abs(screen_min_max[0].x), lol::abs(screen_min_max[0].y)),
  342. max(lol::abs(screen_min_max[1].x), lol::abs(screen_min_max[1].y)));
  343. vec2 screen_offset = vec2(0.f, -(screen_min_max[1].y + screen_min_max[0].y) * .5f);
  344. m_screen_offset = damp(m_screen_offset, screen_offset, .9f, seconds);
  345. 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;
  346. if (cam_factor > 0.f)
  347. {
  348. vec2 new_screen_scale = m_camera->GetScreenScale();
  349. m_camera->SetScreenScale(max(vec2(0.001f), new_screen_scale * ((1.0f + m_zoom_mesh) / (scale_ratio * SCREEN_LIMIT))));
  350. m_camera->m_position.z = damp(m_camera->m_position.z, z_pos + screen_ratio * 2.f, .1f, seconds);
  351. m_camera->SetFov(m_fov_mesh);
  352. m_camera->SetScreenInfos(damp(m_camera->GetScreenSize(), max(1.f, screen_ratio), 1.2f, seconds));
  353. }
  354. //--
  355. //Message Service
  356. //--
  357. String mesh("");
  358. int u = 4;
  359. while (u-- > 0 && MessageService::FetchFirst(MessageBucket::AppIn, mesh))
  360. {
  361. int o = 1;
  362. while (o-- > 0)
  363. {
  364. SceneSetup* new_ssetup = new SceneSetup();
  365. if (new_ssetup->Compile(mesh.C()))
  366. {
  367. delete(m_ssetup);
  368. m_ssetup = new_ssetup;
  369. m_ssetup->Startup();
  370. for (int i = 0; i < m_ssetup->m_custom_cmd.Count(); ++i)
  371. {
  372. if (m_ssetup->m_custom_cmd[i].m1 == "setmesh")
  373. {
  374. //Create a new mesh
  375. EasyMesh* em = new EasyMesh();
  376. if (em->Compile(m_ssetup->m_custom_cmd[i].m2.C()))
  377. {
  378. if (m_mesh_id == m_meshes.Count() - 1)
  379. m_mesh_id++;
  380. m_meshes.Push(em);
  381. }
  382. else
  383. delete(em);
  384. }
  385. }
  386. m_ssetup->m_custom_cmd.Empty();
  387. }
  388. }
  389. }
  390. #if NACL_EM
  391. if (m_stream_update_time > .0f)
  392. {
  393. m_stream_update_time = -1.f;
  394. // MessageService::Send(MessageBucket::AppIn, "[sc#f8f ab 1]");
  395. // MessageService::Send(MessageBucket::AppIn, "[sc#f8f ab 1 splt 4 twy 90]");
  396. // MessageService::Send(MessageBucket::AppIn, "[sc#8ff afcb 1 1 1 0]");
  397. // MessageService::Send(MessageBucket::AppIn, "[sc#ff8 afcb 1 1 1 0]");
  398. }
  399. #elif WIN32
  400. //--
  401. //File management
  402. //--
  403. m_stream_update_time += seconds;
  404. if (m_stream_update_time > m_stream_update_timer)
  405. {
  406. m_stream_update_time = 0.f;
  407. File f;
  408. f.Open(m_file_name.C(), FileAccess::Read);
  409. String cmd = f.ReadString();
  410. f.Close();
  411. if (cmd.Count()
  412. && (!m_cmdlist.Count() || cmd != m_cmdlist.Last()))
  413. {
  414. m_cmdlist << cmd;
  415. cmd = String(" addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1) \
  416. addlight 0.0 position (8 2 6) color #ffff \
  417. custom setmesh \"") + cmd + "\"";
  418. MessageService::Send(MessageBucket::AppIn, cmd);
  419. }
  420. }
  421. #endif //WINDOWS
  422. }
  423. virtual void TickDraw(float seconds)
  424. {
  425. WorldEntity::TickDraw(seconds);
  426. if (!m_init)
  427. return;
  428. //TODO : This should probably be "standard LoL behaviour"
  429. #if NO_NACL_EM
  430. {
  431. if (KeyReleased(KEY_F1))
  432. Video::SetDebugRenderMode(DebugRenderMode::Default);
  433. if (KeyReleased(KEY_F2))
  434. Video::SetDebugRenderMode(DebugRenderMode::Wireframe);
  435. if (KeyReleased(KEY_F3))
  436. Video::SetDebugRenderMode(DebugRenderMode::Lighting);
  437. if (KeyReleased(KEY_F4))
  438. Video::SetDebugRenderMode(DebugRenderMode::Normal);
  439. if (KeyReleased(KEY_F5))
  440. Video::SetDebugRenderMode(DebugRenderMode::UV);
  441. }
  442. #endif //NO_NACL_EM
  443. #if NO_NACL_EM
  444. if (!m_default_texture)
  445. {
  446. m_texture_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinymvtexture));
  447. m_texture_uni = m_texture_shader->GetUniformLocation("u_Texture");
  448. m_default_texture = Tiler::Register("data/test-texture.png", ivec2::zero, ivec2(0,1));
  449. }
  450. else if (m_texture && m_default_texture)
  451. m_texture_shader->SetUniform(m_texture_uni, m_default_texture->GetTexture(), 0);
  452. #endif //NO_NACL_EM
  453. g_renderer->SetClearColor(vec4(0.0f, 0.0f, 0.0f, 1.0f));
  454. vec3 x = vec3(1.f,0.f,0.f);
  455. vec3 y = vec3(0.f,1.f,0.f);
  456. for (int i = 0; i < m_meshes.Count(); i++)
  457. {
  458. {
  459. if (m_meshes[i]->GetMeshState() == MeshRender::NeedConvert)
  460. {
  461. #if WITH_TEXTURE
  462. m_meshes[i]->MeshConvert(new DefaultShaderData(((1 << VertexUsage::Position) | (1 << VertexUsage::Normal) |
  463. (1 << VertexUsage::Color) | (1 << VertexUsage::TexCoord)),
  464. m_texture_shader, true));
  465. #else
  466. m_meshes[i]->MeshConvert();
  467. #endif //WITH_TEXTURE
  468. }
  469. mat4 save_proj = m_camera->GetProjection();
  470. float j = -(float)(m_meshes.Count() - (i + 1)) + (-m_mesh_id1 + (float)(m_meshes.Count() - 1));
  471. if (m_mesh_id1 - m_render_max[0] > (float)i && m_mesh_id1 - m_render_max[1] < (float)i &&
  472. m_meshes[i]->GetMeshState() > MeshRender::NeedConvert)
  473. {
  474. float a_j = lol::abs(j);
  475. float i_trans = (a_j * a_j * m_hist_scale_mesh.x + a_j * m_hist_scale_mesh.x) * .5f;
  476. float i_scale = clamp(1.f - (m_hist_scale_mesh.y * (m_mesh_id1 - (float)i)), 0.f, 1.f);
  477. mat4 new_proj =
  478. //Y object Offset
  479. mat4::translate(x * m_screen_offset.x + y * m_screen_offset.y) *
  480. //Mesh Pos Offset
  481. mat4::translate((x * m_pos_mesh.x * RATIO_HW + y * m_pos_mesh.y) * 2.f * (1.f + .5f * m_zoom_mesh / SCREEN_LIMIT)) *
  482. //Mesh count offset
  483. mat4::translate(x * RATIO_HW * 2.f * (j + i_trans)) *
  484. //Align right meshes
  485. mat4::translate(x - x * RATIO_HW) *
  486. //Mesh count scale
  487. mat4::scale(vec3(vec2(i_scale), 1.f)) *
  488. //Camera projection
  489. save_proj;
  490. m_camera->SetProjection(new_proj);
  491. //#if NO_NACL_EM
  492. m_meshes[i]->Render(m_mat);
  493. //#endif //NO_NACL_EM
  494. g_renderer->Clear(ClearMask::Depth);
  495. }
  496. m_camera->SetProjection(save_proj);
  497. }
  498. }
  499. }
  500. private:
  501. SceneSetup* m_ssetup;
  502. byte m_input_usage;
  503. Controller* m_controller;
  504. mat4 m_mat;
  505. bool m_init;
  506. //Camera Setup
  507. Camera * m_camera;
  508. float m_reset_timer;
  509. float m_fov;
  510. float m_fov_mesh;
  511. float m_fov_speed;
  512. float m_zoom;
  513. float m_zoom_mesh;
  514. float m_zoom_speed;
  515. vec2 m_rot;
  516. vec2 m_rot_mesh;
  517. vec2 m_rot_speed;
  518. vec2 m_pos;
  519. vec2 m_pos_mesh;
  520. vec2 m_pos_speed;
  521. vec2 m_hist_scale;
  522. vec2 m_hist_scale_mesh;
  523. vec2 m_hist_scale_speed;
  524. vec2 m_screen_offset;
  525. //Mesh infos
  526. vec2 m_render_max;
  527. int m_mesh_id;
  528. float m_mesh_id1;
  529. Array<EasyMesh*> m_meshes;
  530. //File data
  531. String m_file_name;
  532. Array<String> m_cmdlist;
  533. float m_stream_update_time;
  534. float m_stream_update_timer;
  535. //misc datas
  536. Shader * m_texture_shader;
  537. TileSet * m_default_texture;
  538. Texture * m_texture;
  539. ShaderUniform m_texture_uni;
  540. Image * m_image;
  541. };
  542. //The basic main :
  543. int main(int argc, char **argv)
  544. {
  545. System::Init(argc, argv);
  546. Application app("MeshViewer", ivec2((int)DEFAULT_WIDTH, (int)DEFAULT_HEIGHT), 60.0f);
  547. if (argc > 1)
  548. new MeshViewer(argv[1]);
  549. else
  550. new MeshViewer();
  551. app.Run();
  552. return EXIT_SUCCESS;
  553. }