[cpp] Refactored String and Vector.

spine-cpp/spine-cpp-unit-tests/src/main.cpp

@@ -98,8 +98,8 @@ void reproduceIssue_776() {
 	loadJson(R_JSON, R_ATLAS, atlas, skeletonData, stateData, skeleton, state);
 	dispose(atlas, skeletonData, stateData, skeleton, state);
 
-	// loadBinary(R_BINARY, R_ATLAS, atlas, skeletonData, stateData, skeleton, state);
-	// dispose(atlas, skeletonData, stateData, skeleton, state);
+	loadBinary(R_BINARY, R_ATLAS, atlas, skeletonData, stateData, skeleton, state);
+	dispose(atlas, skeletonData, stateData, skeleton, state);
 }
 
 int main (int argc, char** argv) {

spine-cpp/spine-cpp/include/spine/ContainerUtil.h

@@ -112,8 +112,8 @@ namespace Spine {
                 T* item = items[i];
                 
                 delete item;
-                
-                items.erase(i);
+
+                items.removeAt(i);
             }
         }
         

spine-cpp/spine-cpp/include/spine/Pool.h

@@ -52,7 +52,7 @@ namespace Spine {
             if (_objects.size() > 0) {
                 T** object = _objects.begin();
                 T* ret = *object;
-                _objects.erase(0);
+                _objects.removeAt(0);
                 
                 return ret;
             }
@@ -65,7 +65,7 @@ namespace Spine {
         
         void free(T* object) {
             if (!_objects.contains(object)) {
-                _objects.push_back(object);
+                _objects.add(object);
             }
         }
         

spine-cpp/spine-cpp/include/spine/SkeletonBounds.h

@@ -101,7 +101,7 @@ namespace Spine {
         int _count;
         
         Polygon() : _count(0) {
-            _vertices.reserve(16);
+			_vertices.ensureCapacity(16);
         }
     };
 }

spine-cpp/spine-cpp/include/spine/SpineObject.h

@@ -34,6 +34,8 @@
 #include <new>
 
 namespace Spine {
+	class String;
+
 	class SpineObject {
 	public:
 		void* operator new(size_t sz, const char* file, int line);

spine-cpp/spine-cpp/include/spine/String.h

@@ -52,7 +52,7 @@ namespace Spine {
 					_buffer = SpineExtension::alloc<char>(_length + 1, __FILE__, __LINE__);
 					memcpy((void *) _buffer, chars, _length + 1);
 				} else {
-					_buffer = chars;
+					_buffer = (char*)chars;
 				}
 			}
 		}
@@ -98,7 +98,7 @@ namespace Spine {
 				_buffer = 0;
 			} else {
 				_length = strlen(chars);
-				_buffer = chars;
+				_buffer = (char*)chars;
 			}
 		}
 
@@ -134,6 +134,26 @@ namespace Spine {
 			return *this;
 		}
 
+		String& operator+ (const char* chars) {
+			size_t len = strlen(chars);
+			size_t thisLen = _length;
+			_length = _length + len;
+			bool same = chars == _buffer;
+			_buffer = SpineExtension::realloc(_buffer, _length + 1, __FILE__, __LINE__);
+			memcpy((void*)(_buffer + thisLen), (void*)(same ? _buffer: chars), len + 1);
+			return *this;
+		}
+
+		String& operator+ (const String& other) {
+			size_t len = other.length();
+			size_t thisLen = _length;
+			_length = _length + len;
+			bool same = other._buffer == _buffer;
+			_buffer = SpineExtension::realloc(_buffer, _length + 1, __FILE__, __LINE__);
+			memcpy((void*)(_buffer + thisLen), (void*)(same ? _buffer: other._buffer), len + 1);
+			return *this;
+		}
+
 		friend bool operator== (const String& a, const String& b) {
 			if (a._buffer == b._buffer) return true;
 			if (a._length != b._length) return false;
@@ -155,7 +175,7 @@ namespace Spine {
 		}
 	private:
 		mutable size_t _length;
-		mutable const char* _buffer;
+		mutable char* _buffer;
 	};
 }
 

spine-cpp/spine-cpp/include/spine/Vector.h

@@ -81,50 +81,44 @@ namespace Spine {
             deallocate(_buffer);
         }
 
