/* Silkworm - Verlet cloth physics in C
 *
 * Copyright (c) 2021 Evan Hemsley
 *
 * This software is provided 'as-is', without any express or implied warranty.
 * In no event will the authors be held liable for any damages arising from
 * the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software in a
 * product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 *
 * Evan "cosmonaut" Hemsley <evan@moonside.games>
 *
 */

#include "Silkworm.h"

#include <stdlib.h>
#include <string.h>

typedef struct Silkworm_Vector2
{
	float x;
	float y;
} Silkworm_Vector2;

typedef struct Silkworm_Link Silkworm_Link;

typedef struct Silkworm_Node
{
	uint64_t id;
	Silkworm_Vector2 position;
	Silkworm_Vector2 previousPosition;
	Silkworm_Vector2 velocity;
	Silkworm_Vector2 acceleration;
	float mass;
	float friction;
	float radius;
	bool pinned;
	float pushFactor;
	bool destroyable;

	bool markedForDestroy; /* mutual recursion on nodes/links so this makes it easier to track destroys */

	Silkworm_Link** links;
	uint32_t linkCount;
} Silkworm_Node;

struct Silkworm_Link
{
	uint64_t id;
	Silkworm_Node* a;
	Silkworm_Node* b;
	float distance;
	float tearThreshold;

	bool markedForDestroy; /* mutual recursion on nodes/links so this makes it easier to track destroys */
};

typedef enum Silkworm_ClothTriangleOrientation
{
	UpperLeft,
	BottomRight
} Silkworm_ClothTriangleOrientation;

typedef struct Silkworm_Triangle
{
	uint64_t id;
	Silkworm_Node* a;
	Silkworm_Node* b;
	Silkworm_Node* c;

	uint32_t aHorizontalIndex;
	uint32_t bHorizontalIndex;
	uint32_t cHorizontalIndex;

	uint32_t aVerticalIndex;
	uint32_t bVerticalIndex;
	uint32_t cVerticalIndex;

	Silkworm_ClothTriangleOrientation orientation;
} Silkworm_Triangle;

typedef struct NodeTriangleHashMap
{
	Silkworm_Node* key;
	uint32_t *indexArray;
	uint32_t indexArrayCount;
} NodeTriangleHashMap;

typedef struct NodeTriangleHashArray
{
	NodeTriangleHashMap* elements;
	uint32_t count;
} NodeTriangleHashArray;

#define NUM_NODE_TRIANGLE_HASH_BUCKETS 1031

typedef struct NodeTriangleHashTable
{
	NodeTriangleHashArray buckets[NUM_NODE_TRIANGLE_HASH_BUCKETS];
} NodeTriangleHashTable;

static inline uint64_t NodeTriangleHashTable_GetHashCode(Silkworm_Node *key)
{
	return 97 + (uint64_t)(size_t)key;
}

static inline uint32_t* NodeTriangleHashTable_Fetch(
	NodeTriangleHashTable *table,
	Silkworm_Node *key,
	uint32_t *arrayCount
) {
	uint32_t i;
	uint64_t hashcode = NodeTriangleHashTable_GetHashCode(key);
	NodeTriangleHashArray* arr = &table->buckets[hashcode % NUM_NODE_TRIANGLE_HASH_BUCKETS];

	for (i = 0; i < arr->count; i += 1)
	{
		if (arr->elements[i].key == key)
		{
			*arrayCount = arr->elements[i].indexArrayCount;
			return arr->elements[i].indexArray;
		}
	}

	*arrayCount = 0;
	return NULL;
}

static inline void NodeTriangleHashTable_Insert(
	NodeTriangleHashTable* table,
	Silkworm_Node* key,
	uint32_t index
) {
	uint32_t i;
	uint64_t hashcode = NodeTriangleHashTable_GetHashCode(key);
	NodeTriangleHashArray* arr = &table->buckets[hashcode % NUM_NODE_TRIANGLE_HASH_BUCKETS];
	bool foundKey = false;

	for (i = 0; i < arr->count; i += 1)
	{
		if (arr->elements[i].key == key)
		{
			arr->elements[i].indexArray = realloc(arr->elements[i].indexArray, sizeof(uint32_t) * (arr->elements[i].indexArrayCount + 1));
			arr->elements[i].indexArray[arr->elements[i].indexArrayCount] = index;
			arr->elements[i].indexArrayCount += 1;
			foundKey = true;
			break;
		}
	}

	if (!foundKey)
	{
		arr->elements = realloc(arr->elements, sizeof(NodeTriangleHashMap) * (arr->count + 1));

		arr->elements[arr->count].key = key;
		arr->elements[arr->count].indexArray = malloc(sizeof(uint32_t));
		arr->elements[arr->count].indexArray[0] = index;
		arr->elements[arr->count].indexArrayCount = 1;

		arr->count += 1;
	}
}

typedef struct LinkTriangleHashMap
{
	Silkworm_Link* key;
	uint32_t* indexArray;
	uint32_t indexArrayCount;
} LinkTriangleHashMap;

typedef struct LinkTriangleHashArray
{
	LinkTriangleHashMap* elements;
	uint32_t count;
} LinkTriangleHashArray;

#define NUM_LINK_TRIANGLE_HASH_BUCKETS 1031

typedef struct LinkTriangleHashTable
{
	LinkTriangleHashArray buckets[NUM_LINK_TRIANGLE_HASH_BUCKETS];
} LinkTriangleHashTable;

static inline uint64_t LinkTriangleHashTable_GetHashCode(Silkworm_Link* key)
{
	return 97 + (uint64_t)(size_t)key;
}

