Changeset 239 for trunk/tests


Ignore:
Timestamp:
05/17/14 02:35:19 (11 years ago)
Author:
epyon
Message:
  • massive update of mesh handling
  • universal mesh handling routines
  • removed a lot of legacy code
  • significantly streamlined MD5 loading
  • all tests updated to new features
Location:
trunk/tests
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/gui_test/nv_gui_test.cc

    r229 r239  
    11#include <nv/gl/gl_device.hh>
    22#include <nv/gui/gui_environment.hh>
     3#include <nv/interface/context.hh>
    34#include <nv/logging.hh>
    45#include <nv/logger.hh>

  • trunk/tests/md2_test/md2_test.cc

    r231 r239  
    11#include <nv/common.hh>
    2 #include <iomanip>
    32#include <nv/gfx/keyframed_mesh.hh>
    43#include <nv/interface/vertex_buffer.hh>
    … …  
    1817#include <nv/time.hh>
    1918#include <nv/string.hh>
    20 #include <nv/interface/mesh.hh>
    2119#include <glm/gtx/rotate_vector.hpp>
    22 #include <glm/gtc/matrix_access.hpp>
    23 #include <glm/gtx/matrix_interpolation.hpp>
    24 
    25 class mesh_part
    26 {
    27 public:
    28         mesh_part( const std::string& path, nv::program* program, nv::window* window )
    29         {
    30                 NV_PROFILE("mesh_construct");
    31                 nv::md2_loader* loader;
    32                 {
    33                         NV_PROFILE("loader->load");
    34                         nv::c_file_system fs;
    35                         nv::stream* mesh_file = fs.open( path.c_str() );
    36                         loader = new nv::md2_loader();
    37                         loader->load( *mesh_file );
    38                         m_mesh_data = loader->release_mesh_data();
    39                         delete mesh_file;
    40                         delete loader;
    41                 }
    42 
    43                 {
    44                         NV_PROFILE("create_mesh");
    45                         m_mesh      = new nv::keyframed_mesh_gpu( window->get_context(), m_mesh_data, program );
    46                 }
    47 
    48         }
    49 
    50         void setup_animation( nv::uint32 start, nv::uint32 stop, nv::uint32 fps, bool loop )
    51         {
    52                 m_mesh->setup_animation( start, stop, fps, loop );
    53         }
    54 
    55         void update( nv::uint32 ms )
    56         {
    57                 m_mesh->update( ms );
    58         }
    59 
    60         nv::mesh_interface* get_mesh() { return m_mesh; }
    61 
    62         size_t get_max_frames()
    63         {
    64                 return m_mesh->get_max_frames();
    65         }
    66 
    67         ~mesh_part()
    68         {
    69                 delete m_mesh_data;
    70                 delete m_mesh;
    71         }
    72 
    73 private:
    74         nv::mesh_data*       m_mesh_data;
    75         nv::keyframed_mesh*  m_mesh;
    76 };
    7720
    7821class application
    … …  
    8730        nv::window*       m_window;
    8831        nv::texture2d*    m_diffuse;
     32        nv::program*      m_program;
     33
    8934        nv::clear_state   m_clear_state;
    9035        nv::render_state  m_render_state;
     36        nv::scene_state   m_scene_state;
    9137
    92         mesh_part*   m_mesh;
    93         nv::program* m_program;
     38        nv::mesh_data*      m_mesh_data;
     39        nv::keyframed_mesh* m_mesh;
    9440};
    9541
    … …  
    11965        NV_PROFILE( "app_initialize" );
    12066        m_program = m_device->create_program( nv::slurp( "obj.vert" ), nv::slurp( "obj.frag" ) );
    121         m_mesh    = new mesh_part( "data/manc.md2", m_program, m_window );
     67
     68        nv::md2_loader* loader;
     69        {
     70                NV_PROFILE("loader->load");
     71                nv::c_file_system fs;
     72                nv::stream* mesh_file = fs.open( "data/manc.md2" );
     73                loader = new nv::md2_loader();
     74                loader->load( *mesh_file );
     75                m_mesh_data = loader->release_mesh_data();
     76                delete mesh_file;
     77                delete loader;
     78        }
     79
     80        {
     81                NV_PROFILE("create_mesh");
     82                m_mesh      = new nv::keyframed_mesh_gpu( m_window->get_context(), m_mesh_data, nullptr, m_program );
     83        }
     84
    12285        return true;
    12386}
    … …  
    12891        NV_PROFILE( "app_run" );
    12992        int keypress = 0;
    130 
    131         glm::vec3 move( 0, 25.f, 0 );
    13293
    13394        nv::uint32 ticks   = m_device->get_ticks();
    … …  
    142103                ticks      = m_device->get_ticks();
    143104                nv::uint32 elapsed = ticks - last_ticks;
     105                m_window->get_context()->clear( m_clear_state );
    144106                m_mesh->update( elapsed );
    145                 {
    146                         NV_PROFILE( "clear" );
    147                         m_window->get_context()->clear( m_clear_state );
    148                 }
     107                glm::vec3 eye = glm::rotate( glm::vec3( 100.0f, 25.0f, 0.0f ), (ticks / 20.f), glm::vec3( 0.0,1.0,0.0 ) );
    149108
    150                 glm::mat4 view;
    151                 glm::mat4 projection;
    152                 {
    153                         NV_PROFILE( "update_sh" );
     109                m_scene_state.set_model( nv::mat4(1.0f) );
     110                m_scene_state.get_camera().set_lookat(eye, glm::vec3(0.0f, 25.0f, 0.0f), glm::vec3(0.0, 1.0, 0.0));
     111                m_scene_state.get_camera().set_perspective(60.0f, 1.0f*800.0f/600.0f, 0.1f, 1000.0f);
    154112
    155                         glm::vec3 source( 100.0f, 0.0f, 0.0f );
    156                         glm::vec3 eye = glm::rotate( source, (ticks / 20.f), glm::vec3( 0.0,1.0,0.0 ) );
     113                m_diffuse->bind( 0 );
     114                m_program->set_opt_uniform( "light_position", glm::vec3(120.0, 120.0, 0) );
     115                m_program->set_opt_uniform( "light_diffuse",  glm::vec4(1.0,1.0,1.0,1.0) );
     116                m_program->set_opt_uniform( "light_specular", glm::vec4(1.0,1.0,1.0,1.0) );
     117                m_mesh->update( m_program );
     118                m_window->get_context()->draw( m_render_state, m_scene_state, m_program, m_mesh );
     119                m_window->swap_buffers();
    157120
    158                         view       = glm::lookAt(eye + move, glm::vec3(0.0f, 0.0f, 0.0f) + move, glm::vec3(0.0, 1.0, 0.0));
    159                         projection = glm::perspective(60.0f, 1.0f*800.0f/600.0f, 0.1f, 1000.0f);
    160 
    161                         m_diffuse->bind( 0 );
    162                         m_program->set_opt_uniform( "nv_m_projection", projection );
    163                         m_program->set_uniform( "light_position", glm::vec3(120.0, 120.0, 0) );
    164                         m_program->set_uniform( "light_diffuse",  glm::vec4(1.0,1.0,1.0,1.0) );
    165                         m_program->set_uniform( "light_specular", glm::vec4(1.0,1.0,1.0,1.0) );
    166                         m_program->set_uniform( "diffuse", 0 );
    167                 }
    168 
    169                 {
    170                         NV_PROFILE( "draw" );
    171                         glm::mat4 model      = glm::mat4(1.0f);
    172                         glm::mat4 mv = view * model;
    173                         m_program->set_opt_uniform( "nv_m_modelview", mv );
    174                         m_program->set_opt_uniform( "nv_m_normal", glm::transpose(glm::inverse(glm::mat3(mv))) );
    175                         m_program->set_uniform( "matrix_mvp", projection * mv );
    176                         m_mesh->get_mesh()->update( m_program );
    177                         m_window->get_context()->draw( m_render_state, m_program, m_mesh->get_mesh() );
    178                 }
    179 
    180                 {
    181                         NV_PROFILE( "swap" );
    182                         m_window->swap_buffers();
    183                 }
    184 
    185                 {
    186                         NV_PROFILE( "pollevent" );
    187                         nv::io_event event;
    188                         while(m_window->poll_event(event))
    189                         {     
    190                                 switch (event.type)
     121                nv::io_event event;
     122                while(m_window->poll_event(event))
     123                {     
     124                        switch (event.type)
     125                        {
     126                        case nv::EV_QUIT:
     127                                keypress = 1;
     128                                break;
     129                        case nv::EV_KEY:
     130                                if (event.key.pressed)
    191131                                {
    192                                 case nv::EV_QUIT:
    193                                         keypress = 1;
    194                                         break;
    195                                 case nv::EV_KEY:
    196                                         if (event.key.pressed)
     132                                        switch (event.key.code)
    197133                                        {
    198                                                 switch (event.key.code)
    199                                                 {
    200                                                 case nv::KEY_ESCAPE : keypress = 1; break;
    201                                                 case nv::KEY_F1 : nv::profiler::pointer()->log_report(); break;
    202                                                 default: break;
    203                                                 }
     134                                        case nv::KEY_ESCAPE : keypress = 1; break;
     135                                        case nv::KEY_F1 : nv::profiler::pointer()->log_report(); break;
     136                                        default: break;
    204137                                        }
    205                                         break;
    206                                 default: break;
    207138                                }
     139                                break;
     140                        default: break;
    208141                        }
    209142                }
    … …  
    216149{
    217150        delete m_program;
     151        delete m_mesh_data;
    218152        delete m_mesh;
    219153        delete m_diffuse;

  • trunk/tests/md2_test/obj.frag

    r189 r239  
    11#version 120
    22
    3 uniform sampler2D diffuse;
     3uniform sampler2D nv_t_diffuse;
    44uniform vec4 light_diffuse;
    55uniform vec4 light_specular;
    … …  
    99varying vec3 v_light_vector;
    1010varying vec3 v_view_vector;
    11  
     11
    1212void main(void) {
     13        vec3 diff_texel      = vec3( texture2D( nv_t_diffuse, v_texcoord ) );   
     14
    1315        vec3 nnormal         = normalize( v_normal );
    1416        vec3 nlight_vector   = normalize( v_light_vector );
    15         vec3 nview_vector    = normalize( v_view_vector );
    1617        vec3 nreflect_vector = reflect( -nlight_vector, nnormal );
    1718
    18         float specular_value = clamp( dot( nreflect_vector, nview_vector ), 0.0, 1.0 );
    19         specular_value       = pow( specular_value, 6.0 );
    20         float diffuse_value  = max( dot( nlight_vector, nnormal ), 0.0 );
     19        float specular_amount = 0.2;
     20        float diffuse_amount  = 1.0 - specular_amount;
    2121
    22         vec3 diff_texel      = vec3( texture2D( diffuse, v_texcoord ) );       
    23        
    24         float final_specular = specular_value * 0.2;
    25         float final_diffuse  = diffuse_value * 0.5;
    26         float final_ambient  = 0.3;
     22        float dot_prod_specular = dot( nreflect_vector, normalize( v_view_vector ) );
     23        float dot_prod_diffuse  = dot( nlight_vector, nnormal );
    2724
    28         vec3 ambient_color   = final_ambient * diff_texel;
    29         vec3 diffuse_color   = light_diffuse.xyz * final_diffuse * diff_texel;
     25        float diffuse_factor  = max( dot_prod_diffuse, 0.0 );
     26        float specular_factor = pow( max( dot_prod_specular, 0.0 ), 16.0 ); // 100.0
     27
     28        float final_diffuse  = diffuse_amount * diffuse_factor * 0.5;
     29        float final_specular = specular_amount * specular_factor;
     30
     31        vec3 diffuse_color   = light_diffuse.xyz  * final_diffuse * diff_texel;
    3032        vec3 specular_color  = light_specular.xyz * final_specular;
     33        vec3 self_ilum_color = vec3 (0.0, 0.0, 0.0);
     34        vec3 ambient_color   = vec3 (0.0, 0.0, 0.0);
    3135
    32         gl_FragColor = vec4( ambient_color + diffuse_color + specular_color, 1.0 );
    33 //      gl_FragColor = vec4( diff_texel, 1.0 );
     36        gl_FragColor = vec4( max( self_ilum_color, diffuse_color + specular_color + ambient_color ), 1.0 );
    3437}

  • trunk/tests/md2_test/obj.vert

    r189 r239  
    1212varying vec2 v_texcoord;
    1313
    14 uniform mat4 matrix_mvp;
    15 uniform mat4 nv_m_modelview;
    16 uniform mat4 nv_m_projection;
    17 uniform mat3 nv_m_normal;
     14uniform mat4 nv_m_mvp;
     15uniform mat4 nv_m_model;
     16uniform mat4 nv_m_model_inv;
     17uniform vec3 nv_v_camera_position;
     18uniform vec3 light_position;
    1819uniform float nv_interpolate;
    19 uniform vec3 light_position;
    2020
    21 void main(void) {
    22         vec4 vertex     = vec4( mix( nv_position, nv_next_position, nv_interpolate ), 1.0 );
    23         vec3 eye_pos    = vec3( nv_m_modelview * vertex );
    24         v_normal        = normalize( nv_m_normal * mix( nv_normal, nv_next_normal, nv_interpolate ) );
    25         v_light_vector  = vec3( normalize( light_position - eye_pos ) );
    26         v_view_vector   = vec3( normalize( -eye_pos ) );
     21void main(void)
     22{
     23        vec4 position   = vec4( mix( nv_position, nv_next_position, nv_interpolate ), 1.0 );
     24        v_normal        = normalize( mix( nv_normal, nv_next_normal, nv_interpolate ) );
     25        v_texcoord      = nv_texcoord;
     26        gl_Position     = nv_m_mvp * position;
    2727
    28         v_texcoord      = nv_texcoord;
    29         gl_Position     = matrix_mvp * vertex;
     28        vec3 camera_loc = vec3(nv_m_model_inv * vec4 (nv_v_camera_position, 1.0) );
     29        vec3 light_loc  = vec3(nv_m_model_inv * vec4 (light_position, 1.0) );
     30
     31        v_view_vector  = normalize( nv_position - camera_loc  );
     32        v_light_vector = normalize( nv_position - light_loc );
    3033}

  • trunk/tests/md3_test/md3_test.cc

    r231 r239  
    1818#include <nv/time.hh>
    1919#include <nv/string.hh>
    20 #include <nv/interface/mesh.hh>
    2120#include <glm/gtx/rotate_vector.hpp>
    2221#include <glm/gtc/matrix_access.hpp>
    … …  
    4342                {
    4443                        NV_PROFILE("create_mesh_data");
    45                         m_data      = loader->release_mesh_data();
     44                        m_mesh_data = loader->release_mesh_data();
     45                        m_tag_map   = loader->create_tag_map();
    4646                }
    4747                delete loader;
    … …  
    5050                        NV_PROFILE("create_mesh");
    5151                        if ( GPU_ANIMATION )
    52                                 m_mesh      = new nv::keyframed_mesh_gpu( window->get_context(), m_data, program );
     52                                m_mesh      = new nv::keyframed_mesh_gpu( window->get_context(), m_mesh_data, m_tag_map, program );
    5353                        else
    54                                 m_mesh      = new nv::keyframed_mesh_cpu( window->get_context(), m_data );
     54                                m_mesh      = new nv::keyframed_mesh_cpu( window->get_context(), m_mesh_data, m_tag_map );
    5555                }
    5656
    … …  
    6767        }
    6868
    69         void update( nv::uint32 ms )
     69        void update( nv::uint32 ms, nv::program* program )
    7070        {
    7171                m_mesh->update( ms );
     72                m_mesh->update( program );
    7273        }
    7374
    … …  
    7980        }
    8081
    81         void draw( nv::context* c, nv::program* program, nv::render_state& rstate, const glm::mat4& m, const glm::mat4& v, const glm::mat4& p )
    82         {
    83                 NV_PROFILE( "mesh-draw" );
    84                 glm::mat4 mv = v * m;
    85                 program->set_opt_uniform( "nv_m_modelview", mv );
    86                 program->set_opt_uniform( "nv_m_normal", glm::transpose(glm::inverse(glm::mat3(mv))) );
    87                 program->set_uniform( "matrix_mvp", p * mv );
    88                
    89                 c->draw( rstate, program, m_mesh );
    90         }
    91 
    9282        ~mesh_part()
    9383        {
    94                 delete m_data;
     84                delete m_tag_map;
     85                delete m_mesh_data;
    9586                delete m_mesh;
    9687        }
    9788
    9889private:
    99         nv::mesh_data*           m_data;
    100         nv::keyframed_mesh*      m_mesh;
     90        nv::tag_map*        m_tag_map;
     91        nv::mesh_data*      m_mesh_data;
     92        nv::keyframed_mesh* m_mesh;
    10193};
    10294
    … …  
    113105        nv::texture2d*    m_diffuse;
    114106        nv::texture2d*    m_diffuse_weapon;
     107
    115108        nv::clear_state   m_clear_state;
    116109        nv::render_state  m_render_state;
     110        nv::scene_state   m_scene_state;
    117111
    118112        mesh_part* m_torso;
    … …  
    120114        mesh_part* m_head;
    121115        mesh_part* m_weapon;
    122         nv::program*      m_program;
     116        nv::program* m_program;
    123117};
    124118
    … …  
    182176                ticks      = m_device->get_ticks();
    183177                nv::uint32 elapsed = ticks - last_ticks;
    184                 m_torso->update( elapsed );
    185                 m_legs->update( elapsed );
     178                m_torso->update( elapsed, m_program );
     179                m_legs->update( elapsed, m_program );
    186180                {
    187181                        NV_PROFILE( "clear" );
    … …  
    197191                        glm::vec3 eye = glm::rotate( source, (ticks / 20.f), glm::vec3( 0.0,1.0,0.0 ) );
    198192
    199                         view       = glm::lookAt(eye + move, glm::vec3(0.0f, 0.0f, 0.0f) + move, glm::vec3(0.0, 1.0, 0.0));
    200                         projection = glm::perspective(60.0f, 1.0f*800.0f/600.0f, 0.1f, 1000.0f);
     193                        m_scene_state.get_camera().set_lookat(eye + move, glm::vec3(0.0f, 0.0f, 0.0f) + move, glm::vec3(0.0, 1.0, 0.0));
     194                        m_scene_state.get_camera().set_perspective(60.0f, 1.0f*800.0f/600.0f, 0.1f, 1000.0f);
    201195
    202196                        m_diffuse->bind( 0 );
    203                         m_program->set_opt_uniform( "nv_m_projection", projection );
    204197                        m_program->set_uniform( "light_position", glm::vec3(120.0, 120.0, 0) );
    205198                        m_program->set_uniform( "light_diffuse",  glm::vec4(1.0,1.0,1.0,1.0) );
    206199                        m_program->set_uniform( "light_specular", glm::vec4(1.0,1.0,1.0,1.0) );
    207                         m_program->set_uniform( "diffuse", 0 );
    208200                }
    209201
    … …  
    211203                        NV_PROFILE( "draw" );
    212204                        glm::mat4 model      = glm::mat4(1.0f);
    213                         m_legs->draw( m_window->get_context(), m_program, m_render_state, model, view, projection );
     205
     206                        m_scene_state.set_model( model );
     207                        m_window->get_context()->draw( m_render_state, m_scene_state, m_program, m_legs->get_mesh() );
    214208
    215209                        //model = m_legs->get_transform( "tag_torso", last_legs_frame, legs_frame, legs_interpolate );
    216210                        model = m_legs->get_transform( "tag_torso" );
    217                         m_torso->draw( m_window->get_context(), m_program, m_render_state, model, view, projection );
     211                        m_scene_state.set_model( model );
     212                        m_window->get_context()->draw( m_render_state, m_scene_state, m_program, m_torso->get_mesh() );
    218213
    219214                        glm::mat4 head = model * m_torso->get_transform( "tag_head" ); //, last_torso_frame, torso_frame, torso_interpolate );
    220                         m_head->draw( m_window->get_context(), m_program, m_render_state, head, view, projection );
     215                        m_scene_state.set_model( head );
     216                        m_window->get_context()->draw( m_render_state, m_scene_state, m_program, m_head->get_mesh() );
    221217
    222218                        glm::mat4 weapon = model * m_torso->get_transform( "tag_weapon" ); //, last_torso_frame, torso_frame, torso_interpolate );
     219                        m_scene_state.set_model( weapon );
    223220                        m_diffuse_weapon->bind( 0 );
    224                         m_weapon->draw( m_window->get_context(), m_program, m_render_state, weapon, view, projection );
     221                        m_window->get_context()->draw( m_render_state, m_scene_state, m_program, m_weapon->get_mesh() );
    225222
    226223                }

  • trunk/tests/md5_test/md5_test.cc

    r231 r239  
    1818#include <nv/time.hh>
    1919#include <nv/string.hh>
    20 #include <nv/interface/mesh.hh>
    2120#include <nv/gfx/skeletal_mesh.hh>
    2221#include <glm/gtx/rotate_vector.hpp>
    2322#include <glm/gtc/matrix_access.hpp>
    2423#include <glm/gtx/matrix_interpolation.hpp>
    25 
    26 class mesh_part
    27 {
    28 public:
    29         mesh_part( const std::string& path, nv::program* program, nv::window* window )
    30                 : m_mesh( nullptr ), m_program( program ), m_loader( nullptr ), m_animation( nullptr ), m_window( window )
    31         {
    32                
    33                 NV_PROFILE("mesh_construct");
    34                 {
    35                         NV_PROFILE("loader->load");
    36                         nv::c_file_system fs;
    37                         nv::stream* mesh_file = fs.open( path.c_str() );
    38                         m_loader = new nv::md5_loader();
    39                         m_loader->load( *mesh_file );
    40                         delete mesh_file;
    41                 }
    42 
    43                 {
    44                         NV_PROFILE("create_mesh");
    45                         m_mesh = new nv::skeletal_mesh( window->get_context(), m_loader );
    46                 }
    47 
    48         }
    49 
    50         void load_animation( const std::string& path )
    51         {
    52                 delete m_animation;
    53                 m_animation = nullptr;
    54                 NV_PROFILE("load_animation");
    55                 nv::c_file_system fs;
    56                 nv::stream* anim_file = fs.open( path.c_str() );
    57 
    58                 if ( anim_file != nullptr )
    59                 {
    60                         m_animation = new nv::md5_animation();
    61                         if ( !m_animation->load_animation(*anim_file) )
    62                         {
    63                                 delete m_animation;
    64                                 m_animation = nullptr;
    65                         }
    66                         m_mesh->setup_animation( m_animation );
    67                         delete anim_file;
    68                 }
    69         }
    70 
    71         void update( nv::uint32 ms )
    72         {
    73                 m_mesh->update( ms );
    74         }
    75 
    76         void draw( nv::context* context, nv::render_state& rstate, const glm::mat4& m, const glm::mat4& v, const glm::mat4& p )
    77         {
    78                 NV_PROFILE( "mesh-draw" );
    79                 glm::mat4 mv = v * m;
    80                 m_program->set_opt_uniform( "nv_m_model", m );
    81                 m_program->set_opt_uniform( "nv_m_modelview", mv );
    82                 m_program->set_opt_uniform( "nv_m_view_inv", glm::inverse( v ) );
    83                 m_program->set_opt_uniform( "nv_m_normal", glm::transpose(glm::inverse(glm::mat3(mv))) );
    84                 m_program->set_uniform( "matrix_mvp", p * mv );
    85                 context->draw( rstate, m_program, m_mesh );
    86         }
    87 
    88         ~mesh_part()
    89         {
    90                 delete m_mesh;
    91         }
    92 
    93 private:
    94         nv::skeletal_mesh* m_mesh;
    95         nv::program*       m_program;
    96         nv::md5_loader*    m_loader;
    97         nv::md5_animation* m_animation;
    98         nv::window*        m_window;
    99 };
    10024
    10125class application
    … …  
    10731        ~application();
    10832protected:
     33        void load_animation( const std::string& path );
     34protected:
     35
     36
    10937        nv::device*       m_device;
    11038        nv::window*       m_window;
    … …  
    11442        nv::clear_state   m_clear_state;
    11543        nv::render_state  m_render_state;
    116 
    117         mesh_part*   m_mesh;
    118         nv::program* m_program;
     44        nv::scene_state   m_scene_state;
     45
     46        nv::skeletal_mesh* m_mesh;
     47        nv::program*       m_program;
     48        nv::md5_mesh_data* m_mesh_data;
     49        nv::md5_animation* m_animation;
     50
    11951};
    12052
    … …  
    12456        m_device = new nv::gl_device();
    12557        m_window = m_device->create_window( 800, 600, false );
     58        m_animation = nullptr;
    12659
    12760        nv::sampler sampler( nv::sampler::LINEAR, nv::sampler::REPEAT );
    … …  
    15285        NV_PROFILE( "app_initialize" );
    15386        m_program = m_device->create_program( nv::slurp( "md5.vert" ), nv::slurp( "md5.frag" ) );
    154         m_mesh    = new mesh_part( "data/qshambler.md5mesh", m_program, m_window );
    155         m_mesh->load_animation( "data/idle02.md5anim" );
     87
     88        nv::md5_loader* loader = nullptr;
     89        {
     90                NV_PROFILE("loader->load");
     91                nv::c_file_system fs;
     92                nv::stream* mesh_file = fs.open( "data/qshambler.md5mesh" );
     93                loader = new nv::md5_loader();
     94                loader->load( *mesh_file );
     95                delete mesh_file;
     96        }
     97
     98        {
     99                NV_PROFILE("create_mesh");
     100                m_mesh_data = (nv::md5_mesh_data*)loader->release_mesh_data();
     101                m_mesh = new nv::skeletal_mesh( m_window->get_context(), m_mesh_data );
     102                delete loader;
     103        }
     104
     105        load_animation( "data/idle02.md5anim" );
    156106        return true;
    157107}
    … …  
    182132                }
    183133
    184                 glm::mat4 view;
    185                 glm::mat4 projection;
    186134                {
    187135                        NV_PROFILE( "update_sh" );
    … …  
    190138                        glm::vec3 eye = glm::rotate( source, (ticks / 20.f), glm::vec3( 0.0,1.0,0.0 ) );
    191139
    192                         view       = glm::lookAt(eye + move, glm::vec3(0.0f, 0.0f, 0.0f) + move, glm::vec3(0.0, 1.0, 0.0));
    193                         projection = glm::perspective(60.0f, 1.0f*800.0f/600.0f, 0.1f, 1000.0f);
     140                        m_scene_state.get_camera().set_lookat(eye + move, glm::vec3(0.0f, 0.0f, 0.0f) + move, glm::vec3(0.0, 1.0, 0.0));
     141                        m_scene_state.get_camera().set_perspective(60.0f, 1.0f*800.0f/600.0f, 0.1f, 1000.0f);
    194142
    195143                        m_diffuse ->bind( 0 );
    196144                        m_specular->bind( 1 );
    197145                        m_normal  ->bind( 2 );
    198                         m_program->set_opt_uniform( "nv_m_projection", projection );
    199                         m_program->set_uniform( "light_position", glm::vec3(180.0, 180.0, 0) );
    200                         m_program->set_uniform( "light_diffuse",  glm::vec4(0.7,0.7,0.7,1.0) );
    201                         m_program->set_uniform( "light_specular", glm::vec4(1.0,1.0,1.0,1.0) );
    202                         m_program->set_uniform( "diffuse", 0 );
    203                         m_program->set_uniform( "specular", 1 );
    204                         m_program->set_uniform( "normalmap", 2 );
     146                        m_program->set_opt_uniform( "light_position", glm::vec3(180.0, 180.0, 0) );
     147                        m_program->set_opt_uniform( "light_diffuse",  glm::vec4(0.7,0.7,0.7,1.0) );
     148                        m_program->set_opt_uniform( "light_specular", glm::vec4(1.0,1.0,1.0,1.0) );
    205149                }
    206150
    207151                {
    208152                        NV_PROFILE( "draw" );
    209                         glm::mat4 model      =
    210                                 glm::mat4(1.f,0.f,0.f,0.f,
    211                                           0.f,0.f,1.f,0.f,
    212                                                   0.f,1.f,0.f,0.f,
    213                                                   0.f,0.f,0.f,1.f);
    214 
    215                         m_mesh->draw( m_window->get_context(), m_render_state, model, view, projection );
     153                        m_scene_state.set_model(nv::mat4(
     154                                1.f,0.f,0.f,0.f,
     155                                0.f,0.f,1.f,0.f,
     156                                0.f,1.f,0.f,0.f,
     157                                0.f,0.f,0.f,1.f
     158                        ) );
     159
     160                        m_window->get_context()->draw( m_render_state, m_scene_state, m_program, m_mesh );
    216161                }
    217162
    … …  
    251196}
    252197
     198void application::load_animation( const std::string& path )
     199{
     200        delete m_animation;
     201        m_animation = nullptr;
     202        NV_PROFILE("load_animation");
     203        nv::c_file_system fs;
     204        nv::stream* anim_file = fs.open( path.c_str() );
     205
     206        if ( anim_file != nullptr )
     207        {
     208                m_animation = new nv::md5_animation();
     209                if ( !m_animation->load_animation(*anim_file) )
     210                {
     211                        delete m_animation;
     212                        m_animation = nullptr;
     213                }
     214                m_mesh->setup_animation( m_animation );
     215                delete anim_file;
     216        }
     217}
     218
     219
    253220application::~application()
    254221{

  • trunk/tests/objload_test/objload_test.cc

    r238 r239  
    1313#include <nv/math.hh>
    1414#include <nv/string.hh>
    15 #include <nv/interface/mesh.hh>
    1615
    1716class application
    … …  
    7170//              delete loader;
    7271
    73         nv::wavefront_loader* loader = new nv::wavefront_loader();
     72        nv::obj_loader* loader = new nv::obj_loader();
    7473        loader->load( *mesh_file );
    7574        m_mesh = loader->release_mesh_data();

  • trunk/tests/render_test/rl.cc

    r238 r239  
    1010#include <nv/math.hh>
    1111#include <nv/string.hh>
    12 #include <nv/interface/mesh.hh>
    1312
    1413const nv::uint16 size_x  = 16;
Note: See TracChangeset for help on using the changeset viewer.