lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
2011 Commits
5 Branches
18 MiB
 
 
 
Tree: 21d90c7c22
lol/test/meshviewer.cpp

1018 lines
38 KiB
Raw Blame History 

  1. 

  2. //

  3. // Lol Engine - EasyMesh tutorial

  4. //

  5. // Copyright: (c) 2011-2013 Sam Hocevar <sam@hocevar.net>

  6. //            (c) 2012-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>

  7. //   This program is free software; you can redistribute it and/or

  8. //   modify it under the terms of the Do What The Fuck You Want To

  9. //   Public License, Version 2, as published by Sam Hocevar. See

  10. //   http://www.wtfpl.net/ for more details.

  11. //

  12. 

  13. #if defined HAVE_CONFIG_H

  14. #   include "config.h"

  15. #endif

  16. 

  17. #include <cfloat> /* for FLT_MAX */

  18. 

  19. #include "core.h"

  20. #include "scenesetup.h"

  21. 

  22. using namespace std;

  23. using namespace lol;

  24. 

  25. static int const TEXTURE_WIDTH = 256;

  26. 

  27. #define     NO_NACL_EM          (!__native_client__ && !EMSCRIPTEN)

  28. #define     NACL_EM             (__native_client__ || EMSCRIPTEN)

  29. #define     NO_NACL_EM_INPUT    (1)

  30. 

  31. #define     R_M                 1.f

  32. #if NACL_EM

  33. #define     DEFAULT_WIDTH       (800.f * R_M)

  34. #define     DEFAULT_HEIGHT      (400.f * R_M)

  35. #else

  36. #define     DEFAULT_WIDTH       (1200.f * R_M)

  37. #define     DEFAULT_HEIGHT      (400.f * R_M)

  38. #endif //NACL_EM

  39. #define     WIDTH               ((float)Video::GetSize().x)

  40. #define     HEIGHT              ((float)Video::GetSize().y)

  41. #define     SCREEN_W            (10.f / WIDTH)

  42. #define     RATIO_HW            (HEIGHT / WIDTH)

  43. #define     RATIO_WH            (WIDTH / HEIGHT)

  44. #define     SCREEN_LIMIT        1.4f

  45. 

  46. #define     RESET_TIMER         .2f

  47. #define     ROT_SPEED           vec2(50.f)

  48. #define     ROT_CLAMP           89.f

  49. #define     POS_SPEED           vec2(1.2f)

  50. #define     POS_CLAMP           1.f

  51. #define     FOV_SPEED           20.f

  52. #define     FOV_CLAMP           120.f

  53. #define     ZOM_SPEED           3.f

  54. #define     ZOM_CLAMP           20.f

  55. #define     HST_SPEED           .5f

  56. #define     HST_CLAMP           1.f

  57. 

  58. #define     WITH_TEXTURE        0

  59. 

  60. 

  61. #define     HAS_KBOARD          (m_input_usage & (1<<IPT_MV_KBOARD))

  62. #define     HAS_MOUSE           (m_input_usage & (1<<IPT_MV_MOUSE))

  63. 

  64. LOLFX_RESOURCE_DECLARE(shinyfur);

  65. LOLFX_RESOURCE_DECLARE(shinymvtexture);

  66. 

  67. enum

  68. {

  69.     IPT_MV_KBOARD = 0,

  70.     IPT_MV_MOUSE,

  71. 

  72.     INPUT_MAX

  73. };

  74. 

  75. enum MVKeyboardList

  76. {

  77.     KEY_CAM_RESET = 0,

  78.     KEY_CAM_POS,

  79.     KEY_CAM_FOV,

  80. 

  81.     KEY_CAM_UP,

  82.     KEY_CAM_DOWN,

  83.     KEY_CAM_LEFT,

  84.     KEY_CAM_RIGHT,

  85. 

  86.     KEY_MESH_NEXT,

  87.     KEY_MESH_PREV,

  88. 

  89.     KEY_F1,

  90.     KEY_F2,

  91.     KEY_F3,

  92.     KEY_F4,

  93.     KEY_F5,

  94.     KEY_ESC,

  95. 

  96.     KEY_MAX

  97. };

  98. 

  99. enum MVMouseKeyList

  100. {

  101.     MSE_CAM_ROT = KEY_MAX,

  102.     MSE_CAM_POS,

  103.     MSE_CAM_FOV,

  104.     MSE_FOCUS,

  105. 

  106.     MSE_MAX

  107. };

  108. 

  109. enum MVMouseAxisList

  110. {

  111.     MSEX_CAM_Y = 0,

  112.     MSEX_CAM_X,

  113. 

  114.     MSEX_MAX

  115. };

  116. 

  117. #define     MAX_KEYS        MSE_MAX

  118. #define     MAX_AXIS        MSEX_MAX

  119. #define     ALL_FEATURES    1

  120. #define     NO_SC_SETUP     0

  121. 

  122. enum GizmoType

  123. {

  124.     GZ_Editor = 0,

  125.     GZ_LightPos,

  126.     GZ_LightDir,

  127. 

  128.     GZ_MAX

  129. };

  130. 

  131. struct LightData

  132. {

  133.     LightData(vec3 pos, vec4 col)

  134.     {

  135.         m_pos = pos;

  136.         m_col = col;

  137.     }

  138. 

  139.     vec3 m_pos;

  140.     vec4 m_col;

  141. };

  142. 

  143. class TargetCamera

  144. {

  145. public:

  146.     void EmptyTargets()             { m_targets.Empty(); }

  147.     void AddTarget(vec3 new_target) { m_targets << new_target; }

  148.     //This considers the box usage A to B as top-left to bottom-right

  149.     void AddTarget(box3 new_target)

  150.     {

  151.         vec3 base_off = .5f * (new_target.B - new_target.A);

  152.         vec3 base_pos = new_target.A + base_off;

  153.         int pass = 0;

  154.         while (pass < 3)

  155.         {

  156.             int mask = 3 - max(0, pass - 1);

  157.             while (mask-- > 0)

  158.             {

  159.                 ivec3 A((pass == 1 || (pass == 2 && mask == 1))?(1):(0));

  160.                 ivec3 B((pass == 2)?(1):(0)); B[mask] = 1;

  161.                 vec3 offset = vec3(ivec3((int)(!A.x != !B.x), (int)(!A.y != !B.y), (int)(!A.z != !B.z)));

  162.                 AddTarget(base_pos + offset * base_off * 2.f - base_off);

  163.             }

  164.             pass++;

  165.         }

  166.     }

  167. 

  168.     Array<vec3>     m_targets;

  169. };

  170. 

  171. class MeshViewer : public WorldEntity

  172. {

  173. public:

  174.     MeshViewer(char const *file_name = "data/mesh-buffer.txt")

  175.       : m_file_name(file_name)

  176.     {

  177.         m_init = false;

  178.         m_first_tick = false;

  179. 

  180.         // Message Service

  181.         MessageService::Setup();

  182. 

  183.         m_ssetup = nullptr;

  184.         m_camera = nullptr;

  185.         m_controller = nullptr;

  186. 

  187.         //Compile ref meshes

  188.         m_gizmos << new EasyMesh();

  189.         m_gizmos.Last()->Compile("[sc#0f0 ac 3 .5 .4 0 ty .25 [ad 3 .4 sy -1] ty .5 ac 3 1 .075 ty .5 dup[rz 90 ry 90 scv#00f dup[ry 90 scv#f00]]][sc#fff ab .1]");

  190.         m_gizmos << new EasyMesh();

  191.         m_gizmos.Last()->Compile("[sc#666 acap 1 .5 .5 ty -.5 sc#fff asph 2 1]");

  192.         m_gizmos << new EasyMesh();

  193.         m_gizmos.Last()->Compile("[sc#fff ac 3 .5 .4 0 ty .25 [ad 3 .4 sy -1] ty .5 ac 3 1 .1 ty .5 [ad 3 .1 sy -1] ty 1 rz 90 ry 90]");

  194. 

  195.         // Mesh Setup

  196.         m_render_max = vec2(-.9f, 4.1f);

  197.         m_mesh_render = 0;

  198.         m_mesh_id = 0;

  199.         m_mesh_id1 = 0.f;

  200.         m_default_texture = nullptr;

  201.         m_texture_shader = nullptr;

  202.         m_texture = nullptr;

  203. 

  204.         //Camera Setup

  205.         m_reset_timer = -1.f;

  206.         m_fov = -100.f;

  207.         m_fov_mesh = 0.f;

  208.         m_fov_speed = 0.f;

  209.         m_zoom = 0.f;

  210.         m_zoom_mesh = 0.f;

  211.         m_zoom_speed = 0.f;

  212.         m_rot = vec2(/*45.f*/0.f, -45.f);

  213.         m_rot_mesh = vec2::zero;

  214.         m_rot_speed = vec2::zero;

  215.         m_pos = vec2::zero;

  216.         m_pos_mesh = vec2::zero;

  217.         m_pos_speed = vec2::zero;

  218.         m_screen_offset = vec2::zero;

  219.         m_hist_scale = vec2(.13f, .03f);

  220.         m_hist_scale_mesh = vec2(.0f);

  221.         m_hist_scale_speed = vec2(.0f);

  222. 

  223.         m_mat_prev = mat4(quat::fromeuler_xyz(vec3::zero));

  224.         m_mat = mat4::translate(vec3(0.f));//mat4(quat::fromeuler_xyz(vec3(m_rot_mesh, .0f)));

  225. 

  226.         m_build_timer = 0.1f;

  227.         m_build_time = -1.f;

  228. 

  229.         //stream update

  230.         m_stream_update_time = 2.0f;

  231.         m_stream_update_timer = 1.0f;

  232.     }

  233. 

  234.     ~MeshViewer()

  235.     {

  236.         if (m_camera)

  237.             g_scene->PopCamera(m_camera);

  238.         if (m_ssetup)

  239.             delete(m_ssetup);

  240.         MessageService::Destroy();

  241. 

  242.         m_controller = nullptr;

  243.         m_camera = nullptr;

  244.         m_ssetup = nullptr;

  245.     }

  246. 

  247. #if NO_NACL_EM_INPUT

  248.     bool  KeyReleased(MVKeyboardList index) { return (HAS_KBOARD && m_controller->GetKey(index).IsReleased()); }

  249.     bool  KeyPressed(MVKeyboardList index)  { return (HAS_KBOARD && m_controller->GetKey(index).IsPressed()); }

  250.     bool  KeyDown(MVKeyboardList index)     { return (HAS_KBOARD && m_controller->GetKey(index).IsDown()); }

  251.     bool  KeyReleased(MVMouseKeyList index) { return (HAS_MOUSE  && m_controller->GetKey(index).IsReleased()); }

  252.     bool  KeyPressed(MVMouseKeyList index)  { return (HAS_MOUSE  && m_controller->GetKey(index).IsPressed()); }

  253.     bool  KeyDown(MVMouseKeyList index)     { return (HAS_MOUSE  && m_controller->GetKey(index).IsDown()); }

  254.     float AxisValue(MVMouseAxisList index)  { return (HAS_MOUSE)?(m_controller->GetAxis(index).GetValue()):(0.f); }

  255. #endif //NO_NACL_EM_INPUT

  256. 

  257.     void Init()

  258.     {

  259.         m_init = true;

  260.         m_input_usage = 0;

  261. 

  262. #if NO_NACL_EM_INPUT

  263.         /* Register an input controller for the keyboard */

  264.         m_controller = new Controller("Default", MAX_KEYS, MAX_AXIS);

  265. 

  266.         if (InputDevice::Get(g_name_mouse.C()))

  267.         {

  268.             m_input_usage |= (1<<IPT_MV_MOUSE);

  269. 

  270.             m_controller->GetKey(MSE_CAM_ROT).BindMouse("Left");

  271.             m_controller->GetKey(MSE_CAM_POS).BindMouse("Right");

  272.             m_controller->GetKey(MSE_CAM_FOV).BindMouse("Middle");

  273.             m_controller->GetKey(MSE_FOCUS).BindMouse("InScreen");

  274.             m_controller->GetAxis(MSEX_CAM_Y).BindMouse("Y");

  275.             m_controller->GetAxis(MSEX_CAM_X).BindMouse("X");

  276.         }

  277. 

  278.         if (InputDevice::Get(g_name_keyboard.C()))

  279.         {

  280.             m_input_usage |= (1<<IPT_MV_KBOARD);

  281. 

  282.             //Camera keyboard rotation

  283.             m_controller->GetKey(KEY_CAM_UP   ).BindKeyboard("Up");

  284.             m_controller->GetKey(KEY_CAM_DOWN ).BindKeyboard("Down");

  285.             m_controller->GetKey(KEY_CAM_LEFT ).BindKeyboard("Left");

  286.             m_controller->GetKey(KEY_CAM_RIGHT).BindKeyboard("Right");

  287. 

  288.             //Camera keyboard position switch

  289.             m_controller->GetKey(KEY_CAM_POS  ).BindKeyboard("LeftShift");

  290.             m_controller->GetKey(KEY_CAM_FOV  ).BindKeyboard("LeftCtrl");

  291. 

  292.             //Camera unzoom switch

  293.             m_controller->GetKey(KEY_CAM_RESET).BindKeyboard("Space");

  294. 

  295.             //Mesh change

  296.             m_controller->GetKey(KEY_MESH_NEXT).BindKeyboard("PageUp");

  297.             m_controller->GetKey(KEY_MESH_PREV).BindKeyboard("PageDown");

  298. 

  299.             //Base setup

  300.             m_controller->GetKey(KEY_F1).BindKeyboard("F1");

  301.             m_controller->GetKey(KEY_F2).BindKeyboard("F2");

  302.             m_controller->GetKey(KEY_F3).BindKeyboard("F3");

  303.             m_controller->GetKey(KEY_F4).BindKeyboard("F4");

  304.             m_controller->GetKey(KEY_F5).BindKeyboard("F5");

  305.             m_controller->GetKey(KEY_ESC).BindKeyboard("Escape");

  306.         }

  307. #endif //NO_NACL_EM_INPUT

  308. 

  309. 

  310.         m_camera = new Camera();

  311.         m_camera->SetView(vec3(0.f, 0.f, 10.f), vec3::zero, vec3::axis_y);

  312.         m_camera->SetProjection(0.f, .0001f, 2000.f, WIDTH * SCREEN_W, RATIO_HW);

  313.         m_camera->UseShift(true);

  314.         g_scene->PushCamera(m_camera);

  315. 

  316.         //Lights setup

  317.         m_ssetup = new SceneSetup();

  318. #if NO_SC_SETUP

  319.         m_ssetup->m_lights << new Light();

  320.         m_ssetup->m_lights.Last()->SetPosition(vec4(4.f, -1.f, -4.f, 0.f));

  321.         m_ssetup->m_lights.Last()->SetColor(vec4(.0f, .2f, .5f, 1.f));

  322.         Ticker::Ref(m_ssetup->m_lights.Last());

  323.         m_ssetup->m_lights << new Light();

  324.         m_ssetup->m_lights.Last()->SetPosition(vec4(8.f, 2.f, 6.f, 0.f));

  325.         m_ssetup->m_lights.Last()->SetColor(vec4(1.f));

  326.         Ticker::Ref(m_ssetup->m_lights.Last());

  327.         EasyMesh* em = new EasyMesh();

  328.         if (em->Compile("sc#fff ab 1"))

  329.         {

  330.             if (m_mesh_id == m_meshes.Count() - 1)

  331.                 m_mesh_id++;

  332.             m_meshes.Push(em, nullptr);

  333.         }

  334. #else

  335.         m_ssetup->Compile("addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1) "

  336.                           "addlight 0.0 position (8 2 6) color #ffff "

  337.                           "showgizmo true ");

  338.         m_ssetup->Startup();

  339. #endif //NO_SC_SETUP

  340.         for (int i = 0; i < m_ssetup->m_lights.Count(); ++i)

  341.         {

  342.             m_light_datas << LightData(m_ssetup->m_lights[i]->GetPosition().xyz, m_ssetup->m_lights[i]->GetColor());

  343.             m_ssetup->m_lights[i]->SetPosition(vec3::zero);

  344.             m_ssetup->m_lights[i]->SetColor(vec4::zero);

  345.         }

  346.     }

  347. 

  348.     virtual void TickGame(float seconds)

  349.     {

  350.         WorldEntity::TickGame(seconds);

  351. 

  352.         if (!m_init && g_scene)

  353.         {

  354.             Init();

  355.             return;

  356.         }

  357. 

  358.         if (!m_init)

  359.             return;

  360. 

  361.         m_first_tick = true;

  362. 

  363.         //TODO : This should probably be "standard LoL behaviour"

  364. #if NO_NACL_EM_INPUT

  365.         {

  366.             //Shutdown logic

  367.             if (KeyReleased(KEY_ESC))

  368.                 Ticker::Shutdown();

  369.         }

  370. #endif //NO_NACL_EM_INPUT

  371. 

  372.         //Compute render mesh count

  373.         float a_j = lol::abs(m_render_max[1]);

  374.         float i_m = m_hist_scale_mesh.x;

  375.         float i_trans = a_j - ((a_j * a_j * i_m * i_m + a_j * i_m) * .5f);

  376.         m_render_max[1] = a_j * ((RATIO_WH * 1.f) / ((i_trans != 0.f)?(i_trans):(RATIO_WH))) - RATIO_HW * .3f;

  377. 

  378.         //Mesh Change

  379. #if NO_NACL_EM_INPUT

  380.         m_mesh_id = clamp(m_mesh_id + ((int)KeyPressed(KEY_MESH_PREV) - (int)KeyPressed(KEY_MESH_NEXT)), 0, m_meshes.Count() - 1);

  381. #endif //NO_NACL_EM_INPUT

  382.         m_mesh_id1 = damp(m_mesh_id1, (float)m_mesh_id, .2f, seconds);

  383. 

  384. #if ALL_FEATURES

  385. 

  386.         //Update light position & damping

  387.         for (int i = 0; i < m_ssetup->m_lights.Count(); ++i)

  388.         {

  389.             vec3 pos = (m_mat * inverse(m_mat_prev) * vec4(m_ssetup->m_lights[i]->GetPosition(), 1.f)).xyz;

  390.             vec3 tgt = (m_mat * vec4(m_light_datas[i].m_pos, 1.f)).xyz;

  391. 

  392.             vec3 new_pos = damp(pos, tgt, .3f, seconds);

  393.             vec4 new_col = damp(m_ssetup->m_lights[i]->GetColor(), m_light_datas[i].m_col, .3f, seconds);

  394. 

  395.             m_ssetup->m_lights[i]->SetPosition(new_pos);

  396.             m_ssetup->m_lights[i]->SetColor(new_col);

  397.         }

  398. 

  399.         //Camera update

  400.         bool is_pos = false;

  401.         bool is_fov = false;

  402.         bool is_hsc = false;

  403.         vec2 tmpv = vec2::zero;

  404. 

  405. #if NO_NACL_EM_INPUT

  406.         is_pos = KeyDown(KEY_CAM_POS) || KeyDown(MSE_CAM_POS);

  407.         is_fov = KeyDown(KEY_CAM_FOV) || KeyDown(MSE_CAM_FOV);

  408. 

  409.         if (KeyDown(MSE_FOCUS) && (KeyDown(MSE_CAM_ROT) || KeyDown(MSE_CAM_POS) || KeyDown(MSE_CAM_FOV)))

  410.         {

  411.             tmpv += vec2(AxisValue(MSEX_CAM_Y), AxisValue(MSEX_CAM_X));

  412.             if (KeyDown(MSE_CAM_ROT))

  413.                 tmpv *= vec2(1.f, 1.f) * 6.f;

  414.             if (KeyDown(MSE_CAM_POS))

  415.                 tmpv *= vec2(1.f, -1.f) * 3.f;

  416.             if (KeyDown(MSE_CAM_FOV))

  417.                 tmpv = vec2(tmpv.y * 4.f, tmpv.x * 6.f);

  418.         }

  419. 

  420.         tmpv += vec2((float)KeyDown(KEY_CAM_UP   ) - (float)KeyDown(KEY_CAM_DOWN),

  421.                      (float)KeyDown(KEY_CAM_RIGHT) - (float)KeyDown(KEY_CAM_LEFT));

  422. #endif //NO_NACL_EM_INPUT

  423. 

  424.         //Base data

  425.         vec2 rot = (!is_pos && !is_fov)?(tmpv):(vec2(.0f)); rot = vec2(rot.x, -rot.y);

  426.         vec2 pos = ( is_pos && !is_fov)?(tmpv):(vec2(.0f)); pos = -vec2(pos.y, pos.x);

  427.         vec2 fov = (!is_pos && is_fov )?(tmpv):(vec2(.0f)); fov = vec2(-fov.x, fov.y);

  428.         vec2 hsc = (is_hsc)?(vec2(0.f)):(vec2(0.f));

  429. 

  430.         //speed

  431.         m_rot_speed = damp(m_rot_speed, rot * ROT_SPEED, .2f, seconds);

  432.         float pos_factor = 1.f / (1.f + m_zoom_mesh * .5f);

  433.         m_pos_speed = damp(m_pos_speed, pos * POS_SPEED * pos_factor, .2f, seconds);

  434.         float fov_factor = 1.f + lol::pow((m_fov_mesh / FOV_CLAMP) * 1.f, 2.f);

  435.         m_fov_speed = damp(m_fov_speed, fov.x * FOV_SPEED * fov_factor, .2f, seconds);

  436.         float zom_factor = 1.f + lol::pow((m_zoom_mesh / ZOM_CLAMP) * 1.f, 2.f);

  437.         m_zoom_speed = damp(m_zoom_speed, fov.y * ZOM_SPEED * zom_factor, .2f, seconds);

  438.         m_hist_scale_speed = damp(m_hist_scale_speed, hsc * HST_SPEED, .2f, seconds);

  439. 

  440.         m_rot += m_rot_speed * seconds;

  441. 

  442. #if NO_NACL_EM_INPUT

  443.         if (m_reset_timer >= 0.f)

  444.             m_reset_timer -= seconds;

  445.         if (KeyPressed(KEY_CAM_RESET))

  446.         {

  447.             if (m_reset_timer >= 0.f)

  448.             {

  449.                 m_pos = vec2(0.f);

  450.                 m_zoom = 0.f;

  451.             }

  452.             else

  453.                 m_reset_timer = RESET_TIMER;

  454.         }

  455. 

  456.         //Transform update

  457.         if (!KeyDown(KEY_CAM_RESET))

  458.         {

  459.             m_pos += m_pos_speed * seconds;

  460.             m_fov += m_fov_speed * seconds;

  461.             m_zoom += m_zoom_speed * seconds;

  462.             m_hist_scale += m_hist_scale_speed * seconds;

  463.         }

  464. #endif //NO_NACL_EM_INPUT

  465. 

  466.         //clamp

  467.         vec2 rot_mesh = vec2(SmoothClamp(m_rot.x, -ROT_CLAMP, ROT_CLAMP, ROT_CLAMP * .1f), m_rot.y);

  468.         vec2 pos_mesh = vec2(SmoothClamp(m_pos.x, -POS_CLAMP, POS_CLAMP, POS_CLAMP * .1f),

  469.                              SmoothClamp(m_pos.y, -POS_CLAMP, POS_CLAMP, POS_CLAMP * .1f));

  470.         float fov_mesh = SmoothClamp(m_fov, 0.f, FOV_CLAMP, FOV_CLAMP * .1f);

  471.         float zoom_mesh = SmoothClamp(m_zoom, -ZOM_CLAMP, ZOM_CLAMP, ZOM_CLAMP * .1f);

  472.         vec2 hist_scale_mesh = vec2(SmoothClamp(m_hist_scale.x, 0.f, HST_CLAMP, HST_CLAMP * .1f),

  473.                                     SmoothClamp(m_hist_scale.y, 0.f, HST_CLAMP, HST_CLAMP * .1f));

  474. 

  475. #if NO_NACL_EM_INPUT

  476.         if (KeyDown(KEY_CAM_RESET) && m_reset_timer < 0.f)

  477.         {

  478.             pos_mesh = vec2::zero;

  479.             zoom_mesh = 0.f;

  480.         }

  481. #endif //NO_NACL_EM_INPUT

  482. 

  483.         m_rot_mesh = vec2(damp(m_rot_mesh.x, rot_mesh.x, .2f, seconds), damp(m_rot_mesh.y, rot_mesh.y, .2f, seconds));

  484.         m_pos_mesh = vec2(damp(m_pos_mesh.x, pos_mesh.x, .2f, seconds), damp(m_pos_mesh.y, pos_mesh.y, .2f, seconds));

  485.         m_fov_mesh = damp(m_fov_mesh, fov_mesh, .2f, seconds);

  486.         m_zoom_mesh = damp(m_zoom_mesh, zoom_mesh, .2f, seconds);

  487.         m_hist_scale_mesh = damp(m_hist_scale_mesh, hist_scale_mesh, .2f, seconds);

  488. 

  489.         //Mesh mat calculation

  490.         m_mat_prev = m_mat;

  491.         m_mat = mat4::translate(vec3(0.f));

  492. 

  493.         //Target List Setup

  494.         TargetCamera tc;

  495.         if (m_meshes.Count() && m_mesh_id >= 0)

  496.             for (int i = 0; i < m_meshes[m_mesh_id].m1->GetVertexCount(); i++)

  497.                 tc.AddTarget((m_mat * mat4::translate(m_meshes[m_mesh_id].m1->GetVertexLocation(i))).v3.xyz);

  498.         tc.AddTarget(box3(vec3::zero, vec3::one));

  499.         for (int k = 0; k < m_ssetup->m_lights.Count() && m_ssetup->m_show_lights; ++k)

  500.         {

  501.             vec3 light_pos = m_ssetup->m_lights[k]->GetPosition();

  502.             mat4 world_cam = m_camera->GetView();

  503.             light_pos = (inverse(world_cam) * vec4((world_cam * vec4(light_pos, 1.0f)).xyz * vec3::axis_z, 1.0f)).xyz;

  504.             tc.AddTarget(box3(vec3::onen, vec3::one) + light_pos *

  505.                          ((m_ssetup->m_lights[k]->GetType() == LightType::Directional)?(-1.f):(1.f)));

  506.         }

  507. 

  508.         //--

  509.         //Update mesh screen location - Get the Min/Max needed

  510.         //--

  511.         vec2 cam_center(0.f);

  512.         float cam_factor = .0f;

  513.         vec3 local_min_max[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };

  514.         vec2 screen_min_max[2] = { vec2(FLT_MAX), vec2(-FLT_MAX) };

  515.         mat4 world_cam = m_camera->GetView();

  516.         mat4 cam_screen = m_camera->GetProjection();

  517. 

  518.         //target on-screen computation

  519.         for (int i = 0; i < tc.m_targets.Count(); i++)

  520.         {

  521.             vec3 obj_loc = tc.m_targets[i];

  522.             {

  523.                 //Debug::DrawBox(obj_loc - vec3(4.f), obj_loc + vec3(4.f), vec4(1.f, 0.f, 0.f, 1.f));

  524.                 mat4 target_mx = mat4::translate(obj_loc);

  525.                 vec3 vpos;

  526. 

  527.                 //Get location in cam coordinates

  528.                 target_mx = world_cam * target_mx;

  529.                 vpos = target_mx.v3.xyz;

  530.                 local_min_max[0] = min(vpos.xyz, local_min_max[0]);

  531.                 local_min_max[1] = max(vpos.xyz, local_min_max[1]);

  532. 

  533.                 //Get location in screen coordinates

  534.                 target_mx = cam_screen * target_mx;

  535.                 vpos = (target_mx.v3 / target_mx.v3.w).xyz;

  536.                 screen_min_max[0] = min(screen_min_max[0], vpos.xy * vec2(RATIO_WH, 1.f));

  537.                 screen_min_max[1] = max(screen_min_max[1], vpos.xy * vec2(RATIO_WH, 1.f));

  538. 

  539.                 //Build Barycenter

  540.                 cam_center += vpos.xy;

  541.                 cam_factor += 1.f;

  542.             }

  543.         }

  544.         float screen_ratio = max(max(lol::abs(screen_min_max[0].x), lol::abs(screen_min_max[0].y)),

  545.                                  max(lol::abs(screen_min_max[1].x), lol::abs(screen_min_max[1].y)));

  546.         float z_dist = m_camera->m_target_distance /*length(m_camera->m_position)*/ + max(local_min_max[0].z, local_min_max[1].z);

  547. 

  548.         vec2 screen_offset = vec2(0.f, -(screen_min_max[1].y + screen_min_max[0].y) * .5f);

  549.         m_screen_offset = damp(m_screen_offset, screen_offset, .9f, seconds);

  550. 

  551.         float forced_zoom = m_zoom_mesh;

  552. 

  553.         if (cam_factor > 0.f)

  554.         {

  555.             vec2 old_sscale = m_camera->GetScreenScale();

  556.             float old_ssize = m_camera->GetScreenSize();

  557.             float zoom_in  = 1.f + lol::max(0.f, forced_zoom);

  558.             float zoom_out = 1.f + lol::max(0.f, -forced_zoom);

  559.             m_camera->SetScreenScale(max(vec2(0.001f), ((old_sscale * zoom_in) / (screen_ratio * zoom_out * SCREEN_LIMIT))));

  560.             m_camera->SetFov(m_fov_mesh);

  561.             m_camera->SetScreenInfos(damp(old_ssize, max(1.f, screen_ratio * zoom_out), 1.2f, seconds));

  562. 

  563.             vec3 posz = ((mat4::rotate(m_rot_mesh.y, vec3::axis_y) * mat4::rotate(-m_rot_mesh.x, vec3::axis_x) * vec4::axis_z)).xyz;

  564.             vec3 newpos = posz * damp(length(m_camera->m_position), z_dist * 1.2f, .1f, seconds);

  565.             m_camera->SetView(newpos, vec3(0.f), vec3::axis_y);

  566.         }

  567. 

  568.         //--

  569.         //Message Service

  570.         //--

  571.         String mesh("");

  572.         int u = 1;

  573.         while (u-- > 0 && MessageService::FetchFirst(MessageBucket::AppIn, mesh))

  574.         {

  575.             int o = 1;

  576.             while (o-- > 0)

  577.             {

  578.                 SceneSetup* new_ssetup = new SceneSetup();

  579.                 if (new_ssetup->Compile(mesh.C()) && new_ssetup->m_lights.Count())

  580.                 {

  581.                     //Store current light datas, in World

  582.                     Array<LightData> light_datas;

  583.                     for (int i = 0; i < m_ssetup->m_lights.Count(); ++i)

  584.                         light_datas << LightData(m_ssetup->m_lights[i]->GetPosition(), m_ssetup->m_lights[i]->GetColor());

  585. 

  586.                     if (m_ssetup)

  587.                         delete(m_ssetup);

  588.                     m_ssetup = new_ssetup;

  589.                     m_ssetup->Startup();

  590. 

  591.                     //Restore all light datas so blend can occur

  592.                     mat4 light_mat = m_mat * inverse(mat4(quat::fromeuler_xyz(vec3::zero)));

  593.                     for (int i = 0; i < m_ssetup->m_lights.Count(); ++i)

  594.                     {

  595.                         //Store local dst in current m_ld

  596.                         LightData ltmp = LightData(m_ssetup->m_lights[i]->GetPosition(), m_ssetup->m_lights[i]->GetColor());

  597.                         if (i < m_light_datas.Count())

  598.                             m_light_datas[i] = ltmp;

  599.                         else

  600.                             m_light_datas << ltmp;

  601. 

  602.                         vec3 loc = vec3::zero;

  603.                         vec4 col = vec4::zero;

  604.                         if (i < light_datas.Count())

  605.                         {

  606.                             loc = light_datas[i].m_pos;

  607.                             col = light_datas[i].m_col;

  608.                         }

  609. 

  610.                         //Restore old light datas in new lights

  611.                         m_ssetup->m_lights[i]->SetPosition(loc);

  612.                         m_ssetup->m_lights[i]->SetColor(col);

  613.                     }

  614.                 }

  615.                 else

  616.                 {

  617.                     m_ssetup->m_custom_cmd += new_ssetup->m_custom_cmd;

  618.                     delete(new_ssetup);

  619.                 }

  620.             }

  621.         }

  622. 

  623.         //Check the custom cmd even if we don't have new messages.

  624.         int o = 1;

  625.         while (o-- > 0)

  626.         {

  627.             for (int i = 0; m_ssetup && i < m_ssetup->m_custom_cmd.Count(); ++i)

  628.             {

  629.                 if (m_ssetup->m_custom_cmd[i].m1 == "setmesh")

  630.                 {

  631.                     //Create a new mesh

  632.                     EasyMesh* em = new EasyMesh();

  633.                     if (em->Compile(m_ssetup->m_custom_cmd[i].m2.C(), false))

  634.                     {

  635.                         em->BD()->Cmdi() = 0;

  636.                         if (m_mesh_id == m_meshes.Count() - 1)

  637.                             m_mesh_id++;

  638.                         m_meshes.Push(em, nullptr);

  639.                     }

  640.                     else

  641.                         delete(em);

  642.                 }

  643.             }

  644.         }

  645.         m_ssetup->m_custom_cmd.Empty();

  646. #endif //ALL_FEATURES

  647. 

  648. #if NACL_EM

  649. /*

  650.         if (m_stream_update_time > .0f)

  651.         {

  652.             m_stream_update_time = -1.f;

  653.             MessageService::Send(MessageBucket::AppIn,

  654.                              " addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1) \

  655.                                addlight 0.0 position (8 2 6) color #ffff \

  656.                                custom setmesh \"[sc#f8f ab 1]\"");

  657. //            MessageService::Send(MessageBucket::AppIn, "[sc#f8f ab 1]");

  658. //            MessageService::Send(MessageBucket::AppIn, "[sc#f8f ab 1 splt 4 twy 90]");

  659. //            MessageService::Send(MessageBucket::AppIn, "[sc#8ff afcb 1 1 1 0]");

  660. //            MessageService::Send(MessageBucket::AppIn, "[sc#ff8 afcb 1 1 1 0]");

  661.         }

  662. */

  663. #elif WIN32

  664.         //--

  665.         //File management

  666.         //--

  667.         m_stream_update_time += seconds;

  668.         if (m_stream_update_time > m_stream_update_timer)

  669.         {

  670.             m_stream_update_time = 0.f;

  671. 

  672.             File f;

  673.             f.Open(m_file_name.C(), FileAccess::Read);

  674.             String cmd = f.ReadString();

  675.             f.Close();

  676. 

  677.             if (cmd.Count()

  678.                  && (!m_cmdlist.Count() || cmd != m_cmdlist.Last()))

  679.             {

  680.                 m_cmdlist << cmd;

  681.                 MessageService::Send(MessageBucket::AppIn, cmd);

  682.             }

  683.         }

  684. #endif //WINDOWS

  685.     }

  686. 

  687.     virtual void TickDraw(float seconds)

  688.     {

  689.         WorldEntity::TickDraw(seconds);

  690. 

  691.         if (!m_init || !m_first_tick)

  692.             return;

  693. 

  694.         //TODO : This should probably be "standard LoL behaviour"

  695. #if NO_NACL_EM_INPUT

  696.         {

  697.             if (KeyReleased(KEY_F2))

  698.                 Video::SetDebugRenderMode((Video::GetDebugRenderMode() + 1) % DebugRenderMode::Max);

  699.             else if (KeyReleased(KEY_F1))

  700.                 Video::SetDebugRenderMode((Video::GetDebugRenderMode() + DebugRenderMode::Max - 1) % DebugRenderMode::Max);

  701.         }

  702. #endif //NO_NACL_EM_INPUT

  703. 

  704. #if NO_NACL_EM && WITH_TEXTURE

  705.         if (!m_default_texture)

  706.         {

  707.             m_texture_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinymvtexture));

  708.             m_texture_uni = m_texture_shader->GetUniformLocation("u_Texture");

  709.             m_default_texture = Tiler::Register("data/test-texture.png", ivec2::zero, ivec2(0,1));

  710.         }

  711.         else if (m_texture && m_default_texture)

  712.             m_texture_shader->SetUniform(m_texture_uni, m_default_texture->GetTexture(), 0);

  713. #endif //NO_NACL_EM

  714. 

  715.         g_renderer->SetClearColor(m_ssetup->m_clear_color);

  716. 

  717.         for (int i = 0; i < m_gizmos.Count(); ++i)

  718.         {

  719.             if (m_gizmos[i]->GetMeshState() == MeshRender::NeedConvert)

  720.                 m_gizmos[i]->MeshConvert();

  721.             else

  722.                 break;

  723.         }

  724. 

  725.         if (m_build_timer > .0f)

  726.         {

  727.             if (m_build_time < .0f)

  728.             {

  729.                 m_build_time = m_build_timer;

  730.                 for (int i = 0; i < m_meshes.Count(); ++i)

  731.                 {

  732.                     if (m_meshes[i].m1 && m_meshes[i].m1->BD()->Cmdi() < m_meshes[i].m1->BD()->CmdStack().GetCmdNb())

  733.                     {

  734.                         EasyMesh* tmp = m_meshes[i].m1;

  735.                         EasyMesh* newtmp = new EasyMesh(*tmp);

  736.                         int ii = 1;

  737. #if 1

  738.                         bool stop = false;

  739.                         while (!stop)

  740.                         {

  741.                             int cmdi = newtmp->BD()->Cmdi() + ii;

  742.                             if (cmdi < newtmp->BD()->CmdStack().GetCmdNb())

  743.                             {

  744.                                 switch (newtmp->BD()->CmdStack().GetCmd(cmdi))

  745.                                 {

  746.                                     case EasyMeshCmdType::LoopStart:

  747.                                     case EasyMeshCmdType::LoopEnd:

  748.                                     case EasyMeshCmdType::OpenBrace:

  749.                                     case EasyMeshCmdType::CloseBrace:

  750.                                     case EasyMeshCmdType::ScaleWinding:

  751.                                     case EasyMeshCmdType::QuadWeighting:

  752.                                     case EasyMeshCmdType::PostBuildNormal:

  753.                                     case EasyMeshCmdType::PreventVertCleanup:

  754.                                     case EasyMeshCmdType::SetColorA:

  755.                                     case EasyMeshCmdType::SetColorB:

  756.                                     {

  757.                                         ii++;

  758.                                         break;

  759.                                     }

  760.                                     default:

  761.                                     {

  762.                                         stop = true;

  763.                                         break;

  764.                                     }

  765.                                 }

  766.                             }

  767.                             else

  768.                                 stop = true;

  769.                         }

  770. #endif

  771.                         newtmp->BD()->CmdExecNb() = ii;

  772.                         newtmp->ExecuteCmdStack(false);

  773. 

  774.                         m_meshes[i].m1 = newtmp;

  775.                         delete(tmp);

  776.                     }

  777.                 }

  778.             }

  779.             m_build_time -= seconds;

  780.         }

  781. 

  782. #define NORMAL_USAGE 1

  783. #if 0

  784.         PrimitiveFace NewFace;

  785.         NewFace.SetNormal(vec3::axis_z);

  786.         NewFace.SetCenter(vec3::zero);

  787.         int imax = 4, jmax = 4;

  788.         int sz = 2;

  789.         for (int i = 0; i < imax; ++i)

  790.         {

  791.             for (int j = 0; j < jmax; ++j)

  792.             {

  793.                 NewFace.AddPolygon(vec3(ivec3(i, j, 0) * sz),

  794.                                    vec3(ivec3(i, j, 0) * sz + ivec3(sz,  0, 0)),

  795.                                    vec3(ivec3(i, j, 0) * sz + ivec3(sz, sz, 0)));

  796.                 NewFace.AddPolygon(vec3(ivec3(i, j, 0) * sz),

  797.                                    vec3(ivec3(i, j, 0) * sz + ivec3(sz, sz, 0)),

  798.                                    vec3(ivec3(i, j, 0) * sz + ivec3( 0, sz, 0)));

  799.             }

  800.         }

  801.         for (int i = 0; i < NewFace.m_edges.Count(); ++i)

  802.         {

  803.             Debug::DrawLine(NewFace.EV0(i) + vec3(.0f, .0f, 2.f), NewFace.EV1(i) + vec3(.0f, .0f, 2.f),

  804.                             NewFace.m_edges[i].m3 ? vec4(.0f, .7f, .0f, 1.f) : vec4(.7f, .0f, .0f, 1.f));

  805.             Debug::DrawBox(NewFace.EV0(i) + vec3(.0f, .0f, 2.f) + vec3(-.1f),

  806.                            NewFace.EV0(i) + vec3(.0f, .0f, 2.f) + vec3(+.1f),

  807.                            NewFace.m_edges[i].m3 ? vec4(.0f, .7f, .0f, 1.f) : vec4(.7f, .0f, .0f, 1.f));

  808.         }

  809.         NewFace.CleanEdges();

  810.         for (int i = 0; i < NewFace.m_edges.Count(); ++i)

  811.         {

  812.             Debug::DrawLine(NewFace.EV0(i), NewFace.EV1(i), vec4(vec3::zero, 1.f));

  813.             Debug::DrawBox(NewFace.EV0(i) + vec3(-.1f),

  814.                            NewFace.EV0(i) + vec3(+.1f),

  815.                            vec4(vec3::zero, 1.f));

  816.         }

  817.         //Try with mesh

  818.         PrimitiveMesh NewMesh;

  819.         for (int i = m_meshes.Count() - 1; 0 <= i && i < m_meshes.Count(); i++)

  820.         {

  821.             for (int j = 0; j < m_meshes[i].m1->m_indices.Count(); j += 3)

  822.             {

  823.                 VertexData v[3] = { m_meshes[i].m1->m_vert[m_meshes[i].m1->m_indices[j  ]],

  824.                                     m_meshes[i].m1->m_vert[m_meshes[i].m1->m_indices[j+1]],

  825.                                     m_meshes[i].m1->m_vert[m_meshes[i].m1->m_indices[j+2]] };

  826.                 NewMesh.AddPolygon(v[0].m_coord, v[1].m_coord, v[2].m_coord, v[0].m_normal);

  827.             }

  828.             NewMesh.CleanFaces();

  829.             break;

  830.         }

  831.         for (int j = 0; j < NewMesh.m_faces.Count(); ++j)

  832.         {

  833.             for (int i = 0; i < NewMesh.m_faces[j].m_edges.Count(); ++i)

  834.             {

  835.                 vec3 v0 = NewMesh.m_faces[j].EV0(i) + NewMesh.m_faces[j].GetNormal() * .4f;

  836.                 vec3 v1 = NewMesh.m_faces[j].EV1(i) + NewMesh.m_faces[j].GetNormal() * .4f;

  837.                 Debug::DrawLine(v0, v1, vec4(vec3::zero, 1.f));

  838.                 Debug::DrawBox(v0 + vec3(-.1f), v0 + vec3(+.1f), vec4(vec3::zero, 1.f));

  839.             }

  840.         }

  841. 

  842. #elif NORMAL_USAGE

  843.         vec3 x = vec3(1.f,0.f,0.f);

  844.         vec3 y = vec3(0.f,1.f,0.f);

  845.         mat4 save_proj = m_camera->GetProjection();

  846.                               //Y object Offset

  847.         mat4 mat_obj_offset = mat4::translate(x * m_screen_offset.x + y * m_screen_offset.y) *

  848.                               //Mesh Pos Offset

  849.                               mat4::translate((x * m_pos_mesh.x * RATIO_HW + y * m_pos_mesh.y) * 2.f * (1.f + .5f * m_zoom_mesh / SCREEN_LIMIT));

  850.                               //Align right meshes

  851.         mat4 mat_align =      mat4::translate(x - x * RATIO_HW);

  852.         mat4 mat_gizmo = mat_obj_offset * mat_align * save_proj;

  853.         for (int i = 0; i < m_meshes.Count(); i++)

  854.         {

  855.             {

  856.                 if (m_meshes[i].m1->GetMeshState() == MeshRender::NeedConvert)

  857.                 {

  858. #if WITH_TEXTURE

  859.                     m_meshes[i].m1->MeshConvert(new DefaultShaderData(((1 << VertexUsage::Position) | (1 << VertexUsage::Normal) |

  860.                                                                        (1 << VertexUsage::Color)    | (1 << VertexUsage::TexCoord)),

  861.                                                                        m_texture_shader, true));

  862. #else

  863.                     m_meshes[i].m1->MeshConvert();

  864. #endif //WITH_TEXTURE

  865.                 }

  866. #if ALL_FEATURES

  867.                 float j = -(float)(m_meshes.Count() - (i + 1)) + (-m_mesh_id1 + (float)(m_meshes.Count() - 1));

  868. 

  869.                 if (m_mesh_id1 - m_render_max[0] > (float)i && m_mesh_id1 - m_render_max[1] < (float)i &&

  870.                     m_meshes[i].m1->GetMeshState() > MeshRender::NeedConvert)

  871.                 {

  872.                     float a_j = lol::abs(j);

  873.                     float i_trans = (a_j * a_j * m_hist_scale_mesh.x + a_j * m_hist_scale_mesh.x) * .5f;

  874.                     float i_scale = clamp(1.f - (m_hist_scale_mesh.y * (m_mesh_id1 - (float)i)), 0.f, 1.f);

  875. 

  876.                     //Mesh count offset

  877.                     mat4 mat_count_offset = mat4::translate(x * RATIO_HW * 2.f * (j + i_trans));

  878.                     //Mesh count scale

  879.                     mat4 mat_count_scale = mat4::scale(vec3(vec2(i_scale), 1.f));

  880. 

  881.                     //Camera projection

  882.                     mat4 new_proj = mat_obj_offset * mat_count_offset * mat_align * mat_count_scale * save_proj;

  883.                     m_camera->SetProjection(new_proj);

  884.                     m_meshes[i].m1->Render(m_mat);

  885.                     g_renderer->Clear(ClearMask::Depth);

  886.                 }

  887.                 m_camera->SetProjection(save_proj);

  888. #else

  889.                 m_meshes[i].m1->Render(m_mat);

  890. #endif //ALL_FEATURES

  891.             }

  892.         }

  893. 

  894.         //Scene setup update

  895.         if (m_ssetup)

  896.         {

  897.             m_camera->SetProjection(mat_gizmo);

  898.             if (m_ssetup->m_show_gizmo)

  899.                 m_gizmos[GZ_Editor]->Render(m_mat);

  900. 

  901.             if (m_ssetup->m_show_lights)

  902.             {

  903.                 for (int k = 0; k < m_ssetup->m_lights.Count(); ++k)

  904.                 {

  905.                     Light* ltmp = m_ssetup->m_lights[k];

  906.                     mat4 world = mat4::translate(ltmp->GetPosition());

  907.                     mat4 local = mat4::translate((inverse(m_mat) * world).v3.xyz);

  908.                     //dir light

  909.                     if (ltmp->GetType() == LightType::Directional)

  910.                     {

  911.                         m_gizmos[GZ_LightPos]->Render(m_mat * inverse(local));

  912.                         m_gizmos[GZ_LightDir]->Render(inverse(world) * inverse(mat4::lookat(vec3::zero, -ltmp->GetPosition(), vec3::axis_y)));

  913.                     }

  914.                     else //point light

  915.                     {

  916.                         m_gizmos[GZ_LightPos]->Render(m_mat * local);

  917.                     }

  918.                 }

  919.             }

  920.             m_camera->SetProjection(save_proj);

  921.         }

  922. #endif //NORMAL_USAGE

  923. 

  924. #if 0 //Debug normal draw

  925.         for (int i = m_meshes.Count() - 1; 0 <= i && i < m_meshes.Count(); i++)

  926.         {

  927.             for (int j = 0; j < m_meshes[i].m1->m_indices.Count(); j += 3)

  928.             {

  929.                 VertexData v[3] = { m_meshes[i].m1->m_vert[m_meshes[i].m1->m_indices[j  ]],

  930.                                     m_meshes[i].m1->m_vert[m_meshes[i].m1->m_indices[j+1]],

  931.                                     m_meshes[i].m1->m_vert[m_meshes[i].m1->m_indices[j+2]]

  932.                                     };

  933.                 for (int k = 0; k < 3; k++)

  934.                     Debug::DrawLine((m_mat * mat4::translate(v[k].m_coord)).v3.xyz,

  935.                                     (m_mat * mat4::translate(v[(k+1)%3].m_coord)).v3.xyz, vec4(vec3((v[k].m_coord.z + 1.f)*.5f),1.f));

  936.             }

  937.             for (int j = 0; j < m_meshes[i].m1->m_vert.Count(); j++)

  938.             {

  939.                 VertexData &v = m_meshes[i].m1->m_vert[m_meshes[i].m1->m_indices[j]];

  940.                 Debug::DrawLine((m_mat * mat4::translate(v.m_coord)).v3.xyz,

  941.                                 (m_mat * mat4::translate(v.m_coord)).v3.xyz +

  942.                                 (m_mat * vec4(v.m_normal * 5.f, 0.f)).xyz, vec4(lol::abs(v.m_normal), 1.f));

  943.             }

  944.         }

  945. #endif

  946.     }

  947. 

  948. private:

  949.     SceneSetup*         m_ssetup;

  950.     Array<LightData>    m_light_datas;

  951.     Controller*         m_controller;

  952.     short               m_input_usage;

  953.     mat4                m_mat;

  954.     mat4                m_mat_prev;

  955.     bool                m_init;

  956.     bool                m_first_tick;

  957. 

  958.     //Camera Setup

  959.     Camera *            m_camera;

  960.     float               m_reset_timer;

  961.     float               m_fov;

  962.     float               m_fov_mesh;

  963.     float               m_fov_speed;

  964.     float               m_zoom;

  965.     float               m_zoom_mesh;

  966.     float               m_zoom_speed;

  967.     vec2                m_rot;

  968.     vec2                m_rot_mesh;

  969.     vec2                m_rot_speed;

  970.     vec2                m_pos;

  971.     vec2                m_pos_mesh;

  972.     vec2                m_pos_speed;

  973.     vec2                m_hist_scale;

  974.     vec2                m_hist_scale_mesh;

  975.     vec2                m_hist_scale_speed;

  976.     vec2                m_screen_offset;

  977. 

  978.     //Mesh update timer

  979.     float               m_build_timer;

  980.     float               m_build_time;

  981. 

  982.     //Mesh infos

  983.     vec2                m_render_max;

  984.     int                 m_mesh_render;

  985.     int                 m_mesh_id;

  986.     float               m_mesh_id1;

  987.     Array<EasyMesh*, EasyMesh*> m_meshes;

  988.     Array<EasyMesh*>    m_gizmos;

  989. 

  990.     //File data

  991.     String              m_file_name;

  992.     Array<String>       m_cmdlist;

  993.     float               m_stream_update_time;

  994.     float               m_stream_update_timer;

  995. 

  996.     //misc datas

  997.     Shader *            m_texture_shader;

  998.     TileSet *           m_default_texture;

  999.     Texture *           m_texture;

  1000.     ShaderUniform       m_texture_uni;

  1001. };

  1002. 

  1003. //The basic main :

  1004. int main(int argc, char **argv)

  1005. {

  1006.     System::Init(argc, argv);

  1007. 

  1008.     Application app("MeshViewer", ivec2((int)DEFAULT_WIDTH, (int)DEFAULT_HEIGHT), 60.0f);

  1009.     if (argc > 1)

  1010.         new MeshViewer(argv[1]);

  1011.     else

  1012.         new MeshViewer();

  1013.     app.Run();

  1014. 

  1015.     return EXIT_SUCCESS;

  1016. }