UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-02-09 08:38:43 +08:00
Code Issues Packages Projects Releases Wiki Activity

[cpp] Refactored String and Vector.

Browse Source
This commit is contained in:
badlogic 2018-02-20 15:10:40 +01:00
parent 88a1a58813
commit bef01b8e89
34 changed files with 342 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
spine-cpp/spine-cpp-unit-tests/src/main.cpp
View File

@ -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) {

4
spine-cpp/spine-cpp/include/spine/ContainerUtil.h
View File

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

4
spine-cpp/spine-cpp/include/spine/Pool.h
View File

@ -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);
}
}

2
spine-cpp/spine-cpp/include/spine/SkeletonBounds.h
View File

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

2
spine-cpp/spine-cpp/include/spine/SpineObject.h
View File

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

26
spine-cpp/spine-cpp/include/spine/String.h
View File

@ -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;
};
}

114
spine-cpp/spine-cpp/include/spine/Vector.h
View File

@ -81,6 +81,57 @@ namespace Spine {
deallocate(_buffer);
}
void clear () {
for (size_t i = 0; i < _size; ++i) {
destroy(_buffer + (_size - 1 - i));
}
_size = 0;
}
size_t size() const {
return _size;
}
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__);
}
}
void ensureCapacity(size_t newCapacity = 0) {
if (_capacity >= newCapacity) return;
_capacity = newCapacity;
_buffer = SpineExtension::realloc<T>(_buffer, newCapacity, __FILE__, __LINE__);
}
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;
if (inIndex != _size) {
for (size_t i = inIndex; i < _size; ++i) {
std::swap(_buffer[i], _buffer[i + 1]);
}
}
destroy(_buffer + _size);
}
bool contains(const T& inValue) {
for (size_t i = 0; i < _size; ++i) {
if (_buffer[i] == inValue) {
@ -101,75 +152,12 @@ namespace Spine {
return -1;
}
void push_back(const T& inValue) {
if (_size == _capacity) {
reserve();
}
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 erase(size_t inIndex) {
assert(inIndex < _size);
--_size;
if (inIndex != _size) {
for (size_t i = inIndex; i < _size; ++i) {
std::swap(_buffer[i], _buffer[i + 1]);
}
}
destroy(_buffer + _size);
}
void clear() {
for (size_t i = 0; i < _size; ++i) {
destroy(_buffer + (_size - 1 - i));
}
_size = 0;
}
size_t size() const {
return _size;
}
T& operator[](size_t inIndex) {
assert(inIndex < _size);
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];
}

28
spine-cpp/spine-cpp/src/spine/AnimationState.cpp
View File

@ -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;

8
spine-cpp/spine-cpp/src/spine/Atlas.cpp
View File

@ -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);
}
}
}

6
spine-cpp/spine-cpp/src/spine/AttachmentTimeline.cpp
View File

@ -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());
}
}

2
spine-cpp/spine-cpp/src/spine/ColorTimeline.cpp
View File

@ -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);
}

6
spine-cpp/spine-cpp/src/spine/CurveTimeline.cpp
View File

@ -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);
}

12
spine-cpp/spine-cpp/src/spine/DeformTimeline.cpp
View File

@ -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) {

16
spine-cpp/spine-cpp/src/spine/DrawOrderTimeline.cpp
View File

@ -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 {

6
spine-cpp/spine-cpp/src/spine/EventTimeline.cpp
View File

@ -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]);
}
}

6
spine-cpp/spine-cpp/src/spine/IkConstraint.cpp
View File

@ -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()));
}
}

2
spine-cpp/spine-cpp/src/spine/IkConstraintTimeline.cpp
View File

@ -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);
}

2
spine-cpp/spine-cpp/src/spine/MeshAttachment.cpp
View File

@ -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());
}

26
spine-cpp/spine-cpp/src/spine/PathConstraint.cpp
View File

@ -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;

2
spine-cpp/spine-cpp/src/spine/PathConstraintMixTimeline.cpp
View File

@ -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);
}

2
spine-cpp/spine-cpp/src/spine/PathConstraintPositionTimeline.cpp
View File

@ -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);
}

4
spine-cpp/spine-cpp/src/spine/RegionAttachment.cpp
View File

@ -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);

2
spine-cpp/spine-cpp/src/spine/RotateTimeline.cpp
View File

@ -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);
}

70
spine-cpp/spine-cpp/src/spine/Skeleton.cpp
View File

@ -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) {

81
spine-cpp/spine-cpp/src/spine/SkeletonBinary.cpp
View File

@ -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]);
}

10
spine-cpp/spine-cpp/src/spine/SkeletonBounds.cpp
View File

@ -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);
}

66
spine-cpp/spine-cpp/src/spine/SkeletonClipping.cpp
View File

@ -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);
}

82
spine-cpp/spine-cpp/src/spine/SkeletonJson.cpp
View File

@ -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;
}
}

4
spine-cpp/spine-cpp/src/spine/Skin.cpp
View File

@ -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());
}
}
}

6
spine-cpp/spine-cpp/src/spine/TransformConstraint.cpp
View File

@ -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()));
}
}

2
spine-cpp/spine-cpp/src/spine/TransformConstraintTimeline.cpp
View File

@ -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);
}

2
spine-cpp/spine-cpp/src/spine/TranslateTimeline.cpp
View File

@ -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);
}

64
spine-cpp/spine-cpp/src/spine/Triangulator.cpp
View File

@ -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);
}
}

2
spine-cpp/spine-cpp/src/spine/TwoColorTimeline.cpp
View File

@ -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);
}