diff options
Diffstat (limited to 'core')
64 files changed, 1302 insertions, 1744 deletions
diff --git a/core/bind/core_bind.cpp b/core/bind/core_bind.cpp index 0d89659cef..384813ecdf 100644 --- a/core/bind/core_bind.cpp +++ b/core/bind/core_bind.cpp @@ -69,11 +69,11 @@ RES _ResourceLoader::load(const String &p_path,const String& p_type_hint, bool p return ret; } -DVector<String> _ResourceLoader::get_recognized_extensions_for_type(const String& p_type) { +PoolVector<String> _ResourceLoader::get_recognized_extensions_for_type(const String& p_type) { List<String> exts; ResourceLoader::get_recognized_extensions_for_type(p_type,&exts); - DVector<String> ret; + PoolVector<String> ret; for(List<String>::Element *E=exts.front();E;E=E->next()) { ret.push_back(E->get()); @@ -135,12 +135,12 @@ Error _ResourceSaver::save(const String &p_path,const RES& p_resource, uint32_t return ResourceSaver::save(p_path,p_resource, p_flags); } -DVector<String> _ResourceSaver::get_recognized_extensions(const RES& p_resource) { +PoolVector<String> _ResourceSaver::get_recognized_extensions(const RES& p_resource) { - ERR_FAIL_COND_V(p_resource.is_null(),DVector<String>()); + ERR_FAIL_COND_V(p_resource.is_null(),PoolVector<String>()); List<String> exts; ResourceSaver::get_recognized_extensions(p_resource,&exts); - DVector<String> ret; + PoolVector<String> ret; for(List<String>::Element *E=exts.front();E;E=E->next()) { ret.push_back(E->get()); @@ -1232,16 +1232,16 @@ _Geometry *_Geometry::get_singleton() { return singleton; } -DVector<Plane> _Geometry::build_box_planes(const Vector3& p_extents) { +PoolVector<Plane> _Geometry::build_box_planes(const Vector3& p_extents) { return Geometry::build_box_planes(p_extents); } -DVector<Plane> _Geometry::build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis) { +PoolVector<Plane> _Geometry::build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis) { return Geometry::build_cylinder_planes(p_radius,p_height,p_sides,p_axis); } -DVector<Plane> _Geometry::build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis) { +PoolVector<Plane> _Geometry::build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis) { return Geometry::build_capsule_planes(p_radius,p_height,p_sides,p_lats,p_axis); } @@ -1262,22 +1262,22 @@ Variant _Geometry::segment_intersects_segment_2d(const Vector2& p_from_a,const V }; }; -DVector<Vector2> _Geometry::get_closest_points_between_segments_2d( const Vector2& p1,const Vector2& q1, const Vector2& p2,const Vector2& q2) { +PoolVector<Vector2> _Geometry::get_closest_points_between_segments_2d( const Vector2& p1,const Vector2& q1, const Vector2& p2,const Vector2& q2) { Vector2 r1, r2; Geometry::get_closest_points_between_segments(p1,q1,p2,q2,r1,r2); - DVector<Vector2> r; + PoolVector<Vector2> r; r.resize(2); r.set(0,r1); r.set(1,r2); return r; } -DVector<Vector3> _Geometry::get_closest_points_between_segments(const Vector3& p1,const Vector3& p2,const Vector3& q1,const Vector3& q2) { +PoolVector<Vector3> _Geometry::get_closest_points_between_segments(const Vector3& p1,const Vector3& p2,const Vector3& q1,const Vector3& q2) { Vector3 r1, r2; Geometry::get_closest_points_between_segments(p1,p2,q1,q2,r1,r2); - DVector<Vector3> r; + PoolVector<Vector3> r; r.resize(2); r.set(0,r1); r.set(1,r2); @@ -1314,9 +1314,9 @@ bool _Geometry::point_is_inside_triangle(const Vector2& s, const Vector2& a, con return Geometry::is_point_in_triangle(s,a,b,c); } -DVector<Vector3> _Geometry::segment_intersects_sphere( const Vector3& p_from, const Vector3& p_to, const Vector3& p_sphere_pos,real_t p_sphere_radius) { +PoolVector<Vector3> _Geometry::segment_intersects_sphere( const Vector3& p_from, const Vector3& p_to, const Vector3& p_sphere_pos,real_t p_sphere_radius) { - DVector<Vector3> r; + PoolVector<Vector3> r; Vector3 res,norm; if (!Geometry::segment_intersects_sphere(p_from,p_to,p_sphere_pos,p_sphere_radius,&res,&norm)) return r; @@ -1326,9 +1326,9 @@ DVector<Vector3> _Geometry::segment_intersects_sphere( const Vector3& p_from, co r.set(1,norm); return r; } -DVector<Vector3> _Geometry::segment_intersects_cylinder( const Vector3& p_from, const Vector3& p_to, float p_height,float p_radius) { +PoolVector<Vector3> _Geometry::segment_intersects_cylinder( const Vector3& p_from, const Vector3& p_to, float p_height,float p_radius) { - DVector<Vector3> r; + PoolVector<Vector3> r; Vector3 res,norm; if (!Geometry::segment_intersects_cylinder(p_from,p_to,p_height,p_radius,&res,&norm)) return r; @@ -1339,9 +1339,9 @@ DVector<Vector3> _Geometry::segment_intersects_cylinder( const Vector3& p_from, return r; } -DVector<Vector3> _Geometry::segment_intersects_convex(const Vector3& p_from, const Vector3& p_to,const Vector<Plane>& p_planes) { +PoolVector<Vector3> _Geometry::segment_intersects_convex(const Vector3& p_from, const Vector3& p_to,const Vector<Plane>& p_planes) { - DVector<Vector3> r; + PoolVector<Vector3> r; Vector3 res,norm; if (!Geometry::segment_intersects_convex(p_from,p_to,p_planes.ptr(),p_planes.size(),&res,&norm)) return r; @@ -1566,9 +1566,9 @@ real_t _File::get_real() const{ return f->get_real(); } -DVector<uint8_t> _File::get_buffer(int p_length) const{ +PoolVector<uint8_t> _File::get_buffer(int p_length) const{ - DVector<uint8_t> data; + PoolVector<uint8_t> data; ERR_FAIL_COND_V(!f,data); ERR_FAIL_COND_V(p_length<0,data); @@ -1576,11 +1576,11 @@ DVector<uint8_t> _File::get_buffer(int p_length) const{ return data; Error err = data.resize(p_length); ERR_FAIL_COND_V(err!=OK,data); - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); int len = f->get_buffer(&w[0],p_length); - ERR_FAIL_COND_V( len < 0 , DVector<uint8_t>()); + ERR_FAIL_COND_V( len < 0 , PoolVector<uint8_t>()); - w = DVector<uint8_t>::Write(); + w = PoolVector<uint8_t>::Write(); if (len < p_length) data.resize(p_length); @@ -1735,7 +1735,7 @@ void _File::store_line(const String& p_string){ f->store_line(p_string); } -void _File::store_buffer(const DVector<uint8_t>& p_buffer){ +void _File::store_buffer(const PoolVector<uint8_t>& p_buffer){ ERR_FAIL_COND(!f); @@ -1743,7 +1743,7 @@ void _File::store_buffer(const DVector<uint8_t>& p_buffer){ if (len==0) return; - DVector<uint8_t>::Read r = p_buffer.read(); + PoolVector<uint8_t>::Read r = p_buffer.read(); f->store_buffer(&r[0],len); } @@ -1762,13 +1762,13 @@ void _File::store_var(const Variant& p_var) { Error err = encode_variant(p_var,NULL,len); ERR_FAIL_COND( err != OK ); - DVector<uint8_t> buff; + PoolVector<uint8_t> buff; buff.resize(len); - DVector<uint8_t>::Write w = buff.write(); + PoolVector<uint8_t>::Write w = buff.write(); err = encode_variant(p_var,&w[0],len); ERR_FAIL_COND( err != OK ); - w=DVector<uint8_t>::Write(); + w=PoolVector<uint8_t>::Write(); store_32(len); store_buffer(buff); @@ -1778,10 +1778,10 @@ Variant _File::get_var() const { ERR_FAIL_COND_V(!f,Variant()); uint32_t len = get_32(); - DVector<uint8_t> buff = get_buffer(len); + PoolVector<uint8_t> buff = get_buffer(len); ERR_FAIL_COND_V(buff.size() != len, Variant()); - DVector<uint8_t>::Read r = buff.read(); + PoolVector<uint8_t>::Read r = buff.read(); Variant v; Error err = decode_variant(v,&r[0],len); @@ -2056,17 +2056,17 @@ String _Marshalls::variant_to_base64(const Variant& p_var) { Error err = encode_variant(p_var,NULL,len); ERR_FAIL_COND_V( err != OK, "" ); - DVector<uint8_t> buff; + PoolVector<uint8_t> buff; buff.resize(len); - DVector<uint8_t>::Write w = buff.write(); + PoolVector<uint8_t>::Write w = buff.write(); err = encode_variant(p_var,&w[0],len); ERR_FAIL_COND_V( err != OK, "" ); int b64len = len / 3 * 4 + 4 + 1; - DVector<uint8_t> b64buff; + PoolVector<uint8_t> b64buff; b64buff.resize(b64len); - DVector<uint8_t>::Write w64 = b64buff.write(); + PoolVector<uint8_t>::Write w64 = b64buff.write(); int strlen = base64_encode((char*)(&w64[0]), (char*)(&w[0]), len); //OS::get_singleton()->print("len is %i, vector size is %i\n", b64len, strlen); @@ -2081,9 +2081,9 @@ Variant _Marshalls::base64_to_variant(const String& p_str) { int strlen = p_str.length(); CharString cstr = p_str.ascii(); - DVector<uint8_t> buf; + PoolVector<uint8_t> buf; buf.resize(strlen / 4 * 3 + 1); - DVector<uint8_t>::Write w = buf.write(); + PoolVector<uint8_t>::Write w = buf.write(); int len = base64_decode((char*)(&w[0]), (char*)cstr.get_data(), strlen); @@ -2094,15 +2094,15 @@ Variant _Marshalls::base64_to_variant(const String& p_str) { return v; }; -String _Marshalls::raw_to_base64(const DVector<uint8_t> &p_arr) { +String _Marshalls::raw_to_base64(const PoolVector<uint8_t> &p_arr) { int len = p_arr.size(); - DVector<uint8_t>::Read r = p_arr.read(); + PoolVector<uint8_t>::Read r = p_arr.read(); int b64len = len / 3 * 4 + 4 + 1; - DVector<uint8_t> b64buff; + PoolVector<uint8_t> b64buff; b64buff.resize(b64len); - DVector<uint8_t>::Write w64 = b64buff.write(); + PoolVector<uint8_t>::Write w64 = b64buff.write(); int strlen = base64_encode((char*)(&w64[0]), (char*)(&r[0]), len); w64[strlen] = 0; @@ -2111,22 +2111,22 @@ String _Marshalls::raw_to_base64(const DVector<uint8_t> &p_arr) { return ret; }; -DVector<uint8_t> _Marshalls::base64_to_raw(const String &p_str) { +PoolVector<uint8_t> _Marshalls::base64_to_raw(const String &p_str) { int strlen = p_str.length(); CharString cstr = p_str.ascii(); int arr_len; - DVector<uint8_t> buf; + PoolVector<uint8_t> buf; { buf.resize(strlen / 4 * 3 + 1); - DVector<uint8_t>::Write w = buf.write(); + PoolVector<uint8_t>::Write w = buf.write(); arr_len = base64_decode((char*)(&w[0]), (char*)cstr.get_data(), strlen); }; buf.resize(arr_len); - // conversion from DVector<uint8_t> to raw array? + // conversion from PoolVector<uint8_t> to raw array? return buf; }; @@ -2136,9 +2136,9 @@ String _Marshalls::utf8_to_base64(const String& p_str) { int len = cstr.length(); int b64len = len / 3 * 4 + 4 + 1; - DVector<uint8_t> b64buff; + PoolVector<uint8_t> b64buff; b64buff.resize(b64len); - DVector<uint8_t>::Write w64 = b64buff.write(); + PoolVector<uint8_t>::Write w64 = b64buff.write(); int strlen = base64_encode((char*)(&w64[0]), (char*)cstr.get_data(), len); @@ -2153,9 +2153,9 @@ String _Marshalls::base64_to_utf8(const String& p_str) { int strlen = p_str.length(); CharString cstr = p_str.ascii(); - DVector<uint8_t> buf; + PoolVector<uint8_t> buf; buf.resize(strlen / 4 * 3 + 1 + 1); - DVector<uint8_t>::Write w = buf.write(); + PoolVector<uint8_t>::Write w = buf.write(); int len = base64_decode((char*)(&w[0]), (char*)cstr.get_data(), strlen); diff --git a/core/bind/core_bind.h b/core/bind/core_bind.h index 9a4f26a12d..f1c98a58dc 100644 --- a/core/bind/core_bind.h +++ b/core/bind/core_bind.h @@ -50,7 +50,7 @@ public: static _ResourceLoader *get_singleton() { return singleton; } Ref<ResourceInteractiveLoader> load_interactive(const String& p_path,const String& p_type_hint=""); RES load(const String &p_path,const String& p_type_hint="", bool p_no_cache = false); - DVector<String> get_recognized_extensions_for_type(const String& p_type); + PoolVector<String> get_recognized_extensions_for_type(const String& p_type); void set_abort_on_missing_resources(bool p_abort); StringArray get_dependencies(const String& p_path); bool has(const String& p_path); @@ -81,7 +81,7 @@ public: static _ResourceSaver *get_singleton() { return singleton; } Error save(const String &p_path,const RES& p_resource, uint32_t p_flags); - DVector<String> get_recognized_extensions(const RES& p_resource); + PoolVector<String> get_recognized_extensions(const RES& p_resource); _ResourceSaver(); @@ -342,20 +342,20 @@ protected: public: static _Geometry *get_singleton(); - DVector<Plane> build_box_planes(const Vector3& p_extents); - DVector<Plane> build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis=Vector3::AXIS_Z); - DVector<Plane> build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis=Vector3::AXIS_Z); + PoolVector<Plane> build_box_planes(const Vector3& p_extents); + PoolVector<Plane> build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis=Vector3::AXIS_Z); + PoolVector<Plane> build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis=Vector3::AXIS_Z); Variant segment_intersects_segment_2d(const Vector2& p_from_a,const Vector2& p_to_a,const Vector2& p_from_b,const Vector2& p_to_b); - DVector<Vector2> get_closest_points_between_segments_2d( const Vector2& p1,const Vector2& q1, const Vector2& p2,const Vector2& q2); - DVector<Vector3> get_closest_points_between_segments(const Vector3& p1,const Vector3& p2,const Vector3& q1,const Vector3& q2); + PoolVector<Vector2> get_closest_points_between_segments_2d( const Vector2& p1,const Vector2& q1, const Vector2& p2,const Vector2& q2); + PoolVector<Vector3> get_closest_points_between_segments(const Vector3& p1,const Vector3& p2,const Vector3& q1,const Vector3& q2); Vector3 get_closest_point_to_segment(const Vector3& p_point, const Vector3& p_a,const Vector3& p_b); Variant ray_intersects_triangle( const Vector3& p_from, const Vector3& p_dir, const Vector3& p_v0,const Vector3& p_v1,const Vector3& p_v2); Variant segment_intersects_triangle( const Vector3& p_from, const Vector3& p_to, const Vector3& p_v0,const Vector3& p_v1,const Vector3& p_v2); bool point_is_inside_triangle(const Vector2& s, const Vector2& a, const Vector2& b, const Vector2& c) const; - DVector<Vector3> segment_intersects_sphere( const Vector3& p_from, const Vector3& p_to, const Vector3& p_sphere_pos,real_t p_sphere_radius); - DVector<Vector3> segment_intersects_cylinder( const Vector3& p_from, const Vector3& p_to, float p_height,float p_radius); - DVector<Vector3> segment_intersects_convex(const Vector3& p_from, const Vector3& p_to,const Vector<Plane>& p_planes); + PoolVector<Vector3> segment_intersects_sphere( const Vector3& p_from, const Vector3& p_to, const Vector3& p_sphere_pos,real_t p_sphere_radius); + PoolVector<Vector3> segment_intersects_cylinder( const Vector3& p_from, const Vector3& p_to, float p_height,float p_radius); + PoolVector<Vector3> segment_intersects_convex(const Vector3& p_from, const Vector3& p_to,const Vector<Plane>& p_planes); real_t segment_intersects_circle(const Vector2& p_from, const Vector2& p_to, const Vector2& p_circle_pos, real_t p_circle_radius); int get_uv84_normal_bit(const Vector3& p_vector); @@ -413,7 +413,7 @@ public: Variant get_var() const; - DVector<uint8_t> get_buffer(int p_length) const; ///< get an array of bytes + PoolVector<uint8_t> get_buffer(int p_length) const; ///< get an array of bytes String get_line() const; String get_as_text() const; String get_md5(const String& p_path) const; @@ -447,7 +447,7 @@ public: Vector<String> get_csv_line(String delim=",") const; - void store_buffer(const DVector<uint8_t>& p_buffer); ///< store an array of bytes + void store_buffer(const PoolVector<uint8_t>& p_buffer); ///< store an array of bytes void store_var(const Variant& p_var); @@ -517,8 +517,8 @@ public: String variant_to_base64(const Variant& p_var); Variant base64_to_variant(const String& p_str); - String raw_to_base64(const DVector<uint8_t>& p_arr); - DVector<uint8_t> base64_to_raw(const String& p_str); + String raw_to_base64(const PoolVector<uint8_t>& p_arr); + PoolVector<uint8_t> base64_to_raw(const String& p_str); String utf8_to_base64(const String& p_str); String base64_to_utf8(const String& p_str); diff --git a/core/compressed_translation.cpp b/core/compressed_translation.cpp index 9b39eeb2c1..f8aa3915d4 100644 --- a/core/compressed_translation.cpp +++ b/core/compressed_translation.cpp @@ -356,8 +356,8 @@ void PHashTranslation::generate(const Ref<Translation> &p_from) { hash_table.resize(size); bucket_table.resize(bucket_table_size); - DVector<int>::Write htwb = hash_table.write(); - DVector<int>::Write btwb = bucket_table.write(); + PoolVector<int>::Write htwb = hash_table.write(); + PoolVector<int>::Write btwb = bucket_table.write(); uint32_t *htw = (uint32_t*)&htwb[0]; uint32_t *btw = (uint32_t*)&btwb[0]; @@ -392,7 +392,7 @@ void PHashTranslation::generate(const Ref<Translation> &p_from) { print_line("total collisions: "+itos(collisions)); strings.resize(total_compression_size); - DVector<uint8_t>::Write cw = strings.write(); + PoolVector<uint8_t>::Write cw = strings.write(); for(int i=0;i<compressed.size();i++) { memcpy(&cw[compressed[i].offset],compressed[i].compressed.get_data(),compressed[i].compressed.size()); @@ -454,11 +454,11 @@ StringName PHashTranslation::get_message(const StringName& p_src_text) const { uint32_t h = hash(0,str.get_data()); - DVector<int>::Read htr = hash_table.read(); + PoolVector<int>::Read htr = hash_table.read(); const uint32_t *htptr = (const uint32_t*)&htr[0]; - DVector<int>::Read btr = bucket_table.read(); + PoolVector<int>::Read btr = bucket_table.read(); const uint32_t *btptr = (const uint32_t*)&btr[0]; - DVector<uint8_t>::Read sr = strings.read(); + PoolVector<uint8_t>::Read sr = strings.read(); const char *sptr= (const char*)&sr[0]; uint32_t p = htptr[ h % htsize]; diff --git a/core/compressed_translation.h b/core/compressed_translation.h index 218a59c05d..cb1e084051 100644 --- a/core/compressed_translation.h +++ b/core/compressed_translation.h @@ -42,9 +42,9 @@ class PHashTranslation : public Translation { //of catching untranslated strings //load/store friendly types - DVector<int> hash_table; - DVector<int> bucket_table; - DVector<uint8_t> strings; + PoolVector<int> hash_table; + PoolVector<int> bucket_table; + PoolVector<uint8_t> strings; struct Bucket { diff --git a/core/dvector.cpp b/core/dvector.cpp index 7caa198c4c..f6b5a5fcbf 100644 --- a/core/dvector.cpp +++ b/core/dvector.cpp @@ -30,3 +30,44 @@ Mutex* dvector_lock=NULL; +PoolAllocator *MemoryPool::memory_pool=NULL; +uint8_t *MemoryPool::pool_memory=NULL; +size_t *MemoryPool::pool_size=NULL; + + +MemoryPool::Alloc *MemoryPool::allocs=NULL; +MemoryPool::Alloc *MemoryPool::free_list=NULL; +uint32_t MemoryPool::alloc_count=0; +uint32_t MemoryPool::allocs_used=0; +Mutex *MemoryPool::alloc_mutex=NULL; + +size_t MemoryPool::total_memory=0; +size_t MemoryPool::max_memory=0; + + +void MemoryPool::setup(uint32_t p_max_allocs) { + + allocs = memnew_arr( Alloc, p_max_allocs); + alloc_count = p_max_allocs; + allocs_used=0; + + for(uint32_t i=0;i<alloc_count-1;i++) { + + allocs[i].free_list=&allocs[i+1]; + } + + free_list=&allocs[0]; + + alloc_mutex = Mutex::create(); + +} + +void MemoryPool::cleanup() { + + memdelete_arr(allocs); + memdelete(alloc_mutex); + + ERR_EXPLAINC("There are still MemoryPool allocs in use at exit!"); + ERR_FAIL_COND(allocs_used>0); + +} diff --git a/core/dvector.h b/core/dvector.h index 9e0090fb7c..f109f842a2 100644 --- a/core/dvector.h +++ b/core/dvector.h @@ -30,6 +30,46 @@ #define DVECTOR_H #include "os/memory.h" +#include "os/copymem.h" +#include "pool_allocator.h" +#include "safe_refcount.h" +#include "os/rw_lock.h" + +struct MemoryPool { + + //avoid accessing these directly, must be public for template access + + static PoolAllocator *memory_pool; + static uint8_t *pool_memory; + static size_t *pool_size; + + + struct Alloc { + + SafeRefCount refcount; + uint32_t lock; + void *mem; + PoolAllocator::ID pool_id; + size_t size; + + Alloc *free_list; + + Alloc() { mem=NULL; lock=0; pool_id=POOL_ALLOCATOR_INVALID_ID; size=0; free_list=NULL; } + }; + + + static Alloc *allocs; + static Alloc *free_list; + static uint32_t alloc_count; + static uint32_t allocs_used; + static Mutex *alloc_mutex; + static size_t total_memory; + static size_t max_memory; + + + static void setup(uint32_t p_max_allocs=(1<<16)); + static void cleanup(); +}; /** @@ -37,182 +77,274 @@ */ -extern Mutex* dvector_lock; - template<class T> -class DVector { +class PoolVector { + + MemoryPool::Alloc *alloc; - mutable MID mem; + void _copy_on_write() { - void copy_on_write() { - if (!mem.is_valid()) + if (!alloc) return; - if (dvector_lock) - dvector_lock->lock(); + ERR_FAIL_COND(alloc->lock>0); - MID_Lock lock( mem ); + if (alloc->refcount.get()==1) + return; //nothing to do - if ( *(int*)lock.data() == 1 ) { - // one reference, means no refcount changes - if (dvector_lock) - dvector_lock->unlock(); - return; + //must allocate something + + MemoryPool::alloc_mutex->lock(); + if (MemoryPool::allocs_used==MemoryPool::alloc_count) { + MemoryPool::alloc_mutex->unlock(); + ERR_EXPLAINC("All memory pool allocations are in use, can't COW."); + ERR_FAIL(); } - MID new_mem= dynalloc( mem.get_size() ); + MemoryPool::Alloc *old_alloc = alloc; + + //take one from the free list + alloc = MemoryPool::free_list; + MemoryPool::free_list = alloc->free_list; + //increment the used counter + MemoryPool::allocs_used++; - if (!new_mem.is_valid()) { + //copy the alloc data + alloc->size=old_alloc->size; + alloc->refcount.init(); + alloc->pool_id=POOL_ALLOCATOR_INVALID_ID; + alloc->lock=0; - if (dvector_lock) - dvector_lock->unlock(); - ERR_FAIL_COND( new_mem.is_valid() ); // out of memory +#ifdef DEBUG_ENABLED + MemoryPool::total_memory+=alloc->size; + if (MemoryPool::total_memory>MemoryPool::max_memory) { + MemoryPool::max_memory=MemoryPool::total_memory; } +#endif - MID_Lock dst_lock( new_mem ); + MemoryPool::alloc_mutex->unlock(); - int *rc = (int*)dst_lock.data(); + if (MemoryPool::memory_pool) { - *rc=1; - T * dst = (T*)(rc + 1 ); + } else { + alloc->mem = memalloc( alloc->size ); + copymem( alloc->mem, old_alloc->mem, alloc->size ); + } - T * src =(T*) ((int*)lock.data() + 1 ); + if (old_alloc->refcount.unref()) { + //this should never happen but.. - int count = (mem.get_size() - sizeof(int)) / sizeof(T); +#ifdef DEBUG_ENABLED + MemoryPool::alloc_mutex->lock(); + MemoryPool::total_memory-=old_alloc->size; + MemoryPool::alloc_mutex->unlock(); +#endif - for (int i=0;i<count;i++) { - memnew_placement( &dst[i], T(src[i]) ); - } + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize + } else { - (*(int*)lock.data())--; + memfree( old_alloc->mem ); + old_alloc->mem=NULL; + old_alloc->size=0; - // unlock all - dst_lock=MID_Lock(); - lock=MID_Lock(); - mem=new_mem; + MemoryPool::alloc_mutex->lock(); + old_alloc->free_list=MemoryPool::free_list; + MemoryPool::free_list=old_alloc; + MemoryPool::allocs_used--; + MemoryPool::alloc_mutex->unlock(); + } - if (dvector_lock) - dvector_lock->unlock(); + } } - void reference( const DVector& p_dvector ) { + void _reference( const PoolVector& p_dvector ) { - unreference(); + if (alloc==p_dvector.alloc) + return; - if (dvector_lock) - dvector_lock->lock(); + _unreference(); - if (!p_dvector.mem.is_valid()) { + if (!p_dvector.alloc) { + return; + } - if (dvector_lock) - dvector_lock->unlock(); + if (p_dvector.alloc->refcount.ref()) { + alloc=p_dvector.alloc; + } + + } + + + void _unreference() { + + if (!alloc) + return; + + if (!alloc->refcount.unref()) { + alloc=NULL; return; } - MID_Lock lock(p_dvector.mem); + //must be disposed! - int * rc = (int*)lock.data(); - (*rc)++; + { + int cur_elements = alloc->size/sizeof(T); + Write w; + for (int i=0;i<cur_elements;i++) { - lock = MID_Lock(); - mem=p_dvector.mem; + w[i].~T(); + } - if (dvector_lock) - dvector_lock->unlock(); + } - } +#ifdef DEBUG_ENABLED + MemoryPool::alloc_mutex->lock(); + MemoryPool::total_memory-=alloc->size; + MemoryPool::alloc_mutex->unlock(); +#endif - void unreference() { + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize + } else { - if (dvector_lock) - dvector_lock->lock(); + memfree( alloc->mem ); + alloc->mem=NULL; + alloc->size=0; - if (!mem.is_valid()) { - if (dvector_lock) - dvector_lock->unlock(); - return; + MemoryPool::alloc_mutex->lock(); + alloc->free_list=MemoryPool::free_list; + MemoryPool::free_list=alloc; + MemoryPool::allocs_used--; + MemoryPool::alloc_mutex->unlock(); + } - MID_Lock lock(mem); + alloc=NULL; + } - int * rc = (int*)lock.data(); - (*rc)--; +public: - if (*rc==0) { - // no one else using it, destruct + class Access { + friend class PoolVector; + protected: + MemoryPool::Alloc *alloc; + T * mem; - T * t= (T*)(rc+1); - int count = (mem.get_size() - sizeof(int)) / sizeof(T); + _FORCE_INLINE_ void _ref(MemoryPool::Alloc *p_alloc) { + alloc=p_alloc; + if (alloc) { + if (atomic_increment(&alloc->lock)==1) { + if (MemoryPool::memory_pool) { + //lock it and get mem + } + } - for (int i=0;i<count;i++) { + mem = (T*)alloc->mem; + } + } - t[i].~T(); + _FORCE_INLINE_ void _unref() { + + + if (alloc) { + if (atomic_decrement(&alloc->lock)==0) { + if (MemoryPool::memory_pool) { + //put mem back + } + } + + mem = NULL; + alloc=NULL; } + } + Access() { + alloc=NULL; + mem=NULL; + } - lock = MID_Lock(); - mem = MID (); + public: + virtual ~Access() { + _unref(); + } + }; - if (dvector_lock) - dvector_lock->unlock(); + class Read : public Access { + public: - } + _FORCE_INLINE_ const T& operator[](int p_index) const { return this->mem[p_index]; } + _FORCE_INLINE_ const T *ptr() const { return this->mem; } -public: + void operator=(const Read& p_read) { + if (this->alloc==p_read.alloc) + return; + this->_unref(); + this->_ref(p_read.alloc); + } - class Read { - friend class DVector; - MID_Lock lock; - const T * mem; - public: + Read(const Read& p_read) { + this->_ref(p_read.alloc); + } + + Read() {} - _FORCE_INLINE_ const T& operator[](int p_index) const { return mem[p_index]; } - _FORCE_INLINE_ const T *ptr() const { return mem; } - Read() { mem=NULL; } }; - class Write { - friend class DVector; - MID_Lock lock; - T * mem; + class Write : public Access { public: - _FORCE_INLINE_ T& operator[](int p_index) { return mem[p_index]; } - _FORCE_INLINE_ T *ptr() { return mem; } + _FORCE_INLINE_ T& operator[](int p_index) const { return this->mem[p_index]; } + _FORCE_INLINE_ T *ptr() const { return this->mem; } + + void operator=(const Write& p_read) { + if (this->alloc==p_read.alloc) + return; + this->_unref(); + this->_ref(p_read.alloc); + } + + Write(const Write& p_read) { + this->_ref(p_read.alloc); + } + + Write() {} - Write() { mem=NULL; } }; Read read() const { Read r; - if (mem.is_valid()) { - r.lock = MID_Lock( mem ); - r.mem = (const T*)((int*)r.lock.data()+1); + if (alloc) { + r._ref(alloc); } return r; + } Write write() { Write w; - if (mem.is_valid()) { - copy_on_write(); - w.lock = MID_Lock( mem ); - w.mem = (T*)((int*)w.lock.data()+1); + if (alloc) { + _copy_on_write(); //make sure there is only one being acessed + w._ref(alloc); } return w; } @@ -250,7 +382,7 @@ public: void set(int p_index, const T& p_val); void push_back(const T& p_val); void append(const T& p_val) { push_back(p_val); } - void append_array(const DVector<T>& p_arr) { + void append_array(const PoolVector<T>& p_arr) { int ds = p_arr.size(); if (ds==0) return; @@ -262,7 +394,7 @@ public: w[bs+i]=r[i]; } - DVector<T> subarray(int p_from, int p_to) { + PoolVector<T> subarray(int p_from, int p_to) { if (p_from<0) { p_from=size()+p_from; @@ -271,15 +403,15 @@ public: p_to=size()+p_to; } if (p_from<0 || p_from>=size()) { - DVector<T>& aux=*((DVector<T>*)0); // nullreturn + PoolVector<T>& aux=*((PoolVector<T>*)0); // nullreturn ERR_FAIL_COND_V(p_from<0 || p_from>=size(),aux) } if (p_to<0 || p_to>=size()) { - DVector<T>& aux=*((DVector<T>*)0); // nullreturn + PoolVector<T>& aux=*((PoolVector<T>*)0); // nullreturn ERR_FAIL_COND_V(p_to<0 || p_to>=size(),aux) } - DVector<T> slice; + PoolVector<T> slice; int span=1 + p_to - p_from; slice.resize(span); Read r = read(); @@ -307,7 +439,7 @@ public: } - bool is_locked() const { return mem.is_locked(); } + bool is_locked() const { return alloc && alloc->lock>0; } inline const T operator[](int p_index) const; @@ -315,27 +447,27 @@ public: void invert(); - void operator=(const DVector& p_dvector) { reference(p_dvector); } - DVector() {} - DVector(const DVector& p_dvector) { reference(p_dvector); } - ~DVector() { unreference(); } + void operator=(const PoolVector& p_dvector) { _reference(p_dvector); } + PoolVector() { alloc=NULL; } + PoolVector(const PoolVector& p_dvector) { alloc=NULL; _reference(p_dvector); } + ~PoolVector() { _unreference(); } }; template<class T> -int DVector<T>::size() const { +int PoolVector<T>::size() const { - return mem.is_valid() ? ((mem.get_size() - sizeof(int)) / sizeof(T) ) : 0; + return alloc ? alloc->size/sizeof(T) : 0; } template<class T> -T DVector<T>::get(int p_index) const { +T PoolVector<T>::get(int p_index) const { return operator[](p_index); } template<class T> -void DVector<T>::set(int p_index, const T& p_val) { +void PoolVector<T>::set(int p_index, const T& p_val) { if (p_index<0 || p_index>=size()) { ERR_FAIL_COND(p_index<0 || p_index>=size()); @@ -346,14 +478,14 @@ void DVector<T>::set(int p_index, const T& p_val) { } template<class T> -void DVector<T>::push_back(const T& p_val) { +void PoolVector<T>::push_back(const T& p_val) { resize( size() + 1 ); set( size() -1, p_val ); } template<class T> -const T DVector<T>::operator[](int p_index) const { +const T PoolVector<T>::operator[](int p_index) const { if (p_index<0 || p_index>=size()) { T& aux=*((T*)0); //nullreturn @@ -367,94 +499,130 @@ const T DVector<T>::operator[](int p_index) const { template<class T> -Error DVector<T>::resize(int p_size) { +Error PoolVector<T>::resize(int p_size) { - if (dvector_lock) - dvector_lock->lock(); - bool same = p_size==size(); + if (alloc==NULL) { - if (dvector_lock) - dvector_lock->unlock(); - // no further locking is necesary because we are supposed to own the only copy of this (using copy on write) + if (p_size==0) + return OK; //nothing to do here - if (same) - return OK; + //must allocate something + MemoryPool::alloc_mutex->lock(); + if (MemoryPool::allocs_used==MemoryPool::alloc_count) { + MemoryPool::alloc_mutex->unlock(); + ERR_EXPLAINC("All memory pool allocations are in use."); + ERR_FAIL_V(ERR_OUT_OF_MEMORY); + } - if (p_size == 0 ) { + //take one from the free list + alloc = MemoryPool::free_list; + MemoryPool::free_list = alloc->free_list; + //increment the used counter + MemoryPool::allocs_used++; - unreference(); - return OK; + //cleanup the alloc + alloc->size=0; + alloc->refcount.init(); + alloc->pool_id=POOL_ALLOCATOR_INVALID_ID; + MemoryPool::alloc_mutex->unlock(); + + } else { + + ERR_FAIL_COND_V( alloc->lock>0, ERR_LOCKED ); //can't resize if locked! } + size_t new_size = sizeof(T)*p_size; - copy_on_write(); // make it unique + if (alloc->size==new_size) + return OK; //nothing to do - ERR_FAIL_COND_V( mem.is_locked(), ERR_LOCKED ); // if after copy on write, memory is locked, fail. + if (p_size == 0 ) { + _unreference(); + return OK; + } - if (p_size > size() ) { + _copy_on_write(); // make it unique - int oldsize=size(); +#ifdef DEBUG_ENABLED + MemoryPool::alloc_mutex->lock(); + MemoryPool::total_memory-=alloc->size; + MemoryPool::total_memory+=new_size; + if (MemoryPool::total_memory>MemoryPool::max_memory) { + MemoryPool::max_memory=MemoryPool::total_memory; + } + MemoryPool::alloc_mutex->unlock(); +#endif - MID_Lock lock; - if (oldsize==0) { + int cur_elements = alloc->size / sizeof(T); - mem = dynalloc( p_size * sizeof(T) + sizeof(int) ); - lock=MID_Lock(mem); - int *rc = ((int*)lock.data()); - *rc=1; + if (p_size > cur_elements ) { + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize } else { - if (dynrealloc( mem, p_size * sizeof(T) + sizeof(int) )!=OK ) { - - ERR_FAIL_V(ERR_OUT_OF_MEMORY); // out of memory + if (alloc->size==0) { + alloc->mem = memalloc( new_size ); + } else { + alloc->mem = memrealloc( alloc->mem, new_size ); } - - lock=MID_Lock(mem); } + alloc->size=new_size; + Write w = write(); + for (int i=cur_elements;i<p_size;i++) { - T *t = (T*)((int*)lock.data() + 1); - - for (int i=oldsize;i<p_size;i++) { - - memnew_placement(&t[i], T ); + memnew_placement(&w[i], T ); } - lock = MID_Lock(); // clear - } else { - - int oldsize=size(); - - MID_Lock lock(mem); + } else { - T *t = (T*)((int*)lock.data() + 1); + { + Write w; + for (int i=p_size;i<cur_elements;i++) { - for (int i=p_size;i<oldsize;i++) { + w[i].~T(); + } - t[i].~T(); } - lock = MID_Lock(); // clear + if (MemoryPool::memory_pool) { + //resize memory pool + //if none, create + //if some resize + } else { + + if (new_size==0) { + memfree( alloc->mem ); + alloc->mem=NULL; + alloc->size=0; - if (dynrealloc( mem, p_size * sizeof(T) + sizeof(int) )!=OK ) { + MemoryPool::alloc_mutex->lock(); + alloc->free_list=MemoryPool::free_list; + MemoryPool::free_list=alloc; + MemoryPool::allocs_used--; + MemoryPool::alloc_mutex->unlock(); - ERR_FAIL_V(ERR_OUT_OF_MEMORY); // wtf error + } else { + alloc->mem = memrealloc( alloc->mem, new_size ); + alloc->size=new_size; + } } - } return OK; } template<class T> -void DVector<T>::invert() { +void PoolVector<T>::invert() { T temp; Write w = write(); int s = size(); diff --git a/core/globals.cpp b/core/globals.cpp index 6609b47147..b6498c62e4 100644 --- a/core/globals.cpp +++ b/core/globals.cpp @@ -691,9 +691,9 @@ static Variant _decode_variant(const String& p_string) { String data=params[4]; int datasize=data.length()/2; - DVector<uint8_t> pixels; + PoolVector<uint8_t> pixels; pixels.resize(datasize); - DVector<uint8_t>::Write wb = pixels.write(); + PoolVector<uint8_t>::Write wb = pixels.write(); const CharType *cptr=data.c_str(); int idx=0; @@ -720,7 +720,7 @@ static Variant _decode_variant(const String& p_string) { } - wb = DVector<uint8_t>::Write(); + wb = PoolVector<uint8_t>::Write(); return Image(w,h,mipmaps,imgformat,pixels); } @@ -992,9 +992,9 @@ static String _encode_variant(const Variant& p_variant) { str+=itos(img.has_mipmaps())+", "; str+=itos(img.get_width())+", "; str+=itos(img.get_height())+", "; - DVector<uint8_t> data = img.get_data(); + PoolVector<uint8_t> data = img.get_data(); int ds=data.size(); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); for(int i=0;i<ds;i++) { uint8_t byte = r[i]; const char hex[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; diff --git a/core/image.cpp b/core/image.cpp index e949cd9b38..174c840c23 100644 --- a/core/image.cpp +++ b/core/image.cpp @@ -365,8 +365,8 @@ void Image::convert( Format p_new_format ){ // int len=data.size(); - DVector<uint8_t>::Read r = data.read(); - DVector<uint8_t>::Write w = new_img.data.write(); + PoolVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Write w = new_img.data.write(); const uint8_t *rptr = r.ptr(); uint8_t *wptr = w.ptr(); @@ -409,8 +409,8 @@ void Image::convert( Format p_new_format ){ } - r = DVector<uint8_t>::Read(); - w = DVector<uint8_t>::Write(); + r = PoolVector<uint8_t>::Read(); + w = PoolVector<uint8_t>::Write(); bool gen_mipmaps=mipmaps; @@ -651,10 +651,10 @@ void Image::resize( int p_width, int p_height, Interpolation p_interpolation ) { Image dst( p_width, p_height, 0, format ); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const unsigned char*r_ptr=r.ptr(); - DVector<uint8_t>::Write w = dst.data.write(); + PoolVector<uint8_t>::Write w = dst.data.write(); unsigned char*w_ptr=w.ptr(); @@ -693,8 +693,8 @@ void Image::resize( int p_width, int p_height, Interpolation p_interpolation ) { } - r = DVector<uint8_t>::Read(); - w = DVector<uint8_t>::Write(); + r = PoolVector<uint8_t>::Read(); + w = PoolVector<uint8_t>::Write(); if (mipmaps>0) dst.generate_mipmaps(); @@ -725,8 +725,8 @@ void Image::crop( int p_width, int p_height ) { Image dst( p_width, p_height,0, format ); { - DVector<uint8_t>::Read r = data.read(); - DVector<uint8_t>::Write w = dst.data.write(); + PoolVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Write w = dst.data.write(); for (int y=0;y<p_height;y++) { @@ -767,7 +767,7 @@ void Image::flip_y() { { - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); uint8_t up[16]; uint8_t down[16]; uint32_t pixel_size = get_format_pixel_size(format); @@ -806,7 +806,7 @@ void Image::flip_x() { { - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); uint8_t up[16]; uint8_t down[16]; uint32_t pixel_size = get_format_pixel_size(format); @@ -925,12 +925,12 @@ void Image::expand_x2_hq2x() { if (current!=FORMAT_RGBA8) convert(FORMAT_RGBA8); - DVector<uint8_t> dest; + PoolVector<uint8_t> dest; dest.resize(width*2*height*2*4); { - DVector<uint8_t>::Read r = data.read(); - DVector<uint8_t>::Write w = dest.write(); + PoolVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Write w = dest.write(); hq2x_resize((const uint32_t*)r.ptr(),width,height,(uint32_t*)w.ptr()); @@ -959,7 +959,7 @@ void Image::shrink_x2() { if (mipmaps) { //just use the lower mipmap as base and copy all - DVector<uint8_t> new_img; + PoolVector<uint8_t> new_img; int ofs = get_mipmap_offset(1); @@ -968,8 +968,8 @@ void Image::shrink_x2() { { - DVector<uint8_t>::Write w=new_img.write(); - DVector<uint8_t>::Read r=data.read(); + PoolVector<uint8_t>::Write w=new_img.write(); + PoolVector<uint8_t>::Read r=data.read(); copymem(w.ptr(),&r[ofs],new_size); } @@ -980,15 +980,15 @@ void Image::shrink_x2() { } else { - DVector<uint8_t> new_img; + PoolVector<uint8_t> new_img; ERR_FAIL_COND( !_can_modify(format) ); int ps = get_format_pixel_size(format); new_img.resize((width/2)*(height/2)*ps); { - DVector<uint8_t>::Write w=new_img.write(); - DVector<uint8_t>::Read r=data.read(); + PoolVector<uint8_t>::Write w=new_img.write(); + PoolVector<uint8_t>::Read r=data.read(); switch(format) { @@ -1027,7 +1027,7 @@ Error Image::generate_mipmaps(bool p_keep_existing) { data.resize(size); - DVector<uint8_t>::Write wp=data.write(); + PoolVector<uint8_t>::Write wp=data.write(); if (nearest_power_of_2(width)==uint32_t(width) && nearest_power_of_2(height)==uint32_t(height)) { //use fast code for powers of 2 @@ -1122,7 +1122,7 @@ bool Image::empty() const { return (data.size()==0); } -DVector<uint8_t> Image::get_data() const { +PoolVector<uint8_t> Image::get_data() const { return data; } @@ -1134,7 +1134,7 @@ void Image::create(int p_width, int p_height, bool p_use_mipmaps,Format p_format int size = _get_dst_image_size(p_width,p_height,p_format,mm,p_use_mipmaps?-1:0); data.resize( size ); { - DVector<uint8_t>::Write w= data.write(); + PoolVector<uint8_t>::Write w= data.write(); zeromem(w.ptr(),size); } @@ -1146,7 +1146,7 @@ void Image::create(int p_width, int p_height, bool p_use_mipmaps,Format p_format } -void Image::create(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const DVector<uint8_t>& p_data) { +void Image::create(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const PoolVector<uint8_t>& p_data) { ERR_FAIL_INDEX(p_width-1,MAX_WIDTH); ERR_FAIL_INDEX(p_height-1,MAX_HEIGHT); @@ -1188,7 +1188,7 @@ void Image::create( const char ** p_xpm ) { HashMap<String,Color> colormap; int colormap_size; uint32_t pixel_size; - DVector<uint8_t>::Write w; + PoolVector<uint8_t>::Write w; while (status!=DONE) { @@ -1355,7 +1355,7 @@ bool Image::is_invisible() const { int w,h; _get_mipmap_offset_and_size(1,len,w,h); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const unsigned char *data_ptr=r.ptr(); bool detected=false; @@ -1401,7 +1401,7 @@ Image::AlphaMode Image::detect_alpha() const { int w,h; _get_mipmap_offset_and_size(1,len,w,h); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const unsigned char *data_ptr=r.ptr(); bool bit=false; @@ -1459,8 +1459,8 @@ bool Image::operator==(const Image& p_image) const { if (data.size() == 0 && p_image.data.size() == 0) return true; - DVector<uint8_t>::Read r = data.read(); - DVector<uint8_t>::Read pr = p_image.data.read(); + PoolVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read pr = p_image.data.read(); return r.ptr() == pr.ptr(); } @@ -1502,11 +1502,11 @@ Error Image::_decompress_bc() { int mm; int size = _get_dst_image_size(wd,ht,FORMAT_RGBA8,mm); - DVector<uint8_t> newdata; + PoolVector<uint8_t> newdata; newdata.resize(size); - DVector<uint8_t>::Write w = newdata.write(); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Write w = newdata.write(); + PoolVector<uint8_t>::Read r = data.read(); int rofs=0; int wofs=0; @@ -1814,8 +1814,8 @@ Error Image::_decompress_bc() { } - w=DVector<uint8_t>::Write(); - r=DVector<uint8_t>::Read(); + w=PoolVector<uint8_t>::Write(); + r=PoolVector<uint8_t>::Read(); data=newdata; format=FORMAT_RGBA8; @@ -1927,7 +1927,7 @@ Image::Image(int p_width, int p_height,bool p_use_mipmaps, Format p_format) { } -Image::Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const DVector<uint8_t>& p_data) { +Image::Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const PoolVector<uint8_t>& p_data) { width=0; height=0; @@ -1950,7 +1950,7 @@ Rect2 Image::get_used_rect() const { return Rect2(); //int data_size = len; - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const unsigned char *rptr=r.ptr(); int ps = format==FORMAT_LA8?2:4; @@ -2005,10 +2005,10 @@ void Image::blit_rect(const Image& p_src, const Rect2& p_src_rect,const Point2& return; Rect2i src_rect( p_src_rect.pos + ( local_src_rect.pos - p_dest), local_src_rect.size ); - DVector<uint8_t>::Write wp = data.write(); + PoolVector<uint8_t>::Write wp = data.write(); uint8_t *dst_data_ptr=wp.ptr(); - DVector<uint8_t>::Read rp = p_src.data.read(); + PoolVector<uint8_t>::Read rp = p_src.data.read(); const uint8_t *src_data_ptr=rp.ptr(); int pixel_size=get_format_pixel_size(format); @@ -2049,10 +2049,10 @@ void (*Image::_image_decompress_bc)(Image *)=NULL; void (*Image::_image_decompress_etc)(Image *)=NULL; void (*Image::_image_decompress_etc2)(Image *)=NULL; -DVector<uint8_t> (*Image::lossy_packer)(const Image& ,float )=NULL; -Image (*Image::lossy_unpacker)(const DVector<uint8_t>& )=NULL; -DVector<uint8_t> (*Image::lossless_packer)(const Image& )=NULL; -Image (*Image::lossless_unpacker)(const DVector<uint8_t>& )=NULL; +PoolVector<uint8_t> (*Image::lossy_packer)(const Image& ,float )=NULL; +Image (*Image::lossy_unpacker)(const PoolVector<uint8_t>& )=NULL; +PoolVector<uint8_t> (*Image::lossless_packer)(const Image& )=NULL; +Image (*Image::lossless_unpacker)(const PoolVector<uint8_t>& )=NULL; void Image::set_compress_bc_func(void (*p_compress_func)(Image *)) { @@ -2067,7 +2067,7 @@ void Image::normalmap_to_xy() { { int len = data.size()/4; - DVector<uint8_t>::Write wp = data.write(); + PoolVector<uint8_t>::Write wp = data.write(); unsigned char *data_ptr=wp.ptr(); for(int i=0;i<len;i++) { @@ -2094,7 +2094,7 @@ void Image::srgb_to_linear() { if (format==FORMAT_RGBA8) { int len = data.size()/4; - DVector<uint8_t>::Write wp = data.write(); + PoolVector<uint8_t>::Write wp = data.write(); unsigned char *data_ptr=wp.ptr(); for(int i=0;i<len;i++) { @@ -2107,7 +2107,7 @@ void Image::srgb_to_linear() { } else if (format==FORMAT_RGB8) { int len = data.size()/3; - DVector<uint8_t>::Write wp = data.write(); + PoolVector<uint8_t>::Write wp = data.write(); unsigned char *data_ptr=wp.ptr(); for(int i=0;i<len;i++) { @@ -2128,7 +2128,7 @@ void Image::premultiply_alpha() { if (format!=FORMAT_RGBA8) return; //not needed - DVector<uint8_t>::Write wp = data.write(); + PoolVector<uint8_t>::Write wp = data.write(); unsigned char *data_ptr=wp.ptr(); @@ -2152,11 +2152,11 @@ void Image::fix_alpha_edges() { if (format!=FORMAT_RGBA8) return; //not needed - DVector<uint8_t> dcopy = data; - DVector<uint8_t>::Read rp = data.read(); + PoolVector<uint8_t> dcopy = data; + PoolVector<uint8_t>::Read rp = data.read(); const uint8_t *srcptr=rp.ptr(); - DVector<uint8_t>::Write wp = data.write(); + PoolVector<uint8_t>::Write wp = data.write(); unsigned char *data_ptr=wp.ptr(); const int max_radius=4; diff --git a/core/image.h b/core/image.h index 2c585d74d9..620160147b 100644 --- a/core/image.h +++ b/core/image.h @@ -123,14 +123,14 @@ public: Error _decompress_bc(); - static DVector<uint8_t> (*lossy_packer)(const Image& p_image,float p_quality); - static Image (*lossy_unpacker)(const DVector<uint8_t>& p_buffer); - static DVector<uint8_t> (*lossless_packer)(const Image& p_image); - static Image (*lossless_unpacker)(const DVector<uint8_t>& p_buffer); + static PoolVector<uint8_t> (*lossy_packer)(const Image& p_image,float p_quality); + static Image (*lossy_unpacker)(const PoolVector<uint8_t>& p_buffer); + static PoolVector<uint8_t> (*lossless_packer)(const Image& p_image); + static Image (*lossless_unpacker)(const PoolVector<uint8_t>& p_buffer); private: Format format; - DVector<uint8_t> data; + PoolVector<uint8_t> data; int width,height; bool mipmaps; @@ -206,7 +206,7 @@ public: * Create a new image of a given size and format. Current image will be lost */ void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format); - void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const DVector<uint8_t>& p_data); + void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const PoolVector<uint8_t>& p_data); void create( const char ** p_xpm ); /** @@ -214,7 +214,7 @@ public: */ bool empty() const; - DVector<uint8_t> get_data() const; + PoolVector<uint8_t> get_data() const; Error load(const String& p_path); Error save_png(const String& p_path); @@ -230,7 +230,7 @@ public: /** * import an image of a specific size and format from a pointer */ - Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const DVector<uint8_t>& p_data); + Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const PoolVector<uint8_t>& p_data); enum AlphaMode { ALPHA_NONE, diff --git a/core/io/file_access_buffered.cpp b/core/io/file_access_buffered.cpp index 347edc7407..71518de38b 100644 --- a/core/io/file_access_buffered.cpp +++ b/core/io/file_access_buffered.cpp @@ -117,7 +117,7 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest,int p_elements) const { int size = (cache.buffer.size() - (file.offset - cache.offset)); size = size - (size % 4); - //DVector<uint8_t>::Read read = cache.buffer.read(); + //PoolVector<uint8_t>::Read read = cache.buffer.read(); //memcpy(p_dest, read.ptr() + (file.offset - cache.offset), size); memcpy(p_dest, cache.buffer.ptr() + (file.offset - cache.offset), size); p_dest += size; @@ -152,7 +152,7 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest,int p_elements) const { }; int r = MIN(left, to_read); - //DVector<uint8_t>::Read read = cache.buffer.read(); + //PoolVector<uint8_t>::Read read = cache.buffer.read(); //memcpy(p_dest+total_read, &read.ptr()[file.offset - cache.offset], r); memcpy(p_dest+total_read, cache.buffer.ptr() + (file.offset - cache.offset), r); diff --git a/core/io/file_access_buffered_fa.h b/core/io/file_access_buffered_fa.h index 8a15584b13..884d40a266 100644 --- a/core/io/file_access_buffered_fa.h +++ b/core/io/file_access_buffered_fa.h @@ -53,7 +53,7 @@ class FileAccessBufferedFA : public FileAccessBuffered { cache.buffer.resize(p_size); // on dvector - //DVector<uint8_t>::Write write = cache.buffer.write(); + //PoolVector<uint8_t>::Write write = cache.buffer.write(); //f.get_buffer(write.ptr(), p_size); // on vector diff --git a/core/io/http_client.cpp b/core/io/http_client.cpp index 4051ae302f..b556d46105 100644 --- a/core/io/http_client.cpp +++ b/core/io/http_client.cpp @@ -87,7 +87,7 @@ Ref<StreamPeer> HTTPClient::get_connection() const { return connection; } -Error HTTPClient::request_raw( Method p_method, const String& p_url, const Vector<String>& p_headers,const DVector<uint8_t>& p_body) { +Error HTTPClient::request_raw( Method p_method, const String& p_url, const Vector<String>& p_headers,const PoolVector<uint8_t>& p_body) { ERR_FAIL_INDEX_V(p_method,METHOD_MAX,ERR_INVALID_PARAMETER); ERR_FAIL_COND_V(status!=STATUS_CONNECTED,ERR_INVALID_PARAMETER); @@ -120,7 +120,7 @@ Error HTTPClient::request_raw( Method p_method, const String& p_url, const Vecto request+="\r\n"; CharString cs=request.utf8(); - DVector<uint8_t> data; + PoolVector<uint8_t> data; //Maybe this goes faster somehow? for(int i=0;i<cs.length();i++) { @@ -128,7 +128,7 @@ Error HTTPClient::request_raw( Method p_method, const String& p_url, const Vecto } data.append_array( p_body ); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); Error err = connection->put_data(&r[0], data.size()); if (err) { diff --git a/core/io/http_client.h b/core/io/http_client.h index 2e78882303..231475775f 100644 --- a/core/io/http_client.h +++ b/core/io/http_client.h @@ -172,7 +172,7 @@ public: void set_connection(const Ref<StreamPeer>& p_connection); Ref<StreamPeer> get_connection() const; - Error request_raw( Method p_method, const String& p_url, const Vector<String>& p_headers,const DVector<uint8_t>& p_body); + Error request_raw( Method p_method, const String& p_url, const Vector<String>& p_headers,const PoolVector<uint8_t>& p_body); Error request( Method p_method, const String& p_url, const Vector<String>& p_headers,const String& p_body=String()); Error send_body_text(const String& p_body); Error send_body_data(const ByteArray& p_body); diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp index bc6cc0bb83..e10e4413bc 100644 --- a/core/io/marshalls.cpp +++ b/core/io/marshalls.cpp @@ -272,11 +272,11 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * if (datalen>0) { len-=5*4; ERR_FAIL_COND_V( len < datalen, ERR_INVALID_DATA ); - DVector<uint8_t> data; + PoolVector<uint8_t> data; data.resize(datalen); - DVector<uint8_t>::Write wr = data.write(); + PoolVector<uint8_t>::Write wr = data.write(); copymem(&wr[0],&buf[20],datalen); - wr = DVector<uint8_t>::Write(); + wr = PoolVector<uint8_t>::Write(); @@ -537,17 +537,17 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * ERR_FAIL_COND_V((int)count>len,ERR_INVALID_DATA); - DVector<uint8_t> data; + PoolVector<uint8_t> data; if (count) { data.resize(count); - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); for(int i=0;i<count;i++) { w[i]=buf[i]; } - w = DVector<uint8_t>::Write(); + w = PoolVector<uint8_t>::Write(); } r_variant=data; @@ -569,18 +569,18 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * len-=4; ERR_FAIL_COND_V((int)count*4>len,ERR_INVALID_DATA); - DVector<int> data; + PoolVector<int> data; if (count) { //const int*rbuf=(const int*)buf; data.resize(count); - DVector<int>::Write w = data.write(); + PoolVector<int>::Write w = data.write(); for(int i=0;i<count;i++) { w[i]=decode_uint32(&buf[i*4]); } - w = DVector<int>::Write(); + w = PoolVector<int>::Write(); } r_variant=Variant(data); if (r_len) { @@ -596,18 +596,18 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * len-=4; ERR_FAIL_COND_V((int)count*4>len,ERR_INVALID_DATA); - DVector<float> data; + PoolVector<float> data; if (count) { //const float*rbuf=(const float*)buf; data.resize(count); - DVector<float>::Write w = data.write(); + PoolVector<float>::Write w = data.write(); for(int i=0;i<count;i++) { w[i]=decode_float(&buf[i*4]); } - w = DVector<float>::Write(); + w = PoolVector<float>::Write(); } r_variant=data; @@ -623,7 +623,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * uint32_t count = decode_uint32(buf); ERR_FAIL_COND_V(count<0,ERR_INVALID_DATA); - DVector<String> strings; + PoolVector<String> strings; buf+=4; len-=4; @@ -676,7 +676,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * len-=4; ERR_FAIL_COND_V((int)count*4*2>len,ERR_INVALID_DATA); - DVector<Vector2> varray; + PoolVector<Vector2> varray; if (r_len) { (*r_len)+=4; @@ -684,7 +684,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * if (count) { varray.resize(count); - DVector<Vector2>::Write w = varray.write(); + PoolVector<Vector2>::Write w = varray.write(); for(int i=0;i<(int)count;i++) { @@ -714,7 +714,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * len-=4; ERR_FAIL_COND_V((int)count*4*3>len,ERR_INVALID_DATA); - DVector<Vector3> varray; + PoolVector<Vector3> varray; if (r_len) { (*r_len)+=4; @@ -722,7 +722,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * if (count) { varray.resize(count); - DVector<Vector3>::Write w = varray.write(); + PoolVector<Vector3>::Write w = varray.write(); for(int i=0;i<(int)count;i++) { @@ -753,7 +753,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * len-=4; ERR_FAIL_COND_V((int)count*4*4>len,ERR_INVALID_DATA); - DVector<Color> carray; + PoolVector<Color> carray; if (r_len) { (*r_len)+=4; @@ -761,7 +761,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * if (count) { carray.resize(count); - DVector<Color>::Write w = carray.write(); + PoolVector<Color>::Write w = carray.write(); for(int i=0;i<(int)count;i++) { @@ -1055,7 +1055,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { case Variant::IMAGE: { Image image = p_variant; - DVector<uint8_t> data=image.get_data(); + PoolVector<uint8_t> data=image.get_data(); if (buf) { @@ -1065,7 +1065,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { encode_uint32(image.get_height(),&buf[12]); int ds=data.size(); encode_uint32(ds,&buf[16]); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); copymem(&buf[20],&r[0],ds); } @@ -1234,14 +1234,14 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { // arrays case Variant::RAW_ARRAY: { - DVector<uint8_t> data = p_variant; + PoolVector<uint8_t> data = p_variant; int datalen=data.size(); int datasize=sizeof(uint8_t); if (buf) { encode_uint32(datalen,buf); buf+=4; - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); copymem(buf,&r[0],datalen*datasize); } @@ -1253,14 +1253,14 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } break; case Variant::INT_ARRAY: { - DVector<int> data = p_variant; + PoolVector<int> data = p_variant; int datalen=data.size(); int datasize=sizeof(int32_t); if (buf) { encode_uint32(datalen,buf); buf+=4; - DVector<int>::Read r = data.read(); + PoolVector<int>::Read r = data.read(); for(int i=0;i<datalen;i++) encode_uint32(r[i],&buf[i*datasize]); @@ -1271,14 +1271,14 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } break; case Variant::REAL_ARRAY: { - DVector<real_t> data = p_variant; + PoolVector<real_t> data = p_variant; int datalen=data.size(); int datasize=sizeof(real_t); if (buf) { encode_uint32(datalen,buf); buf+=4; - DVector<real_t>::Read r = data.read(); + PoolVector<real_t>::Read r = data.read(); for(int i=0;i<datalen;i++) encode_float(r[i],&buf[i*datasize]); @@ -1290,7 +1290,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { case Variant::STRING_ARRAY: { - DVector<String> data = p_variant; + PoolVector<String> data = p_variant; int len=data.size(); if (buf) { @@ -1323,7 +1323,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } break; case Variant::VECTOR2_ARRAY: { - DVector<Vector2> data = p_variant; + PoolVector<Vector2> data = p_variant; int len=data.size(); if (buf) { @@ -1351,7 +1351,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } break; case Variant::VECTOR3_ARRAY: { - DVector<Vector3> data = p_variant; + PoolVector<Vector3> data = p_variant; int len=data.size(); if (buf) { @@ -1380,7 +1380,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } break; case Variant::COLOR_ARRAY: { - DVector<Color> data = p_variant; + PoolVector<Color> data = p_variant; int len=data.size(); if (buf) { diff --git a/core/io/packet_peer.cpp b/core/io/packet_peer.cpp index 720e912e71..5ff09f9fb0 100644 --- a/core/io/packet_peer.cpp +++ b/core/io/packet_peer.cpp @@ -39,7 +39,7 @@ PacketPeer::PacketPeer() { last_get_error=OK; } -Error PacketPeer::get_packet_buffer(DVector<uint8_t> &r_buffer) const { +Error PacketPeer::get_packet_buffer(PoolVector<uint8_t> &r_buffer) const { const uint8_t *buffer; int buffer_size; @@ -51,7 +51,7 @@ Error PacketPeer::get_packet_buffer(DVector<uint8_t> &r_buffer) const { if (buffer_size==0) return OK; - DVector<uint8_t>::Write w = r_buffer.write(); + PoolVector<uint8_t>::Write w = r_buffer.write(); for(int i=0;i<buffer_size;i++) w[i]=buffer[i]; @@ -59,13 +59,13 @@ Error PacketPeer::get_packet_buffer(DVector<uint8_t> &r_buffer) const { } -Error PacketPeer::put_packet_buffer(const DVector<uint8_t> &p_buffer) { +Error PacketPeer::put_packet_buffer(const PoolVector<uint8_t> &p_buffer) { int len = p_buffer.size(); if (len==0) return OK; - DVector<uint8_t>::Read r = p_buffer.read(); + PoolVector<uint8_t>::Read r = p_buffer.read(); return put_packet(&r[0],len); } @@ -108,12 +108,12 @@ Variant PacketPeer::_bnd_get_var() const { return var; }; -Error PacketPeer::_put_packet(const DVector<uint8_t> &p_buffer) { +Error PacketPeer::_put_packet(const PoolVector<uint8_t> &p_buffer) { return put_packet_buffer(p_buffer); } -DVector<uint8_t> PacketPeer::_get_packet() const { +PoolVector<uint8_t> PacketPeer::_get_packet() const { - DVector<uint8_t> raw; + PoolVector<uint8_t> raw; last_get_error=get_packet_buffer(raw); return raw; } diff --git a/core/io/packet_peer.h b/core/io/packet_peer.h index c67cfb943e..bacd5214f1 100644 --- a/core/io/packet_peer.h +++ b/core/io/packet_peer.h @@ -42,8 +42,8 @@ class PacketPeer : public Reference { static void _bind_methods(); - Error _put_packet(const DVector<uint8_t> &p_buffer); - DVector<uint8_t> _get_packet() const; + Error _put_packet(const PoolVector<uint8_t> &p_buffer); + PoolVector<uint8_t> _get_packet() const; Error _get_packet_error() const; @@ -59,8 +59,8 @@ public: /* helpers / binders */ - virtual Error get_packet_buffer(DVector<uint8_t> &r_buffer) const; - virtual Error put_packet_buffer(const DVector<uint8_t> &p_buffer); + virtual Error get_packet_buffer(PoolVector<uint8_t> &r_buffer) const; + virtual Error put_packet_buffer(const PoolVector<uint8_t> &p_buffer); virtual Error get_var(Variant &r_variant) const; virtual Error put_var(const Variant& p_packet); diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp index 512031b128..2a9089e8e8 100644 --- a/core/io/resource_format_binary.cpp +++ b/core/io/resource_format_binary.cpp @@ -264,22 +264,22 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { uint32_t datalen = f->get_32(); - DVector<uint8_t> imgdata; + PoolVector<uint8_t> imgdata; imgdata.resize(datalen); - DVector<uint8_t>::Write w = imgdata.write(); + PoolVector<uint8_t>::Write w = imgdata.write(); f->get_buffer(w.ptr(),datalen); _advance_padding(datalen); - w=DVector<uint8_t>::Write(); + w=PoolVector<uint8_t>::Write(); r_v=Image(width,height,mipmaps,fmt,imgdata); } else { //compressed - DVector<uint8_t> data; + PoolVector<uint8_t> data; data.resize(f->get_32()); - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); f->get_buffer(w.ptr(),data.size()); - w = DVector<uint8_t>::Write(); + w = PoolVector<uint8_t>::Write(); Image img; @@ -448,12 +448,12 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { uint32_t len = f->get_32(); - DVector<uint8_t> array; + PoolVector<uint8_t> array; array.resize(len); - DVector<uint8_t>::Write w = array.write(); + PoolVector<uint8_t>::Write w = array.write(); f->get_buffer(w.ptr(),len); _advance_padding(len); - w=DVector<uint8_t>::Write(); + w=PoolVector<uint8_t>::Write(); r_v=array; } break; @@ -461,9 +461,9 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { uint32_t len = f->get_32(); - DVector<int> array; + PoolVector<int> array; array.resize(len); - DVector<int>::Write w = array.write(); + PoolVector<int>::Write w = array.write(); f->get_buffer((uint8_t*)w.ptr(),len*4); #ifdef BIG_ENDIAN_ENABLED { @@ -475,16 +475,16 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { } #endif - w=DVector<int>::Write(); + w=PoolVector<int>::Write(); r_v=array; } break; case VARIANT_REAL_ARRAY: { uint32_t len = f->get_32(); - DVector<real_t> array; + PoolVector<real_t> array; array.resize(len); - DVector<real_t>::Write w = array.write(); + PoolVector<real_t>::Write w = array.write(); f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t)); #ifdef BIG_ENDIAN_ENABLED { @@ -497,18 +497,18 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { #endif - w=DVector<real_t>::Write(); + w=PoolVector<real_t>::Write(); r_v=array; } break; case VARIANT_STRING_ARRAY: { uint32_t len = f->get_32(); - DVector<String> array; + PoolVector<String> array; array.resize(len); - DVector<String>::Write w = array.write(); + PoolVector<String>::Write w = array.write(); for(uint32_t i=0;i<len;i++) w[i]=get_unicode_string(); - w=DVector<String>::Write(); + w=PoolVector<String>::Write(); r_v=array; @@ -517,9 +517,9 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { uint32_t len = f->get_32(); - DVector<Vector2> array; + PoolVector<Vector2> array; array.resize(len); - DVector<Vector2>::Write w = array.write(); + PoolVector<Vector2>::Write w = array.write(); if (sizeof(Vector2)==8) { f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t)*2); #ifdef BIG_ENDIAN_ENABLED @@ -537,7 +537,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { ERR_EXPLAIN("Vector2 size is NOT 8!"); ERR_FAIL_V(ERR_UNAVAILABLE); } - w=DVector<Vector2>::Write(); + w=PoolVector<Vector2>::Write(); r_v=array; } break; @@ -545,9 +545,9 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { uint32_t len = f->get_32(); - DVector<Vector3> array; + PoolVector<Vector3> array; array.resize(len); - DVector<Vector3>::Write w = array.write(); + PoolVector<Vector3>::Write w = array.write(); if (sizeof(Vector3)==12) { f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t)*3); #ifdef BIG_ENDIAN_ENABLED @@ -565,7 +565,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { ERR_EXPLAIN("Vector3 size is NOT 12!"); ERR_FAIL_V(ERR_UNAVAILABLE); } - w=DVector<Vector3>::Write(); + w=PoolVector<Vector3>::Write(); r_v=array; } break; @@ -573,9 +573,9 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { uint32_t len = f->get_32(); - DVector<Color> array; + PoolVector<Color> array; array.resize(len); - DVector<Color>::Write w = array.write(); + PoolVector<Color>::Write w = array.write(); if (sizeof(Color)==16) { f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t)*4); #ifdef BIG_ENDIAN_ENABLED @@ -593,7 +593,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { ERR_EXPLAIN("Color size is NOT 16!"); ERR_FAIL_V(ERR_UNAVAILABLE); } - w=DVector<Color>::Write(); + w=PoolVector<Color>::Write(); r_v=array; } break; @@ -1587,12 +1587,12 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, int dlen = val.get_data().size(); f->store_32(dlen); - DVector<uint8_t>::Read r = val.get_data().read(); + PoolVector<uint8_t>::Read r = val.get_data().read(); f->store_buffer(r.ptr(),dlen); _pad_buffer(dlen); } else { - DVector<uint8_t> data; + PoolVector<uint8_t> data; if (encoding==IMAGE_ENCODING_LOSSY) { data=Image::lossy_packer(val,quality); @@ -1604,7 +1604,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, int ds=data.size(); f->store_32(ds); if (ds>0) { - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); f->store_buffer(r.ptr(),ds); _pad_buffer(ds); @@ -1703,10 +1703,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, case Variant::RAW_ARRAY: { f->store_32(VARIANT_RAW_ARRAY); - DVector<uint8_t> arr = p_property; + PoolVector<uint8_t> arr = p_property; int len=arr.size(); f->store_32(len); - DVector<uint8_t>::Read r = arr.read(); + PoolVector<uint8_t>::Read r = arr.read(); f->store_buffer(r.ptr(),len); _pad_buffer(len); @@ -1714,10 +1714,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, case Variant::INT_ARRAY: { f->store_32(VARIANT_INT_ARRAY); - DVector<int> arr = p_property; + PoolVector<int> arr = p_property; int len=arr.size(); f->store_32(len); - DVector<int>::Read r = arr.read(); + PoolVector<int>::Read r = arr.read(); for(int i=0;i<len;i++) f->store_32(r[i]); @@ -1725,10 +1725,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, case Variant::REAL_ARRAY: { f->store_32(VARIANT_REAL_ARRAY); - DVector<real_t> arr = p_property; + PoolVector<real_t> arr = p_property; int len=arr.size(); f->store_32(len); - DVector<real_t>::Read r = arr.read(); + PoolVector<real_t>::Read r = arr.read(); for(int i=0;i<len;i++) { f->store_real(r[i]); } @@ -1737,10 +1737,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, case Variant::STRING_ARRAY: { f->store_32(VARIANT_STRING_ARRAY); - DVector<String> arr = p_property; + PoolVector<String> arr = p_property; int len=arr.size(); f->store_32(len); - DVector<String>::Read r = arr.read(); + PoolVector<String>::Read r = arr.read(); for(int i=0;i<len;i++) { save_unicode_string(r[i]); } @@ -1749,10 +1749,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, case Variant::VECTOR3_ARRAY: { f->store_32(VARIANT_VECTOR3_ARRAY); - DVector<Vector3> arr = p_property; + PoolVector<Vector3> arr = p_property; int len=arr.size(); f->store_32(len); - DVector<Vector3>::Read r = arr.read(); + PoolVector<Vector3>::Read r = arr.read(); for(int i=0;i<len;i++) { f->store_real(r[i].x); f->store_real(r[i].y); @@ -1763,10 +1763,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, case Variant::VECTOR2_ARRAY: { f->store_32(VARIANT_VECTOR2_ARRAY); - DVector<Vector2> arr = p_property; + PoolVector<Vector2> arr = p_property; int len=arr.size(); f->store_32(len); - DVector<Vector2>::Read r = arr.read(); + PoolVector<Vector2>::Read r = arr.read(); for(int i=0;i<len;i++) { f->store_real(r[i].x); f->store_real(r[i].y); @@ -1776,10 +1776,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, case Variant::COLOR_ARRAY: { f->store_32(VARIANT_COLOR_ARRAY); - DVector<Color> arr = p_property; + PoolVector<Color> arr = p_property; int len=arr.size(); f->store_32(len); - DVector<Color>::Read r = arr.read(); + PoolVector<Color>::Read r = arr.read(); for(int i=0;i<len;i++) { f->store_real(r[i].r); f->store_real(r[i].g); diff --git a/core/io/resource_format_xml.cpp b/core/io/resource_format_xml.cpp index d4808d4741..34e3f282c1 100644 --- a/core/io/resource_format_xml.cpp +++ b/core/io/resource_format_xml.cpp @@ -623,9 +623,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) return OK; }; - DVector<uint8_t> pixels; + PoolVector<uint8_t> pixels; pixels.resize(datasize); - DVector<uint8_t>::Write wb = pixels.write(); + PoolVector<uint8_t>::Write wb = pixels.write(); int idx=0; uint8_t byte; @@ -652,7 +652,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT); - wb=DVector<uint8_t>::Write(); + wb=PoolVector<uint8_t>::Write(); r_v=Image(w,h,mipmaps,imgformat,pixels); String sdfsdfg; @@ -672,9 +672,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } int len=tag->args["len"].to_int(); - DVector<uint8_t> bytes; + PoolVector<uint8_t> bytes; bytes.resize(len); - DVector<uint8_t>::Write w=bytes.write(); + PoolVector<uint8_t>::Write w=bytes.write(); uint8_t *bytesptr=w.ptr(); int idx=0; uint8_t byte; @@ -700,7 +700,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT); - w=DVector<uint8_t>::Write(); + w=PoolVector<uint8_t>::Write(); r_v=bytes; String sdfsdfg; Error err=parse_property_data(sdfsdfg); @@ -717,9 +717,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } int len=tag->args["len"].to_int(); - DVector<int> ints; + PoolVector<int> ints; ints.resize(len); - DVector<int>::Write w=ints.write(); + PoolVector<int>::Write w=ints.write(); int *intsptr=w.ptr(); int idx=0; String str; @@ -770,7 +770,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } #endif - w=DVector<int>::Write(); + w=PoolVector<int>::Write(); r_v=ints; Error err=goto_end_of_tag(); @@ -786,9 +786,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } int len=tag->args["len"].to_int();; - DVector<real_t> reals; + PoolVector<real_t> reals; reals.resize(len); - DVector<real_t>::Write w=reals.write(); + PoolVector<real_t>::Write w=reals.write(); real_t *realsptr=w.ptr(); int idx=0; String str; @@ -845,7 +845,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) #endif - w=DVector<real_t>::Write(); + w=PoolVector<real_t>::Write(); r_v=reals; Error err=goto_end_of_tag(); @@ -861,9 +861,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } int len=tag->args["len"].to_int(); - DVector<String> strings; + PoolVector<String> strings; strings.resize(len); - DVector<String>::Write w=strings.write(); + PoolVector<String>::Write w=strings.write(); String *stringsptr=w.ptr(); int idx=0; String str; @@ -903,7 +903,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) cs.push_back(c); } } - w=DVector<String>::Write(); + w=PoolVector<String>::Write(); r_v=strings; String sdfsdfg; Error err=parse_property_data(sdfsdfg); @@ -923,7 +923,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) StringArray array; array.resize(len); - DVector<String>::Write w = array.write(); + PoolVector<String>::Write w = array.write(); Error err; Variant v; @@ -964,9 +964,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } int len=tag->args["len"].to_int();; - DVector<Vector3> vectors; + PoolVector<Vector3> vectors; vectors.resize(len); - DVector<Vector3>::Write w=vectors.write(); + PoolVector<Vector3>::Write w=vectors.write(); Vector3 *vectorsptr=w.ptr(); int idx=0; int subidx=0; @@ -1041,7 +1041,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) // double time_taken = (OS::get_singleton()->get_ticks_usec() - tbegin)/1000000.0; - w=DVector<Vector3>::Write(); + w=PoolVector<Vector3>::Write(); r_v=vectors; String sdfsdfg; Error err=goto_end_of_tag(); @@ -1058,9 +1058,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } int len=tag->args["len"].to_int();; - DVector<Vector2> vectors; + PoolVector<Vector2> vectors; vectors.resize(len); - DVector<Vector2>::Write w=vectors.write(); + PoolVector<Vector2>::Write w=vectors.write(); Vector2 *vectorsptr=w.ptr(); int idx=0; int subidx=0; @@ -1135,7 +1135,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) // double time_taken = (OS::get_singleton()->get_ticks_usec() - tbegin)/1000000.0; - w=DVector<Vector2>::Write(); + w=PoolVector<Vector2>::Write(); r_v=vectors; String sdfsdfg; Error err=goto_end_of_tag(); @@ -1152,9 +1152,9 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) } int len=tag->args["len"].to_int();; - DVector<Color> colors; + PoolVector<Color> colors; colors.resize(len); - DVector<Color>::Write w=colors.write(); + PoolVector<Color>::Write w=colors.write(); Color *colorsptr=w.ptr(); int idx=0; int subidx=0; @@ -1194,7 +1194,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) str+=c; } } - w=DVector<Color>::Write(); + w=PoolVector<Color>::Write(); r_v=colors; String sdfsdfg; Error err=parse_property_data(sdfsdfg); @@ -2248,13 +2248,13 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V case Variant::DICTIONARY: type="dictionary"; params="shared=\""+String(p_property.is_shared()?"true":"false")+"\""; oneliner=false; break; case Variant::ARRAY: type="array"; params="len=\""+itos(p_property.operator Array().size())+"\" shared=\""+String(p_property.is_shared()?"true":"false")+"\""; oneliner=false; break; - case Variant::RAW_ARRAY: type="raw_array"; params="len=\""+itos(p_property.operator DVector < uint8_t >().size())+"\""; break; - case Variant::INT_ARRAY: type="int_array"; params="len=\""+itos(p_property.operator DVector < int >().size())+"\""; break; - case Variant::REAL_ARRAY: type="real_array"; params="len=\""+itos(p_property.operator DVector < real_t >().size())+"\""; break; - case Variant::STRING_ARRAY: oneliner=false; type="string_array"; params="len=\""+itos(p_property.operator DVector < String >().size())+"\""; break; - case Variant::VECTOR2_ARRAY: type="vector2_array"; params="len=\""+itos(p_property.operator DVector < Vector2 >().size())+"\""; break; - case Variant::VECTOR3_ARRAY: type="vector3_array"; params="len=\""+itos(p_property.operator DVector < Vector3 >().size())+"\""; break; - case Variant::COLOR_ARRAY: type="color_array"; params="len=\""+itos(p_property.operator DVector < Color >().size())+"\""; break; + case Variant::RAW_ARRAY: type="raw_array"; params="len=\""+itos(p_property.operator PoolVector < uint8_t >().size())+"\""; break; + case Variant::INT_ARRAY: type="int_array"; params="len=\""+itos(p_property.operator PoolVector < int >().size())+"\""; break; + case Variant::REAL_ARRAY: type="real_array"; params="len=\""+itos(p_property.operator PoolVector < real_t >().size())+"\""; break; + case Variant::STRING_ARRAY: oneliner=false; type="string_array"; params="len=\""+itos(p_property.operator PoolVector < String >().size())+"\""; break; + case Variant::VECTOR2_ARRAY: type="vector2_array"; params="len=\""+itos(p_property.operator PoolVector < Vector2 >().size())+"\""; break; + case Variant::VECTOR3_ARRAY: type="vector3_array"; params="len=\""+itos(p_property.operator PoolVector < Vector3 >().size())+"\""; break; + case Variant::COLOR_ARRAY: type="color_array"; params="len=\""+itos(p_property.operator PoolVector < Color >().size())+"\""; break; default: { ERR_PRINT("Unknown Variant type."); @@ -2403,9 +2403,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V String s; Image img = p_property; - DVector<uint8_t> data = img.get_data(); + PoolVector<uint8_t> data = img.get_data(); int len = data.size(); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const uint8_t *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2487,9 +2487,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V case Variant::RAW_ARRAY: { String s; - DVector<uint8_t> data = p_property; + PoolVector<uint8_t> data = p_property; int len = data.size(); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const uint8_t *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2504,9 +2504,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V } break; case Variant::INT_ARRAY: { - DVector<int> data = p_property; + PoolVector<int> data = p_property; int len = data.size(); - DVector<int>::Read r = data.read(); + PoolVector<int>::Read r = data.read(); const int *ptr=r.ptr();; write_tabs(); @@ -2523,9 +2523,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V } break; case Variant::REAL_ARRAY: { - DVector<real_t> data = p_property; + PoolVector<real_t> data = p_property; int len = data.size(); - DVector<real_t>::Read r = data.read(); + PoolVector<real_t>::Read r = data.read(); const real_t *ptr=r.ptr();; write_tabs(); String cm=", " ; @@ -2541,9 +2541,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V } break; case Variant::STRING_ARRAY: { - DVector<String> data = p_property; + PoolVector<String> data = p_property; int len = data.size(); - DVector<String>::Read r = data.read(); + PoolVector<String>::Read r = data.read(); const String *ptr=r.ptr();; String s; //write_string("\n"); @@ -2560,9 +2560,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V } break; case Variant::VECTOR2_ARRAY: { - DVector<Vector2> data = p_property; + PoolVector<Vector2> data = p_property; int len = data.size(); - DVector<Vector2>::Read r = data.read(); + PoolVector<Vector2>::Read r = data.read(); const Vector2 *ptr=r.ptr();; write_tabs(); @@ -2579,9 +2579,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V } break; case Variant::VECTOR3_ARRAY: { - DVector<Vector3> data = p_property; + PoolVector<Vector3> data = p_property; int len = data.size(); - DVector<Vector3>::Read r = data.read(); + PoolVector<Vector3>::Read r = data.read(); const Vector3 *ptr=r.ptr();; write_tabs(); @@ -2599,9 +2599,9 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V } break; case Variant::COLOR_ARRAY: { - DVector<Color> data = p_property; + PoolVector<Color> data = p_property; int len = data.size(); - DVector<Color>::Read r = data.read(); + PoolVector<Color>::Read r = data.read(); const Color *ptr=r.ptr();; write_tabs(); diff --git a/core/io/stream_peer.cpp b/core/io/stream_peer.cpp index 218e17278e..a2812edb81 100644 --- a/core/io/stream_peer.cpp +++ b/core/io/stream_peer.cpp @@ -29,16 +29,16 @@ #include "stream_peer.h" #include "io/marshalls.h" -Error StreamPeer::_put_data(const DVector<uint8_t>& p_data) { +Error StreamPeer::_put_data(const PoolVector<uint8_t>& p_data) { int len = p_data.size(); if (len==0) return OK; - DVector<uint8_t>::Read r = p_data.read(); + PoolVector<uint8_t>::Read r = p_data.read(); return put_data(&r[0],len); } -Array StreamPeer::_put_partial_data(const DVector<uint8_t>& p_data) { +Array StreamPeer::_put_partial_data(const PoolVector<uint8_t>& p_data) { Array ret; @@ -49,7 +49,7 @@ Array StreamPeer::_put_partial_data(const DVector<uint8_t>& p_data) { return ret; } - DVector<uint8_t>::Read r = p_data.read(); + PoolVector<uint8_t>::Read r = p_data.read(); int sent; Error err = put_partial_data(&r[0],len,sent); @@ -66,18 +66,18 @@ Array StreamPeer::_get_data(int p_bytes) { Array ret; - DVector<uint8_t> data; + PoolVector<uint8_t> data; data.resize(p_bytes); if (data.size()!=p_bytes) { ret.push_back(ERR_OUT_OF_MEMORY); - ret.push_back(DVector<uint8_t>()); + ret.push_back(PoolVector<uint8_t>()); return ret; } - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); Error err = get_data(&w[0],p_bytes); - w = DVector<uint8_t>::Write(); + w = PoolVector<uint8_t>::Write(); ret.push_back(err); ret.push_back(data); return ret; @@ -88,19 +88,19 @@ Array StreamPeer::_get_partial_data(int p_bytes) { Array ret; - DVector<uint8_t> data; + PoolVector<uint8_t> data; data.resize(p_bytes); if (data.size()!=p_bytes) { ret.push_back(ERR_OUT_OF_MEMORY); - ret.push_back(DVector<uint8_t>()); + ret.push_back(PoolVector<uint8_t>()); return ret; } - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); int received; Error err = get_partial_data(&w[0],p_bytes,received); - w = DVector<uint8_t>::Write(); + w = PoolVector<uint8_t>::Write(); if (err!=OK) { data.resize(0); @@ -454,7 +454,7 @@ Error StreamPeerBuffer::put_data(const uint8_t* p_data,int p_bytes) { } - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); copymem(&w[pointer],p_data,p_bytes); pointer+=p_bytes; @@ -490,7 +490,7 @@ Error StreamPeerBuffer::get_partial_data(uint8_t* p_buffer, int p_bytes,int &r_r r_received=p_bytes; } - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); copymem(p_buffer,r.ptr(),r_received); } @@ -520,13 +520,13 @@ void StreamPeerBuffer::resize(int p_size){ data.resize(p_size); } -void StreamPeerBuffer::set_data_array(const DVector<uint8_t> & p_data){ +void StreamPeerBuffer::set_data_array(const PoolVector<uint8_t> & p_data){ data=p_data; pointer=0; } -DVector<uint8_t> StreamPeerBuffer::get_data_array() const{ +PoolVector<uint8_t> StreamPeerBuffer::get_data_array() const{ return data; } diff --git a/core/io/stream_peer.h b/core/io/stream_peer.h index 232a908dd7..eb0f90ba50 100644 --- a/core/io/stream_peer.h +++ b/core/io/stream_peer.h @@ -38,8 +38,8 @@ protected: static void _bind_methods(); //bind helpers - Error _put_data(const DVector<uint8_t>& p_data); - Array _put_partial_data(const DVector<uint8_t>& p_data); + Error _put_data(const PoolVector<uint8_t>& p_data); + Array _put_partial_data(const PoolVector<uint8_t>& p_data); Array _get_data(int p_bytes); Array _get_partial_data(int p_bytes); @@ -96,7 +96,7 @@ class StreamPeerBuffer : public StreamPeer { GDCLASS(StreamPeerBuffer,StreamPeer); - DVector<uint8_t> data; + PoolVector<uint8_t> data; int pointer; protected: @@ -116,8 +116,8 @@ public: void resize(int p_size); - void set_data_array(const DVector<uint8_t> & p_data); - DVector<uint8_t> get_data_array() const; + void set_data_array(const PoolVector<uint8_t> & p_data); + PoolVector<uint8_t> get_data_array() const; void clear(); diff --git a/core/io/tcp_server.cpp b/core/io/tcp_server.cpp index 751dfbadca..bfa5dce58f 100644 --- a/core/io/tcp_server.cpp +++ b/core/io/tcp_server.cpp @@ -44,7 +44,7 @@ TCP_Server* TCP_Server::create() { return _create(); } -Error TCP_Server::_listen(uint16_t p_port, DVector<String> p_accepted_hosts) { +Error TCP_Server::_listen(uint16_t p_port, PoolVector<String> p_accepted_hosts) { List<String> hosts; for(int i=0;i<p_accepted_hosts.size();i++) @@ -62,7 +62,7 @@ void TCP_Server::set_ip_type(IP::Type p_type) { void TCP_Server::_bind_methods() { ClassDB::bind_method(_MD("set_ip_type","ip_type"),&TCP_Server::set_ip_type); - ClassDB::bind_method(_MD("listen","port","accepted_hosts"),&TCP_Server::_listen,DEFVAL(DVector<String>())); + ClassDB::bind_method(_MD("listen","port","accepted_hosts"),&TCP_Server::_listen,DEFVAL(PoolVector<String>())); ClassDB::bind_method(_MD("is_connection_available"),&TCP_Server::is_connection_available); ClassDB::bind_method(_MD("take_connection"),&TCP_Server::take_connection); ClassDB::bind_method(_MD("stop"),&TCP_Server::stop); diff --git a/core/io/tcp_server.h b/core/io/tcp_server.h index 5fd65575f6..3d7b3ddd8d 100644 --- a/core/io/tcp_server.h +++ b/core/io/tcp_server.h @@ -43,7 +43,7 @@ protected: static TCP_Server* (*_create)(); //bind helper - Error _listen(uint16_t p_port, DVector<String> p_accepted_hosts=DVector<String>()); + Error _listen(uint16_t p_port, PoolVector<String> p_accepted_hosts=PoolVector<String>()); static void _bind_methods(); public: diff --git a/core/math/a_star.cpp b/core/math/a_star.cpp index 29f61834b4..0d6997183f 100644 --- a/core/math/a_star.cpp +++ b/core/math/a_star.cpp @@ -295,10 +295,10 @@ bool AStar::_solve(Point* begin_point, Point* end_point) { } -DVector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) { +PoolVector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) { - ERR_FAIL_COND_V(!points.has(p_from_id),DVector<Vector3>()); - ERR_FAIL_COND_V(!points.has(p_to_id),DVector<Vector3>()); + ERR_FAIL_COND_V(!points.has(p_from_id),PoolVector<Vector3>()); + ERR_FAIL_COND_V(!points.has(p_to_id),PoolVector<Vector3>()); pass++; @@ -307,7 +307,7 @@ DVector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) { Point* b = points[p_to_id]; if (a==b) { - DVector<Vector3> ret; + PoolVector<Vector3> ret; ret.push_back(a->pos); return ret; } @@ -319,7 +319,7 @@ DVector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) { bool found_route=_solve(begin_point,end_point); if (!found_route) - return DVector<Vector3>(); + return PoolVector<Vector3>(); //midpoints Point *p=end_point; @@ -329,11 +329,11 @@ DVector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) { p=p->prev_point; } - DVector<Vector3> path; + PoolVector<Vector3> path; path.resize(pc); { - DVector<Vector3>::Write w = path.write(); + PoolVector<Vector3>::Write w = path.write(); Point *p=end_point; int idx=pc-1; @@ -351,10 +351,10 @@ DVector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) { } -DVector<int> AStar::get_id_path(int p_from_id, int p_to_id) { +PoolVector<int> AStar::get_id_path(int p_from_id, int p_to_id) { - ERR_FAIL_COND_V(!points.has(p_from_id),DVector<int>()); - ERR_FAIL_COND_V(!points.has(p_to_id),DVector<int>()); + ERR_FAIL_COND_V(!points.has(p_from_id),PoolVector<int>()); + ERR_FAIL_COND_V(!points.has(p_to_id),PoolVector<int>()); pass++; @@ -363,7 +363,7 @@ DVector<int> AStar::get_id_path(int p_from_id, int p_to_id) { Point* b = points[p_to_id]; if (a==b) { - DVector<int> ret; + PoolVector<int> ret; ret.push_back(a->id); return ret; } @@ -375,7 +375,7 @@ DVector<int> AStar::get_id_path(int p_from_id, int p_to_id) { bool found_route=_solve(begin_point,end_point); if (!found_route) - return DVector<int>(); + return PoolVector<int>(); //midpoints Point *p=end_point; @@ -385,11 +385,11 @@ DVector<int> AStar::get_id_path(int p_from_id, int p_to_id) { p=p->prev_point; } - DVector<int> path; + PoolVector<int> path; path.resize(pc); { - DVector<int>::Write w = path.write(); + PoolVector<int>::Write w = path.write(); p=end_point; int idx=pc-1; diff --git a/core/math/a_star.h b/core/math/a_star.h index 66a983a6ce..35e6ead226 100644 --- a/core/math/a_star.h +++ b/core/math/a_star.h @@ -113,8 +113,8 @@ public: int get_closest_point(const Vector3& p_point) const; Vector3 get_closest_pos_in_segment(const Vector3& p_point) const; - DVector<Vector3> get_point_path(int p_from_id, int p_to_id); - DVector<int> get_id_path(int p_from_id, int p_to_id); + PoolVector<Vector3> get_point_path(int p_from_id, int p_to_id); + PoolVector<int> get_id_path(int p_from_id, int p_to_id); AStar(); ~AStar(); diff --git a/core/math/bsp_tree.cpp b/core/math/bsp_tree.cpp index 5242abfa3b..b7194d7ffb 100644 --- a/core/math/bsp_tree.cpp +++ b/core/math/bsp_tree.cpp @@ -484,7 +484,7 @@ BSP_Tree::operator Variant() const { d["planes"]=plane_values; - DVector<int> dst_nodes; + PoolVector<int> dst_nodes; dst_nodes.resize(nodes.size()*3); for(int i=0;i<nodes.size();i++) { @@ -514,19 +514,19 @@ BSP_Tree::BSP_Tree(const Variant& p_variant) { ERR_FAIL_COND(!d.has("aabb")); ERR_FAIL_COND(!d.has("error_radius")); - DVector<int> src_nodes = d["nodes"]; + PoolVector<int> src_nodes = d["nodes"]; ERR_FAIL_COND(src_nodes.size()%3); if (d["planes"].get_type()==Variant::REAL_ARRAY) { - DVector<float> src_planes=d["planes"]; + PoolVector<float> src_planes=d["planes"]; int plane_count=src_planes.size(); ERR_FAIL_COND(plane_count%4); planes.resize(plane_count/4); if (plane_count) { - DVector<float>::Read r = src_planes.read(); + PoolVector<float>::Read r = src_planes.read(); for(int i=0;i<plane_count/4;i++) { planes[i].normal.x=r[i*4+0]; @@ -549,7 +549,7 @@ BSP_Tree::BSP_Tree(const Variant& p_variant) { // int node_count = src_nodes.size(); nodes.resize(src_nodes.size()/3); - DVector<int>::Read r = src_nodes.read(); + PoolVector<int>::Read r = src_nodes.read(); for(int i=0;i<nodes.size();i++) { @@ -560,12 +560,12 @@ BSP_Tree::BSP_Tree(const Variant& p_variant) { } -BSP_Tree::BSP_Tree(const DVector<Face3>& p_faces,float p_error_radius) { +BSP_Tree::BSP_Tree(const PoolVector<Face3>& p_faces,float p_error_radius) { // compute aabb int face_count=p_faces.size(); - DVector<Face3>::Read faces_r=p_faces.read(); + PoolVector<Face3>::Read faces_r=p_faces.read(); const Face3 *facesptr = faces_r.ptr(); diff --git a/core/math/bsp_tree.h b/core/math/bsp_tree.h index 3913e3d34a..236b6e5ac2 100644 --- a/core/math/bsp_tree.h +++ b/core/math/bsp_tree.h @@ -91,7 +91,7 @@ public: BSP_Tree(); BSP_Tree(const Variant& p_variant); - BSP_Tree(const DVector<Face3>& p_faces,float p_error_radius=0); + BSP_Tree(const PoolVector<Face3>& p_faces,float p_error_radius=0); BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const AABB& p_aabb,float p_error_radius=0); ~BSP_Tree(); diff --git a/core/math/geometry.cpp b/core/math/geometry.cpp index 91f7cf179a..3232d36262 100644 --- a/core/math/geometry.cpp +++ b/core/math/geometry.cpp @@ -204,21 +204,21 @@ static bool _group_face(_FaceClassify *p_faces, int len, int p_index,int p_group } -DVector< DVector< Face3 > > Geometry::separate_objects( DVector< Face3 > p_array ) { +PoolVector< PoolVector< Face3 > > Geometry::separate_objects( PoolVector< Face3 > p_array ) { - DVector< DVector< Face3 > > objects; + PoolVector< PoolVector< Face3 > > objects; int len = p_array.size(); - DVector<Face3>::Read r=p_array.read(); + PoolVector<Face3>::Read r=p_array.read(); const Face3* arrayptr = r.ptr(); - DVector< _FaceClassify> fc; + PoolVector< _FaceClassify> fc; fc.resize( len ); - DVector< _FaceClassify >::Write fcw=fc.write(); + PoolVector< _FaceClassify >::Write fcw=fc.write(); _FaceClassify * _fcptr = fcw.ptr(); @@ -231,7 +231,7 @@ DVector< DVector< Face3 > > Geometry::separate_objects( DVector< Face3 > p_array if (error) { - ERR_FAIL_COND_V(error, DVector< DVector< Face3 > >() ); // invalid geometry + ERR_FAIL_COND_V(error, PoolVector< PoolVector< Face3 > >() ); // invalid geometry } /* group connected faces in separate objects */ @@ -257,8 +257,8 @@ DVector< DVector< Face3 > > Geometry::separate_objects( DVector< Face3 > p_array if (group>=0) { objects.resize(group); - DVector< DVector<Face3> >::Write obw=objects.write(); - DVector< Face3 > *group_faces = obw.ptr(); + PoolVector< PoolVector<Face3> >::Write obw=objects.write(); + PoolVector< Face3 > *group_faces = obw.ptr(); for (int i=0;i<len;i++) { if (!_fcptr[i].valid) @@ -487,7 +487,7 @@ static inline void _mark_outside(uint8_t*** p_cell_status,int x,int y,int z,int } } -static inline void _build_faces(uint8_t*** p_cell_status,int x,int y,int z,int len_x,int len_y,int len_z,DVector<Face3>& p_faces) { +static inline void _build_faces(uint8_t*** p_cell_status,int x,int y,int z,int len_x,int len_y,int len_z,PoolVector<Face3>& p_faces) { ERR_FAIL_INDEX(x,len_x); ERR_FAIL_INDEX(y,len_y); @@ -580,13 +580,13 @@ static inline void _build_faces(uint8_t*** p_cell_status,int x,int y,int z,int l } -DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_error ) { +PoolVector< Face3 > Geometry::wrap_geometry( PoolVector< Face3 > p_array,float *p_error ) { #define _MIN_SIZE 1.0 #define _MAX_LENGTH 20 int face_count=p_array.size(); - DVector<Face3>::Read facesr=p_array.read(); + PoolVector<Face3>::Read facesr=p_array.read(); const Face3 *faces = facesr.ptr(); AABB global_aabb; @@ -696,7 +696,7 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro //print_line("Wrapper (3/6): Building Faces"); - DVector<Face3> wrapped_faces; + PoolVector<Face3> wrapped_faces; for (int i=0;i<div_x;i++) { @@ -714,7 +714,7 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro // transform face vertices to global coords int wrapped_faces_count=wrapped_faces.size(); - DVector<Face3>::Write wrapped_facesw=wrapped_faces.write(); + PoolVector<Face3>::Write wrapped_facesw=wrapped_faces.write(); Face3* wrapped_faces_ptr=wrapped_facesw.ptr(); for(int i=0;i<wrapped_faces_count;i++) { @@ -748,7 +748,7 @@ DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_erro return wrapped_faces; } -Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) { +Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes) { MeshData mesh; @@ -896,9 +896,9 @@ Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) { } -DVector<Plane> Geometry::build_box_planes(const Vector3& p_extents) { +PoolVector<Plane> Geometry::build_box_planes(const Vector3& p_extents) { - DVector<Plane> planes; + PoolVector<Plane> planes; planes.push_back( Plane( Vector3(1,0,0), p_extents.x ) ); planes.push_back( Plane( Vector3(-1,0,0), p_extents.x ) ); @@ -910,9 +910,9 @@ DVector<Plane> Geometry::build_box_planes(const Vector3& p_extents) { return planes; } -DVector<Plane> Geometry::build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis) { +PoolVector<Plane> Geometry::build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis) { - DVector<Plane> planes; + PoolVector<Plane> planes; for (int i=0;i<p_sides;i++) { @@ -933,10 +933,10 @@ DVector<Plane> Geometry::build_cylinder_planes(float p_radius, float p_height, i } -DVector<Plane> Geometry::build_sphere_planes(float p_radius, int p_lats,int p_lons, Vector3::Axis p_axis) { +PoolVector<Plane> Geometry::build_sphere_planes(float p_radius, int p_lats,int p_lons, Vector3::Axis p_axis) { - DVector<Plane> planes; + PoolVector<Plane> planes; Vector3 axis; axis[p_axis]=1.0; @@ -969,9 +969,9 @@ DVector<Plane> Geometry::build_sphere_planes(float p_radius, int p_lats,int p_lo } -DVector<Plane> Geometry::build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis) { +PoolVector<Plane> Geometry::build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis) { - DVector<Plane> planes; + PoolVector<Plane> planes; Vector3 axis; axis[p_axis]=1.0; diff --git a/core/math/geometry.h b/core/math/geometry.h index dae556cd09..9800e5513c 100644 --- a/core/math/geometry.h +++ b/core/math/geometry.h @@ -808,9 +808,9 @@ public: } - static DVector< DVector< Face3 > > separate_objects( DVector< Face3 > p_array ); + static PoolVector< PoolVector< Face3 > > separate_objects( PoolVector< Face3 > p_array ); - static DVector< Face3 > wrap_geometry( DVector< Face3 > p_array, float *p_error=NULL ); ///< create a "wrap" that encloses the given geometry + static PoolVector< Face3 > wrap_geometry( PoolVector< Face3 > p_array, float *p_error=NULL ); ///< create a "wrap" that encloses the given geometry struct MeshData { @@ -919,11 +919,11 @@ public: return H; } - static MeshData build_convex_mesh(const DVector<Plane> &p_planes); - static DVector<Plane> build_sphere_planes(float p_radius, int p_lats, int p_lons, Vector3::Axis p_axis=Vector3::AXIS_Z); - static DVector<Plane> build_box_planes(const Vector3& p_extents); - static DVector<Plane> build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis=Vector3::AXIS_Z); - static DVector<Plane> build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis=Vector3::AXIS_Z); + static MeshData build_convex_mesh(const PoolVector<Plane> &p_planes); + static PoolVector<Plane> build_sphere_planes(float p_radius, int p_lats, int p_lons, Vector3::Axis p_axis=Vector3::AXIS_Z); + static PoolVector<Plane> build_box_planes(const Vector3& p_extents); + static PoolVector<Plane> build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis=Vector3::AXIS_Z); + static PoolVector<Plane> build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis=Vector3::AXIS_Z); static void make_atlas(const Vector<Size2i>& p_rects,Vector<Point2i>& r_result, Size2i& r_size); diff --git a/core/math/triangle_mesh.cpp b/core/math/triangle_mesh.cpp index b3daee0c7e..101e164eae 100644 --- a/core/math/triangle_mesh.cpp +++ b/core/math/triangle_mesh.cpp @@ -94,7 +94,7 @@ int TriangleMesh::_create_bvh(BVH*p_bvh,BVH** p_bb,int p_from,int p_size,int p_d } -void TriangleMesh::create(const DVector<Vector3>& p_faces) { +void TriangleMesh::create(const PoolVector<Vector3>& p_faces) { valid=false; @@ -104,7 +104,7 @@ void TriangleMesh::create(const DVector<Vector3>& p_faces) { triangles.resize(fc); bvh.resize(fc*3); //will never be larger than this (todo make better) - DVector<BVH>::Write bw = bvh.write(); + PoolVector<BVH>::Write bw = bvh.write(); { @@ -112,8 +112,8 @@ void TriangleMesh::create(const DVector<Vector3>& p_faces) { //except for the Set for repeated triangles, everything //goes in-place. - DVector<Vector3>::Read r = p_faces.read(); - DVector<Triangle>::Write w = triangles.write(); + PoolVector<Vector3>::Read r = p_faces.read(); + PoolVector<Triangle>::Write w = triangles.write(); Map<Vector3,int> db; for(int i=0;i<fc;i++) { @@ -149,16 +149,16 @@ void TriangleMesh::create(const DVector<Vector3>& p_faces) { } vertices.resize(db.size()); - DVector<Vector3>::Write vw = vertices.write(); + PoolVector<Vector3>::Write vw = vertices.write(); for (Map<Vector3,int>::Element *E=db.front();E;E=E->next()) { vw[E->get()]=E->key(); } } - DVector<BVH*> bwptrs; + PoolVector<BVH*> bwptrs; bwptrs.resize(fc); - DVector<BVH*>::Write bwp = bwptrs.write(); + PoolVector<BVH*>::Write bwp = bwptrs.write(); for(int i=0;i<fc;i++) { bwp[i]=&bw[i]; @@ -168,7 +168,7 @@ void TriangleMesh::create(const DVector<Vector3>& p_faces) { int max_alloc=fc; int max=_create_bvh(bw.ptr(),bwp.ptr(),0,fc,1,max_depth,max_alloc); - bw=DVector<BVH>::Write(); //clearup + bw=PoolVector<BVH>::Write(); //clearup bvh.resize(max_alloc); //resize back valid=true; @@ -197,9 +197,9 @@ Vector3 TriangleMesh::get_area_normal(const AABB& p_aabb) const { int level=0; - DVector<Triangle>::Read trianglesr = triangles.read(); - DVector<Vector3>::Read verticesr=vertices.read(); - DVector<BVH>::Read bvhr=bvh.read(); + PoolVector<Triangle>::Read trianglesr = triangles.read(); + PoolVector<Vector3>::Read verticesr=vertices.read(); + PoolVector<BVH>::Read bvhr=bvh.read(); const Triangle *triangleptr=trianglesr.ptr(); int pos=bvh.size()-1; @@ -299,9 +299,9 @@ bool TriangleMesh::intersect_segment(const Vector3& p_begin,const Vector3& p_end int level=0; - DVector<Triangle>::Read trianglesr = triangles.read(); - DVector<Vector3>::Read verticesr=vertices.read(); - DVector<BVH>::Read bvhr=bvh.read(); + PoolVector<Triangle>::Read trianglesr = triangles.read(); + PoolVector<Vector3>::Read verticesr=vertices.read(); + PoolVector<BVH>::Read bvhr=bvh.read(); const Triangle *triangleptr=trianglesr.ptr(); const Vector3 *vertexptr=verticesr.ptr(); @@ -422,9 +422,9 @@ bool TriangleMesh::intersect_ray(const Vector3& p_begin,const Vector3& p_dir,Vec int level=0; - DVector<Triangle>::Read trianglesr = triangles.read(); - DVector<Vector3>::Read verticesr=vertices.read(); - DVector<BVH>::Read bvhr=bvh.read(); + PoolVector<Triangle>::Read trianglesr = triangles.read(); + PoolVector<Vector3>::Read verticesr=vertices.read(); + PoolVector<BVH>::Read bvhr=bvh.read(); const Triangle *triangleptr=trianglesr.ptr(); const Vector3 *vertexptr=verticesr.ptr(); @@ -524,18 +524,18 @@ bool TriangleMesh::is_valid() const { return valid; } -DVector<Face3> TriangleMesh::get_faces() const { +PoolVector<Face3> TriangleMesh::get_faces() const { if (!valid) - return DVector<Face3>(); + return PoolVector<Face3>(); - DVector<Face3> faces; + PoolVector<Face3> faces; int ts = triangles.size(); faces.resize(triangles.size()); - DVector<Face3>::Write w=faces.write(); - DVector<Triangle>::Read r = triangles.read(); - DVector<Vector3>::Read rv = vertices.read(); + PoolVector<Face3>::Write w=faces.write(); + PoolVector<Triangle>::Read r = triangles.read(); + PoolVector<Vector3>::Read rv = vertices.read(); for(int i=0;i<ts;i++) { for(int j=0;j<3;j++) { @@ -543,7 +543,7 @@ DVector<Face3> TriangleMesh::get_faces() const { } } - w = DVector<Face3>::Write(); + w = PoolVector<Face3>::Write(); return faces; } diff --git a/core/math/triangle_mesh.h b/core/math/triangle_mesh.h index d42f9c8dde..37d32bd7ec 100644 --- a/core/math/triangle_mesh.h +++ b/core/math/triangle_mesh.h @@ -41,8 +41,8 @@ class TriangleMesh : public Reference { int indices[3]; }; - DVector<Triangle> triangles; - DVector<Vector3> vertices; + PoolVector<Triangle> triangles; + PoolVector<Vector3> vertices; struct BVH { @@ -79,7 +79,7 @@ class TriangleMesh : public Reference { int _create_bvh(BVH*p_bvh,BVH** p_bb,int p_from,int p_size,int p_depth,int&max_depth,int&max_alloc); - DVector<BVH> bvh; + PoolVector<BVH> bvh; int max_depth; bool valid; @@ -89,10 +89,10 @@ public: bool intersect_segment(const Vector3& p_begin,const Vector3& p_end,Vector3 &r_point, Vector3 &r_normal) const; bool intersect_ray(const Vector3& p_begin,const Vector3& p_dir,Vector3 &r_point, Vector3 &r_normal) const; Vector3 get_area_normal(const AABB& p_aabb) const; - DVector<Face3> get_faces() const; + PoolVector<Face3> get_faces() const; - void create(const DVector<Vector3>& p_faces); + void create(const PoolVector<Vector3>& p_faces); TriangleMesh(); }; diff --git a/core/method_ptrcall.h b/core/method_ptrcall.h index e38d59fd8f..2e3959c3ab 100644 --- a/core/method_ptrcall.h +++ b/core/method_ptrcall.h @@ -133,12 +133,12 @@ struct PtrToArg< const T* > { template<>\ struct PtrToArg<Vector<m_type> > {\ _FORCE_INLINE_ static Vector<m_type> convert(const void* p_ptr) {\ - const DVector<m_type> *dvs = reinterpret_cast<const DVector<m_type> *>(p_ptr);\ + const PoolVector<m_type> *dvs = reinterpret_cast<const PoolVector<m_type> *>(p_ptr);\ Vector<m_type> ret;\ int len = dvs->size();\ ret.resize(len);\ {\ - DVector<m_type>::Read r=dvs->read();\ + PoolVector<m_type>::Read r=dvs->read();\ for(int i=0;i<len;i++) {\ ret[i]=r[i];\ }\ @@ -146,11 +146,11 @@ struct PtrToArg<Vector<m_type> > {\ return ret;\ }\ _FORCE_INLINE_ static void encode(Vector<m_type> p_vec, void* p_ptr) {\ - DVector<m_type> *dv = reinterpret_cast<DVector<m_type> *>(p_ptr);\ + PoolVector<m_type> *dv = reinterpret_cast<PoolVector<m_type> *>(p_ptr);\ int len=p_vec.size();\ dv->resize(len);\ {\ - DVector<m_type>::Write w=dv->write();\ + PoolVector<m_type>::Write w=dv->write();\ for(int i=0;i<len;i++) {\ w[i]=p_vec[i];\ }\ @@ -160,12 +160,12 @@ struct PtrToArg<Vector<m_type> > {\ template<>\ struct PtrToArg<const Vector<m_type>& > {\ _FORCE_INLINE_ static Vector<m_type> convert(const void* p_ptr) {\ - const DVector<m_type> *dvs = reinterpret_cast<const DVector<m_type> *>(p_ptr);\ + const PoolVector<m_type> *dvs = reinterpret_cast<const PoolVector<m_type> *>(p_ptr);\ Vector<m_type> ret;\ int len = dvs->size();\ ret.resize(len);\ {\ - DVector<m_type>::Read r=dvs->read();\ + PoolVector<m_type>::Read r=dvs->read();\ for(int i=0;i<len;i++) {\ ret[i]=r[i];\ }\ @@ -226,26 +226,26 @@ MAKE_VECARR(Plane); #define MAKE_DVECARR(m_type) \ template<>\ -struct PtrToArg<DVector<m_type> > {\ - _FORCE_INLINE_ static DVector<m_type> convert(const void* p_ptr) {\ +struct PtrToArg<PoolVector<m_type> > {\ + _FORCE_INLINE_ static PoolVector<m_type> convert(const void* p_ptr) {\ const Array *arr = reinterpret_cast<const Array *>(p_ptr);\ - DVector<m_type> ret;\ + PoolVector<m_type> ret;\ int len = arr->size();\ ret.resize(len);\ {\ - DVector<m_type>::Write w=ret.write();\ + PoolVector<m_type>::Write w=ret.write();\ for(int i=0;i<len;i++) {\ w[i]=(*arr)[i];\ }\ }\ return ret;\ }\ - _FORCE_INLINE_ static void encode(DVector<m_type> p_vec, void* p_ptr) {\ + _FORCE_INLINE_ static void encode(PoolVector<m_type> p_vec, void* p_ptr) {\ Array *arr = reinterpret_cast<Array *>(p_ptr);\ int len = p_vec.size();\ arr->resize(len);\ {\ - DVector<m_type>::Read r=p_vec.read();\ + PoolVector<m_type>::Read r=p_vec.read();\ for(int i=0;i<len;i++) {\ (*arr)[i]=r[i];\ }\ @@ -253,14 +253,14 @@ struct PtrToArg<DVector<m_type> > {\ } \ };\ template<>\ -struct PtrToArg<const DVector<m_type>& > {\ - _FORCE_INLINE_ static DVector<m_type> convert(const void* p_ptr) {\ +struct PtrToArg<const PoolVector<m_type>& > {\ + _FORCE_INLINE_ static PoolVector<m_type> convert(const void* p_ptr) {\ const Array *arr = reinterpret_cast<const Array *>(p_ptr);\ - DVector<m_type> ret;\ + PoolVector<m_type> ret;\ int len = arr->size();\ ret.resize(len);\ {\ - DVector<m_type>::Write w=ret.write();\ + PoolVector<m_type>::Write w=ret.write();\ for(int i=0;i<len;i++) {\ w[i]=(*arr)[i];\ }\ @@ -297,15 +297,15 @@ MAKE_STRINGCONV(StringName); MAKE_STRINGCONV(IP_Address); template<> -struct PtrToArg<DVector<Face3> > { - _FORCE_INLINE_ static DVector<Face3> convert(const void* p_ptr) { - const DVector<Vector3> *dvs = reinterpret_cast<const DVector<Vector3> *>(p_ptr); - DVector<Face3> ret; +struct PtrToArg<PoolVector<Face3> > { + _FORCE_INLINE_ static PoolVector<Face3> convert(const void* p_ptr) { + const PoolVector<Vector3> *dvs = reinterpret_cast<const PoolVector<Vector3> *>(p_ptr); + PoolVector<Face3> ret; int len = dvs->size()/3; ret.resize(len); { - DVector<Vector3>::Read r=dvs->read(); - DVector<Face3>::Write w=ret.write(); + PoolVector<Vector3>::Read r=dvs->read(); + PoolVector<Face3>::Write w=ret.write(); for(int i=0;i<len;i++) { w[i].vertex[0]=r[i*3+0]; w[i].vertex[1]=r[i*3+1]; @@ -314,13 +314,13 @@ struct PtrToArg<DVector<Face3> > { } return ret; } - _FORCE_INLINE_ static void encode(DVector<Face3> p_vec, void* p_ptr) {\ - DVector<Vector3> *arr = reinterpret_cast<DVector<Vector3> *>(p_ptr);\ + _FORCE_INLINE_ static void encode(PoolVector<Face3> p_vec, void* p_ptr) {\ + PoolVector<Vector3> *arr = reinterpret_cast<PoolVector<Vector3> *>(p_ptr);\ int len = p_vec.size();\ arr->resize(len*3);\ {\ - DVector<Face3>::Read r=p_vec.read();\ - DVector<Vector3>::Write w=arr->write();\ + PoolVector<Face3>::Read r=p_vec.read();\ + PoolVector<Vector3>::Write w=arr->write();\ for(int i=0;i<len;i++) {\ w[i*3+0]=r[i].vertex[0];\ w[i*3+1]=r[i].vertex[1];\ @@ -330,15 +330,15 @@ struct PtrToArg<DVector<Face3> > { } \ }; template<> -struct PtrToArg<const DVector<Face3>& > { - _FORCE_INLINE_ static DVector<Face3> convert(const void* p_ptr) { - const DVector<Vector3> *dvs = reinterpret_cast<const DVector<Vector3> *>(p_ptr); - DVector<Face3> ret; +struct PtrToArg<const PoolVector<Face3>& > { + _FORCE_INLINE_ static PoolVector<Face3> convert(const void* p_ptr) { + const PoolVector<Vector3> *dvs = reinterpret_cast<const PoolVector<Vector3> *>(p_ptr); + PoolVector<Face3> ret; int len = dvs->size()/3; ret.resize(len); { - DVector<Vector3>::Read r=dvs->read(); - DVector<Face3>::Write w=ret.write(); + PoolVector<Vector3>::Read r=dvs->read(); + PoolVector<Face3>::Write w=ret.write(); for(int i=0;i<len;i++) { w[i].vertex[0]=r[i*3+0]; w[i].vertex[1]=r[i*3+1]; diff --git a/core/object.cpp b/core/object.cpp index 82377013e1..0f9b112ad2 100644 --- a/core/object.cpp +++ b/core/object.cpp @@ -1112,9 +1112,9 @@ Array Object::_get_method_list_bind() const { } -DVector<String> Object::_get_meta_list_bind() const { +PoolVector<String> Object::_get_meta_list_bind() const { - DVector<String> _metaret; + PoolVector<String> _metaret; List<Variant> keys; metadata.get_key_list(&keys); @@ -1942,27 +1942,37 @@ uint32_t ObjectDB::instance_counter=1; HashMap<Object*,ObjectID,ObjectDB::ObjectPtrHash> ObjectDB::instance_checks; uint32_t ObjectDB::add_instance(Object *p_object) { - GLOBAL_LOCK_FUNCTION; + ERR_FAIL_COND_V( p_object->get_instance_ID()!=0, 0 ); + + rw_lock->write_lock(); instances[++instance_counter]=p_object; #ifdef DEBUG_ENABLED instance_checks[p_object]=instance_counter; #endif + rw_lock->write_unlock(); + return instance_counter; } void ObjectDB::remove_instance(Object *p_object) { - GLOBAL_LOCK_FUNCTION; + + rw_lock->write_lock(); + instances.erase( p_object->get_instance_ID() ); #ifdef DEBUG_ENABLED instance_checks.erase(p_object); #endif + + rw_lock->write_unlock(); } Object *ObjectDB::get_instance(uint32_t p_instance_ID) { - GLOBAL_LOCK_FUNCTION; + rw_lock->read_lock(); Object**obj=instances.getptr(p_instance_ID); + rw_lock->read_unlock(); + if (!obj) return NULL; return *obj; @@ -1970,13 +1980,16 @@ Object *ObjectDB::get_instance(uint32_t p_instance_ID) { void ObjectDB::debug_objects(DebugFunc p_func) { - GLOBAL_LOCK_FUNCTION; + rw_lock->read_lock(); const uint32_t *K=NULL; while((K=instances.next(K))) { p_func(instances[*K]); } + + rw_lock->read_unlock(); + } @@ -1987,15 +2000,26 @@ void Object::get_argument_options(const StringName& p_function,int p_idx,List<St int ObjectDB::get_object_count() { - GLOBAL_LOCK_FUNCTION; - return instances.size(); + rw_lock->read_lock(); + int count =instances.size(); + rw_lock->read_unlock(); + + return count; + +} + +RWLock *ObjectDB::rw_lock=NULL; + +void ObjectDB::setup() { + + rw_lock = RWLock::create(); } void ObjectDB::cleanup() { - GLOBAL_LOCK_FUNCTION; + rw_lock->write_lock(); if (instances.size()) { WARN_PRINT("ObjectDB Instances still exist!"); @@ -2014,4 +2038,7 @@ void ObjectDB::cleanup() { } instances.clear(); instance_checks.clear(); + rw_lock->write_unlock(); + + memdelete(rw_lock); } diff --git a/core/object.h b/core/object.h index 6dd427bf41..7c74f70518 100644 --- a/core/object.h +++ b/core/object.h @@ -34,6 +34,7 @@ #include "set.h" #include "map.h" #include "vmap.h" +#include "os/rw_lock.h" #define VARIANT_ARG_LIST const Variant& p_arg1=Variant(),const Variant& p_arg2=Variant(),const Variant& p_arg3=Variant(),const Variant& p_arg4=Variant(),const Variant& p_arg5=Variant() #define VARIANT_ARG_PASS p_arg1,p_arg2,p_arg3,p_arg4,p_arg5 @@ -481,7 +482,7 @@ protected: return &_class_name; } - DVector<String> _get_meta_list_bind() const; + PoolVector<String> _get_meta_list_bind() const; Array _get_property_list_bind() const; Array _get_method_list_bind() const; @@ -686,9 +687,14 @@ class ObjectDB { friend class Object; friend void unregister_core_types(); + + static RWLock *rw_lock; static void cleanup(); static uint32_t add_instance(Object *p_object); static void remove_instance(Object *p_object); +friend void register_core_types(); + static void setup(); + public: typedef void (*DebugFunc)(Object *p_obj); diff --git a/core/object_type_db.cpp b/core/object_type_db.cpp index 94cc865b62..7432c09563 100644 --- a/core/object_type_db.cpp +++ b/core/object_type_db.cpp @@ -31,11 +31,12 @@ #ifdef NO_THREADS -#define OBJTYPE_LOCK +#define OBJTYPE_RLOCK #else -#define OBJTYPE_LOCK MutexLock _mutex_lock_(lock); +#define OBJTYPE_RLOCK RWLockRead _rw_lockr_(lock); +#define OBJTYPE_WLOCK RWLockWrite _rw_lockw_(lock); #endif @@ -215,7 +216,7 @@ ClassDB::ClassInfo::~ClassInfo() { bool ClassDB::is_parent_class(const StringName &p_class,const StringName& p_inherits) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; StringName inherits=p_class; @@ -230,7 +231,7 @@ bool ClassDB::is_parent_class(const StringName &p_class,const StringName& p_inhe } void ClassDB::get_class_list( List<StringName> *p_classes) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; const StringName *k=NULL; @@ -245,7 +246,7 @@ void ClassDB::get_class_list( List<StringName> *p_classes) { void ClassDB::get_inheriters_from_class( const StringName& p_class,List<StringName> *p_classes) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; const StringName *k=NULL; @@ -259,7 +260,7 @@ void ClassDB::get_inheriters_from_class( const StringName& p_class,List<StringNa StringName ClassDB::get_parent_class(const StringName& p_class) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ClassInfo *ti = classes.getptr(p_class); ERR_FAIL_COND_V(!ti,""); @@ -268,7 +269,7 @@ StringName ClassDB::get_parent_class(const StringName& p_class) { ClassDB::APIType ClassDB::get_api_type(const StringName &p_class) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ClassInfo *ti = classes.getptr(p_class); ERR_FAIL_COND_V(!ti,API_NONE); @@ -277,6 +278,7 @@ ClassDB::APIType ClassDB::get_api_type(const StringName &p_class) { uint64_t ClassDB::get_api_hash(APIType p_api) { + OBJTYPE_RLOCK; #ifdef DEBUG_METHODS_ENABLED uint64_t hash = hash_djb2_one_64(HashMapHahserDefault::hash(VERSION_FULL_NAME)); @@ -433,12 +435,13 @@ uint64_t ClassDB::get_api_hash(APIType p_api) { bool ClassDB::class_exists(const StringName &p_class) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; return classes.has(p_class); } void ClassDB::add_compatibility_class(const StringName& p_class,const StringName& p_fallback) { + OBJTYPE_WLOCK; compat_classes[p_class]=p_fallback; } @@ -446,7 +449,7 @@ Object *ClassDB::instance(const StringName &p_class) { ClassInfo *ti; { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ti=classes.getptr(p_class); if (!ti || ti->disabled || !ti->creation_func) { if (compat_classes.has(p_class)) { @@ -462,7 +465,7 @@ Object *ClassDB::instance(const StringName &p_class) { } bool ClassDB::can_instance(const StringName &p_class) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ClassInfo *ti = classes.getptr(p_class); ERR_FAIL_COND_V(!ti,false); @@ -472,7 +475,7 @@ bool ClassDB::can_instance(const StringName &p_class) { void ClassDB::_add_class2(const StringName& p_class, const StringName& p_inherits) { - OBJTYPE_LOCK; + OBJTYPE_WLOCK; StringName name = p_class; @@ -499,7 +502,7 @@ void ClassDB::_add_class2(const StringName& p_class, const StringName& p_inherit void ClassDB::get_method_list(StringName p_class,List<MethodInfo> *p_methods,bool p_no_inheritance) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ClassInfo *type=classes.getptr(p_class); @@ -572,7 +575,7 @@ void ClassDB::get_method_list(StringName p_class,List<MethodInfo> *p_methods,boo MethodBind *ClassDB::get_method(StringName p_class, StringName p_name) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ClassInfo *type=classes.getptr(p_class); @@ -589,7 +592,7 @@ MethodBind *ClassDB::get_method(StringName p_class, StringName p_name) { void ClassDB::bind_integer_constant(const StringName& p_class, const StringName &p_name, int p_constant) { - OBJTYPE_LOCK; + OBJTYPE_WLOCK; ClassInfo *type=classes.getptr(p_class); if (!type) { @@ -611,7 +614,7 @@ void ClassDB::bind_integer_constant(const StringName& p_class, const StringName void ClassDB::get_integer_constant_list(const StringName& p_class, List<String> *p_constants, bool p_no_inheritance) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ClassInfo *type=classes.getptr(p_class); @@ -639,7 +642,7 @@ void ClassDB::get_integer_constant_list(const StringName& p_class, List<String> int ClassDB::get_integer_constant(const StringName& p_class, const StringName &p_name, bool *p_success) { - OBJTYPE_LOCK; + OBJTYPE_RLOCK; ClassInfo *type=classes.getptr(p_class); @@ -666,6 +669,8 @@ int ClassDB::get_integer_constant(const StringName& p_class, const StringName &p void ClassDB::add_signal(StringName p_class,const MethodInfo& p_signal) { + OBJTYPE_WLOCK; + ClassInfo *type=classes.getptr(p_class); ERR_FAIL_COND(!type); @@ -688,6 +693,8 @@ void ClassDB::add_signal(StringName p_class,const MethodInfo& p_signal) { void ClassDB::get_signal_list(StringName p_class,List<MethodInfo> *p_signals,bool p_no_inheritance) { + OBJTYPE_RLOCK; + ClassInfo *type=classes.getptr(p_class); ERR_FAIL_COND(!type); @@ -712,6 +719,7 @@ void ClassDB::get_signal_list(StringName p_class,List<MethodInfo> *p_signals,boo bool ClassDB::has_signal(StringName p_class,StringName p_signal) { + OBJTYPE_RLOCK; ClassInfo *type=classes.getptr(p_class); ClassInfo *check=type; while(check) { @@ -725,6 +733,7 @@ bool ClassDB::has_signal(StringName p_class,StringName p_signal) { bool ClassDB::get_signal(StringName p_class,StringName p_signal,MethodInfo *r_signal) { + OBJTYPE_RLOCK; ClassInfo *type=classes.getptr(p_class); ClassInfo *check=type; while(check) { @@ -743,6 +752,7 @@ bool ClassDB::get_signal(StringName p_class,StringName p_signal,MethodInfo *r_si void ClassDB::add_property_group(StringName p_class,const String& p_name,const String& p_prefix) { + OBJTYPE_WLOCK; ClassInfo *type=classes.getptr(p_class); ERR_FAIL_COND(!type); @@ -752,7 +762,13 @@ void ClassDB::add_property_group(StringName p_class,const String& p_name,const S void ClassDB::add_property(StringName p_class,const PropertyInfo& p_pinfo, const StringName& p_setter, const StringName& p_getter, int p_index) { + + lock->read_lock(); + ClassInfo *type=classes.getptr(p_class); + + lock->read_unlock(); + ERR_FAIL_COND(!type); MethodBind *mb_set=NULL; @@ -804,6 +820,9 @@ void ClassDB::add_property(StringName p_class,const PropertyInfo& p_pinfo, const ERR_FAIL(); } #endif + + OBJTYPE_WLOCK + type->property_list.push_back(p_pinfo); PropertySetGet psg; @@ -821,6 +840,8 @@ void ClassDB::add_property(StringName p_class,const PropertyInfo& p_pinfo, const void ClassDB::get_property_list(StringName p_class, List<PropertyInfo> *p_list, bool p_no_inheritance,const Object *p_validator) { + OBJTYPE_RLOCK; + ClassInfo *type=classes.getptr(p_class); ClassInfo *check=type; while(check) { @@ -846,6 +867,7 @@ void ClassDB::get_property_list(StringName p_class, List<PropertyInfo> *p_list, bool ClassDB::set_property(Object* p_object,const StringName& p_property, const Variant& p_value,bool *r_valid) { + ClassInfo *type=classes.getptr(p_object->get_class_name()); ClassInfo *check=type; while(check) { @@ -1010,6 +1032,7 @@ bool ClassDB::has_property(const StringName& p_class, const StringName& p_proper void ClassDB::set_method_flags(StringName p_class,StringName p_method,int p_flags) { + OBJTYPE_WLOCK; ClassInfo *type=classes.getptr(p_class); ClassInfo *check=type; ERR_FAIL_COND(!check); @@ -1070,7 +1093,7 @@ MethodBind* ClassDB::bind_methodfi(uint32_t p_flags, MethodBind *p_bind , const } - OBJTYPE_LOCK; + OBJTYPE_WLOCK; ERR_FAIL_COND_V(!p_bind,NULL); p_bind->set_name(mdname); @@ -1114,6 +1137,8 @@ MethodBind* ClassDB::bind_methodfi(uint32_t p_flags, MethodBind *p_bind , const void ClassDB::add_virtual_method(const StringName& p_class, const MethodInfo& p_method , bool p_virtual) { ERR_FAIL_COND(!classes.has(p_class)); + OBJTYPE_WLOCK; + #ifdef DEBUG_METHODS_ENABLED MethodInfo mi=p_method; if (p_virtual) @@ -1149,12 +1174,16 @@ void ClassDB::get_virtual_methods(const StringName& p_class, List<MethodInfo> * void ClassDB::set_class_enabled(StringName p_class,bool p_enable) { + OBJTYPE_WLOCK; + ERR_FAIL_COND(!classes.has(p_class)); classes[p_class].disabled=!p_enable; } bool ClassDB::is_class_enabled(StringName p_class) { + OBJTYPE_RLOCK; + ClassInfo *ti=classes.getptr(p_class); if (!ti || !ti->creation_func) { if (compat_classes.has(p_class)) { @@ -1206,23 +1235,19 @@ void ClassDB::get_extensions_for_type(const StringName& p_class,List<String> *p_ } -Mutex *ClassDB::lock=NULL; +RWLock *ClassDB::lock=NULL; void ClassDB::init() { #ifndef NO_THREADS - lock = Mutex::create(); + lock = RWLock::create(); #endif } void ClassDB::cleanup() { -#ifndef NO_THREADS - - memdelete(lock); -#endif //OBJTYPE_LOCK; hah not here @@ -1241,6 +1266,12 @@ void ClassDB::cleanup() { classes.clear(); resource_base_extensions.clear(); compat_classes.clear(); + +#ifndef NO_THREADS + + memdelete(lock); +#endif + } // diff --git a/core/object_type_db.h b/core/object_type_db.h index 3613d351e4..158a4dae23 100644 --- a/core/object_type_db.h +++ b/core/object_type_db.h @@ -156,7 +156,7 @@ public: return memnew( T ); } - static Mutex *lock; + static RWLock *lock; static HashMap<StringName,ClassInfo,StringNameHasher> classes; static HashMap<StringName,StringName,StringNameHasher> resource_base_extensions; static HashMap<StringName,StringName,StringNameHasher> compat_classes; diff --git a/core/os/memory.cpp b/core/os/memory.cpp index cf42c3681a..37a523b763 100644 --- a/core/os/memory.cpp +++ b/core/os/memory.cpp @@ -33,61 +33,6 @@ #include <stdlib.h> -MID::MID(MemoryPoolDynamic::ID p_id) { - - data = (Data*)memalloc(sizeof(Data)); - data->refcount.init(); - data->id=p_id; -} - -void MID::unref() { - - if (!data) - return; - if (data->refcount.unref()) { - - if (data->id!=MemoryPoolDynamic::INVALID_ID) - MemoryPoolDynamic::get_singleton()->free(data->id); - memfree(data); - } - - data=NULL; -} -Error MID::_resize(size_t p_size) { - - if (p_size==0 && (!data || data->id==MemoryPoolDynamic::INVALID_ID)) - return OK; - if (p_size && !data) { - // create data because we'll need it - data = (Data*)memalloc(sizeof(Data)); - ERR_FAIL_COND_V( !data,ERR_OUT_OF_MEMORY ); - data->refcount.init(); - data->id=MemoryPoolDynamic::INVALID_ID; - } - - if (p_size==0 && data && data->id==MemoryPoolDynamic::INVALID_ID) { - - MemoryPoolDynamic::get_singleton()->free(data->id); - data->id=MemoryPoolDynamic::INVALID_ID; - } - - if (p_size>0) { - - if (data->id==MemoryPoolDynamic::INVALID_ID) { - - data->id=MemoryPoolDynamic::get_singleton()->alloc(p_size,"Unnamed MID"); - ERR_FAIL_COND_V( data->id==MemoryPoolDynamic::INVALID_ID, ERR_OUT_OF_MEMORY ); - - } else { - - MemoryPoolDynamic::get_singleton()->realloc(data->id,p_size); - ERR_FAIL_COND_V( data->id==MemoryPoolDynamic::INVALID_ID, ERR_OUT_OF_MEMORY ); - - } - } - - return OK; -} void * operator new(size_t p_size,const char *p_description) { @@ -242,34 +187,6 @@ size_t Memory::get_mem_max_usage(){ } -MID Memory::alloc_dynamic(size_t p_bytes, const char *p_descr) { - - MemoryPoolDynamic::ID id = MemoryPoolDynamic::get_singleton()->alloc(p_bytes,p_descr); - - return MID(id); -} -Error Memory::realloc_dynamic(MID p_mid,size_t p_bytes) { - - MemoryPoolDynamic::ID id = p_mid.data?p_mid.data->id:MemoryPoolDynamic::INVALID_ID; - - if (id==MemoryPoolDynamic::INVALID_ID) - return ERR_INVALID_PARAMETER; - - return MemoryPoolDynamic::get_singleton()->realloc(p_mid, p_bytes); - -} - -size_t Memory::get_dynamic_mem_available() { - - return MemoryPoolDynamic::get_singleton()->get_available_mem(); -} - -size_t Memory::get_dynamic_mem_usage() { - - return MemoryPoolDynamic::get_singleton()->get_total_usage(); -} - - _GlobalNil::_GlobalNil() { diff --git a/core/os/memory.h b/core/os/memory.h index 6a939e3d6f..0e6dea48d3 100644 --- a/core/os/memory.h +++ b/core/os/memory.h @@ -31,8 +31,6 @@ #include <stddef.h> #include "safe_refcount.h" -#include "os/memory_pool_dynamic.h" - /** @@ -44,88 +42,6 @@ #endif -class MID { - - struct Data { - - SafeRefCount refcount; - MemoryPoolDynamic::ID id; - }; - - mutable Data *data; - - - - void ref(Data *p_data) { - - if (data==p_data) - return; - unref(); - - if (p_data && p_data->refcount.ref()) - data=p_data; - } - -friend class MID_Lock; - - inline void lock() { - - if (data && data->id!=MemoryPoolDynamic::INVALID_ID) - MemoryPoolDynamic::get_singleton()->lock(data->id); - } - inline void unlock() { - - if (data && data->id!=MemoryPoolDynamic::INVALID_ID) - MemoryPoolDynamic::get_singleton()->unlock(data->id); - - } - - inline void * get() { - - if (data && data->id!=MemoryPoolDynamic::INVALID_ID) - return MemoryPoolDynamic::get_singleton()->get(data->id); - - return NULL; - } - - - void unref(); - Error _resize(size_t p_size); - -friend class Memory; - - MID(MemoryPoolDynamic::ID p_id); -public: - - bool is_valid() const { return data; } - operator bool() const { return data; } - - - size_t get_size() const { return (data && data->id!=MemoryPoolDynamic::INVALID_ID) ? MemoryPoolDynamic::get_singleton()->get_size(data->id) : 0; } - Error resize(size_t p_size) { return _resize(p_size); } - inline void operator=(const MID& p_mid) { ref( p_mid.data ); } - inline bool is_locked() const { return (data && data->id!=MemoryPoolDynamic::INVALID_ID) ? MemoryPoolDynamic::get_singleton()->is_locked(data->id) : false; } - inline MID(const MID& p_mid) { data=NULL; ref( p_mid.data ); } - inline MID() { data = NULL; } - ~MID() { unref(); } -}; - - -class MID_Lock { - - MID mid; - -public: - - void *data() { return mid.get(); } - - void operator=(const MID_Lock& p_lock ) { mid.unlock(); mid = p_lock.mid; mid.lock(); } - inline MID_Lock(const MID& p_mid) { mid=p_mid; mid.lock(); } - inline MID_Lock(const MID_Lock& p_lock) { mid=p_lock.mid; mid.lock(); } - MID_Lock() {} - ~MID_Lock() { mid.unlock(); } -}; - class Memory{ @@ -148,12 +64,6 @@ public: static size_t get_mem_max_usage(); - static MID alloc_dynamic(size_t p_bytes, const char *p_descr=""); - static Error realloc_dynamic(MID p_mid,size_t p_bytes); - - static size_t get_dynamic_mem_available(); - static size_t get_dynamic_mem_usage(); - }; class DefaultAllocator { @@ -174,18 +84,6 @@ void * operator new(size_t p_size,void *p_pointer,size_t check, const char *p_de #define memfree(m_size) Memory::free_static(m_size) -#ifdef DEBUG_MEMORY_ENABLED -#define dynalloc(m_size) Memory::alloc_dynamic(m_size, __FILE__ ":" __STR(__LINE__) ", type: DYNAMIC") -#define dynrealloc(m_mem,m_size) m_mem.resize(m_size) - -#else - -#define dynalloc(m_size) Memory::alloc_dynamic(m_size) -#define dynrealloc(m_mem,m_size) m_mem.resize(m_size) - -#endif - - _ALWAYS_INLINE_ void postinitialize_handler(void *) {} @@ -241,7 +139,7 @@ T* memnew_arr_template(size_t p_elements,const char *p_descr="") { if (p_elements==0) return 0; /** overloading operator new[] cannot be done , because it may not return the real allocated address (it may pad the 'element count' before the actual array). Because of that, it must be done by hand. This is the - same strategy used by std::vector, and the DVector class, so it should be safe.*/ + same strategy used by std::vector, and the PoolVector class, so it should be safe.*/ size_t len = sizeof(T) * p_elements; uint64_t *mem = (uint64_t*)Memory::alloc_static( len , true ); diff --git a/core/os/memory_pool_dynamic.cpp b/core/os/memory_pool_dynamic.cpp deleted file mode 100644 index 0bd64a0362..0000000000 --- a/core/os/memory_pool_dynamic.cpp +++ /dev/null @@ -1,50 +0,0 @@ -/*************************************************************************/ -/* memory_pool_dynamic.cpp */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#include "memory_pool_dynamic.h" - - -MemoryPoolDynamic* MemoryPoolDynamic::singleton=NULL; - - -MemoryPoolDynamic* MemoryPoolDynamic::get_singleton() { - - return singleton; -} - - -MemoryPoolDynamic::MemoryPoolDynamic() { - - ERR_FAIL_COND(singleton!=NULL); - singleton=this; -} - -MemoryPoolDynamic::~MemoryPoolDynamic() { - - singleton=NULL; -} diff --git a/core/os/memory_pool_dynamic.h b/core/os/memory_pool_dynamic.h deleted file mode 100644 index 025e925d3c..0000000000 --- a/core/os/memory_pool_dynamic.h +++ /dev/null @@ -1,79 +0,0 @@ -/*************************************************************************/ -/* memory_pool_dynamic.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef MEMORY_POOL_DYNAMIC_H -#define MEMORY_POOL_DYNAMIC_H - -#include "typedefs.h" - - -class MemoryPoolDynamic { - - static MemoryPoolDynamic* singleton; -protected: -friend class Memory; -friend class MID; - - enum { - - INVALID_ID=0xFFFFFFFF - }; - - static MemoryPoolDynamic* get_singleton(); - - typedef uint64_t ID; - - - virtual ID alloc(size_t p_amount,const char* p_description)=0; - virtual void free(ID p_id)=0; - virtual Error realloc(ID p_id, size_t p_amount)=0; - virtual bool is_valid(ID p_id)=0; - virtual size_t get_size(ID p_id) const=0; - virtual const char* get_description(ID p_id) const=0; - - virtual Error lock(ID p_id)=0; - virtual void * get(ID p_ID)=0; - virtual Error unlock(ID p_id)=0; - virtual bool is_locked(ID p_id) const=0; - - virtual size_t get_available_mem() const=0; - virtual size_t get_total_usage() const=0; - - MemoryPoolDynamic(); -public: - virtual ~MemoryPoolDynamic(); - -}; - - -#endif - - - - - diff --git a/core/os/memory_pool_dynamic_prealloc.cpp b/core/os/memory_pool_dynamic_prealloc.cpp deleted file mode 100644 index d2efa4cc88..0000000000 --- a/core/os/memory_pool_dynamic_prealloc.cpp +++ /dev/null @@ -1,116 +0,0 @@ -/*************************************************************************/ -/* memory_pool_dynamic_prealloc.cpp */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#include "memory_pool_dynamic_prealloc.h" -#include "os/memory.h" - -#include "print_string.h" -MemoryPoolDynamicPrealloc::ID MemoryPoolDynamicPrealloc::alloc(size_t p_amount,const char* p_description) { - - -// print_line("dynpool - allocating: "+itos(p_amount)); - ID id = pool_alloc->alloc(p_amount); -// print_line("dynpool - free: "+itos(pool_alloc->get_free_mem())); - return id; - -} - -void MemoryPoolDynamicPrealloc::free(ID p_id) { - - pool_alloc->free(p_id); -} - -Error MemoryPoolDynamicPrealloc::realloc(ID p_id, size_t p_amount) { - - return pool_alloc->resize(p_id,p_amount); -} - -bool MemoryPoolDynamicPrealloc::is_valid(ID p_id) { - - return true; -} - -size_t MemoryPoolDynamicPrealloc::get_size(ID p_id) const { - - return pool_alloc->get_size(p_id); -} - -const char* MemoryPoolDynamicPrealloc::get_description(ID p_id) const { - - return ""; -} - -Error MemoryPoolDynamicPrealloc::lock(ID p_id) { - -// print_line("lock: "+itos(p_id)); - return pool_alloc->lock(p_id); -} - -void * MemoryPoolDynamicPrealloc::get(ID p_ID) { - -// print_line("get: "+itos(p_ID)); - return pool_alloc->get(p_ID); -} - -Error MemoryPoolDynamicPrealloc::unlock(ID p_id) { - -// print_line("unlock: "+itos(p_id)); - pool_alloc->unlock(p_id); - return OK; -} - -bool MemoryPoolDynamicPrealloc::is_locked(ID p_id) const { - - return pool_alloc->is_locked(p_id); -} - - -size_t MemoryPoolDynamicPrealloc::get_available_mem() const { - - return pool_alloc->get_free_mem(); -} - -size_t MemoryPoolDynamicPrealloc::get_total_usage() const { - - return pool_alloc->get_used_mem(); -} - - - -MemoryPoolDynamicPrealloc::MemoryPoolDynamicPrealloc(void * p_mem,int p_size, int p_align, int p_max_entries) { - - pool_alloc = memnew( PoolAllocator(p_mem,p_size,p_align,true,p_max_entries)); - -} - -MemoryPoolDynamicPrealloc::~MemoryPoolDynamicPrealloc() { - - - memdelete( pool_alloc ); -} - diff --git a/core/os/memory_pool_dynamic_prealloc.h b/core/os/memory_pool_dynamic_prealloc.h deleted file mode 100644 index a2e51b93f3..0000000000 --- a/core/os/memory_pool_dynamic_prealloc.h +++ /dev/null @@ -1,60 +0,0 @@ -/*************************************************************************/ -/* memory_pool_dynamic_prealloc.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef MEMORY_POOL_DYNAMIC_PREALLOC_H -#define MEMORY_POOL_DYNAMIC_PREALLOC_H - -#include "pool_allocator.h" -#include "core/os/memory_pool_dynamic.h" - -class MemoryPoolDynamicPrealloc : public MemoryPoolDynamic { - - PoolAllocator *pool_alloc; - -public: - - virtual ID alloc(size_t p_amount,const char* p_description); - virtual void free(ID p_id); - virtual Error realloc(ID p_id, size_t p_amount); - virtual bool is_valid(ID p_id); - virtual size_t get_size(ID p_id) const; - virtual const char* get_description(ID p_id) const; - - virtual Error lock(ID p_id); - virtual void * get(ID p_ID); - virtual Error unlock(ID p_id); - virtual bool is_locked(ID p_id) const; - - virtual size_t get_available_mem() const; - virtual size_t get_total_usage() const; - - MemoryPoolDynamicPrealloc(void * p_mem,int p_size, int p_align = 16, int p_max_entries=PoolAllocator::DEFAULT_MAX_ALLOCS); - ~MemoryPoolDynamicPrealloc(); -}; - -#endif // MEMORY_POOL_DYNAMIC_PREALLOC_H diff --git a/core/os/memory_pool_dynamic_static.cpp b/core/os/memory_pool_dynamic_static.cpp deleted file mode 100644 index b7a1bbc19f..0000000000 --- a/core/os/memory_pool_dynamic_static.cpp +++ /dev/null @@ -1,272 +0,0 @@ -/*************************************************************************/ -/* memory_pool_dynamic_static.cpp */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#include "memory_pool_dynamic_static.h" -#include "os/memory.h" -#include "os/os.h" -#include "ustring.h" -#include "print_string.h" -#include <stdio.h> - -MemoryPoolDynamicStatic::Chunk *MemoryPoolDynamicStatic::get_chunk(ID p_id) { - - uint64_t check = p_id/MAX_CHUNKS; - uint64_t idx = p_id%MAX_CHUNKS; - - if (!chunk[idx].mem || chunk[idx].check!=check) - return NULL; - - return &chunk[idx]; -} - - -const MemoryPoolDynamicStatic::Chunk *MemoryPoolDynamicStatic::get_chunk(ID p_id) const { - - uint64_t check = p_id/MAX_CHUNKS; - uint64_t idx = p_id%MAX_CHUNKS; - - if (!chunk[idx].mem || chunk[idx].check!=check) - return NULL; - - return &chunk[idx]; -} - -MemoryPoolDynamic::ID MemoryPoolDynamicStatic::alloc(size_t p_amount,const char* p_description) { - - _THREAD_SAFE_METHOD_ - - int idx=-1; - - for (int i=0;i<MAX_CHUNKS;i++) { - - last_alloc++; - if (last_alloc>=MAX_CHUNKS) - last_alloc=0; - - if ( !chunk[last_alloc].mem ) { - - idx=last_alloc; - break; - } - } - - - if (idx==-1) { - ERR_EXPLAIN("Out of dynamic Memory IDs"); - ERR_FAIL_V(INVALID_ID); - //return INVALID_ID; - } - - //chunk[idx].mem = Memory::alloc_static(p_amount,p_description); - chunk[idx].mem = memalloc(p_amount); - if (!chunk[idx].mem) - return INVALID_ID; - - chunk[idx].size=p_amount; - chunk[idx].check=++last_check; - chunk[idx].descr=p_description; - chunk[idx].lock=0; - - total_usage+=p_amount; - if (total_usage>max_usage) - max_usage=total_usage; - - ID id = chunk[idx].check*MAX_CHUNKS + (uint64_t)idx; - - return id; - -} -void MemoryPoolDynamicStatic::free(ID p_id) { - - _THREAD_SAFE_METHOD_ - - Chunk *c = get_chunk(p_id); - ERR_FAIL_COND(!c); - - - total_usage-=c->size; - memfree(c->mem); - - c->mem=0; - - if (c->lock>0) { - - ERR_PRINT("Freed ID Still locked"); - } -} - -Error MemoryPoolDynamicStatic::realloc(ID p_id, size_t p_amount) { - - _THREAD_SAFE_METHOD_ - - Chunk *c = get_chunk(p_id); - ERR_FAIL_COND_V(!c,ERR_INVALID_PARAMETER); - ERR_FAIL_COND_V(c->lock > 0 , ERR_LOCKED ); - - - void * new_mem = memrealloc(c->mem,p_amount); - - ERR_FAIL_COND_V(!new_mem,ERR_OUT_OF_MEMORY); - total_usage-=c->size; - c->mem=new_mem; - c->size=p_amount; - total_usage+=c->size; - if (total_usage>max_usage) - max_usage=total_usage; - - - return OK; -} -bool MemoryPoolDynamicStatic::is_valid(ID p_id) { - - _THREAD_SAFE_METHOD_ - - Chunk *c = get_chunk(p_id); - - return c!=NULL; - -} -size_t MemoryPoolDynamicStatic::get_size(ID p_id) const { - - _THREAD_SAFE_METHOD_ - - const Chunk *c = get_chunk(p_id); - ERR_FAIL_COND_V(!c,0); - - return c->size; - - -} -const char* MemoryPoolDynamicStatic::get_description(ID p_id) const { - - _THREAD_SAFE_METHOD_ - - const Chunk *c = get_chunk(p_id); - ERR_FAIL_COND_V(!c,""); - - return c->descr; - -} - - -bool MemoryPoolDynamicStatic::is_locked(ID p_id) const { - - _THREAD_SAFE_METHOD_ - - const Chunk *c = get_chunk(p_id); - ERR_FAIL_COND_V(!c,false); - - return c->lock>0; - -} - -Error MemoryPoolDynamicStatic::lock(ID p_id) { - - _THREAD_SAFE_METHOD_ - - Chunk *c = get_chunk(p_id); - ERR_FAIL_COND_V(!c,ERR_INVALID_PARAMETER); - - c->lock++; - - return OK; -} -void * MemoryPoolDynamicStatic::get(ID p_id) { - - _THREAD_SAFE_METHOD_ - - const Chunk *c = get_chunk(p_id); - ERR_FAIL_COND_V(!c,NULL); - ERR_FAIL_COND_V( c->lock==0, NULL ); - - return c->mem; -} -Error MemoryPoolDynamicStatic::unlock(ID p_id) { - - _THREAD_SAFE_METHOD_ - - Chunk *c = get_chunk(p_id); - ERR_FAIL_COND_V(!c,ERR_INVALID_PARAMETER); - - ERR_FAIL_COND_V( c->lock<=0, ERR_INVALID_PARAMETER ); - c->lock--; - - return OK; -} - -size_t MemoryPoolDynamicStatic::get_available_mem() const { - - return Memory::get_mem_available(); -} - -size_t MemoryPoolDynamicStatic::get_total_usage() const { - _THREAD_SAFE_METHOD_ - - return total_usage; -} - -MemoryPoolDynamicStatic::MemoryPoolDynamicStatic() { - - last_check=1; - last_alloc=0; - total_usage=0; - max_usage=0; -} - -MemoryPoolDynamicStatic::~MemoryPoolDynamicStatic() { - -#ifdef DEBUG_MEMORY_ENABLED - - if (OS::get_singleton()->is_stdout_verbose()) { - - if (total_usage>0) { - - ERR_PRINT("DYNAMIC ALLOC: ** MEMORY LEAKS DETECTED **"); - ERR_PRINT(String("DYNAMIC ALLOC: "+String::num(total_usage)+" bytes of memory in use at exit.").ascii().get_data()); - - ERR_PRINT("DYNAMIC ALLOC: Following is the list of leaked allocations:"); - - for (int i=0;i<MAX_CHUNKS;i++) { - - if (chunk[i].mem) { - - ERR_PRINT(String("\t"+String::num(chunk[i].size)+" bytes - "+String(chunk[i].descr)).ascii().get_data()); - } - } - - ERR_PRINT("DYNAMIC ALLOC: End of Report."); - - print_line("INFO: dynmem - max: "+itos(max_usage)+", "+itos(total_usage)+" leaked."); - } else { - - print_line("INFO: dynmem - max: "+itos(max_usage)+", no leaks."); - } - } - -#endif -} diff --git a/core/os/memory_pool_dynamic_static.h b/core/os/memory_pool_dynamic_static.h deleted file mode 100644 index a72d39355c..0000000000 --- a/core/os/memory_pool_dynamic_static.h +++ /dev/null @@ -1,86 +0,0 @@ -/*************************************************************************/ -/* memory_pool_dynamic_static.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef MEMORY_POOL_DYNAMIC_STATIC_H -#define MEMORY_POOL_DYNAMIC_STATIC_H - -#include "os/memory_pool_dynamic.h" -#include "typedefs.h" -#include "os/thread_safe.h" - -class MemoryPoolDynamicStatic : public MemoryPoolDynamic { - - _THREAD_SAFE_CLASS_ - - enum { - MAX_CHUNKS=65536 - }; - - - struct Chunk { - - uint64_t lock; - uint64_t check; - void *mem; - size_t size; - const char *descr; - - Chunk() { mem=NULL; lock=0; check=0; } - }; - - Chunk chunk[MAX_CHUNKS]; - uint64_t last_check; - int last_alloc; - size_t total_usage; - size_t max_usage; - - Chunk *get_chunk(ID p_id); - const Chunk *get_chunk(ID p_id) const; -public: - - virtual ID alloc(size_t p_amount,const char* p_description); - virtual void free(ID p_id); - virtual Error realloc(ID p_id, size_t p_amount); - virtual bool is_valid(ID p_id); - virtual size_t get_size(ID p_id) const; - virtual const char* get_description(ID p_id) const; - - virtual bool is_locked(ID p_id) const; - virtual Error lock(ID p_id); - virtual void * get(ID p_ID); - virtual Error unlock(ID p_id); - - virtual size_t get_available_mem() const; - virtual size_t get_total_usage() const; - - MemoryPoolDynamicStatic(); - virtual ~MemoryPoolDynamicStatic(); - -}; - -#endif diff --git a/core/os/os.cpp b/core/os/os.cpp index 7333d667db..82500f5423 100644 --- a/core/os/os.cpp +++ b/core/os/os.cpp @@ -371,7 +371,7 @@ int OS::get_static_memory_usage() const { } int OS::get_dynamic_memory_usage() const{ - return Memory::get_dynamic_mem_usage(); + return MemoryPool::total_memory; } int OS::get_static_memory_peak_usage() const { diff --git a/core/os/rw_lock.cpp b/core/os/rw_lock.cpp new file mode 100644 index 0000000000..9b2d1f8a46 --- /dev/null +++ b/core/os/rw_lock.cpp @@ -0,0 +1,21 @@ +#include "rw_lock.h" +#include "error_macros.h" +#include <stddef.h> + + + +RWLock* (*RWLock::create_func)()=0; + +RWLock *RWLock::create() { + + ERR_FAIL_COND_V( !create_func, 0 ); + + return create_func(); +} + + +RWLock::~RWLock() { + + +} + diff --git a/core/os/rw_lock.h b/core/os/rw_lock.h new file mode 100644 index 0000000000..c513e6d636 --- /dev/null +++ b/core/os/rw_lock.h @@ -0,0 +1,46 @@ +#ifndef RWLOCK_H +#define RWLOCK_H + +#include "error_list.h" + +class RWLock { +protected: + static RWLock* (*create_func)(); + +public: + + virtual void read_lock()=0; ///< Lock the rwlock, block if locked by someone else + virtual void read_unlock()=0; ///< Unlock the rwlock, let other threads continue + virtual Error read_try_lock()=0; ///< Attempt to lock the rwlock, OK on success, ERROR means it can't lock. + + virtual void write_lock()=0; ///< Lock the rwlock, block if locked by someone else + virtual void write_unlock()=0; ///< Unlock the rwlock, let other thwrites continue + virtual Error write_try_lock()=0; ///< Attempt to lock the rwlock, OK on success, ERROR means it can't lock. + + static RWLock * create(); ///< Create a rwlock + + virtual ~RWLock(); +}; + + +class RWLockRead { + + RWLock *lock; +public: + + RWLockRead(RWLock* p_lock) { lock=p_lock; if (lock) lock->read_lock(); } + ~RWLockRead() { if (lock) lock->read_unlock(); } + +}; + +class RWLockWrite { + + RWLock *lock; +public: + + RWLockWrite(RWLock* p_lock) { lock=p_lock; if (lock) lock->write_lock(); } + ~RWLockWrite() { if (lock) lock->write_unlock(); } + +}; + +#endif // RWLOCK_H diff --git a/core/packed_data_container.cpp b/core/packed_data_container.cpp index 8bf77b735a..77afbfc214 100644 --- a/core/packed_data_container.cpp +++ b/core/packed_data_container.cpp @@ -82,7 +82,7 @@ Variant PackedDataContainer::_iter_get_ofs(const Variant& p_iter,uint32_t p_offs if (pos<0 || pos>=size) return Variant(); - DVector<uint8_t>::Read rd=data.read(); + PoolVector<uint8_t>::Read rd=data.read(); const uint8_t *r=&rd[p_offset]; uint32_t type = decode_uint32(r); @@ -131,7 +131,7 @@ Variant PackedDataContainer::_get_at_ofs(uint32_t p_ofs,const uint8_t *p_buf,boo uint32_t PackedDataContainer::_type_at_ofs(uint32_t p_ofs) const { - DVector<uint8_t>::Read rd=data.read(); + PoolVector<uint8_t>::Read rd=data.read(); const uint8_t *r=&rd[p_ofs]; uint32_t type = decode_uint32(r); @@ -140,7 +140,7 @@ uint32_t PackedDataContainer::_type_at_ofs(uint32_t p_ofs) const { int PackedDataContainer::_size(uint32_t p_ofs) const { - DVector<uint8_t>::Read rd=data.read(); + PoolVector<uint8_t>::Read rd=data.read(); const uint8_t *r=&rd[p_ofs]; uint32_t type = decode_uint32(r); @@ -160,7 +160,7 @@ int PackedDataContainer::_size(uint32_t p_ofs) const { Variant PackedDataContainer::_key_at_ofs(uint32_t p_ofs,const Variant& p_key,bool &err) const { - DVector<uint8_t>::Read rd=data.read(); + PoolVector<uint8_t>::Read rd=data.read(); const uint8_t *r=&rd[p_ofs]; uint32_t type = decode_uint32(r); @@ -344,21 +344,21 @@ Error PackedDataContainer::pack(const Variant& p_data) { _pack(p_data,tmpdata,string_cache); datalen=tmpdata.size(); data.resize(tmpdata.size()); - DVector<uint8_t>::Write w = data.write(); + PoolVector<uint8_t>::Write w = data.write(); copymem(w.ptr(),tmpdata.ptr(),tmpdata.size()); return OK; } -void PackedDataContainer::_set_data(const DVector<uint8_t>& p_data) { +void PackedDataContainer::_set_data(const PoolVector<uint8_t>& p_data) { data=p_data; datalen=data.size(); } -DVector<uint8_t> PackedDataContainer::_get_data() const { +PoolVector<uint8_t> PackedDataContainer::_get_data() const { return data; } diff --git a/core/packed_data_container.h b/core/packed_data_container.h index 5e0180a424..f8ff43f9b0 100644 --- a/core/packed_data_container.h +++ b/core/packed_data_container.h @@ -50,7 +50,7 @@ class PackedDataContainer : public Resource { }; - DVector<uint8_t> data; + PoolVector<uint8_t> data; int datalen; @@ -73,8 +73,8 @@ friend class PackedDataContainerRef; protected: - void _set_data(const DVector<uint8_t>& p_data); - DVector<uint8_t> _get_data() const; + void _set_data(const PoolVector<uint8_t>& p_data); + PoolVector<uint8_t> _get_data() const; static void _bind_methods(); public: diff --git a/core/path_remap.cpp b/core/path_remap.cpp index 92a2ab9af7..980e8f76e7 100644 --- a/core/path_remap.cpp +++ b/core/path_remap.cpp @@ -124,13 +124,13 @@ void PathRemap::clear_remaps() { void PathRemap::load_remaps() { // default remaps first - DVector<String> remaps = GlobalConfig::get_singleton()->get("remap/all"); + PoolVector<String> remaps = GlobalConfig::get_singleton()->get("remap/all"); { int rlen = remaps.size(); ERR_FAIL_COND( rlen%2 ); - DVector<String>::Read r = remaps.read(); + PoolVector<String>::Read r = remaps.read(); for(int i=0;i<rlen/2;i++) { String from = r[i*2+0]; @@ -147,7 +147,7 @@ void PathRemap::load_remaps() { int rlen = remaps.size(); ERR_FAIL_COND( rlen%2 ); - DVector<String>::Read r = remaps.read(); + PoolVector<String>::Read r = remaps.read(); for(int i=0;i<rlen/2;i++) { String from = r[i*2+0]; diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp index e3c18217e9..7c076d028e 100644 --- a/core/register_core_types.cpp +++ b/core/register_core_types.cpp @@ -85,6 +85,9 @@ extern void unregister_variant_methods(); void register_core_types() { + ObjectDB::setup(); + ResourceCache::setup(); + MemoryPool::setup(); _global_mutex=Mutex::create(); @@ -241,4 +244,7 @@ void unregister_core_types() { memdelete(_global_mutex); _global_mutex=NULL; //still needed at a few places }; + + MemoryPool::cleanup(); + } diff --git a/core/resource.cpp b/core/resource.cpp index a503e965b0..7bcdd88891 100644 --- a/core/resource.cpp +++ b/core/resource.cpp @@ -164,17 +164,31 @@ void Resource::set_path(const String& p_path, bool p_take_over) { if (path_cache!="") { + ResourceCache::lock->write_lock(); ResourceCache::resources.erase(path_cache); + ResourceCache::lock->write_unlock(); } path_cache=""; - if (ResourceCache::resources.has( p_path )) { + + ResourceCache::lock->read_lock(); + bool has_path = ResourceCache::resources.has( p_path ); + ResourceCache::lock->read_unlock(); + + if (has_path) { if (p_take_over) { + ResourceCache::lock->write_lock(); ResourceCache::resources.get(p_path)->set_name(""); + ResourceCache::lock->write_unlock(); } else { ERR_EXPLAIN("Another resource is loaded from path: "+p_path); - ERR_FAIL_COND( ResourceCache::resources.has( p_path ) ); + + ResourceCache::lock->read_lock(); + bool exists = ResourceCache::resources.has( p_path ); + ResourceCache::lock->read_unlock(); + + ERR_FAIL_COND( exists ); } } @@ -182,7 +196,9 @@ void Resource::set_path(const String& p_path, bool p_take_over) { if (path_cache!="") { + ResourceCache::lock->write_lock(); ResourceCache::resources[path_cache]=this;; + ResourceCache::lock->write_unlock(); } _change_notify("resource/path"); @@ -393,8 +409,11 @@ Resource::Resource() { Resource::~Resource() { - if (path_cache!="") + if (path_cache!="") { + ResourceCache::lock->write_lock(); ResourceCache::resources.erase(path_cache); + ResourceCache::lock->write_unlock(); + } if (owners.size()) { WARN_PRINT("Resource is still owned"); } @@ -402,18 +421,24 @@ Resource::~Resource() { HashMap<String,Resource*> ResourceCache::resources; +RWLock *ResourceCache::lock=NULL; + +void ResourceCache::setup() { + + lock = RWLock::create(); +} + void ResourceCache::clear() { if (resources.size()) ERR_PRINT("Resources Still in use at Exit!"); resources.clear(); + memdelete(lock); } void ResourceCache::reload_externals() { - GLOBAL_LOCK_FUNCTION - //const String *K=NULL; //while ((K=resources.next(K))) { // resources[*K]->reload_external_data(); @@ -423,15 +448,21 @@ void ResourceCache::reload_externals() { bool ResourceCache::has(const String& p_path) { - GLOBAL_LOCK_FUNCTION + lock->read_lock();; + bool b = resources.has(p_path); + lock->read_unlock();; + - return resources.has(p_path); + return b; } Resource *ResourceCache::get(const String& p_path) { - GLOBAL_LOCK_FUNCTION + lock->read_lock(); Resource **res = resources.getptr(p_path); + + lock->read_unlock(); + if (!res) { return NULL; } @@ -443,6 +474,7 @@ Resource *ResourceCache::get(const String& p_path) { void ResourceCache::get_cached_resources(List<Ref<Resource> > *p_resources) { + lock->read_lock(); const String* K=NULL; while((K=resources.next(K))) { @@ -450,17 +482,22 @@ void ResourceCache::get_cached_resources(List<Ref<Resource> > *p_resources) { p_resources->push_back( Ref<Resource>( r )); } + lock->read_unlock(); } int ResourceCache::get_cached_resource_count() { - return resources.size(); + lock->read_lock(); + int rc = resources.size(); + lock->read_unlock(); + + return rc; } void ResourceCache::dump(const char* p_file,bool p_short) { #ifdef DEBUG_ENABLED - GLOBAL_LOCK_FUNCTION + lock->read_lock(); Map<String,int> type_count; @@ -500,5 +537,7 @@ void ResourceCache::dump(const char* p_file,bool p_short) { memdelete(f); } + lock->read_unlock(); + #endif } diff --git a/core/resource.h b/core/resource.h index cb109b3767..11f2c5ee2a 100644 --- a/core/resource.h +++ b/core/resource.h @@ -165,9 +165,12 @@ typedef Ref<Resource> RES; class ResourceCache { friend class Resource; + static RWLock *lock; static HashMap<String,Resource*> resources; friend void unregister_core_types(); static void clear(); +friend void register_core_types(); + static void setup(); public: static void reload_externals(); diff --git a/core/safe_refcount.cpp b/core/safe_refcount.cpp index f0d4fbd610..ede37bbe8a 100644 --- a/core/safe_refcount.cpp +++ b/core/safe_refcount.cpp @@ -76,6 +76,9 @@ uint32_t atomic_decrement( register uint32_t * pw ) { return InterlockedDecrement( (LONG volatile*)pw ); } +uint32_t atomic_increment( register uint32_t * pw ) { + return InterlockedIncrement( (LONG volatile*)pw ); +} #elif defined(__GNUC__) uint32_t atomic_conditional_increment( register uint32_t * pw ) { @@ -95,6 +98,12 @@ uint32_t atomic_decrement( register uint32_t * pw ) { } +uint32_t atomic_increment( register uint32_t * pw ) { + + return __sync_add_and_fetch(pw,1); + +} + #else //no threads supported? #error Must provide atomic functions for this platform or compiler! diff --git a/core/safe_refcount.h b/core/safe_refcount.h index 08bea9d244..6e349d89d8 100644 --- a/core/safe_refcount.h +++ b/core/safe_refcount.h @@ -38,6 +38,7 @@ uint32_t atomic_conditional_increment( register uint32_t * counter ); uint32_t atomic_decrement( register uint32_t * pw ); +uint32_t atomic_increment( register uint32_t * pw ); diff --git a/core/string_db.cpp b/core/string_db.cpp index 471195ceda..be35a44ed1 100644 --- a/core/string_db.cpp +++ b/core/string_db.cpp @@ -41,9 +41,12 @@ StringName _scs_create(const char *p_chr) { } bool StringName::configured=false; +Mutex* StringName::lock=NULL; void StringName::setup() { + lock = Mutex::create(); + ERR_FAIL_COND(configured); for(int i=0;i<STRING_TABLE_LEN;i++) { @@ -54,7 +57,8 @@ void StringName::setup() { void StringName::cleanup() { - _global_lock(); + lock->lock(); + int lost_strings=0; for(int i=0;i<STRING_TABLE_LEN;i++) { @@ -78,7 +82,9 @@ void StringName::cleanup() { if (OS::get_singleton()->is_stdout_verbose() && lost_strings) { print_line("StringName: "+itos(lost_strings)+" unclaimed string names at exit."); } - _global_unlock(); + lock->unlock(); + + memdelete(lock); } void StringName::unref() { @@ -87,7 +93,7 @@ void StringName::unref() { if (_data && _data->refcount.unref()) { - _global_lock(); + lock->lock(); if (_data->prev) { _data->prev->next=_data->next; @@ -103,7 +109,7 @@ void StringName::unref() { } memdelete(_data); - _global_unlock(); + lock->unlock(); } _data=NULL; @@ -186,7 +192,7 @@ StringName::StringName(const char *p_name) { if (!p_name || p_name[0]==0) return; //empty, ignore - _global_lock(); + lock->lock(); uint32_t hash = String::hash(p_name); @@ -206,7 +212,7 @@ StringName::StringName(const char *p_name) { if (_data) { if (_data->refcount.ref()) { // exists - _global_unlock(); + lock->unlock(); return; } else { @@ -226,8 +232,7 @@ StringName::StringName(const char *p_name) { _table[idx]=_data; - _global_unlock(); - + lock->unlock(); } StringName::StringName(const StaticCString& p_static_string) { @@ -238,7 +243,7 @@ StringName::StringName(const StaticCString& p_static_string) { ERR_FAIL_COND( !p_static_string.ptr || !p_static_string.ptr[0]); - _global_lock(); + lock->lock(); uint32_t hash = String::hash(p_static_string.ptr); @@ -258,7 +263,7 @@ StringName::StringName(const StaticCString& p_static_string) { if (_data) { if (_data->refcount.ref()) { // exists - _global_unlock(); + lock->unlock(); return; } else { @@ -278,7 +283,8 @@ StringName::StringName(const StaticCString& p_static_string) { _table[idx]=_data; - _global_unlock(); + lock->unlock(); + } @@ -292,7 +298,7 @@ StringName::StringName(const String& p_name) { if (p_name==String()) return; - _global_lock(); + lock->lock(); uint32_t hash = p_name.hash(); @@ -311,7 +317,7 @@ StringName::StringName(const String& p_name) { if (_data) { if (_data->refcount.ref()) { // exists - _global_unlock(); + lock->unlock(); return; } else { @@ -332,7 +338,7 @@ StringName::StringName(const String& p_name) { _table[idx]->prev=_data; _table[idx]=_data; - _global_unlock(); + lock->unlock(); } @@ -344,7 +350,7 @@ StringName StringName::search(const char *p_name) { if (!p_name[0]) return StringName(); - _global_lock(); + lock->lock(); uint32_t hash = String::hash(p_name); @@ -361,12 +367,13 @@ StringName StringName::search(const char *p_name) { } if (_data && _data->refcount.ref()) { - _global_unlock(); + lock->unlock(); + return StringName(_data); } - _global_unlock(); + lock->unlock(); return StringName(); //does not exist @@ -380,7 +387,7 @@ StringName StringName::search(const CharType *p_name) { if (!p_name[0]) return StringName(); - _global_lock(); + lock->lock(); uint32_t hash = String::hash(p_name); @@ -397,12 +404,12 @@ StringName StringName::search(const CharType *p_name) { } if (_data && _data->refcount.ref()) { - _global_unlock(); + lock->unlock(); return StringName(_data); } - _global_unlock(); + lock->unlock(); return StringName(); //does not exist } @@ -410,7 +417,7 @@ StringName StringName::search(const String &p_name) { ERR_FAIL_COND_V( p_name=="", StringName() ); - _global_lock(); + lock->lock(); uint32_t hash = p_name.hash(); @@ -427,12 +434,12 @@ StringName StringName::search(const String &p_name) { } if (_data && _data->refcount.ref()) { - _global_unlock(); + lock->unlock(); return StringName(_data); } - _global_unlock(); + lock->unlock(); return StringName(); //does not exist } diff --git a/core/string_db.h b/core/string_db.h index fd24159265..a14cdbc7ba 100644 --- a/core/string_db.h +++ b/core/string_db.h @@ -32,7 +32,7 @@ #include "hash_map.h" #include "ustring.h" #include "safe_refcount.h" - +#include "os/mutex.h" /** @author Juan Linietsky <reduzio@gmail.com> */ @@ -83,6 +83,7 @@ class StringName { friend void register_core_types(); friend void unregister_core_types(); + static Mutex *lock; static void setup(); static void cleanup(); static bool configured; diff --git a/core/translation.cpp b/core/translation.cpp index 8e58b45565..302f74a98c 100644 --- a/core/translation.cpp +++ b/core/translation.cpp @@ -799,9 +799,9 @@ static bool is_valid_locale(const String& p_locale) { return false; } -DVector<String> Translation::_get_messages() const { +PoolVector<String> Translation::_get_messages() const { - DVector<String> msgs; + PoolVector<String> msgs; msgs.resize(translation_map.size()*2); int idx=0; for (const Map<StringName, StringName>::Element *E=translation_map.front();E;E=E->next()) { @@ -814,9 +814,9 @@ DVector<String> Translation::_get_messages() const { return msgs; } -DVector<String> Translation::_get_message_list() const { +PoolVector<String> Translation::_get_message_list() const { - DVector<String> msgs; + PoolVector<String> msgs; msgs.resize(translation_map.size()); int idx=0; for (const Map<StringName, StringName>::Element *E=translation_map.front();E;E=E->next()) { @@ -829,12 +829,12 @@ DVector<String> Translation::_get_message_list() const { } -void Translation::_set_messages(const DVector<String>& p_messages){ +void Translation::_set_messages(const PoolVector<String>& p_messages){ int msg_count=p_messages.size(); ERR_FAIL_COND(msg_count%2); - DVector<String>::Read r = p_messages.read(); + PoolVector<String>::Read r = p_messages.read(); for(int i=0;i<msg_count;i+=2) { @@ -1048,12 +1048,12 @@ TranslationServer *TranslationServer::singleton=NULL; bool TranslationServer::_load_translations(const String& p_from) { if (GlobalConfig::get_singleton()->has(p_from)) { - DVector<String> translations=GlobalConfig::get_singleton()->get(p_from); + PoolVector<String> translations=GlobalConfig::get_singleton()->get(p_from); int tcount=translations.size(); if (tcount) { - DVector<String>::Read r = translations.read(); + PoolVector<String>::Read r = translations.read(); for(int i=0;i<tcount;i++) { diff --git a/core/translation.h b/core/translation.h index 01edc82139..85ab4a229d 100644 --- a/core/translation.h +++ b/core/translation.h @@ -42,10 +42,10 @@ class Translation : public Resource { String locale; Map<StringName, StringName> translation_map; - DVector<String> _get_message_list() const; + PoolVector<String> _get_message_list() const; - DVector<String> _get_messages() const; - void _set_messages(const DVector<String>& p_messages); + PoolVector<String> _get_messages() const; + void _set_messages(const PoolVector<String>& p_messages); protected: static void _bind_methods(); diff --git a/core/variant.cpp b/core/variant.cpp index 19b0ea7129..f2c614e14f 100644 --- a/core/variant.cpp +++ b/core/variant.cpp @@ -842,37 +842,37 @@ bool Variant::is_zero() const { // arrays case RAW_ARRAY: { - return reinterpret_cast<const DVector<uint8_t>*>(_data._mem)->size()==0; + return reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem)->size()==0; } break; case INT_ARRAY: { - return reinterpret_cast<const DVector<int>*>(_data._mem)->size()==0; + return reinterpret_cast<const PoolVector<int>*>(_data._mem)->size()==0; } break; case REAL_ARRAY: { - return reinterpret_cast<const DVector<real_t>*>(_data._mem)->size()==0; + return reinterpret_cast<const PoolVector<real_t>*>(_data._mem)->size()==0; } break; case STRING_ARRAY: { - return reinterpret_cast<const DVector<String>*>(_data._mem)->size()==0; + return reinterpret_cast<const PoolVector<String>*>(_data._mem)->size()==0; } break; case VECTOR2_ARRAY: { - return reinterpret_cast<const DVector<Vector2>*>(_data._mem)->size()==0; + return reinterpret_cast<const PoolVector<Vector2>*>(_data._mem)->size()==0; } break; case VECTOR3_ARRAY: { - return reinterpret_cast<const DVector<Vector3>*>(_data._mem)->size()==0; + return reinterpret_cast<const PoolVector<Vector3>*>(_data._mem)->size()==0; } break; case COLOR_ARRAY: { - return reinterpret_cast<const DVector<Color>*>(_data._mem)->size()==0; + return reinterpret_cast<const PoolVector<Color>*>(_data._mem)->size()==0; } break; default: {} @@ -1070,37 +1070,37 @@ void Variant::reference(const Variant& p_variant) { // arrays case RAW_ARRAY: { - memnew_placement( _data._mem, DVector<uint8_t> ( *reinterpret_cast<const DVector<uint8_t>*>(p_variant._data._mem) ) ); + memnew_placement( _data._mem, PoolVector<uint8_t> ( *reinterpret_cast<const PoolVector<uint8_t>*>(p_variant._data._mem) ) ); } break; case INT_ARRAY: { - memnew_placement( _data._mem, DVector<int> ( *reinterpret_cast<const DVector<int>*>(p_variant._data._mem) ) ); + memnew_placement( _data._mem, PoolVector<int> ( *reinterpret_cast<const PoolVector<int>*>(p_variant._data._mem) ) ); } break; case REAL_ARRAY: { - memnew_placement( _data._mem, DVector<real_t> ( *reinterpret_cast<const DVector<real_t>*>(p_variant._data._mem) ) ); + memnew_placement( _data._mem, PoolVector<real_t> ( *reinterpret_cast<const PoolVector<real_t>*>(p_variant._data._mem) ) ); } break; case STRING_ARRAY: { - memnew_placement( _data._mem, DVector<String> ( *reinterpret_cast<const DVector<String>*>(p_variant._data._mem) ) ); + memnew_placement( _data._mem, PoolVector<String> ( *reinterpret_cast<const PoolVector<String>*>(p_variant._data._mem) ) ); } break; case VECTOR2_ARRAY: { - memnew_placement( _data._mem, DVector<Vector2> ( *reinterpret_cast<const DVector<Vector2>*>(p_variant._data._mem) ) ); + memnew_placement( _data._mem, PoolVector<Vector2> ( *reinterpret_cast<const PoolVector<Vector2>*>(p_variant._data._mem) ) ); } break; case VECTOR3_ARRAY: { - memnew_placement( _data._mem, DVector<Vector3> ( *reinterpret_cast<const DVector<Vector3>*>(p_variant._data._mem) ) ); + memnew_placement( _data._mem, PoolVector<Vector3> ( *reinterpret_cast<const PoolVector<Vector3>*>(p_variant._data._mem) ) ); } break; case COLOR_ARRAY: { - memnew_placement( _data._mem, DVector<Color> ( *reinterpret_cast<const DVector<Color>*>(p_variant._data._mem) ) ); + memnew_placement( _data._mem, PoolVector<Color> ( *reinterpret_cast<const PoolVector<Color>*>(p_variant._data._mem) ) ); } break; default: {} @@ -1198,37 +1198,37 @@ void Variant::clear() { // arrays case RAW_ARRAY: { - reinterpret_cast< DVector<uint8_t>* >(_data._mem)->~DVector<uint8_t>(); + reinterpret_cast< PoolVector<uint8_t>* >(_data._mem)->~PoolVector<uint8_t>(); } break; case INT_ARRAY: { - reinterpret_cast< DVector<int>* >(_data._mem)->~DVector<int>(); + reinterpret_cast< PoolVector<int>* >(_data._mem)->~PoolVector<int>(); } break; case REAL_ARRAY: { - reinterpret_cast< DVector<real_t>* >(_data._mem)->~DVector<real_t>(); + reinterpret_cast< PoolVector<real_t>* >(_data._mem)->~PoolVector<real_t>(); } break; case STRING_ARRAY: { - reinterpret_cast< DVector<String>* >(_data._mem)->~DVector<String>(); + reinterpret_cast< PoolVector<String>* >(_data._mem)->~PoolVector<String>(); } break; case VECTOR2_ARRAY: { - reinterpret_cast< DVector<Vector2>* >(_data._mem)->~DVector<Vector2>(); + reinterpret_cast< PoolVector<Vector2>* >(_data._mem)->~PoolVector<Vector2>(); } break; case VECTOR3_ARRAY: { - reinterpret_cast< DVector<Vector3>* >(_data._mem)->~DVector<Vector3>(); + reinterpret_cast< PoolVector<Vector3>* >(_data._mem)->~PoolVector<Vector3>(); } break; case COLOR_ARRAY: { - reinterpret_cast< DVector<Color>* >(_data._mem)->~DVector<Color>(); + reinterpret_cast< PoolVector<Color>* >(_data._mem)->~PoolVector<Color>(); } break; default: {} /* not needed */ @@ -1578,7 +1578,7 @@ Variant::operator String() const { } break; case VECTOR2_ARRAY: { - DVector<Vector2> vec = operator DVector<Vector2>(); + PoolVector<Vector2> vec = operator PoolVector<Vector2>(); String str("["); for(int i=0;i<vec.size();i++) { @@ -1591,7 +1591,7 @@ Variant::operator String() const { } break; case VECTOR3_ARRAY: { - DVector<Vector3> vec = operator DVector<Vector3>(); + PoolVector<Vector3> vec = operator PoolVector<Vector3>(); String str("["); for(int i=0;i<vec.size();i++) { @@ -1604,7 +1604,7 @@ Variant::operator String() const { } break; case STRING_ARRAY: { - DVector<String> vec = operator DVector<String>(); + PoolVector<String> vec = operator PoolVector<String>(); String str("["); for(int i=0;i<vec.size();i++) { @@ -1617,7 +1617,7 @@ Variant::operator String() const { } break; case INT_ARRAY: { - DVector<int> vec = operator DVector<int>(); + PoolVector<int> vec = operator PoolVector<int>(); String str("["); for(int i=0;i<vec.size();i++) { @@ -1630,7 +1630,7 @@ Variant::operator String() const { } break; case REAL_ARRAY: { - DVector<real_t> vec = operator DVector<real_t>(); + PoolVector<real_t> vec = operator PoolVector<real_t>(); String str("["); for(int i=0;i<vec.size();i++) { @@ -1893,13 +1893,13 @@ inline DA _convert_array_from_variant(const Variant& p_variant) { case Variant::ARRAY: { return _convert_array<DA,Array >( p_variant.operator Array () ); } - case Variant::RAW_ARRAY: { return _convert_array<DA,DVector<uint8_t> >( p_variant.operator DVector<uint8_t> () ); } - case Variant::INT_ARRAY: { return _convert_array<DA,DVector<int> >( p_variant.operator DVector<int> () ); } - case Variant::REAL_ARRAY: { return _convert_array<DA,DVector<real_t> >( p_variant.operator DVector<real_t> () ); } - case Variant::STRING_ARRAY: { return _convert_array<DA,DVector<String> >( p_variant.operator DVector<String> () ); } - case Variant::VECTOR2_ARRAY: { return _convert_array<DA,DVector<Vector2> >( p_variant.operator DVector<Vector2> () ); } - case Variant::VECTOR3_ARRAY: { return _convert_array<DA,DVector<Vector3> >( p_variant.operator DVector<Vector3> () ); } - case Variant::COLOR_ARRAY: { return _convert_array<DA,DVector<Color> >( p_variant.operator DVector<Color>() ); } + case Variant::RAW_ARRAY: { return _convert_array<DA,PoolVector<uint8_t> >( p_variant.operator PoolVector<uint8_t> () ); } + case Variant::INT_ARRAY: { return _convert_array<DA,PoolVector<int> >( p_variant.operator PoolVector<int> () ); } + case Variant::REAL_ARRAY: { return _convert_array<DA,PoolVector<real_t> >( p_variant.operator PoolVector<real_t> () ); } + case Variant::STRING_ARRAY: { return _convert_array<DA,PoolVector<String> >( p_variant.operator PoolVector<String> () ); } + case Variant::VECTOR2_ARRAY: { return _convert_array<DA,PoolVector<Vector2> >( p_variant.operator PoolVector<Vector2> () ); } + case Variant::VECTOR3_ARRAY: { return _convert_array<DA,PoolVector<Vector3> >( p_variant.operator PoolVector<Vector3> () ); } + case Variant::COLOR_ARRAY: { return _convert_array<DA,PoolVector<Color> >( p_variant.operator PoolVector<Color>() ); } default: { return DA(); } } @@ -1914,64 +1914,64 @@ Variant::operator Array() const { return _convert_array_from_variant<Array >(*this); } -Variant::operator DVector<uint8_t>() const { +Variant::operator PoolVector<uint8_t>() const { if (type==RAW_ARRAY) - return *reinterpret_cast<const DVector<uint8_t>* >(_data._mem); + return *reinterpret_cast<const PoolVector<uint8_t>* >(_data._mem); else - return _convert_array_from_variant<DVector<uint8_t> >(*this); + return _convert_array_from_variant<PoolVector<uint8_t> >(*this); } -Variant::operator DVector<int>() const { +Variant::operator PoolVector<int>() const { if (type==INT_ARRAY) - return *reinterpret_cast<const DVector<int>* >(_data._mem); + return *reinterpret_cast<const PoolVector<int>* >(_data._mem); else - return _convert_array_from_variant<DVector<int> >(*this); + return _convert_array_from_variant<PoolVector<int> >(*this); } -Variant::operator DVector<real_t>() const { +Variant::operator PoolVector<real_t>() const { if (type==REAL_ARRAY) - return *reinterpret_cast<const DVector<real_t>* >(_data._mem); + return *reinterpret_cast<const PoolVector<real_t>* >(_data._mem); else - return _convert_array_from_variant<DVector<real_t> >(*this); + return _convert_array_from_variant<PoolVector<real_t> >(*this); } -Variant::operator DVector<String>() const { +Variant::operator PoolVector<String>() const { if (type==STRING_ARRAY) - return *reinterpret_cast<const DVector<String>* >(_data._mem); + return *reinterpret_cast<const PoolVector<String>* >(_data._mem); else - return _convert_array_from_variant<DVector<String> >(*this); + return _convert_array_from_variant<PoolVector<String> >(*this); } -Variant::operator DVector<Vector3>() const { +Variant::operator PoolVector<Vector3>() const { if (type==VECTOR3_ARRAY) - return *reinterpret_cast<const DVector<Vector3>* >(_data._mem); + return *reinterpret_cast<const PoolVector<Vector3>* >(_data._mem); else - return _convert_array_from_variant<DVector<Vector3> >(*this); + return _convert_array_from_variant<PoolVector<Vector3> >(*this); } -Variant::operator DVector<Vector2>() const { +Variant::operator PoolVector<Vector2>() const { if (type==VECTOR2_ARRAY) - return *reinterpret_cast<const DVector<Vector2>* >(_data._mem); + return *reinterpret_cast<const PoolVector<Vector2>* >(_data._mem); else - return _convert_array_from_variant<DVector<Vector2> >(*this); + return _convert_array_from_variant<PoolVector<Vector2> >(*this); } -Variant::operator DVector<Color>() const { +Variant::operator PoolVector<Color>() const { if (type==COLOR_ARRAY) - return *reinterpret_cast<const DVector<Color>* >(_data._mem); + return *reinterpret_cast<const PoolVector<Color>* >(_data._mem); else - return _convert_array_from_variant<DVector<Color> >(*this); + return _convert_array_from_variant<PoolVector<Color> >(*this); } @@ -1990,13 +1990,13 @@ Variant::operator Vector<RID>() const { Variant::operator Vector<Vector2>() const { - DVector<Vector2> from=operator DVector<Vector2>(); + PoolVector<Vector2> from=operator PoolVector<Vector2>(); Vector<Vector2> to; int len=from.size(); if (len==0) return Vector<Vector2>(); to.resize(len); - DVector<Vector2>::Read r = from.read(); + PoolVector<Vector2>::Read r = from.read(); Vector2 *w = &to[0]; for (int i=0;i<len;i++) { @@ -2005,16 +2005,16 @@ Variant::operator Vector<Vector2>() const { return to; } -Variant::operator DVector<Plane>() const { +Variant::operator PoolVector<Plane>() const { Array va= operator Array(); - DVector<Plane> planes; + PoolVector<Plane> planes; int va_size=va.size(); if (va_size==0) return planes; planes.resize(va_size); - DVector<Plane>::Write w = planes.write(); + PoolVector<Plane>::Write w = planes.write(); for(int i=0;i<va_size;i++) w[i]=va[i]; @@ -2022,17 +2022,17 @@ Variant::operator DVector<Plane>() const { return planes; } -Variant::operator DVector<Face3>() const { +Variant::operator PoolVector<Face3>() const { - DVector<Vector3> va= operator DVector<Vector3>(); - DVector<Face3> faces; + PoolVector<Vector3> va= operator PoolVector<Vector3>(); + PoolVector<Face3> faces; int va_size=va.size(); if (va_size==0) return faces; faces.resize(va_size/3); - DVector<Face3>::Write w = faces.write(); - DVector<Vector3>::Read r = va.read(); + PoolVector<Face3>::Write w = faces.write(); + PoolVector<Vector3>::Read r = va.read(); for(int i=0;i<va_size;i++) w[i/3].vertex[i%3]=r[i]; @@ -2072,7 +2072,7 @@ Variant::operator Vector<Variant>() const { Variant::operator Vector<uint8_t>() const { - DVector<uint8_t> from=operator DVector<uint8_t>(); + PoolVector<uint8_t> from=operator PoolVector<uint8_t>(); Vector<uint8_t> to; int len=from.size(); to.resize(len); @@ -2084,7 +2084,7 @@ Variant::operator Vector<uint8_t>() const { } Variant::operator Vector<int>() const { - DVector<int> from=operator DVector<int>(); + PoolVector<int> from=operator PoolVector<int>(); Vector<int> to; int len=from.size(); to.resize(len); @@ -2096,7 +2096,7 @@ Variant::operator Vector<int>() const { } Variant::operator Vector<real_t>() const { - DVector<real_t> from=operator DVector<real_t>(); + PoolVector<real_t> from=operator PoolVector<real_t>(); Vector<real_t> to; int len=from.size(); to.resize(len); @@ -2109,7 +2109,7 @@ Variant::operator Vector<real_t>() const { Variant::operator Vector<String>() const { - DVector<String> from=operator DVector<String>(); + PoolVector<String> from=operator PoolVector<String>(); Vector<String> to; int len=from.size(); to.resize(len); @@ -2122,13 +2122,13 @@ Variant::operator Vector<String>() const { } Variant::operator Vector<Vector3>() const { - DVector<Vector3> from=operator DVector<Vector3>(); + PoolVector<Vector3> from=operator PoolVector<Vector3>(); Vector<Vector3> to; int len=from.size(); if (len==0) return Vector<Vector3>(); to.resize(len); - DVector<Vector3>::Read r = from.read(); + PoolVector<Vector3>::Read r = from.read(); Vector3 *w = &to[0]; for (int i=0;i<len;i++) { @@ -2139,13 +2139,13 @@ Variant::operator Vector<Vector3>() const { } Variant::operator Vector<Color>() const { - DVector<Color> from=operator DVector<Color>(); + PoolVector<Color> from=operator PoolVector<Color>(); Vector<Color> to; int len=from.size(); if (len==0) return Vector<Color>(); to.resize(len); - DVector<Color>::Read r = from.read(); + PoolVector<Color>::Read r = from.read(); Color *w = &to[0]; for (int i=0;i<len;i++) { @@ -2167,7 +2167,7 @@ Variant::operator IP_Address() const { if (type==REAL_ARRAY || type==INT_ARRAY || type==RAW_ARRAY) { - DVector<int> addr=operator DVector<int>(); + PoolVector<int> addr=operator PoolVector<int>(); if (addr.size()==4) { return IP_Address(addr.get(0),addr.get(1),addr.get(2),addr.get(3)); } @@ -2418,7 +2418,7 @@ Variant::Variant(const Array& p_array) { } -Variant::Variant(const DVector<Plane>& p_array) { +Variant::Variant(const PoolVector<Plane>& p_array) { type=ARRAY; @@ -2467,11 +2467,11 @@ Variant::Variant(const Vector<Vector2>& p_array) { type=NIL; - DVector<Vector2> v; + PoolVector<Vector2> v; int len=p_array.size(); if (len>0) { v.resize(len); - DVector<Vector2>::Write w = v.write(); + PoolVector<Vector2>::Write w = v.write(); const Vector2 *r = p_array.ptr(); for (int i=0;i<len;i++) @@ -2481,59 +2481,59 @@ Variant::Variant(const Vector<Vector2>& p_array) { } -Variant::Variant(const DVector<uint8_t>& p_raw_array) { +Variant::Variant(const PoolVector<uint8_t>& p_raw_array) { type=RAW_ARRAY; - memnew_placement( _data._mem, DVector<uint8_t>(p_raw_array) ); + memnew_placement( _data._mem, PoolVector<uint8_t>(p_raw_array) ); } -Variant::Variant(const DVector<int>& p_int_array) { +Variant::Variant(const PoolVector<int>& p_int_array) { type=INT_ARRAY; - memnew_placement( _data._mem, DVector<int>(p_int_array) ); + memnew_placement( _data._mem, PoolVector<int>(p_int_array) ); } -Variant::Variant(const DVector<real_t>& p_real_array) { +Variant::Variant(const PoolVector<real_t>& p_real_array) { type=REAL_ARRAY; - memnew_placement( _data._mem, DVector<real_t>(p_real_array) ); + memnew_placement( _data._mem, PoolVector<real_t>(p_real_array) ); } -Variant::Variant(const DVector<String>& p_string_array) { +Variant::Variant(const PoolVector<String>& p_string_array) { type=STRING_ARRAY; - memnew_placement( _data._mem, DVector<String>(p_string_array) ); + memnew_placement( _data._mem, PoolVector<String>(p_string_array) ); } -Variant::Variant(const DVector<Vector3>& p_vector3_array) { +Variant::Variant(const PoolVector<Vector3>& p_vector3_array) { type=VECTOR3_ARRAY; - memnew_placement( _data._mem, DVector<Vector3>(p_vector3_array) ); + memnew_placement( _data._mem, PoolVector<Vector3>(p_vector3_array) ); } -Variant::Variant(const DVector<Vector2>& p_vector2_array) { +Variant::Variant(const PoolVector<Vector2>& p_vector2_array) { type=VECTOR2_ARRAY; - memnew_placement( _data._mem, DVector<Vector2>(p_vector2_array) ); + memnew_placement( _data._mem, PoolVector<Vector2>(p_vector2_array) ); } -Variant::Variant(const DVector<Color>& p_color_array) { +Variant::Variant(const PoolVector<Color>& p_color_array) { type=COLOR_ARRAY; - memnew_placement( _data._mem, DVector<Color>(p_color_array) ); + memnew_placement( _data._mem, PoolVector<Color>(p_color_array) ); } -Variant::Variant(const DVector<Face3>& p_face_array) { +Variant::Variant(const PoolVector<Face3>& p_face_array) { - DVector<Vector3> vertices; + PoolVector<Vector3> vertices; int face_count=p_face_array.size(); vertices.resize(face_count*3); if (face_count) { - DVector<Face3>::Read r = p_face_array.read(); - DVector<Vector3>::Write w = vertices.write(); + PoolVector<Face3>::Read r = p_face_array.read(); + PoolVector<Vector3>::Write w = vertices.write(); for(int i=0;i<face_count;i++) { @@ -2541,8 +2541,8 @@ Variant::Variant(const DVector<Face3>& p_face_array) { w[i*3+j]=r[i].vertex[j]; } - r=DVector<Face3>::Read(); - w=DVector<Vector3>::Write(); + r=PoolVector<Face3>::Read(); + w=PoolVector<Vector3>::Write(); } @@ -2567,7 +2567,7 @@ Variant::Variant(const Vector<Variant>& p_array) { Variant::Variant(const Vector<uint8_t>& p_array) { type=NIL; - DVector<uint8_t> v; + PoolVector<uint8_t> v; int len=p_array.size(); v.resize(len); for (int i=0;i<len;i++) @@ -2578,7 +2578,7 @@ Variant::Variant(const Vector<uint8_t>& p_array) { Variant::Variant(const Vector<int>& p_array) { type=NIL; - DVector<int> v; + PoolVector<int> v; int len=p_array.size(); v.resize(len); for (int i=0;i<len;i++) @@ -2589,7 +2589,7 @@ Variant::Variant(const Vector<int>& p_array) { Variant::Variant(const Vector<real_t>& p_array) { type=NIL; - DVector<real_t> v; + PoolVector<real_t> v; int len=p_array.size(); v.resize(len); for (int i=0;i<len;i++) @@ -2600,7 +2600,7 @@ Variant::Variant(const Vector<real_t>& p_array) { Variant::Variant(const Vector<String>& p_array) { type=NIL; - DVector<String> v; + PoolVector<String> v; int len=p_array.size(); v.resize(len); for (int i=0;i<len;i++) @@ -2611,11 +2611,11 @@ Variant::Variant(const Vector<String>& p_array) { Variant::Variant(const Vector<Vector3>& p_array) { type=NIL; - DVector<Vector3> v; + PoolVector<Vector3> v; int len=p_array.size(); if (len>0) { v.resize(len); - DVector<Vector3>::Write w = v.write(); + PoolVector<Vector3>::Write w = v.write(); const Vector3 *r = p_array.ptr(); for (int i=0;i<len;i++) @@ -2627,7 +2627,7 @@ Variant::Variant(const Vector<Vector3>& p_array) { Variant::Variant(const Vector<Color>& p_array) { type=NIL; - DVector<Color> v; + PoolVector<Color> v; int len=p_array.size(); v.resize(len); for (int i=0;i<len;i++) @@ -2826,27 +2826,27 @@ uint32_t Variant::hash() const { } break; case RAW_ARRAY: { - const DVector<uint8_t>& arr = *reinterpret_cast<const DVector<uint8_t>* >(_data._mem); + const PoolVector<uint8_t>& arr = *reinterpret_cast<const PoolVector<uint8_t>* >(_data._mem); int len = arr.size(); - DVector<uint8_t>::Read r = arr.read(); + PoolVector<uint8_t>::Read r = arr.read(); return hash_djb2_buffer((uint8_t*)&r[0],len); } break; case INT_ARRAY: { - const DVector<int>& arr = *reinterpret_cast<const DVector<int>* >(_data._mem); + const PoolVector<int>& arr = *reinterpret_cast<const PoolVector<int>* >(_data._mem); int len = arr.size(); - DVector<int>::Read r = arr.read(); + PoolVector<int>::Read r = arr.read(); return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(int)); } break; case REAL_ARRAY: { - const DVector<real_t>& arr = *reinterpret_cast<const DVector<real_t>* >(_data._mem); + const PoolVector<real_t>& arr = *reinterpret_cast<const PoolVector<real_t>* >(_data._mem); int len = arr.size(); - DVector<real_t>::Read r = arr.read(); + PoolVector<real_t>::Read r = arr.read(); return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(real_t)); @@ -2854,9 +2854,9 @@ uint32_t Variant::hash() const { case STRING_ARRAY: { uint32_t hash=5831; - const DVector<String>& arr = *reinterpret_cast<const DVector<String>* >(_data._mem); + const PoolVector<String>& arr = *reinterpret_cast<const PoolVector<String>* >(_data._mem); int len = arr.size(); - DVector<String>::Read r = arr.read(); + PoolVector<String>::Read r = arr.read(); for(int i=0;i<len;i++) { hash = hash_djb2_one_32(r[i].hash(),hash); @@ -2867,9 +2867,9 @@ uint32_t Variant::hash() const { case VECTOR2_ARRAY: { uint32_t hash=5831; - const DVector<Vector2>& arr = *reinterpret_cast<const DVector<Vector2>* >(_data._mem); + const PoolVector<Vector2>& arr = *reinterpret_cast<const PoolVector<Vector2>* >(_data._mem); int len = arr.size(); - DVector<Vector2>::Read r = arr.read(); + PoolVector<Vector2>::Read r = arr.read(); for(int i=0;i<len;i++) { hash = hash_djb2_one_float(r[i].x,hash); @@ -2882,9 +2882,9 @@ uint32_t Variant::hash() const { case VECTOR3_ARRAY: { uint32_t hash=5831; - const DVector<Vector3>& arr = *reinterpret_cast<const DVector<Vector3>* >(_data._mem); + const PoolVector<Vector3>& arr = *reinterpret_cast<const PoolVector<Vector3>* >(_data._mem); int len = arr.size(); - DVector<Vector3>::Read r = arr.read(); + PoolVector<Vector3>::Read r = arr.read(); for(int i=0;i<len;i++) { hash = hash_djb2_one_float(r[i].x,hash); @@ -2898,9 +2898,9 @@ uint32_t Variant::hash() const { case COLOR_ARRAY: { uint32_t hash=5831; - const DVector<Color>& arr = *reinterpret_cast<const DVector<Color>* >(_data._mem); + const PoolVector<Color>& arr = *reinterpret_cast<const PoolVector<Color>* >(_data._mem); int len = arr.size(); - DVector<Color>::Read r = arr.read(); + PoolVector<Color>::Read r = arr.read(); for(int i=0;i<len;i++) { hash = hash_djb2_one_float(r[i].r,hash); diff --git a/core/variant.h b/core/variant.h index f4bb3b6c8b..a2b9a88b3e 100644 --- a/core/variant.h +++ b/core/variant.h @@ -63,13 +63,13 @@ struct PropertyInfo; struct MethodInfo; -typedef DVector<uint8_t> ByteArray; -typedef DVector<int> IntArray; -typedef DVector<real_t> RealArray; -typedef DVector<String> StringArray; -typedef DVector<Vector2> Vector2Array; -typedef DVector<Vector3> Vector3Array; -typedef DVector<Color> ColorArray; +typedef PoolVector<uint8_t> ByteArray; +typedef PoolVector<int> IntArray; +typedef PoolVector<real_t> RealArray; +typedef PoolVector<String> StringArray; +typedef PoolVector<Vector2> Vector2Array; +typedef PoolVector<Vector3> Vector3Array; +typedef PoolVector<Color> ColorArray; class Variant { public: @@ -227,14 +227,14 @@ public: operator Dictionary() const; operator Array() const; - operator DVector<uint8_t>() const; - operator DVector<int>() const; - operator DVector<real_t>() const; - operator DVector<String>() const; - operator DVector<Vector3>() const; - operator DVector<Color>() const; - operator DVector<Plane>() const; - operator DVector<Face3>() const; + operator PoolVector<uint8_t>() const; + operator PoolVector<int>() const; + operator PoolVector<real_t>() const; + operator PoolVector<String>() const; + operator PoolVector<Vector3>() const; + operator PoolVector<Color>() const; + operator PoolVector<Plane>() const; + operator PoolVector<Face3>() const; operator Vector<Variant>() const; @@ -246,7 +246,7 @@ public: operator Vector<Color>() const; operator Vector<RID>() const; operator Vector<Vector2>() const; - operator DVector<Vector2>() const; + operator PoolVector<Vector2>() const; operator Vector<Plane>() const; // some core type enums to convert to @@ -295,14 +295,14 @@ public: Variant(const Dictionary& p_dictionary); Variant(const Array& p_array); - Variant(const DVector<Plane>& p_array); // helper - Variant(const DVector<uint8_t>& p_raw_array); - Variant(const DVector<int>& p_int_array); - Variant(const DVector<real_t>& p_real_array); - Variant(const DVector<String>& p_string_array); - Variant(const DVector<Vector3>& p_vector3_array); - Variant(const DVector<Color>& p_color_array); - Variant(const DVector<Face3>& p_face_array); + Variant(const PoolVector<Plane>& p_array); // helper + Variant(const PoolVector<uint8_t>& p_raw_array); + Variant(const PoolVector<int>& p_int_array); + Variant(const PoolVector<real_t>& p_real_array); + Variant(const PoolVector<String>& p_string_array); + Variant(const PoolVector<Vector3>& p_vector3_array); + Variant(const PoolVector<Color>& p_color_array); + Variant(const PoolVector<Face3>& p_face_array); Variant(const Vector<Variant>& p_array); @@ -315,7 +315,7 @@ public: Variant(const Vector<Plane>& p_array); // helper Variant(const Vector<RID>& p_array); // helper Variant(const Vector<Vector2>& p_array); // helper - Variant(const DVector<Vector2>& p_array); // helper + Variant(const PoolVector<Vector2>& p_array); // helper Variant(const IP_Address& p_address); diff --git a/core/variant_call.cpp b/core/variant_call.cpp index cedf21b377..a9adc744b6 100644 --- a/core/variant_call.cpp +++ b/core/variant_call.cpp @@ -305,7 +305,7 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var retval.resize(len); ByteArray::Write w = retval.write(); copymem(w.ptr(), charstr.ptr(), len); - w = DVector<uint8_t>::Write(); + w = PoolVector<uint8_t>::Write(); r_ret = retval; } @@ -320,7 +320,7 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var retval.resize(len); ByteArray::Write w = retval.write(); copymem(w.ptr(), charstr.ptr(), len); - w = DVector<uint8_t>::Write(); + w = PoolVector<uint8_t>::Write(); r_ret = retval; } diff --git a/core/variant_op.cpp b/core/variant_op.cpp index 94a2ea9977..a8495a4913 100644 --- a/core/variant_op.cpp +++ b/core/variant_op.cpp @@ -186,16 +186,16 @@ case m_name: { \ r_valid=false;\ return;\ }\ - const DVector<m_type> &array_a=*reinterpret_cast<const DVector<m_type> *>(p_a._data._mem);\ - const DVector<m_type> &array_b=*reinterpret_cast<const DVector<m_type> *>(p_b._data._mem);\ + const PoolVector<m_type> &array_a=*reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem);\ + const PoolVector<m_type> &array_b=*reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem);\ \ int a_len = array_a.size();\ if (a_len m_opa array_b.size()){\ _RETURN( m_ret_s);\ }else {\ \ - DVector<m_type>::Read ra = array_a.read();\ - DVector<m_type>::Read rb = array_b.read();\ + PoolVector<m_type>::Read ra = array_a.read();\ + PoolVector<m_type>::Read rb = array_b.read();\ \ for(int i=0;i<a_len;i++) {\ if (ra[i] m_opb rb[i])\ @@ -212,9 +212,9 @@ case m_name: { \ r_valid=false;\ _RETURN( NIL);\ }\ - const DVector<m_type> &array_a=*reinterpret_cast<const DVector<m_type> *>(p_a._data._mem);\ - const DVector<m_type> &array_b=*reinterpret_cast<const DVector<m_type> *>(p_b._data._mem);\ - DVector<m_type> sum = array_a;\ + const PoolVector<m_type> &array_a=*reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem);\ + const PoolVector<m_type> &array_b=*reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem);\ + PoolVector<m_type> sum = array_a;\ sum.append_array(array_b);\ _RETURN( sum );\ } @@ -1049,10 +1049,10 @@ Variant Variant::get_named(const StringName& p_index, bool *r_valid) const { } break; #define DEFAULT_OP_DVECTOR_SET(m_name, dv_type, skip_cond)\ - DEFAULT_OP_ARRAY_CMD(m_name, DVector<dv_type>, if(skip_cond) return;, arr->set(index, p_value);return) + DEFAULT_OP_ARRAY_CMD(m_name, PoolVector<dv_type>, if(skip_cond) return;, arr->set(index, p_value);return) #define DEFAULT_OP_DVECTOR_GET(m_name, dv_type)\ - DEFAULT_OP_ARRAY_CMD(m_name, const DVector<dv_type>, ;, return arr->get(index)) + DEFAULT_OP_ARRAY_CMD(m_name, const PoolVector<dv_type>, ;, return arr->get(index)) void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) { @@ -2561,10 +2561,10 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { int index = p_index; - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>* >(_data._mem); + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>* >(_data._mem); int l=arr->size(); if (l) { - DVector<uint8_t>::Read r = arr->read(); + PoolVector<uint8_t>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2580,10 +2580,10 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { int index = p_index; - const DVector<int> *arr=reinterpret_cast<const DVector<int>* >(_data._mem); + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>* >(_data._mem); int l=arr->size(); if (l) { - DVector<int>::Read r = arr->read(); + PoolVector<int>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2599,10 +2599,10 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { real_t index = p_index; - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>* >(_data._mem); + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>* >(_data._mem); int l=arr->size(); if (l) { - DVector<real_t>::Read r = arr->read(); + PoolVector<real_t>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2618,11 +2618,11 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { if (p_index.get_type()==Variant::STRING) { String index = p_index; - const DVector<String> *arr=reinterpret_cast<const DVector<String>* >(_data._mem); + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>* >(_data._mem); int l=arr->size(); if (l) { - DVector<String>::Read r = arr->read(); + PoolVector<String>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2638,11 +2638,11 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { if (p_index.get_type()==Variant::VECTOR2) { Vector2 index = p_index; - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>* >(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>* >(_data._mem); int l=arr->size(); if (l) { - DVector<Vector2>::Read r = arr->read(); + PoolVector<Vector2>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2658,11 +2658,11 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { if (p_index.get_type()==Variant::VECTOR3) { Vector3 index = p_index; - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>* >(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>* >(_data._mem); int l=arr->size(); if (l) { - DVector<Vector3>::Read r = arr->read(); + PoolVector<Vector3>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2679,12 +2679,12 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { if (p_index.get_type()==Variant::COLOR) { Color index = p_index; - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>* >(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>* >(_data._mem); int l=arr->size(); if (l) { - DVector<Color>::Read r = arr->read(); + PoolVector<Color>::Read r = arr->read(); for(int i=0;i<l;i++) { if (r[i]==index) return true; @@ -2992,7 +2992,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { return true; } break; case RAW_ARRAY: { - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem); + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3000,7 +3000,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { } break; case INT_ARRAY: { - const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem); + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3008,7 +3008,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { } break; case REAL_ARRAY: { - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem); + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3016,7 +3016,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { } break; case STRING_ARRAY: { - const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem); + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3024,7 +3024,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { } break; case VECTOR2_ARRAY: { - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3032,7 +3032,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { } break; case VECTOR3_ARRAY: { - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3040,7 +3040,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { } break; case COLOR_ARRAY: { - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; @@ -3123,7 +3123,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { return true; } break; case RAW_ARRAY: { - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem); + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3133,7 +3133,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { } break; case INT_ARRAY: { - const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem); + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3143,7 +3143,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { } break; case REAL_ARRAY: { - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem); + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3153,7 +3153,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { } break; case STRING_ARRAY: { - const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem); + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3163,7 +3163,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { } break; case VECTOR2_ARRAY: { - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3173,7 +3173,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { } break; case VECTOR3_ARRAY: { - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3183,7 +3183,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { } break; case COLOR_ARRAY: { - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); int idx=r_iter; idx++; if (idx>=arr->size()) @@ -3255,7 +3255,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { return arr->get(idx); } break; case RAW_ARRAY: { - const DVector<uint8_t> *arr=reinterpret_cast<const DVector<uint8_t>*>(_data._mem); + const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3266,7 +3266,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { return arr->get(idx); } break; case INT_ARRAY: { - const DVector<int> *arr=reinterpret_cast<const DVector<int>*>(_data._mem); + const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3277,7 +3277,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { return arr->get(idx); } break; case REAL_ARRAY: { - const DVector<real_t> *arr=reinterpret_cast<const DVector<real_t>*>(_data._mem); + const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3288,7 +3288,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { return arr->get(idx); } break; case STRING_ARRAY: { - const DVector<String> *arr=reinterpret_cast<const DVector<String>*>(_data._mem); + const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3300,7 +3300,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { } break; case VECTOR2_ARRAY: { - const DVector<Vector2> *arr=reinterpret_cast<const DVector<Vector2>*>(_data._mem); + const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3312,7 +3312,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { } break; case VECTOR3_ARRAY: { - const DVector<Vector3> *arr=reinterpret_cast<const DVector<Vector3>*>(_data._mem); + const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3324,7 +3324,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { } break; case COLOR_ARRAY: { - const DVector<Color> *arr=reinterpret_cast<const DVector<Color>*>(_data._mem); + const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED if (idx<0 || idx>=arr->size()) { @@ -3495,20 +3495,20 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r case REAL_ARRAY:{ r_dst=a; } return; case STRING_ARRAY:{ r_dst=a; } return; case VECTOR2_ARRAY:{ - const DVector<Vector2> *arr_a=reinterpret_cast<const DVector<Vector2>* >(a._data._mem); - const DVector<Vector2> *arr_b=reinterpret_cast<const DVector<Vector2>* >(b._data._mem); + const PoolVector<Vector2> *arr_a=reinterpret_cast<const PoolVector<Vector2>* >(a._data._mem); + const PoolVector<Vector2> *arr_b=reinterpret_cast<const PoolVector<Vector2>* >(b._data._mem); int sz = arr_a->size(); if (sz==0 || arr_b->size()!=sz) { r_dst=a; } else { - DVector<Vector2> v; + PoolVector<Vector2> v; v.resize(sz); { - DVector<Vector2>::Write vw=v.write(); - DVector<Vector2>::Read ar=arr_a->read(); - DVector<Vector2>::Read br=arr_b->read(); + PoolVector<Vector2>::Write vw=v.write(); + PoolVector<Vector2>::Read ar=arr_a->read(); + PoolVector<Vector2>::Read br=arr_b->read(); for(int i=0;i<sz;i++) { vw[i]=ar[i].linear_interpolate(br[i],c); @@ -3523,20 +3523,20 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r case VECTOR3_ARRAY:{ - const DVector<Vector3> *arr_a=reinterpret_cast<const DVector<Vector3>* >(a._data._mem); - const DVector<Vector3> *arr_b=reinterpret_cast<const DVector<Vector3>* >(b._data._mem); + const PoolVector<Vector3> *arr_a=reinterpret_cast<const PoolVector<Vector3>* >(a._data._mem); + const PoolVector<Vector3> *arr_b=reinterpret_cast<const PoolVector<Vector3>* >(b._data._mem); int sz = arr_a->size(); if (sz==0 || arr_b->size()!=sz) { r_dst=a; } else { - DVector<Vector3> v; + PoolVector<Vector3> v; v.resize(sz); { - DVector<Vector3>::Write vw=v.write(); - DVector<Vector3>::Read ar=arr_a->read(); - DVector<Vector3>::Read br=arr_b->read(); + PoolVector<Vector3>::Write vw=v.write(); + PoolVector<Vector3>::Read ar=arr_a->read(); + PoolVector<Vector3>::Read br=arr_b->read(); for(int i=0;i<sz;i++) { vw[i]=ar[i].linear_interpolate(br[i],c); diff --git a/core/variant_parser.cpp b/core/variant_parser.cpp index 597e975873..325c998ec5 100644 --- a/core/variant_parser.cpp +++ b/core/variant_parser.cpp @@ -802,7 +802,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in int len = Image::get_image_data_size(width,height,format,mipmaps); - DVector<uint8_t> buffer; + PoolVector<uint8_t> buffer; buffer.resize(len); if (buffer.size()!=len) { @@ -810,7 +810,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in } { - DVector<uint8_t>::Write w=buffer.write(); + PoolVector<uint8_t>::Write w=buffer.write(); for(int i=0;i<len;i++) { get_token(p_stream,token,line,r_err_str); @@ -1156,11 +1156,11 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in if (err) return err; - DVector<uint8_t> arr; + PoolVector<uint8_t> arr; { int len=args.size(); arr.resize(len); - DVector<uint8_t>::Write w = arr.write(); + PoolVector<uint8_t>::Write w = arr.write(); for(int i=0;i<len;i++) { w[i]=args[i]; } @@ -1177,11 +1177,11 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in if (err) return err; - DVector<int> arr; + PoolVector<int> arr; { int len=args.size(); arr.resize(len); - DVector<int>::Write w = arr.write(); + PoolVector<int>::Write w = arr.write(); for(int i=0;i<len;i++) { w[i]=int(args[i]); } @@ -1198,11 +1198,11 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in if (err) return err; - DVector<float> arr; + PoolVector<float> arr; { int len=args.size(); arr.resize(len); - DVector<float>::Write w = arr.write(); + PoolVector<float>::Write w = arr.write(); for(int i=0;i<len;i++) { w[i]=args[i]; } @@ -1251,11 +1251,11 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in } - DVector<String> arr; + PoolVector<String> arr; { int len=cs.size(); arr.resize(len); - DVector<String>::Write w = arr.write(); + PoolVector<String>::Write w = arr.write(); for(int i=0;i<len;i++) { w[i]=cs[i]; } @@ -1273,11 +1273,11 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in if (err) return err; - DVector<Vector2> arr; + PoolVector<Vector2> arr; { int len=args.size()/2; arr.resize(len); - DVector<Vector2>::Write w = arr.write(); + PoolVector<Vector2>::Write w = arr.write(); for(int i=0;i<len;i++) { w[i]=Vector2(args[i*2+0],args[i*2+1]); } @@ -1294,11 +1294,11 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in if (err) return err; - DVector<Vector3> arr; + PoolVector<Vector3> arr; { int len=args.size()/3; arr.resize(len); - DVector<Vector3>::Write w = arr.write(); + PoolVector<Vector3>::Write w = arr.write(); for(int i=0;i<len;i++) { w[i]=Vector3(args[i*3+0],args[i*3+1],args[i*3+2]); } @@ -1315,11 +1315,11 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in if (err) return err; - DVector<Color> arr; + PoolVector<Color> arr; { int len=args.size()/4; arr.resize(len); - DVector<Color>::Write w = arr.write(); + PoolVector<Color>::Write w = arr.write(); for(int i=0;i<len;i++) { w[i]=Color(args[i*4+0],args[i*4+1],args[i*4+2],args[i*4+3]); } @@ -1986,9 +1986,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str String s; - DVector<uint8_t> data = img.get_data(); + PoolVector<uint8_t> data = img.get_data(); int len = data.size(); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const uint8_t *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2128,9 +2128,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud,"ByteArray( "); String s; - DVector<uint8_t> data = p_variant; + PoolVector<uint8_t> data = p_variant; int len = data.size(); - DVector<uint8_t>::Read r = data.read(); + PoolVector<uint8_t>::Read r = data.read(); const uint8_t *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2147,9 +2147,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str case Variant::INT_ARRAY: { p_store_string_func(p_store_string_ud,"IntArray( "); - DVector<int> data = p_variant; + PoolVector<int> data = p_variant; int len = data.size(); - DVector<int>::Read r = data.read(); + PoolVector<int>::Read r = data.read(); const int *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2167,9 +2167,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str case Variant::REAL_ARRAY: { p_store_string_func(p_store_string_ud,"FloatArray( "); - DVector<real_t> data = p_variant; + PoolVector<real_t> data = p_variant; int len = data.size(); - DVector<real_t>::Read r = data.read(); + PoolVector<real_t>::Read r = data.read(); const real_t *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2185,9 +2185,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str case Variant::STRING_ARRAY: { p_store_string_func(p_store_string_ud,"StringArray( "); - DVector<String> data = p_variant; + PoolVector<String> data = p_variant; int len = data.size(); - DVector<String>::Read r = data.read(); + PoolVector<String>::Read r = data.read(); const String *ptr=r.ptr();; String s; //write_string("\n"); @@ -2208,9 +2208,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str case Variant::VECTOR2_ARRAY: { p_store_string_func(p_store_string_ud,"Vector2Array( "); - DVector<Vector2> data = p_variant; + PoolVector<Vector2> data = p_variant; int len = data.size(); - DVector<Vector2>::Read r = data.read(); + PoolVector<Vector2>::Read r = data.read(); const Vector2 *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2226,9 +2226,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str case Variant::VECTOR3_ARRAY: { p_store_string_func(p_store_string_ud,"Vector3Array( "); - DVector<Vector3> data = p_variant; + PoolVector<Vector3> data = p_variant; int len = data.size(); - DVector<Vector3>::Read r = data.read(); + PoolVector<Vector3>::Read r = data.read(); const Vector3 *ptr=r.ptr();; for (int i=0;i<len;i++) { @@ -2245,9 +2245,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud,"ColorArray( "); - DVector<Color> data = p_variant; + PoolVector<Color> data = p_variant; int len = data.size(); - DVector<Color>::Read r = data.read(); + PoolVector<Color>::Read r = data.read(); const Color *ptr=r.ptr();; for (int i=0;i<len;i++) { diff --git a/core/vector.h b/core/vector.h index 3227561000..3119657cbb 100644 --- a/core/vector.h +++ b/core/vector.h @@ -32,7 +32,7 @@ /** * @class Vector * @author Juan Linietsky - * Vector container. Regular Vector Container. Use with care and for smaller arrays when possible. Use DVector for large arrays. + * Vector container. Regular Vector Container. Use with care and for smaller arrays when possible. Use PoolVector for large arrays. */ #include "os/memory.h" #include "error_macros.h" |