SkeletonRenderer.m

/******************************************************************************
 * 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.
 *****************************************************************************/

#import <spine/SkeletonRenderer.h>
#import <spine/spine-cocos2d-objc.h>
#import <spine/extension.h>
#import <spine/GLUtils.h>
#import "CCDrawNode.h"

static unsigned short quadTriangles[6] = {0, 1, 2, 2, 3, 0};
static spTwoColorBatcher* batcher = 0;
static spMesh* mesh = 0;
static bool handlerQueued = false;

@interface SkeletonRenderer (Private)
- (void) initialize:(spSkeletonData*)skeletonData ownsSkeletonData:(bool)ownsSkeletonData;
@end

@implementation SkeletonRenderer

@synthesize skeleton = _skeleton;
@synthesize rootBone = _rootBone;
@synthesize twoColorTint = _twoColorTint;
@synthesize debugSlots = _debugSlots;
@synthesize debugBones = _debugBones;
@synthesize effect = _effect;

+ (id) skeletonWithData:(spSkeletonData*)skeletonData ownsSkeletonData:(bool)ownsSkeletonData {
	return [[[self alloc] initWithData:skeletonData ownsSkeletonData:ownsSkeletonData] autorelease];
}

+ (id) skeletonWithFile:(NSString*)skeletonDataFile atlas:(spAtlas*)atlas scale:(float)scale {
	return [[[self alloc] initWithFile:skeletonDataFile atlas:atlas scale:scale] autorelease];
}

+ (id) skeletonWithFile:(NSString*)skeletonDataFile atlasFile:(NSString*)atlasFile scale:(float)scale {
	return [[[self alloc] initWithFile:skeletonDataFile atlasFile:atlasFile scale:scale] autorelease];
}

- (void) initialize:(spSkeletonData*)skeletonData ownsSkeletonData:(bool)ownsSkeletonData {
	if (!batcher) {
		batcher = spTwoColorBatcher_create();
		mesh = spMesh_create(64000, 32000);
	}

	_ownsSkeletonData = ownsSkeletonData;

	_worldVertices = MALLOC(float, 1000); // Max number of vertices per mesh.

	_skeleton = spSkeleton_create(skeletonData);
	_rootBone = _skeleton->bones[0];

	_blendFunc.src = GL_ONE;
	_blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA;
	_drawNode = [[CCDrawNode alloc] init];
	[_drawNode setBlendMode: [CCBlendMode premultipliedAlphaMode]];
	[self addChild:_drawNode];

	[self setShader:[CCShader positionTextureColorShader]];

	_premultipliedAlpha = true;
	screenMode = [CCBlendMode blendModeWithOptions:@{
		CCBlendFuncSrcColor: @(GL_ONE),
		CCBlendFuncDstColor: @(GL_ONE_MINUS_SRC_COLOR)}
	];

	_clipper = spSkeletonClipping_create();
	_effect = 0;
}

- (id) initWithData:(spSkeletonData*)skeletonData ownsSkeletonData:(bool)ownsSkeletonData {
	NSAssert(skeletonData, @"skeletonData cannot be null.");

	self = [super init];
	if (!self) return nil;

	[self initialize:skeletonData ownsSkeletonData:ownsSkeletonData];

	return self;
}

- (id) initWithFile:(NSString*)skeletonDataFile atlas:(spAtlas*)atlas scale:(float)scale {
	self = [super init];
	if (!self) return nil;

	spSkeletonJson* json = spSkeletonJson_create(atlas);
	json->scale = scale;
	spSkeletonData* skeletonData = nil;

	@synchronized(self.class) {
		spSkeletonJson_readSkeletonDataFile(json, [skeletonDataFile UTF8String]);
	}
	NSAssert(skeletonData, ([NSString stringWithFormat:@"Error reading skeleton data file: %@\nError: %s", skeletonDataFile, json->error]));
	spSkeletonJson_dispose(json);
	if (!skeletonData) return 0;

	[self initialize:skeletonData ownsSkeletonData:YES];

	return self;
}

