Changeset 295 for trunk/src

Timestamp:

07/31/14 02:32:59 (11 years ago)

Author:

epyon

Message:

• gl_context - support for integration with wxWindows
• wx.hh - simple wxWindows integration
• mesh_creator - flip normals and merge operations added
• fix in packed_indexed_array
• various minor fixes

Location:

trunk/src

Files:

• gfx/mesh_creator.cc (modified) (2 diffs)
• gfx/skeletal_mesh.cc (modified) (1 diff)
• gl/gl_window.cc (modified) (3 diffs)
• library.cc (modified) (1 diff)
• logger.cc (modified) (1 diff)

trunk/src/gfx/mesh_creator.cc

@@ -168 +168 @@
 };
 
+void nv::mesh_data_creator::flip_normals()
+{
+        int ch_n  = m_data->get_channel_index( slot::NORMAL );
+        size_t n_offset = 0;
+        if ( ch_n == -1 ) return;
+        mesh_raw_channel* channel = m_data->m_channels[ch_n];
+        for ( uint32 i = 0; i < channel->desc.count; ++i )
+                if ( channel->desc.slots[i].vslot == slot::NORMAL )
+                {
+                        n_offset  = channel->desc.slots[i].offset; 
+                }
+
+        for ( uint32 i = 0; i < channel->count; ++i )
+        {
+                vec3& normal = *(vec3*)(channel->data + channel->desc.size * i + n_offset);
+                normal = -normal;
+        }
+}
+
+
 void nv::mesh_data_creator::generate_tangents()
 {
@@ -339 +359 @@
         return result;
 }
+
+nv::mesh_raw_channel* nv::mesh_data_creator::append_channels( mesh_raw_channel* a, mesh_raw_channel* b, uint32 frame_count )
+{
+        if ( a->desc != b->desc ) return nullptr;
+        if ( a->count % frame_count != 0 ) return nullptr;
+        if ( b->count % frame_count != 0 ) return nullptr;
+        size_t vtx_size = a->desc.size;
+
+        uint8* data = new uint8[ ( a->count + b->count ) * vtx_size ];
+        
+
+        if ( frame_count == 1 )
+        {
+                size_t a_size = vtx_size * a->count;
+                std::copy_n( a->data, a_size, data );
+                std::copy_n( b->data, vtx_size * b->count, data + a_size );             
+        }
+        else
+        {
+                size_t frame_size_a = ( a->count / frame_count ) * vtx_size;
+                size_t frame_size_b = ( b->count / frame_count ) * vtx_size;
+                size_t pos_a = 0;
+                size_t pos_b = 0;
+                size_t pos   = 0;
+                for ( size_t i = 0; i < frame_count; ++i )
+                {
+                        std::copy_n( a->data + pos_a, frame_size_a, data + pos );
+                        std::copy_n( b->data + pos_b, frame_size_b, data + pos + frame_size_a );                                pos_a += frame_size_a; 
+                        pos_b += frame_size_b; 
+                        pos   += frame_size_a + frame_size_b;
+                }
+        }
+
+        mesh_raw_channel* result = new mesh_raw_channel;
+        result->count = a->count + b->count;
+        result->desc  = a->desc;
+        result->data  = data;
+        return result;
+}
+
+
+
+bool nv::mesh_data_creator::is_same_format( mesh_data* other )
+{
+        if ( m_data->get_channel_count() != other->get_channel_count() ) return false;
+        for ( uint32 c = 0; c < m_data->get_channel_count(); ++c )
+        {
+                if ( m_data->get_channel(c)->desc != other->get_channel(c)->desc )
+                        return false;
+        }
+        return true;
+}
+
+void nv::mesh_data_creator::merge( mesh_data* other )
+{
+        if ( !is_same_format( other ) ) return;
+        int ch_pi  = m_data->get_channel_index( slot::POSITION );
+        int ch_ti  = m_data->get_channel_index( slot::TEXCOORD );
+        int och_pi = other->get_channel_index( slot::POSITION );
+        int och_ti = other->get_channel_index( slot::TEXCOORD );
+        if ( ch_pi == -1 || ch_ti == -1 ) return;
+        size_t size   = m_data->m_channels[ ch_ti ]->count;
+        size_t osize  =  other->m_channels[ och_ti ]->count;
+        size_t count  = m_data->m_channels[ ch_pi ]->count;
+        size_t ocount =  other->m_channels[ och_pi ]->count;
+        if ( count % size != 0 || ocount % osize != 0 ) return;
+        if ( count / size != ocount / osize ) return;
+        
+        for ( uint32 c = 0; c < m_data->get_channel_count(); ++c )
+        {
+                mesh_raw_channel* old = m_data->m_channels[c];
+                size_t frame_count = ( old->is_index() ? 1 : old->count / size );
+                m_data->m_channels[c] = append_channels( old, other->m_channels[c], frame_count );
+                NV_ASSERT( m_data->m_channels[c], "Merge problem!" );
+                if ( old->is_index() )
+                {
+                        switch ( old->desc.slots[0].etype )
+                        {
+                        case USHORT : 
+                                {
+                                        NV_ASSERT( size + osize < uint16(-1), "Index out of range!" );
+                                        uint16* indexes = (uint16*)m_data->m_channels[c]->data;
+                                        for ( uint16 i = (uint16)old->count; i < m_data->m_channels[c]->count; ++i )
+                                                indexes[i] += (uint16)size;
+
+                                }
+                                break;
+                        case UINT   : 
+                                {
+                                        uint32* indexes = (uint32*)m_data->m_channels[c]->data;
+                                        for ( uint32 i = old->count; i < m_data->m_channels[c]->count; ++i )
+                                                indexes[i] += size;
+                                }
+                                break;
+                        default : NV_ASSERT( false, "Unsupported index type!" ); break;
+                        }
+                        m_data->m_index_channel = m_data->m_channels[c];
+                }
+                delete old;
+        }
+}

