Changeset 520

Timestamp:

10/03/16 17:45:46 (9 years ago)

Author:

epyon

Message:

• ecs updates
• animation updates
• ragdoll manager
• lua has own random engine
• several minor fixes
• particle engine/particle group
• shitload of other stuff
• bullet world

Location:

trunk

Files:

• nv/bullet (added)
• nv/bullet/bullet_world.hh (added)
• nv/core/aabb.hh (added)
• nv/core/bullet_world.hh (added)
• nv/ecs/ecs.hh (modified) (13 diffs)
• nv/engine/animation.hh (modified) (7 diffs)
• nv/engine/default_resource_manager.hh (modified) (3 diffs)
• nv/engine/light.hh (modified) (3 diffs)
• nv/engine/particle_engine.hh (modified) (11 diffs)
• nv/engine/particle_group.hh (added)
• nv/engine/ragdoll_manager.hh (added)
• nv/gfx/debug_draw.hh (modified) (1 diff)
• nv/gfx/mesh_creator.hh (modified) (2 diffs)
• nv/gfx/skeleton_instance.hh (modified) (3 diffs)
• nv/gl/gl_context.hh (modified) (1 diff)
• nv/image/miniz.hh (modified) (1 diff)
• nv/image/png_writer.hh (added)
• nv/interface/context.hh (modified) (1 diff)
• nv/interface/image_writer.hh (added)
• nv/interface/physics_world.hh (added)
• nv/lua/lua_aux.hh (modified) (2 diffs)
• nv/stl/container/random_access.hh (modified) (1 diff)
• nv_bullet.lua (added)
• nv_wx.lua (modified) (2 diffs)
• src/bullet (added)
• src/bullet/bullet_helper.hh (added)
• src/bullet/bullet_world.cc (added)
• src/core/library.cc (modified) (1 diff)
• src/curses/curses_terminal.cc (modified) (1 diff)
• src/engine/default_resource_manager.cc (modified) (2 diffs)
• src/engine/particle_engine.cc (modified) (28 diffs)
• src/engine/particle_group.cc (added)
• src/engine/particle_manager.cc (modified) (1 diff)
• src/engine/ragdoll_manager.cc (added)
• src/gfx/debug_draw.cc (modified) (1 diff)
• src/gfx/gfx_terminal.cc (modified) (3 diffs)
• src/gfx/mesh_creator.cc (modified) (1 diff)
• src/gfx/skeleton_instance.cc (modified) (1 diff)
• src/gl/gl_context.cc (modified) (1 diff)
• src/gui/gui_ascii_renderer.cc (modified) (1 diff)
• src/gui/gui_environment.cc (modified) (1 diff)
• src/image/miniz.cc (modified) (1 diff)
• src/image/png_writer.cc (added)
• src/lib/gl.cc (modified) (2 diffs)
• src/lua/lua_area.cc (modified) (5 diffs)
• src/lua/lua_aux.cc (modified) (7 diffs)
• src/lua/lua_map_tile.cc (modified) (2 diffs)
• src/lua/lua_math.cc (modified) (2 diffs)

trunk/nv/ecs/ecs.hh

@@ -17 +17 @@
 #include <nv/stl/string.hh>
 #include <nv/stl/handle.hh>
+#include <nv/core/types.hh>
 
 namespace nv
@@ -122 +123 @@
 
 
-                template < typename HANDLE = handle<> >
+                template < typename Handle = handle<>, typename Time = f32 >
                 class ecs
                 {
                 public:
-                        typedef HANDLE handle_type;
+                        typedef Time   time_type;
+                        typedef Handle handle_type;
 
                         typedef uint32 message_type;
@@ -134 +136 @@
                                 message_type type;
                                 handle_type  entity;
-                                uint8        payload[128 - sizeof( uint32 ) - sizeof( handle_type )];
+                                time_type    time;
+                                uint8        payload[128 - sizeof( uint32 ) - sizeof( handle_type ) - sizeof( time_type )];
                         };
 
-                        class component_interface
+                        struct message_compare_type
+                        {
+                                bool operator()( const message& l, const message& r )
+                                {
+                                        return l.time > r.time;
+                                }
+                        };
+
+                        class receiver_interface
                         {
                         public:
+                                virtual void update( time_type dtime ) = 0;
                                 virtual bool handle_message( const message& ) = 0;
                                 virtual void clear() = 0;
+                        };
+
+                        class component_interface : public receiver_interface
+                        {
+                        public:
                                 virtual void remove( handle_type h ) = 0;
+                                virtual void* get_raw( handle_type h ) = 0;
+                                virtual const void* get_raw( handle_type h ) const = 0;
                         };
 
@@ -153 +172 @@
                         }
 
-                        template < typename COMPONENT >
-                        void register_component( string_view /*name*/, component_interface* c )
+                        void register_receiver( string_view /*name*/, receiver_interface* c )
+                        {
+                                m_receivers.push_back( c );
+                        }
+
+                        template < typename Component >
+                        void register_component( string_view name, component_interface* c )
                         {
                                 m_components.push_back( c );
+                                register_receiver( name, c );
+                                m_component_map[thash64::create<Component>()] = c;
                         }
 
                         bool dispatch( const message& m )
                         {
-                                for ( auto c : m_components )
+                                for ( auto c : m_receivers )
                                         c->handle_message( m );
                                 return true;
@@ -169 +195 @@
                         bool dispatch( handle_type h, Args&&... args )
                         {
-                                message m{ Payload::message_id, h };
+                                message m{ Payload::message_id, h, time_type(0) };
                                 new( &m.payload ) Payload{ nv::forward<Args>( args )... };
                                 return dispatch( m );
                         }
 
+                        bool queue( const message& m )
+                        {
+                                push_event( m );
+                                return true;
+                        }
+
+                        template < typename Payload, typename ...Args >
+                        bool queue( handle_type h, time_type delay, Args&&... args )
+                        {
+                                message m{ Payload::message_id, h, m_time + delay };
+                                new( &m.payload ) Payload{ nv::forward<Args>( args )... };
+                                return queue( m );
+                        }
+
+
                         handle_type create()
                         {
@@ -179 +220 @@
                         }
 
+                        void update( time_type dtime )
+                        {
+                                if ( dtime == time_type(0) ) return;
+                                m_time += dtime;
+                                while ( !m_queue.empty() && m_queue.front().time <= m_time )
+                                {
+                                        message msg = m_queue.front();
+                                        pop_event();
+                                        dispatch( msg );
+                                }
+
+                                for ( auto c : m_receivers )
+                                        c->update( dtime );
+                        }
+
+                        time_type update_step()
+                        {
+                                time_type before = m_time;
+                                if ( !m_queue.empty() )
+                                {
+                                        message msg = m_queue.front();
+                                        m_time = msg.time;
+                                        pop_event();
+                                        dispatch( msg );
+                                        if ( before != m_time )
+                                                for ( auto c : m_receivers )
+                                                        c->update( m_time - before );
+                                }
+                                return m_time;
+                        }
+
+                        time_type get_time() const { return m_time; }
+
+                        bool events_pending() const
+                        {
+                                return !m_queue.empty();
+                        }
+
+                        const message& top_event() const
+                        {
+                                return m_queue.front();
+                        }
+
+                        void reset_events()
+                        {
+                                m_queue.clear();
+                                m_time = time_type(0);
+                        }
+
                         void clear()
                         {
-                                for ( auto c : m_components )
+                                reset_events();
+                                for ( auto c : m_receivers )
                                         c->clear();
                                 m_handles.clear();
@@ -198 +289 @@
                         }
 
+                        template < typename Component >
+                        Component* get( handle_type h )
+                        {
+                                return static_cast< Component* >( m_component_map[thash64::create< Component >()]->get_raw( h ) );
+                        }
+
+                        template < typename Component >
+                        const Component* get( handle_type h ) const
+                        {
+                                return static_cast<const Component*>( m_component_map[thash64::create< Component >()]->get_raw( h ) );
+                        }
+
                 protected:
-                        handle_manager< handle_type > m_handles;
-                        vector< component_interface* > m_components;
+                        void push_event( const message& msg )
+                        {
+                                m_queue.push_back( msg );
+                                push_heap( m_queue.begin(), m_queue.end(), m_compare );
+                        }
+
+                        void pop_event()
+                        {
+                                pop_heap( m_queue.begin(), m_queue.end(), m_compare );
+                                m_queue.pop_back();
+                        }
+
+                        handle_manager< handle_type >               m_handles;
+                        vector< component_interface* >              m_components;
+                        vector< receiver_interface* >               m_receivers;
+                        hash_store< thash64, component_interface* > m_component_map;
+                        time_type                                   m_time = time_type(0);
+                        vector< message >                           m_queue;
+                        message_compare_type                        m_compare;
                 };
 