- (id) initWithFile:(NSString*)skeletonDataFile atlasFile:(NSString*)atlasFile scale:(float)scale {
	self = [super init];
	if (!self) return nil;

	@synchronized(self.class) {
		_atlas = spAtlas_createFromFile([atlasFile UTF8String], 0);
	}
	NSAssert(_atlas, ([NSString stringWithFormat:@"Error reading atlas file: %@", atlasFile]));
	if (!_atlas) return 0;

	spSkeletonJson* json = spSkeletonJson_create(_atlas);
	json->scale = scale;
	spSkeletonData* skeletonData;

	@synchronized(self.class) {
		skeletonData = spSkeletonJson_readSkeletonDataFile(json, [skeletonDataFile UTF8String]);
	}
	NSAssert(skeletonData, ([NSString stringWithFormat:@"Error reading skeleton data file: %@\nError: %s", skeletonDataFile, json->error]));
	spSkeletonJson_dispose(json);
	if (!skeletonData) return 0;

	[self initialize:skeletonData ownsSkeletonData:YES];

	return self;
}

- (void) dealloc {
	if (_ownsSkeletonData) spSkeletonData_dispose(_skeleton->data);
	if (_atlas) spAtlas_dispose(_atlas);
	spSkeleton_dispose(_skeleton);
	FREE(_worldVertices);
	spSkeletonClipping_dispose(_clipper);
	[super dealloc];
}