static inline uint32_t* LinkTriangleHashTable_Fetch(
	LinkTriangleHashTable* table,
	Silkworm_Link* key,
	uint32_t* arrayCount
) {
	uint32_t i;
	uint64_t hashcode = LinkTriangleHashTable_GetHashCode(key);
	LinkTriangleHashArray* arr = &table->buckets[hashcode % NUM_LINK_TRIANGLE_HASH_BUCKETS];

	for (i = 0; i < arr->count; i += 1)
	{
		if (arr->elements[i].key == key)
		{
			*arrayCount = arr->elements[i].indexArrayCount;
			return arr->elements[i].indexArray;
		}
	}

	*arrayCount = 0;
	return NULL;
}

static inline void LinkTriangleHashTable_Insert(
	LinkTriangleHashTable* table,
	Silkworm_Link* key,
	uint32_t index
) {
	uint32_t i;
	uint64_t hashcode = LinkTriangleHashTable_GetHashCode(key);
	LinkTriangleHashArray* arr = &table->buckets[hashcode % NUM_LINK_TRIANGLE_HASH_BUCKETS];
	bool foundKey = false;

	for (i = 0; i < arr->count; i += 1)
	{
		if (arr->elements[i].key == key)
		{
			arr->elements[i].indexArray = realloc(arr->elements[i].indexArray, sizeof(uint32_t) * (arr->elements[i].indexArrayCount + 1));
			arr->elements[i].indexArray[arr->elements[i].indexArrayCount] = index;
			arr->elements[i].indexArrayCount += 1;
			foundKey = true;
			break;
		}
	}

	if (!foundKey)
	{
		arr->elements = realloc(arr->elements, sizeof(LinkTriangleHashMap) * (arr->count + 1));

		arr->elements[arr->count].key = key;
		arr->elements[arr->count].indexArray = malloc(sizeof(uint32_t));
		arr->elements[arr->count].indexArray[0] = index;
		arr->elements[arr->count].indexArrayCount = 1;

		arr->count += 1;
	}
}

typedef struct Silkworm_Cloth
{
	uint64_t id;
	float windFactor;

	uint32_t horizontalNodeCount;
	uint32_t verticalNodeCount;

	uint64_t** nodeIndices; /* x by y grid of indices */

	Silkworm_Triangle** triangles; /* array of pointers so we can use NULL */
	uint32_t triangleCount;

	NodeTriangleHashTable nodeHash;
	LinkTriangleHashTable linkHash;
} Silkworm_Cloth;

typedef struct Silkworm_Rope
{
	uint32_t nodeCount;

	uint32_t* nodeIndices;
} Silkworm_Rope;

typedef struct Silkworm_Color
{
	uint8_t r;
	uint8_t g;
	uint8_t b;
	uint8_t a;
} Silkworm_Color;

typedef struct Silkworm_Context
{
	Silkworm_Node** nodes;
	uint32_t nodeCount;

	Silkworm_Link** links;
	uint32_t linkCount;

	Silkworm_Cloth** cloths;
	uint32_t clothCount;
	uint32_t clothCapacity;

	uint64_t* nodeIndexStack;
	uint32_t nodeIndexStackCount;
	uint32_t nodeIndexStackCapacity;

	uint64_t* linkIndexStack;
	uint32_t linkIndexStackCount;
	uint32_t linkIndexStackCapacity;

	uint64_t* clothIndexStack;
	uint32_t clothIndexStackCount;
	uint32_t clothIndexStackCapacity;

	float gravity;
	float xBound;
	float yBound;
	uint32_t clothDensity;

	uint8_t* currentBufferAddress; /* GM doesnt let you pass more than 4 arguments with different types lol */
} Silkworm_Context;

static Silkworm_Context *context = NULL;

#define CONSTRAINT_ITERATION_COUNT 3 /* TODO: make this a parameter? */

void Silkworm_Init()
{
	context = malloc(sizeof(Silkworm_Context));

	context->nodes = NULL;
	context->nodeCount = 0;

	context->links = NULL;
	context->linkCount = 0;

	context->cloths = NULL;
	context->clothCount = 0;

	context->nodeIndexStackCapacity = 16;
	context->nodeIndexStack = malloc(sizeof(uint64_t) * context->nodeIndexStackCapacity);
	context->nodeIndexStackCount = 0;

	context->linkIndexStackCapacity = 16;
	context->linkIndexStack = malloc(sizeof(uint64_t) * context->linkIndexStackCapacity);
	context->linkIndexStackCount = 0;

	context->clothIndexStackCapacity = 16;
	context->clothIndexStack = malloc(sizeof(uint64_t) * context->clothIndexStackCapacity);
	context->clothIndexStackCount = 0;

	context->gravity = 200;
	context->xBound = 1000;
	context->yBound = 1000;
	context->clothDensity = 4;
}

static inline Silkworm_Node* LookupNode(uint64_t nodeId)
{
	return context->nodes[nodeId];
}

static inline Silkworm_Link* LookupLink(uint64_t linkId)
{
	return context->links[linkId];
}

static inline Silkworm_Cloth* LookupCloth(uint64_t clothId)
{
	return context->cloths[clothId];
}

/* we defer actual destruction to Update to avoid issues with NULL */

void Silkworm_DestroyNode(double nodeId)
{
	uint32_t i;
	Silkworm_Node* node = LookupNode((uint64_t)nodeId);

	if (node != NULL)
	{
		node->markedForDestroy = true;

		for (i = 0; i < node->linkCount; i += 1)
		{
			if (node->links[i] != NULL)
			{
				node->links[i]->markedForDestroy = true;
			}
		}
	}
}

