spine-sys 0.1.1

/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated January 1, 2020. Replaces all prior versions.
 *
 * Copyright (c) 2013-2020, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software
 * or otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#include <spine/Bone.h>
#include <spine/extension.h>
#include <stdio.h>
static int yDown;

void spBone_setYDown (int value) {
	yDown = value;
}

int spBone_isYDown () {
	return yDown;
}

spBone* spBone_create (spBoneData* data, spSkeleton* skeleton, spBone* parent) {
	spBone* self = NEW(spBone);
	CONST_CAST(spBoneData*, self->data) = data;
	CONST_CAST(spSkeleton*, self->skeleton) = skeleton;
	CONST_CAST(spBone*, self->parent) = parent;
	CONST_CAST(float, self->a) = 1.0f;
	CONST_CAST(float, self->d) = 1.0f;
	spBone_setToSetupPose(self);
	return self;
}

void spBone_dispose (spBone* self) {
	FREE(self->children);
	FREE(self);
}

void spBone_updateWorldTransform (spBone* self) {
	spBone_updateWorldTransformWith(self, self->x, self->y, self->rotation, self->scaleX, self->scaleY, self->shearX, self->shearY);
}

void spBone_updateWorldTransformWith (spBone* self, float x, float y, float rotation, float scaleX, float scaleY, float shearX, float shearY) {
	float cosine, sine;
	float pa, pb, pc, pd;
	spBone* parent = self->parent;
	float sx = self->skeleton->scaleX;
	float sy = self->skeleton->scaleY * (spBone_isYDown() ? -1 : 1);

	self->ax = x;
	self->ay = y;
	self->arotation = rotation;
	self->ascaleX = scaleX;
	self->ascaleY = scaleY;
	self->ashearX = shearX;
	self->ashearY = shearY;
	self->appliedValid = 1;

	if (!parent) { /* Root bone. */
		float rotationY = rotation + 90 + shearY;
		CONST_CAST(float, self->a) = COS_DEG(rotation + shearX) * scaleX * sx;
		CONST_CAST(float, self->b) = COS_DEG(rotationY) * scaleY * sx;
		CONST_CAST(float, self->c) = SIN_DEG(rotation + shearX) * scaleX * sy;
		CONST_CAST(float, self->d) = SIN_DEG(rotationY) * scaleY * sy;
		CONST_CAST(float, self->worldX) = x * sx + self->skeleton->x;
		CONST_CAST(float, self->worldY) = y * sy + self->skeleton->y;
		return;
	}

	pa = parent->a;
	pb = parent->b;
	pc = parent->c;
	pd = parent->d;

	CONST_CAST(float, self->worldX) = pa * x + pb * y + parent->worldX;
	CONST_CAST(float, self->worldY) = pc * x + pd * y + parent->worldY;

	switch (self->data->transformMode) {
	case SP_TRANSFORMMODE_NORMAL: {
		float rotationY = rotation + 90 + shearY;
		float la = COS_DEG(rotation + shearX) * scaleX;
		float lb = COS_DEG(rotationY) * scaleY;
		float lc = SIN_DEG(rotation + shearX) * scaleX;
		float ld = SIN_DEG(rotationY) * scaleY;
		CONST_CAST(float, self->a) = pa * la + pb * lc;
		CONST_CAST(float, self->b) = pa * lb + pb * ld;
		CONST_CAST(float, self->c) = pc * la + pd * lc;
		CONST_CAST(float, self->d) = pc * lb + pd * ld;
		return;
	}
	case SP_TRANSFORMMODE_ONLYTRANSLATION: {
		float rotationY = rotation + 90 + shearY;
		CONST_CAST(float, self->a) = COS_DEG(rotation + shearX) * scaleX;
		CONST_CAST(float, self->b) = COS_DEG(rotationY) * scaleY;
		CONST_CAST(float, self->c) = SIN_DEG(rotation + shearX) * scaleX;
		CONST_CAST(float, self->d) = SIN_DEG(rotationY) * scaleY;
		break;
	}
	case SP_TRANSFORMMODE_NOROTATIONORREFLECTION: {
		float s = pa * pa + pc * pc;
		float prx, rx, ry, la, lb, lc, ld;
		if (s > 0.0001f) {
			s = ABS(pa * pd - pb * pc) / s;
			pb = pc * s;
			pd = pa * s;
			prx = ATAN2(pc, pa) * RAD_DEG;
		} else {
			pa = 0;
			pc = 0;
			prx = 90 - ATAN2(pd, pb) * RAD_DEG;
		}
		rx = rotation + shearX - prx;
		ry = rotation + shearY - prx + 90;
		la = COS_DEG(rx) * scaleX;
		lb = COS_DEG(ry) * scaleY;
		lc = SIN_DEG(rx) * scaleX;
		ld = SIN_DEG(ry) * scaleY;
		CONST_CAST(float, self->a) = pa * la - pb * lc;
		CONST_CAST(float, self->b) = pa * lb - pb * ld;
		CONST_CAST(float, self->c) = pc * la + pd * lc;
		CONST_CAST(float, self->d) = pc * lb + pd * ld;
		break;
	}
	case SP_TRANSFORMMODE_NOSCALE:
	case SP_TRANSFORMMODE_NOSCALEORREFLECTION: {
		float za, zc, s;
		float r, zb, zd, la, lb, lc, ld;
		cosine = COS_DEG(rotation); sine = SIN_DEG(rotation);
		za = (pa * cosine + pb * sine) / sx;
		zc = (pc * cosine + pd * sine) / sy;
		s = SQRT(za * za + zc * zc);
		if (s > 0.00001f) s = 1 / s;
		za *= s;
		zc *= s;
		s = SQRT(za * za + zc * zc);
		if (self->data->transformMode == SP_TRANSFORMMODE_NOSCALE && (pa * pd - pb * pc < 0) != (sx < 0 != sy < 0))
			s = -s;
		r = PI / 2 + ATAN2(zc, za);
		zb = COS(r) * s;
		zd = SIN(r) * s;
		la = COS_DEG(shearX) * scaleX;
		lb = COS_DEG(90 + shearY) * scaleY;
		lc = SIN_DEG(shearX) * scaleX;
		ld = SIN_DEG(90 + shearY) * scaleY;
		CONST_CAST(float, self->a) = za * la + zb * lc;
		CONST_CAST(float, self->b) = za * lb + zb * ld;
		CONST_CAST(float, self->c) = zc * la + zd * lc;
		CONST_CAST(float, self->d) = zc * lb + zd * ld;
		break;
	}
	}

	CONST_CAST(float, self->a) *= sx;
	CONST_CAST(float, self->b) *= sx;
	CONST_CAST(float, self->c) *= sy;
	CONST_CAST(float, self->d) *= sy;
}