-(void)draw:(CCRenderer *)renderer transform:(const GLKMatrix4 *)transform {
	// FIXME we need to clear the mesh parts at the end of the frame
	// there's no general event mechanism to get notified on end frame
	// that doesn't need to be re-added every frame. This is a poor man
	// notification system that may break if the block is called on a
	// separate thread.
	if (!handlerQueued) {
		[[CCDirector sharedDirector] addFrameCompletionHandler: ^{
			spMesh_clearParts(mesh);
			handlerQueued = false;
		}];
		handlerQueued = true;
	}

	if (_effect) _effect->begin(_effect, _skeleton);

	CCColor* nodeColor = self.color;
	_skeleton->color.r = nodeColor.red;
	_skeleton->color.g = nodeColor.green;
	_skeleton->color.b = nodeColor.blue;
	_skeleton->color.a = self.displayedOpacity;

	int blendMode = -1;
	uint32_t srcBlend = GL_SRC_ALPHA;
	uint32_t dstBlend = GL_ONE_MINUS_SRC_ALPHA;
	float* uvs = 0;
	float* vertices = _worldVertices;
	int verticesCount = 0;
	unsigned short* triangles = 0;
	int trianglesCount = 0;
	float r = 0, g = 0, b = 0, a = 0;
	float dr = 0, dg = 0, db = 0, da = _premultipliedAlpha ? 1 : 0;
	for (int i = 0, n = _skeleton->slotsCount; i < n; i++) {
		spSlot* slot = _skeleton->drawOrder[i];
		if (!slot->attachment) continue;
		if (!slot->bone->active) continue;
		CCTexture *texture = 0;
		switch (slot->attachment->type) {
		case SP_ATTACHMENT_REGION: {
			spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment;
			spRegionAttachment_computeWorldVertices(attachment, slot->bone, vertices, 0, 2);
			texture = [self getTextureForRegion:attachment];
			uvs = attachment->uvs;
			verticesCount = 8;
			triangles = quadTriangles;
			trianglesCount = 6;
			r = attachment->color.r;
			g = attachment->color.g;
			b = attachment->color.b;
			a = attachment->color.a;
			break;
		}
		case SP_ATTACHMENT_MESH: {
			spMeshAttachment* attachment = (spMeshAttachment*)slot->attachment;
			spVertexAttachment_computeWorldVertices(SUPER(attachment), slot, 0, attachment->super.worldVerticesLength, vertices, 0, 2);
			texture = [self getTextureForMesh:attachment];
			uvs = attachment->uvs;
			verticesCount = attachment->super.worldVerticesLength;
			triangles = attachment->triangles;
			trianglesCount = attachment->trianglesCount;
			r = attachment->color.r;
			g = attachment->color.g;
			b = attachment->color.b;
			a = attachment->color.a;
			break;
		}
		case SP_ATTACHMENT_CLIPPING: {
			spClippingAttachment* clip = (spClippingAttachment*)slot->attachment;
			spSkeletonClipping_clipStart(_clipper, slot, clip);
		}
		default: ;
		}

		if (texture) {
			if (slot->data->blendMode != blendMode) {
				blendMode = slot->data->blendMode;
				switch (slot->data->blendMode) {
				case SP_BLEND_MODE_ADDITIVE:
					[self setBlendMode:[CCBlendMode addMode]];
					srcBlend = !_premultipliedAlpha ? GL_SRC_ALPHA : GL_ONE;
					dstBlend = GL_ONE;
					break;
				case SP_BLEND_MODE_MULTIPLY:
					[self setBlendMode:[CCBlendMode multiplyMode]];
					srcBlend = GL_DST_COLOR;
					dstBlend = GL_ONE_MINUS_SRC_ALPHA;
					break;
				case SP_BLEND_MODE_SCREEN:
					[self setBlendMode:screenMode];
					srcBlend = GL_ONE;
					dstBlend = GL_ONE_MINUS_SRC_COLOR;
					break;
				default:
					[self setBlendMode:_premultipliedAlpha ? [CCBlendMode premultipliedAlphaMode] : [CCBlendMode alphaMode]];
					srcBlend = !_premultipliedAlpha ? GL_SRC_ALPHA : GL_ONE;
					dstBlend = GL_ONE_MINUS_SRC_ALPHA;
				}
			}
			if (_premultipliedAlpha) {
				a *= _skeleton->color.a * slot->color.a;
				r *= _skeleton->color.r * slot->color.r * a;
				g *= _skeleton->color.g * slot->color.g * a;
				b *= _skeleton->color.b * slot->color.b * a;
			} else {
				a *= _skeleton->color.a * slot->color.a;
				r *= _skeleton->color.r * slot->color.r;
				g *= _skeleton->color.g * slot->color.g;
				b *= _skeleton->color.b * slot->color.b;
			}
			self.texture = texture;
			bool isVisible = true;
			if (!_skipVisibilityCheck) {
				float minX = FLT_MAX, minY = FLT_MAX, maxX = FLT_MIN, maxY = FLT_MIN;
				for (int i = 0; i < verticesCount * 2; i+=2) {
					minX = MIN(vertices[i], minX);
					maxX = MAX(vertices[i], maxX);
					minY = MIN(vertices[i+1], minY);
					maxY = MAX(vertices[i+1], maxY);
				}
				GLKVector2 center = GLKVector2Make(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2);
				GLKVector2 extents = GLKVector2Make((maxX - minX) / 2, (maxY - minY) / 2);
				isVisible = CCRenderCheckVisbility(transform, center, extents);
			}

			if (isVisible) {

				if (spSkeletonClipping_isClipping(_clipper)) {
					spSkeletonClipping_clipTriangles(_clipper, vertices, verticesCount, triangles, trianglesCount, uvs, 2);
					vertices = _clipper->clippedVertices->items;
					verticesCount = _clipper->clippedVertices->size;
					uvs = _clipper->clippedUVs->items;
					triangles = _clipper->clippedTriangles->items;
					trianglesCount = _clipper->clippedTriangles->size;
				}

				if (trianglesCount > 0) {
					if (!self.twoColorTint) {
						CCRenderBuffer buffer = [renderer enqueueTriangles:(trianglesCount / 3) andVertexes:verticesCount withState:self.renderState globalSortOrder:0];
						for (int i = 0; i * 2 < verticesCount; ++i) {
							CCVertex vertex;
							vertex.position = GLKVector4Make(vertices[i * 2], vertices[i * 2 + 1], 0.0, 1.0);
							vertex.color = GLKVector4Make(r, g, b, a);
							vertex.texCoord1 = GLKVector2Make(uvs[i * 2], 1 - uvs[i * 2 + 1]);
							if (_effect) {
								spColor light;
								spColor dark;
								light.r = r;
								light.g = g;
								light.b = b;
								light.a = a;
								dark.r = dark.g = dark.b = dark.a = 0;
								_effect->transform(_effect, &vertex.position.x, &vertex.position.y, &vertex.texCoord1.s, &vertex.texCoord1.t, &light, &dark);
								vertex.color.r = light.r;
								vertex.color.g = light.g;
								vertex.color.b = light.b;
								vertex.color.a = light.a;
							}
							CCRenderBufferSetVertex(buffer, i, CCVertexApplyTransform(vertex, transform));
						}
						for (int j = 0; j * 3 < trianglesCount; ++j) {
							CCRenderBufferSetTriangle(buffer, j, triangles[j * 3], triangles[j * 3 + 1], triangles[j * 3 + 2]);
						}
					} else {
						if (slot->darkColor) {
							dr = slot->darkColor->r;
							dg = slot->darkColor->g;
							db = slot->darkColor->b;
						} else {
							dr = dg = db = 0;
						}

						spMeshPart meshPart;
						spMesh_allocatePart(mesh, &meshPart, verticesCount / 2, trianglesCount, self.texture.name, srcBlend, dstBlend);

						spVertex* verts = &meshPart.mesh->vertices[meshPart.startVertex];
						unsigned short* indices = &meshPart.mesh->indices[meshPart.startIndex];

						if (_effect) {
							spColor light;
							light.r = r;
							light.g = g;
							light.b = b;
							light.a = a;
							spColor dark;
							dark.r = dr;
							dark.g = dg;
							dark.b = db;
							dark.a = da;
							for (int i = 0; i * 2 < verticesCount; i++, verts++) {
								spColor lightCopy = light;
								spColor darkCopy = dark;

								CCVertex vertex;
								vertex.position = GLKVector4Make(vertices[i * 2], vertices[i * 2 + 1], 0.0, 1.0);
								verts->u = uvs[i * 2];
								verts->v = 1 - uvs[i * 2 + 1];
								_effect->transform(_effect, &vertex.position.x, &vertex.position.y, &verts->u, &verts->v, &lightCopy, &darkCopy);

								vertex = CCVertexApplyTransform(vertex, transform);
								verts->x = vertex.position.x;
								verts->y = vertex.position.y;
								verts->z = vertex.position.z;
								verts->w = vertex.position.w;
								verts->color = ((unsigned short)(lightCopy.r * 255))| ((unsigned short)(lightCopy.g * 255)) << 8 | ((unsigned short)(lightCopy.b * 255)) <<16 | ((unsigned short)(lightCopy.a * 255)) << 24;
								verts->color2 = ((unsigned short)(darkCopy.r * 255)) | ((unsigned short)(darkCopy.g * 255)) << 8 | ((unsigned short)(darkCopy.b * 255)) << 16 | ((unsigned short)(darkCopy.a * 255)) << 24;

							}
						} else {
							for (int i = 0; i * 2 < verticesCount; i++, verts++) {
								CCVertex vertex;
								vertex.position = GLKVector4Make(vertices[i * 2], vertices[i * 2 + 1], 0.0, 1.0);
								vertex = CCVertexApplyTransform(vertex, transform);
								verts->x = vertex.position.x;
								verts->y = vertex.position.y;
								verts->z = vertex.position.z;
								verts->w = vertex.position.w;
								verts->color = ((unsigned short)(r * 255))| ((unsigned short)(g * 255)) << 8 | ((unsigned short)(b * 255)) <<16 | ((unsigned short)(a * 255)) << 24;
								verts->color2 = ((unsigned short)(dr * 255)) | ((unsigned short)(dg * 255)) << 8 | ((unsigned short)(db * 255)) << 16 | ((unsigned short)(da * 255)) << 24;
								verts->u = uvs[i * 2];
								verts->v = 1 - uvs[i * 2 + 1];
							}
						}

						for (int j = 0; j < trianglesCount; j++, indices++) {
							*indices = triangles[j];
						}

						[renderer enqueueBlock:^{
							spTwoColorBatcher_add(batcher, meshPart);
						} globalSortOrder:0 debugLabel: nil threadSafe: false];
					}
				}
			}
		}
		spSkeletonClipping_clipEnd(_clipper, slot);
	}
	spSkeletonClipping_clipEnd2(_clipper);

	if (self.twoColorTint) {
		[renderer enqueueBlock:^{
			spTwoColorBatcher_flush(batcher);
		} globalSortOrder:0 debugLabel: nil threadSafe: false];
	}

	[_drawNode clear];
	if (_debugSlots) {
		// Slots.
		CGPoint points[4];
		for (int i = 0, n = _skeleton->slotsCount; i < n; i++) {
			spSlot* slot = _skeleton->drawOrder[i];
			if (!slot->bone->active) continue;
			if (!slot->attachment || slot->attachment->type != SP_ATTACHMENT_REGION) continue;
			spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment;
			spRegionAttachment_computeWorldVertices(attachment, slot->bone, _worldVertices, 0, 2);
			points[0] = ccp(_worldVertices[0], _worldVertices[1]);
			points[1] = ccp(_worldVertices[2], _worldVertices[3]);
			points[2] = ccp(_worldVertices[4], _worldVertices[5]);
			points[3] = ccp(_worldVertices[6], _worldVertices[7]);
			[_drawNode drawPolyWithVerts:points count:4 fillColor:[CCColor clearColor] borderWidth:1 borderColor:[CCColor blueColor]];
		}
	}
	if (_debugBones) {
		// Bone lengths.
		for (int i = 0, n = _skeleton->bonesCount; i < n; i++) {
			spBone *bone = _skeleton->bones[i];
			if (!bone->active) continue;
			float x = bone->data->length * bone->a + bone->worldX;
			float y = bone->data->length * bone->c + bone->worldY;
			[_drawNode drawSegmentFrom:ccp(bone->worldX, bone->worldY) to: ccp(x, y)radius:2 color:[CCColor redColor]];
		}

		// Bone origins.
		for (int i = 0, n = _skeleton->bonesCount; i < n; i++) {
			spBone *bone = _skeleton->bones[i];
			if (!bone->active) continue;
			[_drawNode drawDot:ccp(bone->worldX, bone->worldY) radius:4 color:[CCColor greenColor]];
			if (i == 0) [_drawNode drawDot:ccp(bone->worldX, bone->worldY) radius:4 color:[CCColor blueColor]];
		}
	}

	if (_effect) _effect->end(_effect);
}