void Silkworm_Internal_DestroyLink(Silkworm_Link* link)
{
	link->markedForDestroy = true;
}

void Silkworm_DestroyLink(double linkId)
{
	Silkworm_Internal_DestroyLink(LookupLink((uint64_t)linkId));
}

void Silkworm_Internal_DestroyCloth(Silkworm_Cloth* cloth)
{
	uint32_t i, j;

	context->cloths[cloth->id] = NULL;

	for (i = 0; i < NUM_NODE_TRIANGLE_HASH_BUCKETS; i += 1)
	{
		for (j = 0; j < cloth->nodeHash.buckets[i].count; j += 1)
		{
			free(cloth->nodeHash.buckets[i].elements[j].indexArray);
		}
		if (cloth->nodeHash.buckets[i].elements != NULL)
		{
			free(cloth->nodeHash.buckets[i].elements);
		}
	}

	for (i = 0; i < NUM_LINK_TRIANGLE_HASH_BUCKETS; i += 1)
	{
		for (j = 0; j < cloth->linkHash.buckets[i].count; j += 1)
		{
			free(cloth->linkHash.buckets[i].elements[j].indexArray);
		}
		if (cloth->linkHash.buckets[i].elements != NULL)
		{
			free(cloth->linkHash.buckets[i].elements);
		}
	}

	for (i = 0; i < cloth->horizontalNodeCount; i += 1)
	{
		for (j = 0; j < cloth->verticalNodeCount; j += 1)
		{
			Silkworm_DestroyNode((double)cloth->nodeIndices[i][j]);
		}
		free(cloth->nodeIndices[i]);
	}
	free(cloth->nodeIndices);

	for (i = 0; i < cloth->triangleCount; i += 1)
	{
		if (cloth->triangles[i] != NULL)
		{
			free(cloth->triangles[i]);
		}
	}
	free(cloth->triangles);

	if (context->clothIndexStackCount >= context->clothIndexStackCapacity)
	{
		context->clothIndexStackCapacity *= 2;
		context->nodeIndexStack = realloc(context->nodeIndexStack, sizeof(uint64_t) * context->nodeIndexStackCapacity);
	}

	context->clothIndexStack[context->clothIndexStackCount] = cloth->id;
	context->clothIndexStackCount += 1;

	free(cloth);
}

void Silkworm_DestroyCloth(double clothId)
{
	Silkworm_Internal_DestroyCloth(LookupCloth((uint64_t)clothId));
}

void Silkworm_PerformDestroys()
{
	uint32_t i, j, k;

	for (i = 0; i < context->linkCount; i += 1)
	{
		Silkworm_Link* link = context->links[i];

		if (link != NULL && context->links[i]->markedForDestroy)
		{
			/* find cloth to remove from relevant triangles */
			for (j = 0; j < context->clothCount; j += 1)
			{
				Silkworm_Cloth* cloth = context->cloths[j];

				if (cloth != NULL)
				{
					uint32_t triangleIndexCount = 0;
					uint32_t* triangleIndices = LinkTriangleHashTable_Fetch(&cloth->linkHash, link, &triangleIndexCount);

					for (k = 0; k < triangleIndexCount; k += 1)
					{
						uint32_t triangleIndex = triangleIndices[k];

						if (cloth->triangles[triangleIndex] != NULL)
						{
							free(cloth->triangles[triangleIndex]);
							cloth->triangles[triangleIndex] = NULL;
						}
					}
				}
			}

			for (j = 0; j < link->a->linkCount; j += 1)
			{
				if (link->a->links[j] == context->links[i])
				{
					link->a->links[j] = NULL;
				}
			}

			for (j = 0; j < link->b->linkCount; j += 1)
			{
				if (link->b->links[j] == context->links[i])
				{
					link->b->links[j] = NULL;
				}
			}

			free(context->links[i]);
			context->links[i] = NULL;

			if (context->linkIndexStackCount >= context->linkIndexStackCapacity)
			{
				context->linkIndexStackCapacity *= 2;
				context->linkIndexStack = realloc(context->linkIndexStack, sizeof(uint64_t) * context->linkIndexStackCapacity);
			}

			context->linkIndexStack[context->linkIndexStackCount] = i;
			context->linkIndexStackCount += 1;
		}
	}

	for (i = 0; i < context->nodeCount; i += 1)
	{
		Silkworm_Node* node = context->nodes[i];
		if (node != NULL && node->markedForDestroy)
		{
			/* find cloth to remove from relevant triangles */
			for (j = 0; j < context->clothCount; j += 1)
			{
				Silkworm_Cloth* cloth = context->cloths[j];

				if (cloth != NULL)
				{
					uint32_t triangleIndexCount = 0;
					uint32_t* triangleIndices = NodeTriangleHashTable_Fetch(&cloth->nodeHash, node, &triangleIndexCount);

					for (k = 0; k < triangleIndexCount; k += 1)
					{
						uint32_t triangleIndex = triangleIndices[k];

						if (cloth->triangles[triangleIndex] != NULL)
						{
							free(cloth->triangles[triangleIndex]);
							cloth->triangles[triangleIndex] = NULL;
						}
					}
				}
			}

			free(context->nodes[i]->links);
			free(context->nodes[i]);
			context->nodes[i] = NULL;

			if (context->nodeIndexStackCount >= context->nodeIndexStackCapacity)
			{
				context->nodeIndexStackCapacity *= 2;
				context->nodeIndexStack = realloc(context->nodeIndexStack, sizeof(uint64_t) * context->nodeIndexStackCapacity);
			}

			context->nodeIndexStack[context->nodeIndexStackCount] = i;
			context->nodeIndexStackCount += 1;
		}
	}
}