@@ -210 +330 @@
                         typedef typename ecs_type::message             message_type;
                         typedef typename ecs_type::handle_type         handle_type;
+                        typedef typename ecs_type::time_type           time_type;
                         typedef index_table< handle_type >             index_table_type;
                         typedef COMPONENT                              value_type;
@@ -252 +373 @@
                         }
 
+                        virtual void update( time_type /*dtime*/ )
+                        {
+                                // no-op
+                        }
+
                         virtual void clear()
                         {
+                                for ( uint32 i = 0; i < m_index.size(); ++i )
+                                        destroy( &m_data[i] );
                                 m_index.clear();
                                 m_data.clear();
@@ -270 +398 @@
                         }
 
+                        void* get_raw( handle_type h )
+                        {
+                                index_type i = m_index.get( h );
+                                return i >= 0 ? &( m_data[unsigned( i )] ) : nullptr;
+                        }
+
+                        const void* get_raw( handle_type h ) const
+                        {
+                                index_type i = m_index.get( h );
+                                return i >= 0 ? &( m_data[unsigned( i )] ) : nullptr;
+                        }
+
+
                         virtual void remove( handle_type h )
                         {
+                                value_type* v = get( h );
+                                if ( v == nullptr ) return;
+                                destroy( v );
                                 index_type dead_eindex = m_index.remove_swap( h );
                                 if ( dead_eindex == -1 ) return;
@@ -281 +425 @@
                         }
 
-                        virtual void remove( index_type i )
-                        {
-                                index_type dead_eindex = m_index.remove_swap( i );
-                                if ( dead_eindex == -1 ) return;
-                                if ( dead_eindex != static_cast<index_type>( m_data.size() - 1 ) )
-                                {
-                                        m_data[unsigned( dead_eindex )] = move( m_data.back() );
-                                }
-                                m_data.pop_back();
+                        virtual void destroy( value_type* )
+                        {
+                                // cleanup
                         }
 
@@ -295 +433 @@
                         {
                                 return true;
+                        }
+
+                        ~component()
+                        {
+                                clear();
                         }
 
@@ -318 +461 @@
                 };
 
-                template < typename COMPONENTS >
-                class system
+                template < typename ECS >
+                class receiver : public ECS::receiver_interface
                 {
-
+                public:
+                        typedef ECS                                    ecs_type;
+                        typedef typename ecs_type::message             message_type;
+                        typedef typename ecs_type::handle_type         handle_type;
+                        typedef typename ecs_type::time_type           time_type;
+
+                        receiver( ecs_type& a_ecs, string_view a_name ) : m_ecs( a_ecs )
+                        {
+                                m_ecs.register_receiver( a_name, this );
+                        }
+                        virtual void update( time_type /*dtime*/ )
+                        {
+                                // no-op
+                        }
+
+                        virtual void clear()
+                        {
+                                // no-op
+                        }
+                        virtual bool handle_message( const message_type& )
+                        {
+                                return false;
+                        }
+                protected:
+                        ecs_type&        m_ecs;
                 };
-
         }
 

trunk/nv/engine/animation.hh

@@ -109 +109 @@
                         return m_current_state;
                 }
-                void add_transition( const animator_transition_data& data, uint32 source )
-                {
+                float add_transition( const animator_transition_data& data, uint32 source )
+                {
+                        float duration = 0.0f;
                         if ( m_transitions.size() > 0 )
                         {
+                                for ( const auto& t : m_transitions )
+                                        duration += t.duration - t.time;
                                 auto& last = m_transitions.back();
                                 if ( last.target == source && data.target == last.source )
@@ -118 +121 @@
                                         nv::swap( last.target, last.source );
                                         last.time = last.duration - last.time;
-                                        return;
+                                        /* this duration might be inaccurate? */
+                                        return duration;
                                 }
                         }
                         m_transitions.push_back( animator_transition_instance( data, source ) );
+                        return duration + m_transitions.back().duration;
                 }
                 void reset()
@@ -198 +203 @@
                 }
                 
-                void queue_event( const animator_data* data, shash64 name )
-                {
+                float queue_event( const animator_data* data, shash64 name )
+                {
+                        float duration = 0.0f;
                         for ( uint32 i = 0; i < m_layers.size(); ++i )
                                 // what about activating nonactive layers?
@@ -209 +215 @@
                                         if ( it != state.transitions.end() )
                                         {
-                                                m_layers[i].add_transition( it->second, uint32( last_state ) );
+                                                float d = m_layers[i].add_transition( it->second, uint32( last_state ) );
+                                                duration = nv::max( d, duration );
                                         }
                                 }
-                }
-
-                void update( const animator_data* data, float dtime )
+                        return duration;
+                }
+
+                void update( const animator_data* data, float dtime, bool do_delocalize = true )
                 {
                         for ( uint32 i = 0; i < m_layers.size(); ++i )
@@ -235 +243 @@
                                 }
 
+                        if ( do_delocalize )
+                                m_transforms.delocalize( data->poses->get_tree() );
+                }
+                void delocalize( const animator_data* data )
+                {
                         m_transforms.delocalize( data->poses->get_tree() );
                 }
@@ -275 +288 @@
                 }
 
-        protected:
+                const skeleton_transforms& stored()
+                {
+                        return m_stored;
+                }
+
+                void store()
+                {
+                        m_stored.assign( m_transforms );
+                }
+
+
+//      protected:
 
                 void animate_layer( const animator_layer_data& layer, const animator_transition_instance& transition, pose_data_set* pose_data, float t )
@@ -349 +373 @@
                 }
 
+
                 vector< animator_layer_instance > m_layers;
                 skeleton_transforms               m_transforms;
-
-
+                skeleton_transforms               m_stored;
         };
 

trunk/nv/engine/default_resource_manager.hh

@@ -26 +26 @@
 #include <nv/engine/model_manager.hh>
 #include <nv/engine/particle_manager.hh>
+#include <nv/engine/ragdoll_manager.hh>
 
 namespace nv
@@ -58 +59 @@
                 const type_database* get_type_db() { return m_lua->get_type_data()->get_type_database(); }
 
-                virtual void initialize( lua::state* lua );
+                virtual void initialize( lua::state* lua, physics_world* world );
                 virtual void reload_data();
         protected:
@@ -73 +74 @@
                 model_manager*         m_models;
                 particle_manager*      m_particles;
+                ragdoll_manager*       m_ragdolls;
         };
 

trunk/nv/engine/light.hh

@@ -33 +33 @@
         {
                 vec3 position;
-                vec3 color;
+                vec4 color;
                 vec4 direction;
                 float angle;
@@ -43 +43 @@
                 light_data() : color( 1.0 ), direction( 0.0f, -1.0f, 0.0f, 1.0f ), angle( 0.6f ), umbra_angle( 0.2f ), range( 4.0 ), smooth( 0 ), shadow( shadow_type::ACTIVE ) {}
                 light_data( const vec3& a_position, const vec3& a_color, shadow_type type )
-                        : position( a_position ), color( a_color )
+                        : position( a_position ), color( a_color, 1.0f )
                         , direction( 0.0f, -1.0f, 0.0f, 1.0f ), angle( 0.6f ), umbra_angle( 0.2f ), range( 4.0 ), smooth( 0 ), shadow( type ) {}
                 light_data( const light_data& ) = default;
         };
+        
+        NV_RTTI_DECLARE( nv::light_data )
 
         struct light_data_distance_compare
@@ -89 +91 @@
 
                                 m_blocks[i].position  = vec4( lights[i]->position, 1.0f );
-                                m_blocks[i].color     = vec4( lights[i]->color, 1.0f );
+                                m_blocks[i].color     = vec4( vec3( lights[i]->color ) * lights[i]->color.w, 1.0f );
                                 m_blocks[i].direction = lights[i]->direction;
                                 m_blocks[i].params    = vec4( lights[i]->angle, lights[i]->umbra_angle, lights[i]->range, 1.0f );

trunk/nv/engine/particle_engine.hh

@@ -1 @@
-// Copyright (C) 2014-2015 ChaosForge Ltd
+// Copyright (C) 2014-2016 ChaosForge Ltd
 // http://chaosforge.org/
 //
@@ -16 +16 @@
 #include <nv/gfx/texture_atlas.hh>
 #include <nv/core/resource.hh>
+#include <nv/core/random.hh>
 #include <nv/interface/scene_node.hh>
 #include <nv/interface/context.hh>
+#include <nv/engine/particle_group.hh>
 
 namespace nv
@@ -27 +29 @@
         struct particle_emitter_data;
         struct particle_affector_data;
-        struct particle;
 