- (CCTexture*) getTextureForRegion:(spRegionAttachment*)attachment {
	return (CCTexture*)((spAtlasRegion*)attachment->rendererObject)->page->rendererObject;
}

- (CCTexture*) getTextureForMesh:(spMeshAttachment*)attachment {
	return (CCTexture*)((spAtlasRegion*)attachment->rendererObject)->page->rendererObject;
}

- (CGRect) boundingBox {
	float minX = FLT_MAX, minY = FLT_MAX, maxX = FLT_MIN, maxY = FLT_MIN;
	float scaleX = self.scaleX, scaleY = self.scaleY;
	for (int i = 0; i < _skeleton->slotsCount; ++i) {
		spSlot* slot = _skeleton->slots[i];
		if (!slot->attachment) continue;
		int verticesCount;
		if (slot->attachment->type == SP_ATTACHMENT_REGION) {
			spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment;
			spRegionAttachment_computeWorldVertices(attachment, slot->bone, _worldVertices, 0, 2);
			verticesCount = 8;
		} else if (slot->attachment->type == SP_ATTACHMENT_MESH) {
			spMeshAttachment* mesh = (spMeshAttachment*)slot->attachment;
			spVertexAttachment_computeWorldVertices(SUPER(mesh), slot, 0, mesh->super.worldVerticesLength, _worldVertices, 0, 2);

			verticesCount = mesh->super.worldVerticesLength;
		} else
			continue;
		for (int ii = 0; ii < verticesCount; ii += 2) {
			float x = _worldVertices[ii] * scaleX, y = _worldVertices[ii + 1] * scaleY;
			minX = fmin(minX, x);
			minY = fmin(minY, y);
			maxX = fmax(maxX, x);
			maxY = fmax(maxY, y);
		}
	}
	minX = self.position.x + minX;
	minY = self.position.y + minY;
	maxX = self.position.x + maxX;
	maxY = self.position.y + maxY;
	return CGRectMake(minX, minY, maxX - minX, maxY - minY);
}