void Silkworm_Update(double deltaTime)
{
	uint32_t i, j;
	Silkworm_Link *link;
	Silkworm_Node *node;

	float delta = (float)deltaTime;

	for (i = 0; i < CONSTRAINT_ITERATION_COUNT; i += 1)
	{
		for (j = 0; j < context->linkCount; j += 1)
		{
			link = context->links[j];

			if (link != NULL)
			{
				float diffX = link->a->position.x - link->b->position.x;
				float diffY = link->a->position.y - link->b->position.y;
				float d = (float)sqrt(diffX * diffX + diffY * diffY);

				float difference = (link->distance - d) / d;

				float translateX = diffX * 0.5f * difference;
				float translateY = diffY * 0.5f * difference;

				float distanceMoved = (float)sqrt(translateX * translateX + translateY * translateY);

				if (distanceMoved > link->tearThreshold)
				{
					Silkworm_DestroyLink((double)link->id);
				}
				else
				{
					if (!link->a->pinned)
					{
						link->a->position.x += translateX;
						link->a->position.y += translateY;
					}

					if (!link->b->pinned)
					{
						link->b->position.x -= translateX;
						link->b->position.y -= translateY;
					}
				}
			}
		}
	}

	for (j = 0; j < context->nodeCount; j += 1)
	{
		node = context->nodes[j];

		if (node != NULL)
		{
			if (!node->pinned)
			{
				float velocityX = (node->position.x - node->previousPosition.x) * node->friction;
				float velocityY = (node->position.y - node->previousPosition.y) * node->friction;

				float accelerationX = node->acceleration.x * delta * delta;
				float accelerationY = (node->acceleration.y + node->mass * context->gravity) * delta * delta;

				node->previousPosition.x = node->position.x;
				node->previousPosition.y = node->position.y;

				node->position.x += velocityX + accelerationX;
				node->position.y += velocityY + accelerationY;

				node->velocity.x = velocityX * delta;
				node->velocity.y = velocityY * delta;

				if (fabs(node->position.x) > context->xBound || fabs(node->position.x) > context->yBound)
				{
					Silkworm_DestroyNode((double)node->id);
				}
			}
		}
	}

	Silkworm_PerformDestroys();
}

double Silkworm_CreateNode(double xPosition, double yPosition, double mass, double friction, double radius, double pushFactor)
{
	Silkworm_Node* node = malloc(sizeof(Silkworm_Node));
	uint64_t id;

	if (context->nodeIndexStackCount > 0)
	{
		id = context->nodeIndexStack[context->nodeIndexStackCount - 1];
		context->nodeIndexStackCount -= 1;
	}
	else
	{
		id = context->nodeCount;

		context->nodes = realloc(context->nodes, sizeof(Silkworm_Node*) * (context->nodeCount + 1));
		context->nodeCount += 1;
	}

	context->nodes[id] = node;

	node->id = id;
	node->position.x = (float)xPosition;
	node->position.y = (float)yPosition;
	node->previousPosition.x = (float)xPosition;
	node->previousPosition.y = (float)yPosition;
	node->velocity.x = 0;
	node->velocity.y = 0;
	node->acceleration.x = 0;
	node->acceleration.y = 0;
	node->mass = (float)mass;
	node->friction = (float)friction;
	node->radius = (float)radius;
	node->pushFactor = (float)pushFactor;
	node->pinned = false;
	node->destroyable = false;
	node->markedForDestroy = false;
	node->links = NULL;
	node->linkCount = 0;

	return (double)node->id;
}

void Silkworm_NodeSetVelocity(double nodeId, double xVelocity, double yVelocity)
{
	LookupNode(nodeId)->velocity.x = (float)xVelocity;
	LookupNode(nodeId)->velocity.y = (float)yVelocity;
}

void Silkworm_NodeSetAcceleration(double nodeId, double xAcceleration, double yAcceleration)
{
	LookupNode(nodeId)->acceleration.x = (float)xAcceleration;
	LookupNode(nodeId)->acceleration.y = (float)yAcceleration;
}

void Silkworm_NodeSetDestroyable(double nodeId)
{
	LookupNode(nodeId)->destroyable = true;
}

void Silkworm_ClothNodePin(double clothId, double i, double j)
{
	Silkworm_Cloth* cloth = LookupCloth(clothId);
	context->nodes[cloth->nodeIndices[(uint64_t)i][(uint64_t)j]]->pinned = true;
}

void Silkworm_ClothNodeUnpin(double clothId, double i, double j)
{
	Silkworm_Cloth* cloth = LookupCloth(clothId);
	context->nodes[cloth->nodeIndices[(uint64_t)i][(uint64_t)j]]->pinned = false;
}

void Silkworm_ClothNodeDestroy(double clothId, double i, double j)
{
	Silkworm_Cloth* cloth = LookupCloth(clothId);
	uint64_t nodeIndex = cloth->nodeIndices[(uint64_t)i][(uint64_t)j];
	Silkworm_Node* node = context->nodes[nodeIndex];
	Silkworm_DestroyNode(nodeIndex);
}