-        typedef void( *particle_emitter_func )( const particle_emitter_data*, particle*, uint32 count );
+        typedef void( *particle_emitter_func )( random_base* r, const particle_emitter_data*, particle*, uint32 count );
         typedef void( *particle_affector_func )( const particle_affector_data*, particle*, float factor, uint32 count );
         typedef bool( *particle_affector_init_func )( lua::table_guard* table, particle_affector_data* data );
@@ -37 +38 @@
                 particle_affector_func      process;
                 particle_affector_init_func init;
-        };
-
-        enum class particle_orientation
-        {
-                POINT,
-                ORIENTED,
-                ORIENTED_COMMON,
-                PERPENDICULAR,
-                PERPENDICULAR_COMMON,
-        };
-        enum class particle_origin
-        {
-                CENTER,
-                TOP_LEFT,
-                TOP_CENTER,
-                TOP_RIGHT,
-                CENTER_LEFT,
-                CENTER_RIGHT,
-                BOTTOM_LEFT,
-                BOTTOM_CENTER,
-                BOTTOM_RIGHT,
-        };
-
-        struct particle_vtx
-        {
-                vec3 position;
-                vec2 texcoord;
-                vec4 color;
-        };
-
-        struct particle_quad
-        {
-                particle_vtx data[6];
-        };
-
-        struct particle
-        {
-                vec3   position;
-                vec4   color;
-                vec3   velocity;
-                vec2   size;
-                vec2   tcoord_a;
-                vec2   tcoord_b;
-                float  rotation;
-                float  lifetime;
-                float  death;
         };
 
@@ -127 +82 @@
         };
 
-        struct particle_system_data
+        struct particle_system_data : particle_group_settings
         {
                 uint32 quota;
-                vec3   common_up;
-                vec3   common_dir;
-                bool   accurate_facing;
-                particle_orientation   orientation;
-                particle_origin        origin;
                 uint32                 emitter_count;
                 particle_emitter_data  emitters[MAX_PARTICLE_EMITTERS];
@@ -141 +91 @@
         };
 
-        struct particle_system_group_tag {};
-        typedef handle< uint32, 16, 16, particle_system_group_tag > particle_system_group;
         struct particle_system_tag {};
         typedef handle< uint32, 16, 16, particle_system_tag > particle_system;
@@ -151 +99 @@
                 particle_emitter_info emitters[MAX_PARTICLE_EMITTERS];
 
-                uint32                count;
-                vec2                  texcoords[2];
-                particle_system_group group;
+                uint32         count;
+                vec2           texcoords[2];
+                particle_group group;
 
                 const particle_system_data*    data;
-        };
-
-        struct particle_system_group_info
-        {
-                uint32                count;
-                uint32                quota;
-                vertex_array          vtx_array;
-                buffer                vtx_buffer;
-                bool                  local;
-                particle_quad*        quads;
-                uint32                ref_counter;
-        };
-
-        struct particle_render_data
-        {
-                uint32                count;
-                vertex_array          vtx_array;
         };
 
@@ -178 +109 @@
 
 NV_RTTI_DECLARE_NAME( nv::particle_system_data, "particle_system_data" )
-NV_RTTI_DECLARE_NAME( nv::particle_orientation, "particle_orientation" )
-NV_RTTI_DECLARE_NAME( nv::particle_origin,      "particle_origin" )
 
-namespace nv {
+namespace nv
+{
 
         class particle_engine
         {
         public:
-                particle_engine( context* a_context, bool debug_data = false );
+                particle_engine( context* a_context, random_base* rng, particle_group_manager* groups, bool debug_data = false );
                 void reset();
-                void prepare( particle_system_group group );
-                particle_system_group create_group( uint32 max_particles );
-                particle_system create_system( resource< particle_system_data > rdata, particle_system_group group );
-                particle_system create_system( const particle_system_data* data, particle_system_group group );
-                void release( particle_system_group group );
+                void prepare( particle_group group );
+                particle_group create_group( uint32 max_particles );
+                particle_system create_system( resource< particle_system_data > rdata, particle_group group );
+                particle_system create_system( const particle_system_data* data, particle_group group );
+                void release( particle_group group );
                 void release( particle_system system );
                 void update( particle_system system, transform model, float dtime );
@@ -205 +135 @@
                 static const vector< particle_emitter_func >* get_debug_emitter_list() { return m_debug_emitter_list; }
                 static const vector< particle_affector_func >* get_debug_affector_list() { return m_debug_affector_list; }
-                static const type_entry* get_debug_type( particle_affector_init_func f );
-                static void register_types( type_database* db );
-                particle_render_data get_render_data( particle_system_group group );
+                static const type_entry* get_debug_type( particle_affector_func f );
+                static void register_types( type_database* db, bool debug_data = false );
+                particle_render_data get_render_data( particle_group group );
+                particle_group_manager* get_particle_manager() { return m_pgm; }
                 ~particle_engine();
         private:
@@ -213 +144 @@
                 void register_standard_emitters();
                 void register_standard_affectors();
-                void generate_data( particle_system_info* info, const scene_state& s );
                 void destroy_particles( particle_system_info* info, float dtime );
                 void create_particles( particle_system_info* info, transform tr, float dtime );
@@ -219 +149 @@
                 void update_emitters( particle_system_info* info, float dtime );
 
+                particle_group_manager* m_pgm;
                 context* m_context;
+                random_base* m_rng;
 
                 handle_store< particle_system_info, particle_system >             m_systems;
-                handle_store< particle_system_group_info, particle_system_group > m_groups;
 
                 static hash_store< shash64, particle_emitter_func >          m_emitters;

trunk/nv/gfx/debug_draw.hh

@@ -37 +37 @@
                 void push_aabox( const vec3& a, const vec3& b, const vec3& color );
                 void push_gizmo( const nv::transform& tr, float length );
+                void push_wire_capsule( const transform& tr, float radius, float height );
                 ~debug_data();
         private:

trunk/nv/gfx/mesh_creator.hh

@@ -10 +10 @@
 #include <nv/common.hh>
 #include <nv/stl/math.hh>
+#include <nv/core/aabb.hh>
 #include <nv/interface/mesh_data.hh>
 
@@ -22 +23 @@
                         initialize();
                 }
+
+                aabb calculate_aabb();
 
                 // assumes that position and normal is vec3, tangent is vec4

trunk/nv/gfx/skeleton_instance.hh

@@ -10 +10 @@
 #include <nv/common.hh>
 #include <nv/stl/array.hh>
+#include <nv/core/logging.hh>
 #include <nv/interface/context.hh>
 #include <nv/interface/mesh_data.hh>
@@ -126 +127 @@
                 }
 
+                void delocalize( const data_node_tree& node_data, const array_view< bool >& mask )
+                {
+                        for ( uint32 n = 0; n < node_data.size(); ++n )
+                                if ( node_data[n].parent_id == -1 )
+                                        delocalize_rec( node_data, n, transform(), mask );
+                }
+
                 void delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent );
+                void delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent, const array_view< bool >& mask );
 
 //      protected:
@@ -194 +203 @@
 
 
-        protected:
+//      protected:
 
                 dynamic_array< mat4 >      m_matrix;

trunk/nv/gl/gl_context.hh

@@ -41 +41 @@
                 virtual void release( vertex_array va );
                 virtual void release( framebuffer f );
+                virtual image_data* dump_image( image_format f, image_data* reuse );
                 virtual const framebuffer_info* get_framebuffer_info( framebuffer f ) const;
 

trunk/nv/image/miniz.hh

@@ -17 +17 @@
 
         void *miniz_decompress( const void *source_buf, size_t source_buf_len, size_t *out_len, bool parse_header );
-
+        int miniz_compress( unsigned char *pDest, unsigned long *pDest_len, const unsigned char *pSource, unsigned long source_len, int level );
+        unsigned long miniz_bound( unsigned long source_len );
 
 }

trunk/nv/interface/context.hh

@@ -159 +159 @@
                 virtual void release( texture t ) { m_device->release( t ); }
                 virtual void release( buffer b ) { m_device->release( b ); }
+
+                virtual image_data* dump_image( image_format f, image_data* reuse ) = 0;
 
                 virtual texture create_texture( texture_type type, ivec2 size, image_format aformat, sampler asampler, const void* data = nullptr ) = 0;

trunk/nv/lua/lua_aux.hh

@@ -9 +9 @@
 
 #include <nv/lua/lua_state.hh>
+#include <nv/core/random.hh>
 
 namespace nv
@@ -14 +15 @@
         namespace lua
         {
+                random& rng();
                 void register_aux( lua::state* state );
         }

trunk/nv/stl/container/random_access.hh

@@ -99 +99 @@
                 inline void fill( const value_type& value )
                 {
-                        fill_n( iterator( Super::data() ), iterator( Super::data() + this->size() ), value );
+                        ::nv::fill( iterator( Super::data() ), iterator( Super::data() + this->size() ), value );
                 }
 

trunk/nv_wx.lua

