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

[cpp] Added preliminary SFML backend, fixed up a few APIs.

Browse Source
This commit is contained in:
badlogic 2018-02-21 17:52:56 +01:00
parent 6d243eca48
commit ed7dc4ea93
17 changed files with 276 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -45,7 +45,7 @@ namespace Spine {
explicit EventData(const String& name); explicit EventData(const String& name);
/// The name of the event, which is unique within the skeleton. /// The name of the event, which is unique within the skeleton.
const String& getName(); const String& getName() const;
int getIntValue(); int getIntValue();
void setIntValue(int inValue); void setIntValue(int inValue);

12
spine-cpp/spine-cpp/include/spine/MeshAttachment.h
View File

@ -62,8 +62,8 @@ namespace Spine {
Vector<float>& getUVs(); Vector<float>& getUVs();
void setUVs(Vector<float>& inValue); void setUVs(Vector<float>& inValue);
Vector<short>& getTriangles(); Vector<unsigned short>& getTriangles();
void setTriangles(Vector<short>& inValue); void setTriangles(Vector<unsigned short>& inValue);
Color& getColor(); Color& getColor();
@ -115,8 +115,8 @@ namespace Spine {
void setParentMesh(MeshAttachment* inValue); void setParentMesh(MeshAttachment* inValue);
// Nonessential. // Nonessential.
Vector<short>& getEdges(); Vector<unsigned short>& getEdges();
void setEdges(Vector<short>& inValue); void setEdges(Vector<unsigned short>& inValue);
float getWidth(); float getWidth();
void setWidth(float inValue); void setWidth(float inValue);
float getHeight(); float getHeight();
@ -127,8 +127,8 @@ namespace Spine {
MeshAttachment* _parentMesh; MeshAttachment* _parentMesh;
Vector<float> _uvs; Vector<float> _uvs;
Vector<float> _regionUVs; Vector<float> _regionUVs;
Vector<short> _triangles; Vector<unsigned short> _triangles;
Vector<short> _edges; Vector<unsigned short> _edges;
void* _rendererObject; void* _rendererObject;
String _path; String _path;
float _regionU; float _regionU;

1
spine-cpp/spine-cpp/include/spine/Skeleton.h
View File

@ -158,6 +158,7 @@ namespace Spine {
Color& getColor(); Color& getColor();
float getTime(); float getTime();
void setTime(float inValue); void setTime(float inValue);
void setPosition(float x, float y);
float getX(); float getX();
void setX(float inValue); void setX(float inValue);
float getY(); float getY();

8
spine-cpp/spine-cpp/include/spine/SkeletonBinary.h
View File

@ -78,6 +78,10 @@ namespace Spine {
SkeletonData* readSkeletonData(const unsigned char* binary, int length); SkeletonData* readSkeletonData(const unsigned char* binary, int length);
SkeletonData* readSkeletonDataFile(const String& path); SkeletonData* readSkeletonDataFile(const String& path);
void setScale(float scale) { _scale = scale; }
String& getError() { return _error; }
private: private:
struct DataInput : public SpineObject { struct DataInput : public SpineObject {
@ -115,9 +119,9 @@ namespace Spine {
void readVertices(DataInput* input, VertexAttachment* attachment, int vertexCount); void readVertices(DataInput* input, VertexAttachment* attachment, int vertexCount);
Vector<float> readFloatArray(DataInput *input, int n, float scale); void readFloatArray(DataInput *input, int n, float scale, Vector<float>& array);
Vector<short> readShortArray(DataInput *input); void readShortArray(DataInput *input, Vector<unsigned short>& array);
Animation* readAnimation(const char* name, DataInput* input, SkeletonData *skeletonData); Animation* readAnimation(const char* name, DataInput* input, SkeletonData *skeletonData);

6
spine-cpp/spine-cpp/include/spine/SkeletonClipping.h
View File

@ -48,12 +48,12 @@ namespace Spine {
void clipEnd(); void clipEnd();
void clipTriangles(Vector<float>& vertices, int verticesLength, Vector<int>& triangles, int trianglesLength, Vector<float>& uvs); void clipTriangles(Vector<float>& vertices, int verticesLength, Vector<unsigned short>& triangles, int trianglesLength, Vector<float>& uvs);
bool isClipping(); bool isClipping();
Vector<float>& getClippedVertices(); Vector<float>& getClippedVertices();
Vector<int>& getClippedTriangles(); Vector<unsigned short>& getClippedTriangles();
Vector<float>& getClippedUVs(); Vector<float>& getClippedUVs();
private: private:
@ -61,7 +61,7 @@ namespace Spine {
Vector<float> _clippingPolygon; Vector<float> _clippingPolygon;
Vector<float> _clipOutput; Vector<float> _clipOutput;
Vector<float> _clippedVertices; Vector<float> _clippedVertices;
Vector<int> _clippedTriangles; Vector<unsigned short> _clippedTriangles;
Vector<float> _clippedUVs; Vector<float> _clippedUVs;
Vector<float> _scratch; Vector<float> _scratch;
ClippingAttachment* _clipAttachment; ClippingAttachment* _clipAttachment;

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

@ -57,6 +57,10 @@ namespace Spine {
SkeletonData* readSkeletonDataFile(const String& path); SkeletonData* readSkeletonDataFile(const String& path);
SkeletonData* readSkeletonData(const char* json); SkeletonData* readSkeletonData(const char* json);
void setScale (float scale) { _scale = scale; }
String& getError() { return _error; }
private: private:
AttachmentLoader* _attachmentLoader; AttachmentLoader* _attachmentLoader;

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

@ -175,6 +175,10 @@ namespace Spine {
return !(lhs == rhs); return !(lhs == rhs);
} }
T* buffer() {
return _buffer;
}
private: private:
size_t _size; size_t _size;
size_t _capacity; size_t _capacity;

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

@ -88,6 +88,8 @@
#include <spine/SkeletonData.h> #include <spine/SkeletonData.h>
#include <spine/SkeletonJson.h> #include <spine/SkeletonJson.h>
#include <spine/Skin.h> #include <spine/Skin.h>
#include <spine/Slot.h>
#include <spine/SlotData.h>
#include <spine/SpineObject.h> #include <spine/SpineObject.h>
#include <spine/String.h> #include <spine/String.h>
#include <spine/TextureLoader.h> #include <spine/TextureLoader.h>

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

@ -42,7 +42,7 @@ namespace Spine {
} }
/// The name of the event, which is unique within the skeleton. /// The name of the event, which is unique within the skeleton.
const String& EventData::getName() { const String& EventData::getName() const {
return _name; return _name;
} }

47
spine-cpp/spine-cpp/src/spine/MathUtil.cpp
View File

@ -32,18 +32,6 @@
#include <math.h> #include <math.h>
namespace Spine { namespace Spine {
float MathUtil::SIN_TABLE[SIN_COUNT] = {0.0f};
MathUtil::MathUtil() {
for (int i = 0; i < SIN_COUNT; ++i) {
SIN_TABLE[i] = sin((i + 0.5f) / SIN_COUNT * RadFull);
}
for (int i = 0; i < 360; i += 90) {
SIN_TABLE[i * DegToIndex & SIN_MASK] = sin(i * DegRad);
}
}
int MathUtil::sign(float val) { int MathUtil::sign(float val) {
return (0 < val) - (val < 0); return (0 < val) - (val < 0);
} }
@ -74,53 +62,28 @@ namespace Spine {
/// Returns the sine in radians from a lookup table. /// Returns the sine in radians from a lookup table.
float MathUtil::sin(float radians) { float MathUtil::sin(float radians) {
return SIN_TABLE[(int)(radians * RadToIndex) & SIN_MASK]; return ::sin(radians);
} }
/// Returns the cosine in radians from a lookup table. /// Returns the cosine in radians from a lookup table.
float MathUtil::cos(float radians) { float MathUtil::cos(float radians) {
return SIN_TABLE[(int)((radians + SPINE_PI / 2) * RadToIndex) & SIN_MASK]; return ::cos(radians);
} }
/// Returns the sine in radians from a lookup table. /// Returns the sine in radians from a lookup table.
float MathUtil::sinDeg(float degrees) { float MathUtil::sinDeg(float degrees) {
return SIN_TABLE[(int)(degrees * DegToIndex) & SIN_MASK]; return ::sin(degrees * DegRad);
} }
/// Returns the cosine in radians from a lookup table. /// Returns the cosine in radians from a lookup table.
float MathUtil::cosDeg(float degrees) { float MathUtil::cosDeg(float degrees) {
return SIN_TABLE[(int)((degrees + 90) * DegToIndex) & SIN_MASK]; return ::cos(degrees * DegRad);
} }
/// Returns atan2 in radians, faster but less accurate than Math.Atan2. Average error of 0.00231 radians (0.1323 /// Returns atan2 in radians, faster but less accurate than Math.Atan2. Average error of 0.00231 radians (0.1323
/// degrees), largest error of 0.00488 radians (0.2796 degrees). /// degrees), largest error of 0.00488 radians (0.2796 degrees).
float MathUtil::atan2(float y, float x) { float MathUtil::atan2(float y, float x) {
if (areFloatsPracticallyEqual(x, 0.0f)) { return ::atan2(y, x);
if (y > 0.0f) {
return SPINE_PI / 2;
}
if (areFloatsPracticallyEqual(y, 0.0f)) {
return 0.0f;
}
return -SPINE_PI / 2;
}
float atan, z = y / x;
if (fabs(z) < 1.0f) {
atan = z / (1.0f + 0.28f * z * z);
if (x < 0.0f) {
return atan + (y < 0.0f ? -SPINE_PI : SPINE_PI);
}
return atan;
}
atan = SPINE_PI / 2 - z / (z * z + 0.28f);
return y < 0.0f ? atan - SPINE_PI : atan;
} }
float MathUtil::acos(float v) { float MathUtil::acos(float v) {

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

@ -104,11 +104,11 @@
_uvs = inValue; _uvs = inValue;
} }
Vector<short>& MeshAttachment::getTriangles() { Vector<unsigned short>& MeshAttachment::getTriangles() {
return _triangles; return _triangles;
} }
void MeshAttachment::setTriangles(Vector<short>& inValue) { void MeshAttachment::setTriangles(Vector<unsigned short>& inValue) {
_triangles = inValue; _triangles = inValue;
} }
@ -243,11 +243,11 @@
} }
} }
Vector<short>& MeshAttachment::getEdges() { Vector<unsigned short>& MeshAttachment::getEdges() {
return _edges; return _edges;
} }
void MeshAttachment::setEdges(Vector<short>& inValue) { void MeshAttachment::setEdges(Vector<unsigned short>& inValue) {
_edges = inValue; _edges = inValue;
} }

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

@ -119,7 +119,6 @@ namespace Spine {
} }
updateCache(); updateCache();
updateWorldTransform();
} }
Skeleton::~Skeleton() { Skeleton::~Skeleton() {
@ -496,6 +495,11 @@ namespace Spine {
void Skeleton::setTime(float inValue) { void Skeleton::setTime(float inValue) {
_time = inValue; _time = inValue;
} }
void Skeleton::setPosition(float x, float y) {
_x = x;
_y = y;
}
float Skeleton::getX() { float Skeleton::getX() {
return _x; return _x;

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

@ -579,16 +579,13 @@ namespace Spine {
mesh->_path = String(path); mesh->_path = String(path);
readColor(input, mesh->getColor()); readColor(input, mesh->getColor());
vertexCount = readVarint(input, true); vertexCount = readVarint(input, true);
Vector<float> float_array = readFloatArray(input, vertexCount << 1, 1); readFloatArray(input, vertexCount << 1, 1, mesh->getRegionUVs());
mesh->setRegionUVs(float_array); readShortArray(input, mesh->getTriangles());
Vector<short> triangles = readShortArray(input);
mesh->setTriangles(triangles);
readVertices(input, static_cast<VertexAttachment*>(mesh), vertexCount); readVertices(input, static_cast<VertexAttachment*>(mesh), vertexCount);
mesh->updateUVs(); mesh->updateUVs();
mesh->_hullLength = readVarint(input, true) << 1; mesh->_hullLength = readVarint(input, true) << 1;
if (nonessential) { if (nonessential) {
Vector<short> edges = readShortArray(input); readShortArray(input, mesh->getEdges());
mesh->setEdges(edges);
mesh->_width = readFloat(input) * _scale; mesh->_width = readFloat(input) * _scale;
mesh->_height = readFloat(input) * _scale; mesh->_height = readFloat(input) * _scale;
} }
@ -705,7 +702,7 @@ namespace Spine {
int verticesLength = vertexCount << 1; int verticesLength = vertexCount << 1;
if (!readBoolean(input)) { if (!readBoolean(input)) {
attachment->setVertices(readFloatArray(input, verticesLength, scale)); readFloatArray(input, verticesLength, scale, attachment->getVertices());
return; return;
} }
@ -728,8 +725,7 @@ namespace Spine {
attachment->setBones(vertices._bones); attachment->setBones(vertices._bones);
} }
Vector<float> SkeletonBinary::readFloatArray(DataInput *input, int n, float scale) { void SkeletonBinary::readFloatArray(DataInput *input, int n, float scale, Vector<float>& array) {
Vector<float> array;
array.setSize(n); array.setSize(n);
int i; int i;
@ -743,14 +739,10 @@ namespace Spine {
array[i] = readFloat(input) * scale; array[i] = readFloat(input) * scale;
} }
} }
return array;
} }
Vector<short> SkeletonBinary::readShortArray(DataInput *input) { void SkeletonBinary::readShortArray(DataInput *input, Vector<unsigned short>& array) {
int n = readVarint(input, true); int n = readVarint(input, true);
Vector<short> array;
array.setSize(n); array.setSize(n);
int i; int i;
@ -758,8 +750,6 @@ namespace Spine {
array[i] = readByte(input) << 8; array[i] = readByte(input) << 8;
array[i] |= readByte(input); array[i] |= readByte(input);
} }
return array;
} }
Animation* SkeletonBinary::readAnimation(const char* name, DataInput* input, SkeletonData *skeletonData) { Animation* SkeletonBinary::readAnimation(const char* name, DataInput* input, SkeletonData *skeletonData) {

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

@ -85,10 +85,10 @@ namespace Spine {
_clippingPolygon.clear(); _clippingPolygon.clear();
} }
void SkeletonClipping::clipTriangles(Vector<float>& vertices, int verticesLength, Vector<int>& triangles, int trianglesLength, Vector<float>& uvs) { void SkeletonClipping::clipTriangles(Vector<float>& vertices, int verticesLength, Vector<unsigned short>& triangles, int trianglesLength, Vector<float>& uvs) {
Vector<float>& clipOutput = _clipOutput; Vector<float>& clipOutput = _clipOutput;
Vector<float>& clippedVertices = _clippedVertices; Vector<float>& clippedVertices = _clippedVertices;
Vector<int>& clippedTriangles = _clippedTriangles; Vector<unsigned short>& clippedTriangles = _clippedTriangles;
Vector< Vector<float>* >& polygons = _clippingPolygons; Vector< Vector<float>* >& polygons = _clippingPolygons;
int polygonsCount = static_cast<int>(_clippingPolygons.size()); int polygonsCount = static_cast<int>(_clippingPolygons.size());
@ -184,7 +184,7 @@ namespace Spine {
return _clippedVertices; return _clippedVertices;
} }
Vector<int>& SkeletonClipping::getClippedTriangles() { Vector<unsigned short>& SkeletonClipping::getClippedTriangles() {
return _clippedTriangles; return _clippedTriangles;
} }

247
spine-sfml/cpp/example/main.cpp
View File

@ -36,103 +36,102 @@
#include <SFML/Window/Mouse.hpp> #include <SFML/Window/Mouse.hpp>
using namespace std; using namespace std;
using namespace spine; using namespace Spine;
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void callback (AnimationState* state, EventType type, TrackEntry* entry, Event* event) { void callback (AnimationState* state, EventType type, TrackEntry* entry, Event* event) {
const char* animationName = (entry && entry->animation) ? entry->animation->name : 0; const String& animationName = (entry && entry->getAnimation()) ? entry->getAnimation()->getName() : String("");
switch (type) { switch (type) {
case ANIMATION_START: case EventType_Start:
printf("%d start: %s\n", entry->trackIndex, animationName); printf("%d start: %s\n", entry->getTrackIndex(), animationName.buffer());
break; break;
case ANIMATION_INTERRUPT: case EventType_Interrupt:
printf("%d interrupt: %s\n", entry->trackIndex, animationName); printf("%d interrupt: %s\n", entry->getTrackIndex(), animationName.buffer());
break; break;
case ANIMATION_END: case EventType_End:
printf("%d end: %s\n", entry->trackIndex, animationName); printf("%d end: %s\n", entry->getTrackIndex(), animationName.buffer());
break; break;
case ANIMATION_COMPLETE: case EventType_Complete:
printf("%d complete: %s\n", entry->trackIndex, animationName); printf("%d complete: %s\n", entry->getTrackIndex(), animationName.buffer());
break; break;
case ANIMATION_DISPOSE: case EventType_Dispose:
printf("%d dispose: %s\n", entry->trackIndex, animationName); printf("%d dispose: %s\n", entry->getTrackIndex(), animationName.buffer());
break; break;
case ANIMATION_EVENT: case EventType_Event:
printf("%d event: %s, %s: %d, %f, %s\n", entry->trackIndex, animationName, event->data->name, event->intValue, event->floatValue, printf("%d event: %s, %s: %d, %f, %s\n", entry->getTrackIndex(), animationName.buffer(), event->getData().getName().buffer(), event->getIntValue(), event->getFloatValue(),
event->stringValue); event->getStringValue().buffer());
break; break;
} }
fflush(stdout); fflush(stdout);
} }
SkeletonData* readSkeletonJsonData (const char* filename, Atlas* atlas, float scale) { SkeletonData* readSkeletonJsonData (const String& filename, Atlas* atlas, float scale) {
SkeletonJson* json = SkeletonJson_create(atlas); SkeletonJson* json = new (__FILE__, __LINE__) SkeletonJson(atlas);
json->scale = scale; json->setScale(scale);
SkeletonData* skeletonData = SkeletonJson_readSkeletonDataFile(json, filename); SkeletonData* skeletonData = json->readSkeletonDataFile(filename);
if (!skeletonData) { if (!skeletonData) {
printf("%s\n", json->error); printf("%s\n", json->getError().buffer());
exit(0); exit(0);
} }
SkeletonJson_dispose(json); delete json;
return skeletonData; return skeletonData;
} }
SkeletonData* readSkeletonBinaryData (const char* filename, Atlas* atlas, float scale) { SkeletonData* readSkeletonBinaryData (const char* filename, Atlas* atlas, float scale) {
SkeletonBinary* binary = SkeletonBinary_create(atlas); SkeletonBinary* binary = new (__FILE__, __LINE__) SkeletonBinary(atlas);
binary->scale = scale; binary->setScale(scale);
SkeletonData *skeletonData = SkeletonBinary_readSkeletonDataFile(binary, filename); SkeletonData *skeletonData = binary->readSkeletonDataFile(filename);
if (!skeletonData) { if (!skeletonData) {
printf("%s\n", binary->error); printf("%s\n", binary->getError().buffer());
exit(0); exit(0);
} }
SkeletonBinary_dispose(binary); delete binary;
return skeletonData; return skeletonData;
} }
void testcase (void func(SkeletonData* skeletonData, Atlas* atlas), void testcase (void func(SkeletonData* skeletonData, Atlas* atlas),
const char* jsonName, const char* binaryName, const char* atlasName, const char* jsonName, const char* binaryName, const char* atlasName,
float scale) { float scale) {
Atlas* atlas = Atlas_createFromFile(atlasName, 0); Atlas* atlas = new (__FILE__, __LINE__) Atlas(atlasName, 0);
SkeletonData* skeletonData = readSkeletonJsonData(jsonName, atlas, scale); SkeletonData* skeletonData = readSkeletonJsonData(jsonName, atlas, scale);
func(skeletonData, atlas); func(skeletonData, atlas);
SkeletonData_dispose(skeletonData); delete skeletonData;
skeletonData = readSkeletonBinaryData(binaryName, atlas, scale); skeletonData = readSkeletonBinaryData(binaryName, atlas, scale);
func(skeletonData, atlas); func(skeletonData, atlas);
SkeletonData_dispose(skeletonData); delete skeletonData;
Atlas_dispose(atlas); delete atlas;
} }
void spineboy (SkeletonData* skeletonData, Atlas* atlas) { void spineboy (SkeletonData* skeletonData, Atlas* atlas) {
SkeletonBounds* bounds = SkeletonBounds_create(); SkeletonBounds bounds;
// Configure mixing. // Configure mixing.
AnimationStateData* stateData = AnimationStateData_create(skeletonData); AnimationStateData stateData(skeletonData);
AnimationStateData_setMixByName(stateData, "walk", "jump", 0.2f); stateData.setMix("walk", "jump", 0.2f);
AnimationStateData_setMixByName(stateData, "jump", "run", 0.2f); stateData.setMix("jump", "run", 0.2f);
SkeletonDrawable* drawable = new SkeletonDrawable(skeletonData, stateData); SkeletonDrawable* drawable = new SkeletonDrawable(skeletonData, &stateData);
drawable->timeScale = 1; drawable->timeScale = 1;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->flipX = false; skeleton->setFlipX(false);
skeleton->flipY = false; skeleton->setFlipY(false);
Skeleton_setToSetupPose(skeleton); skeleton->setToSetupPose();
skeleton->x = 320; skeleton->setPosition(320, 590);
skeleton->y = 590; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
Slot* headSlot = Skeleton_findSlot(skeleton, "head"); Slot* headSlot = skeleton->findSlot("head");
drawable->state->listener = callback; drawable->state->setOnAnimationEventFunc(callback);
AnimationState_addAnimationByName(drawable->state, 0, "walk", true, 0); drawable->state->addAnimation(0, "walk", true, 0);
AnimationState_addAnimationByName(drawable->state, 0, "jump", false, 3); drawable->state->addAnimation(0, "jump", false, 3);
AnimationState_addAnimationByName(drawable->state, 0, "run", true, 0); drawable->state->addAnimation(0, "run", true, 0);
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - spineboy"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - spineboy");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -145,14 +144,14 @@ void spineboy (SkeletonData* skeletonData, Atlas* atlas) {
float delta = deltaClock.getElapsedTime().asSeconds(); float delta = deltaClock.getElapsedTime().asSeconds();
deltaClock.restart(); deltaClock.restart();
SkeletonBounds_update(bounds, skeleton, true); bounds.update(*skeleton, true);
sf::Vector2i position = sf::Mouse::getPosition(window); sf::Vector2i position = sf::Mouse::getPosition(window);
if (SkeletonBounds_containsPoint(bounds, position.x, position.y)) { if (bounds.containsPoint(position.x, position.y)) {
headSlot->color.g = 0; headSlot->getColor()._g = 0;
headSlot->color.b = 0; headSlot->getColor()._b = 0;
} else { } else {
headSlot->color.g = 1; headSlot->getColor()._g = 1;
headSlot->color.b = 1; headSlot->getColor()._b = 1;
} }
drawable->update(delta); drawable->update(delta);
@ -162,7 +161,7 @@ void spineboy (SkeletonData* skeletonData, Atlas* atlas) {
window.display(); window.display();
} }
SkeletonBounds_dispose(bounds); delete drawable;
} }
void goblins (SkeletonData* skeletonData, Atlas* atlas) { void goblins (SkeletonData* skeletonData, Atlas* atlas) {
@ -170,17 +169,15 @@ void goblins (SkeletonData* skeletonData, Atlas* atlas) {
drawable->timeScale = 1; drawable->timeScale = 1;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->flipX = false; skeleton->setFlipX(false);
skeleton->flipY = false; skeleton->setFlipY(false);
Skeleton_setSkinByName(skeleton, "goblin"); skeleton->setSkin("goblin");
Skeleton_setSlotsToSetupPose(skeleton); skeleton->setSlotsToSetupPose();
//Skeleton_setAttachment(skeleton, "left hand item", "dagger");
skeleton->x = 320; skeleton->setPosition(320, 590);
skeleton->y = 590; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
AnimationState_setAnimationByName(drawable->state, 0, "walk", true); drawable->state->setAnimation(0, "walk", true);
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - goblins"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - goblins");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -205,17 +202,16 @@ void raptor (SkeletonData* skeletonData, Atlas* atlas) {
SkeletonDrawable* drawable = new SkeletonDrawable(skeletonData); SkeletonDrawable* drawable = new SkeletonDrawable(skeletonData);
drawable->timeScale = 1; drawable->timeScale = 1;
spSwirlVertexEffect* effect = spSwirlVertexEffect_create(400); // BOZO spSwirlVertexEffect* effect = spSwirlVertexEffect_create(400);
effect->centerY = -200; // effect->centerY = -200;
drawable->vertexEffect = &effect->super; // drawable->vertexEffect = &effect->super;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->x = 320; skeleton->setPosition(320, 590);
skeleton->y = 590; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
AnimationState_setAnimationByName(drawable->state, 0, "walk", true); drawable->state->setAnimation(0, "walk", true);
AnimationState_addAnimationByName(drawable->state, 1, "gun-grab", false, 2); drawable->state->addAnimation(1, "gun-grab", false, 2);
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - raptor"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - raptor");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -230,9 +226,9 @@ void raptor (SkeletonData* skeletonData, Atlas* atlas) {
deltaClock.restart(); deltaClock.restart();
swirlTime += delta; swirlTime += delta;
float percent = fmod(swirlTime, 2); float percent = MathUtil::fmod(swirlTime, 2);
if (percent > 1) percent = 1 - (percent - 1); if (percent > 1) percent = 1 - (percent - 1);
effect->angle = _spMath_interpolate(_spMath_pow2_apply, -60, 60, percent); // BOZO effect->angle = _spMath_interpolate(_spMath_pow2_apply, -60, 60, percent);
drawable->update(delta); drawable->update(delta);
@ -240,7 +236,7 @@ void raptor (SkeletonData* skeletonData, Atlas* atlas) {
window.draw(*drawable); window.draw(*drawable);
window.display(); window.display();
} }
spSwirlVertexEffect_dispose(effect); // BOZO spSwirlVertexEffect_dispose(effect);
} }
void tank (SkeletonData* skeletonData, Atlas* atlas) { void tank (SkeletonData* skeletonData, Atlas* atlas) {
@ -248,11 +244,10 @@ void tank (SkeletonData* skeletonData, Atlas* atlas) {
drawable->timeScale = 1; drawable->timeScale = 1;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->x = 500; skeleton->setPosition(500, 590);
skeleton->y = 590; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
AnimationState_setAnimationByName(drawable->state, 0, "drive", true); drawable->state->setAnimation(0, "drive", true);
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - tank"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - tank");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -277,11 +272,10 @@ void vine (SkeletonData* skeletonData, Atlas* atlas) {
drawable->timeScale = 1; drawable->timeScale = 1;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->x = 320; skeleton->setPosition(320, 590);
skeleton->y = 590; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
AnimationState_setAnimationByName(drawable->state, 0, "grow", true); drawable->state->setAnimation(0, "grow", true);
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - vine"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - vine");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -307,14 +301,13 @@ void stretchyman (SkeletonData* skeletonData, Atlas* atlas) {
drawable->timeScale = 1; drawable->timeScale = 1;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->flipX = false; skeleton->setFlipX(false);
skeleton->flipY = false; skeleton->setFlipY(false);
skeleton->x = 100; skeleton->setPosition(100, 590);
skeleton->y = 590; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
AnimationState_setAnimationByName(drawable->state, 0, "sneak", true); drawable->state->setAnimation(0, "sneak", true);
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - Streatchyman"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - Streatchyman");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -340,11 +333,10 @@ void coin (SkeletonData* skeletonData, Atlas* atlas) {
drawable->timeScale = 1; drawable->timeScale = 1;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->x = 320; skeleton->setPosition(320, 590);
skeleton->y = 590; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
AnimationState_setAnimationByName(drawable->state, 0, "rotate", true); drawable->state->setAnimation(0, "rotate", true);
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - vine"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - vine");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -371,25 +363,24 @@ void owl (SkeletonData* skeletonData, Atlas* atlas) {
drawable->timeScale = 1; drawable->timeScale = 1;
Skeleton* skeleton = drawable->skeleton; Skeleton* skeleton = drawable->skeleton;
skeleton->x = 320; skeleton->setPosition(320, 400);
skeleton->y = 400; skeleton->updateWorldTransform();
Skeleton_updateWorldTransform(skeleton);
AnimationState_setAnimationByName(drawable->state, 0, "idle", true); drawable->state->setAnimation(0, "idle", true);
AnimationState_setAnimationByName(drawable->state, 1, "blink", true); drawable->state->setAnimation(1, "blink", true);
spTrackEntry* left = AnimationState_setAnimationByName(drawable->state, 2, "left", true); TrackEntry* left = drawable->state->setAnimation(2, "left", true);
spTrackEntry* right = AnimationState_setAnimationByName(drawable->state, 3, "right", true); TrackEntry* right = drawable->state->setAnimation(3, "right", true);
spTrackEntry* up = AnimationState_setAnimationByName(drawable->state, 4, "up", true); TrackEntry* up = drawable->state->setAnimation(4, "up", true);
spTrackEntry* down = AnimationState_setAnimationByName(drawable->state, 5, "down", true); TrackEntry* down = drawable->state->setAnimation(5, "down", true);
left->alpha = 0; left->setAlpha(0);
left->mixBlend = SP_MIX_BLEND_ADD; // BOZO left->setMixBlend(SP_MIX_BLEND_ADD);
right->alpha = 0; right->setAlpha(0);
right->mixBlend = SP_MIX_BLEND_ADD; // BOZO right->mixBlend = SP_MIX_BLEND_ADD;
up->alpha = 0; up->setAlpha(0);
up->mixBlend = SP_MIX_BLEND_ADD; // BOZO up->mixBlend = SP_MIX_BLEND_ADD;
down->alpha = 0; down->setAlpha(0);
down->mixBlend = SP_MIX_BLEND_ADD; // BOZO down->mixBlend = SP_MIX_BLEND_ADD;
sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - owl"); sf::RenderWindow window(sf::VideoMode(640, 640), "Spine SFML - owl");
window.setFramerateLimit(60); window.setFramerateLimit(60);
@ -400,12 +391,12 @@ void owl (SkeletonData* skeletonData, Atlas* atlas) {
if (event.type == sf::Event::Closed) window.close(); if (event.type == sf::Event::Closed) window.close();
if (event.type == sf::Event::MouseMoved) { if (event.type == sf::Event::MouseMoved) {
float x = event.mouseMove.x / 640.0f; float x = event.mouseMove.x / 640.0f;
left->alpha = (MAX(x, 0.5f) - 0.5f) * 2; left->setAlpha((MAX(x, 0.5f) - 0.5f) * 2);
right->alpha = (0.5 - MIN(x, 0.5)) * 2; right->setAlpha((0.5 - MIN(x, 0.5)) * 2);
float y = event.mouseMove.y / 640.0f; float y = event.mouseMove.y / 640.0f;
down->alpha = (MAX(y, 0.5f) - 0.5f) * 2; down->setAlpha((MAX(y, 0.5f) - 0.5f) * 2);
up->alpha = (0.5 - MIN(y, 0.5)) * 2; up->setAlpha((0.5 - MIN(y, 0.5)) * 2);
} }
} }
@ -424,38 +415,40 @@ void owl (SkeletonData* skeletonData, Atlas* atlas) {
* Used for debugging purposes during runtime development * Used for debugging purposes during runtime development
*/ */
void test (SkeletonData* skeletonData, Atlas* atlas) { void test (SkeletonData* skeletonData, Atlas* atlas) {
spSkeleton* skeleton = Skeleton_create(skeletonData); Skeleton* skeleton = new (__FILE__, __LINE__) Skeleton(skeletonData);
spAnimationStateData* animData = spAnimationStateData_create(skeletonData); AnimationStateData* animData = new (__FILE__, __LINE__) AnimationStateData(skeletonData);
spAnimationState* animState = spAnimationState_create(animData); AnimationState* animState = new (__FILE__, __LINE__) AnimationState(animData);
spAnimationState_setAnimationByName(animState, 0, "drive", true); animState->setAnimation(0, "drive", true);
float d = 3; float d = 3;
for (int i = 0; i < 1; i++) { for (int i = 0; i < 1; i++) {
spSkeleton_update(skeleton, d); skeleton->update(d);
spAnimationState_update(animState, d); animState->update(d);
spAnimationState_apply(animState, skeleton); animState->apply(*skeleton);
spSkeleton_updateWorldTransform(skeleton); skeleton->updateWorldTransform();
for (int ii = 0; ii < skeleton->bonesCount; ii++) { for (int ii = 0; ii < skeleton->getBones().size(); ii++) {
spBone* bone = skeleton->bones[ii]; Bone* bone = skeleton->getBones()[ii];
printf("%s %f %f %f %f %f %f\n", bone->data->name, bone->a, bone->b, bone->c, bone->d, bone->worldX, bone->worldY); printf("%s %f %f %f %f %f %f\n", bone->getData().getName().buffer(), bone->getA(), bone->getB(), bone->getC(), bone->getD(), bone->getWorldX(), bone->getWorldY());
} }
printf("========================================\n"); printf("========================================\n");
d += 0.1f; d += 0.1f;
} }
Skeleton_dispose(skeleton); delete skeleton;
delete animData;
delete animState;
} }
int main () { int main () {
testcase(test, "data/tank-pro.json", "data/tank-pro.skel", "data/tank.atlas", 1.0f); testcase(test, "data/tank-pro.json", "data/tank-pro.skel", "data/tank.atlas", 1.0f);
testcase(owl, "data/owl-pro.json", "data/owl-pro.skel", "data/owl.atlas", 0.5f); testcase(spineboy, "data/spineboy-ess.json", "data/spineboy-ess.skel", "data/spineboy.atlas", 0.6f);
/*testcase(owl, "data/owl-pro.json", "data/owl-pro.skel", "data/owl.atlas", 0.5f);
testcase(coin, "data/coin-pro.json", "data/coin-pro.skel", "data/coin.atlas", 0.5f); testcase(coin, "data/coin-pro.json", "data/coin-pro.skel", "data/coin.atlas", 0.5f);
testcase(vine, "data/vine-pro.json", "data/vine-pro.skel", "data/vine.atlas", 0.5f); testcase(vine, "data/vine-pro.json", "data/vine-pro.skel", "data/vine.atlas", 0.5f);
testcase(tank, "data/tank-pro.json", "data/tank-pro.skel", "data/tank.atlas", 0.2f); testcase(tank, "data/tank-pro.json", "data/tank-pro.skel", "data/tank.atlas", 0.2f);
testcase(raptor, "data/raptor-pro.json", "data/raptor-pro.skel", "data/raptor.atlas", 0.5f); testcase(raptor, "data/raptor-pro.json", "data/raptor-pro.skel", "data/raptor.atlas", 0.5f);
testcase(spineboy, "data/spineboy-ess.json", "data/spineboy-ess.skel", "data/spineboy.atlas", 0.6f); testcase(spineboy, "data/spineboy-ess.json", "data/spineboy-ess.skel", "data/spineboy.atlas", 0.6f);
testcase(goblins, "data/goblins-pro.json", "data/goblins-pro.skel", "data/goblins.atlas", 1.4f); testcase(goblins, "data/goblins-pro.json", "data/goblins-pro.skel", "data/goblins.atlas", 1.4f);
testcase(stretchyman, "data/stretchyman-pro.json", "data/stretchyman-pro.skel", "data/stretchyman.atlas", 0.6f); testcase(stretchyman, "data/stretchyman-pro.json", "data/stretchyman-pro.skel", "data/stretchyman.atlas", 0.6f);*/
return 0; return 0;
} }

190
spine-sfml/cpp/src/spine/spine-sfml.cpp
View File

@ -47,14 +47,13 @@ sf::BlendMode additivePma = sf::BlendMode(sf::BlendMode::One, sf::BlendMode::One
sf::BlendMode multiplyPma = sf::BlendMode(sf::BlendMode::DstColor, sf::BlendMode::OneMinusSrcAlpha); sf::BlendMode multiplyPma = sf::BlendMode(sf::BlendMode::DstColor, sf::BlendMode::OneMinusSrcAlpha);
sf::BlendMode screenPma = sf::BlendMode(sf::BlendMode::One, sf::BlendMode::OneMinusSrcColor); sf::BlendMode screenPma = sf::BlendMode(sf::BlendMode::One, sf::BlendMode::OneMinusSrcColor);
_SP_ARRAY_IMPLEMENT_TYPE(spColorArray, spColor)
void _AtlasPage_createTexture (AtlasPage* self, const char* path){ void _AtlasPage_createTexture (Spine::AtlasPage* self, const char* path){
Texture* texture = new Texture(); Texture* texture = new Texture();
if (!texture->loadFromFile(path)) return; if (!texture->loadFromFile(path)) return;
if (self->magFilter == SP_ATLAS_LINEAR) texture->setSmooth(true); if (self->magFilter == Spine::TextureFilter_Nearest) texture->setSmooth(true);
if (self->uWrap == SP_ATLAS_REPEAT && self->vWrap == SP_ATLAS_REPEAT) texture->setRepeated(true); if (self->uWrap == Spine::TextureWrap_Repeat && self->vWrap == Spine::TextureWrap_Repeat) texture->setRepeated(true);
self->rendererObject = texture; self->rendererObject = texture;
Vector2u size = texture->getSize(); Vector2u size = texture->getSize();
@ -62,147 +61,146 @@ void _AtlasPage_createTexture (AtlasPage* self, const char* path){
self->height = size.y; self->height = size.y;
} }
void _AtlasPage_disposeTexture (AtlasPage* self){ void _AtlasPage_disposeTexture (Spine::AtlasPage* self){
delete (Texture*)self->rendererObject; delete (Texture*)self->rendererObject;
} }
char* _Util_readFile (const char* path, int* length){ char* _Util_readFile (const char* path, int* length){
return _spReadFile(path, length); return Spine::SpineExtension::readFile(Spine::String(path), length);
} }
/**/ /**/
namespace spine { namespace Spine {
SkeletonDrawable::SkeletonDrawable (SkeletonData* skeletonData, AnimationStateData* stateData) : SkeletonDrawable::SkeletonDrawable (SkeletonData* skeletonData, AnimationStateData* stateData) :
timeScale(1), timeScale(1),
vertexArray(new VertexArray(Triangles, skeletonData->bonesCount * 4)), vertexArray(new VertexArray(Triangles, skeletonData->getBones().size() * 4)),
vertexEffect(0), worldVertices(), clipper() {
worldVertices(0), clipper(0) { Bone::setYDown(true);
Bone_setYDown(true); worldVertices.setSize(SPINE_MESH_VERTEX_COUNT_MAX);
worldVertices = MALLOC(float, SPINE_MESH_VERTEX_COUNT_MAX); skeleton = new (__FILE__, __LINE__) Skeleton(skeletonData);
skeleton = Skeleton_create(skeletonData); tempUvs.ensureCapacity(16);
tempUvs = spFloatArray_create(16); tempColors.ensureCapacity(16);
tempColors = spColorArray_create(16);
ownsAnimationStateData = stateData == 0; ownsAnimationStateData = stateData == 0;
if (ownsAnimationStateData) stateData = AnimationStateData_create(skeletonData); if (ownsAnimationStateData) stateData = new (__FILE__, __LINE__) AnimationStateData(skeletonData);
state = AnimationState_create(stateData); state = new (__FILE__, __LINE__) AnimationState(stateData);
clipper = spSkeletonClipping_create();
} }
SkeletonDrawable::~SkeletonDrawable () { SkeletonDrawable::~SkeletonDrawable () {
delete vertexArray; delete vertexArray;
FREE(worldVertices); if (ownsAnimationStateData) delete state->getData();
if (ownsAnimationStateData) AnimationStateData_dispose(state->data); delete state;
AnimationState_dispose(state); delete skeleton;
Skeleton_dispose(skeleton);
spSkeletonClipping_dispose(clipper);
spFloatArray_dispose(tempUvs);
spColorArray_dispose(tempColors);
} }
void SkeletonDrawable::update (float deltaTime) { void SkeletonDrawable::update (float deltaTime) {
Skeleton_update(skeleton, deltaTime); skeleton->update(deltaTime);
AnimationState_update(state, deltaTime * timeScale); state->update(deltaTime * timeScale);
AnimationState_apply(state, skeleton); state->apply(*skeleton);
Skeleton_updateWorldTransform(skeleton); skeleton->updateWorldTransform();
} }
void SkeletonDrawable::draw (RenderTarget& target, RenderStates states) const { void SkeletonDrawable::draw (RenderTarget& target, RenderStates states) const {
vertexArray->clear(); vertexArray->clear();
states.texture = 0; states.texture = NULL;
unsigned short quadIndices[6] = { 0, 1, 2, 2, 3, 0 }; Vector<unsigned short> quadIndices;
quadIndices.add(0);
quadIndices.add(1);
quadIndices.add(2);
quadIndices.add(2);
quadIndices.add(3);
quadIndices.add(0);
if (vertexEffect != 0) vertexEffect->begin(vertexEffect, skeleton); // BOZO if (vertexEffect != 0) vertexEffect->begin(vertexEffect, skeleton);
sf::Vertex vertex; sf::Vertex vertex;
Texture* texture = 0; Texture* texture = NULL;
for (int i = 0; i < skeleton->slotsCount; ++i) { for (int i = 0; i < skeleton->getSlots().size(); ++i) {
Slot* slot = skeleton->drawOrder[i]; Slot& slot = *skeleton->getDrawOrder()[i];
Attachment* attachment = slot->attachment; Attachment* attachment = slot.getAttachment();
if (!attachment) continue; if (!attachment) continue;
float* vertices = worldVertices; Vector<float>* vertices = &worldVertices;
int verticesCount = 0; int verticesCount = 0;
float* uvs = 0; Vector<float>* uvs = NULL;
unsigned short* indices = 0; Vector<unsigned short>* indices = NULL;
int indicesCount = 0; int indicesCount = 0;
spColor* attachmentColor; Color* attachmentColor;
if (attachment->type == ATTACHMENT_REGION) { if (attachment->rtti.derivesFrom(RegionAttachment::rtti)) {
RegionAttachment* regionAttachment = (RegionAttachment*)attachment; RegionAttachment* regionAttachment = (RegionAttachment*)attachment;
spRegionAttachment_computeWorldVertices(regionAttachment, slot->bone, vertices, 0, 2); regionAttachment->computeWorldVertices(slot.getBone(), worldVertices, 0, 2);
verticesCount = 4; verticesCount = 4;
uvs = regionAttachment->uvs; uvs = &regionAttachment->getUVs();
indices = quadIndices; indices = &quadIndices;
indicesCount = 6; indicesCount = 6;
texture = (Texture*)((AtlasRegion*)regionAttachment->rendererObject)->page->rendererObject; texture = (Texture*)((AtlasRegion*)regionAttachment->getRendererObject())->page->rendererObject;
attachmentColor = &regionAttachment->color; attachmentColor = &regionAttachment->getColor();
} else if (attachment->type == ATTACHMENT_MESH) { } else if (attachment->rtti.derivesFrom(MeshAttachment::rtti)) {
MeshAttachment* mesh = (MeshAttachment*)attachment; MeshAttachment* mesh = (MeshAttachment*)attachment;
if (mesh->super.worldVerticesLength > SPINE_MESH_VERTEX_COUNT_MAX) continue; if (mesh->getWorldVerticesLength() > worldVertices.size()) worldVertices.setSize(mesh->getWorldVerticesLength());
texture = (Texture*)((AtlasRegion*)mesh->rendererObject)->page->rendererObject; texture = (Texture*)((AtlasRegion*)mesh->getRendererObject())->page->rendererObject;
spVertexAttachment_computeWorldVertices(SUPER(mesh), slot, 0, mesh->super.worldVerticesLength, worldVertices, 0, 2); mesh->computeWorldVertices(slot, 0, mesh->getWorldVerticesLength(), worldVertices, 0, 2);
verticesCount = mesh->super.worldVerticesLength >> 1; verticesCount = mesh->getWorldVerticesLength() >> 1;
uvs = mesh->uvs; uvs = &mesh->getUVs();
indices = mesh->triangles; indices = &mesh->getTriangles();
indicesCount = mesh->trianglesCount; indicesCount = mesh->getTriangles().size();
attachmentColor = &mesh->color; attachmentColor = &mesh->getColor();
} else if (attachment->type == SP_ATTACHMENT_CLIPPING) { } else if (attachment->rtti.derivesFrom(ClippingAttachment::rtti)) {
spClippingAttachment* clip = (spClippingAttachment*)slot->attachment; ClippingAttachment* clip = (ClippingAttachment*)slot.getAttachment();
spSkeletonClipping_clipStart(clipper, slot, clip); clipper.clipStart(slot, clip);
continue; continue;
} else continue; } else continue;
Uint8 r = static_cast<Uint8>(skeleton->color.r * slot->color.r * attachmentColor->r * 255); Uint8 r = static_cast<Uint8>(skeleton->getColor()._r * slot.getColor()._r * attachmentColor->_r * 255);
Uint8 g = static_cast<Uint8>(skeleton->color.g * slot->color.g * attachmentColor->g * 255); Uint8 g = static_cast<Uint8>(skeleton->getColor()._g * slot.getColor()._g * attachmentColor->_g * 255);
Uint8 b = static_cast<Uint8>(skeleton->color.b * slot->color.b * attachmentColor->b * 255); Uint8 b = static_cast<Uint8>(skeleton->getColor()._b * slot.getColor()._b * attachmentColor->_b * 255);
Uint8 a = static_cast<Uint8>(skeleton->color.a * slot->color.a * attachmentColor->a * 255); Uint8 a = static_cast<Uint8>(skeleton->getColor()._a * slot.getColor()._a * attachmentColor->_a * 255);
vertex.color.r = r; vertex.color.r = r;
vertex.color.g = g; vertex.color.g = g;
vertex.color.b = b; vertex.color.b = b;
vertex.color.a = a; vertex.color.a = a;
spColor light; Color light;
light.r = r / 255.0f; light._r = r / 255.0f;
light.g = g / 255.0f; light._g = g / 255.0f;
light.b = b / 255.0f; light._b = b / 255.0f;
light.a = a / 255.0f; light._a = a / 255.0f;
sf::BlendMode blend; sf::BlendMode blend;
if (!usePremultipliedAlpha) { if (!usePremultipliedAlpha) {
switch (slot->data->blendMode) { switch (slot.getData().getBlendMode()) {
case BLEND_MODE_NORMAL: case BlendMode_Normal:
blend = normal; blend = normal;
break; break;
case BLEND_MODE_ADDITIVE: case BlendMode_Additive:
blend = additive; blend = additive;
break; break;
case BLEND_MODE_MULTIPLY: case BlendMode_Multiply:
blend = multiply; blend = multiply;
break; break;
case BLEND_MODE_SCREEN: case BlendMode_Screen:
blend = screen; blend = screen;
break; break;
default: default:
blend = normal; blend = normal;
} }
} else { } else {
switch (slot->data->blendMode) { switch (slot.getData().getBlendMode()) {
case BLEND_MODE_NORMAL: case BlendMode_Normal:
blend = normalPma; blend = normalPma;
break; break;
case BLEND_MODE_ADDITIVE: case BlendMode_Additive:
blend = additivePma; blend = additivePma;
break; break;
case BLEND_MODE_MULTIPLY: case BlendMode_Multiply:
blend = multiplyPma; blend = multiplyPma;
break; break;
case BLEND_MODE_SCREEN: case BlendMode_Screen:
blend = screenPma; blend = screenPma;
break; break;
default: default:
@ -219,18 +217,18 @@ void SkeletonDrawable::draw (RenderTarget& target, RenderStates states) const {
states.texture = texture; states.texture = texture;
} }
if (spSkeletonClipping_isClipping(clipper)) { if (clipper.isClipping()) {
spSkeletonClipping_clipTriangles(clipper, vertices, verticesCount << 1, indices, indicesCount, uvs, 2); clipper.clipTriangles(worldVertices, verticesCount << 1, *indices, indicesCount, *uvs);
vertices = clipper->clippedVertices->items; vertices = &clipper.getClippedVertices();
verticesCount = clipper->clippedVertices->size >> 1; verticesCount = clipper.getClippedVertices().size() >> 1;
uvs = clipper->clippedUVs->items; uvs = &clipper.getClippedUVs();
indices = clipper->clippedTriangles->items; indices = &clipper.getClippedTriangles();
indicesCount = clipper->clippedTriangles->size; indicesCount = clipper.getClippedTriangles().size();
} }
Vector2u size = texture->getSize(); Vector2u size = texture->getSize();
if (vertexEffect != 0) { /* BOZO if (vertexEffect != 0) {
spFloatArray_clear(tempUvs); spFloatArray_clear(tempUvs);
spColorArray_clear(tempColors); spColorArray_clear(tempColors);
for (int i = 0; i < verticesCount; i++) { for (int i = 0; i < verticesCount; i++) {
@ -263,23 +261,23 @@ void SkeletonDrawable::draw (RenderTarget& target, RenderStates states) const {
vertex.color.a = static_cast<Uint8>(vertexColor.a * 255); vertex.color.a = static_cast<Uint8>(vertexColor.a * 255);
vertexArray->append(vertex); vertexArray->append(vertex);
} }
} else { } else {*/
for (int i = 0; i < indicesCount; ++i) { for (int i = 0; i < indicesCount; ++i) {
int index = indices[i] << 1; int index = (*indices)[i] << 1;
vertex.position.x = vertices[index]; vertex.position.x = (*vertices)[index];
vertex.position.y = vertices[index + 1]; vertex.position.y = (*vertices)[index + 1];
vertex.texCoords.x = uvs[index] * size.x; vertex.texCoords.x = (*uvs)[index] * size.x;
vertex.texCoords.y = uvs[index + 1] * size.y; vertex.texCoords.y = (*uvs)[index + 1] * size.y;
vertexArray->append(vertex); vertexArray->append(vertex);
} }
} // }
spSkeletonClipping_clipEnd(clipper, slot); clipper.clipEnd(slot);
} }
target.draw(*vertexArray, states); target.draw(*vertexArray, states);
spSkeletonClipping_clipEnd2(clipper); clipper.clipEnd();
if (vertexEffect != 0) vertexEffect->end(vertexEffect); // BOZO if (vertexEffect != 0) vertexEffect->end(vertexEffect);
} }
} /* namespace spine */ } /* namespace spine */

24
spine-sfml/cpp/src/spine/spine-sfml.h
View File

@ -38,34 +38,32 @@
#include <SFML/Graphics/RenderTarget.hpp> #include <SFML/Graphics/RenderTarget.hpp>
#include <SFML/Graphics/RenderStates.hpp> #include <SFML/Graphics/RenderStates.hpp>
_SP_ARRAY_DECLARE_TYPE(spColorArray, spColor)
namespace spine { namespace Spine {
class SkeletonDrawable: public sf::Drawable { class SkeletonDrawable: public sf::Drawable {
public: public:
spSkeleton* skeleton; Skeleton* skeleton;
spAnimationState* state; AnimationState* state;
float timeScale; float timeScale;
sf::VertexArray* vertexArray; sf::VertexArray* vertexArray;
spVertexEffect* vertexEffect;
SkeletonDrawable (spSkeletonData* skeleton, spAnimationStateData* stateData = 0); SkeletonDrawable (SkeletonData* skeleton, AnimationStateData* stateData = 0);
~SkeletonDrawable (); ~SkeletonDrawable ();
void update (float deltaTime); void update (float deltaTime);
virtual void draw (sf::RenderTarget& target, sf::RenderStates states) const; virtual void draw (sf::RenderTarget& target, sf::RenderStates states) const ;
void setUsePremultipliedAlpha(bool usePMA) { usePremultipliedAlpha = usePMA; }; void setUsePremultipliedAlpha(bool usePMA) { usePremultipliedAlpha = usePMA; };
bool getUsePremultipliedAlpha() { return usePremultipliedAlpha; }; bool getUsePremultipliedAlpha() { return usePremultipliedAlpha; };
private: private:
bool ownsAnimationStateData; mutable bool ownsAnimationStateData;
float* worldVertices; mutable Vector<float> worldVertices;
spFloatArray* tempUvs; mutable Vector<float> tempUvs;
spColorArray* tempColors; mutable Vector<Color> tempColors;
spSkeletonClipping* clipper; mutable SkeletonClipping clipper;
bool usePremultipliedAlpha; mutable bool usePremultipliedAlpha;
}; };
} /* namespace spine */ } /* namespace spine */