Changeset 2353


Ignore:
Timestamp:
Feb 5, 2013, 12:23:03 AM (7 years ago)
Author:
touky
Message:

MeshViewer :

  • Added file handling with new mesh generation each time the buffer file is updated (that's not very pretty, but it works).
  • Added multiple mesh viewing with "history" and some basic camera movement (it uses the keypad for now, not very sam friendly, I know).
Location:
trunk/test
Files:
1 added
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/MeshViewer.cpp

    r2298 r2353  
     1
    12//
    23// Lol Engine - EasyMesh tutorial
     
    2021using namespace std;
    2122using namespace lol;
    22 #define MESH_DIST 5.0f
     23
     24#define    IPT_CAM_RESET          "Cam_Center"
     25#define    IPT_CAM_FORWARD        "Cam_Forward"
     26#define    IPT_CAM_BACKWARD       "Cam_Backward"
     27#define    IPT_CAM_ZOOM_OUT       "Cam_Zoom_In"
     28#define    IPT_CAM_ZOOM_IN        "Cam_Zoom_Out"
     29
     30#define    IPT_MESH_UPDATE        "Mesh_Update"
     31#define    IPT_MESH_RESET         "Mesh_Reset"
     32
     33#define    IPT_MESH_LEFT          "Mesh_Left"
     34#define    IPT_MESH_RIGHT         "Mesh_Right"
     35#define    IPT_MESH_UP            "Mesh_Up"
     36#define    IPT_MESH_DOWN          "Mesh_Down"
     37#define    IPT_MESH_SCALE_UP      "Mesh_Scale_Up"
     38#define    IPT_MESH_SCALE_DOWN    "Mesh_Scale_Down"
     39#define    IPT_MESH_OFFSET_UP     "Mesh_Offset_Up"
     40#define    IPT_MESH_OFFSET_DOWN   "Mesh_Offset_Down"
     41#define    IPT_MESH_ROT_LEFT      "Mesh_Rot_Left"
     42#define    IPT_MESH_ROT_RIGHT     "Mesh_Rot_Right"
     43#define    IPT_MESH_ROT_UP        "Mesh_Rot_Up"
     44#define    IPT_MESH_ROT_DOWN      "Mesh_Rot_Down"
    2345
    2446class MeshViewer : public WorldEntity
    2547{
    2648public:
    27     MeshViewer()
    28     {
    29         int i=10;
    30         while (i--)
    31         {
    32             m_meshes.Push(EasyMesh());
    33             m_meshes.Last().Compile("[sc#2f2 ab 2 2 2 t .8 .8 .8 rx 20 ry 20 [sc#22f ab 2 2 2 tx 0 csgu]]");
    34         }
    35 
     49    void SetFov(float new_fov=60.0f)
     50    {
     51        //FOV compensation doesn't work
     52        ivec2 video_size = Video::GetSize();
     53        float near = -video_size.x - video_size.y;
     54        float far = video_size.x + video_size.y;
     55        float t1 = tanf(new_fov / 2);
     56        float dist = video_size.x / (2.0f * t1);
     57        //m_fov_compensation = mat4::translate(-0.5f * video_size.x, -0.5f * video_size.y, -dist);
     58        m_fov_compensation = mat4::translate(vec3(.0f));
     59        if (new_fov > 0.1f)
     60            m_camera->SetPerspective(new_fov, (float)video_size.x, (float)video_size.y, .1f, 1000.f);
     61        else
     62            m_camera->SetOrtho((float)video_size.x, (float)video_size.y, .1f, 1000.f);
     63    }
     64
     65    MeshViewer(char *file_buffer = "MeshViewerBuffer.txt")
     66    {
     67        //Input setup
     68        Input::LinkActionToKey(IPT_CAM_RESET,           Key::Return);
     69        Input::LinkActionToKey(IPT_CAM_FORWARD,         Key::PageUp);
     70        Input::LinkActionToKey(IPT_CAM_BACKWARD,        Key::PageDown);
     71        Input::LinkActionToKey(IPT_CAM_ZOOM_IN,         Key::Home);
     72        Input::LinkActionToKey(IPT_CAM_ZOOM_OUT,        Key::End);
     73
     74        Input::LinkActionToKey(IPT_MESH_LEFT,           Key::Left);
     75        Input::LinkActionToKey(IPT_MESH_RIGHT,          Key::Right);
     76        Input::LinkActionToKey(IPT_MESH_UP,             Key::Up);
     77        Input::LinkActionToKey(IPT_MESH_DOWN,           Key::Down);
     78
     79        Input::LinkActionToKey(IPT_MESH_UPDATE,         Key::Space);
     80        Input::LinkActionToKey(IPT_MESH_RESET,          Key::KP0);
     81
     82        Input::LinkActionToKey(IPT_MESH_OFFSET_DOWN,    Key::KP1);
     83        Input::LinkActionToKey(IPT_MESH_OFFSET_UP,      Key::KP3);
     84        Input::LinkActionToKey(IPT_MESH_SCALE_DOWN,     Key::KP7);
     85        Input::LinkActionToKey(IPT_MESH_SCALE_UP,       Key::KP9);
     86
     87        Input::LinkActionToKey(IPT_MESH_ROT_LEFT,       Key::KP4);
     88        Input::LinkActionToKey(IPT_MESH_ROT_RIGHT,      Key::KP6);
     89        Input::LinkActionToKey(IPT_MESH_ROT_UP,         Key::KP8);
     90        Input::LinkActionToKey(IPT_MESH_ROT_DOWN,       Key::KP5);
     91       
    3692        m_angle = 0;
    3793
     94        //Camera Setup
     95        m_fov_zoom_damp = .0f;
     96        m_fov_damp = 60.0f;
     97        m_fov = 60.0f;
    3898        m_camera = new Camera(vec3(0.f, 600.f, 0.f),
    3999                              vec3(0.f, 0.f, 0.f),
    40100                              vec3(0, 1, 0));
    41         m_camera->SetPerspective(60.f, 16, 9, .1f, 1000.f);
     101        SetFov(m_fov_damp);
    42102        m_camera->SetTarget(vec3(0.f, 0.f, 0.f));
    43         m_camera->SetPosition(vec3(0.f, 0.f, 5.f));
     103        m_camera->SetPosition(vec3(0.f, 0.f, 10.f));
    44104        m_camera->ForceSceneUpdate();
    45105        Ticker::Ref(m_camera);
    46106
     107        //Lights setup
    47108        m_lights << new Light();
    48109        m_lights.Last()->SetPosition(vec4(4.f, -1.f, -4.f, 0.f));
     
    55116        Ticker::Ref(m_lights.Last());
    56117
    57         min_pos = vec3(FLT_MAX);
    58         max_pos = vec3(-FLT_MAX);
    59 
    60         m_ready = false;
     118        //Speed damp
     119        m_mesh_rotate_damp = vec2(.0f);
     120        m_mesh_screen_move_damp = vec2(.0f);
     121        m_mesh_move_damp = vec2(.0f);
     122
     123        //Actual values
     124        SetDefaultMeshTransform();
     125
     126        //Actual values damp
     127        m_mesh_rotation_damp = vec2(.0f);
     128        m_mesh_screen_offset_damp = vec2(.0f);
     129        m_mesh_offset_damp = vec2(.0f);
     130
     131
     132        m_mat = mat4::rotate(m_mesh_rotation.x, vec3(1, 0, 0)) *
     133                mat4::rotate(m_angle, vec3(0, 1, 0)) *
     134                mat4::rotate(m_mesh_rotation.y, vec3(0, 1, 0));
     135
     136        //File management
     137#ifdef HAVE_STDIO_H
     138        m_file_buffer = fopen("MeshViewerBuffer.txt", "r");
     139
     140        if (!m_file_buffer)
     141            Ticker::Shutdown();
     142#else //Full FAIL, kill the viewer
     143        Ticker::Shutdown();
     144#endif
     145
     146        m_last_stream_size = 0;
     147        m_last_stream_cmd << 0;
     148
     149        m_stream_update_time = 0.0f;
     150        m_stream_update_timer = 1.0f;
    61151    }
    62152
     
    66156        for (int i = 0; i < m_lights.Count(); ++i)
    67157            Ticker::Unref(m_lights[i]);
    68     }
    69 
     158#ifdef HAVE_STDIO_H
     159        fclose(m_file_buffer);
     160#endif
     161    }
     162
     163    void SetDefaultMeshTransform()
     164    {
     165        m_mesh_rotation = vec2(25.0f, .0f);
     166        m_mesh_screen_offset = vec2(.54f, .0f);
     167        m_mesh_offset = vec2(-.64f, .07f);
     168    }
     169   
    70170    virtual void TickGame(float seconds)
    71171    {
    72172        WorldEntity::TickGame(seconds);
    73         //vec4 vertex = in_ModelView * vec4(in_Vertex, 1.0);
    74         //    gl_Position = in_Proj * vertex;
    75 
    76 
    77         m_angle += seconds * 70.0f;
    78         m_mat = mat4::rotate(m_angle, vec3(0, 1, 0));
    79 
    80         //mat4 screen_matrix = Scene::GetDefault()->GetProjMatrix() * Scene::GetDefault()->GetViewMatrix();
    81         mat4 world_view_matrix = m_camera->GetViewMatrix() * m_mat;
    82         mat4 world_screen_matrix = m_camera->GetProjMatrix() * world_view_matrix;
    83         mat4 view_world_matrix = inverse(m_camera->GetViewMatrix());
    84         mat4 screen_view_matrix = inverse(m_camera->GetProjMatrix());
    85         vec4 a(0, 2, 0, 1.0f);
    86         vec4 b(0,-2, 0, 1.0f);
    87         vec4 c(0, 0, -2, 1.0f);
    88         vec4 d(-1, -1, 1, 1.0f);
    89 
    90         //vec2 toto;
    91         //near plane : vec4(toto, 1.f, 1.f);
    92         //far plane : vec4(toto, -1.f, 1.f);
    93 
    94         a = vec4((world_screen_matrix * a).xyz / a.w, a.w);
    95         b = vec4((world_screen_matrix * b).xyz / b.w, b.w);
    96         c = vec4((inverse(world_screen_matrix) * c).xyz / c.w, c.w);
    97         d = vec4((inverse(world_screen_matrix) * d).xyz / d.w, d.w);
    98         a = b;
    99         c = d;
    100 
    101         //this is the algorithm for a camera that must keep n target in the screen
     173
     174        //Shutdown logic
     175        if (Input::WasReleased(Key::Escape))
     176            Ticker::Shutdown();
     177
     178        //Update Mesh BBox - Get the Min/Max needed
     179        vec3 min_max[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
     180        int mesh_id = m_meshes.Count() - 1;
     181        for (; mesh_id >= 0; mesh_id--)
     182            if (m_meshes[mesh_id].m2)
     183                break;
     184
     185        if (m_meshes.Count() && mesh_id >= 0)
    102186        {
    103             //Get the Min/Max needed
    104             vec3 new_min_pos(FLT_MAX);
    105             vec3 new_max_pos(-FLT_MAX);
    106             for (int i = 0; i < m_meshes.Last().GetVertexCount(); i++)
     187            for (int i = 0; i < m_meshes[mesh_id].m1.GetVertexCount(); i++)
    107188            {
    108                 vec4 vpos = world_view_matrix * vec4(m_meshes.Last().GetVertexLocation(i), 1.0f);
    109                 new_min_pos = min(vpos.xyz, new_min_pos);
    110                 new_max_pos = max(vpos.xyz, new_max_pos);
     189                vec3 vpos = m_meshes[mesh_id].m1.GetVertexLocation(i);
     190                min_max[0] = min(vpos.xyz, min_max[0]);
     191                min_max[1] = max(vpos.xyz, min_max[1]);
    111192            }
    112 
    113             //Actual camera algorithm
     193        }
     194        else
     195        {
     196            min_max[0] = vec3(.0f);
     197            min_max[1] = vec3(.0f);
     198        }
     199        //[0] : center, [1] : size.
     200        vec3 BBox[2] = { vec3(.0f), vec3(.0f) };
     201        BBox[1] = min_max[1] - min_max[0];
     202        BBox[0] = min_max[0] + BBox[1] * .5f;
     203        vec3 BBox_mod = BBox[1];
     204
     205        //--
     206        //Camera movement handling
     207        //--
     208        vec3 cam_move = BBox_mod * seconds *
     209                        vec3(.0f, .0f, (float)(Input::GetStatus(IPT_CAM_BACKWARD) - Input::GetStatus(IPT_CAM_FORWARD)));
     210
     211        if (Input::WasReleased(IPT_CAM_RESET))
     212            SetFov();
     213
     214        float fov_zoom = (float)(Input::GetStatus(IPT_CAM_ZOOM_OUT) - Input::GetStatus(IPT_CAM_ZOOM_IN));
     215        m_fov_zoom_damp = damp(m_fov_zoom_damp, fov_zoom, (fov_zoom == .0f)?(.15f):(0.5f), seconds);
     216        m_fov = max(.0f, m_fov + seconds * 10.0f * m_fov_zoom_damp);
     217        m_fov_damp = damp(m_fov_damp, m_fov, .2f, seconds);
     218        SetFov(m_fov_damp);
     219
     220        m_camera->SetPosition(m_camera->GetPosition() + cam_move);
     221        m_camera->SetTarget(m_camera->GetPosition() + vec3(0, 0, -5.0f));
     222
     223        //--
     224        //Mesh movement handling
     225        //--
     226        if (Input::WasReleased(IPT_MESH_RESET))
     227            SetDefaultMeshTransform();
     228
     229        vec2 new_move = vec2(.0f);
     230
     231        new_move = vec2((float)(Input::GetStatus(IPT_MESH_RIGHT) - Input::GetStatus(IPT_MESH_LEFT)),
     232                        (float)(Input::GetStatus(IPT_MESH_UP)    - Input::GetStatus(IPT_MESH_DOWN)));
     233        m_mesh_screen_move_damp = vec2(damp(m_mesh_screen_move_damp.x, new_move.x, (new_move.x == .0f)?(.15f):(0.5f), seconds),
     234                                         damp(m_mesh_screen_move_damp.y, new_move.y, (new_move.y == .0f)?(.15f):(0.5f), seconds));
     235
     236        new_move = vec2((float)(Input::GetStatus(IPT_MESH_OFFSET_UP) - Input::GetStatus(IPT_MESH_OFFSET_DOWN)),
     237                        (float)(Input::GetStatus(IPT_MESH_SCALE_UP)  - Input::GetStatus(IPT_MESH_SCALE_DOWN)));
     238        m_mesh_move_damp = vec2(damp(m_mesh_move_damp.x, new_move.x, (new_move.x == .0f)?(.15f):(0.5f), seconds),
     239                                  damp(m_mesh_move_damp.y, new_move.y, (new_move.y == .0f)?(.15f):(0.5f), seconds));
     240
     241        new_move = vec2((float)(Input::GetStatus(IPT_MESH_ROT_UP)    - Input::GetStatus(IPT_MESH_ROT_DOWN)),
     242                        (float)(Input::GetStatus(IPT_MESH_ROT_RIGHT) - Input::GetStatus(IPT_MESH_ROT_LEFT)));
     243        m_mesh_rotate_damp = vec2(damp(m_mesh_rotate_damp.x, new_move.x, (new_move.x == .0f)?(.15f):(0.5f), seconds),
     244                                    damp(m_mesh_rotate_damp.y, new_move.y, (new_move.y == .0f)?(.15f):(0.5f), seconds));
     245
     246        vec2 mesh_screen_move = seconds * 0.6f * m_mesh_screen_move_damp;
     247        vec2 mesh_offset_move = seconds * vec2(.6f, .2f) * m_mesh_move_damp;
     248        vec2 mesh_rotate = seconds * vec2(40.0f, 60.0f) * m_mesh_rotate_damp;
     249
     250        //Add movement
     251        m_mesh_screen_offset += mesh_screen_move;
     252        m_mesh_offset += mesh_offset_move;
     253        m_mesh_rotation += mesh_rotate;
     254
     255        //Compute damp
     256        m_mesh_rotation_damp = damp(m_mesh_rotation_damp, m_mesh_rotation, .2f, seconds);
     257        m_mesh_screen_offset_damp = damp(m_mesh_screen_offset_damp, m_mesh_screen_offset, .2f, seconds);
     258        m_mesh_offset_damp = damp(m_mesh_offset_damp, m_mesh_offset, .2f, seconds);
     259
     260        //Clamp necessary
     261        m_mesh_rotation.x = clamp(m_mesh_rotation.x, -90.0f, 90.0f);
     262        m_mesh_offset.y = max(.0f, m_mesh_offset.y);
     263
     264        //m_angle += seconds * 70.0f;
     265        m_mat = mat4::rotate(m_mesh_rotation.x, vec3(1, 0, 0)) *
     266                mat4::rotate(m_angle, vec3(0, 1, 0)) *
     267                mat4::rotate(m_mesh_rotation.y, vec3(0, 1, 0));
     268
     269        //--
     270        //File management
     271        //--
     272        if (Input::WasReleased(IPT_MESH_UPDATE))
     273            m_stream_update_time = m_stream_update_timer + 1.0f;
     274        m_stream_update_time += seconds;
     275
     276#ifdef HAVE_STDIO_H
     277        // obtain file size:
     278        fseek(m_file_buffer, 0 , SEEK_END);
     279        long new_stream_size = ftell(m_file_buffer);
     280        rewind(m_file_buffer);
     281#else
     282        long new_stream_size = 0;
     283#endif
     284
     285        if (new_stream_size && (new_stream_size != m_last_stream_size || m_stream_update_time > m_stream_update_timer))
     286        {
     287            Array<char> new_stream_cmd;
     288            m_stream_update_time = .0f;
     289
     290            //Reserve the needed datas & read the file
     291            new_stream_cmd.Resize((int)new_stream_size);
     292#ifdef HAVE_STDIO_H
     293            size_t result = fread(&new_stream_cmd[0], 1, new_stream_size, m_file_buffer);
     294#else
     295#endif
     296
     297            //if the new cmd is different from the previous one
     298            if (new_stream_cmd.Count() != m_last_stream_cmd.Count() ||
     299                strcmp(&new_stream_cmd[0], &m_last_stream_cmd[0]))
    114300            {
    115                 vec4 BottomLeft = m_camera->GetProjMatrix() * vec4(new_min_pos.xy, new_min_pos.z, 1.0f);
    116                 vec4 TopRight = m_camera->GetProjMatrix() * vec4(new_max_pos.xy, new_min_pos.z, 1.0f);
    117                 BottomLeft = vec4(BottomLeft.xyz / BottomLeft.w, BottomLeft.w);
    118                 TopRight = vec4(TopRight.xyz / TopRight.w, TopRight.w);
    119                 //vec2 NewSize = TopRight.xy - BottomLeft.xy;
    120                 //NewSize.x = max(NewSize.x, NewSize.y) * 1.5f;
    121                 vec4 DistantPoint = screen_view_matrix * vec4(vec2(1.0f, 1.0f), TopRight.z * TopRight.w, TopRight.w);
    122 
    123                 vec3 vcenter = vec3(new_min_pos.xy + new_max_pos.xy, .0f) * .5f;
    124                 vec4 new_pos = screen_view_matrix * vec4(.0f, .0f, new_min_pos.z, 1.0f);
    125                 //vcenter.z += (new_pos.z - new_pos.z * NewSize.x);
    126                 vcenter = (view_world_matrix * vec4(vcenter, 1.0f)).xyz;
    127 
    128                 m_camera->SetPosition(damp(m_camera->GetPosition(), vcenter, 0.4f, seconds));
    129                 //m_camera->SetPosition(vcenter);
    130                 m_camera->SetTarget(m_camera->GetPosition() + vec3(0, 0, -5.0f));
     301                //store the current datas
     302                m_last_stream_cmd  = new_stream_cmd;
     303                m_last_stream_size = new_stream_size;
     304
     305                //Create a new mesh
     306                m_meshes.Push(EasyMesh(), false, .0f, vec3(.0f));
     307                m_meshes.Last().m1.Compile(&new_stream_cmd[0]);
    131308            }
    132             //
    133309        }
    134310    }
     
    138314        WorldEntity::TickDraw(seconds);
    139315
    140         if (!m_ready)
    141         {
    142             for (int i = 0; i < m_meshes.Count(); i++)
    143                 m_meshes[i].MeshConvert();
    144             m_ready = true;
    145         }
    146 
    147         Video::SetClearColor(vec4(0.0f, 0.0f, 0.0f, 1.0f));
    148 
    149         m_mat = mat4::translate(vec3(m_meshes.Count() * MESH_DIST * 0.5f, 0, m_meshes.Count() * MESH_DIST) * -1.0f) * m_mat;
    150316        for (int i = 0; i < m_meshes.Count(); i++)
    151317        {
    152             m_mat = mat4::translate(vec3(MESH_DIST * 0.5f, 0, MESH_DIST)) * m_mat;
    153             m_meshes[i].Render(m_mat);
    154             Video::Clear(ClearMask::Depth);
     318            if (!m_meshes[i].m2)
     319            {
     320                m_meshes[i].m1.MeshConvert();
     321                m_meshes[i].m2 = true;
     322            }
    155323        }
    156         //m_mat = mat4::translate(vec3(.0f));
    157         //m_meshes.Last().Render(m_mat);
     324
     325        Video::SetClearColor(vec4(0.0f, 0.0f, 0.0f, 1.0f));
     326
     327        mat4 default_proj = Scene::GetDefault()->GetProjMatrix();
     328        for (int i = 0; i < m_meshes.Count(); i++)
     329        {
     330            float new_scale = max(.0f, 1.0f - (m_mesh_offset_damp.y * (float)(m_meshes.Count() - (i + 1))));
     331            m_meshes[i].m3 = damp(m_meshes[i].m3, new_scale, .35f, seconds);
     332            if (m_meshes[i].m3 > .0f)
     333            {
     334                vec3 new_mesh_offset = vec3(.0f);
     335                for (int j = m_meshes.Count() - 1; j > i; j--)
     336                {
     337                    float ofs_scale = max(.0f, 1.0f - (m_mesh_offset_damp.y * (float)(m_meshes.Count() - (j + 0))));
     338                    new_mesh_offset = new_mesh_offset + vec3(m_meshes[j].m3 * ofs_scale * ofs_scale * m_mesh_offset_damp.x, .0f, .0f);
     339                }
     340                m_meshes[i].m4 = damp(m_meshes[i].m4, new_mesh_offset, .35f, seconds);
     341                Scene::GetDefault()->SetProjMatrix(mat4::translate(m_meshes[i].m4) *
     342                                                   mat4::translate(vec3(m_mesh_screen_offset_damp, .0f)) *
     343                                                   mat4::scale(vec3(vec2(m_meshes[i].m3), 1.0f)) *
     344                                                   default_proj *
     345                                                   m_fov_compensation);
     346                m_meshes[i].m1.Render(m_mat);
     347                Video::Clear(ClearMask::Depth);
     348            }
     349        }
     350        Scene::GetDefault()->SetProjMatrix(default_proj);
    158351    }
    159352
    160353private:
    161     //Array<EasyMesh, mat4, float> m_gears;
    162     float m_angle;
    163     mat4 m_mat;
    164     vec3 min_pos;
    165     vec3 max_pos;
    166 
    167     Array<EasyMesh> m_meshes;
    168     Array<Light *> m_lights;
    169     Camera *m_camera;
    170 
    171     bool m_ready;
     354    float           m_angle;
     355    mat4            m_mat;
     356
     357    //Mesh infos
     358    //Move damping
     359    vec2            m_mesh_rotate_damp;
     360    vec2            m_mesh_screen_move_damp;
     361    vec2            m_mesh_move_damp;
     362
     363    //Move transform damping
     364    vec2            m_mesh_rotation_damp;
     365    vec2            m_mesh_screen_offset_damp;
     366    vec2            m_mesh_offset_damp; 
     367
     368    vec2            m_mesh_rotation;     //Meshes rotation
     369    vec2            m_mesh_screen_offset;//Meshes screen offset
     370    vec2            m_mesh_offset;       //Mesh Offset after first mesh (x: offset, y: scale)
     371
     372    //File data
     373#ifdef HAVE_STDIO_H
     374    FILE *          m_file_buffer;
     375#endif
     376    long            m_last_stream_size;
     377    Array<char>     m_last_stream_cmd;
     378    float           m_stream_update_time;
     379    float           m_stream_update_timer;
     380
     381    //misc datas
     382    Array<EasyMesh, bool, float, vec3> m_meshes;
     383    Array<Light *>  m_lights;
     384    Camera *        m_camera;
     385    float           m_fov;
     386    float           m_fov_damp;
     387    float           m_fov_zoom_damp;
     388    mat4            m_fov_compensation;
    172389};
    173390
     391//The basic main :
    174392int main(int argc, char **argv)
    175393{
    176394    System::Init(argc, argv);
    177395
    178     Application app("MeshViewer", ivec2(960, 600), 60.0f);
    179     new MeshViewer();
     396    Application app("MeshViewer", ivec2(1600, 600), 60.0f);
     397    if (argc > 1)
     398        new MeshViewer(argv[1]);
     399    else
     400        new MeshViewer();
    180401    app.Run();
    181402
Note: See TracChangeset for help on using the changeset viewer.