void spBone_setToSetupPose (spBone* self) {
	self->x = self->data->x;
	self->y = self->data->y;
	self->rotation = self->data->rotation;
	self->scaleX = self->data->scaleX;
	self->scaleY = self->data->scaleY;
	self->shearX = self->data->shearX;
	self->shearY = self->data->shearY;
}

float spBone_getWorldRotationX (spBone* self) {
	return ATAN2(self->c, self->a) * RAD_DEG;
}

float spBone_getWorldRotationY (spBone* self) {
	return ATAN2(self->d, self->b) * RAD_DEG;
}

float spBone_getWorldScaleX (spBone* self) {
	return SQRT(self->a * self->a + self->c * self->c);
}

float spBone_getWorldScaleY (spBone* self) {
	return SQRT(self->b * self->b + self->d * self->d);
}

/** Computes the individual applied transform values from the world transform. This can be useful to perform processing using
 * the applied transform after the world transform has been modified directly (eg, by a constraint).
 * <p>
 * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. */
void spBone_updateAppliedTransform (spBone* self) {
	spBone* parent = self->parent;
	self->appliedValid = 1;
	if (!parent) {
		self->ax = self->worldX;
		self->ay = self->worldY;
		self->arotation = ATAN2(self->c, self->a) * RAD_DEG;
		self->ascaleX = SQRT(self->a * self->a + self->c * self->c);
		self->ascaleY = SQRT(self->b * self->b + self->d * self->d);
		self->ashearX = 0;
		self->ashearY = ATAN2(self->a * self->b + self->c * self->d, self->a * self->d - self->b * self->c) * RAD_DEG;
	} else {
		float pa = parent->a, pb = parent->b, pc = parent->c, pd = parent->d;
		float pid = 1 / (pa * pd - pb * pc);
		float dx = self->worldX - parent->worldX, dy = self->worldY - parent->worldY;
		float ia = pid * pd;
		float id = pid * pa;
		float ib = pid * pb;
		float ic = pid * pc;
		float ra = ia * self->a - ib * self->c;
		float rb = ia * self->b - ib * self->d;
		float rc = id * self->c - ic * self->a;
		float rd = id * self->d - ic * self->b;
		self->ax = (dx * pd * pid - dy * pb * pid);
		self->ay = (dy * pa * pid - dx * pc * pid);
		self->ashearX = 0;
		self->ascaleX = SQRT(ra * ra + rc * rc);
		if (self->ascaleX > 0.0001f) {
			float det = ra * rd - rb * rc;
			self->ascaleY = det / self->ascaleX;
			self->ashearY = ATAN2(ra * rb + rc * rd, det) * RAD_DEG;
			self->arotation = ATAN2(rc, ra) * RAD_DEG;
		} else {
			self->ascaleX = 0;
			self->ascaleY = SQRT(rb * rb + rd * rd);
			self->ashearY = 0;
			self->arotation = 90 - ATAN2(rd, rb) * RAD_DEG;
		}
	}
}

