lolengine
/
lol
mirror da https://github.com/lolengine/lol
1
0
Forka 0
Codice Problemi 0 Rilasci 0 Wiki Attività
2897 Commit
5 Rami (Branch)
521 MiB
 
 
 
Albero (Tree): 0e79b79d23
lol/doc/samples/meshviewer/meshviewer.cpp

1132 righe
40 KiB
Originale Blame Cronologia 

  1. //

  2. //  Lol Engine — EasyMesh tutorial

  3. //

  4. //  Copyright © 2011—2019 Sam Hocevar <sam@hocevar.net>

  5. //            © 2012—2015 Benjamin “Touky” Huet <huet.benjamin@gmail.com>

  6. //

  7. //  Lol Engine is free software. It comes without any warranty, to

  8. //  the extent permitted by applicable law. You can redistribute it

  9. //  and/or modify it under the terms of the Do What the Fuck You Want

  10. //  to Public License, Version 2, as published by the WTFPL Task Force.

  11. //  See http://www.wtfpl.net/ for more details.

  12. //

  13. 

  14. #if HAVE_CONFIG_H

  15. #   include "config.h"

  16. #endif

  17. 

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

  19. #include <string>

  20. #include <map>

  21. 

  22. #include <lol/engine.h>

  23. #include <lol/lua.h>

  24. 

  25. #include "scenesetup.h"

  26. 

  27. using namespace lol;

  28. 

  29. static int const TEXTURE_WIDTH = 256;

  30. 

  31. //Basic build defines ---------------------------------------------------------

  32. #define     HAS_WEB             (EMSCRIPTEN)

  33. #define     HAS_INPUT           (_WIN32 && !HAS_WEB)

  34. 

  35. //Basic config defines --------------------------------------------------------

  36. #define     R_M                 1.f

  37. #if HAS_WEB

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

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

  40. #else

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

  42. #define     DEFAULT_HEIGHT      (800.f * R_M)

  43. #endif //HAS_WEB

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

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

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

  47. #define     RATIO_HW            (HEIGHT / WIDTH)

  48. #define     RATIO_WH            (WIDTH / HEIGHT)

  49. #define     SCREEN_LIMIT        1.4f

  50. 

  51. #define     RESET_TIMER         .2f

  52. #define     ROT_SPEED           vec2(radians(50.f))

  53. #define     ROT_CLAMP           radians(89.f)

  54. #define     POS_SPEED           vec2(1.2f)

  55. #define     POS_CLAMP           1.f

  56. #define     FOV_SPEED           radians(20.f)

  57. #define     FOV_CLAMP           radians(120.f)

  58. #define     ZOM_SPEED           3.f

  59. #define     ZOM_CLAMP           20.f

  60. #define     HST_SPEED           .5f

  61. #define     HST_CLAMP           1.f

  62. 

  63. #define     WITH_TEXTURE        0

  64. #define     WITH_THREAD_MANAGER 0 // FIXME: this was removed from Lol Engine

  65. 

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

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

  68. 

  69. #include "meshviewer.h"

  70. 

  71. LOLFX_RESOURCE_DECLARE(shinyfur);

  72. LOLFX_RESOURCE_DECLARE(shinymvtexture);

  73. 

  74. //TargetCamera ----------------------------------------------------------------

  75. class TargetCamera

  76. {

  77. public:

  78.     void EmptyTargets()             { m_targets.clear(); }

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

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

  81.     void AddTarget(box3 new_target)

  82.     {

  83.         vec3 base_off = .5f * new_target.extent();

  84.         vec3 base_pos = new_target.center();

  85.         int pass = 0;

  86.         while (pass < 3)

  87.         {

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

  89.             while (mask-- > 0)

  90.             {

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

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

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

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

  95.             }

  96.             pass++;

  97.         }

  98.     }

  99. 

  100.     array<vec3>     m_targets;

  101. };

  102. 

  103. //EasyMeshViewerObject --------------------------------------------------------

  104. void EasyMeshViewerObject::tick_draw(float seconds, Scene &scene)

  105. {

  106.     switch (m_mesh.GetMeshState().ToScalar())

  107.     {

  108.     case MeshRender::NeedConvert: { m_mesh.MeshConvert(); break; }

  109.     case MeshRender::CanRender: { m_mesh.Render(scene, mat4::identity/*TODO:FIX THAT*/); break; }

  110.     default: break;

  111.     }

  112. }

  113. 

  114. //EasyMeshLoadJob -------------------------------------------------------------

  115. bool EasyMeshLoadJob::DoWork()

  116. {

  117.     std::map<std::string, EasyMeshLuaObject*> meshes;

  118.     if (m_loader.ExecLuaFile(m_path) && EasyMeshLuaLoader::GetRegisteredMeshes(meshes))

  119.     {

  120.         for (auto const &kv : meshes)

  121.             m_meshes << new EasyMeshViewerObject(kv.first, kv.second->GetMesh());

  122.     }

  123.     return m_meshes.count() > 0;

  124. }

  125. 

  126. //-----------------------------------------------------------------------------

  127. MeshViewerLoadJob* EasyMeshLoadJob::GetInstance(std::string const& path)

  128. {

  129.     if (Check(path))

  130.         return new EasyMeshLoadJob(path);

  131.     return nullptr;

  132. }

  133. 

  134. //-----------------------------------------------------------------------------

  135. void EasyMeshLoadJob::RetrieveResult(class MeshViewer* app)

  136. {

  137.     for (EasyMeshViewerObject* mesh : m_meshes)

  138.         app->AddViewerObj(mesh);

  139.     m_meshes.clear();

  140. }

  141. 

  142. //MeshViewer ------------------------------------------------------------------

  143. MeshViewer::MeshViewer(char const *file_name)

  144.     : m_file_name(file_name)

  145. {

  146.     LolImGui::Init();

  147. }

  148. 

  149. //-----------------------------------------------------------------------------

  150. MeshViewer::~MeshViewer()

  151. {

  152.     LolImGui::Shutdown();

  153.     Stop();

  154. }

  155. 

  156. //-----------------------------------------------------------------------------

  157. void MeshViewer::Start()

  158. {

  159.     if (m_init) return;

  160. 

  161.     /** OLD STUFF **/

  162.     //Prepare();

  163. 

  164.     //Threads setup

  165.     m_entities << (m_file_check = new FileUpdateTester());

  166. #if WITH_THREAD_MANAGER

  167.     m_entities << (m_file_loader = new DefaultThreadManager(4, 0));

  168. #endif

  169. 

  170.     //Scene setup

  171.     m_ssetup_file_name = "../data/meshviewer.init.lua";

  172.     UpdateSceneSetup();

  173. 

  174.     //Mesh file

  175.     m_file_status = m_file_check->RegisterFile(m_file_name);

  176. #if WITH_THREAD_MANAGER

  177.     m_file_loader->AddJob(GetLoadJob(m_file_name));

  178. #endif

  179. 

  180.     //Camera setup

  181.     m_camera = new Camera();

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

  183.     m_camera->SetProjection(radians(40.f), .0001f, 200.f);

  184.     //m_camera->SetProjection(radians(90.f), .0001f, 2000.f, WIDTH * SCREEN_W, RATIO_HW);

  185.     //m_camera->UseShift(true);

  186.     Scene& scene = Scene::GetScene();

  187.     scene.PushCamera(m_camera);

  188.     scene.SetTileCam(0);

  189. 

  190.     //Text setup

  191.     m_entities << (m_text = new Text("", "data/font/ascii.png"));

  192.     m_text->SetPos(vec3(0, 0 /*(float)-m_text->GetFontSize().y*/, 0));

  193. 

  194. #if HAS_INPUT

  195.     InputProfile& ip = m_profile;

  196.     ip.AddBindings<MeshViewerKeyInput, MeshViewerKeyInput::KBD_BEG, MeshViewerKeyInput::KBD_END>(InputProfileType::Keyboard);

  197.     ip.AddBindings<MeshViewerKeyInput, MeshViewerKeyInput::MSE_BEG, MeshViewerKeyInput::MSE_END>(InputProfileType::MouseKey);

  198. 

  199.     m_entities << (m_controller = new Controller("MeshViewer"));

  200.     m_controller->Init(m_profile);

  201. #endif //HAS_INPUT

  202. 

  203.     //Ref all entities

  204.     for (Entity* entity : m_entities) Ticker::Ref(entity);

  205. 

  206.     /** ----- Start threads ----- **/

  207.     m_file_check->Start();

  208. 

  209.     /** ----- Init is done ----- **/

  210.     m_init = true;

  211. }

  212. 

  213. //-----------------------------------------------------------------------------

  214. void MeshViewer::Stop()

  215. {

  216.     if (!m_init) return;

  217. 

  218.     /** OLD STUFF **/

  219.     //Unprepare();

  220. 

  221.     //Destroy scene setup

  222.     UpdateSceneSetup(true);

  223. 

  224.     //Destroy core stuff

  225.     Scene& scene = Scene::GetScene();

  226.     if (m_camera) scene.PopCamera(m_camera);

  227. 

  228.     m_file_check->UnregisterFile(m_file_status);

  229. 

  230.     //Unref all entities

  231.     for (Entity* entity : m_entities) Ticker::Unref(entity);

  232. 

  233.     //Delete objs

  234.     while (m_objs.count()) delete m_objs.pop();

  235. 

  236.     //Nullify all

  237.     m_camera = nullptr;

  238.     m_controller = nullptr;

  239.     m_file_check = nullptr;

  240. #if WITH_THREAD_MANAGER

  241.     m_file_loader = nullptr;

  242. #endif

  243. 

  244.     /** ----- Init is needed ----- **/

  245.     m_init = false;

  246. }

  247. 

  248. //-----------------------------------------------------------------------------

  249. void MeshViewer::UpdateSceneSetup(bool only_destroy)

  250. {

  251.     //Delete previous setups

  252.     for (auto &key : m_ssetups)

  253.         delete key.second;

  254.     m_ssetups.clear();

  255.     if (m_ssetup_file_status)

  256.     {

  257.         m_file_check->UnregisterFile(m_ssetup_file_status);

  258.         delete m_ssetup_file_status;

  259.     }

  260.     m_ssetup_file_status = nullptr;

  261. 

  262.     //Init new setups

  263.     if (!only_destroy)

  264.     {

  265.         m_ssetup_loader.ExecLuaFile(m_ssetup_file_name);

  266.         if (m_ssetup_loader.GetLoadedSetups(m_ssetups))

  267.         {

  268.             m_ssetup_file_status = m_file_check->RegisterFile(m_ssetup_file_name);

  269.             if (!m_ssetup_name.length() || !has_key(m_ssetups, m_ssetup_name))

  270.                 m_ssetup_name = m_ssetups.begin()->first;

  271.         }

  272.     }

  273. }

  274. 

  275. //-----------------------------------------------------------------------------

  276. MeshViewerLoadJob* MeshViewer::GetLoadJob(std::string const& path)

  277. {

  278.     MeshViewerLoadJob* job = nullptr;

  279.     if (job = EasyMeshLoadJob::GetInstance(path)) return job;

  280.     return job;

  281. }

  282. 

  283. //-----------------------------------------------------------------------------

  284. void MeshViewer::tick_game(float seconds)

  285. {

  286.     super::tick_game(seconds);

  287. 

  288.     if (!m_init && Scene::IsReady()) Start();

  289.     if (!m_init) return;

  290. 

  291.     m_first_tick = true;

  292. 

  293. #if HAS_INPUT

  294.     {

  295.         //Shutdown logic

  296.         if (m_controller->IsKeyPressed(MeshViewerKeyInput::Exit))

  297.         {

  298.             Ticker::Shutdown();

  299.             return;

  300.         }

  301.     }

  302. #endif //HAS_INPUT

  303. 

  304.     static bool default_open = true;

  305.     //static float fov = radians(40.f);

  306.     //static vec3 sphere_pos = vec3(20.f, 45.f, 45.f);

  307.     //static bool use_custom_cam = true;

  308.     //static float f;

  309.     //static int mesh_idx = 0;

  310.     //static array<char*> mesh_names_char;

  311.     //static array<std::string> mesh_names_str;

  312. 

  313.     //Draw viewer objects

  314.     m_menu_mesh_names_char.clear();

  315.     m_menu_mesh_names_str.clear();

  316.     for (ViewerObject* obj : m_objs)

  317.         m_menu_mesh_names_str << obj->GetName();

  318.     for (auto const &str : m_menu_mesh_names_str)

  319.         m_menu_mesh_names_char << str.c_str();

  320. 

  321.     ImGuiIO& io = ImGui::GetIO();

  322.     //CAMERA UI ---------------------------------------------------------------

  323.     ImGui::Begin("Camera Setup" /*, &default_open, ImGuiWindowFlags_AlwaysAutoResize*/);

  324.     {

  325.         ImGui::Text("Hello, world!");

  326.         ImGui::Checkbox("Use custom cam", &m_menu_cam_useage);

  327.         ImGui::Text("MousePos! %.2f/%.2f", io.MousePos.x, io.MousePos.y);

  328.         ImGui::Text("Left Mouse: %s", io.MouseDown[0] ? "true" : "false");

  329.         ImGui::SliderFloat("Cam FOV", &m_menu_cam_fov, 0.1f, 120.0f);

  330.         ImGui::SliderFloat("Cam Distance", &m_menu_cam_pos.x, 0.1f, 30.f);

  331.         ImGui::SliderFloat("Cam H-axis", &m_menu_cam_pos.y, -180.f, 180.f);

  332.         ImGui::SliderFloat("Cam V-axis", &m_menu_cam_pos.z, -89.f, 89.f);

  333.         ImGui::Combo("Scene Setup", &m_menu_mesh_idx, (const char**)m_menu_mesh_names_char.data(), (int)m_menu_mesh_names_char.count());

  334. 

  335.         ImGui::ListBox("Meshes", &m_menu_mesh_idx, (const char**)m_menu_mesh_names_char.data(), (int)m_menu_mesh_names_char.count());

  336.         //ImGui::ListBox()

  337.     }

  338.     ImGui::End();

  339. 

  340.     //Camera

  341.     if (m_menu_cam_useage)

  342.     {

  343.         vec3 sphere_pos_rad = m_menu_cam_pos;

  344.         sphere_pos_rad.z = (sphere_pos_rad.z > 0.f) ? (90.f - sphere_pos_rad.z) : (sphere_pos_rad.z - 90.f);

  345.         sphere_pos_rad = vec3(sphere_pos_rad.x, radians(sphere_pos_rad.y), radians(sphere_pos_rad.z));

  346.         m_camera->SetFov(radians(m_menu_cam_fov));

  347.         m_camera->SetPosition(cartesian(sphere_pos_rad));

  348.         m_camera->SetTarget(vec3::zero, vec3::axis_y);

  349.     }

  350. 

  351.     //Check file update

  352.     ASSERT(m_file_status);

  353.     //if (false) //DEBUG

  354. #if WITH_THREAD_MANAGER

  355.     //m_file_status->GetTime()

  356.     if (m_file_status->HasUpdated())

  357.         m_file_loader->AddJob(GetLoadJob(m_file_name));

  358. #endif

  359. 

  360.     //Check work done

  361.     //if (false) //DEBUG

  362.     {

  363.         array<ThreadJob*> result;

  364. #if WITH_THREAD_MANAGER

  365.         m_file_loader->GetWorkResult(result);

  366. #endif

  367.         if (result.count())

  368.         {

  369.             for (ThreadJob* job : result)

  370.             {

  371.                 if (job->GetJobType() == ThreadJobType::WORK_SUCCEEDED)

  372.                 {

  373.                     MeshViewerLoadJob* mvjob = static_cast<MeshViewerLoadJob*>(job);

  374.                     mvjob->RetrieveResult(this);

  375.                 }

  376.                 delete job;

  377.             }

  378.         }

  379.     }

  380. 

  381.     /** OLD STUFF **/

  382.     //Update(seconds);

  383. }

  384. 

  385. //-----------------------------------------------------------------------------

  386. void MeshViewer::tick_draw(float seconds, Scene &scene)

  387. {

  388.     super::tick_draw(seconds, scene);

  389. 

  390.     //Draw viewer objects

  391.     if (m_menu_mesh_idx >= 0 && m_menu_mesh_idx < m_objs.count())

  392.         m_objs[m_menu_mesh_idx]->tick_draw(seconds, scene);

  393. 

  394.     m_text->SetText("CECI EST UN TEST\n");

  395. 

  396.     //Draw gizmos & grid

  397.     Debug::DrawGizmo(vec3::zero, vec3::axis_x, vec3::axis_y, vec3::axis_z, 10.f);

  398.     auto context = Debug::DrawContext::New(Color::white);

  399.     Debug::DrawGrid(vec3::zero, vec3::axis_x, vec3::axis_y, vec3::axis_z, 10.f);

  400. 

  401.     /** OLD STUFF **/

  402.     //Draw(seconds);

  403. }

  404. 

  405. //The basic main --------------------------------------------------------------

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

  407. {

  408.     sys::init(argc, argv);

  409. 

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

  411.     if (argc > 1)

  412.         new MeshViewer(argv[1]);

  413.     else

  414.         new MeshViewer();

  415. 

  416.     ////DEBUG TEST

  417.     //SceneDisplay* display = new ApplicationDisplay("newDisplay", ivec2(800, 600));

  418.     //SceneDisplay::Add(display);

  419.     //Scene::GetScene(Scene::GetCount() - 1).SetDisplay(display);

  420. 

  421.     app.Run();

  422. 

  423.     return EXIT_SUCCESS;

  424. }

  425. 

  426. //-------------------------------------------------------------------------

  427. //OLD ---------------------------------------------------------------------

  428. //-------------------------------------------------------------------------

  429. #if HAS_INPUT

  430. bool  MeshViewer::KeyReleased(MVKeyboardList index) { return (HAS_KBOARD && m_controller->WasKeyReleasedThisFrame(index)); }

  431. bool  MeshViewer::KeyPressed(MVKeyboardList index)  { return (HAS_KBOARD && m_controller->WasKeyPressedThisFrame(index)); }

  432. bool  MeshViewer::KeyDown(MVKeyboardList index)     { return (HAS_KBOARD && m_controller->IsKeyPressed(index)); }

  433. bool  MeshViewer::KeyReleased(MVMouseKeyList index) { return (HAS_MOUSE  && m_controller->WasKeyReleasedThisFrame(index)); }

  434. bool  MeshViewer::KeyPressed(MVMouseKeyList index)  { return (HAS_MOUSE  && m_controller->WasKeyPressedThisFrame(index)); }

  435. bool  MeshViewer::KeyDown(MVMouseKeyList index)     { return (HAS_MOUSE  && m_controller->IsKeyPressed(index)); }

  436. float MeshViewer::AxisValue(MVMouseAxisList index)  { return (HAS_MOUSE) ? (m_controller->GetAxisValue(index)) : (0.f); }

  437. #endif //HAS_INPUT

  438. 

  439. void MeshViewer::Prepare()

  440. {

  441.     // Message Service

  442.     MessageService::Setup();

  443. 

  444.     //Compile ref meshes

  445.     m_gizmos << new EasyMesh();

  446.     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]");

  447.     m_gizmos << new EasyMesh();

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

  449.     m_gizmos << new EasyMesh();

  450.     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]");

  451. 

  452.     // Mesh Setup

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

  454.     m_mesh_render = 0;

  455.     m_mesh_id = 0;

  456.     m_mesh_id1 = 0.f;

  457.     m_default_texture = nullptr;

  458.     m_texture_shader = nullptr;

  459.     m_texture = nullptr;

  460. 

  461.     //Camera Setup

  462.     m_reset_timer = -1.f;

  463.     m_fov = radians(-100.f);

  464.     m_fov_mesh = 0.f;

  465.     m_fov_speed = 0.f;

  466.     m_zoom = 0.f;

  467.     m_zoom_mesh = 0.f;

  468.     m_zoom_speed = 0.f;

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

  470.     m_rot_mesh = vec2::zero;

  471.     m_rot_speed = vec2::zero;

  472.     m_pos = vec2::zero;

  473.     m_pos_mesh = vec2::zero;

  474.     m_pos_speed = vec2::zero;

  475.     m_screen_offset = vec2::zero;

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

  477.     m_hist_scale_mesh = vec2(.0f);

  478.     m_hist_scale_speed = vec2(.0f);

  479. 

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

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

  482. 

  483.     m_build_timer = 0.1f;

  484.     m_build_time = -1.f;

  485. 

  486.     //stream update

  487.     m_stream_update_time = 2.0f;

  488.     m_stream_update_timer = 1.0f;

  489. 

  490.     m_init = true;

  491.     m_input_usage = 0;

  492. 

  493. #if HAS_INPUT

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

  495.     m_controller = new Controller("Default");

  496.     m_controller->SetInputCount(MAX_KEYS, MAX_AXIS);

  497. 

  498.     if (InputDevice::Get(g_name_mouse.c_str()))

  499.     {

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

  501. 

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

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

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

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

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

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

  508.     }

  509. 

  510.     if (InputDevice::Get(g_name_keyboard.c_str()))

  511.     {

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

  513. 

  514.         //Camera keyboard rotation

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

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

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

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

  519. 

  520.         //Camera keyboard position switch

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

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

  523. 

  524.         //Camera unzoom switch

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

  526. 

  527.         //Mesh change

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

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

  530. 

  531.         //Base setup

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

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

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

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

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

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

  538.     }

  539. #endif //HAS_INPUT

  540. 

  541. 

  542.     m_camera = new Camera();

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

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

  545.     m_camera->UseShift(true);

  546.     Scene& scene = Scene::GetScene();

  547.     scene.PushCamera(m_camera);

  548. 

  549.     //Lights setup

  550.     m_ssetup = new SceneSetup();

  551. #if NO_SC_SETUP

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

  553.     m_ssetup->m_lights.last()->SetPosition(vec4(4.f, -1.f, -4.f, 0.f));

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

  555.     Ticker::Ref(m_ssetup->m_lights.last());

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

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

  558.     m_ssetup->m_lights.last()->SetColor(vec4(1.f));

  559.     Ticker::Ref(m_ssetup->m_lights.last());

  560.     EasyMesh* em = new EasyMesh();

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

  562.     {

  563.         if (m_mesh_id == m_meshes.count() - 1)

  564.             m_mesh_id++;

  565.         m_meshes.push(em, nullptr);

  566.     }

  567. #else

  568.     //TOUKY CHANGE THAT

  569.     /*

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

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

  572.     "showgizmo true ");

  573.     */

  574.     m_ssetup->Startup();

  575. #endif //NO_SC_SETUP

  576.     for (int i = 0; i < m_ssetup->m_lights.count(); ++i)

  577.     {

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

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

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

  581.     }

  582. }

  583. 

  584. void MeshViewer::Unprepare()

  585. {

  586.     Scene& scene = Scene::GetScene();

  587.     if (m_camera) scene.PopCamera(m_camera);

  588.     if (m_ssetup) delete m_ssetup;

  589. 

  590.     MessageService::Destroy();

  591. 

  592.     //Register all entities

  593.     for (Entity* entity : m_entities)

  594.         Ticker::Unref(entity);

  595. 

  596.     m_controller = nullptr;

  597.     m_camera = nullptr;

  598.     m_ssetup = nullptr;

  599. 

  600.     /** ----- Init is needed ----- **/

  601.     m_init = false;

  602. }

  603. 

  604. void MeshViewer::Update(float seconds)

  605. {

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

  607. #if HAS_INPUT

  608.     {

  609.         //Shutdown logic

  610.         if (KeyReleased(KEY_ESC))

  611.             Ticker::Shutdown();

  612.     }

  613. #endif //HAS_INPUT

  614. 

  615.     //Compute render mesh count

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

  617.     float i_m = m_hist_scale_mesh.x;

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

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

  620. 

  621.     //Mesh Change

  622. #if HAS_INPUT

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

  624. #endif //HAS_INPUT

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

  626. 

  627. #if ALL_FEATURES

  628. 

  629.     //Update light position & damping

  630.     for (int i = 0; i < m_ssetup->m_lights.count(); ++i)

  631.     {

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

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

  634. 

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

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

  637. 

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

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

  640.     }

  641. 

  642.     //Camera update

  643.     bool is_pos = false;

  644.     bool is_fov = false;

  645.     bool is_hsc = false;

  646.     vec2 tmpv = vec2::zero;

  647. 

  648. #if HAS_INPUT

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

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

  651. 

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

  653.     {

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

  655.         if (KeyDown(MSE_CAM_ROT))

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

  657.         if (KeyDown(MSE_CAM_POS))

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

  659.         if (KeyDown(MSE_CAM_FOV))

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

  661.     }

  662. 

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

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

  665. #endif //HAS_INPUT

  666. 

  667.     //Base data

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

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

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

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

  672. 

  673.     //speed

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

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

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

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

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

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

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

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

  682. 

  683.     m_rot += m_rot_speed * seconds;

  684. 

  685. #if HAS_INPUT

  686.     if (m_reset_timer >= 0.f)

  687.         m_reset_timer -= seconds;

  688.     if (KeyPressed(KEY_CAM_RESET))

  689.     {

  690.         if (m_reset_timer >= 0.f)

  691.         {

  692.             m_pos = vec2(0.f);

  693.             m_zoom = 0.f;

  694.         }

  695.         else

  696.             m_reset_timer = RESET_TIMER;

  697.     }

  698. 

  699.     //Transform update

  700.     if (!KeyDown(KEY_CAM_RESET))

  701.     {

  702.         m_pos += m_pos_speed * seconds;

  703.         m_fov += m_fov_speed * seconds;

  704.         m_zoom += m_zoom_speed * seconds;

  705.         m_hist_scale += m_hist_scale_speed * seconds;

  706.     }

  707. #endif //HAS_INPUT

  708. 

  709.     //clamp

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

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

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

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

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

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

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

  717. 

  718. #if HAS_INPUT

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

  720.     {

  721.         pos_mesh = vec2::zero;

  722.         zoom_mesh = 0.f;

  723.     }

  724. #endif //HAS_INPUT

  725. 

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

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

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

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

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

  731. 

  732.     //Mesh mat calculation

  733.     m_mat_prev = m_mat;

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

  735. 

  736.     //Target List Setup

  737.     TargetCamera tc;

  738.     if (m_meshes.count() && m_mesh_id >= 0)

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

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

  741.     tc.AddTarget(box3(vec3(0.f), vec3(1.f)));

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

  743.     {

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

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

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

  747.         tc.AddTarget(box3(vec3(-1.f), vec3(1.f)) + light_pos *

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

  749.     }

  750. 

  751.     //--

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

  753.     //--

  754.     vec2 cam_center(0.f);

  755.     float cam_factor = .0f;

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

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

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

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

  760. 

  761.     //target on-screen computation

  762.     for (int i = 0; i < tc.m_targets.count(); i++)

  763.     {

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

  765.         {

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

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

  768.             vec3 vpos;

  769. 

  770.             //Get location in cam coordinates

  771.             target_mx = world_cam * target_mx;

  772.             vpos = target_mx[3].xyz;

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

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

  775. 

  776.             //Get location in screen coordinates

  777.             target_mx = cam_screen * target_mx;

  778.             vpos = (target_mx[3] / target_mx[3].w).xyz;

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

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

  781. 

  782.             //Build Barycenter

  783.             cam_center += vpos.xy;

  784.             cam_factor += 1.f;

  785.         }

  786.     }

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

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

  789.     float z_dist = //m_camera->m_target_distance

  790.         length(m_camera->m_position)

  791.         + max(local_min_max[0].z, local_min_max[1].z);

  792. 

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

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

  795. 

  796.     float forced_zoom = m_zoom_mesh;

  797. 

  798.     if (cam_factor > 0.f)

  799.     {

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

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

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

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

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

  805.         m_camera->SetFov(m_fov_mesh);

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

  807. 

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

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

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

  811.     }

  812. 

  813.     //--

  814.     //Message Service

  815.     //--

  816.     std::string mesh;

  817.     int u = 1;

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

  819.     {

  820.         int o = 1;

  821.         while (o-- > 0)

  822.         {

  823.             SceneSetup* new_ssetup = new SceneSetup();

  824.             if (false) //new_ssetup->Compile(mesh.c_str()) && new_ssetup->m_lights.count())

  825.             {

  826.                 //Store current light datas, in World

  827.                 array<LightData> light_datas;

  828.                 for (int i = 0; i < m_ssetup->m_lights.count(); ++i)

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

  830. 

  831.                 if (m_ssetup)

  832.                     delete m_ssetup;

  833.                 m_ssetup = new_ssetup;

  834.                 m_ssetup->Startup();

  835. 

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

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

  838.                 for (int i = 0; i < m_ssetup->m_lights.count(); ++i)

  839.                 {

  840.                     //Store local dst in current m_ld

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

  842.                     if (i < m_light_datas.count())

  843.                         m_light_datas[i] = ltmp;

  844.                     else

  845.                         m_light_datas << ltmp;

  846. 

  847.                     vec3 loc = vec3::zero;

  848.                     vec4 col = vec4::zero;

  849.                     if (i < light_datas.count())

  850.                     {

  851.                         loc = light_datas[i].m_pos;

  852.                         col = light_datas[i].m_col;

  853.                     }

  854. 

  855.                     //Restore old light datas in new lights

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

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

  858.                 }

  859.             }

  860.             else

  861.             {

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

  863.                 delete new_ssetup;

  864.             }

  865.         }

  866.     }

  867. 

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

  869.     int o = 1;

  870.     while (o-- > 0)

  871.     {

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

  873.         {

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

  875.             {

  876.                 //Create a new mesh

  877.                 EasyMesh* em = new EasyMesh();

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

  879.                 {

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

  881.                     if (m_mesh_id == m_meshes.count() - 1)

  882.                         m_mesh_id++;

  883.                     m_meshes.push(em, nullptr);

  884.                 }

  885.                 else

  886.                     delete em;

  887.             }

  888.         }

  889.     }

  890.     m_ssetup->m_custom_cmd.clear();

  891. #endif //ALL_FEATURES

  892. 

  893. #if HAS_WEB

  894. /*

  895.     if (m_stream_update_time > .0f)

  896.     {

  897.         m_stream_update_time = -1.f;

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

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

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

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

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

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

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

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

  906.     }

  907. */

  908. #elif defined(_WIN32)

  909.     //--

  910.     //File management

  911.     //--

  912.     m_stream_update_time += seconds;

  913.     if (m_stream_update_time > m_stream_update_timer)

  914.     {

  915.         m_stream_update_time = 0.f;

  916. 

  917.         File f;

  918.         f.Open(m_file_name.c_str(), FileAccess::Read);

  919.         std::string cmd = f.ReadString().C();

  920.         f.Close();

  921. 

  922.         if (cmd.count()

  923.                 && (!m_cmdlist.count() || cmd != m_cmdlist.last()))

  924.         {

  925.             m_cmdlist << cmd;

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

  927.         }

  928.     }

  929. #endif //WINDOWS

  930. }

  931. 

  932. void MeshViewer::Draw(float seconds, Scene &scene)

  933. {

  934. 

  935.     if (!m_init || !m_first_tick)

  936.         return;

  937. 

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

  939. #if HAS_INPUT

  940.     {

  941.         if (KeyReleased(KEY_F2))

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

  943.         else if (KeyReleased(KEY_F1))

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

  945.     }

  946. #endif //HAS_INPUT

  947. 

  948. #if !HAS_WEB && WITH_TEXTURE

  949.     if (!m_default_texture)

  950.     {

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

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

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

  954.     }

  955.     else if (m_texture && m_default_texture)

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

  957. #endif //!HAS_WEB && WITH_TEXTURE

  958. 

  959.     scene.get_renderer()->SetClearColor(m_ssetup->m_clear_color);

  960. 

  961.     for (int i = 0; i < m_gizmos.count(); ++i)

  962.     {

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

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

  965.         else

  966.             break;

  967.     }

  968. 

  969.     if (m_build_timer > .0f)

  970.     {

  971.         if (m_build_time < .0f)

  972.         {

  973.             m_build_time = m_build_timer;

  974.             for (int i = 0; i < m_meshes.count(); ++i)

  975.             {

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

  977.                 {

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

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

  980.                     int ii = 1;

  981. #if 1

  982.                     bool stop = false;

  983.                     while (!stop)

  984.                     {

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

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

  987.                         {

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

  989.                             {

  990.                                 case EasyMeshCmdType::LoopStart:

  991.                                 case EasyMeshCmdType::LoopEnd:

  992.                                 case EasyMeshCmdType::OpenBrace:

  993.                                 case EasyMeshCmdType::CloseBrace:

  994.                                 case EasyMeshCmdType::ScaleWinding:

  995.                                 case EasyMeshCmdType::QuadWeighting:

  996.                                 case EasyMeshCmdType::PostBuildNormal:

  997.                                 case EasyMeshCmdType::PreventVertCleanup:

  998.                                 case EasyMeshCmdType::SetColorA:

  999.                                 case EasyMeshCmdType::SetColorB:

  1000.                                 {

  1001.                                     ii++;

  1002.                                     break;

  1003.                                 }

  1004.                                 default:

  1005.                                 {

  1006.                                     stop = true;

  1007.                                     break;

  1008.                                 }

  1009.                             }

  1010.                         }

  1011.                         else

  1012.                             stop = true;

  1013.                     }

  1014. #endif

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

  1016.                     newtmp->ExecuteCmdStack(false);

  1017. 

  1018.                     m_meshes[i].m1 = newtmp;

  1019.                     delete tmp;

  1020.                 }

  1021.             }

  1022.         }

  1023.         m_build_time -= seconds;

  1024.     }

  1025. 

  1026. #define NORMAL_USAGE 1

  1027. #if NORMAL_USAGE

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

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

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

  1031.                             //Y object Offset

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

  1033.                             //Mesh Pos Offset

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

  1035.                             //Align right meshes

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

  1037.     mat4 mat_gizmo = mat_obj_offset * mat_align * save_proj;

  1038.     for (int i = 0; i < m_meshes.count(); i++)

  1039.     {

  1040.         {

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

  1042.             {

  1043. #if WITH_TEXTURE

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

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

  1046.                                                                     m_texture_shader, true));

  1047. #else

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

  1049. #endif //WITH_TEXTURE

  1050.             }

  1051. #if ALL_FEATURES

  1052.             float j = -(float)(m_meshes.count() - (i + 1)) + (-m_mesh_id1 + (float)(m_meshes.count() - 1));

  1053. 

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

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

  1056.             {

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

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

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

  1060. 

  1061.                 //Mesh count offset

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

  1063.                 //Mesh count scale

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

  1065. 

  1066.                 //Camera projection

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

  1068.                 m_camera->SetProjection(new_proj);

  1069.                 m_meshes[i].m1->Render(scene, m_mat);

  1070.                 scene.get_renderer()->Clear(ClearMask::Depth);

  1071.             }

  1072.             m_camera->SetProjection(save_proj);

  1073. #else

  1074.             m_meshes[i].m1->Render(scene, m_mat);

  1075. #endif //ALL_FEATURES

  1076.         }

  1077.     }

  1078. 

  1079.     //Scene setup update

  1080.     if (m_ssetup)

  1081.     {

  1082.         m_camera->SetProjection(mat_gizmo);

  1083.         if (m_ssetup->m_show_gizmo)

  1084.             m_gizmos[GZ_Editor]->Render(scene, m_mat);

  1085. 

  1086.         if (m_ssetup->m_show_lights)

  1087.         {

  1088.             for (int k = 0; k < m_ssetup->m_lights.count(); ++k)

  1089.             {

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

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

  1092.                 mat4 local = mat4::translate((inverse(m_mat) * world)[3].xyz);

  1093.                 //dir light

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

  1095.                 {

  1096.                     m_gizmos[GZ_LightPos]->Render(scene, m_mat * inverse(local));

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

  1098.                 }

  1099.                 else //point light

  1100.                 {

  1101.                     m_gizmos[GZ_LightPos]->Render(scene, m_mat * local);

  1102.                 }

  1103.             }

  1104.         }

  1105.         m_camera->SetProjection(save_proj);

  1106.     }

  1107. #endif //NORMAL_USAGE

  1108. 

  1109. #if 0 //Debug normal draw

  1110.     for (int i = m_meshes.count() - 1; 0 <= i && i < m_meshes.count(); i++)

  1111.     {

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

  1113.         {

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

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

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

  1117.                                 };

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

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

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

  1121.         }

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

  1123.         {

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

  1125.             Debug::DrawLine((m_mat * mat4::translate(v.m_coord))[3].xyz,

  1126.                             (m_mat * mat4::translate(v.m_coord))[3].xyz +

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

  1128.         }

  1129.     }

  1130. #endif

  1131. }