// --- Convenience methods for Skeleton_* functions.

- (void) updateWorldTransform {
	spSkeleton_updateWorldTransform(_skeleton);
}

- (void) setToSetupPose {
	spSkeleton_setToSetupPose(_skeleton);
}
- (void) setBonesToSetupPose {
	spSkeleton_setBonesToSetupPose(_skeleton);
}
- (void) setSlotsToSetupPose {
	spSkeleton_setSlotsToSetupPose(_skeleton);
}

- (spBone*) findBone:(NSString*)boneName {
	return spSkeleton_findBone(_skeleton, [boneName UTF8String]);
}

- (spSlot*) findSlot:(NSString*)slotName {
	return spSkeleton_findSlot(_skeleton, [slotName UTF8String]);
}

- (bool) setSkin:(NSString*)skinName {
	return (bool)spSkeleton_setSkinByName(_skeleton, skinName ? [skinName UTF8String] : 0);
}

- (spAttachment*) getAttachment:(NSString*)slotName attachmentName:(NSString*)attachmentName {
	return spSkeleton_getAttachmentForSlotName(_skeleton, [slotName UTF8String], [attachmentName UTF8String]);
}
- (bool) setAttachment:(NSString*)slotName attachmentName:(NSString*)attachmentName {
	return (bool)spSkeleton_setAttachment(_skeleton, [slotName UTF8String], [attachmentName UTF8String]);
}

// --- CCBlendProtocol

- (void) setBlendFunc:(ccBlendFunc)func {
	self.blendFunc = func;
}

- (ccBlendFunc) blendFunc {
	return _blendFunc;
}

- (void) setOpacityModifyRGB:(BOOL)value {
	_premultipliedAlpha = value;
}

- (BOOL) doesOpacityModifyRGB {
	return _premultipliedAlpha;
}

@end