@@ -1 +1 @@
 assert( NV_RUNTIME == "dcrt" )
+
+project "*"
+        includedirs { 
+                "D:/Libraries/wxwidgets/include/msvc/",
+                "D:/Libraries/wxwidgets/include/",
+        }
+        libdirs { "D:/Libraries/wxwidgets/lib/vc140_dll" }
+        defines { "__WXMSW__", "_UNICODE", "WXUSINGDLL", "wxMSVC_VERSION_AUTO" }
 
 project "nv-wx"
@@ -11 +19 @@
         links { "nv-core", "nv-gl", "nv-formats", "nv-lua", "nv-lib", "nv-io", "nv-gfx", "nv-sdl" }
 
-solution "*"
-        includedirs { 
-                "D:/Libraries/wxwidgets/include/msvc/",
-                "D:/Libraries/wxwidgets/include/",
-        }
-        libdirs { "D:/Libraries/wxwidgets/lib/vc140_dll" }
-        defines { "__WXMSW__", "_UNICODE", "WXUSINGDLL", "wxMSVC_VERSION_AUTO" }

trunk/src/core/library.cc

@@ -11 +11 @@
 #   include <windows.h>
 #   define NV_LIB_EXT ".dll"
-#   define NV_LIB_OPEN( name ) static_cast<void*>( LoadLibraryEx( name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH ) )
+#   define NV_LIB_OPEN( name ) static_cast<void*>( LoadLibraryExA( name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH ) )
 #   define NV_LIB_GET( handle, name ) reinterpret_cast<void*>( GetProcAddress( static_cast<HMODULE>( handle ), name ) )
 #   define NV_LIB_CLOSE( handle ) ( FreeLibrary( static_cast<HMODULE>( handle ) ) != 0 )

trunk/src/curses/curses_terminal.cc

@@ -131 +131 @@
         }
 
+        // if result is a typable char from the 0..9 range
+        if ( result >= 0x108 && result <= 0x108 + 12 )
+        {
+                kevent.key.code = static_cast<nv::key_code>( nv::KEY_F1 + result - 0x108 - 1 );
+        }
+
         // other recognized codes
         switch ( result )

trunk/src/engine/default_resource_manager.cc

@@ -11 +11 @@
 default_resource_manager::default_resource_manager( context* context, bool clear_material_paths )
 {
-        m_images        = register_resource_handler< image_data >( new image_manager );
-        m_meshes        = register_resource_handler< data_channel_set >( new mesh_manager );
-        m_binds         = register_resource_handler< animator_bind_data >( new animator_bind_manager );
-        m_animators     = register_resource_handler< animator_data >( new animator_manager );
-        m_materials     = register_resource_handler< material >( new material_manager( clear_material_paths ) );
-        m_programs      = register_resource_handler< program >( new program_manager( context ) );
-        m_gpu_meshes    = register_resource_handler< gpu_mesh >( new gpu_mesh_manager( context, m_meshes ) );
-        m_mesh_datas    = register_resource_handler< mesh_data >( new mesh_data_manager( m_meshes ) );
+        m_images = register_resource_handler< image_data >( new image_manager );
+        m_meshes = register_resource_handler< data_channel_set >( new mesh_manager );
+        m_binds = register_resource_handler< animator_bind_data >( new animator_bind_manager );
+        m_animators = register_resource_handler< animator_data >( new animator_manager );
+        m_materials = register_resource_handler< material >( new material_manager( clear_material_paths ) );
+        m_programs = register_resource_handler< program >( new program_manager( context ) );
+        m_gpu_meshes = register_resource_handler< gpu_mesh >( new gpu_mesh_manager( context, m_meshes ) );
+        m_mesh_datas = register_resource_handler< mesh_data >( new mesh_data_manager( m_meshes ) );
         m_gpu_materials = register_resource_handler< gpu_material >( new gpu_material_manager( context, m_materials, m_images ) );
-        m_models        = register_resource_handler< model >( new model_manager( this, m_binds, m_mesh_datas ) );
-        m_particles     = register_resource_handler< particle_system_data >( new particle_manager );
+        m_models = register_resource_handler< model >( new model_manager( this, m_binds, m_mesh_datas ) );
+        m_particles = register_resource_handler< particle_system_data >( new particle_manager );
+        m_ragdolls = register_resource_handler< ragdoll_data >( new ragdoll_manager( m_models ) );
 }
 
-void default_resource_manager::initialize( lua::state* lua )
+void default_resource_manager::initialize( lua::state* lua, physics_world* world )
 {
         m_lua = lua;
@@ -72 +73 @@
         m_models->initialize( lua );
         m_particles->initialize( lua );
+        m_ragdolls->initialize( lua );
+        m_ragdolls->initialize( world );
 }
 

trunk/src/engine/particle_engine.cc

@@ -1 @@
-// Copyright (C) 2014-2015 ChaosForge Ltd
+// Copyright (C) 2014-2016 ChaosForge Ltd
 // http://chaosforge.org/
 //
@@ -26 +26 @@
 using namespace nv;
 
-static void nv_particle_emitter_point( const particle_emitter_data*, particle* p, uint32 count )
+static void nv_particle_emitter_point( random_base*, const particle_emitter_data*, particle* p, uint32 count )
 {
         for ( uint32 i = 0; i < count; ++i )
@@ -34 +34 @@
 }
 
-static void nv_particle_emitter_box( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                p[i].position = 
-                        r.frange( -pe->hextents[0], pe->hextents[0] ) * pe->cdir +
-                        r.frange( 0.0f, pe->extents[1] ) * pe->dir +
-                        r.frange( -pe->hextents[2], pe->hextents[2] ) * pe->odir;
-        }
-}
-
-static void nv_particle_emitter_cylinder( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec2 rellipse( r.disk_point( pe->precise ) * pe->extents[0] );
+static void nv_particle_emitter_box( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                p[i].position = 
+                        r->frange( -pe->hextents[0], pe->hextents[0] ) * pe->cdir +
+                        r->frange( 0.0f, pe->extents[1] ) * pe->dir +
+                        r->frange( -pe->hextents[2], pe->hextents[2] ) * pe->odir;
+        }
+}
+
+static void nv_particle_emitter_cylinder( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec2 rellipse( r->disk_point( pe->precise ) * pe->extents[0] );
                 p[i].position = 
                         rellipse.x * pe->cdir +
-                        r.frange( 0.0f, pe->extents[1] ) * pe->dir +
+                        r->frange( 0.0f, pe->extents[1] ) * pe->dir +
                         rellipse.y * pe->odir;
         }
 }
 