void spBone_worldToLocal (spBone* self, float worldX, float worldY, float* localX, float* localY) {
	float a = self->a, b = self->b, c = self->c, d = self->d;
	float invDet = 1 / (a * d - b * c);
	float x = worldX - self->worldX, y = worldY - self->worldY;
	*localX = (x * d * invDet - y * b * invDet);
	*localY = (y * a * invDet - x * c * invDet);
}

void spBone_localToWorld (spBone* self, float localX, float localY, float* worldX, float* worldY) {
	float x = localX, y = localY;
	*worldX = x * self->a + y * self->b + self->worldX;
	*worldY = x * self->c + y * self->d + self->worldY;
}

float spBone_worldToLocalRotation (spBone* self, float worldRotation) {
	float sine, cosine;
	sine = SIN_DEG(worldRotation);
	cosine = COS_DEG(worldRotation);
	return ATAN2(self->a * sine - self->c * cosine, self->d * cosine - self->b * sine) * RAD_DEG + self->rotation - self->shearX;
}

float spBone_localToWorldRotation (spBone* self, float localRotation) {
	float sine, cosine;
	localRotation -= self->rotation - self->shearX;
	sine = SIN_DEG(localRotation);
	cosine = COS_DEG(localRotation);
	return ATAN2(cosine * self->c + sine * self->d, cosine * self->a + sine * self->b) * RAD_DEG;
}

void spBone_rotateWorld (spBone* self, float degrees) {
	float a = self->a, b = self->b, c = self->c, d = self->d;
	float cosine = COS_DEG(degrees), sine = SIN_DEG(degrees);
	CONST_CAST(float, self->a) = cosine * a - sine * c;
	CONST_CAST(float, self->b) = cosine * b - sine * d;
	CONST_CAST(float, self->c) = sine * a + cosine * c;
	CONST_CAST(float, self->d) = sine * b + cosine * d;
	CONST_CAST(int, self->appliedValid) = 0;
}