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

Temporarily commenting out some sections so I can build

Browse Source
This commit is contained in:
Stephen Gowen 2017-11-02 13:41:56 -04:00
parent ac0302d09c
commit 51f3306a72
3 changed files with 240 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -40,104 +40,104 @@ namespace Spine
{ {
RTTI_DECL; RTTI_DECL;
public: // public:
public int HullLength { get { return _hulllength; } set { _hulllength = value; } } // public int HullLength { get { return _hulllength; } set { _hulllength = value; } }
public float[] RegionUVs { get { return _regionUVs; } set { _regionUVs = value; } } // public float[] RegionUVs { get { return _regionUVs; } set { _regionUVs = value; } }
/// The UV pair for each vertex, normalized within the entire texture. <seealso cref="MeshAttachment.updateUVs"/> // /// The UV pair for each vertex, normalized within the entire texture. <seealso cref="MeshAttachment.updateUVs"/>
public float[] UVs { get { return _uvs; } set { _uvs = value; } } // public float[] UVs { get { return _uvs; } set { _uvs = value; } }
public int[] Triangles { get { return _triangles; } set { _triangles = value; } } // public int[] Triangles { get { return _triangles; } set { _triangles = value; } }
//
public float R { get { return r; } set { r = value; } } // public float R { get { return r; } set { r = value; } }
public float G { get { return g; } set { g = value; } } // public float G { get { return g; } set { g = value; } }
public float B { get { return b; } set { b = value; } } // public float B { get { return b; } set { b = value; } }
public float A { get { return a; } set { a = value; } } // public float A { get { return a; } set { a = value; } }
//
public string Path { get; set; } // public string Path { get; set; }
public object RendererObject; //public Object RendererObject { get; set; } // public object RendererObject; //public Object RendererObject { get; set; }
public float RegionU { get; set; } // public float RegionU { get; set; }
public float RegionV { get; set; } // public float RegionV { get; set; }
public float RegionU2 { get; set; } // public float RegionU2 { get; set; }
public float RegionV2 { get; set; } // public float RegionV2 { get; set; }
public bool RegionRotate { get; set; } // public bool RegionRotate { get; set; }
public float RegionOffsetX { get { return _regionOffsetX; } set { _regionOffsetX = value; } } // public float RegionOffsetX { get { return _regionOffsetX; } set { _regionOffsetX = value; } }
public float RegionOffsetY { get { return _regionOffsetY; } set { _regionOffsetY = value; } } // Pixels stripped from the bottom left, unrotated. // public float RegionOffsetY { get { return _regionOffsetY; } set { _regionOffsetY = value; } } // Pixels stripped from the bottom left, unrotated.
public float RegionWidth { get { return _regionWidth; } set { _regionWidth = value; } } // public float RegionWidth { get { return _regionWidth; } set { _regionWidth = value; } }
public float RegionHeight { get { return _regionHeight; } set { _regionHeight = value; } } // Unrotated, stripped size. // public float RegionHeight { get { return _regionHeight; } set { _regionHeight = value; } } // Unrotated, stripped size.
public float RegionOriginalWidth { get { return _regionOriginalWidth; } set { _regionOriginalWidth = value; } } // public float RegionOriginalWidth { get { return _regionOriginalWidth; } set { _regionOriginalWidth = value; } }
public float RegionOriginalHeight { get { return _regionOriginalHeight; } set { _regionOriginalHeight = value; } } // Unrotated, unstripped size. // public float RegionOriginalHeight { get { return _regionOriginalHeight; } set { _regionOriginalHeight = value; } } // Unrotated, unstripped size.
//
public bool InheritDeform { get { return _inheritDeform; } set { _inheritDeform = value; } } // public bool InheritDeform { get { return _inheritDeform; } set { _inheritDeform = value; } }
//
public MeshAttachment ParentMesh { // public MeshAttachment ParentMesh {
get { return _parentMesh; } // get { return _parentMesh; }
set { // set {
_parentMesh = value; // _parentMesh = value;
if (value != null) { // if (value != null) {
bones = value.bones; // bones = value.bones;
vertices = value.vertices; // vertices = value.vertices;
worldVerticesLength = value.worldVerticesLength; // worldVerticesLength = value.worldVerticesLength;
_regionUVs = value._regionUVs; // _regionUVs = value._regionUVs;
_triangles = value._triangles; // _triangles = value._triangles;
HullLength = value.HullLength; // HullLength = value.HullLength;
Edges = value.Edges; // Edges = value.Edges;
Width = value.Width; // Width = value.Width;
Height = value.Height; // Height = value.Height;
} // }
} // }
} // }
//
// Nonessential. // // Nonessential.
public int[] Edges { get; set; } // public int[] Edges { get; set; }
public float Width { get; set; } // public float Width { get; set; }
public float Height { get; set; } // public float Height { get; set; }
//
public MeshAttachment (string name) : VertexAttachment(name) // public MeshAttachment (string name) : VertexAttachment(name)
{ // {
// Empty // // Empty
} // }
//
public void updateUVs() // public void updateUVs()
{ // {
float u = RegionU, v = RegionV, width = RegionU2 - RegionU, height = RegionV2 - RegionV; // float u = RegionU, v = RegionV, width = RegionU2 - RegionU, height = RegionV2 - RegionV;
if (_uvs == null || _uvs.Length != _regionUVs.Length) // if (_uvs == null || _uvs.Length != _regionUVs.Length)
{ // {
_uvs = new float[_regionUVs.Length]; // _uvs = new float[_regionUVs.Length];
} // }
//
float[] _uvs = _uvs; // float[] _uvs = _uvs;
if (_regionRotate) // if (_regionRotate)
{ // {
for (int i = 0, n = _uvs.Length; i < n; i += 2) // for (int i = 0, n = _uvs.Length; i < n; i += 2)
{ // {
_uvs[i] = u + _regionUVs[i + 1] * width; // _uvs[i] = u + _regionUVs[i + 1] * width;
_uvs[i + 1] = v + height - _regionUVs[i] * height; // _uvs[i + 1] = v + height - _regionUVs[i] * height;
} // }
} // }
else // else
{ // {
for (int i = 0, n = _uvs.Length; i < n; i += 2) // for (int i = 0, n = _uvs.Length; i < n; i += 2)
{ // {
_uvs[i] = u + _regionUVs[i] * width; // _uvs[i] = u + _regionUVs[i] * width;
_uvs[i + 1] = v + _regionUVs[i + 1] * height; // _uvs[i + 1] = v + _regionUVs[i + 1] * height;
} // }
} // }
} // }
//
virtual bool applyDeform(VertexAttachment* sourceAttachment) // virtual bool applyDeform(VertexAttachment* sourceAttachment)
{ // {
return this == sourceAttachment || (_inheritDeform && _parentMesh == sourceAttachment); // return this == sourceAttachment || (_inheritDeform && _parentMesh == sourceAttachment);
} // }
//
private: // private:
float _regionOffsetX, _regionOffsetY, _regionWidth, _regionHeight, _regionOriginalWidth, _regionOriginalHeight; // float _regionOffsetX, _regionOffsetY, _regionWidth, _regionHeight, _regionOriginalWidth, _regionOriginalHeight;
MeshAttachment* _parentMesh; // MeshAttachment* _parentMesh;
float[] _uvs, _regionUVs; // float[] _uvs, _regionUVs;
int[] _triangles; // int[] _triangles;
float r = 1, g = 1, b = 1, a = 1; // float r = 1, g = 1, b = 1, a = 1;
int _hulllength; // int _hulllength;
bool _inheritDeform; // bool _inheritDeform;
bool _regionRotate; // bool _regionRotate;
} };
} }
#endif /* Spine_MeshAttachment_h */ #endif /* Spine_MeshAttachment_h */