-static void nv_particle_emitter_sphere( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec3 rsphere = r.sphere_point( pe->precise ) * pe->extents[0];
+static void nv_particle_emitter_sphere( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec3 rsphere = r->sphere_point( pe->precise ) * pe->extents[0];
                 p[i].position = 
                         rsphere.x * pe->cdir +
@@ -72 +69 @@
 }
 
-static void nv_particle_emitter_cylindroid( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec2 rellipse = r.ellipse_point( vec2( pe->hextents[0], pe->hextents[2] ), pe->precise );
+static void nv_particle_emitter_cylindroid( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec2 rellipse = r->ellipse_point( vec2( pe->hextents[0], pe->hextents[2] ), pe->precise );
                 p[i].position = 
                         rellipse.x * pe->cdir +
-                        r.frange( 0.0f, pe->extents[1] ) * pe->dir +
+                        r->frange( 0.0f, pe->extents[1] ) * pe->dir +
                         rellipse.y * pe->odir;
         }
 }
 
-static void nv_particle_emitter_ellipsoid( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec3 rsphere = r.ellipsoid_point( pe->hextents, pe->precise );
+static void nv_particle_emitter_ellipsoid( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec3 rsphere = r->ellipsoid_point( pe->hextents, pe->precise );
                 p[i].position = 
                         rsphere.x * pe->cdir +
@@ -98 +93 @@
 }
 
-static void nv_particle_emitter_hollow_cylinder( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec2 rellipse = r.hollow_disk_point( 
+static void nv_particle_emitter_hollow_cylinder( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec2 rellipse = r->hollow_disk_point(
                         pe->ihextents[0],
                         pe->hextents[0],
@@ -109 +103 @@
                 p[i].position = 
                         rellipse.x * pe->cdir +
-                        r.frange( 0.0f, pe->extents[1] ) * pe->dir +
+                        r->frange( 0.0f, pe->extents[1] ) * pe->dir +
                         rellipse.y * pe->odir;
         }
 }
 
-static void nv_particle_emitter_hollow_sphere( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec3 rellipse = r.hollow_sphere_point( pe->ihextents[0], pe->hextents[0], pe->precise );
+static void nv_particle_emitter_hollow_sphere( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec3 rellipse = r->hollow_sphere_point( pe->ihextents[0], pe->hextents[0], pe->precise );
                 p[i].position = 
                         rellipse.x * pe->cdir +
@@ -127 +120 @@
 }
 
-static void nv_particle_emitter_hollow_cylindroid( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec2 rellipse = r.hollow_ellipse_point( 
+static void nv_particle_emitter_hollow_cylindroid( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec2 rellipse = r->hollow_ellipse_point(
                         vec2( pe->ihextents[0], pe->ihextents[2] ), 
                         vec2( pe->hextents[0], pe->hextents[2] ), 
@@ -138 +130 @@
                 p[i].position = 
                         rellipse.x * pe->cdir +
-                        r.frange( 0.0f, pe->extents[1] ) * pe->dir +
+                        r->frange( 0.0f, pe->extents[1] ) * pe->dir +
                         rellipse.y * pe->odir;
         }
 }
 
-static void nv_particle_emitter_hollow_ellipsoid( const particle_emitter_data* pe, particle* p, uint32 count )
-{
-        random& r = random::get();
-        for ( uint32 i = 0; i < count; ++i )
-        {
-                vec3 rellipse = r.hollow_ellipsoid_point( pe->ihextents, pe->hextents, pe->precise );
+static void nv_particle_emitter_hollow_ellipsoid( random_base* r, const particle_emitter_data* pe, particle* p, uint32 count )
+{
+        for ( uint32 i = 0; i < count; ++i )
+        {
+                vec3 rellipse = r->hollow_ellipsoid_point( pe->ihextents, pe->hextents, pe->precise );
                 p[i].position = 
                         rellipse.x * pe->cdir +
@@ -278 +269 @@
 }
 
-nv::particle_engine::particle_engine( context* a_context, bool debug_data )
-{
-        m_context       = a_context;
+nv::particle_engine::particle_engine( context* a_context, random_base* rng, particle_group_manager* groups, bool debug_data )
+{
+        m_context = a_context;
+        m_pgm     = groups;
+        m_rng     = rng;
+        if ( m_rng == nullptr )
+                m_rng = &random::get();
+
         if ( debug_data )
         {
                 m_debug_emitter_names  = new nv::hash_map< nv::particle_emitter_func,  nv::const_string >;
                 m_debug_affector_names = new nv::hash_map< nv::particle_affector_func, nv::const_string >;
-                m_debug_affector_types = new nv::hash_map< nv::particle_affector_func, nv::type_entry* >;
                 m_debug_emitter_list   = new nv::vector< nv::particle_emitter_func >;
                 m_debug_affector_list  = new nv::vector< nv::particle_affector_func >;
@@ -294 +289 @@
 }
 
-nv::particle_system nv::particle_engine::create_system( const particle_system_data* data, particle_system_group group )
-{
-        particle_system_group_info* ginfo = m_groups.get( group );
-        if ( !ginfo ) return nv::particle_system();
-
+nv::particle_system nv::particle_engine::create_system( const particle_system_data* data, particle_group group )
+{
+        if ( !m_pgm->ref( group ) ) 
+                return nv::particle_system();
+        
         particle_system result = m_systems.create();
         particle_system_info* info = m_systems.get( result );
@@ -310 +305 @@
                         info->emitters[i].pause = 0;
                 else
-                        info->emitters[i].pause = random::get().frange( data->emitters[i].duration_min, data->emitters[i].duration_max );
+                        info->emitters[i].pause = m_rng->frange( data->emitters[i].duration_min, data->emitters[i].duration_max );
 
         }
@@ -316 +311 @@
         info->count = 0;
         info->particles = new particle[data->quota];
-        ginfo->ref_counter++;
 
         return result;
 }
 
-nv::particle_system nv::particle_engine::create_system( resource< nv::particle_system_data > rdata, particle_system_group group )
+nv::particle_system nv::particle_engine::create_system( resource< nv::particle_system_data > rdata, particle_group group )
 {
         if ( auto data = rdata.lock() )
@@ -328 +322 @@
 }
 
-void nv::particle_engine::prepare( particle_system_group group )
-{
-        particle_system_group_info* info = m_groups.get( group );
-        if ( info )
-        {
-                info->count = 0;
-        }
-}
-
-nv::particle_system_group nv::particle_engine::create_group( uint32 max_particles )
-{
-        particle_system_group result     = m_groups.create();
-        particle_system_group_info* info = m_groups.get( result );
-        info->local = false;
-        info->count = 0;
-        info->quota = max_particles;
-        info->vtx_buffer = m_context->create_buffer( VERTEX_BUFFER, STREAM_DRAW, info->quota * sizeof( particle_quad )/*, info->quads_[0].data*/ );
-        vertex_array_desc desc;
-        desc.add_vertex_buffers< particle_vtx >( info->vtx_buffer, true );
-        info->vtx_array = m_context->create_vertex_array( desc );
-        info->quads     = new particle_quad[info->quota];
-        info->ref_counter = 0;
-        return result;
+void nv::particle_engine::prepare( particle_group group )
+{
+        m_pgm->prepare( group );
+}
+
+nv::particle_group nv::particle_engine::create_group( uint32 max_particles )
+{
+        return m_pgm->create_group( max_particles );
 }
 
@@ -369 +348 @@
         while ( m_systems.size() > 0 )
                 release( m_systems.get_handle( 0 ) );
-        while ( m_groups.size() > 0 )
-                release( m_groups.get_handle( 0 ) );
+        if ( m_pgm )
+                m_pgm->reset();
         m_emitters.clear();
         m_affectors.clear();
@@ -381 +360 @@
         if ( info )
         {
-                particle_system_group_info* ginfo = m_groups.get( info->group );
-                if ( ginfo ) ginfo->ref_counter--;
-                                delete[] info->particles;
+                m_pgm->unref( info->group );
+                delete[] info->particles;
                 m_systems.destroy( system );
         }
 }
 
-void nv::particle_engine::release( particle_system_group group )
-{
-        particle_system_group_info* info = m_groups.get( group );
-        if ( info )
-        {
-                delete[] info->quads;
-                m_context->release( info->vtx_array );
-                m_groups.destroy( group );
-        }
+void nv::particle_engine::release( particle_group group )
+{
+        m_pgm->release( group );
 }
 
@@ -403 +375 @@
         particle_system_info* info = m_systems.get( system );
         if ( info )
-        {
-                generate_data( info, s );
-        }
+                m_pgm->generate_data( array_view< particle >( info->particles, info->count ), info->data, info->group, s );
 }
 
@@ -440 +410 @@
                 info->texcoords[1] = b;
         }
-}
-
-void nv::particle_engine::generate_data( particle_system_info* info, const scene_state& s )
-{
-//      void* rawptr = m_context->map_buffer( info->vtx_buffer, nv::WRITE_UNSYNCHRONIZED, offset, info->count*sizeof( particle_quad ) );
-//      particle_quad* quads = reinterpret_cast<particle_quad*>( rawptr );
-
-        particle_system_group_info* group = m_groups.get( info->group );
-        if ( !info )
-        {
-                return;
-        }
-
-        vec2 lb     = vec2( -0.5f, -0.5f );
-        vec2 rt     = vec2( 0.5f, 0.5f );
-
-        switch ( info->data->origin )
-        {
-        case particle_origin::CENTER        : break;
-        case particle_origin::TOP_LEFT      : lb = vec2(0.f,-1.f); rt = vec2(1.f,0.f);  break;
-        case particle_origin::TOP_CENTER    : lb.y = -1.f; rt.y = 0.f; break;
-        case particle_origin::TOP_RIGHT     : lb = vec2(-1.f,-1.f); rt = vec2(); break;
-        case particle_origin::CENTER_LEFT   : lb.x = 0.f; rt.x = 1.f; break;
-        case particle_origin::CENTER_RIGHT  : lb.x = -1.f; rt.x = 0.f; break;
-        case particle_origin::BOTTOM_LEFT   : lb = vec2(); rt = vec2(1.f,1.f); break;
-        case particle_origin::BOTTOM_CENTER : lb.y = 0.f; rt.y = 1.f; break; 
-        case particle_origin::BOTTOM_RIGHT  : lb = vec2(-1.f,0.f); rt = vec2(.0f,1.f); break;
-        }
-
-        const vec3 sm[4] = 
-        { 
-                vec3( lb.x, lb.y, 0.0f ),
-                vec3( rt.x, lb.y, 0.0f ),
-                vec3( lb.x, rt.y, 0.0f ),
-                vec3( rt.x, rt.y, 0.0f ),
-        };
-        vec3 z( 0.0f, 0.0f ,1.0f );
-
-        particle_orientation orientation = info->data->orientation;
-        vec3 common_up ( info->data->common_up );
-        vec3 common_dir( info->data->common_dir );
-        bool accurate_facing = info->data->accurate_facing;
-        mat3 rot_mat;
-        vec3 right;
-        vec3 pdir( 0.0f, 1.0f, 0.0f );
-
-        vec3 camera_pos   = s.get_camera().get_position();
-        vec3 inv_view_dir = math::normalize( -s.get_camera().get_direction() );
-
-        for ( uint32 i = 0; i < info->count; ++i )
-        {
-                const particle& pdata = info->particles[i];
-//              particle_quad& rdata  = quads[i];
-                particle_quad& rdata  = group->quads[i + group->count];
-
-                vec3 view_dir( inv_view_dir );
-                if ( accurate_facing ) view_dir = math::normalize( camera_pos - pdata.position );
-
-                switch ( orientation )
-                {
-                case particle_orientation::POINT :
-                        right   = math::normalize( math::cross( view_dir, vec3( 0, 1, 0 ) ) );
-                        right   = math::rotate( right, pdata.rotation, view_dir );
-                        rot_mat = mat3( right, math::cross( right, -view_dir ), -view_dir );
-                        break;
-                case particle_orientation::ORIENTED :
-                        pdir    = normalize_safe( pdata.velocity, pdir );
-                        right   = math::normalize( math::cross( pdir, view_dir ) );
-                        rot_mat = mat3( right, pdir, math::cross( pdir, right ) );
-                        break;
-                case particle_orientation::ORIENTED_COMMON :
-                        right   = math::normalize( math::cross( common_dir, view_dir ) );
-                        rot_mat = mat3( right, common_dir, math::cross( common_dir, right ) );
-                        break;
-                case particle_orientation::PERPENDICULAR :
-                        pdir    = normalize_safe( pdata.velocity, pdir );
-                        right   = math::normalize( math::cross( common_up, pdir ) );
-                        rot_mat = mat3( right, common_up, math::cross( common_up, right ) );
-                        break;
-                case particle_orientation::PERPENDICULAR_COMMON :
-                        right   = math::normalize( math::cross( common_up, common_dir ) );
-                        rot_mat = mat3( right, common_up, math::cross( common_up, right ) );
-                        break;
-                }
-
-                vec2 texcoords[4] =
-                {
-                        pdata.tcoord_a,
-                        vec2( pdata.tcoord_b.x, pdata.tcoord_a.y ),
-                        vec2( pdata.tcoord_a.x, pdata.tcoord_b.y ),
-                        pdata.tcoord_b
-                };
-
-                vec3 size( pdata.size.x, pdata.size.y, 0.0f );
-                vec3 s0 = rot_mat * ( ( size * sm[0] ) );
-                vec3 s1 = rot_mat * ( ( size * sm[1] ) );
-                vec3 s2 = rot_mat * ( ( size * sm[2] ) );
-                vec3 s3 = rot_mat * ( ( size * sm[3] ) );
-
-                rdata.data[0].position = pdata.position + s0;
-                rdata.data[0].color    = pdata.color;
-                rdata.data[0].texcoord = texcoords[0];
-
-                rdata.data[1].position = pdata.position + s1;
-                rdata.data[1].color    = pdata.color;
-                rdata.data[1].texcoord = texcoords[1];
-
-                rdata.data[2].position = pdata.position + s2;
-                rdata.data[2].color    = pdata.color;
-                rdata.data[2].texcoord = texcoords[2];
-
-                rdata.data[3].position = pdata.position + s3;
-                rdata.data[3].color    = pdata.color;
-                rdata.data[3].texcoord = texcoords[3];
-
-                rdata.data[4] = rdata.data[2];
-                rdata.data[5] = rdata.data[1];
-        }
-//      m_context->unmap_buffer( info->vtx_buffer );
-
-        m_context->update( group->vtx_buffer, group->quads, group->count*sizeof(particle_quad), info->count*sizeof( particle_quad ) );
-        group->count += info->count;
 }
 
@@ -584 +432 @@
         if ( ecount == 0 ) return;
 
-        random& r = random::get();
         bool local = model.is_identity();
 //      if ( !local ) 
@@ -605 +452 @@
                                 {
                                         particle& pinfo = info->particles[info->count];
-                                        edata.emitter_func( &(info->data->emitters[i]), &pinfo, 1 );
+                                        edata.emitter_func( m_rng, &(info->data->emitters[i]), &pinfo, 1 );
                                         pinfo.position = vec3();
                                         pinfo.position+= edata.position;
@@ -611 +458 @@
                                                 pinfo.position = pinfo.position * model;
                                         pinfo.color    = edata.color_min == edata.color_max ?
-                                                edata.color_min : r.range( edata.color_min, edata.color_max );
+                                                edata.color_min : m_rng->range( edata.color_min, edata.color_max );
                                         pinfo.size     = edata.size_min == edata.size_max ?
-                                                edata.size_min : r.range( edata.size_min, edata.size_max );
+                                                edata.size_min : m_rng->range( edata.size_min, edata.size_max );
                                         if ( edata.square ) pinfo.size.y = pinfo.size.x;
                                         float velocity = edata.velocity_min == edata.velocity_max ?
-                                                edata.velocity_min : r.frange( edata.velocity_min, edata.velocity_max );
+                                                edata.velocity_min : m_rng->frange( edata.velocity_min, edata.velocity_max );
                                         pinfo.lifetime = dtime + einfo.next;
                                         pinfo.death = ( edata.lifetime_min == edata.lifetime_max ?
-                                                edata.lifetime_min : r.frange( edata.lifetime_min, edata.lifetime_max ) );
-                                        pinfo.rotation = r.frand( 2* math::pi<float>() );
+                                                edata.lifetime_min : m_rng->frange( edata.lifetime_min, edata.lifetime_max ) );
+                                        pinfo.rotation = m_rng->frand( 2* math::pi<float>() );
                                         pinfo.tcoord_a = info->texcoords[0];
                                         pinfo.tcoord_b = info->texcoords[1];
@@ -628 +475 @@
                                         {
                                                 float emission_angle = math::radians( edata.angle );
-                                                float cos_theta = r.frange( cos( emission_angle ), 1.0f );
+                                                float cos_theta = m_rng->frange( cos( emission_angle ), 1.0f );
                                                 float sin_theta = sqrt(1.0f - cos_theta * cos_theta );
-                                                float phi       = r.frange( 0.0f, 2* math::pi<float>() );
+                                                float phi       = m_rng->frange( 0.0f, 2* math::pi<float>() );
                                                 pinfo.velocity  = model.get_orientation() * 
                                                         ( edata.odir * ( cos(phi) * sin_theta ) +
@@ -672 +519 @@
         uint32 ecount = info->data->emitter_count;
         if ( ecount == 0 ) return;
-        random& r = random::get();
 
         for ( uint32 i = 0; i < ecount; ++i )
@@ -691 +537 @@
                                 einfo.active = false;
                                 if ( edata.repeat_min > 0.0f )
-                                        einfo.pause += r.frange( edata.repeat_min, edata.repeat_max );
+                                        einfo.pause += m_rng->frange( edata.repeat_min, edata.repeat_max );
                                 else
                                         einfo.pause = 0.0f;
@@ -698 +544 @@
                         {
                                 einfo.active = true;
-                                einfo.pause += r.frange( edata.duration_min, edata.duration_max );
+                                einfo.pause += m_rng->frange( edata.duration_min, edata.duration_max );
                         }
                 }
@@ -776 +622 @@
 }
 
-nv::particle_render_data nv::particle_engine::get_render_data( particle_system_group group )
-{
-        const particle_system_group_info* info = m_groups.get( group );
-        if ( info )
-        {
-                return{ info->count, info->vtx_array };
-        }
-        return { 0, nv::vertex_array() };
+nv::particle_render_data nv::particle_engine::get_render_data( particle_group group )
+{
+        return m_pgm->get_render_data( group );
 }
 
@@ -794 +635 @@
 }
 
-void nv::particle_engine::register_types( type_database* db )
+const nv::type_entry* nv::particle_engine::get_debug_type( particle_affector_func f )
+{
+        if ( m_debug_affector_types )
+        {
+                auto it = m_debug_affector_types->find( f );
+                if ( it != m_debug_affector_types->end() )
+                        return it->second;
+        }
+        return nullptr;
+}
+
+void nv::particle_engine::register_types( type_database* db, bool debug_data )
 {
         db->create_type<particle_orientation>()
@@ -816 +668 @@
                 ;
 
-        if ( m_debug_affector_types )
-        {
+        if ( debug_data )
+        {
+                if ( !m_debug_affector_types )
+                        m_debug_affector_types = new nv::hash_map< nv::particle_affector_func, nv::type_entry* >;
+
                 int you_could_get_rid_of_the_init_function_using_these; int error;
                 int universal_vm_based_affector;
@@ -849 +704 @@
         }
 }
+

trunk/src/engine/particle_manager.cc

@@ -61 +61 @@
         data->emitter_count   = 0;
         data->affector_count  = 0;
-
-        const_string orientation = table.get_string( "orientation", "point" );
-        if ( orientation == "point" )                     { data->orientation = particle_orientation::POINT; }
-        else if ( orientation == "oriented" )             { data->orientation = particle_orientation::ORIENTED; }
-        else if ( orientation == "oriented_common" )      { data->orientation = particle_orientation::ORIENTED_COMMON; }
-        else if ( orientation == "perpendicular" )        { data->orientation = particle_orientation::PERPENDICULAR; }
-        else if ( orientation == "perpendicular_common" ) { data->orientation = particle_orientation::PERPENDICULAR_COMMON; }
-        else 
-        {
-                NV_LOG_ERROR( "Unknown orientation type! (", orientation, ")!" );
-                data->orientation = particle_orientation::POINT;
-        }
-
-        const_string origin = table.get_string( "origin", "center" );
-        if      ( origin == "center" )        { data->origin = particle_origin::CENTER; }
-        else if ( origin == "top_left" )      { data->origin = particle_origin::TOP_LEFT; }
-        else if ( origin == "top_center" )    { data->origin = particle_origin::TOP_CENTER; }
-        else if ( origin == "top_right" )     { data->origin = particle_origin::TOP_RIGHT; }
-        else if ( origin == "center_left" )   { data->origin = particle_origin::CENTER_LEFT; }
-        else if ( origin == "center_right" )  { data->origin = particle_origin::CENTER_RIGHT; }
-        else if ( origin == "bottom_left" )   { data->origin = particle_origin::BOTTOM_LEFT; }
-        else if ( origin == "bottom_center" ) { data->origin = particle_origin::BOTTOM_CENTER; }
-        else if ( origin == "bottom_right" )  { data->origin = particle_origin::BOTTOM_RIGHT; }
-        else 
-        {
-                NV_LOG_ERROR( "Unknown particle origin! (", origin, ")!" );
-                data->origin = particle_origin::CENTER;
-        }
+        data->orientation     = particle_orientation( table.get_unsigned("orientation", 0) );
+        data->origin          = particle_origin( table.get_unsigned( "origin",0  ) );
 
         data->common_up  = math::normalize( table.get<vec3>("common_up",  vec3(1,0,0) ) );

trunk/src/gfx/debug_draw.cc

@@ -101 +101 @@
 }
 
+void nv::debug_data::push_wire_capsule( const transform& tr, float radius, float height )
+{
+        vec3 p = tr.get_position();
+        quat o = tr.get_orientation();
+        vec3 dir   = o * vec3( 0, 1, 0 );
+        vec3 ldir  = o * vec3( 1, 0, 0 );
+        vec3 h1dir = o * normalize( vec3( 1, -1, 0 ) );
+        vec3 h2dir = o * normalize( vec3( 1, 1, 0 ) );
+        vec3 sp1[12];
+        vec3 sp2[12];
+        vec3 hsp1[12];
+        vec3 hsp2[12];
+        for ( uint32 i = 0; i < 12; ++i )
+        {
+                sp1[i]  = nv::math::rotate( ldir * radius, ( float( i ) / 12.0f ) * math::two_pi<float>(), dir );
+                hsp1[i] = nv::math::rotate( h1dir * radius, ( float( i ) / 12.0f ) * math::two_pi<float>(), dir );
+        }
+        for ( uint32 i = 0; i < 12; ++i )
+        {
+                sp2[i]  = nv::math::rotate( ldir * radius + height * dir, ( float( i ) / 12.0f ) * math::two_pi<float>(), dir );
+                hsp2[i] = nv::math::rotate( h2dir * radius + height * dir, ( float( i ) / 12.0f ) * math::two_pi<float>(), dir );
+        }
+
+        for ( uint32 i = 0; i < 12; ++i )
+        {
+                push_line( p + sp1[i], p + sp1[( i + 1 ) % 12], vec3( 1.0f, 0.0f, 0.0f ) );
+                push_line( p + sp2[i], p + sp2[( i + 1 ) % 12], vec3( 0.0f, 1.0f, 0.0f ) );
+                push_line( p + sp1[i], p + sp2[i], vec3( 0.0f, 0.0f, 1.0f ) );
+
+                push_line( p + hsp1[i], p + sp1[i], vec3( 0.0f, 0.0f, 1.0f ) );
+                push_line( p + hsp1[i], p + hsp1[( i + 1 ) % 12], vec3( 1.0f, 0.0f, 0.0f ) );
+                push_line( p + hsp2[i], p + sp2[i], vec3( 0.0f, 0.0f, 1.0f ) );
+                push_line( p + hsp2[i], p + hsp2[( i + 1 ) % 12], vec3( 0.0f, 1.0f, 0.0f ) );
+
+                push_line( p + hsp1[i], p - radius * dir, vec3( 0.0f, 0.0f, 1.0f ) );
+                push_line( p + hsp2[i], p + ( height + radius ) * dir, vec3( 0.0f, 0.0f, 1.0f ) );
+
+        }
+
+                
+}
+
+
 nv::debug_data::~debug_data()
 {

trunk/src/gfx/gfx_terminal.cc

@@ -84 +84 @@
                 fgcolor = fg.get_argb32();
                 bgcolor = bg.get_argb32();
-                gylph   = uint32( ch );
-                NV_LOG_INFO( uint32( 
-                        ( fgcolor & uint32( 0x00FF0000 ) ) >> 16 ), "-", uint32( ( fgcolor & uint32( 0x0000FF00 ) ) >> 8 ),"-" , uint32( fgcolor & uint32( 0x000000FF ) ) );
+                gylph   = uint32( uint8(ch) );
         }
 };
@@ -139 +137 @@
         m_dc.p = m_context->create_program( nv_gfx_terminal_vs, nv_gfx_terminal_fs );
 
-        m_data->buffer = m_context->create_buffer( nv::UNIFORM_BUFFER, nv::DYNAMIC_DRAW, tsize.x * tsize.y * sizeof( gfx_terminal_uniform_block ), m_data->data );
+        m_data->buffer = m_context->create_buffer( nv::UNIFORM_BUFFER, nv::STREAM_DRAW, tsize.x * tsize.y * sizeof( gfx_terminal_uniform_block ), m_data->data );
         m_context->bind( m_data->buffer, 7 );
         m_context->get_device()->set_opt_uniform( m_dc.p, "term_size", vec2( tsize ) );
@@ -151 +149 @@
 void gfx_terminal::update()
 {
-        m_context->bind( m_data->buffer, 7 );
-        m_context->update( m_data->buffer, m_data->data, 0, m_data->size.x * m_data->size.y * sizeof( gfx_terminal_uniform_block ) );
-        m_update_needed = false;
+        if ( m_update_needed )
+        {
+                m_context->bind( m_data->buffer, 7 );
+                m_context->update( m_data->buffer, m_data->data, 0, m_data->size.x * m_data->size.y * sizeof( gfx_terminal_uniform_block ) );
+                m_update_needed = false;
+        }
 }
 

trunk/src/gfx/mesh_creator.cc

@@ -87 +87 @@
 }
 
+
+nv::aabb nv::mesh_data_creator::calculate_aabb()
+{
+        NV_ASSERT_ALWAYS( m_pos_channel, "No position channel found!" );
+        vec3 minv;
+        vec3 maxv;
+
+        if ( m_pos_channel->size() > 0 )
+        {
+                minv = *reinterpret_cast<const vec3*>( m_pos_channel->raw_data() + m_pos_offset );
+                maxv = minv;
+        }
+
+        for ( uint32 c = 0; c < m_pos_channel->size(); ++c )
+        {
+                vec3 v = *reinterpret_cast<const vec3*>( m_pos_channel->raw_data() + c*m_pos_channel->element_size() + m_pos_offset );
+                minv = nv::math::min( minv, v );
+                maxv = nv::math::max( maxv, v );
+        }
+        vec3 extents  = maxv - minv;
+        vec3 hextents = extents * 0.5f;
+        vec3 halfv    = minv + hextents;
+        return aabb( nv::transform( halfv ), hextents );
+}
 
 void nv::mesh_data_creator::transform( const vec3& pos, const mat3& r33, float scale /*= 1.0f */ )

trunk/src/gfx/skeleton_instance.cc

@@ -182 +182 @@
 }
 
+void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent, const array_view< bool >& mask )
+{
+        transform global_mat = parent;
+        bool b = mask[id];
+        if ( !b )
+                global_mat = m_transforms[id];
+        else
+        {
+                global_mat *= m_transforms[id];
+                m_transforms[id] = global_mat;
+        }
+        for ( auto child : node_data.children( id ) )
+        {
+                delocalize_rec( node_data, child, global_mat, mask );
+        }
+}
+

trunk/src/gl/gl_context.cc

@@ -125 +125 @@
         }
 }
+
+nv::image_data* nv::gl_context::dump_image( image_format f, image_data* reuse )
+{
+        NV_ASSERT_ALWAYS( f.type   == nv::UBYTE, "Bad format passed to dump" );
+        NV_ASSERT_ALWAYS( f.format == nv::RGB || f.format == nv::RGBA, "Bad format passed to dump" );
+        glPixelStorei( GL_PACK_ALIGNMENT, 1 );
+        image_data* result = reuse;
+        if ( !result ) result = new image_data( f, ivec2( m_viewport.z, m_viewport.w ) );
+        glReadPixels( 0, 0, m_viewport.z, m_viewport.w, f.format == nv::RGB ? GL_RGB : GL_RGBA, datatype_to_gl_enum( f.type ), const_cast< uint8* >( result->get_data() ) );
+        return result;
+}
+
 
 const framebuffer_info* nv::gl_context::get_framebuffer_info( framebuffer f ) const

trunk/src/gui/gui_ascii_renderer.cc

@@ -98 +98 @@
                 m_terminal->print( abs.ll(), er->border_color, term_color(), er->border_chars[6] );
                 m_terminal->print( abs.lr,   er->border_color, term_color(), er->border_chars[7] );
-                m_terminal->update();
+                //m_terminal->update();
         }
         if ( !e->m_text.empty() )

trunk/src/gui/gui_environment.cc

@@ -183 +183 @@
                         handle h = get_element( position( ev.mbutton.x, ev.mbutton.y ) );
                         element* e = m_elements.get( h );
+                        if (e)
                         if ( e->m_on_click ) e->m_on_click();
 

trunk/src/image/miniz.cc

@@ -2668 +2668 @@
         return tinfl_decompress_mem_to_heap( source_buf, source_buf_len, out_len, parse_header ? TINFL_FLAG_PARSE_ZLIB_HEADER : 0 );
 }
+
+int nv::miniz_compress( unsigned char *pDest, unsigned long *pDest_len, const unsigned char *pSource, unsigned long source_len, int level )
+{
+        NV_PROFILE( "compress" );
+        return mz_compress2( pDest, pDest_len, pSource, source_len, level );
+}
+
+unsigned long nv::miniz_bound( unsigned long source_len )
+{
+        return mz_compressBound( source_len );
+}

trunk/src/lib/gl.cc

@@ -189 +189 @@
 
 
-        HWND hWndFake = CreateWindow(TEXT("Dummy67789"), "FAKE", WS_OVERLAPPEDWINDOW | WS_MAXIMIZE | WS_CLIPCHILDREN, 
+        HWND hWndFake = CreateWindowA("Dummy67789", "FAKE", WS_OVERLAPPEDWINDOW | WS_MAXIMIZE | WS_CLIPCHILDREN,
                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, NULL, 
                 NULL, GetModuleHandle(nullptr), NULL); 
@@ -213 +213 @@
         wgl_makecurrent(hDC, hRCFake); 
 
-        LoadLibrary( "gdi32.dll" );
+        LoadLibraryA( "gdi32.dll" );
         bool gl_loaded = nv::load_gl_library( path );
         bool wgl_loaded = nv::load_wgl_library( path );

trunk/src/lua/lua_area.cc

@@ -8 +8 @@
 
 #include "nv/lua/lua_raw.hh"
-#include "nv/core/random.hh"
+#include "nv/lua/lua_aux.hh"
 
 using nv::lua::detail::is_coord;
@@ -333 +333 @@
         nv::sint32 xs = ( b.x - a.x ) + 1;
         nv::sint32 ys = ( b.y - a.y ) - 1;
-        nv::sint32 roll = nv::random::get().srand( 2 * xs + 2 * ys );
+        nv::sint32 roll = nv::lua::rng().srand( 2 * xs + 2 * ys );
         nv::ivec2 result;
 
@@ -356 +356 @@
         nv::sint32 xs = ( b.x - a.x ) - 1;
         nv::sint32 ys = ( b.y - a.y ) - 1;
-        nv::sint32 roll = nv::random::get().srand( 2 * xs + 2 * ys );
+        nv::sint32 roll = nv::lua::rng().srand( 2 * xs + 2 * ys );
         nv::ivec2 result;
 
@@ -375 +375 @@
 {
         nv::rectangle area = to_area( L, 1 );
-        push_coord( L, nv::random::get().range( area.ul, area.lr ) );
+        push_coord( L, nv::lua::rng().range( area.ul, area.lr ) );
         return 1;
 }
@@ -383 +383 @@
         nv::rectangle area  = to_area( L, 1 );
         nv::ivec2     dim   = to_coord( L, 2 );
-        nv::ivec2     start = nv::random::get().range( area.ul, area.lr - dim );
+        nv::ivec2     start = nv::lua::rng().range( area.ul, area.lr - dim );
         push_area( L, nv::rectangle( start, start + dim ) );
         return 1;

trunk/src/lua/lua_aux.cc

@@ -9 +9 @@
 #include "nv/lua/lua_raw.hh"
 #include "nv/core/random.hh"
+
+static nv::random lua_rng;
 
 static int nluaaux_table_copy( lua_State* L )
@@ -94 +96 @@
         if ( dice < 1 )  luaL_argerror( L, 1, "die count lower than 1!" );
         if ( sides < 1 ) luaL_argerror( L, 2, "side count lower than 1!" );
-        lua_pushnumber( L, nv::random::get().dice( static_cast< nv::uint32 >( dice ), static_cast< nv::uint32 >( sides ) ) );
+        lua_pushnumber( L, lua_rng.dice( static_cast< nv::uint32 >( dice ), static_cast< nv::uint32 >( sides ) ) );
         return 1;
 }
@@ -102 +104 @@
         if ( lua_gettop( L ) == 0 )
         {
-                lua_pushnumber( L, nv::random::get().frand(1.0f) );
+                lua_pushnumber( L, lua_rng.frand(1.0f) );
         }
         else
@@ -110 +112 @@
                         lua_Integer arg1 = luaL_checkinteger( L, 1 );
                         if ( arg1 < 1 ) arg1 = 1;
-                        nlua_pushunsigned( L, nv::random::get().urange( 1, static_cast<nv::uint32>( arg1 ) ) );
+                        nlua_pushunsigned( L, lua_rng.urange( 1, static_cast<nv::uint32>( arg1 ) ) );
                 }
                 else
@@ -116 +118 @@
                         int arg1 = static_cast< int >( luaL_checkinteger( L, 1 ) );
                         int arg2 = static_cast< int >( luaL_checkinteger( L, 2 ) );
-                        int result = ( arg2 >= arg1 ? nv::random::get().srange( arg1, arg2 ) : nv::random::get().srange( arg2, arg1 ) );
+                        int result = ( arg2 >= arg1 ? lua_rng.srange( arg1, arg2 ) : lua_rng.srange( arg2, arg1 ) );
                         lua_pushinteger( L, result );
                 }