double Silkworm_CreateLink(double aId, double bId, double distance, double tearThreshold)
{
	Silkworm_Node *nodeA = LookupNode(aId);
	Silkworm_Node *nodeB = LookupNode(bId);

	uint64_t id;

	Silkworm_Link* link = malloc(sizeof(Silkworm_Link));

	if (context->linkIndexStackCount > 0)
	{
		id = context->linkIndexStack[context->linkIndexStackCount - 1];
		context->linkIndexStackCount -= 1;
	}
	else
	{
		id = context->linkCount;

		context->links = realloc(context->links, sizeof(Silkworm_Link*) * (context->linkCount + 1));
		context->linkCount += 1;
	}

	context->links[id] = link;

	link->id = id;
	link->a = nodeA;
	link->b = nodeB;
	link->distance = (float)distance;
	link->tearThreshold = (float)tearThreshold;
	link->markedForDestroy = false;

	link->a->links = realloc(link->a->links, sizeof(Silkworm_Link*) * (link->a->linkCount + 1));
	link->a->links[link->a->linkCount] = link;
	link->a->linkCount += 1;

	link->b->links = realloc(link->b->links, sizeof(Silkworm_Link*) * (link->b->linkCount + 1));
	link->b->links[link->b->linkCount] = link;
	link->b->linkCount += 1;

	return (double)link->id;
}

double Silkworm_CreateCloth(double xPosition, double yPosition, double width, double height, double mass, double friction, double windFactor, double tearThreshold)
{
	int32_t i, j, k, m;

	Silkworm_Cloth* cloth = malloc(sizeof(Silkworm_Cloth));

	cloth->windFactor = (float)windFactor;
	cloth->horizontalNodeCount = ((uint32_t)width / context->clothDensity) + 1;
	cloth->verticalNodeCount = ((uint32_t)height / context->clothDensity) + 1;
	cloth->nodeIndices = malloc(sizeof(uint64_t*) * cloth->horizontalNodeCount);

	uint64_t id;

	if (context->clothIndexStackCount > 0)
	{
		id = context->clothIndexStack[context->clothIndexStackCount - 1];
		context->clothIndexStackCount -= 1;

		context->cloths[id] = cloth;
	}
	else
	{
		id = context->clothCount;

		context->cloths = realloc(context->cloths, sizeof(Silkworm_Cloth*) * (context->clothCount + 1));
		context->cloths[id] = cloth;
		context->clothCount += 1;
	}

	cloth->id = id;

	for (i = 0; i < NUM_NODE_TRIANGLE_HASH_BUCKETS; i += 1)
	{
		cloth->nodeHash.buckets[i].elements = NULL;
		cloth->nodeHash.buckets[i].count = 0;
	}

	for (i = 0; i < NUM_LINK_TRIANGLE_HASH_BUCKETS; i += 1)
	{
		cloth->linkHash.buckets[i].elements = NULL;
		cloth->linkHash.buckets[i].count = 0;
	}

	for (i = 0; i < cloth->horizontalNodeCount; i += 1)
	{
		cloth->nodeIndices[i] = malloc(sizeof(uint64_t) * cloth->verticalNodeCount);

		for (j = 0; j < cloth->verticalNodeCount; j += 1)
		{
			uint64_t nodeId = (uint64_t) Silkworm_CreateNode(xPosition + i * context->clothDensity, yPosition + j * context->clothDensity, mass, friction, 1, 0.5);

			cloth->nodeIndices[i][j] = nodeId;

			if (j == 0)
			{
				Silkworm_ClothNodePin((double)cloth->id, (double)i, (double)j);
			}

			Silkworm_NodeSetDestroyable((double)nodeId);
		}
	}

	cloth->triangles = malloc(sizeof(Silkworm_Triangle*) * cloth->horizontalNodeCount * cloth->verticalNodeCount * 2);
	uint32_t triangleIndex = 0;

	for (i = 0; i < cloth->horizontalNodeCount; i += 1)
	{
		for (j = 0; j < cloth->verticalNodeCount; j += 1)
		{
			if (i + 1 < cloth->horizontalNodeCount && j + 1 < cloth->verticalNodeCount)
			{
				cloth->triangles[triangleIndex] = malloc(sizeof(Silkworm_Triangle));

				cloth->triangles[triangleIndex]->a = context->nodes[cloth->nodeIndices[i][j]];
				cloth->triangles[triangleIndex]->b = context->nodes[cloth->nodeIndices[i + 1][j]];
				cloth->triangles[triangleIndex]->c = context->nodes[cloth->nodeIndices[i][j + 1]];
				cloth->triangles[triangleIndex]->orientation = UpperLeft;

				cloth->triangles[triangleIndex]->aHorizontalIndex = i;
				cloth->triangles[triangleIndex]->aVerticalIndex = j;

				cloth->triangles[triangleIndex]->bHorizontalIndex = i + 1;
				cloth->triangles[triangleIndex]->bVerticalIndex = j;

				cloth->triangles[triangleIndex]->cHorizontalIndex = i;
				cloth->triangles[triangleIndex]->cVerticalIndex = j + 1;

				NodeTriangleHashTable_Insert(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i][j]], triangleIndex);
				NodeTriangleHashTable_Insert(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i + 1][j]], triangleIndex);
				NodeTriangleHashTable_Insert(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i][j + 1]], triangleIndex);

				triangleIndex += 1;
			}

			if (i - 1 >= 0 && j - 1 >= 0)
			{
				cloth->triangles[triangleIndex] = malloc(sizeof(Silkworm_Triangle));

				cloth->triangles[triangleIndex]->a = context->nodes[cloth->nodeIndices[i][j]];
				cloth->triangles[triangleIndex]->b = context->nodes[cloth->nodeIndices[i - 1][j]];
				cloth->triangles[triangleIndex]->c = context->nodes[cloth->nodeIndices[i][j - 1]];
				cloth->triangles[triangleIndex]->orientation = BottomRight;

				cloth->triangles[triangleIndex]->aHorizontalIndex = i;
				cloth->triangles[triangleIndex]->aVerticalIndex = j;

				cloth->triangles[triangleIndex]->bHorizontalIndex = i - 1;
				cloth->triangles[triangleIndex]->bVerticalIndex = j;

				cloth->triangles[triangleIndex]->cHorizontalIndex = i;
				cloth->triangles[triangleIndex]->cVerticalIndex = j - 1;

				NodeTriangleHashTable_Insert(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i][j]], triangleIndex);
				NodeTriangleHashTable_Insert(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i - 1][j]], triangleIndex);
				NodeTriangleHashTable_Insert(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i][j - 1]], triangleIndex);

				triangleIndex += 1;
			}
		}
	}

	cloth->triangleCount = triangleIndex;

	for (i = 0; i < cloth->horizontalNodeCount; i += 1)
	{
		for (j = 0; j < cloth->verticalNodeCount; j += 1)
		{
			if (i - 1 >= 0)
			{
				double linkId = Silkworm_CreateLink((double)cloth->nodeIndices[i - 1][j], (double)cloth->nodeIndices[i][j], context->clothDensity, tearThreshold);

				uint32_t indexArrayOneCount = 0;
				uint32_t* indexArrayOne = NodeTriangleHashTable_Fetch(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i - 1][j]], &indexArrayOneCount);

				uint32_t indexArrayTwoCount = 0;
				uint32_t* indexArrayTwo = NodeTriangleHashTable_Fetch(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i][j]], &indexArrayTwoCount);

				for (k = 0; k < indexArrayOneCount; k += 1)
				{
					uint32_t triangleIndex = indexArrayOne[k];
					for (m = 0; m < indexArrayTwoCount; m += 1)
					{
						if (indexArrayTwo[m] == triangleIndex)
						{
							LinkTriangleHashTable_Insert(&cloth->linkHash, context->links[(uint64_t)linkId], triangleIndex);
						}
					}
				}
			}

			if (j - 1 >= 0)
			{
				double linkId = Silkworm_CreateLink((double)cloth->nodeIndices[i][j - 1], (double)cloth->nodeIndices[i][j], context->clothDensity, tearThreshold);

				uint32_t indexArrayOneCount = 0;
				uint32_t* indexArrayOne = NodeTriangleHashTable_Fetch(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i][j - 1]], &indexArrayOneCount);

				uint32_t indexArrayTwoCount = 0;
				uint32_t* indexArrayTwo = NodeTriangleHashTable_Fetch(&cloth->nodeHash, context->nodes[cloth->nodeIndices[i][j]], &indexArrayTwoCount);

				for (k = 0; k < indexArrayOneCount; k += 1)
				{
					uint32_t triangleIndex = indexArrayOne[k];
					for (m = 0; m < indexArrayTwoCount; m += 1)
					{
						if (indexArrayTwo[m] == triangleIndex)
						{
							LinkTriangleHashTable_Insert(&cloth->linkHash, context->links[(uint64_t)linkId], triangleIndex);
						}
					}
				}
			}
		}
	}

	return (double)cloth->id;
}

