lolengine
/
lol
kopie van https://github.com/lolengine/lol
1
0
Vork 0
Code Kwesties 0 Publicaties 0 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2550 Commits
5 Branches
64 MiB
 
 
 
Tree: d4e3ad4a4e
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'd4e3ad4a4e'
${ noResults }
lol/doc/samples/meshviewer/meshviewer.cpp

1095 regels
39 KiB
Ruw Blame Geschiedenis 

  1. 

  2. //

  3. // Lol Engine - EasyMesh tutorial

  4. //

  5. // Copyright: (c) 2011-2014 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 HAVE_CONFIG_H

  14. #   include "config.h"

  15. #endif

  16. 

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

  18. 

  19. #include <lol/engine.h>

  20. #include "scenesetup.h"

  21. 

  22. using namespace lol;

  23. 

  24. static int const TEXTURE_WIDTH = 256;

  25. 

  26. //Basic build defines ---------------------------------------------------------

  27. #define     HAS_WEB             (__native_client__ || EMSCRIPTEN)

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

  29. 

  30. //Basic config defines --------------------------------------------------------

  31. #define     R_M                 1.f

  32. #if HAS_WEB

  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      (800.f * R_M)

  38. #endif //HAS_WEB

  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. #include "meshviewer.h"

  65. 

  66. LOLFX_RESOURCE_DECLARE(shinyfur);

  67. LOLFX_RESOURCE_DECLARE(shinymvtexture);

  68. 

  69. //TargetCamera ----------------------------------------------------------------

  70. class TargetCamera

  71. {

  72. public:

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

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

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

  76.     void AddTarget(box3 new_target)

  77.     {

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

  79.         vec3 base_pos = new_target.A + base_off;

  80.         int pass = 0;

  81.         while (pass < 3)

  82.         {

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

  84.             while (mask-- > 0)

  85.             {

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

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

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

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

  90.             }

  91.             pass++;

  92.         }

  93.     }

  94. 

  95.     array<vec3>     m_targets;

  96. };

  97. 

  98. //EasyMeshViewerObject --------------------------------------------------------

  99. void EasyMeshViewerObject::TickDraw(float seconds, Scene &scene)

  100. {

  101.     switch (m_mesh.GetMeshState().ToScalar())

  102.     {

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

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

  105.     default: break;

  106.     }

  107. }

  108. 

  109. //EasyMeshLoadJob -------------------------------------------------------------

  110. bool EasyMeshLoadJob::DoWork()

  111. {

  112.     map<String, EasyMeshLuaObject*> meshes;

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

  114.     {

  115.         array<String> keys = meshes.keys();

  116.         for (String key : keys)

  117.             m_meshes << new EasyMeshViewerObject(key, meshes[key]->GetMesh());

  118.     }

  119.     return !!m_meshes.count();

  120. }

  121. 

  122. //-----------------------------------------------------------------------------

  123. MeshViewerLoadJob* EasyMeshLoadJob::GetInstance(String const& path)

  124. {

  125.     if (Check(path))

  126.         return new EasyMeshLoadJob(path);

  127.     return nullptr;

  128. }

  129. 

  130. //-----------------------------------------------------------------------------

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

  132. {

  133.     for (EasyMeshViewerObject* mesh : m_meshes)

  134.         app->AddViewerObj(mesh);

  135.     m_meshes.Empty();

  136. }

  137. 

  138. //MeshViewer ------------------------------------------------------------------

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

  140.     : m_file_name(file_name)

  141. {

  142.     LolImGui::Init();

  143. }

  144. 

  145. //-----------------------------------------------------------------------------

  146. MeshViewer::~MeshViewer()

  147. {

  148.     LolImGui::Shutdown();

  149.     Stop();

  150. }

  151. 

  152. //-----------------------------------------------------------------------------

  153. void MeshViewer::Start()

  154. {

  155.     /** OLD STUFF **/

  156.     //Prepare();

  157. 

  158.     //Threads setup

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

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

  161. 

  162.     //Scene setup

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

  164.     UpdateSceneSetup();

  165. 

  166.     //Mesh file

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

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

  169. 

  170.     //Camera setup

  171.     m_camera = new Camera();

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

  173.     m_camera->SetProjection(40.f, .0001f, 2000.f);

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

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

  176.     g_scene->PushCamera(m_camera);

  177. 

  178. #if HAS_INPUT

  179.     InputProfile& ip = m_profile;

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

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

  182. 

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

  184.     m_controller->Init(m_profile);

  185. #endif //HAS_INPUT

  186. 

  187.     /** ----- Register all entities ----- **/

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

  189. 

  190.     /** ----- Init is done ----- **/

  191.     m_init = true;

  192. 

  193.     /** ----- Start threads ----- **/

  194.     m_file_check->Start();

  195. 

  196. }

  197. 

  198. //-----------------------------------------------------------------------------

  199. void MeshViewer::Stop()

  200. {

  201.     //Destroy scene setup

  202.     UpdateSceneSetup(true);

  203. 

  204.     //Destroy core stuff

  205.     if (m_camera) g_scene->PopCamera(m_camera);

  206. 

  207.     m_file_check->UnregisterFile(m_file_status);

  208. 

  209.     //Register all entities

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

  211. 

  212.     //Delete objs

  213.     while (m_objs.count()) delete m_objs.Pop();

  214. 

  215.     //Nullify all

  216.     m_camera = nullptr;

  217.     m_controller = nullptr;

  218.     m_file_check = nullptr;

  219.     m_file_loader = nullptr;

  220. 

  221.     /** ----- Init is needed ----- **/

  222.     m_init = false;

  223. }

  224. 

  225. //-----------------------------------------------------------------------------

  226. void MeshViewer::UpdateSceneSetup(bool only_destroy)

  227. {

  228.     //Delete previous setups

  229.     array<String> keys = m_ssetups.keys();

  230.     for (String key : keys)

  231.         delete m_ssetups[key];

  232.     m_ssetups.empty();

  233.     if (m_ssetup_file_status)

  234.     {

  235.         m_file_check->UnregisterFile(m_ssetup_file_status);

  236.         delete m_ssetup_file_status;

  237.     }

  238.     m_ssetup_file_status = nullptr;

  239. 

  240.     //Init new setups

  241.     if (!only_destroy)

  242.     {

  243.         m_ssetup_loader.ExecLuaFile(m_ssetup_file_name);

  244.         if (m_ssetup_loader.GetLoadedSetups(m_ssetups))

  245.         {

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

  247.             array<String> keys = m_ssetups.keys();

  248.             if (!m_ssetup_name.count() || !keys.find(m_ssetup_name))

  249.                 m_ssetup_name = keys[0];

  250.         }

  251.     }

  252. }

  253. 

  254. //-----------------------------------------------------------------------------

  255. MeshViewerLoadJob* MeshViewer::GetLoadJob(String const& path)

  256. {

  257.     MeshViewerLoadJob* job = nullptr;

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

  259.     return job;

  260. }

  261. 

  262. //-----------------------------------------------------------------------------

  263. void MeshViewer::TickGame(float seconds)

  264. {

  265.     super::TickGame(seconds);

  266. 

  267.     if (!m_init && g_scene) Start();

  268.     if (!m_init) return;

  269. 

  270.     m_first_tick = true;

  271. 

  272. #if HAS_INPUT

  273.     {

  274.         //Shutdown logic

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

  276.             Ticker::Shutdown();

  277.     }

  278. #endif //HAS_INPUT

  279. 

  280.     static bool default_open = true;

  281.     //static float fov = 40.f;

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

  283.     //static bool use_custom_cam = true;

  284.     //static float f;

  285.     //static int mesh_idx = 0;

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

  287.     //static array<String> mesh_names_str;

  288. 

  289.     //Draw viewer objects

  290.     m_menu_mesh_names_char.empty();

  291.     m_menu_mesh_names_str.empty();

  292.     for (ViewerObject* obj : m_objs)

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

  294.     for (ptrdiff_t i = 0; i < m_menu_mesh_names_str.count(); ++i)

  295.         m_menu_mesh_names_char << m_menu_mesh_names_str[i].C();

  296. 

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

  298.     //CAMERA UI ---------------------------------------------------------------

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

  300.     {

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

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

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

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

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

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

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

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

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

  310. 

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

  312.         //ImGui::ListBox()

  313.     }

  314.     ImGui::End();

  315. 

  316.     //Camera

  317.     if (m_menu_cam_useage)

  318.     {

  319.         vec3 sphere_pos_rad = m_menu_cam_pos;

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

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

  322.         m_camera->SetFov(m_menu_cam_fov);

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

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

  325.     }

  326. 

  327.     //Check file update

  328.     ASSERT(m_file_status);

  329.     //if (false) //DEBUG

  330.     //m_file_status->GetTime()

  331.     if (m_file_status->HasUpdated())

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

  333. 

  334.     //Check work done

  335.     //if (false) //DEBUG

  336.     {

  337.         array<ThreadJob*> result;

  338.         m_file_loader->GetWorkResult(result);

  339.         if (result.count())

  340.         {

  341.             for (ThreadJob* job : result)

  342.             {

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

  344.                 {

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

  346.                     mvjob->RetrieveResult(this);

  347.                 }

  348.                 delete job;

  349.             }

  350.         }

  351.     }

  352. 

  353.     /** OLD STUFF **/

  354.     //Update(seconds);

  355. }

  356. 

  357. //-----------------------------------------------------------------------------

  358. void MeshViewer::TickDraw(float seconds, Scene &scene)

  359. {

  360.     super::TickDraw(seconds, scene);

  361. 

  362.     //Draw viewer objects

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

  364.         m_objs[m_menu_mesh_idx]->TickDraw(seconds, scene);

  365. 

  366.     //Draw gizmos & grid

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

  368.     Debug::DrawSetupColor(Color::white);

  369.     Debug::DrawSetupSegment(1.f);

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

  371. 

  372.     /** OLD STUFF **/

  373.     //Draw(seconds);

  374. }

  375. 

  376. //The basic main --------------------------------------------------------------

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

  378. {

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

  380. 

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

  382.     if (argc > 1)

  383.         new MeshViewer(argv[1]);

  384.     else

  385.         new MeshViewer();

  386.     app.Run();

  387. 

  388.     return EXIT_SUCCESS;

  389. }

  390. 

  391. //-------------------------------------------------------------------------

  392. //OLD ---------------------------------------------------------------------

  393. //-------------------------------------------------------------------------

  394. #if HAS_INPUT

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

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

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

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

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

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

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

  402. #endif //HAS_INPUT

  403. 

  404. void MeshViewer::Prepare()

  405. {

  406.     // Message Service

  407.     MessageService::Setup();

  408. 

  409.     //Compile ref meshes

  410.     m_gizmos << new EasyMesh();

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

  412.     m_gizmos << new EasyMesh();

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

  414.     m_gizmos << new EasyMesh();

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

  416. 

  417.     // Mesh Setup

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

  419.     m_mesh_render = 0;

  420.     m_mesh_id = 0;

  421.     m_mesh_id1 = 0.f;

  422.     m_default_texture = nullptr;

  423.     m_texture_shader = nullptr;

  424.     m_texture = nullptr;

  425. 

  426.     //Camera Setup

  427.     m_reset_timer = -1.f;

  428.     m_fov = -100.f;

  429.     m_fov_mesh = 0.f;

  430.     m_fov_speed = 0.f;

  431.     m_zoom = 0.f;

  432.     m_zoom_mesh = 0.f;

  433.     m_zoom_speed = 0.f;

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

  435.     m_rot_mesh = vec2::zero;

  436.     m_rot_speed = vec2::zero;

  437.     m_pos = vec2::zero;

  438.     m_pos_mesh = vec2::zero;

  439.     m_pos_speed = vec2::zero;

  440.     m_screen_offset = vec2::zero;

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

  442.     m_hist_scale_mesh = vec2(.0f);

  443.     m_hist_scale_speed = vec2(.0f);

  444. 

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

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

  447. 

  448.     m_build_timer = 0.1f;

  449.     m_build_time = -1.f;

  450. 

  451.     //stream update

  452.     m_stream_update_time = 2.0f;

  453.     m_stream_update_timer = 1.0f;

  454. 

  455.     m_init = true;

  456.     m_input_usage = 0;

  457. 

  458. #if HAS_INPUT

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

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

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

  462. 

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

  464.     {

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

  466. 

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

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

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

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

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

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

  473.     }

  474. 

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

  476.     {

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

  478. 

  479.         //Camera keyboard rotation

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

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

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

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

  484. 

  485.         //Camera keyboard position switch

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

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

  488. 

  489.         //Camera unzoom switch

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

  491. 

  492.         //Mesh change

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

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

  495. 

  496.         //Base setup

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

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

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

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

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

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

  503.     }

  504. #endif //HAS_INPUT

  505. 

  506. 

  507.     m_camera = new Camera();

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

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

  510.     m_camera->UseShift(true);

  511.     g_scene->PushCamera(m_camera);

  512. 

  513.     //Lights setup

  514.     m_ssetup = new SceneSetup();

  515. #if NO_SC_SETUP

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

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

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

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

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

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

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

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

  524.     EasyMesh* em = new EasyMesh();

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

  526.     {

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

  528.             m_mesh_id++;

  529.         m_meshes.Push(em, nullptr);

  530.     }

  531. #else

  532.     //TOUKY CHANGE THAT

  533.     /*

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

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

  536.     "showgizmo true ");

  537.     */

  538.     m_ssetup->Startup();

  539. #endif //NO_SC_SETUP

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

  541.     {

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

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

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

  545.     }

  546. }

  547. 

  548. void MeshViewer::Unprepare()

  549. {

  550.     if (m_camera) g_scene->PopCamera(m_camera);

  551.     if (m_ssetup) delete m_ssetup;

  552. 

  553.     MessageService::Destroy();

  554. 

  555.     //Register all entities

  556.     for (Entity* entity : m_entities)

  557.         Ticker::Unref(entity);

  558. 

  559.     m_controller = nullptr;

  560.     m_camera = nullptr;

  561.     m_ssetup = nullptr;

  562. 

  563.     /** ----- Init is needed ----- **/

  564.     m_init = false;

  565. }

  566. 

  567. void MeshViewer::Update(float seconds)

  568. {

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

  570. #if HAS_INPUT

  571.     {

  572.         //Shutdown logic

  573.         if (KeyReleased(KEY_ESC))

  574.             Ticker::Shutdown();

  575.     }

  576. #endif //HAS_INPUT

  577. 

  578.     //Compute render mesh count

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

  580.     float i_m = m_hist_scale_mesh.x;

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

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

  583. 

  584.     //Mesh Change

  585. #if HAS_INPUT

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

  587. #endif //HAS_INPUT

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

  589. 

  590. #if ALL_FEATURES

  591. 

  592.     //Update light position & damping

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

  594.     {

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

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

  597. 

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

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

  600. 

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

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

  603.     }

  604. 

  605.     //Camera update

  606.     bool is_pos = false;

  607.     bool is_fov = false;

  608.     bool is_hsc = false;

  609.     vec2 tmpv = vec2::zero;

  610. 

  611. #if HAS_INPUT

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

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

  614. 

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

  616.     {

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

  618.         if (KeyDown(MSE_CAM_ROT))

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

  620.         if (KeyDown(MSE_CAM_POS))

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

  622.         if (KeyDown(MSE_CAM_FOV))

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

  624.     }

  625. 

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

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

  628. #endif //HAS_INPUT

  629. 

  630.     //Base data

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

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

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

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

  635. 

  636.     //speed

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

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

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

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

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

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

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

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

  645. 

  646.     m_rot += m_rot_speed * seconds;

  647. 

  648. #if HAS_INPUT

  649.     if (m_reset_timer >= 0.f)

  650.         m_reset_timer -= seconds;

  651.     if (KeyPressed(KEY_CAM_RESET))

  652.     {

  653.         if (m_reset_timer >= 0.f)

  654.         {

  655.             m_pos = vec2(0.f);

  656.             m_zoom = 0.f;

  657.         }

  658.         else

  659.             m_reset_timer = RESET_TIMER;

  660.     }

  661. 

  662.     //Transform update

  663.     if (!KeyDown(KEY_CAM_RESET))

  664.     {

  665.         m_pos += m_pos_speed * seconds;

  666.         m_fov += m_fov_speed * seconds;

  667.         m_zoom += m_zoom_speed * seconds;

  668.         m_hist_scale += m_hist_scale_speed * seconds;

  669.     }

  670. #endif //HAS_INPUT

  671. 

  672.     //clamp

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

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

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

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

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

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

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

  680. 

  681. #if HAS_INPUT

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

  683.     {

  684.         pos_mesh = vec2::zero;

  685.         zoom_mesh = 0.f;

  686.     }

  687. #endif //HAS_INPUT

  688. 

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

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

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

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

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

  694. 

  695.     //Mesh mat calculation

  696.     m_mat_prev = m_mat;

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

  698. 

  699.     //Target List Setup

  700.     TargetCamera tc;

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

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

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

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

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

  706.     {

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

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

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

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

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

  712.     }

  713. 

  714.     //--

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

  716.     //--

  717.     vec2 cam_center(0.f);

  718.     float cam_factor = .0f;

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

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

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

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

  723. 

  724.     //target on-screen computation

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

  726.     {

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

  728.         {

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

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

  731.             vec3 vpos;

  732. 

  733.             //Get location in cam coordinates

  734.             target_mx = world_cam * target_mx;

  735.             vpos = target_mx[3].xyz;

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

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

  738. 

  739.             //Get location in screen coordinates

  740.             target_mx = cam_screen * target_mx;

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

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

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

  744. 

  745.             //Build Barycenter

  746.             cam_center += vpos.xy;

  747.             cam_factor += 1.f;

  748.         }

  749.     }

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

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

  752.     float z_dist = //m_camera->m_target_distance

  753.         length(m_camera->m_position)

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

  755. 

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

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

  758. 

  759.     float forced_zoom = m_zoom_mesh;

  760. 

  761.     if (cam_factor > 0.f)

  762.     {

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

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

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

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

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

  768.         m_camera->SetFov(m_fov_mesh);

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

  770. 

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

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

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

  774.     }

  775. 

  776.     //--

  777.     //Message Service

  778.     //--

  779.     String mesh("");

  780.     int u = 1;

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

  782.     {

  783.         int o = 1;

  784.         while (o-- > 0)

  785.         {

  786.             SceneSetup* new_ssetup = new SceneSetup();

  787.             if (false) //new_ssetup->Compile(mesh.C()) && new_ssetup->m_lights.Count())

  788.             {

  789.                 //Store current light datas, in World

  790.                 array<LightData> light_datas;

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

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

  793. 

  794.                 if (m_ssetup)

  795.                     delete m_ssetup;

  796.                 m_ssetup = new_ssetup;

  797.                 m_ssetup->Startup();

  798. 

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

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

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

  802.                 {

  803.                     //Store local dst in current m_ld

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

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

  806.                         m_light_datas[i] = ltmp;

  807.                     else

  808.                         m_light_datas << ltmp;

  809. 

  810.                     vec3 loc = vec3::zero;

  811.                     vec4 col = vec4::zero;

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

  813.                     {

  814.                         loc = light_datas[i].m_pos;

  815.                         col = light_datas[i].m_col;

  816.                     }

  817. 

  818.                     //Restore old light datas in new lights

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

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

  821.                 }

  822.             }

  823.             else

  824.             {

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

  826.                 delete new_ssetup;

  827.             }

  828.         }

  829.     }

  830. 

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

  832.     int o = 1;

  833.     while (o-- > 0)

  834.     {

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

  836.         {

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

  838.             {

  839.                 //Create a new mesh

  840.                 EasyMesh* em = new EasyMesh();

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

  842.                 {

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

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

  845.                         m_mesh_id++;

  846.                     m_meshes.Push(em, nullptr);

  847.                 }

  848.                 else

  849.                     delete em;

  850.             }

  851.         }

  852.     }

  853.     m_ssetup->m_custom_cmd.Empty();

  854. #endif //ALL_FEATURES

  855. 

  856. #if HAS_WEB

  857. /*

  858.     if (m_stream_update_time > .0f)

  859.     {

  860.         m_stream_update_time = -1.f;

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

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

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

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

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

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

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

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

  869.     }

  870. */

  871. #elif defined(_WIN32)

  872.     //--

  873.     //File management

  874.     //--

  875.     m_stream_update_time += seconds;

  876.     if (m_stream_update_time > m_stream_update_timer)

  877.     {

  878.         m_stream_update_time = 0.f;

  879. 

  880.         File f;

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

  882.         String cmd = f.ReadString();

  883.         f.Close();

  884. 

  885.         if (cmd.Count()

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

  887.         {

  888.             m_cmdlist << cmd;

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

  890.         }

  891.     }

  892. #endif //WINDOWS

  893. }

  894. 

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

  896. {

  897. 

  898.     if (!m_init || !m_first_tick)

  899.         return;

  900. 

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

  902. #if HAS_INPUT

  903.     {

  904.         if (KeyReleased(KEY_F2))

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

  906.         else if (KeyReleased(KEY_F1))

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

  908.     }

  909. #endif //HAS_INPUT

  910. 

  911. #if !HAS_WEB && WITH_TEXTURE

  912.     if (!m_default_texture)

  913.     {

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

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

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

  917.     }

  918.     else if (m_texture && m_default_texture)

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

  920. #endif //!HAS_WEB && WITH_TEXTURE

  921. 

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

  923. 

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

  925.     {

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

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

  928.         else

  929.             break;

  930.     }

  931. 

  932.     if (m_build_timer > .0f)

  933.     {

  934.         if (m_build_time < .0f)

  935.         {

  936.             m_build_time = m_build_timer;

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

  938.             {

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

  940.                 {

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

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

  943.                     int ii = 1;

  944. #if 1

  945.                     bool stop = false;

  946.                     while (!stop)

  947.                     {

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

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

  950.                         {

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

  952.                             {

  953.                                 case EasyMeshCmdType::LoopStart:

  954.                                 case EasyMeshCmdType::LoopEnd:

  955.                                 case EasyMeshCmdType::OpenBrace:

  956.                                 case EasyMeshCmdType::CloseBrace:

  957.                                 case EasyMeshCmdType::ScaleWinding:

  958.                                 case EasyMeshCmdType::QuadWeighting:

  959.                                 case EasyMeshCmdType::PostBuildNormal:

  960.                                 case EasyMeshCmdType::PreventVertCleanup:

  961.                                 case EasyMeshCmdType::SetColorA:

  962.                                 case EasyMeshCmdType::SetColorB:

  963.                                 {

  964.                                     ii++;

  965.                                     break;

  966.                                 }

  967.                                 default:

  968.                                 {

  969.                                     stop = true;

  970.                                     break;

  971.                                 }

  972.                             }

  973.                         }

  974.                         else

  975.                             stop = true;

  976.                     }

  977. #endif

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

  979.                     newtmp->ExecuteCmdStack(false);

  980. 

  981.                     m_meshes[i].m1 = newtmp;

  982.                     delete tmp;

  983.                 }

  984.             }

  985.         }

  986.         m_build_time -= seconds;

  987.     }

  988. 

  989. #define NORMAL_USAGE 1

  990. #if NORMAL_USAGE

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

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

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

  994.                             //Y object Offset

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

  996.                             //Mesh Pos Offset

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

  998.                             //Align right meshes

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

  1000.     mat4 mat_gizmo = mat_obj_offset * mat_align * save_proj;

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

  1002.     {

  1003.         {

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

  1005.             {

  1006. #if WITH_TEXTURE

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

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

  1009.                                                                     m_texture_shader, true));

  1010. #else

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

  1012. #endif //WITH_TEXTURE

  1013.             }

  1014. #if ALL_FEATURES

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

  1016. 

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

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

  1019.             {

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

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

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

  1023. 

  1024.                 //Mesh count offset

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

  1026.                 //Mesh count scale

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

  1028. 

  1029.                 //Camera projection

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

  1031.                 m_camera->SetProjection(new_proj);

  1032.                 scene.AddPrimitive(*m_meshes[i].m1, m_mat);

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

  1034.             }

  1035.             m_camera->SetProjection(save_proj);

  1036. #else

  1037.             scene.AddPrimitive(*m_meshes[i].m1, m_mat);

  1038. #endif //ALL_FEATURES

  1039.         }

  1040.     }

  1041. 

  1042.     //Scene setup update

  1043.     if (m_ssetup)

  1044.     {

  1045.         m_camera->SetProjection(mat_gizmo);

  1046.         if (m_ssetup->m_show_gizmo)

  1047.             scene.AddPrimitive(*m_gizmos[GZ_Editor], m_mat);

  1048. 

  1049.         if (m_ssetup->m_show_lights)

  1050.         {

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

  1052.             {

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

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

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

  1056.                 //dir light

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

  1058.                 {

  1059.                     scene.AddPrimitive(*m_gizmos[GZ_LightPos], m_mat * inverse(local));

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

  1061.                 }

  1062.                 else //point light

  1063.                 {

  1064.                     scene.AddPrimitive(*m_gizmos[GZ_LightPos], m_mat * local);

  1065.                 }

  1066.             }

  1067.         }

  1068.         m_camera->SetProjection(save_proj);

  1069.     }

  1070. #endif //NORMAL_USAGE

  1071. 

  1072. #if 0 //Debug normal draw

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

  1074.     {

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

  1076.         {

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

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

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

  1080.                                 };

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

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

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

  1084.         }

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

  1086.         {

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

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

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

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

  1091.         }

  1092.     }

  1093. #endif

  1094. }