Changeset 239 for trunk/tests/md2_test


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/md2_test
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • 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}
Note: See TracChangeset for help on using the changeset viewer.