/* FIXME: this is very unsafe */
double Silkworm_ClothHorizontalNodeCount(double clothId)
{
	return context->cloths[(uint32_t)clothId]->horizontalNodeCount;
}

double Silkworm_ClothVerticalNodeCount(double clothId)
{
	return context->cloths[(uint32_t)clothId]->verticalNodeCount;
}

void Silkworm_ClothFillNodeDataBuffer(double clothId)
{
	uint32_t i, j;
	uint8_t* bufferAddress = context->currentBufferAddress;
	Silkworm_Cloth* cloth = LookupCloth(clothId);

	uint8_t active = 0;
	uint8_t pinned = 0;

	for (i = 0; i < cloth->horizontalNodeCount; i += 1)
	{
		for (j = 0; j < cloth->verticalNodeCount; j += 1)
		{
			active = context->nodes[cloth->nodeIndices[i][j]] != NULL;

			memcpy(bufferAddress, &active, sizeof(uint8_t));
			bufferAddress += sizeof(uint8_t);

			pinned = 0;
			if (context->nodes[cloth->nodeIndices[i][j]] != NULL)
			{
				pinned = context->nodes[cloth->nodeIndices[i][j]]->pinned;
			}

			memcpy(bufferAddress, &pinned, sizeof(uint8_t));
			bufferAddress += sizeof(uint8_t);
		}
	}
}

void Silkworm_ApplyWind(double xSpeed, double ySpeed)
{
	uint32_t i, j, k;
	Silkworm_Cloth* cloth;
	Silkworm_Node* node;

	for (i = 0; i < context->clothCount; i += 1)
	{
		if (context->cloths[i] != NULL)
		{
			cloth = context->cloths[i];

			for (j = 0; j < cloth->horizontalNodeCount; j += 1)
			{
				for (k = 0; k < cloth->verticalNodeCount; k += 1)
				{
					node = context->nodes[cloth->nodeIndices[j][k]];

					if (node != NULL && !node->pinned)
					{
						node->position.x += (float)xSpeed * 0.025f * cloth->windFactor;
						node->position.y += (float)ySpeed * 0.025f * cloth->windFactor;
					}
				}
			}
		}
	}
}

void Silkworm_SetBuffer(const char* bufferId)
{
	context->currentBufferAddress = (uint8_t*)bufferId;
}