trunk/src/gfx/skeletal_mesh.cc

@@ -225 +225 @@
                 skeletal_animation_entry_gpu * anim = (skeletal_animation_entry_gpu*)(a_anim);
                 anim->prepare( m_bone_data );
-                update_animation( a_anim, uint32( anim->get_start() * 1000.f * anim->get_frame_rate() * 1000 ) );
+                update_animation( a_anim, 0 );
         }
 }

trunk/src/gl/gl_window.cc

@@ -206 +206 @@
 
 gl_window::gl_window( device* dev, uint16 width, uint16 height, bool fullscreen )
-        : m_device( dev ), m_width( width ), m_height( height ), m_title("NV Engine"), m_handle( nullptr ), m_adopted( false )
+        : m_device( dev ), m_width( width ), m_height( height ), m_title("NV Engine"), m_handle( nullptr ), m_hwnd( 0 ), m_adopted( false )
 {
         //      bpp = m_info->vfmt->BitsPerPixel;
@@ -298 +298 @@
 void gl_window::swap_buffers()
 {
-        if ( m_adopted ) return; // NOT SURE
+        if ( m_adopted )
+        {
+#if NV_PLATFORM == NV_WINDOWS
+                ::SwapBuffers( (HDC)m_hwnd );
+#else
+        NV_ASSERT( false, "Native GL context only working with SDL 2.0!" );
+#endif
+
+        }
 #if NV_SDL_VERSION == NV_SDL_20
         SDL_GL_SwapWindow( static_cast<SDL_Window*>( m_handle ) );
@@ -328 +336 @@
 //      m_height  = (uint16)rect.bottom;
         m_handle  = window;
+        m_hwnd    = ::GetDC( (HWND)handle );
         m_context->set_viewport( nv::ivec4( 0, 0, m_width, m_height ) );
 #else

trunk/src/library.cc

@@ -120 +120 @@
     }
     m_handle = NULL;
-    NV_LOG( LOG_NOTICE, "library : '" + m_name + "' closed." );
 }
 

trunk/src/logger.cc

@@ -251 +251 @@
         return buffer;
 }
+
+const char* nv::log_sink::level_name( log_level level ) const
+{
+        return NV_LOG_LEVEL_NAME( level );
+}
+
+const char* nv::log_sink::padded_level_name( log_level level ) const
+{
+        return NV_LOG_LEVEL_NAME_PAD( level );
+}