source: trunk/src/gfx/keyframed_mesh.cc @ 295

// Copyright (C) 2011 Kornel Kisielewicz
// This file is part of NV Libraries.
// For conditions of distribution and use, see copyright notice in nv.hh

#include "nv/gfx/keyframed_mesh.hh"

#include <glm/gtc/matrix_access.hpp>
#include <glm/gtx/matrix_interpolation.hpp>
#include "nv/interface/context.hh"
#include "nv/interface/device.hh"


#include "nv/logging.hh"

using namespace nv;

nv::keyframed_mesh::keyframed_mesh( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
        : animated_mesh()
        , m_mesh_data( a_data )
        , m_tag_map( a_tag_map )
        , m_last_frame( 0 )
        , m_next_frame( 0 )
        , m_interpolation( 0.0f )
        , m_active( false )
{
        m_va = a_device->create_vertex_array();

        m_index_count  = m_mesh_data->get_index_channel()->count;
        m_vertex_count = m_mesh_data->get_channel<vertex_t>()->count;
        m_vchannel     = m_mesh_data->get_channel<vertex_pnt>();
        m_vsize        = sizeof( vertex_pnt );
        m_has_tangent  = true;
        if ( m_vchannel == nullptr )
        {
                m_vchannel     = m_mesh_data->get_channel<vertex_pn>();
                m_has_tangent  = false;
                m_vsize        = sizeof( vertex_pn );
        }
        m_frame_count  = m_vchannel->count / m_vertex_count;
}

size_t keyframed_mesh::get_max_frames() const
{
        return m_frame_count;
}

transform keyframed_mesh::get_node_transform( uint32 node_id ) const
{
        NV_ASSERT( m_tag_map, "TAGMAP FAIL" );
        NV_ASSERT( node_id < m_tag_map->get_count(), "TAGMAP FAIL" );
        const key_data* data = m_tag_map->get_node( node_id )->data;
        NV_ASSERT( data, "TAG FAIL" );
        transform last = data->get_raw_transform( m_last_frame );
        transform next = data->get_raw_transform( m_next_frame );
        return interpolate( last, next, m_interpolation  );
}

mat4 keyframed_mesh::get_node_matrix( uint32 node_id ) const
{
        return get_node_transform( node_id ).extract();
}

void nv::keyframed_mesh::set_frame( uint32 frame )
{
        m_last_frame    = frame;
        m_next_frame    = frame;
        m_active        = false;
        m_interpolation = 0.0f;
}

void nv::keyframed_mesh::update_animation( animation_entry* anim, uint32 a_anim_time )
{
        if ( m_active )
        {
                float tick_time = ( (float)a_anim_time * 0.001f ) * anim->get_frame_rate();
                float duration  = anim->is_looping() ? anim->get_duration() + 1.0f : anim->get_duration();
                if ( tick_time >= duration )
                {
                        if ( anim->is_looping() )
                        {
                                tick_time = fmodf( tick_time, duration );
                        }
                        else
                        {
                                m_active     = false;
                                m_last_frame = (uint32)anim->get_end();
                                m_next_frame = m_last_frame;
                                m_interpolation = 0.0f;
                                return;
                        }
                }
                m_last_frame    = (uint32)( glm::floor( tick_time ) + anim->get_start() );
                m_next_frame    = m_last_frame + 1;
                if ( m_next_frame > (uint32)anim->get_end() ) m_next_frame = (uint32)anim->get_start();
                m_interpolation = tick_time - glm::floor( tick_time );
        }
}


void nv::keyframed_mesh::update( program* a_program ) const
{
        a_program->set_opt_uniform( "nv_interpolate", m_interpolation );
}

nv::keyframed_mesh::~keyframed_mesh()
{
        delete m_va;
}

void nv::keyframed_mesh::run_animation( animation_entry* a_anim )
{
        if ( a_anim )
        {
                m_active        = true;
                m_last_frame    = 0;
                m_next_frame    = 0;
                m_interpolation = 0.0f;
        }
        else
        {
                m_active = false;
        }
}

nv::keyframed_mesh_gpu::keyframed_mesh_gpu( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map, program* a_program )
        : keyframed_mesh( a_device, a_data, a_tag_map )
        , m_loc_next_position( -1 )
        , m_loc_next_normal( -1 )
        , m_loc_next_tangent( -1 )
        , m_gpu_last_frame( 0xFFFFFFFF )
        , m_gpu_next_frame( 0xFFFFFFFF )
{
        m_loc_next_position = a_program->get_attribute( "nv_next_position" )->get_location();
        m_loc_next_normal   = a_program->get_attribute( "nv_next_normal" )->get_location();
        m_loc_next_tangent  = a_program->try_get_attribute_location( "nv_next_tangent" );
        m_va = a_device->create_vertex_array( a_data, STATIC_DRAW );
        vertex_buffer* vb = m_va->find_buffer( slot::POSITION );
        m_va->add_vertex_buffer( m_loc_next_position, vb, FLOAT, 3, 0, m_vsize, false );
        m_va->add_vertex_buffer( m_loc_next_normal,   vb, FLOAT, 3, sizeof( vec3 ), m_vsize, false );
        if ( m_has_tangent )
                m_va->add_vertex_buffer( m_loc_next_tangent, vb, FLOAT, 4, 2*sizeof( vec3 ), m_vsize, false );
}


void nv::keyframed_mesh_gpu::update( uint32 ms )
{
        animated_mesh::update( ms );

        if ( m_gpu_last_frame != m_last_frame )
        {
                m_va->update_vertex_buffer( slot::POSITION, m_last_frame * m_vertex_count * m_vsize );
                m_va->update_vertex_buffer( slot::NORMAL,   m_last_frame * m_vertex_count * m_vsize + sizeof( vec3 ) );
                if ( m_has_tangent && m_loc_next_tangent != -1 )
                {
                        m_va->update_vertex_buffer( slot::TANGENT,   m_last_frame * m_vertex_count * m_vsize + 2*sizeof( vec3 ) );
                }
                m_gpu_last_frame = m_last_frame;
        }
        if ( m_gpu_next_frame != m_next_frame )
        {
                m_va->update_vertex_buffer( m_loc_next_position, m_next_frame * m_vertex_count * m_vsize );
                m_va->update_vertex_buffer( m_loc_next_normal,   m_next_frame * m_vertex_count * m_vsize + sizeof( vec3 ) );
                m_va->update_vertex_buffer( m_loc_next_tangent,   m_next_frame * m_vertex_count * m_vsize + 2*sizeof( vec3 ) );
                m_gpu_next_frame = m_next_frame;
        }
}

nv::keyframed_mesh_cpu::keyframed_mesh_cpu( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
        : keyframed_mesh( a_device, a_data, a_tag_map )
{
        m_vb = a_device->create_vertex_buffer( nv::STATIC_DRAW, m_vertex_count * m_vsize, (void*)m_vchannel->data );
        m_va->add_vertex_buffers( m_vb, m_vchannel );

        nv::vertex_buffer* vb = a_device->create_vertex_buffer( nv::STATIC_DRAW, m_vertex_count * sizeof( nv::vec2 ), (void*)m_mesh_data->get_channel<vertex_t>()->data );
        m_va->add_vertex_buffers( vb, m_mesh_data->get_channel<vertex_t>() );

        nv::index_buffer* ib = a_device->create_index_buffer( nv::STATIC_DRAW, m_mesh_data->get_index_channel()->size(), (void*)m_mesh_data->get_index_channel()->data );
        m_va->set_index_buffer( ib, m_mesh_data->get_index_channel()->desc.slots[0].etype, true );

        m_data = new uint8[ m_vertex_count * m_vsize ];
}

void nv::keyframed_mesh_cpu::update( uint32 ms )
{
        animated_mesh::update( ms );

        // TODO: this could be done generic for any data
        if ( m_has_tangent )
        {
                const vertex_pnt* data = m_mesh_data->get_channel_data<vertex_pnt>();
                const vertex_pnt* prev = data + m_vertex_count * m_last_frame;
                const vertex_pnt* next = data + m_vertex_count * m_next_frame;
                      vertex_pnt* vtx  = (vertex_pnt*)m_data;
                for ( size_t i = 0; i < m_vertex_count; ++i )
                {
                        vtx[i].position = glm::mix( prev[i].position, next[i].position, m_interpolation );
                        vtx[i].normal   = glm::mix( prev[i].normal,   next[i].normal,   m_interpolation );
                        vtx[i].tangent  = glm::mix( prev[i].tangent,  next[i].tangent,   m_interpolation );
                }
        }
        else
        {
                const vertex_pn* data = m_mesh_data->get_channel_data<vertex_pn>();
                const vertex_pn* prev = data + m_vertex_count * m_last_frame;
                const vertex_pn* next = data + m_vertex_count * m_next_frame;
                      vertex_pn* vtx  = (vertex_pn*)m_data;

                for ( size_t i = 0; i < m_vertex_count; ++i )
                {
                        vtx[i].position = glm::mix( prev[i].position, next[i].position, m_interpolation );
                        vtx[i].normal   = glm::mix( prev[i].normal,   next[i].normal,   m_interpolation );
                }
        }

        m_vb->bind();
        m_vb->update( m_data, 0, m_vertex_count * m_vsize );
        m_vb->unbind();
}

nv::keyframed_mesh_cpu::~keyframed_mesh_cpu()
{
        delete[] m_data;
}