/* pattern is x, y position then color + alpha then UV position */
double Silkworm_ClothFillTriangleBuffer(double clothId, double leftUV, double widthUV, double topUV, double heightUV)
{
	uint32_t i, triangleCount;
	uint8_t* bufferAddress = context->currentBufferAddress;
	Silkworm_Cloth* cloth = LookupCloth(clothId);

	Silkworm_Color color;
	color.r = 255;
	color.g = 255;
	color.b = 255;
	color.a = 255;

	triangleCount = 0;
	for (i = 0; i < cloth->triangleCount; i += 1)
	{
		if (cloth->triangles[i] != NULL)
		{
			if (cloth->triangles[i]->orientation == UpperLeft)
			{
				float left = (float)leftUV + (float)widthUV * ((float)cloth->triangles[i]->aHorizontalIndex / (cloth->horizontalNodeCount - 1));
				float right = (float)leftUV + (float)widthUV * ((float)cloth->triangles[i]->bHorizontalIndex / (cloth->horizontalNodeCount - 1));

				float top = (float)topUV + (float)heightUV * ((float)cloth->triangles[i]->aVerticalIndex / (cloth->verticalNodeCount - 1));
				float bottom = (float)topUV + (float)heightUV * ((float)cloth->triangles[i]->cVerticalIndex / (cloth->verticalNodeCount - 1));

				memcpy(bufferAddress, &cloth->triangles[i]->a->position, sizeof(Silkworm_Vector2));
				bufferAddress += sizeof(Silkworm_Vector2);

				memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
				bufferAddress += sizeof(Silkworm_Color);

				memcpy(bufferAddress, &left, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &top, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &cloth->triangles[i]->b->position, sizeof(Silkworm_Vector2));
				bufferAddress += sizeof(Silkworm_Vector2);

				memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
				bufferAddress += sizeof(Silkworm_Color);

				memcpy(bufferAddress, &right, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &top, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &cloth->triangles[i]->c->position, sizeof(Silkworm_Vector2));
				bufferAddress += sizeof(Silkworm_Vector2);

				memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
				bufferAddress += sizeof(Silkworm_Color);

				memcpy(bufferAddress, &left, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &bottom, sizeof(float));
				bufferAddress += sizeof(float);

				triangleCount += 1;
			}
			else if (cloth->triangles[i]->orientation == BottomRight)
			{
				float left = (float)leftUV + (float)widthUV * ((float)cloth->triangles[i]->bHorizontalIndex / (cloth->horizontalNodeCount - 1));
				float right = (float)leftUV + (float)widthUV * ((float)cloth->triangles[i]->aHorizontalIndex / (cloth->horizontalNodeCount - 1));

				float top = (float)topUV + (float)heightUV * ((float)cloth->triangles[i]->cVerticalIndex / (cloth->verticalNodeCount - 1));
				float bottom = (float)topUV + (float)heightUV * ((float)cloth->triangles[i]->aVerticalIndex / (cloth->verticalNodeCount - 1));

				memcpy(bufferAddress, &cloth->triangles[i]->a->position, sizeof(Silkworm_Vector2));
				bufferAddress += sizeof(Silkworm_Vector2);

				memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
				bufferAddress += sizeof(Silkworm_Color);

				memcpy(bufferAddress, &right, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &bottom, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &cloth->triangles[i]->b->position, sizeof(Silkworm_Vector2));
				bufferAddress += sizeof(Silkworm_Vector2);

				memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
				bufferAddress += sizeof(Silkworm_Color);

				memcpy(bufferAddress, &left, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &bottom, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &cloth->triangles[i]->c->position, sizeof(Silkworm_Vector2));
				bufferAddress += sizeof(Silkworm_Vector2);

				memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
				bufferAddress += sizeof(Silkworm_Color);

				memcpy(bufferAddress, &right, sizeof(float));
				bufferAddress += sizeof(float);

				memcpy(bufferAddress, &top, sizeof(float));
				bufferAddress += sizeof(float);

				triangleCount += 1;
			}
		}
	}

	return (double)triangleCount * 3;
}

/* in bytes */
double Silkworm_GetEditorBufferRequiredSize()
{
	return 72 * context->nodeCount + 72 * context->linkCount;
}

/* position, color */
double Silkworm_FillEditorBuffer()
{
	uint32_t i, triangleCount;
	uint8_t* bufferAddress = context->currentBufferAddress;

	Silkworm_Vector2 position;
	position.x = 0;
	position.y = 0;

	Silkworm_Color color;
	color.r = 0;
	color.g = 0;
	color.b = 255;
	color.a = 255;

	triangleCount = 0;

	/* draw links */
	for (i = 0; i < context->linkCount; i += 1)
	{
		Silkworm_Link* link = context->links[i];

		if (link != NULL)
		{
			/* top left triangle */
			float left, right, top, bottom;

			if (link->a->position.y < link->b->position.y)
			{
				top = link->a->position.y;
				bottom = link->b->position.y;
			}
			else
			{
				top = link->b->position.y;
				bottom = link->a->position.y;
			}

			if (link->a->position.x < link->b->position.x)
			{
				left = link->a->position.x;
				right = link->b->position.x;
			}
			else
			{
				left = link->b->position.x;
				right = link->a->position.x;
			}

			/* upper left triangle */
			position.x = left;
			position.y = top;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = right;
			position.y = top;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = left;
			position.y = bottom;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			triangleCount += 1;

			/* bottom right triangle */
			position.x = left;
			position.y = bottom;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = right;
			position.y = top;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = right;
			position.y = bottom;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			triangleCount += 1;
		}
	}

	color.r = 255;
	color.b = 0;

	/* draw nodes */
	for (i = 0; i < context->nodeCount; i += 1)
	{
		Silkworm_Node* node = context->nodes[i];

		if (node != NULL)
		{
			if (node->pinned)
			{
				color.r = 255;
				color.g = 255;
				color.b = 0;
			}
			else
			{
				color.r = 255;
				color.g = 0;
				color.b = 0;
			}

			/* top left triangle */
			position.x = node->position.x - node->radius;
			position.y = node->position.y - node->radius;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = node->position.x + node->radius;
			position.y = node->position.y - node->radius;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = node->position.x - node->radius;
			position.y = node->position.y + node->radius;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			triangleCount += 1;

			/* bottom right triangle */
			position.x = node->position.x - node->radius;
			position.y = node->position.y + node->radius;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = node->position.x + node->radius;
			position.y = node->position.y - node->radius;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			position.x = node->position.x + node->radius;
			position.y = node->position.y + node->radius;

			memcpy(bufferAddress, &position, sizeof(Silkworm_Vector2));
			bufferAddress += sizeof(Silkworm_Vector2);

			memcpy(bufferAddress, &color, sizeof(Silkworm_Color));
			bufferAddress += sizeof(Silkworm_Color);

			triangleCount += 1;
		}
	}

	return (double)triangleCount * 3;
}

