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

Simplified SkeletonBounds AABB computation.

Browse Source
This commit is contained in:
NathanSweet 2013-09-24 15:37:46 +02:00
parent dda304faa0
commit 8cec4eb354
5 changed files with 50 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
spine-csharp/src/SkeletonBounds.cs
View File

@ -36,78 +36,24 @@ using System.Collections.Generic;
namespace Spine {
public class SkeletonBounds {
private bool aabb;
private List<Polygon> polygonPool = new List<Polygon>();
private float minX, minY, maxX, maxY;
public List<BoundingBoxAttachment> BoundingBoxes { get; private set; }
public List<Polygon> Polygons { get; private set; }
private float minX;
public float MinX {
get {
if (!aabb) aabbCompute();
return minX;
}
private set {
minX = value;
}
}
private float maxX;
public float MaxX {
get {
if (!aabb) aabbCompute();
return maxX;
}
private set {
maxX = value;
}
}
private float minY;
public float MinY {
get {
if (!aabb) aabbCompute();
return minY;
}
private set {
minY = value;
}
}
private float maxY;
public float MaxY {
get {
if (!aabb) aabbCompute();
return maxY;
}
private set {
maxY = value;
}
}
public float Width {
get {
if (!aabb) aabbCompute();
return maxX - minX;
}
}
public float Height {
get {
if (!aabb) aabbCompute();
return maxY - minY;
}
}
public float MinX { get { return minX; } set { minX = value; } }
public float MinY { get { return minY; } set { minY = value; } }
public float MaxX { get { return maxX; } set { maxX = value; } }
public float MaxY { get { return maxY; } set { maxY = value; } }
public float Width { get { return maxX - minX; } }
public float Height { get { return maxY - minY; } }
public SkeletonBounds () {
BoundingBoxes = new List<BoundingBoxAttachment>();
Polygons = new List<Polygon>();
}
public void Update (Skeleton skeleton) {
aabb = false;
public void Update (Skeleton skeleton, bool updateAabb) {
List<BoundingBoxAttachment> boundingBoxes = BoundingBoxes;
List<Polygon> polygons = Polygons;
List<Slot> slots = skeleton.slots;
@ -139,6 +85,8 @@ namespace Spine {
if (polygon.Vertices.Length < count) polygon.Vertices = new float[count];
boundingBox.ComputeWorldVertices(x, y, slot.bone, polygon.Vertices);
}
if (updateAabb) aabbCompute();
}
private void aabbCompute () {
@ -160,19 +108,16 @@ namespace Spine {
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
aabb = true;
}
/** Returns true if the axis aligned bounding box contains the point. */
public bool AabbContainsPoint (float x, float y) {
if (!aabb) aabbCompute();
return x >= minX && x <= maxX && y >= minY && y <= maxY;
}
/** Returns true if the axis aligned bounding box intersects the line segment. */
public bool AabbIntersectsSegment (float x1, float y1, float x2, float y2) {
if (!aabb) aabbCompute();
float minX = this.minX;
float minY = this.minY;
float maxX = this.maxX;
@ -193,14 +138,11 @@ namespace Spine {
/** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
public bool AabbIntersectsSkeleton (SkeletonBounds bounds) {
if (!aabb) aabbCompute();
if (!bounds.aabb) bounds.aabbCompute();
return minX < bounds.maxX && maxX > bounds.minX && minY < bounds.maxY && maxY > bounds.minY;
}
/** Returns true if the bounding box attachment contains the point. */
public bool ContainsPoint (int index, float x, float y) {
Polygon polygon = Polygons[index];
/** Returns true if the polygon contains the point. */
public bool ContainsPoint (Polygon polygon, float x, float y) {
float[] vertices = polygon.Vertices;
int nn = polygon.Count;
@ -209,7 +151,7 @@ namespace Spine {
for (int ii = 0; ii < nn; ii += 2) {
float vertexY = vertices[ii + 1];
float prevY = vertices[prevIndex + 1];
if (vertexY < y && prevY >= y || prevY < y && vertexY >= y) {
if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
float vertexX = vertices[ii];
if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
}
@ -219,40 +161,25 @@ namespace Spine {
}
/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
* efficient to only call this method if {@link #aabbContainsPoint(float, float)} return true. */
* efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
public BoundingBoxAttachment ContainsPoint (float x, float y) {
List<BoundingBoxAttachment> boundingBoxes = BoundingBoxes;
for (int i = 0, n = boundingBoxes.Count; i < n; i++)
if (ContainsPoint(i, x, y)) return boundingBoxes[i];
List<Polygon> polygons = Polygons;
for (int i = 0, n = polygons.Count; i < n; i++)
if (ContainsPoint(polygons[i], x, y)) return BoundingBoxes[i];
return null;
}
/** Returns true if the bounding box attachment contains the point. The bounding box must be in the SkeletonBounds. */
public bool containsPoint (BoundingBoxAttachment attachment, float x, float y) {
int index = BoundingBoxes.IndexOf(attachment);
return index == -1 ? false : ContainsPoint(index, x, y);
}
/** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
* more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} return true. */
* more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns true. */
public BoundingBoxAttachment IntersectsSegment (float x1, float y1, float x2, float y2) {
List<BoundingBoxAttachment> boundingBoxes = BoundingBoxes;
for (int i = 0, n = boundingBoxes.Count; i < n; i++) {
BoundingBoxAttachment attachment = boundingBoxes[i];
if (IntersectsSegment(attachment, x1, y1, x2, y2)) return attachment;
}
List<Polygon> polygons = Polygons;
for (int i = 0, n = polygons.Count; i < n; i++)
if (IntersectsSegment(polygons[i], x1, y1, x2, y2)) return BoundingBoxes[i];
return null;
}
/** Returns true if the bounding box attachment contains the line segment. */
public bool IntersectsSegment (BoundingBoxAttachment attachment, float x1, float y1, float x2, float y2) {
int index = BoundingBoxes.IndexOf(attachment);
return index == -1 ? false : IntersectsSegment(index, x1, y1, x2, y2);
}
/** Returns true if the bounding box attachment contains the line segment. */
public bool IntersectsSegment (int index, float x1, float y1, float x2, float y2) {
Polygon polygon = Polygons[index];
/** Returns true if the polygon contains the line segment. */
public bool IntersectsSegment (Polygon polygon, float x1, float y1, float x2, float y2) {
float[] vertices = polygon.Vertices;
int nn = polygon.Count;
@ -274,6 +201,11 @@ namespace Spine {
}
return false;
}
public Polygon getPolygon (BoundingBoxAttachment attachment) {
int index = BoundingBoxes.IndexOf(attachment);
return index == -1 ? null : Polygons[index];
}
}
}

66
spine-libgdx/src/com/esotericsoftware/spine/SkeletonBounds.java
View File

@ -40,14 +40,11 @@ import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.FloatArray;
public class SkeletonBounds {
private boolean aabb;
private float minX, minY, maxX, maxY;
private Array<BoundingBoxAttachment> boundingBoxes = new Array();
private Array<FloatArray> polygons = new Array();
public void update (Skeleton skeleton) {
aabb = false;
public void update (Skeleton skeleton, boolean updateAabb) {
Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
Array<FloatArray> polygons = this.polygons;
Array<Slot> slots = skeleton.slots;
@ -75,6 +72,8 @@ public class SkeletonBounds {
boundingBox.computeWorldVertices(x, y, slot.bone, polygon.items);
}
}
if (updateAabb) aabbCompute();
}
private void aabbCompute () {
@ -96,18 +95,15 @@ public class SkeletonBounds {
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
aabb = true;
}
/** Returns true if the axis aligned bounding box contains the point. */
public boolean aabbContainsPoint (float x, float y) {
if (!aabb) aabbCompute();
return x >= minX && x <= maxX && y >= minY && y <= maxY;
}
/** Returns true if the axis aligned bounding box intersects the line segment. */
public boolean aabbIntersectsSegment (float x1, float y1, float x2, float y2) {
if (!aabb) aabbCompute();
float minX = this.minX;
float minY = this.minY;
float maxX = this.maxX;
@ -128,14 +124,20 @@ public class SkeletonBounds {
/** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
public boolean aabbIntersectsSkeleton (SkeletonBounds bounds) {
if (!aabb) aabbCompute();
if (!bounds.aabb) bounds.aabbCompute();
return minX < bounds.maxX && maxX > bounds.minX && minY < bounds.maxY && maxY > bounds.minY;
}
/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
* efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
public BoundingBoxAttachment containsPoint (float x, float y) {
Array<FloatArray> polygons = this.polygons;
for (int i = 0, n = polygons.size; i < n; i++)
if (containsPoint(polygons.get(i), x, y)) return boundingBoxes.get(i);
return null;
}
/** Returns true if the bounding box attachment contains the point. */
public boolean containsPoint (int index, float x, float y) {
FloatArray polygon = polygons.get(index);
public boolean containsPoint (FloatArray polygon, float x, float y) {
float[] vertices = polygon.items;
int nn = polygon.size;
@ -144,7 +146,7 @@ public class SkeletonBounds {
for (int ii = 0; ii < nn; ii += 2) {
float vertexY = vertices[ii + 1];
float prevY = vertices[prevIndex + 1];
if (vertexY < y && prevY >= y || prevY < y && vertexY >= y) {
if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
float vertexX = vertices[ii];
if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
}
@ -153,41 +155,17 @@ public class SkeletonBounds {
return inside;
}
/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
* efficient to only call this method if {@link #aabbContainsPoint(float, float)} return true. */
public BoundingBoxAttachment containsPoint (float x, float y) {
Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
for (int i = 0, n = boundingBoxes.size; i < n; i++)
if (containsPoint(i, x, y)) return boundingBoxes.get(i);
return null;
}
/** Returns true if the bounding box attachment contains the point. The bounding box must be in the SkeletonBounds. */
public boolean containsPoint (BoundingBoxAttachment attachment, float x, float y) {
int index = boundingBoxes.indexOf(attachment, true);
return index == -1 ? false : containsPoint(index, x, y);
}
/** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
* more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} return true. */
* more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns true. */
public BoundingBoxAttachment intersectsSegment (float x1, float y1, float x2, float y2) {
Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
for (int i = 0, n = boundingBoxes.size; i < n; i++) {
BoundingBoxAttachment attachment = boundingBoxes.get(i);
if (intersectsSegment(attachment, x1, y1, x2, y2)) return attachment;
}
Array<FloatArray> polygons = this.polygons;
for (int i = 0, n = polygons.size; i < n; i++)
if (intersectsSegment(polygons.get(i), x1, y1, x2, y2)) return boundingBoxes.get(i);
return null;
}
/** Returns true if the bounding box attachment contains the line segment. */
public boolean intersectsSegment (BoundingBoxAttachment attachment, float x1, float y1, float x2, float y2) {
int index = boundingBoxes.indexOf(attachment, true);
return index == -1 ? false : intersectsSegment(index, x1, y1, x2, y2);
}
/** Returns true if the bounding box attachment contains the line segment. */
public boolean intersectsSegment (int index, float x1, float y1, float x2, float y2) {
FloatArray polygon = polygons.get(index);
public boolean intersectsSegment (FloatArray polygon, float x1, float y1, float x2, float y2) {
float[] vertices = polygon.items;
int nn = polygon.size;
@ -211,32 +189,26 @@ public class SkeletonBounds {
}
public float getMinX () {
if (!aabb) aabbCompute();
return minX;
}
public float getMinY () {
if (!aabb) aabbCompute();
return minY;
}
public float getMaxX () {
if (!aabb) aabbCompute();
return maxX;
}
public float getMaxY () {
if (!aabb) aabbCompute();
return maxY;
}
public float getWidth () {
if (!aabb) aabbCompute();
return maxX - minX;
}
public float getHeight () {
if (!aabb) aabbCompute();
return maxY - minY;
}

2
spine-libgdx/src/com/esotericsoftware/spine/SkeletonRendererDebug.java
View File

@ -101,7 +101,7 @@ public class SkeletonRendererDebug {
if (drawBoundingBoxes) {
SkeletonBounds bounds = this.bounds;
bounds.update(skeleton);
bounds.update(skeleton, true);
renderer.setColor(aabbColor);
renderer.rect(bounds.getMinX(), bounds.getMinY(), bounds.getWidth(), bounds.getHeight());
renderer.setColor(boundingBoxColor);

2
spine-xna/example/src/ExampleGame.cs
View File

@ -133,7 +133,7 @@ namespace Spine {
skeletonRenderer.Draw(skeleton);
skeletonRenderer.End();
bounds.Update(skeleton);
bounds.Update(skeleton, true);
MouseState mouse = Mouse.GetState();
headSlot.G = 1;
headSlot.B = 1;

2
spine-xna/src/SkeletonRenderer.cs
View File

@ -116,7 +116,7 @@ namespace Spine {
item.vertexTR.Color.A = a;
float[] vertices = this.vertices;
regionAttachment.ComputeVertices(x, y, slot.Bone, vertices);
regionAttachment.ComputeWorldVertices(x, y, slot.Bone, vertices);
item.vertexTL.Position.X = vertices[RegionAttachment.X1];
item.vertexTL.Position.Y = vertices[RegionAttachment.Y1];
item.vertexTL.Position.Z = 0;