280
spine-cpp/spine-cpp/include/spine/RegionAttachment.h
View File

@ -47,146 +47,146 @@ namespace Spine
{ {
RTTI_DECL; RTTI_DECL;
public: // public:
const int BLX = 0; // const int BLX = 0;
const int BLY = 1; // const int BLY = 1;
const int ULX = 2; // const int ULX = 2;
const int ULY = 3; // const int ULY = 3;
const int URX = 4; // const int URX = 4;
const int URY = 5; // const int URY = 5;
const int BRX = 6; // const int BRX = 6;
const int BRY = 7; // const int BRY = 7;
//
float X { get { return x; } set { x = value; } } // float X { get { return x; } set { x = value; } }
float Y { get { return y; } set { y = value; } } // float Y { get { return y; } set { y = value; } }
float Rotation { get { return _rotation; } set { _rotation = value; } } // float Rotation { get { return _rotation; } set { _rotation = value; } }
float ScaleX { get { return scaleX; } set { scaleX = value; } } // float ScaleX { get { return scaleX; } set { scaleX = value; } }
float ScaleY { get { return scaleY; } set { scaleY = value; } } // float ScaleY { get { return scaleY; } set { scaleY = value; } }
float Width { get { return width; } set { width = value; } } // float Width { get { return width; } set { width = value; } }
float Height { get { return height; } set { height = value; } } // float Height { get { return height; } set { height = value; } }
//
float R { get { return r; } set { r = value; } } // float R { get { return r; } set { r = value; } }
float G { get { return g; } set { g = value; } } // float G { get { return g; } set { g = value; } }
float B { get { return b; } set { b = value; } } // float B { get { return b; } set { b = value; } }
float A { get { return a; } set { a = value; } } // float A { get { return a; } set { a = value; } }
//
std::string Path { get; set; } // std::string Path { get; set; }
object RendererObject; //object RendererObject { get; set; } // object RendererObject; //object RendererObject { get; set; }
float RegionOffsetX { get { return _regionOffsetX; } set { _regionOffsetX = value; } } // float RegionOffsetX { get { return _regionOffsetX; } set { _regionOffsetX = value; } }
float RegionOffsetY { get { return _regionOffsetY; } set { _regionOffsetY = value; } } // Pixels stripped from the bottom left, unrotated. // float RegionOffsetY { get { return _regionOffsetY; } set { _regionOffsetY = value; } } // Pixels stripped from the bottom left, unrotated.
float RegionWidth { get { return _regionWidth; } set { _regionWidth = value; } } // float RegionWidth { get { return _regionWidth; } set { _regionWidth = value; } }
float RegionHeight { get { return _regionHeight; } set { _regionHeight = value; } } // Unrotated, stripped size. // float RegionHeight { get { return _regionHeight; } set { _regionHeight = value; } } // Unrotated, stripped size.
float RegionOriginalWidth { get { return _regionOriginalWidth; } set { _regionOriginalWidth = value; } } // float RegionOriginalWidth { get { return _regionOriginalWidth; } set { _regionOriginalWidth = value; } }
float RegionOriginalHeight { get { return _regionOriginalHeight; } set { _regionOriginalHeight = value; } } // Unrotated, unstripped size. // float RegionOriginalHeight { get { return _regionOriginalHeight; } set { _regionOriginalHeight = value; } } // Unrotated, unstripped size.
//
float[] Offset { get { return _offset; } } // float[] Offset { get { return _offset; } }
float[] UVs { get { return _uvs; } } // float[] UVs { get { return _uvs; } }
//
RegionAttachment (std::string name) : Attachment(name) // RegionAttachment (std::string name) : Attachment(name)
{ // {
// Empty // // Empty
} // }
//
void updateOffset() // void updateOffset()
{ // {
float regionScaleX = _width / _regionOriginalWidth * _scaleX; // float regionScaleX = _width / _regionOriginalWidth * _scaleX;
float regionScaleY = _height / _regionOriginalHeight * _scaleY; // float regionScaleY = _height / _regionOriginalHeight * _scaleY;
float localX = -_width / 2 * _scaleX + _regionOffsetX * regionScaleX; // float localX = -_width / 2 * _scaleX + _regionOffsetX * regionScaleX;
float localY = -_height / 2 * _scaleY + _regionOffsetY * regionScaleY; // float localY = -_height / 2 * _scaleY + _regionOffsetY * regionScaleY;
float localX2 = localX + _regionWidth * regionScaleX; // float localX2 = localX + _regionWidth * regionScaleX;
float localY2 = localY + _regionHeight * regionScaleY; // float localY2 = localY + _regionHeight * regionScaleY;
float cos = MathUtil::cosDeg(_rotation); // float cos = MathUtil::cosDeg(_rotation);
float sin = MathUtil::sinDeg(_rotation); // float sin = MathUtil::sinDeg(_rotation);
float localXCos = localX * cos + _x; // float localXCos = localX * cos + _x;
float localXSin = localX * sin; // float localXSin = localX * sin;
float localYCos = localY * cos + _y; // float localYCos = localY * cos + _y;
float localYSin = localY * sin; // float localYSin = localY * sin;
float localX2Cos = localX2 * cos + _x; // float localX2Cos = localX2 * cos + _x;
float localX2Sin = localX2 * sin; // float localX2Sin = localX2 * sin;
float localY2Cos = localY2 * cos + _y; // float localY2Cos = localY2 * cos + _y;
float localY2Sin = localY2 * sin; // float localY2Sin = localY2 * sin;
//
_offset[BLX] = localXCos - localYSin; // _offset[BLX] = localXCos - localYSin;
_offset[BLY] = localYCos + localXSin; // _offset[BLY] = localYCos + localXSin;
_offset[ULX] = localXCos - localY2Sin; // _offset[ULX] = localXCos - localY2Sin;
_offset[ULY] = localY2Cos + localXSin; // _offset[ULY] = localY2Cos + localXSin;
_offset[URX] = localX2Cos - localY2Sin; // _offset[URX] = localX2Cos - localY2Sin;
_offset[URY] = localY2Cos + localX2Sin; // _offset[URY] = localY2Cos + localX2Sin;
_offset[BRX] = localX2Cos - localYSin; // _offset[BRX] = localX2Cos - localYSin;
_offset[BRY] = localYCos + localX2Sin; // _offset[BRY] = localYCos + localX2Sin;
} // }
//
void setUVs(float u, float v, float u2, float v2, bool rotate) // void setUVs(float u, float v, float u2, float v2, bool rotate)
{ // {
if (rotate) // if (rotate)
{ // {
_uvs[URX] = u; // _uvs[URX] = u;
_uvs[URY] = v2; // _uvs[URY] = v2;
_uvs[BRX] = u; // _uvs[BRX] = u;
_uvs[BRY] = v; // _uvs[BRY] = v;
_uvs[BLX] = u2; // _uvs[BLX] = u2;
_uvs[BLY] = v; // _uvs[BLY] = v;
_uvs[ULX] = u2; // _uvs[ULX] = u2;
_uvs[ULY] = v2; // _uvs[ULY] = v2;
} // }
else // else
{ // {
_uvs[ULX] = u; // _uvs[ULX] = u;
_uvs[ULY] = v2; // _uvs[ULY] = v2;
_uvs[URX] = u; // _uvs[URX] = u;
_uvs[URY] = v; // _uvs[URY] = v;
_uvs[BRX] = u2; // _uvs[BRX] = u2;
_uvs[BRY] = v; // _uvs[BRY] = v;
_uvs[BLX] = u2; // _uvs[BLX] = u2;
_uvs[BLY] = v2; // _uvs[BLY] = v2;
} // }
} // }
//
/// Transforms the attachment's four vertices to world coordinates. // /// Transforms the attachment's four vertices to world coordinates.
/// @param bone The parent bone. // /// @param bone The parent bone.
/// @param worldVertices The output world vertices. Must have a length greater than or equal to offset + 8. // /// @param worldVertices The output world vertices. Must have a length greater than or equal to offset + 8.
/// @param offset The worldVertices index to begin writing values. // /// @param offset The worldVertices index to begin writing values.
/// @param stride The number of worldVertices entries between the value pairs written. // /// @param stride The number of worldVertices entries between the value pairs written.
void computeWorldVertices(Bone& bone, Vector<float> worldVertices, int offset, int stride = 2) // void computeWorldVertices(Bone& bone, Vector<float> worldVertices, int offset, int stride = 2)
{ // {
assert(worldVertices.size() >= 8); // assert(worldVertices.size() >= 8);
//
float[] vertexOffset = _offset; // float[] vertexOffset = _offset;
float bwx = bone.worldX, bwy = bone.worldY; // float bwx = bone.worldX, bwy = bone.worldY;
float a = bone.a, b = bone.b, c = bone.c, d = bone.d; // float a = bone.a, b = bone.b, c = bone.c, d = bone.d;
float offsetX, offsetY; // float offsetX, offsetY;
//
offsetX = vertexOffset[BRX]; // 0 // offsetX = vertexOffset[BRX]; // 0
offsetY = vertexOffset[BRY]; // 1 // offsetY = vertexOffset[BRY]; // 1
worldVertices[offset] = offsetX * a + offsetY * b + bwx; // bl // worldVertices[offset] = offsetX * a + offsetY * b + bwx; // bl
worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy; // worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy;
offset += stride; // offset += stride;
//
offsetX = vertexOffset[BLX]; // 2 // offsetX = vertexOffset[BLX]; // 2
offsetY = vertexOffset[BLY]; // 3 // offsetY = vertexOffset[BLY]; // 3
worldVertices[offset] = offsetX * a + offsetY * b + bwx; // ul // worldVertices[offset] = offsetX * a + offsetY * b + bwx; // ul
worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy; // worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy;
offset += stride; // offset += stride;
//
offsetX = vertexOffset[ULX]; // 4 // offsetX = vertexOffset[ULX]; // 4
offsetY = vertexOffset[ULY]; // 5 // offsetY = vertexOffset[ULY]; // 5
worldVertices[offset] = offsetX * a + offsetY * b + bwx; // ur // worldVertices[offset] = offsetX * a + offsetY * b + bwx; // ur
worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy; // worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy;
offset += stride; // offset += stride;
//
offsetX = vertexOffset[URX]; // 6 // offsetX = vertexOffset[URX]; // 6
offsetY = vertexOffset[URY]; // 7 // offsetY = vertexOffset[URY]; // 7
worldVertices[offset] = offsetX * a + offsetY * b + bwx; // br // worldVertices[offset] = offsetX * a + offsetY * b + bwx; // br
worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy; // worldVertices[offset + 1] = offsetX * c + offsetY * d + bwy;
} // }
//
private: // private:
float _x, _y, _rotation, _scaleX = 1, _scaleY = 1, _width, _height; // float _x, _y, _rotation, _scaleX = 1, _scaleY = 1, _width, _height;
float _regionOffsetX, _regionOffsetY, _regionWidth, _regionHeight, _regionOriginalWidth, _regionOriginalHeight; // float _regionOffsetX, _regionOffsetY, _regionWidth, _regionHeight, _regionOriginalWidth, _regionOriginalHeight;
float[] _offset = new float[8]; // float[] _offset = new float[8];
float[] _uvs = new float[8]; // float[] _uvs = new float[8];
float r = 1, g = 1, b = 1, a = 1; // float r = 1, g = 1, b = 1, a = 1;
} };
} }
#endif /* Spine_RegionAttachment_h */ #endif /* Spine_RegionAttachment_h */

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

@ -480,7 +480,7 @@ namespace Spine
{ {
outVertexBuffer.reserve(8); outVertexBuffer.reserve(8);
} }
regionAttachment->computeWorldVertices(slot->getBone(), outVertexBuffer, 0); // regionAttachment->computeWorldVertices(slot->getBone(), outVertexBuffer, 0);
} }
else if (attachment != NULL && attachment->getRTTI().derivesFrom(MeshAttachment::rtti)) else if (attachment != NULL && attachment->getRTTI().derivesFrom(MeshAttachment::rtti))
{ {
@ -492,7 +492,7 @@ namespace Spine
outVertexBuffer.reserve(verticesLength); outVertexBuffer.reserve(verticesLength);
} }
mesh->computeWorldVertices(slot, 0, verticesLength, outVertexBuffer, 0); // mesh->computeWorldVertices(slot, 0, verticesLength, outVertexBuffer, 0);
} }
for (int ii = 0; ii < verticesLength; ii += 2) for (int ii = 0; ii < verticesLength; ii += 2)