-        bool contains(const T& inValue) {
+        void clear () {
             for (size_t i = 0; i < _size; ++i) {
-                if (_buffer[i] == inValue) {
-                    return true;
-                }
+                destroy(_buffer + (_size - 1 - i));
             }
 
-            return false;
+            _size = 0;
         }
 
-        int indexOf(const T& inValue) {
-            for (size_t i = 0; i < _size; ++i) {
-                if (_buffer[i] == inValue) {
-                    return static_cast<int>(i);
-                }
-            }
-
-            return -1;
+        size_t size() const {
+            return _size;
         }
 
-        void push_back(const T& inValue) {
-            if (_size == _capacity) {
-                reserve();
+        void setSize(size_t newSize) {
+            assert(newSize >= 0);
+            _size = newSize;
+            if (_capacity < newSize) {
+                _capacity = (int)(_size  * 1.75f);
+                if (_capacity < 8) _capacity = 8;
+                _buffer = Spine::SpineExtension::realloc<T>(_buffer, _capacity, __FILE__, __LINE__);
             }
-
-            construct(_buffer + _size++, inValue);
         }
 
-        void insert(size_t inIndex, const T& inValue) {
-            assert(inIndex < _size);
-
-            if (_size == _capacity) {
-                reserve();
-            }
-
-            for (size_t i = ++_size - 1; i > inIndex; --i) {
-                construct(_buffer + i, _buffer[i - 1]);
-                destroy(_buffer + (i - 1));
-            }
-
-            construct(_buffer + inIndex, inValue);
+        void ensureCapacity(size_t newCapacity = 0) {
+            if (_capacity >= newCapacity) return;
+            _capacity = newCapacity;
+            _buffer = SpineExtension::realloc<T>(_buffer, newCapacity, __FILE__, __LINE__);
         }
 
-        void erase(size_t inIndex) {
+		void add(const T &inValue) {
+			if (_size == _capacity) {
+                _capacity = (int)(_size  * 1.75f);
+                if (_capacity < 8) _capacity = 8;
+                _buffer = Spine::SpineExtension::realloc<T>(_buffer, _capacity, __FILE__, __LINE__);
+			}
+			construct(_buffer + _size++, inValue);
+		}
+
+        void removeAt(size_t inIndex) {
             assert(inIndex < _size);
 
             --_size;
@@ -138,16 +132,24 @@ namespace Spine {
             destroy(_buffer + _size);
         }
 
-        void clear() {
+        bool contains(const T& inValue) {
             for (size_t i = 0; i < _size; ++i) {
-                destroy(_buffer + (_size - 1 - i));
+                if (_buffer[i] == inValue) {
+                    return true;
+                }
             }
 
-            _size = 0;
+            return false;
         }
 
-        size_t size() const {
-            return _size;
+        int indexOf(const T& inValue) {
+            for (size_t i = 0; i < _size; ++i) {
+                if (_buffer[i] == inValue) {
+                    return static_cast<int>(i);
+                }
+            }
+
+            return -1;
         }
 
         T& operator[](size_t inIndex) {
@@ -156,20 +158,6 @@ namespace Spine {
             return _buffer[inIndex];
         }
 
-        void reserve(size_t inCapacity = 0) {
-            size_t newCapacity = inCapacity > 0 ? inCapacity : _capacity > 0 ? _capacity * 2 : 1;
-            if (newCapacity > _capacity) {
-                _buffer = SpineExtension::realloc<T>(_buffer, newCapacity, __FILE__, __LINE__);
-                _capacity = newCapacity;
-            }
-        }
-
-        void setSize(size_t inValue) {
-            assert(inValue <= _capacity);
-
-            _size = inValue;
-        }
-
         T* begin() {
             return &_buffer[0];
         }

spine-cpp/spine-cpp/src/spine/AnimationState.cpp

@@ -135,22 +135,22 @@ namespace Spine {
     
     TrackEntry* TrackEntry::setTimelineData(TrackEntry* to, Vector<TrackEntry*>& mixingToArray, Vector<int>& propertyIDs) {
         if (to != NULL) {
-            mixingToArray.push_back(to);
+            mixingToArray.add(to);
         }
         
         TrackEntry* lastEntry = _mixingFrom != NULL ? _mixingFrom->setTimelineData(this, mixingToArray, propertyIDs) : this;
         
         if (to != NULL) {
-            mixingToArray.erase(mixingToArray.size() - 1);
+            mixingToArray.removeAt(mixingToArray.size() - 1);
         }
         
         int mixingToLast = static_cast<int>(mixingToArray.size()) - 1;
         Vector<Timeline*>& timelines = _animation->_timelines;
         int timelinesCount = static_cast<int>(timelines.size());
-        _timelineData.reserve(timelinesCount);
+        _timelineData.ensureCapacity(timelinesCount);
         _timelineData.setSize(timelinesCount);
         _timelineDipMix.clear();
-        _timelineDipMix.reserve(timelinesCount);
+        _timelineDipMix.ensureCapacity(timelinesCount);
         _timelineDipMix.setSize(timelinesCount);
         
         // outer:
@@ -160,7 +160,7 @@ namespace Spine {
                 _timelineData[i] = AnimationState::Subsequent;
             }
             else {
-                propertyIDs.push_back(id);
+                propertyIDs.add(id);
                 
                 if (to == NULL || !to->hasTimeline(id)) {
                     _timelineData[i] = AnimationState::First;
@@ -232,29 +232,29 @@ namespace Spine {
     }
     
     void EventQueue::start(TrackEntry* entry) {
-        _eventQueueEntries.push_back(newEventQueueEntry(EventType_Start, entry));
+        _eventQueueEntries.add(newEventQueueEntry(EventType_Start, entry));
         _state._animationsChanged = true;
     }
     
     void EventQueue::interrupt(TrackEntry* entry) {
-        _eventQueueEntries.push_back(newEventQueueEntry(EventType_Interrupt, entry));
+        _eventQueueEntries.add(newEventQueueEntry(EventType_Interrupt, entry));
     }
     
     void EventQueue::end(TrackEntry* entry) {
-        _eventQueueEntries.push_back(newEventQueueEntry(EventType_End, entry));
+        _eventQueueEntries.add(newEventQueueEntry(EventType_End, entry));
         _state._animationsChanged = true;
     }
     
     void EventQueue::dispose(TrackEntry* entry) {
-        _eventQueueEntries.push_back(newEventQueueEntry(EventType_Dispose, entry));
+        _eventQueueEntries.add(newEventQueueEntry(EventType_Dispose, entry));
     }
     
     void EventQueue::complete(TrackEntry* entry) {
-        _eventQueueEntries.push_back(newEventQueueEntry(EventType_Complete, entry));
+        _eventQueueEntries.add(newEventQueueEntry(EventType_Complete, entry));
     }
     
     void EventQueue::event(TrackEntry* entry, Event* event) {
-        _eventQueueEntries.push_back(newEventQueueEntry(EventType_Event, entry, event));
+        _eventQueueEntries.add(newEventQueueEntry(EventType_Event, entry, event));
     }
     
     /// Raises all events in the queue and drains the queue.
@@ -424,7 +424,7 @@ namespace Spine {
                 
                 bool firstFrame = current._timelinesRotation.size() == 0;
                 if (firstFrame) {
-                    current._timelinesRotation.reserve(timelines.size() << 1);
+                    current._timelinesRotation.ensureCapacity(timelines.size() << 1);
                     current._timelinesRotation.setSize(timelines.size() << 1);
                 }
                 Vector<float>& timelinesRotation = current._timelinesRotation;
@@ -781,7 +781,7 @@ namespace Spine {
         bool firstFrame = from->_timelinesRotation.size() == 0;
         if (firstFrame) {
             // from.timelinesRotation.setSize
-            from->_timelinesRotation.reserve(timelines.size() << 1);
+            from->_timelinesRotation.ensureCapacity(timelines.size() << 1);
             from->_timelinesRotation.setSize(timelines.size() << 1);
         }
         
@@ -908,7 +908,7 @@ namespace Spine {
         }
         
         while (index >= _tracks.size()) {
-            _tracks.push_back(NULL);
+            _tracks.add(NULL);
         }
         
         return NULL;

spine-cpp/spine-cpp/src/spine/Atlas.cpp

@@ -163,7 +163,7 @@ namespace Spine {
 
                 SpineExtension::free(path, __FILE__, __LINE__);
 
-                _pages.push_back(page);
+                _pages.add(page);
             }
             else {
                 AtlasRegion* region = new (__FILE__, __LINE__) AtlasRegion();
@@ -198,7 +198,7 @@ namespace Spine {
 
                 if (count == 4) {
                     /* split is optional */
-                    region->splits.reserve(4);
+                    region->splits.ensureCapacity(4);
                     region->splits.setSize(4);
                     region->splits[0] = toInt(tuple);
                     region->splits[1] = toInt(tuple + 1);
@@ -210,7 +210,7 @@ namespace Spine {
 
                     if (count == 4) {
                         /* pad is optional, but only present with splits */
-                        region->pads.reserve(4);
+                        region->pads.ensureCapacity(4);
                         region->pads.setSize(4);
                         region->pads[0] = toInt(tuple);
                         region->pads[1] = toInt(tuple + 1);
@@ -232,7 +232,7 @@ namespace Spine {
 
                 region->index = toInt(&str);
 
-                _regions.push_back(region);
+                _regions.add(region);
             }
         }
     }

spine-cpp/spine-cpp/src/spine/AttachmentTimeline.cpp

@@ -42,13 +42,13 @@ namespace Spine {
     RTTI_IMPL(AttachmentTimeline, Timeline);
     
     AttachmentTimeline::AttachmentTimeline(int frameCount) : Timeline(), _slotIndex(0) {
-        _frames.reserve(frameCount);
-        _attachmentNames.reserve(frameCount);
+        _frames.ensureCapacity(frameCount);
+        _attachmentNames.ensureCapacity(frameCount);
         
         _frames.setSize(frameCount);
         
         for (int i = 0; i < frameCount; ++i) {
-            _attachmentNames.push_back(String());
+            _attachmentNames.add(String());
         }
     }
     

spine-cpp/spine-cpp/src/spine/ColorTimeline.cpp

@@ -53,7 +53,7 @@ namespace Spine {
     const int ColorTimeline::A = 4;
     
     ColorTimeline::ColorTimeline(int frameCount) : CurveTimeline(frameCount), _slotIndex(0) {
-        _frames.reserve(frameCount * ENTRIES);
+		_frames.ensureCapacity(frameCount * ENTRIES);
         _frames.setSize(frameCount * ENTRIES);
     }
     

spine-cpp/spine-cpp/src/spine/CurveTimeline.cpp

@@ -42,14 +42,14 @@ namespace Spine {
     
     CurveTimeline::CurveTimeline(int frameCount) {
         assert(frameCount > 0);
-        
-        _curves.reserve((frameCount - 1) * BEZIER_SIZE);
+
+        _curves.ensureCapacity((frameCount - 1) * BEZIER_SIZE);
         _curves.setSize((frameCount - 1) * BEZIER_SIZE);
     }
 
     CurveTimeline::~CurveTimeline() {
     }
-    
+
     int CurveTimeline::getFrameCount() {
         return static_cast<int>(_curves.size() / BEZIER_SIZE + 1);
     }

spine-cpp/spine-cpp/src/spine/DeformTimeline.cpp

@@ -44,14 +44,14 @@ namespace Spine {
     RTTI_IMPL(DeformTimeline, CurveTimeline);
     
     DeformTimeline::DeformTimeline(int frameCount) : CurveTimeline(frameCount), _slotIndex(0), _attachment(NULL) {
-        _frames.reserve(frameCount);
-        _frameVertices.reserve(frameCount);
+        _frames.ensureCapacity(frameCount);
+        _frameVertices.ensureCapacity(frameCount);
         
         _frames.setSize(frameCount);
         
         for (int i = 0; i < frameCount; ++i) {
             Vector<float> vec;
-            _frameVertices.push_back(vec);
+            _frameVertices.add(vec);
         }
     }
     
@@ -87,7 +87,7 @@ namespace Spine {
                     }
                     
                     // Ensure size and preemptively set count.
-                    vertices.reserve(vertexCount);
+                    vertices.ensureCapacity(vertexCount);
                     vertices.setSize(vertexCount);
                     
                     if (vertexAttachment->_bones.size() == 0) {
@@ -111,7 +111,7 @@ namespace Spine {
         }
         
         // Ensure size and preemptively set count.
-        vertices.reserve(vertexCount);
+        vertices.ensureCapacity(vertexCount);
         vertices.setSize(vertexCount);
         
         if (time >= _frames[_frames.size() - 1]) {
@@ -122,7 +122,7 @@ namespace Spine {
                 vertices.clear();
                 for (int i = 0; i < vertexCount; ++i) {
                     float vertex = lastVertices[i];
-                    vertices.push_back(vertex);
+                    vertices.add(vertex);
                 }
             }
             else if (pose == MixPose_Setup) {

spine-cpp/spine-cpp/src/spine/DrawOrderTimeline.cpp

@@ -42,14 +42,14 @@ namespace Spine {
     RTTI_IMPL(DrawOrderTimeline, Timeline);
     
     DrawOrderTimeline::DrawOrderTimeline(int frameCount) : Timeline() {
-        _frames.reserve(frameCount);
-        _drawOrders.reserve(frameCount);
+		_frames.ensureCapacity(frameCount);
+		_drawOrders.ensureCapacity(frameCount);
         
         _frames.setSize(frameCount);
         
         for (int i = 0; i < frameCount; ++i) {
             Vector<int> vec;
-            _drawOrders.push_back(vec);
+            _drawOrders.add(vec);
         }
     }
     
@@ -58,9 +58,9 @@ namespace Spine {
         Vector<Slot*>& slots = skeleton._slots;
         if (direction == MixDirection_Out && pose == MixPose_Setup) {
             drawOrder.clear();
-            drawOrder.reserve(slots.size());
+			drawOrder.ensureCapacity(slots.size());
             for (int i = 0, n = static_cast<int>(slots.size()); i < n; ++i) {
-                drawOrder.push_back(slots[i]);
+                drawOrder.add(slots[i]);
             }
             return;
         }
@@ -68,9 +68,9 @@ namespace Spine {
         if (time < _frames[0]) {
             if (pose == MixPose_Setup) {
                 drawOrder.clear();
-                drawOrder.reserve(slots.size());
+				drawOrder.ensureCapacity(slots.size());
                 for (int i = 0, n = static_cast<int>(slots.size()); i < n; ++i) {
-                    drawOrder.push_back(slots[i]);
+                    drawOrder.add(slots[i]);
                 }
             }
             return;
@@ -89,7 +89,7 @@ namespace Spine {
         if (drawOrderToSetupIndex.size() == 0) {
             drawOrder.clear();
             for (int i = 0, n = static_cast<int>(slots.size()); i < n; ++i) {
-                drawOrder.push_back(slots[i]);
+                drawOrder.add(slots[i]);
             }
         }
         else {

spine-cpp/spine-cpp/src/spine/EventTimeline.cpp

@@ -44,8 +44,8 @@ namespace Spine {
     RTTI_IMPL(EventTimeline, Timeline);
     
     EventTimeline::EventTimeline(int frameCount) : Timeline() {
-        _frames.reserve(frameCount);
-        _events.reserve(frameCount);
+		_frames.ensureCapacity(frameCount);
+		_events.ensureCapacity(frameCount);
         
         _frames.setSize(frameCount);
         _events.setSize(frameCount);
@@ -99,7 +99,7 @@ namespace Spine {
         }
         
         for (; frame < frameCount && time >= _frames[frame]; ++frame) {
-            events.push_back(_events[frame]);
+            events.add(_events[frame]);
         }
     }
     

spine-cpp/spine-cpp/src/spine/IkConstraint.cpp

@@ -247,11 +247,11 @@ namespace Spine {
     _mix(data.getMix()),
     _bendDirection(data.getBendDirection()),
     _target(skeleton.findBone(data.getTarget()->getName())) {
-        _bones.reserve(_data.getBones().size());
+        _bones.ensureCapacity(_data.getBones().size());
         for (BoneData** i = _data.getBones().begin(); i != _data.getBones().end(); ++i) {
             BoneData* boneData = (*i);
-            
-            _bones.push_back(skeleton.findBone(boneData->getName()));
+
+            _bones.add(skeleton.findBone(boneData->getName()));
         }
     }
     

spine-cpp/spine-cpp/src/spine/IkConstraintTimeline.cpp

@@ -51,7 +51,7 @@ namespace Spine {
     const int IkConstraintTimeline::BEND_DIRECTION = 2;
     
     IkConstraintTimeline::IkConstraintTimeline(int frameCount) : CurveTimeline(frameCount), _ikConstraintIndex(0) {
-        _frames.reserve(frameCount * ENTRIES);
+		_frames.ensureCapacity(frameCount * ENTRIES);
         _frames.setSize(frameCount * ENTRIES);
     }
     

spine-cpp/spine-cpp/src/spine/MeshAttachment.cpp

@@ -62,7 +62,7 @@ namespace Spine {
     void MeshAttachment::updateUVs() {
         float u = _regionU, v = _regionV, width = _regionU2 - _regionU, height = _regionV2 - _regionV;
         if (_uvs.size() != _regionUVs.size()) {
-            _uvs.reserve(_regionUVs.size());
+			_uvs.ensureCapacity(_regionUVs.size());
             _uvs.setSize(_regionUVs.size());
         }
         

spine-cpp/spine-cpp/src/spine/PathConstraint.cpp

@@ -58,14 +58,14 @@ namespace Spine {
     _spacing(data.getSpacing()),
     _rotateMix(data.getRotateMix()),
     _translateMix(data.getTranslateMix()) {
-        _bones.reserve(_data.getBones().size());
+        _bones.ensureCapacity(_data.getBones().size());
         for (BoneData** i = _data.getBones().begin(); i != _data.getBones().end(); ++i) {
             BoneData* boneData = (*i);
-            
-            _bones.push_back(skeleton.findBone(boneData->getName()));
+
+            _bones.add(skeleton.findBone(boneData->getName()));
         }
-        
-        _segments.reserve(10);
+
+        _segments.ensureCapacity(10);
         _segments.setSize(10);
     }
     
@@ -96,12 +96,12 @@ namespace Spine {
         bool tangents = rotateMode == RotateMode_Tangent, scale = rotateMode == RotateMode_ChainScale;
         size_t boneCount = _bones.size();
         int spacesCount = static_cast<int>(tangents ? boneCount : boneCount + 1);
-        _spaces.reserve(spacesCount);
+        _spaces.ensureCapacity(spacesCount);
         _spaces.setSize(spacesCount);
         float spacing = _spacing;
         if (scale || lengthSpacing) {
             if (scale) {
-                _lengths.reserve(boneCount);
+                _lengths.ensureCapacity(boneCount);
                 _lengths.setSize(boneCount);
             }
             
@@ -268,7 +268,7 @@ namespace Spine {
     Vector<float> PathConstraint::computeWorldPositions(PathAttachment& path, int spacesCount, bool tangents, bool percentPosition, bool percentSpacing) {
         Slot& target = *_target;
         float position = _position;
-        _positions.reserve(spacesCount * 3 + 2);
+        _positions.ensureCapacity(spacesCount * 3 + 2);
         _positions.setSize(spacesCount * 3 + 2);
         bool closed = path.isClosed();
         int verticesLength = path.getWorldVerticesLength();
@@ -289,8 +289,8 @@ namespace Spine {
                     _spaces[i] *= pathLength;
                 }
             }
-            
-            _world.reserve(8);
+
+            _world.ensureCapacity(8);
             _world.setSize(8);
             for (int i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
                 float space = _spaces[i];
@@ -362,7 +362,7 @@ namespace Spine {
         // World vertices.
         if (closed) {
             verticesLength += 2;
-            _world.reserve(verticesLength);
+            _world.ensureCapacity(verticesLength);
             _world.setSize(verticesLength);
             path.computeWorldVertices(target, 2, verticesLength - 4, _world, 0);
             path.computeWorldVertices(target, 0, 2, _world, verticesLength - 4);
@@ -372,13 +372,13 @@ namespace Spine {
         else {
             curveCount--;
             verticesLength -= 4;
-            _world.reserve(verticesLength);
+            _world.ensureCapacity(verticesLength);
             _world.setSize(verticesLength);
             path.computeWorldVertices(target, 2, verticesLength, _world, 0);
         }
         
         // Curve lengths.
-        _curves.reserve(curveCount);
+        _curves.ensureCapacity(curveCount);
         _curves.setSize(curveCount);
         pathLength = 0;
         float x1 = _world[0], y1 = _world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;

spine-cpp/spine-cpp/src/spine/PathConstraintMixTimeline.cpp

@@ -51,7 +51,7 @@ namespace Spine {
     const int PathConstraintMixTimeline::TRANSLATE = 2;
     
     PathConstraintMixTimeline::PathConstraintMixTimeline(int frameCount) : CurveTimeline(frameCount), _pathConstraintIndex(0) {
-        _frames.reserve(frameCount * ENTRIES);
+		_frames.ensureCapacity(frameCount * ENTRIES);
         _frames.setSize(frameCount * ENTRIES);
     }
     

spine-cpp/spine-cpp/src/spine/PathConstraintPositionTimeline.cpp

@@ -49,7 +49,7 @@ namespace Spine {
     const int PathConstraintPositionTimeline::VALUE = 1;
     
     PathConstraintPositionTimeline::PathConstraintPositionTimeline(int frameCount) : CurveTimeline(frameCount), _pathConstraintIndex(0) {
-        _frames.reserve(frameCount * ENTRIES);
+		_frames.ensureCapacity(frameCount * ENTRIES);
         _frames.setSize(frameCount * ENTRIES);
     }
 

spine-cpp/spine-cpp/src/spine/RegionAttachment.cpp

@@ -72,8 +72,8 @@ namespace Spine {
     _g(0),
     _b(0),
     _a(0) {
-        _offset.reserve(NUM_UVS);
-        _uvs.reserve(NUM_UVS);
+        _offset.ensureCapacity(NUM_UVS);
+        _uvs.ensureCapacity(NUM_UVS);
         
         _offset.setSize(NUM_UVS);
         _uvs.setSize(NUM_UVS);

spine-cpp/spine-cpp/src/spine/RotateTimeline.cpp

@@ -42,7 +42,7 @@ namespace Spine {
     RTTI_IMPL(RotateTimeline, CurveTimeline);
     
     RotateTimeline::RotateTimeline(int frameCount) : CurveTimeline(frameCount), _boneIndex(0) {
-        _frames.reserve(frameCount << 1);
+		_frames.ensureCapacity(frameCount << 1);
         _frames.setSize(frameCount << 1);
     }
     

spine-cpp/spine-cpp/src/spine/Skeleton.cpp

@@ -65,7 +65,7 @@ namespace Spine {
     _flipY(false),
     _x(0),
     _y(0) {
-        _bones.reserve(_data->getBones().size());
+        _bones.ensureCapacity(_data->getBones().size());
         for (BoneData** i = _data->getBones().begin(); i != _data->getBones().end(); ++i) {
             BoneData* data = (*i);
             
@@ -76,49 +76,49 @@ namespace Spine {
             else {
                 Bone* parent = _bones[data->getParent()->getIndex()];
                 bone = new (__FILE__, __LINE__) Bone(*data, *this, parent);
-                parent->getChildren().push_back(bone);
+				parent->getChildren().add(bone);
             }
-            
-            _bones.push_back(bone);
+
+			_bones.add(bone);
         }
-        
-        _slots.reserve(_data->getSlots().size());
-        _drawOrder.reserve(_data->getSlots().size());
+
+        _slots.ensureCapacity(_data->getSlots().size());
+        _drawOrder.ensureCapacity(_data->getSlots().size());
         for (SlotData** i = _data->getSlots().begin(); i != _data->getSlots().end(); ++i) {
             SlotData* data = (*i);
             
             Bone* bone = _bones[data->getBoneData().getIndex()];
             Slot* slot = new (__FILE__, __LINE__) Slot(*data, *bone);
-            
-            _slots.push_back(slot);
-            _drawOrder.push_back(slot);
+
+			_slots.add(slot);
+			_drawOrder.add(slot);
         }
-        
-        _ikConstraints.reserve(_data->getIkConstraints().size());
+
+        _ikConstraints.ensureCapacity(_data->getIkConstraints().size());
         for (IkConstraintData** i = _data->getIkConstraints().begin(); i != _data->getIkConstraints().end(); ++i) {
             IkConstraintData* data = (*i);
             
             IkConstraint* constraint = new (__FILE__, __LINE__) IkConstraint(*data, *this);
-            
-            _ikConstraints.push_back(constraint);
+
+			_ikConstraints.add(constraint);
         }
-        
-        _transformConstraints.reserve(_data->getTransformConstraints().size());
+
+        _transformConstraints.ensureCapacity(_data->getTransformConstraints().size());
         for (TransformConstraintData** i = _data->getTransformConstraints().begin(); i != _data->getTransformConstraints().end(); ++i) {
             TransformConstraintData* data = (*i);
             
             TransformConstraint* constraint = new (__FILE__, __LINE__) TransformConstraint(*data, *this);
-            
-            _transformConstraints.push_back(constraint);
+
+			_transformConstraints.add(constraint);
         }
-        
-        _pathConstraints.reserve(_data->getPathConstraints().size());
+
+        _pathConstraints.ensureCapacity(_data->getPathConstraints().size());
         for (PathConstraintData** i = _data->getPathConstraints().begin(); i != _data->getPathConstraints().end(); ++i) {
             PathConstraintData* data = (*i);
             
             PathConstraint* constraint = new (__FILE__, __LINE__) PathConstraint(*data, *this);
-            
-            _pathConstraints.push_back(constraint);
+
+			_pathConstraints.add(constraint);
         }
         
         updateCache();
@@ -261,7 +261,7 @@ namespace Spine {
     void Skeleton::setSlotsToSetupPose() {
         _drawOrder.clear();
         for (int i = 0, n = static_cast<int>(_slots.size()); i < n; ++i) {
-            _drawOrder.push_back(_slots[i]);
+			_drawOrder.add(_slots[i]);
         }
         
         for (int i = 0, n = static_cast<int>(_slots.size()); i < n; ++i) {
@@ -416,7 +416,7 @@ namespace Spine {
 
                 verticesLength = 8;
                 if (outVertexBuffer.size() < 8) {
-                    outVertexBuffer.reserve(8);
+                    outVertexBuffer.ensureCapacity(8);
                     outVertexBuffer.setSize(8);
                 }
                 regionAttachment->computeWorldVertices(slot->getBone(), outVertexBuffer, 0);
@@ -426,7 +426,7 @@ namespace Spine {
 
                 verticesLength = mesh->getWorldVerticesLength();
                 if (outVertexBuffer.size() < verticesLength) {
-                    outVertexBuffer.reserve(verticesLength);
+                    outVertexBuffer.ensureCapacity(verticesLength);
                     outVertexBuffer.setSize(verticesLength);
                 }
 
@@ -573,11 +573,11 @@ namespace Spine {
         if (constrained.size() > 1) {
             Bone* child = constrained[constrained.size() - 1];
             if (!_updateCache.contains(child)) {
-                _updateCacheReset.push_back(child);
+				_updateCacheReset.add(child);
             }
         }
-        
-        _updateCache.push_back(constraint);
+
+		_updateCache.add(constraint);
         
         sortReset(parent->getChildren());
         constrained[constrained.size() - 1]->_sorted = true;
@@ -610,8 +610,8 @@ namespace Spine {
         for (int i = 0; i < boneCount; ++i) {
             sortBone(constrained[i]);
         }
-        
-        _updateCache.push_back(constraint);
+
+		_updateCache.add(constraint);
         
         for (int i = 0; i < boneCount; ++i) {
             sortReset(constrained[i]->getChildren());
@@ -632,7 +632,7 @@ namespace Spine {
                 Bone* child = constrained[i];
                 sortBone(child->getParent());
                 if (!_updateCache.contains(child)) {
-                    _updateCacheReset.push_back(child);
+					_updateCacheReset.add(child);
                 }
             }
         }
@@ -641,8 +641,8 @@ namespace Spine {
                 sortBone(constrained[i]);
             }
         }
-        
-        _updateCache.push_back(constraint);
+
+		_updateCache.add(constraint);
         
         for (int i = 0; i < boneCount; ++i) {
             sortReset(constrained[i]->getChildren());
@@ -700,8 +700,8 @@ namespace Spine {
         }
         
         bone->_sorted = true;
-        
-        _updateCache.push_back(bone);
+
+		_updateCache.add(bone);
     }
     
     void Skeleton::sortReset(Vector<Bone*>& bones) {

spine-cpp/spine-cpp/src/spine/SkeletonBinary.cpp

@@ -154,7 +154,7 @@ namespace Spine {
         
         /* Bones. */
         int bonesCount = readVarint(input, true);
-        skeletonData->_bones.reserve(bonesCount);
+        skeletonData->_bones.ensureCapacity(bonesCount);
         skeletonData->_bones.setSize(bonesCount);
         for (i = 0; i < bonesCount; ++i) {
             BoneData* data;
@@ -201,7 +201,7 @@ namespace Spine {
 
         /* Slots. */
         int slotsCount = readVarint(input, true);
-        skeletonData->_slots.reserve(slotsCount);
+        skeletonData->_slots.ensureCapacity(slotsCount);
         skeletonData->_slots.setSize(slotsCount);
         for (i = 0; i < slotsCount; ++i) {
             int r, g, b, a;
@@ -228,7 +228,7 @@ namespace Spine {
 
         /* IK constraints. */
         int ikConstraintsCount = readVarint(input, true);
-        skeletonData->_ikConstraints.reserve(ikConstraintsCount);
+        skeletonData->_ikConstraints.ensureCapacity(ikConstraintsCount);
         skeletonData->_ikConstraints.setSize(ikConstraintsCount);
         for (i = 0; i < ikConstraintsCount; ++i) {
             const char* name = readString(input);
@@ -238,7 +238,7 @@ namespace Spine {
             data->_order = readVarint(input, true);
 
             int bonesCount = readVarint(input, true);
-            data->_bones.reserve(bonesCount);
+            data->_bones.ensureCapacity(bonesCount);
             data->_bones.setSize(bonesCount);
             for (ii = 0; ii < bonesCount; ++ii) {
                 data->_bones[ii] = skeletonData->_bones[readVarint(input, true)];
@@ -252,7 +252,7 @@ namespace Spine {
 
         /* Transform constraints. */
         int transformConstraintsCount = readVarint(input, true);
-        skeletonData->_transformConstraints.reserve(transformConstraintsCount);
+        skeletonData->_transformConstraints.ensureCapacity(transformConstraintsCount);
         skeletonData->_transformConstraints.setSize(transformConstraintsCount);
         for (i = 0; i < transformConstraintsCount; ++i) {
             const char* name = readString(input);
@@ -261,7 +261,7 @@ namespace Spine {
             
             data->_order = readVarint(input, true);
             int bonesCount = readVarint(input, true);
-            data->_bones.reserve(bonesCount);
+            data->_bones.ensureCapacity(bonesCount);
             data->_bones.setSize(bonesCount);
             for (ii = 0; ii < bonesCount; ++ii) {
                 data->_bones[ii] = skeletonData->_bones[readVarint(input, true)];
@@ -285,7 +285,7 @@ namespace Spine {
 
         /* Path constraints */
         int pathConstraintsCount = readVarint(input, true);
-        skeletonData->_pathConstraints.reserve(pathConstraintsCount);
+        skeletonData->_pathConstraints.ensureCapacity(pathConstraintsCount);
         skeletonData->_pathConstraints.setSize(pathConstraintsCount);
         for (i = 0; i < pathConstraintsCount; ++i) {
             const char* name = readString(input);
@@ -295,7 +295,7 @@ namespace Spine {
             data->_order = readVarint(input, true);
             
             int bonesCount = readVarint(input, true);
-            data->_bones.reserve(bonesCount);
+            data->_bones.ensureCapacity(bonesCount);
             data->_bones.setSize(bonesCount);
             for (ii = 0; ii < bonesCount; ++ii) {
                 data->_bones[ii] = skeletonData->_bones[readVarint(input, true)];
@@ -328,7 +328,7 @@ namespace Spine {
             ++skinsCount;
         }
 
-        skeletonData->_skins.reserve(skinsCount);
+        skeletonData->_skins.ensureCapacity(skinsCount);
         skeletonData->_skins.setSize(skinsCount);
 
         if (skeletonData->_defaultSkin) {
@@ -366,7 +366,7 @@ namespace Spine {
 
         /* Events. */
         int eventsCount = readVarint(input, true);
-        skeletonData->_events.reserve(eventsCount);
+        skeletonData->_events.ensureCapacity(eventsCount);
         skeletonData->_events.setSize(eventsCount);
         for (i = 0; i < eventsCount; ++i) {
             const char* name = readString(input);
@@ -380,7 +380,7 @@ namespace Spine {
 
         /* Animations. */
         int animationsCount = readVarint(input, true);
-        skeletonData->_animations.reserve(animationsCount);
+        skeletonData->_animations.ensureCapacity(animationsCount);
         skeletonData->_animations.setSize(animationsCount);
         for (i = 0; i < animationsCount; ++i) {
             const char* name = readString(input);
@@ -634,7 +634,7 @@ namespace Spine {
                 }
                 
                 LinkedMesh* linkedMesh = new (__FILE__, __LINE__) LinkedMesh(mesh, String(skinName), slotIndex, String(parent));
-                _linkedMeshes.push_back(linkedMesh);
+				_linkedMeshes.add(linkedMesh);
                 
                 if (freeName) {
                     SpineExtension::free(name, __FILE__, __LINE__);
@@ -653,7 +653,7 @@ namespace Spine {
                 vertexCount = readVarint(input, true);
                 readVertices(input, static_cast<VertexAttachment*>(path), vertexCount);
                 int lengthsLength = vertexCount / 3;
-                path->_lengths.reserve(lengthsLength);
+                path->_lengths.ensureCapacity(lengthsLength);
                 path->_lengths.setSize(lengthsLength);
                 for (i = 0; i < lengthsLength; ++i) {
                     path->_lengths[i] = readFloat(input) * _scale;
@@ -721,17 +721,17 @@ namespace Spine {
         }
         
         Vertices vertices;
-        vertices._bones.reserve(verticesLength * 3);
-        vertices._vertices.reserve(verticesLength * 3 * 3);
+        vertices._bones.ensureCapacity(verticesLength * 3);
+        vertices._vertices.ensureCapacity(verticesLength * 3 * 3);
         
         for (int i = 0; i < vertexCount; ++i) {
             int boneCount = readVarint(input, true);
-            vertices._bones.push_back(boneCount);
+			vertices._bones.add(boneCount);
             for (int ii = 0; ii < boneCount; ++ii) {
-                vertices._bones.push_back(readVarint(input, true));
-                vertices._vertices.push_back(readFloat(input) * scale);
-                vertices._vertices.push_back(readFloat(input) * scale);
-                vertices._vertices.push_back(readFloat(input));
+				vertices._bones.add(readVarint(input, true));
+				vertices._vertices.add(readFloat(input) * scale);
+				vertices._vertices.add(readFloat(input) * scale);
+				vertices._vertices.add(readFloat(input));
             }
         }
         
@@ -741,7 +741,7 @@ namespace Spine {
     
     Vector<float> SkeletonBinary::readFloatArray(DataInput *input, int n, float scale) {
         Vector<float> array;
-        array.reserve(n);
+        array.ensureCapacity(n);
         array.setSize(n);
         
         int i;
@@ -763,7 +763,7 @@ namespace Spine {
         int n = readVarint(input, true);
         
         Vector<short> array;
-        array.reserve(n);
+        array.ensureCapacity(n);
         array.setSize(n);
         
         int i;
@@ -791,10 +791,9 @@ namespace Spine {
                         AttachmentTimeline* timeline = new (__FILE__, __LINE__) AttachmentTimeline(frameCount);
                         timeline->_slotIndex = slotIndex;
                         for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) {
-                            const char* attachmentName = readString(input);
-                            timeline->setFrame(frameIndex, readFloat(input), String(attachmentName, true));
+                            timeline->setFrame(frameIndex, readFloat(input), String(readString(input), true));
                         }
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                         duration = MAX(duration, timeline->_frames[frameCount - 1]);
                         break;
                     }
@@ -813,7 +812,7 @@ namespace Spine {
                                 readCurve(input, frameIndex, timeline);
                             }
                         }
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                         duration = MAX(duration, timeline->_frames[(frameCount - 1) * ColorTimeline::ENTRIES]);
                         break;
                     }
@@ -837,7 +836,7 @@ namespace Spine {
                                 readCurve(input, frameIndex, timeline);
                             }
                         }
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                         duration = MAX(duration, timeline->_frames[(frameCount - 1) * TwoColorTimeline::ENTRIES]);
                         break;
                     }
@@ -866,7 +865,7 @@ namespace Spine {
                                 readCurve(input, frameIndex, timeline);
                             }
                         }
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                         duration = MAX(duration, timeline->_frames[(frameCount - 1) * RotateTimeline::ENTRIES]);
                         break;
                     }
@@ -892,7 +891,7 @@ namespace Spine {
                                 readCurve(input, frameIndex, timeline);
                             }
                         }
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                         duration = MAX(duration, timeline->_frames[(frameCount - 1) * TranslateTimeline::ENTRIES]);
                         break;
                     }
@@ -917,7 +916,7 @@ namespace Spine {
                     readCurve(input, frameIndex, timeline);
                 }
             }
-            timelines.push_back(timeline);
+			timelines.add(timeline);
             duration = MAX(duration, timeline->_frames[(frameCount - 1) * IkConstraintTimeline::ENTRIES]);
         }
 
@@ -933,7 +932,7 @@ namespace Spine {
                     readCurve(input, frameIndex, timeline);
                 }
             }
-            timelines.push_back(timeline);
+			timelines.add(timeline);
             duration = MAX(duration, timeline->_frames[(frameCount - 1) * TransformConstraintTimeline::ENTRIES]);
         }
 
@@ -970,7 +969,7 @@ namespace Spine {
                                 readCurve(input, frameIndex, timeline);
                             }
                         }
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                         duration = MAX(duration, timeline->_frames[(frameCount - 1) * PathConstraintPositionTimeline::ENTRIES]);
                         break;
                     }
@@ -984,7 +983,7 @@ namespace Spine {
                                 readCurve(input, frameIndex, timeline);
                             }
                         }
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                         duration = MAX(duration, timeline->_frames[(frameCount - 1) * PathConstraintMixTimeline::ENTRIES]);
                         break;
                     }
@@ -1026,9 +1025,9 @@ namespace Spine {
                         int end = readVarint(input, true);
                         if (end == 0) {
                             if (weighted) {
-                                deform.reserve(deformLength);
+                                deform.setSize(deformLength);
                                 for (int i = 0; i < deformLength; ++i) {
-                                    deform.push_back(0);
+									deform.add(0);
                                 }
                             }
                             else {
@@ -1036,7 +1035,7 @@ namespace Spine {
                             }
                         }
                         else {
-                            deform.reserve(deformLength);
+                            deform.setSize(deformLength);
                             int start = readVarint(input, true);
                             end += start;
                             if (scale == 1) {
@@ -1063,7 +1062,7 @@ namespace Spine {
                         }
                     }
 
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     duration = MAX(duration, timeline->_frames[frameCount - 1]);
                 }
             }
@@ -1080,13 +1079,13 @@ namespace Spine {
                 int offsetCount = readVarint(input, true);
                 
                 Vector<int> drawOrder;
-                drawOrder.reserve(slotCount);
+                drawOrder.ensureCapacity(slotCount);
                 for (int ii = slotCount - 1; ii >= 0; --ii) {
                     drawOrder[ii] = -1;
                 }
                 
                 Vector<int> unchanged;
-                unchanged.reserve(slotCount - offsetCount);
+                unchanged.ensureCapacity(slotCount - offsetCount);
                 int originalIndex = 0, unchangedIndex = 0;
                 for (int ii = 0; ii < offsetCount; ++ii) {
                     int slotIndex = readVarint(input, true);
@@ -1112,7 +1111,7 @@ namespace Spine {
                 }
                 timeline->setFrame(i, time, drawOrder);
             }
-            timelines.push_back(timeline);
+			timelines.add(timeline);
             duration = MAX(duration, timeline->_frames[drawOrderCount - 1]);
         }
 
@@ -1137,7 +1136,7 @@ namespace Spine {
                 timeline->setFrame(i, event);
             }
 
-            timelines.push_back(timeline);
+			timelines.add(timeline);
             duration = MAX(duration, timeline->_frames[eventCount - 1]);
         }
 

spine-cpp/spine-cpp/src/spine/SkeletonBounds.cpp

@@ -47,7 +47,7 @@ namespace Spine {
 
         _boundingBoxes.clear();
         for (int i = 0, n = static_cast<int>(_polygons.size()); i < n; ++i) {
-            _polygonPool.push_back(_polygons[i]);
+            _polygonPool.add(_polygons[i]);
         }
 
         _polygons.clear();
@@ -59,26 +59,26 @@ namespace Spine {
                 continue;
             }
             BoundingBoxAttachment* boundingBox = static_cast<BoundingBoxAttachment*>(attachment);
-            _boundingBoxes.push_back(boundingBox);
+            _boundingBoxes.add(boundingBox);
 
             Polygon* polygonP = NULL;
             int poolCount = static_cast<int>(_polygonPool.size());
             if (poolCount > 0) {
                 polygonP = _polygonPool[poolCount - 1];
-                _polygonPool.erase(poolCount - 1);
+                _polygonPool.removeAt(poolCount - 1);
             }
             else {
                 Polygon* polygonP = new (__FILE__, __LINE__) Polygon();
             }
 
-            _polygons.push_back(polygonP);
+            _polygons.add(polygonP);
 
             Polygon& polygon = *polygonP;
 
             int count = boundingBox->getWorldVerticesLength();
             polygon._count = count;
             if (polygon._vertices.size() < count) {
-                polygon._vertices.reserve(count);
+                polygon._vertices.ensureCapacity(count);
             }
             boundingBox->computeWorldVertices(*slot, polygon._vertices);
         }

spine-cpp/spine-cpp/src/spine/SkeletonClipping.cpp

@@ -35,10 +35,10 @@
 
 namespace Spine {
     SkeletonClipping::SkeletonClipping() : _clipAttachment(NULL) {
-        _clipOutput.reserve(128);
-        _clippedVertices.reserve(128);
-        _clippedTriangles.reserve(128);
-        _clippedUVs.reserve(128);
+		_clipOutput.ensureCapacity(128);
+		_clippedVertices.ensureCapacity(128);
+		_clippedTriangles.ensureCapacity(128);
+		_clippedUVs.ensureCapacity(128);
     }
     
     int SkeletonClipping::clipStart(Slot& slot, ClippingAttachment* clip) {
@@ -49,7 +49,7 @@ namespace Spine {
         _clipAttachment = clip;
 
         int n = clip->getWorldVerticesLength();
-        _clippingPolygon.reserve(n);
+		_clippingPolygon.ensureCapacity(n);
         _clippingPolygon.setSize(n);
         clip->computeWorldVertices(slot, 0, n, _clippingPolygon, 0, 2);
         makeClockwise(_clippingPolygon);
@@ -61,8 +61,8 @@ namespace Spine {
             Vector<float>* polygonP = (*i);
             Vector<float>& polygon = *polygonP;
             makeClockwise(polygon);
-            polygon.push_back(polygon[0]);
-            polygon.push_back(polygon[1]);
+            polygon.add(polygon[0]);
+            polygon.add(polygon[1]);
         }
         
         return static_cast<int>(_clippingPolygons.size());
@@ -122,9 +122,9 @@ namespace Spine {
                     float d = 1 / (d0 * d2 + d1 * (y1 - y3));
 
                     int clipOutputCount = clipOutputLength >> 1;
-                    clippedVertices.reserve(s + clipOutputCount * 2);
+					clippedVertices.ensureCapacity(s + clipOutputCount * 2);
                     clippedVertices.setSize(s + clipOutputCount * 2);
-                    _clippedUVs.reserve(s + clipOutputCount * 2);
+					_clippedUVs.ensureCapacity(s + clipOutputCount * 2);
                     _clippedUVs.setSize(s + clipOutputCount * 2);
                     for (int ii = 0; ii < clipOutputLength; ii += 2) {
                         float x = clipOutput[ii], y = clipOutput[ii + 1];
@@ -140,7 +140,7 @@ namespace Spine {
                     }
 
                     s = static_cast<int>(clippedTriangles.size());
-                    clippedTriangles.reserve(s + 3 * (clipOutputCount - 2));
+					clippedTriangles.ensureCapacity(s + 3 * (clipOutputCount - 2));
                     clippedTriangles.setSize(s + 3 * (clipOutputCount - 2));
                     clipOutputCount--;
                     for (int ii = 1; ii < clipOutputCount; ii++) {
@@ -152,9 +152,9 @@ namespace Spine {
                     index += clipOutputCount + 1;
                 }
                 else {
-                    clippedVertices.reserve(s + 3 * 2);
+					clippedVertices.ensureCapacity(s + 3 * 2);
                     clippedVertices.setSize(s + 3 * 2);
-                    _clippedUVs.reserve(s + 3 * 2);
+					_clippedUVs.ensureCapacity(s + 3 * 2);
                     _clippedUVs.setSize(s + 3 * 2);
                     clippedVertices[s] = x1;
                     clippedVertices[s + 1] = y1;
@@ -171,7 +171,7 @@ namespace Spine {
                     _clippedUVs[s + 5] = v3;
 
                     s = static_cast<int>(clippedTriangles.size());
-                    clippedTriangles.reserve(s + 3);
+					clippedTriangles.ensureCapacity(s + 3);
                     clippedTriangles.setSize(s + 3);
                     clippedTriangles[s] = index;
                     clippedTriangles[s + 1] = index + 1;
@@ -214,14 +214,14 @@ namespace Spine {
         }
 
         input.clear();
-        input.push_back(x1);
-        input.push_back(y1);
-        input.push_back(x2);
-        input.push_back(y2);
-        input.push_back(x3);
-        input.push_back(y3);
-        input.push_back(x1);
-        input.push_back(y1);
+        input.add(x1);
+        input.add(y1);
+        input.add(x2);
+        input.add(y2);
+        input.add(x3);
+        input.add(y3);
+        input.add(x1);
+        input.add(y1);
         output.clear();
 
         Vector<float>& clippingVertices = clippingArea;
@@ -240,24 +240,24 @@ namespace Spine {
                 if (deltaX * (inputY - edgeY2) - deltaY * (inputX - edgeX2) > 0) {
                     if (side2) {
                         // v1 inside, v2 inside
-                        output.push_back(inputX2);
-                        output.push_back(inputY2);
+                        output.add(inputX2);
+                        output.add(inputY2);
                         continue;
                     }
                     // v1 inside, v2 outside
                     float c0 = inputY2 - inputY, c2 = inputX2 - inputX;
                     float ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
-                    output.push_back(edgeX + (edgeX2 - edgeX) * ua);
-                    output.push_back(edgeY + (edgeY2 - edgeY) * ua);
+                    output.add(edgeX + (edgeX2 - edgeX) * ua);
+                    output.add(edgeY + (edgeY2 - edgeY) * ua);
                 }
                 else if (side2) {
                     // v1 outside, v2 inside
                     float c0 = inputY2 - inputY, c2 = inputX2 - inputX;
                     float ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
-                    output.push_back(edgeX + (edgeX2 - edgeX) * ua);
-                    output.push_back(edgeY + (edgeY2 - edgeY) * ua);
-                    output.push_back(inputX2);
-                    output.push_back(inputY2);
+                    output.add(edgeX + (edgeX2 - edgeX) * ua);
+                    output.add(edgeY + (edgeY2 - edgeY) * ua);
+                    output.add(inputX2);
+                    output.add(inputY2);
                 }
                 clipped = true;
             }
@@ -268,8 +268,8 @@ namespace Spine {
                 return true;
             }
 
-            output.push_back(output[0]);
-            output.push_back(output[1]);
+            output.add(output[0]);
+            output.add(output[1]);
 
             if (i == clippingVerticesLast) {
                 break;
@@ -283,11 +283,11 @@ namespace Spine {
         if (originalOutput != output) {
             originalOutput.clear();
             for (int i = 0, n = static_cast<int>(output.size()) - 2; i < n; ++i) {
-                originalOutput.push_back(output[i]);
+                originalOutput.add(output[i]);
             }
         }
         else {
-            originalOutput.reserve(originalOutput.size() - 2);
+			originalOutput.ensureCapacity(originalOutput.size() - 2);
             originalOutput.setSize(originalOutput.size() - 2);
         }
 

spine-cpp/spine-cpp/src/spine/SkeletonJson.cpp

@@ -144,7 +144,7 @@ namespace Spine {
 
         /* Bones. */
         bones = Json::getItem(root, "bones");
-        skeletonData->_bones.reserve(bones->_size);
+        skeletonData->_bones.ensureCapacity(bones->_size);
         skeletonData->_bones.setSize(bones->_size);
         int bonesCount = 0;
         for (boneMap = bones->_child, i = 0; boneMap; boneMap = boneMap->_next, ++i) {
@@ -198,7 +198,7 @@ namespace Spine {
         slots = Json::getItem(root, "slots");
         if (slots) {
             Json *slotMap;
-            skeletonData->_slots.reserve(slots->_size);
+            skeletonData->_slots.ensureCapacity(slots->_size);
             skeletonData->_slots.setSize(slots->_size);
             for (slotMap = slots->_child, i = 0; slotMap; slotMap = slotMap->_next, ++i) {
                 SlotData* data;
@@ -259,7 +259,7 @@ namespace Spine {
         ik = Json::getItem(root, "ik");
         if (ik) {
             Json *constraintMap;
-            skeletonData->_ikConstraints.reserve(ik->_size);
+            skeletonData->_ikConstraints.ensureCapacity(ik->_size);
             skeletonData->_ikConstraints.setSize(ik->_size);
             for (constraintMap = ik->_child, i = 0; constraintMap; constraintMap = constraintMap->_next, ++i) {
                 const char* targetName;
@@ -269,7 +269,7 @@ namespace Spine {
                 data->_order = Json::getInt(constraintMap, "order", 0);
 
                 boneMap = Json::getItem(constraintMap, "bones");
-                data->_bones.reserve(boneMap->_size);
+                data->_bones.ensureCapacity(boneMap->_size);
                 data->_bones.setSize(boneMap->_size);
                 for (boneMap = boneMap->_child, ii = 0; boneMap; boneMap = boneMap->_next, ++ii) {
                     data->_bones[ii] = skeletonData->findBone(boneMap->_valueString);
@@ -299,7 +299,7 @@ namespace Spine {
         transform = Json::getItem(root, "transform");
         if (transform) {
             Json *constraintMap;
-            skeletonData->_transformConstraints.reserve(transform->_size);
+            skeletonData->_transformConstraints.ensureCapacity(transform->_size);
             skeletonData->_transformConstraints.setSize(transform->_size);
             for (constraintMap = transform->_child, i = 0; constraintMap; constraintMap = constraintMap->_next, ++i) {
                 const char* name;
@@ -309,7 +309,7 @@ namespace Spine {
                 data->_order = Json::getInt(constraintMap, "order", 0);
 
                 boneMap = Json::getItem(constraintMap, "bones");
-                data->_bones.reserve(boneMap->_size);
+                data->_bones.ensureCapacity(boneMap->_size);
                 data->_bones.setSize(boneMap->_size);
                 for (boneMap = boneMap->_child, ii = 0; boneMap; boneMap = boneMap->_next, ++ii) {
                     data->_bones[ii] = skeletonData->findBone(boneMap->_valueString);
@@ -350,7 +350,7 @@ namespace Spine {
         path = Json::getItem(root, "path");
         if (path) {
             Json *constraintMap;
-            skeletonData->_pathConstraints.reserve(path->_size);
+            skeletonData->_pathConstraints.ensureCapacity(path->_size);
             skeletonData->_pathConstraints.setSize(path->_size);
             for (constraintMap = path->_child, i = 0; constraintMap; constraintMap = constraintMap->_next, ++i) {
                 const char* name;
@@ -361,7 +361,7 @@ namespace Spine {
                 data->_order = Json::getInt(constraintMap, "order", 0);
 
                 boneMap = Json::getItem(constraintMap, "bones");
-                data->_bones.reserve(boneMap->_size);
+                data->_bones.ensureCapacity(boneMap->_size);
                 data->_bones.setSize(boneMap->_size);
                 for (boneMap = boneMap->_child, ii = 0; boneMap; boneMap = boneMap->_next, ++ii) {
                     data->_bones[ii] = skeletonData->findBone(boneMap->_valueString);
@@ -430,7 +430,7 @@ namespace Spine {
         skins = Json::getItem(root, "skins");
         if (skins) {
             Json *skinMap;
-            skeletonData->_skins.reserve(skins->_size);
+            skeletonData->_skins.ensureCapacity(skins->_size);
             skeletonData->_skins.setSize(skins->_size);
             int skinsIndex = 0;
             for (skinMap = skins->_child, i = 0; skinMap; skinMap = skinMap->_next, ++i) {
@@ -536,7 +536,7 @@ namespace Spine {
                                 if (!entry) {
                                     int verticesLength;
                                     entry = Json::getItem(attachmentMap, "triangles");
-                                    mesh->_triangles.reserve(entry->_size);
+                                    mesh->_triangles.ensureCapacity(entry->_size);
                                     mesh->_triangles.setSize(entry->_size);
                                     for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii) {
                                         mesh->_triangles[ii] = (unsigned short)entry->_valueInt;
@@ -544,7 +544,7 @@ namespace Spine {
 
                                     entry = Json::getItem(attachmentMap, "uvs");
                                     verticesLength = entry->_size;
-                                    mesh->_regionUVs.reserve(verticesLength);
+                                    mesh->_regionUVs.ensureCapacity(verticesLength);
                                     mesh->_regionUVs.setSize(verticesLength);
                                     for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii) {
                                         mesh->_regionUVs[ii] = entry->_valueFloat;
@@ -558,7 +558,7 @@ namespace Spine {
 
                                     entry = Json::getItem(attachmentMap, "edges");
                                     if (entry) {
-                                        mesh->_edges.reserve(entry->_size);
+                                        mesh->_edges.ensureCapacity(entry->_size);
                                         mesh->_edges.setSize(entry->_size);
                                         for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii) {
                                             mesh->_edges[ii] = entry->_valueInt;
@@ -568,7 +568,7 @@ namespace Spine {
                                 else {
                                     mesh->_inheritDeform = Json::getInt(attachmentMap, "deform", 1);
                                     LinkedMesh* linkedMesh = new (__FILE__, __LINE__) LinkedMesh(mesh, String(Json::getString(attachmentMap, "skin", 0)), slotIndex, String(entry->_valueString));
-                                    _linkedMeshes.push_back(linkedMesh);
+									_linkedMeshes.add(linkedMesh);
                                 }
                                 break;
                             }
@@ -592,7 +592,7 @@ namespace Spine {
                                 vertexCount = Json::getInt(attachmentMap, "vertexCount", 0);
                                 readVertices(attachmentMap, pathAttatchment, vertexCount << 1);
 
-                                pathAttatchment->_lengths.reserve(vertexCount / 3);
+                                pathAttatchment->_lengths.ensureCapacity(vertexCount / 3);
                                 pathAttatchment->_lengths.setSize(vertexCount / 3);
 
                                 curves = Json::getItem(attachmentMap, "lengths");
@@ -658,7 +658,7 @@ namespace Spine {
         events = Json::getItem(root, "events");
         if (events) {
             Json *eventMap;
-            skeletonData->_events.reserve(events->_size);
+            skeletonData->_events.ensureCapacity(events->_size);
             skeletonData->_events.setSize(events->_size);
             for (eventMap = events->_child, i = 0; eventMap; eventMap = eventMap->_next, ++i) {
                 EventData* eventData = new (__FILE__, __LINE__) EventData(String(eventMap->_name));
@@ -675,7 +675,7 @@ namespace Spine {
         animations = Json::getItem(root, "animations");
         if (animations) {
             Json *animationMap;
-            skeletonData->_animations.reserve(animations->_size);
+            skeletonData->_animations.ensureCapacity(animations->_size);
             skeletonData->_animations.setSize(animations->_size);
             int animationsIndex = 0;
             for (animationMap = animations->_child; animationMap; animationMap = animationMap->_next) {
@@ -805,7 +805,7 @@ namespace Spine {
                         String attachmentName = name->_type == Json::JSON_NULL ? "" : name->_valueString;
                         timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), attachmentName);
                     }
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     timelinesCount++;
                     duration = MAX(duration, timeline->_frames[timelineMap->_size - 1]);
 
@@ -820,7 +820,7 @@ namespace Spine {
                         timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), toColor(s, 0), toColor(s, 1), toColor(s, 2), toColor(s, 3));
                         readCurve(valueMap, timeline, frameIndex);
                     }
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     timelinesCount++;
                     duration = MAX(duration, timeline->_frames[(timelineMap->_size - 1) * ColorTimeline::ENTRIES]);
 
@@ -837,7 +837,7 @@ namespace Spine {
                                                     toColor(s, 3), toColor(ds, 0), toColor(ds, 1), toColor(ds, 2));
                         readCurve(valueMap, timeline, frameIndex);
                     }
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     timelinesCount++;
                     duration = MAX(duration, timeline->_frames[(timelineMap->_size - 1) * TwoColorTimeline::ENTRIES]);
                 }
@@ -870,7 +870,7 @@ namespace Spine {
                         timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), Json::getFloat(valueMap, "angle", 0));
                         readCurve(valueMap, timeline, frameIndex);
                     }
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     timelinesCount++;
                     duration = MAX(duration, timeline->_frames[(timelineMap->_size - 1) * RotateTimeline::ENTRIES]);
                 }
@@ -897,7 +897,7 @@ namespace Spine {
                             readCurve(valueMap, timeline, frameIndex);
                         }
 
-                        timelines.push_back(timeline);
+						timelines.add(timeline);
                     timelinesCount++;
                         duration = MAX(duration, timeline->_frames[(timelineMap->_size - 1) * TranslateTimeline::ENTRIES]);
                     }
@@ -925,7 +925,7 @@ namespace Spine {
                 timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), Json::getFloat(valueMap, "mix", 1), Json::getInt(valueMap, "bendPositive", 1) ? 1 : -1);
                 readCurve(valueMap, timeline, frameIndex);
             }
-            timelines.push_back(timeline);
+			timelines.add(timeline);
                     timelinesCount++;
             duration = MAX(duration, timeline->_frames[(constraintMap->_size - 1) * IkConstraintTimeline::ENTRIES]);
         }
@@ -945,7 +945,7 @@ namespace Spine {
                 timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), Json::getFloat(valueMap, "rotateMix", 1), Json::getFloat(valueMap, "translateMix", 1), Json::getFloat(valueMap, "scaleMix", 1), Json::getFloat(valueMap, "shearMix", 1));
                 readCurve(valueMap, timeline, frameIndex);
             }
-            timelines.push_back(timeline);
+			timelines.add(timeline);
                     timelinesCount++;
             duration = MAX(duration, timeline->_frames[(constraintMap->_size - 1) * TransformConstraintTimeline::ENTRIES]);
         }
@@ -994,7 +994,7 @@ namespace Spine {
                         timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), Json::getFloat(valueMap, timelineName, 0) * timelineScale);
                         readCurve(valueMap, timeline, frameIndex);
                     }
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     timelinesCount++;
                     duration = MAX(duration, timeline->_frames[(timelineMap->_size - 1) * PathConstraintPositionTimeline::ENTRIES]);
                 }
@@ -1005,7 +1005,7 @@ namespace Spine {
                         timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), Json::getFloat(valueMap, "rotateMix", 1), Json::getFloat(valueMap, "translateMix", 1));
                         readCurve(valueMap, timeline, frameIndex);
                     }
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     timelinesCount++;
                     duration = MAX(duration, timeline->_frames[(timelineMap->_size - 1) * PathConstraintMixTimeline::ENTRIES]);
                 }
@@ -1036,9 +1036,9 @@ namespace Spine {
                     Vector<float>& vertices = attachment->_vertices;
                     deformLength = weighted ? static_cast<int>(vertices.size()) / 3 * 2 : static_cast<int>(vertices.size());
                     Vector<float> tempDeform;
-                    tempDeform.reserve(deformLength);
+                    tempDeform.ensureCapacity(deformLength);
                     for (int i = 0; i < deformLength; ++i) {
-                        tempDeform.push_back(0);
+						tempDeform.add(0);
                     }
 
                     timeline = new (__FILE__, __LINE__) DeformTimeline(timelineMap->_size);
@@ -1082,7 +1082,7 @@ namespace Spine {
                         readCurve(valueMap, timeline, frameIndex);
                     }
 
-                    timelines.push_back(timeline);
+					timelines.add(timeline);
                     timelinesCount++;
                     duration = MAX(duration, timeline->_frames[timelineMap->_size - 1]);
                 }
@@ -1100,11 +1100,11 @@ namespace Spine {
                 if (offsets) {
                     Json* offsetMap;
                     Vector<int> unchanged;
-                    unchanged.reserve(skeletonData->_slots.size() - offsets->_size);
+                    unchanged.ensureCapacity(skeletonData->_slots.size() - offsets->_size);
                     unchanged.setSize(skeletonData->_slots.size() - offsets->_size);
                     int originalIndex = 0, unchangedIndex = 0;
 
-                    drawOrder2.reserve(skeletonData->_slots.size());
+                    drawOrder2.ensureCapacity(skeletonData->_slots.size());
                     drawOrder2.setSize(skeletonData->_slots.size());
                     for (ii = static_cast<int>(skeletonData->_slots.size()) - 1; ii >= 0; --ii) {
                         drawOrder2[ii] = -1;
@@ -1138,7 +1138,7 @@ namespace Spine {
                 }
                 timeline->setFrame(frameIndex, Json::getFloat(valueMap, "time", 0), drawOrder2);
             }
-            timelines.push_back(timeline);
+			timelines.add(timeline);
                     timelinesCount++;
             duration = MAX(duration, timeline->_frames[drawOrder->_size - 1]);
         }
@@ -1162,7 +1162,7 @@ namespace Spine {
                 event->_stringValue = Json::getString(valueMap, "string", eventData->_stringValue.buffer());
                 timeline->setFrame(frameIndex, event);
             }
-            timelines.push_back(timeline);
+			timelines.add(timeline);
                     timelinesCount++;
             duration = MAX(duration, timeline->_frames[events->_size - 1]);
         }
@@ -1179,7 +1179,7 @@ namespace Spine {
 
         entry = Json::getItem(attachmentMap, "vertices");
         entrySize = entry->_size;
-        vertices.reserve(entrySize);
+        vertices.ensureCapacity(entrySize);
         vertices.setSize(entrySize);
         for (entry = entry->_child, i = 0; entry; entry = entry->_next, ++i) {
             vertices[i] = entry->_valueFloat;
@@ -1197,17 +1197,17 @@ namespace Spine {
         }
 
         Vertices bonesAndWeights;
-        bonesAndWeights._bones.reserve(verticesLength * 3);
-        bonesAndWeights._vertices.reserve(verticesLength * 3 * 3);
+        bonesAndWeights._bones.ensureCapacity(verticesLength * 3);
+        bonesAndWeights._vertices.ensureCapacity(verticesLength * 3 * 3);
 
         for (i = 0, n = entrySize; i < n;) {
             int boneCount = (int)vertices[i++];
-            bonesAndWeights._bones.push_back(boneCount);
+			bonesAndWeights._bones.add(boneCount);
             for (nn = i + boneCount * 4; i < nn; i += 4) {
-                bonesAndWeights._bones.push_back((int)vertices[i]);
-                bonesAndWeights._vertices.push_back(vertices[i + 1] * _scale);
-                bonesAndWeights._vertices.push_back(vertices[i + 2] * _scale);
-                bonesAndWeights._vertices.push_back(vertices[i + 3]);
+				bonesAndWeights._bones.add((int) vertices[i]);
+				bonesAndWeights._vertices.add(vertices[i + 1] * _scale);
+				bonesAndWeights._vertices.add(vertices[i + 2] * _scale);
+				bonesAndWeights._vertices.add(vertices[i + 3]);
             }
         }
 
@@ -1225,7 +1225,7 @@ namespace Spine {
         }
         
         _error = String(message);
-        
+
         delete root;
     }
 }

spine-cpp/spine-cpp/src/spine/Skin.cpp

@@ -86,7 +86,7 @@ namespace Spine {
     void Skin::findNamesForSlot(int slotIndex, Vector<String>& names) {
         for (HashMap<AttachmentKey, Attachment*, HashAttachmentKey>::Iterator i = _attachments.begin(); i != _attachments.end(); ++i) {
             if (i.key()._slotIndex == slotIndex) {
-                names.push_back(i.key()._name);
+                names.add(i.key()._name);
             }
         }
     }
@@ -94,7 +94,7 @@ namespace Spine {
     void Skin::findAttachmentsForSlot(int slotIndex, Vector<Attachment*>& attachments) {
         for (HashMap<AttachmentKey, Attachment*, HashAttachmentKey>::Iterator i = _attachments.begin(); i != _attachments.end(); ++i) {
             if (i.key()._slotIndex == slotIndex) {
-                attachments.push_back(i.value());
+                attachments.add(i.value());
             }
         }
     }

spine-cpp/spine-cpp/src/spine/TransformConstraint.cpp

@@ -47,11 +47,11 @@ namespace Spine {
     _translateMix(data.getTranslateMix()),
     _scaleMix(data.getScaleMix()),
     _shearMix(data.getShearMix()) {
-        _bones.reserve(_data.getBones().size());
+        _bones.ensureCapacity(_data.getBones().size());
         for (BoneData** i = _data.getBones().begin(); i != _data.getBones().end(); ++i) {
             BoneData* boneData = (*i);
-            
-            _bones.push_back(skeleton.findBone(boneData->getName()));
+
+            _bones.add(skeleton.findBone(boneData->getName()));
         }
     }
     

spine-cpp/spine-cpp/src/spine/TransformConstraintTimeline.cpp

@@ -55,7 +55,7 @@ namespace Spine {
     const int TransformConstraintTimeline::SHEAR = 4;
     
     TransformConstraintTimeline::TransformConstraintTimeline(int frameCount) : CurveTimeline(frameCount), _transformConstraintIndex(0) {
-        _frames.reserve(frameCount * ENTRIES);
+		_frames.ensureCapacity(frameCount * ENTRIES);
         _frames.setSize(frameCount * ENTRIES);
     }
     

spine-cpp/spine-cpp/src/spine/TranslateTimeline.cpp

@@ -51,7 +51,7 @@ namespace Spine {
     const int TranslateTimeline::Y = 2;
     
     TranslateTimeline::TranslateTimeline(int frameCount) : CurveTimeline(frameCount), _boneIndex(0) {
-        _frames.reserve(frameCount * ENTRIES);
+		_frames.ensureCapacity(frameCount * ENTRIES);
         _frames.setSize(frameCount * ENTRIES);
     }
 

spine-cpp/spine-cpp/src/spine/Triangulator.cpp

@@ -38,14 +38,14 @@ namespace Spine {
         
         Vector<int>& indices = _indices;
         indices.clear();
-        indices.reserve(vertexCount);
+		indices.ensureCapacity(vertexCount);
         indices.setSize(vertexCount);
         for (int i = 0; i < vertexCount; ++i) {
             indices[i] = i;
         }
         
         Vector<bool>& isConcaveArray = _isConcaveArray;
-        isConcaveArray.reserve(vertexCount);
+		isConcaveArray.ensureCapacity(vertexCount);
         isConcaveArray.setSize(vertexCount);
         for (int i = 0, n = vertexCount; i < n; ++i) {
             isConcaveArray[i] = isConcave(i, vertexCount, vertices, indices);
@@ -53,7 +53,7 @@ namespace Spine {
         
         Vector<int>& triangles = _triangles;
         triangles.clear();
-        triangles.reserve(MAX(0, vertexCount - 2) << 2);
+		triangles.ensureCapacity(MAX(0, vertexCount - 2) << 2);
         
         while (vertexCount > 3) {
             // Find ear tip.
@@ -101,11 +101,11 @@ namespace Spine {
             }
             
             // Cut ear tip.
-            triangles.push_back(indices[(vertexCount + i - 1) % vertexCount]);
-            triangles.push_back(indices[i]);
-            triangles.push_back(indices[(i + 1) % vertexCount]);
-            indices.erase(i);
-            isConcaveArray.erase(i);
+            triangles.add(indices[(vertexCount + i - 1) % vertexCount]);
+            triangles.add(indices[i]);
+            triangles.add(indices[(i + 1) % vertexCount]);
+            indices.removeAt(i);
+            isConcaveArray.removeAt(i);
             vertexCount--;
             
             int previousIndex = (vertexCount + i - 1) % vertexCount;
@@ -115,9 +115,9 @@ namespace Spine {
         }
         
         if (vertexCount == 3) {
-            triangles.push_back(indices[2]);
-            triangles.push_back(indices[0]);
-            triangles.push_back(indices[1]);
+            triangles.add(indices[2]);
+            triangles.add(indices[0]);
+            triangles.add(indices[1]);
         }
         
         return triangles;
@@ -160,9 +160,9 @@ namespace Spine {
                 int winding1 = winding(p[o], p[o + 1], p[o + 2], p[o + 3], x3, y3);
                 int winding2 = winding(x3, y3, p[0], p[1], p[2], p[3]);
                 if (winding1 == lastwinding && winding2 == lastwinding) {
-                    polygon.push_back(x3);
-                    polygon.push_back(y3);
-                    polygonIndices.push_back(t3);
+                    polygon.add(x3);
+                    polygon.add(y3);
+                    polygonIndices.add(t3);
                     merged = true;
                 }
             }
@@ -170,8 +170,8 @@ namespace Spine {
             // Otherwise make this triangle the new base.
             if (!merged) {
                 if (polygon.size() > 0) {
-                    convexPolygons.push_back(&polygon);
-                    convexPolygonsIndices.push_back(&polygonIndices);
+                    convexPolygons.add(&polygon);
+                    convexPolygonsIndices.add(&polygonIndices);
                 }
                 else {
                     _polygonPool.free(&polygon);
@@ -180,25 +180,25 @@ namespace Spine {
                 
                 polygon = *_polygonPool.obtain();
                 polygon.clear();
-                polygon.push_back(x1);
-                polygon.push_back(y1);
-                polygon.push_back(x2);
-                polygon.push_back(y2);
-                polygon.push_back(x3);
-                polygon.push_back(y3);
+                polygon.add(x1);
+                polygon.add(y1);
+                polygon.add(x2);
+                polygon.add(y2);
+                polygon.add(x3);
+                polygon.add(y3);
                 polygonIndices = *_polygonIndicesPool.obtain();
                 polygonIndices.clear();
-                polygonIndices.push_back(t1);
-                polygonIndices.push_back(t2);
-                polygonIndices.push_back(t3);
+                polygonIndices.add(t1);
+                polygonIndices.add(t2);
+                polygonIndices.add(t3);
                 lastwinding = winding(x1, y1, x2, y2, x3, y3);
                 fanBaseIndex = t1;
             }
         }
         
         if (polygon.size() > 0) {
-            convexPolygons.push_back(&polygon);
-            convexPolygonsIndices.push_back(&polygonIndices);
+            convexPolygons.add(&polygon);
+            convexPolygonsIndices.add(&polygonIndices);
         }
         
         // Go through the list of polygons and try to merge the remaining triangles with the found triangle fans.
@@ -249,9 +249,9 @@ namespace Spine {
                 if (winding1 == winding0 && winding2 == winding0) {
                     otherPoly.clear();
                     otherIndices.clear();
-                    polygon.push_back(x3);
-                    polygon.push_back(y3);
-                    polygonIndices.push_back(otherLastIndex);
+                    polygon.add(x3);
+                    polygon.add(y3);
+                    polygonIndices.add(otherLastIndex);
                     prevPrevX = prevX;
                     prevPrevY = prevY;
                     prevX = x3;
@@ -265,10 +265,10 @@ namespace Spine {
         for (int i = static_cast<int>(convexPolygons.size()) - 1; i >= 0; --i) {
             polygon = *convexPolygons[i];
             if (polygon.size() == 0) {
-                convexPolygons.erase(i);
+                convexPolygons.removeAt(i);
                 _polygonPool.free(&polygon);
                 polygonIndices = *convexPolygonsIndices[i];
-                convexPolygonsIndices.erase(i);
+                convexPolygonsIndices.removeAt(i);
                 _polygonIndicesPool.free(&polygonIndices);
             }
         }

spine-cpp/spine-cpp/src/spine/TwoColorTimeline.cpp

@@ -59,7 +59,7 @@ namespace Spine {
     const int TwoColorTimeline::B2 = 7;
     
     TwoColorTimeline::TwoColorTimeline(int frameCount) : CurveTimeline(frameCount), _slotIndex(0) {
-        _frames.reserve(frameCount * ENTRIES);
+		_frames.ensureCapacity(frameCount * ENTRIES);
         _frames.setSize(frameCount * ENTRIES);
     }