void Silkworm_PushNodesInRadius(double x, double y, double radius, double xDirection, double yDirection)
{
	/* TODO: spatial hash implementation */

	uint32_t i;

	for (i = 0; i < context->nodeCount; i += 1)
	{
		Silkworm_Node* node = context->nodes[i];

		if (node != NULL && !node->pinned)
		{
			float xDistance = (float)fabs((float)x - node->position.x);
			float yDistance = (float)fabs((float)y - node->position.y);

			float squareDistance = xDistance * xDistance + yDistance * yDistance;

			if (squareDistance <= radius * radius)
			{
				node->position.x += (float)xDirection;
				node->position.y += (float)yDirection;
			}
		}
	}
}

void Silkworm_PinNodesInRadius(double x, double y, double radius)
{
	/* TODO: spatial hash implementation */

	uint32_t i;

	for (i = 0; i < context->nodeCount; i += 1)
	{
		Silkworm_Node* node = context->nodes[i];

		if (node != NULL)
		{
			float xDistance = (float)fabs((float)x - node->position.x);
			float yDistance = (float)fabs((float)y - node->position.y);

			float squareDistance = xDistance * xDistance + yDistance * yDistance;

			if (squareDistance <= radius * radius)
			{
				node->pinned = true;
			}
		}
	}
}

void Silkworm_UnpinNodesInRadius(double x, double y, double radius)
{
	/* TODO: spatial hash implementation */

	uint32_t i;

	for (i = 0; i < context->nodeCount; i += 1)
	{
		Silkworm_Node* node = context->nodes[i];

		if (node != NULL)
		{
			float xDistance = (float)fabs((float)x - node->position.x);
			float yDistance = (float)fabs((float)y - node->position.y);

			float squareDistance = xDistance * xDistance + yDistance * yDistance;

			if (squareDistance <= radius * radius)
			{
				node->pinned = false;
			}
		}
	}
}

void Silkworm_DestroyNodesInRadius(double x, double y, double radius)
{
	/* TODO: spatial hash implementation */

	uint32_t i;

	for (i = 0; i < context->nodeCount; i += 1)
	{
		Silkworm_Node* node = context->nodes[i];

		if (node != NULL)
		{
			float xDistance = (float)fabs((float)x - node->position.x);
			float yDistance = (float)fabs((float)y - node->position.y);

			float squareDistance = xDistance * xDistance + yDistance * yDistance;

			if (squareDistance <= radius * radius)
			{
				Silkworm_DestroyNode(i);
			}
		}
	}

	Silkworm_PerformDestroys();
}

double Silkworm_DestroyClothInRadius(double x, double y, double radius)
{
	/* TODO: spatial hash implementation */

	uint32_t i, j;
	int32_t clothId = -1;

	for (i = 0; i < context->nodeCount; i += 1)
	{
		Silkworm_Node* node = context->nodes[i];

		if (node != NULL)
		{
			float xDistance = (float)fabs((float)x - node->position.x);
			float yDistance = (float)fabs((float)y - node->position.y);

			float squareDistance = xDistance * xDistance + yDistance * yDistance;

			if (squareDistance <= radius * radius)
			{
				for (j = 0; j < context->clothCount; j += 1)
				{
					Silkworm_Cloth* cloth = context->cloths[j];

					if (cloth != NULL)
					{
						/* if the node has a triangle in the cloth, it's part of the cloth! */
						uint32_t arrayCount = 0;
						NodeTriangleHashTable_Fetch(&cloth->nodeHash, node, &arrayCount);

						if (arrayCount > 0)
						{
							clothId = cloth->id;
						}
					}
				}
			}
		}
	}

	if (clothId != -1)
	{
		Silkworm_DestroyCloth((double)clothId);
	}

	Silkworm_PerformDestroys();
	return clothId;
}

void Silkworm_ClearAll()
{
	uint32_t i;

	for (i = 0; i < context->clothCount; i += 1)
	{
		if (context->cloths[i] != NULL)
		{
			Silkworm_Internal_DestroyCloth(context->cloths[i]);
		}
	}

	Silkworm_PerformDestroys();
}

void Silkworm_Finish()
{
	Silkworm_ClearAll();

	free(context->nodes);
	free(context->links);
	free(context->cloths);

	free(context->nodeIndexStack);
	free(context->linkIndexStack);
	free(context->clothIndexStack);

	free(context);
	context = NULL;
}