@@ -125 +127 @@
 static int nluaaux_math_randomseed( lua_State* L )
 {
-        nv::random::get().set_seed( nlua_tounsigned( L, 1 ) );
+        lua_rng.set_seed( nlua_tounsigned( L, 1 ) );
         return 0;
 }
@@ -137 +139 @@
 };
 
+nv::random & nv::lua::rng()
+{
+        return lua_rng;
+}
+
 void nv::lua::register_aux( lua::state* state )
 {

trunk/src/lua/lua_map_tile.cc

@@ -11 +11 @@
 #include "nv/stl/numeric.hh"
 #include "nv/stl/algorithm.hh"
-#include "nv/core/random.hh"
+#include "nv/lua/lua_aux.hh"
 #include "nv/lua/lua_area.hh"
 #include "nv/lua/lua_math.hh"
@@ -207 +207 @@
 static int nlua_map_tile_flip_random( lua_State* L )
 {
-        switch ( nv::random::get().urand( 4 ) )
+        switch ( nv::lua::rng().urand( 4 ) )
         {
         case 1 : nlua_map_tile_flip_x( L ); break;

trunk/src/lua/lua_math.cc

@@ -8 +8 @@
 
 #include "nv/lua/lua_raw.hh"
-#include "nv/core/random.hh"
+#include "nv/lua/lua_aux.hh"
 #include "nv/stl/type_traits/common.hh"
 
@@ -126 +126 @@
 int nlua_vec_random( lua_State* L )
 {
-        push_vec<T>( L, nv::random::get().range( to_vec<T>( L, 1 ), to_vec<T>( L, 2 ) ) );
+        push_vec<T>( L, nv::lua::rng().range( to_vec<T>( L, 1 ), to_vec<T>( L, 2 ) ) );
         return 1;
 }