source: trunk/test/meshviewer.cpp @ 2838

Last change on this file since 2838 was 2838, checked in by sam, 6 years ago

test: port the btphystest and meshviewer tests to the new input API.

  • Property svn:eol-style set to LF
File size: 21.2 KB
Line 
1
2//
3// Lol Engine - EasyMesh tutorial
4//
5// Copyright: (c) 2011-2013 Sam Hocevar <sam@hocevar.net>
6//            (c) 2012-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
7//   This program is free software; you can redistribute it and/or
8//   modify it under the terms of the Do What The Fuck You Want To
9//   Public License, Version 2, as published by Sam Hocevar. See
10//   http://www.wtfpl.net/ for more details.
11//
12
13#if defined HAVE_CONFIG_H
14#   include "config.h"
15#endif
16
17#include <cfloat> /* for FLT_MAX */
18
19#include "core.h"
20
21using namespace std;
22using namespace lol;
23
24static int const TEXTURE_WIDTH = 256;
25
26LOLFX_RESOURCE_DECLARE(shinyfur);
27LOLFX_RESOURCE_DECLARE(shinymvtexture);
28
29enum
30{
31    KEY_CAM_RESET,
32    KEY_CAM_FORWARD,
33    KEY_CAM_BACKWARD,
34    KEY_CAM_ZOOM_OUT,
35    KEY_CAM_ZOOM_IN,
36
37    KEY_MESH_UPDATE,
38    KEY_MESH_RESET,
39    KEY_MESH_PREV,
40    KEY_MESH_NEXT,
41
42    KEY_MESH_LEFT,
43    KEY_MESH_RIGHT,
44    KEY_MESH_UP,
45    KEY_MESH_DOWN,
46    KEY_MESH_SCALE_UP,
47    KEY_MESH_SCALE_DOWN,
48    KEY_MESH_OFFSET_UP,
49    KEY_MESH_OFFSET_DOWN,
50    KEY_MESH_ROT_LEFT,
51    KEY_MESH_ROT_RIGHT,
52    KEY_MESH_ROT_UP,
53    KEY_MESH_ROT_DOWN,
54
55    KEY_F1,
56    KEY_F2,
57    KEY_F3,
58    KEY_F4,
59    KEY_F5,
60    KEY_ESC,
61
62    KEY_MAX,
63};
64
65#define    MIN_FOV                0.1f
66
67#define    WITH_FUR               0
68#define    WITH_TEXTURE           0
69
70class MeshViewer : public WorldEntity
71{
72public:
73    void SetFov(float new_fov=60.0f, vec2 video_size = vec2(Video::GetSize()))
74    {
75        if (new_fov > MIN_FOV)
76            g_scene->GetCamera()->SetProjection(mat4::perspective(new_fov, video_size.x, video_size.y, .1f, 1000.f));
77        else
78            g_scene->GetCamera()->SetProjection(mat4::ortho(video_size.x, video_size.y, .1f, 1000.f));
79    }
80
81    MeshViewer(char const *file_name = "data/mesh-buffer.txt")
82      : m_file_name(file_name)
83    {
84        /* Register an input controller for the keyboard */
85        m_controller = new Controller(KEY_MAX, 0);
86
87        m_controller->GetKey(KEY_CAM_RESET).Bind("Keyboard", "Return");
88        m_controller->GetKey(KEY_CAM_ZOOM_IN).Bind("Keyboard", "PageUp");
89        m_controller->GetKey(KEY_CAM_ZOOM_OUT).Bind("Keyboard", "PageDown");
90
91        m_controller->GetKey(KEY_MESH_LEFT).Bind("Keyboard", "Left");
92        m_controller->GetKey(KEY_MESH_RIGHT).Bind("Keyboard", "Right");
93        m_controller->GetKey(KEY_MESH_UP).Bind("Keyboard", "Up");
94        m_controller->GetKey(KEY_MESH_DOWN).Bind("Keyboard", "Down");
95
96        m_controller->GetKey(KEY_MESH_UPDATE).Bind("Keyboard", "Space");
97        m_controller->GetKey(KEY_MESH_RESET).Bind("Keyboard", "KP0");
98        m_controller->GetKey(KEY_MESH_PREV).Bind("Keyboard", "KPPlus");
99        m_controller->GetKey(KEY_MESH_NEXT).Bind("Keyboard", "KPMinus");
100
101        m_controller->GetKey(KEY_MESH_OFFSET_DOWN).Bind("Keyboard", "KP1");
102        m_controller->GetKey(KEY_MESH_OFFSET_UP).Bind("Keyboard", "KP3");
103        m_controller->GetKey(KEY_MESH_SCALE_DOWN).Bind("Keyboard", "KP7");
104        m_controller->GetKey(KEY_MESH_SCALE_UP).Bind("Keyboard", "KP9");
105
106        m_controller->GetKey(KEY_MESH_ROT_LEFT).Bind("Keyboard", "KP4");
107        m_controller->GetKey(KEY_MESH_ROT_RIGHT).Bind("Keyboard", "KP6");
108        m_controller->GetKey(KEY_MESH_ROT_UP).Bind("Keyboard", "KP8");
109        m_controller->GetKey(KEY_MESH_ROT_DOWN).Bind("Keyboard", "KP5");
110
111        m_controller->GetKey(KEY_F1).Bind("Keyboard", "F1");
112        m_controller->GetKey(KEY_F2).Bind("Keyboard", "F2");
113        m_controller->GetKey(KEY_F3).Bind("Keyboard", "F3");
114        m_controller->GetKey(KEY_F4).Bind("Keyboard", "F4");
115        m_controller->GetKey(KEY_F5).Bind("Keyboard", "F5");
116        m_controller->GetKey(KEY_ESC).Bind("Keyboard", "Escape");
117
118        // State
119        m_mesh_shown = 0;
120        m_angle = 0;
121        m_default_texture = NULL;
122
123        //Camera Setup
124        m_fov_zoom_damp = .0f;
125        m_fov_damp = 60.0f;
126        m_fov = 60.0f;
127        m_camera = new Camera();
128        SetFov(m_fov_damp);
129        m_camera->SetView(vec3(0.f, 0.f, 10.f),
130                          vec3(0.f, 0.f, 0.f),
131                          vec3(0.f, 1.f, 0.f));
132        g_scene->PushCamera(m_camera);
133
134        //Lights setup
135        m_lights << new Light();
136        m_lights.Last()->SetPosition(vec4(4.f, -1.f, -4.f, 0.f));
137        m_lights.Last()->SetColor(vec4(.0f, .2f, .5f, 1.f));
138        Ticker::Ref(m_lights.Last());
139
140        m_lights << new Light();
141        m_lights.Last()->SetPosition(vec4(8.f, 2.f, 6.f, 1.f));
142        m_lights.Last()->SetColor(vec4(.5f, .3f, .0f, 1.f));
143        Ticker::Ref(m_lights.Last());
144
145        //Speed damp
146        m_mesh_rotate_damp = vec2(.0f);
147        m_mesh_screen_move_damp = vec2(.0f);
148        m_mesh_move_damp = vec2(.0f);
149
150        //Actual values
151        SetDefaultMeshTransform();
152
153        //Actual values damp
154        m_mesh_rotation_damp = vec2(.0f);
155        m_mesh_screen_offset_damp = vec2(.0f);
156        m_mesh_offset_damp = vec2(.0f);
157
158
159        m_mat = mat4::rotate(m_mesh_rotation.x, vec3(1, 0, 0)) *
160                mat4::rotate(m_angle, vec3(0, 1, 0)) *
161                mat4::rotate(m_mesh_rotation.y, vec3(0, 1, 0));
162
163        m_stream_update_time = 2.0f;
164        m_stream_update_timer = 1.0f;
165    }
166
167    ~MeshViewer()
168    {
169        g_scene->PopCamera(m_camera);
170        for (int i = 0; i < m_lights.Count(); ++i)
171            Ticker::Unref(m_lights[i]);
172    }
173
174    void SetDefaultMeshTransform()
175    {
176        m_mesh_rotation = vec2(25.0f, .0f);
177        m_mesh_screen_offset = vec2(.54f, .0f);
178        m_mesh_offset = vec2(-.64f, .07f);
179    }
180
181    virtual void TickGame(float seconds)
182    {
183        WorldEntity::TickGame(seconds);
184
185        //TODO : This should probably be "standard LoL behaviour"
186        {
187            //Shutdown logic
188            if (m_controller->GetKey(KEY_ESC).IsReleased())
189                Ticker::Shutdown();
190        }
191
192        //--
193        //Update Mesh BBox - Get the Min/Max needed
194        //--
195        vec2 screen_min_max[2] = { vec2(FLT_MAX), vec2(-FLT_MAX) };
196        vec3 cam_min_max[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
197        vec3 world_min_max[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
198        int mesh_id = m_meshes.Count() - 1;
199        for (; mesh_id >= 0; mesh_id--)
200            if (m_meshes[mesh_id].m2)
201                break;
202
203        mat4 world_cam = g_scene->GetCamera()->GetView();
204        mat4 cam_screen = g_scene->GetCamera()->GetProjection();
205
206        if (m_meshes.Count() && mesh_id >= 0)
207        {
208            for (int i = 0; i < m_meshes[mesh_id].m1.GetVertexCount(); i++)
209            {
210                //--
211                mat4 LocalPos = m_mat * mat4::translate(m_meshes[mesh_id].m1.GetVertexLocation(i));
212                vec3 vpos = LocalPos.v3.xyz;
213
214                world_min_max[0] = min(vpos.xyz, world_min_max[0]);
215                world_min_max[1] = max(vpos.xyz, world_min_max[1]);
216
217                //--
218                LocalPos = world_cam * LocalPos;
219                vpos = LocalPos.v3.xyz;
220
221                cam_min_max[0] = min(vpos.xyz, cam_min_max[0]);
222                cam_min_max[1] = max(vpos.xyz, cam_min_max[1]);
223
224                //--
225                LocalPos = cam_screen * LocalPos;
226                vpos = (LocalPos.v3 / LocalPos.v3.w).xyz;
227
228                screen_min_max[0] = min(vpos.xy, screen_min_max[0]);
229                screen_min_max[1] = max(vpos.xy, screen_min_max[1]);
230            }
231        }
232        else
233        {
234            world_min_max[1] = vec3(.0f);
235            world_min_max[0] = vec3(.0f);
236            cam_min_max[1] = vec3(.0f);
237            cam_min_max[0] = vec3(.0f);
238            screen_min_max[0] = vec2(.0f);
239            screen_min_max[1] = vec2(.0f);
240        }
241        //[0] : center, [1] : size.
242        vec3 BBox[2] = { vec3(.0f), vec3(.0f) };
243        BBox[1] = world_min_max[1] - world_min_max[0];
244        BBox[0] = world_min_max[0] + BBox[1] * .5f;
245        vec3 BBox_mod = BBox[1];
246#if 0
247
248        //--
249        //Camera movement handling
250        //--
251        if (m_controller->GetKey(KEY_CAM_RESET).IsReleased())
252            SetFov();
253
254        //Auto Fov
255        float local_max = max(max(lol::abs(world_min_max[0].x), lol::abs(world_min_max[0].y)),
256                          max(    lol::abs(world_min_max[1].x), lol::abs(world_min_max[1].y)));
257        float fov_ratio = max(max(lol::abs(screen_min_max[0].x), lol::abs(screen_min_max[0].y)),
258                              max(lol::abs(screen_min_max[1].x), lol::abs(screen_min_max[1].y)));
259
260        //Fov modification
261        float fov_zoom = (float)(Input::GetStatus(IPT_CAM_ZOOM_OUT) - Input::GetStatus(IPT_CAM_ZOOM_IN));
262        m_fov_zoom_damp = damp(m_fov_zoom_damp, fov_zoom, (fov_zoom == .0f)?(.15f):(0.5f), seconds);
263        m_fov = max(.0f, m_fov + seconds * 10.0f * m_fov_zoom_damp);
264        m_fov_damp = damp(m_fov_damp, m_fov, .2f, seconds);
265
266        if (m_fov_damp < MIN_FOV)
267        {
268            vec2 tmp = vec2(Video::GetSize());
269            SetFov(0, vec2(local_max * 2.2f) * (tmp / vec2(tmp.y)));
270        }
271        else
272            SetFov(m_fov_damp);
273
274        //Move modification
275        vec3 campos = g_scene->GetCamera()->GetPosition();
276        if (m_fov_damp < MIN_FOV)
277            g_scene->GetCamera()->SetView(vec3(campos.xy, 10.f), quat(1.f));
278        else if (fov_ratio > .0f)
279            g_scene->GetCamera()->SetView(vec3(campos.xy, campos.z * fov_ratio * 1.1f), quat(1.f));
280#else
281        Camera* cur_cam = g_scene->GetCamera();
282        vec3 min_max_diff = (cam_min_max[1] - cam_min_max[0]);
283        float screen_size = max(max(lol::abs(min_max_diff.x), lol::abs(min_max_diff.y)),
284                            max(    lol::abs(min_max_diff.x), lol::abs(min_max_diff.y)));
285        float fov_ratio = max(max(lol::abs(screen_min_max[0].x), lol::abs(screen_min_max[0].y)),
286                              max(lol::abs(screen_min_max[1].x), lol::abs(screen_min_max[1].y)));
287
288        float fov_zoom = 0.f;
289        fov_zoom += m_controller->GetKey(KEY_CAM_ZOOM_OUT).IsDown() ? 1.f : 0.f;
290        fov_zoom -= m_controller->GetKey(KEY_CAM_ZOOM_IN).IsDown() ? 1.f : 0.f;
291        m_fov_zoom_damp = damp(m_fov_zoom_damp, fov_zoom, (fov_zoom == .0f)?(.15f):(0.5f), seconds);
292        m_fov = max(.0f, m_fov + seconds * 10.0f * m_fov_zoom_damp);
293        m_fov_damp = damp(m_fov_damp, m_fov, .2f, seconds);
294
295        if (m_fov_damp < MIN_FOV)
296            cur_cam->SetProjection(mat4::ortho(screen_size * fov_ratio * 1.1f, 1600.f / 600.f, 1000.f));
297        else if (fov_ratio > .0f)
298            cur_cam->SetProjection(mat4::shifted_perspective(m_fov_damp, screen_size * fov_ratio * 1.1f, 1600.f / 600.f, 1000.f));
299
300        vec3 cam_center = cam_min_max[0] + min_max_diff * .5f;
301
302        vec4 test = inverse(world_cam) * vec4(.0f,.0f,-1.0f,1.f);
303        test = test;
304        test = inverse(world_cam) * vec4(.0f,.0f,.0f,1.f);
305        test = inverse(world_cam) * vec4(.0f,.0f,1.0f,1.f);
306
307        vec3 eye = (inverse(world_cam) * vec4(vec3(cam_center.xy, cam_min_max[1].z), 1.f)).xyz;
308        vec3 target = (inverse(world_cam) * vec4(vec3(cam_center.xy, cam_min_max[0].z), 1.f)).xyz;
309        if (eye == target)
310            cur_cam->SetView(vec3(.0f), vec3(.0f, .0f, -1.f), vec3(0.f, 1.f, 0.f));
311        else
312            cur_cam->SetView(eye, target, vec3(0,1,0));
313#endif
314
315        //--
316        //Mesh movement handling
317        //--
318        if (m_controller->GetKey(KEY_MESH_RESET).IsReleased())
319            SetDefaultMeshTransform();
320
321        m_mesh_shown += m_controller->GetKey(KEY_MESH_NEXT).IsReleased() ? 1 : 0;
322        m_mesh_shown -= m_controller->GetKey(KEY_MESH_PREV).IsReleased() ? 1 : 0;
323        m_mesh_shown = clamp(m_mesh_shown, 0, max(m_meshes.Count(), 1) - 1);
324
325        vec2 new_move = vec2(.0f);
326        new_move.x += m_controller->GetKey(KEY_MESH_RIGHT).IsDown() ? 1.f : 0.f;
327        new_move.x -= m_controller->GetKey(KEY_MESH_LEFT).IsDown() ? 1.f : 0.f;
328        new_move.y += m_controller->GetKey(KEY_MESH_UP).IsDown() ? 1.f : 0.f;
329        new_move.y -= m_controller->GetKey(KEY_MESH_DOWN).IsDown() ? 1.f : 0.f;
330
331        m_mesh_screen_move_damp = vec2(damp(m_mesh_screen_move_damp.x, new_move.x, (new_move.x == .0f)?(.15f):(0.5f), seconds),
332                                         damp(m_mesh_screen_move_damp.y, new_move.y, (new_move.y == .0f)?(.15f):(0.5f), seconds));
333
334        new_move.x = m_controller->GetKey(KEY_MESH_OFFSET_UP).IsDown() ? 1.f : 0.f;
335        new_move.x -= m_controller->GetKey(KEY_MESH_OFFSET_DOWN).IsDown() ? 1.f : 0.f;
336        new_move.y = m_controller->GetKey(KEY_MESH_SCALE_UP).IsDown() ? 1.f : 0.f;
337        new_move.y -= m_controller->GetKey(KEY_MESH_SCALE_DOWN).IsDown() ? 1.f : 0.f;
338        m_mesh_move_damp = vec2(damp(m_mesh_move_damp.x, new_move.x, (new_move.x == .0f)?(.15f):(0.5f), seconds),
339                                  damp(m_mesh_move_damp.y, new_move.y, (new_move.y == .0f)?(.15f):(0.5f), seconds));
340
341        new_move.x = m_controller->GetKey(KEY_MESH_ROT_UP).IsDown() ? 1.f : 0.f;
342        new_move.x -= m_controller->GetKey(KEY_MESH_ROT_DOWN).IsDown() ? 1.f : 0.f;
343        new_move.y = m_controller->GetKey(KEY_MESH_ROT_RIGHT).IsDown() ? 1.f : 0.f;
344        new_move.y -= m_controller->GetKey(KEY_MESH_ROT_LEFT).IsDown() ? 1.f : 0.f;
345        m_mesh_rotate_damp = vec2(damp(m_mesh_rotate_damp.x, new_move.x, (new_move.x == .0f)?(.15f):(0.5f), seconds),
346                                    damp(m_mesh_rotate_damp.y, new_move.y, (new_move.y == .0f)?(.15f):(0.5f), seconds));
347
348        vec2 mesh_screen_move = seconds * 0.6f * m_mesh_screen_move_damp;
349        vec2 mesh_offset_move = seconds * vec2(.6f, .2f) * m_mesh_move_damp;
350        vec2 mesh_rotate = seconds * vec2(40.0f, 60.0f) * m_mesh_rotate_damp;
351
352        //Add movement
353        m_mesh_screen_offset += mesh_screen_move;
354        m_mesh_offset += mesh_offset_move;
355        m_mesh_rotation += mesh_rotate;
356
357        //Compute damp
358        m_mesh_rotation_damp = damp(m_mesh_rotation_damp, m_mesh_rotation, .2f, seconds);
359        m_mesh_screen_offset_damp = damp(m_mesh_screen_offset_damp, m_mesh_screen_offset, .2f, seconds);
360        m_mesh_offset_damp = damp(m_mesh_offset_damp, m_mesh_offset, .2f, seconds);
361
362        //Clamp necessary
363        m_mesh_rotation.x = clamp(m_mesh_rotation.x, -90.0f, 90.0f);
364        m_mesh_offset.y = max(.0f, m_mesh_offset.y);
365
366        //m_angle += seconds * 70.0f;
367        m_mat = mat4::rotate(m_mesh_rotation.x, vec3(1, 0, 0)) *
368                mat4::rotate(m_angle, vec3(0, 1, 0)) *
369                mat4::rotate(m_mesh_rotation.y, vec3(0, 1, 0));
370
371        //--
372        //File management
373        //--
374        if (m_controller->GetKey(KEY_MESH_UPDATE).IsReleased())
375            m_stream_update_time = m_stream_update_timer + 1.0f;
376        m_stream_update_time += seconds;
377
378        if (m_stream_update_time > m_stream_update_timer)
379        {
380            m_stream_update_time = 0.f;
381
382            File f;
383            f.Open(m_file_name.C(), FileAccess::Read);
384            String cmd = f.ReadString();
385            f.Close();
386
387            for (int i = 0; i < cmd.Count() - 1; i++)
388            {
389                if (cmd[i] == '/' && cmd[i + 1] == '/')
390                {
391                    int j = i;
392                    for (; j < cmd.Count(); j++)
393                    {
394                        if (cmd[j] == '\r' || cmd[j] == '\n')
395                            break;
396                    }
397                    String new_cmd = cmd.Sub(0, i);
398                    if (j < cmd.Count())
399                        new_cmd += cmd.Sub(j, cmd.Count() - j);
400                    cmd = new_cmd;
401                    i--;
402                }
403            }
404
405            if (cmd.Count()
406                 && (!m_cmdlist.Count() || cmd != m_cmdlist.Last()))
407            {
408                m_cmdlist << cmd;
409
410                //Create a new mesh
411                m_meshes.Push(EasyMesh(), false, .0f, vec3(.0f));
412                if (!m_meshes.Last().m1.Compile(cmd.C()))
413                    m_meshes.Pop();
414                //else
415                //    m_meshes.Last().m1.ComputeTexCoord(0.2f, 2);
416            }
417        }
418    }
419
420    virtual void TickDraw(float seconds)
421    {
422        WorldEntity::TickDraw(seconds);
423
424        //TODO : This should probably be "standard LoL behaviour"
425        {
426            if (m_controller->GetKey(KEY_F1).IsReleased())
427                Video::SetDebugRenderMode(DebugRenderMode::Default);
428            if (m_controller->GetKey(KEY_F2).IsReleased())
429                Video::SetDebugRenderMode(DebugRenderMode::Wireframe);
430            if (m_controller->GetKey(KEY_F3).IsReleased())
431                Video::SetDebugRenderMode(DebugRenderMode::Lighting);
432            if (m_controller->GetKey(KEY_F4).IsReleased())
433                Video::SetDebugRenderMode(DebugRenderMode::Normal);
434            if (m_controller->GetKey(KEY_F5).IsReleased())
435                Video::SetDebugRenderMode(DebugRenderMode::UV);
436        }
437
438        if (!m_default_texture)
439        {
440            m_texture_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinymvtexture));
441            m_texture_uni = m_texture_shader->GetUniformLocation("u_Texture");
442            //m_image = new Image("data/test-texture.png");
443            m_default_texture = Tiler::Register("data/test-texture.png", ivec2(0), ivec2(0,1));
444
445            //ivec2 size = m_image->GetSize();
446            //// m_image->GetFormat()
447            //m_texture = new Texture(m_image->GetSize(), PixelFormat::ABGR_8);
448            //m_texture->SetData(m_image->GetData());
449            // PixelFormat::ABGR_8
450        }
451        else if (m_texture && m_default_texture)
452            m_texture_shader->SetUniform(m_texture_uni, m_default_texture->GetTexture(), 0);
453
454        for (int i = 0; i < m_meshes.Count(); i++)
455        {
456            if (!m_meshes[i].m2)
457            {
458                //Fur support
459#if WITH_FUR
460                m_meshes[i].m1.MeshConvert(Shader::Create(LOLFX_RESOURCE_NAME(shinyfur)));
461#elif WITH_TEXTURE
462                //m_meshes[i].m1.MeshConvert(m_texture_shader);
463                //m_meshes[i].m1.MeshConvert();
464                m_meshes[i].m1.MeshConvert(new DefaultShaderData(((1 << VertexUsage::Position) | (1 << VertexUsage::Normal) |
465                                                                  (1 << VertexUsage::Color)    | (1 << VertexUsage::TexCoord)),
466                                                                  m_texture_shader, true));
467#else
468                m_meshes[i].m1.MeshConvert();
469#endif
470                m_meshes[i].m2 = true;
471            }
472        }
473
474        g_renderer->SetClearColor(vec4(0.0f, 0.0f, 0.0f, 1.0f));
475
476        mat4 default_proj = g_scene->GetCamera()->GetProjection();
477        int max_drawn = m_meshes.Count() - m_mesh_shown;
478        for (int i = max_drawn; i < m_meshes.Count(); i++)
479            m_meshes[i].m4 = vec3(.0f);
480        for (int i = 0; i < max_drawn; i++)
481        {
482            float new_scale = max(.0f, 1.0f - (m_mesh_offset_damp.y * (float)(max_drawn - (i + 1))));
483            m_meshes[i].m3 = damp(m_meshes[i].m3, new_scale, .35f, seconds);
484            if (m_meshes[i].m3 > .0f)
485            {
486                vec3 new_mesh_offset = vec3(.0f);
487                //damping calculations
488                for (int j = max_drawn - 1; j > i; j--)
489                {
490                    float ofs_scale = max(.0f, 1.0f - (m_mesh_offset_damp.y * (float)(max_drawn - (j + 0))));
491                    new_mesh_offset = new_mesh_offset + vec3(m_meshes[j].m3 * ofs_scale * ofs_scale * m_mesh_offset_damp.x, .0f, .0f);
492                }
493                m_meshes[i].m4 = damp(m_meshes[i].m4, new_mesh_offset, .35f, seconds);
494
495                g_scene->GetCamera()->SetProjection(
496                                                                mat4::translate(m_meshes[i].m4) *
497                                                                mat4::translate(vec3(m_mesh_screen_offset_damp, .0f)) *
498                                                                mat4::scale(vec3(vec2(m_meshes[i].m3), 1.0f)) *
499                                                                default_proj);
500#if WITH_FUR
501                for (int j=0; j < 40; j++)
502                    m_meshes[i].m1.Render(m_mat, 0.1 * j);
503#else
504                m_meshes[i].m1.Render(m_mat);
505#endif
506                g_renderer->Clear(ClearMask::Depth);
507            }
508        }
509        g_scene->GetCamera()->SetProjection(default_proj);
510    }
511
512private:
513    Controller *m_controller;
514    Camera *m_camera;
515    float m_angle;
516    mat4 m_mat;
517
518    //Mesh infos
519    //Move damping
520    vec2 m_mesh_rotate_damp;
521    vec2 m_mesh_screen_move_damp;
522    vec2 m_mesh_move_damp;
523
524    //Move transform damping
525    vec2 m_mesh_rotation_damp;
526    vec2 m_mesh_screen_offset_damp;
527    vec2 m_mesh_offset_damp;
528
529    vec2 m_mesh_rotation;     //Meshes rotation
530    vec2 m_mesh_screen_offset;//Meshes screen offset
531    vec2 m_mesh_offset;       //Mesh Offset after first mesh (x: offset, y: scale)
532    int  m_mesh_shown;
533
534    //File data
535    String        m_file_name;
536    Array<String> m_cmdlist;
537    float         m_stream_update_time;
538    float         m_stream_update_timer;
539
540    //misc datas
541    Array<EasyMesh, bool, float, vec3> m_meshes;
542    Array<Light *>  m_lights;
543    Shader *        m_texture_shader;
544    TileSet *       m_default_texture;
545    Texture *       m_texture;
546    ShaderUniform   m_texture_uni;
547    Image *         m_image;
548    float           m_fov;
549    float           m_fov_damp;
550    float           m_fov_zoom_damp;
551    mat4            m_fov_compensation;
552};
553
554//The basic main :
555int main(int argc, char **argv)
556{
557    System::Init(argc, argv);
558
559    Application app("MeshViewer", ivec2(1600, 600), 60.0f);
560    if (argc > 1)
561        new MeshViewer(argv[1]);
562    else
563        new MeshViewer();
564    app.Run();
565
566    return EXIT_SUCCESS;
567}
568
Note: See TracBrowser for help on using the repository browser.