Update xatlas to b7d7bb.

4 files changed, 6033 insertions, 5476 deletions

diff --git a/modules/xatlas_unwrap/register_types.cpp b/modules/xatlas_unwrap/register_types.cpp
index 903b57f017..c18aa04336 100644
--- a/modules/xatlas_unwrap/register_types.cpp
+++ b/modules/xatlas_unwrap/register_types.cpp
@@ -39,57 +39,37 @@ extern bool (*array_mesh_lightmap_unwrap_callback)(float p_texel_size, const flo
 bool xatlas_mesh_lightmap_unwrap_callback(float p_texel_size, const float *p_vertices, const float *p_normals, int p_vertex_count, const int *p_indices, const int *p_face_materials, int p_index_count, float **r_uv, int **r_vertex, int *r_vertex_count, int **r_index, int *r_index_count, int *r_size_hint_x, int *r_size_hint_y) {
 
 	//set up input mesh
-	xatlas::InputMesh input_mesh;
-	input_mesh.indexData = malloc(sizeof(int) * p_index_count);
+	xatlas::MeshDecl input_mesh;
+	input_mesh.indexData = p_indices;
 	input_mesh.indexCount = p_index_count;
-	input_mesh.indexFormat = xatlas::IndexFormat::Float; //really xatlas?
-	input_mesh.faceMaterialData = (uint16_t *)malloc(sizeof(uint16_t) * p_index_count);
-
-	for (int i = 0; i < p_index_count; i++) {
-		int *index = (int *)input_mesh.indexData;
-		index[i] = p_indices[i];
-	}
-	for (int i = 0; i < p_index_count / 3; i++) {
-		uint16_t *mat_index = (uint16_t *)input_mesh.faceMaterialData;
-		mat_index[i] = p_face_materials[i];
-	}
+	input_mesh.indexFormat = xatlas::IndexFormat::UInt32;
 
 	input_mesh.vertexCount = p_vertex_count;
-	input_mesh.vertexPositionData = malloc(sizeof(float) * p_vertex_count * 3);
+	input_mesh.vertexPositionData = p_vertices;
 	input_mesh.vertexPositionStride = sizeof(float) * 3;
-	input_mesh.vertexNormalData = malloc(sizeof(float) * p_vertex_count * 3);
-	input_mesh.vertexNormalStride = sizeof(float) * 3;
-
-	//material is a better hint than this i guess?
+	input_mesh.vertexNormalData = p_normals;
+	input_mesh.vertexNormalStride = sizeof(uint32_t) * 3;
 	input_mesh.vertexUvData = NULL;
 	input_mesh.vertexUvStride = 0;
 
-	for (int i = 0; i < p_vertex_count * 3; i++) {
-		float *vertex_ptr = (float *)input_mesh.vertexPositionData;
-		float *normal_ptr = (float *)input_mesh.vertexNormalData;
+	xatlas::ChartOptions chart_options;
+	xatlas::PackOptions pack_options;
 
-		vertex_ptr[i] = p_vertices[i];
-		normal_ptr[i] = p_normals[i];
-	}
-
-	xatlas::CharterOptions chart_options;
-	xatlas::PackerOptions pack_options;
-
-	pack_options.method = xatlas::PackMethod::TexelArea;
-	pack_options.texelArea = 1.0 / p_texel_size;
-	pack_options.quality = 3;
+	pack_options.maxChartSize = 4096;
+	pack_options.bruteForce = true;
+	pack_options.texelsPerUnit = 1.0 / p_texel_size;
 
 	xatlas::Atlas *atlas = xatlas::Create();
-	printf("adding mesh..\n");
-	xatlas::AddMeshError err = xatlas::AddMesh(atlas, input_mesh);
-	ERR_EXPLAINC(xatlas::StringForEnum(err.code));
-	ERR_FAIL_COND_V(err.code != xatlas::AddMeshErrorCode::Success, false);
+	printf("Adding mesh..\n");
+	xatlas::AddMeshError::Enum err = xatlas::AddMesh(atlas, input_mesh, 1);
+	ERR_EXPLAINC(xatlas::StringForEnum(err));
+	ERR_FAIL_COND_V(err != xatlas::AddMeshError::Enum::Success, false);
 
-	printf("generate..\n");
-	xatlas::Generate(atlas, chart_options, pack_options);
+	printf("Generate..\n");
+	xatlas::Generate(atlas, chart_options, NULL, pack_options);
 
-	*r_size_hint_x = xatlas::GetWidth(atlas);
-	*r_size_hint_y = xatlas::GetHeight(atlas);
+	*r_size_hint_x = atlas->width;
+	*r_size_hint_y = atlas->height;
 
 	float w = *r_size_hint_x;
 	float h = *r_size_hint_y;
@@ -98,39 +78,33 @@ bool xatlas_mesh_lightmap_unwrap_callback(float p_texel_size, const float *p_ver
 		return false; //could not bake
 	}
 
-	const xatlas::OutputMesh *const *output_meshes = xatlas::GetOutputMeshes(atlas);
-
-	const xatlas::OutputMesh *output = output_meshes[0];
+	const xatlas::Mesh &output = atlas->meshes[0];
 
-	*r_vertex = (int *)malloc(sizeof(int) * output->vertexCount);
-	*r_uv = (float *)malloc(sizeof(float) * output->vertexCount * 2);
-	*r_index = (int *)malloc(sizeof(int) * output->indexCount);
+	*r_vertex = (int *)malloc(sizeof(int) * output.vertexCount);
+	*r_uv = (float *)malloc(sizeof(float) * output.vertexCount * 2);
+	*r_index = (int *)malloc(sizeof(int) * output.indexCount);
 
 	float max_x = 0;
 	float max_y = 0;
-	for (uint32_t i = 0; i < output->vertexCount; i++) {
-		(*r_vertex)[i] = output->vertexArray[i].xref;
-		(*r_uv)[i * 2 + 0] = output->vertexArray[i].uv[0] / w;
-		(*r_uv)[i * 2 + 1] = output->vertexArray[i].uv[1] / h;
-		max_x = MAX(max_x, output->vertexArray[i].uv[0]);
-		max_y = MAX(max_y, output->vertexArray[i].uv[1]);
+	for (uint32_t i = 0; i < output.vertexCount; i++) {
+		(*r_vertex)[i] = output.vertexArray[i].xref;
+		(*r_uv)[i * 2 + 0] = output.vertexArray[i].uv[0] / w;
+		(*r_uv)[i * 2 + 1] = output.vertexArray[i].uv[1] / h;
+		max_x = MAX(max_x, output.vertexArray[i].uv[0]);
+		max_y = MAX(max_y, output.vertexArray[i].uv[1]);
 	}
 
-	printf("final texsize: %f,%f - max %f,%f\n", w, h, max_x, max_y);
-	*r_vertex_count = output->vertexCount;
+	printf("Final texture size: %f,%f - max %f,%f\n", w, h, max_x, max_y);
+	*r_vertex_count = output.vertexCount;
 
-	for (uint32_t i = 0; i < output->indexCount; i++) {
-		(*r_index)[i] = output->indexArray[i];
+	for (uint32_t i = 0; i < output.indexCount; i++) {
+		(*r_index)[i] = output.indexArray[i];
 	}
 
-	*r_index_count = output->indexCount;
+	*r_index_count = output.indexCount;
 
 	//xatlas::Destroy(atlas);
-	free((void *)input_mesh.indexData);
-	free((void *)input_mesh.vertexPositionData);
-	free((void *)input_mesh.vertexNormalData);
-	free((void *)input_mesh.faceMaterialData);
-	printf("done");
+	printf("Done\n");
 	return true;
 }
 
diff --git a/thirdparty/README.md b/thirdparty/README.md
index dbdf9bbf4f..b38a0b3adf 100644
--- a/thirdparty/README.md
+++ b/thirdparty/README.md
@@ -511,7 +511,7 @@ folder.
 ## xatlas
 
 - Upstream: https://github.com/jpcy/xatlas
-- Version: git (b8ec29b, 2018)
+- Version: git (b7d7bb, 2019)
 - License: MIT
 
 Files extracted from upstream source:
diff --git a/thirdparty/xatlas/xatlas.cpp b/thirdparty/xatlas/xatlas.cpp
index 2cc2905eee..c62be4e73a 100644
--- a/thirdparty/xatlas/xatlas.cpp
+++ b/thirdparty/xatlas/xatlas.cpp
@@ -1,128 +1,441 @@
-// This code is in the public domain -- castanyo@yahoo.es
+/*
+MIT License
+
+Copyright (c) 2018-2019 Jonathan Young
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+/*
+thekla_atlas
+https://github.com/Thekla/thekla_atlas
+MIT License
+Copyright (c) 2013 Thekla, Inc
+Copyright NVIDIA Corporation 2006 -- Ignacio Castano <icastano@nvidia.com>
+
+Fast-BVH
+https://github.com/brandonpelfrey/Fast-BVH
+MIT License
+Copyright (c) 2012 Brandon Pelfrey
+*/
 #include <algorithm>
-#include <cmath>
-#include <memory>
-#include <unordered_map>
-#include <vector>
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
 #include <assert.h>
-#include <float.h>
+#include <float.h> // FLT_MAX
+#include <limits.h>
 #include <math.h>
-#include <stdarg.h>
+#define __STDC_LIMIT_MACROS
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
-#include <time.h>
 #include "xatlas.h"
 
-#undef min
-#undef max
+#ifndef XA_DEBUG
+#ifdef NDEBUG
+#define XA_DEBUG 0
+#else
+#define XA_DEBUG 1
+#endif
+#endif
 
-#ifndef xaAssert
-#define xaAssert(exp) if (!(exp)) { xaPrint("%s %s %s\n", #exp, __FILE__, __LINE__); }
+#ifndef XA_PROFILE
+#define XA_PROFILE 0
 #endif
-#ifndef xaDebugAssert
-#define xaDebugAssert(exp) assert(exp)
+#if XA_PROFILE
+#include <time.h>
 #endif
-#ifndef xaPrint
-#define xaPrint(...) if (xatlas::internal::s_print) { xatlas::internal::s_print(__VA_ARGS__); }
+
+#ifndef XA_MULTITHREADED
+#define XA_MULTITHREADED 1
 #endif
 
-#ifdef _MSC_VER
-// Ignore gcc attributes.
-#define __attribute__(X)
+#define XA_STR(x) #x
+#define XA_XSTR(x) XA_STR(x)
+
+#ifndef XA_ASSERT
+#define XA_ASSERT(exp) if (!(exp)) { XA_PRINT_WARNING("\rASSERT: %s %s %d\n", XA_XSTR(exp), __FILE__, __LINE__); }
 #endif
 
-#ifdef _MSC_VER
-#define restrict
-#define NV_FORCEINLINE __forceinline
-#else
-#define restrict __restrict__
-#define NV_FORCEINLINE  __attribute__((always_inline)) inline
+#ifndef XA_DEBUG_ASSERT
+#define XA_DEBUG_ASSERT(exp) assert(exp)
 #endif
 
-#define NV_UINT32_MAX   0xffffffff
-#define NV_FLOAT_MAX    3.402823466e+38F
+#ifndef XA_PRINT
+#define XA_PRINT(...) \
+	if (xatlas::internal::s_print && xatlas::internal::s_printVerbose) \
+		xatlas::internal::s_print(__VA_ARGS__);
+#endif
 
-#ifndef PI
-#define PI                  float(3.1415926535897932384626433833)
+#ifndef XA_PRINT_WARNING
+#define XA_PRINT_WARNING(...) \
+	if (xatlas::internal::s_print) \
+		xatlas::internal::s_print(__VA_ARGS__);
 #endif
 
-#define NV_EPSILON          (0.0001f)
-#define NV_NORMAL_EPSILON   (0.001f)
+#define XA_ALLOC(tag, type) (type *)internal::Realloc(nullptr, sizeof(type), tag, __FILE__, __LINE__)
+#define XA_ALLOC_ARRAY(tag, type, num) (type *)internal::Realloc(nullptr, sizeof(type) * num, tag, __FILE__, __LINE__)
+#define XA_REALLOC(tag, ptr, type, num) (type *)internal::Realloc(ptr, sizeof(type) * num, tag, __FILE__, __LINE__)
+#define XA_FREE(ptr) internal::Realloc(ptr, 0, internal::MemTag::Default, __FILE__, __LINE__)
+#define XA_NEW(tag, type, ...) new (XA_ALLOC(tag, type)) type(__VA_ARGS__)
+
+#define XA_UNUSED(a) ((void)(a))
+
+#define XA_GROW_CHARTS_COPLANAR 1
+#define XA_MERGE_CHARTS 1
+#define XA_MERGE_CHARTS_MIN_NORMAL_DEVIATION 0.5f
+#define XA_RECOMPUTE_CHARTS 1
+#define XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION 0
+
+#define XA_DEBUG_HEAP 0
+#define XA_DEBUG_SINGLE_CHART 0
+#define XA_DEBUG_EXPORT_ATLAS_IMAGES 0
+#define XA_DEBUG_EXPORT_OBJ_SOURCE_MESHES 0
+#define XA_DEBUG_EXPORT_OBJ_CHART_GROUPS 0
+#define XA_DEBUG_EXPORT_OBJ_CHARTS 0
+#define XA_DEBUG_EXPORT_OBJ_BEFORE_FIX_TJUNCTION 0
+#define XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR 0
+#define XA_DEBUG_EXPORT_OBJ_NOT_DISK 0
+#define XA_DEBUG_EXPORT_OBJ_CHARTS_AFTER_PARAMETERIZATION 0
+#define XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION 0
+#define XA_DEBUG_EXPORT_OBJ_RECOMPUTED_CHARTS 0
+
+#define XA_DEBUG_EXPORT_OBJ (0 \
+	|| XA_DEBUG_EXPORT_OBJ_SOURCE_MESHES \
+	|| XA_DEBUG_EXPORT_OBJ_CHART_GROUPS \
+	|| XA_DEBUG_EXPORT_OBJ_CHARTS \
+	|| XA_DEBUG_EXPORT_OBJ_BEFORE_FIX_TJUNCTION \
+	|| XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR \
+	|| XA_DEBUG_EXPORT_OBJ_NOT_DISK \
+	|| XA_DEBUG_EXPORT_OBJ_CHARTS_AFTER_PARAMETERIZATION \
+	|| XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION \
+	|| XA_DEBUG_EXPORT_OBJ_RECOMPUTED_CHARTS)
+
+#ifdef _MSC_VER
+#define XA_FOPEN(_file, _filename, _mode) { if (fopen_s(&_file, _filename, _mode) != 0) _file = NULL; }
+#define XA_SPRINTF(_buffer, _size, _format, ...) sprintf_s(_buffer, _size, _format, __VA_ARGS__)
+#else
+#define XA_FOPEN(_file, _filename, _mode) _file = fopen(_filename, _mode)
+#define XA_SPRINTF(_buffer, _size, _format, ...) sprintf(_buffer, _format, __VA_ARGS__)
+#endif
 
 namespace xatlas {
 namespace internal {
 
-static PrintFunc s_print = NULL;
+static ReallocFunc s_realloc = realloc;
+static PrintFunc s_print = printf;
+static bool s_printVerbose = false;
+
+struct MemTag
+{
+	enum
+	{
+		Default,
+		Mesh,
+		MeshBoundaries,
+		MeshColocals,
+		MeshEdgeMap,
+		MeshIndices,
+		MeshNormals,
+		MeshPositions,
+		MeshTexcoords,
+		Count
+	};
+};
+
+#if XA_DEBUG_HEAP
+struct AllocHeader
+{
+	size_t size;
+	const char *file;
+	int line;
+	int tag;
+	AllocHeader *prev, *next;
+	bool free;
+};
+
+static std::mutex s_allocMutex;
+static AllocHeader *s_allocRoot = nullptr;
+static size_t s_allocTotalSize = 0, s_allocPeakSize = 0, s_allocTotalTagSize[MemTag::Count] = { 0 }, s_allocPeakTagSize[MemTag::Count] = { 0 };
+static constexpr uint32_t kAllocRedzone = 0x12345678;
+
+static void *Realloc(void *ptr, size_t size, int tag, const char *file, int line)
+{
+	std::unique_lock<std::mutex> lock(s_allocMutex);
+	if (!size && !ptr)
+		return nullptr;
+	uint8_t *realPtr = nullptr;
+	AllocHeader *header = nullptr;
+	if (ptr) {
+		realPtr = ((uint8_t *)ptr) - sizeof(AllocHeader);
+		header = (AllocHeader *)realPtr;
+	}
+	if (realPtr && size) {
+		s_allocTotalSize -= header->size;
+		s_allocTotalTagSize[header->tag] -= header->size;
+		// realloc, remove.
+		if (header->prev)
+			header->prev->next = header->next;
+		else
+			s_allocRoot = header->next;
+		if (header->next)
+			header->next->prev = header->prev;
+	}
+	if (!size) {
+		s_allocTotalSize -= header->size;
+		s_allocTotalTagSize[header->tag] -= header->size;
+		XA_ASSERT(!header->free); // double free
+		header->free = true;
+		return nullptr;
+	}
+	size += sizeof(AllocHeader) + sizeof(kAllocRedzone);
+	uint8_t *newPtr = (uint8_t *)s_realloc(realPtr, size);
+	if (!newPtr)
+		return nullptr;
+	header = (AllocHeader *)newPtr;
+	header->size = size;
+	header->file = file;
+	header->line = line;
+	header->tag = tag;
+	header->free = false;
+	if (!s_allocRoot) {
+		s_allocRoot = header;
+		header->prev = header->next = 0;
+	} else {
+		header->prev = nullptr;
+		header->next = s_allocRoot;
+		s_allocRoot = header;
+		header->next->prev = header;
+	}
+	s_allocTotalSize += size;
+	if (s_allocTotalSize > s_allocPeakSize)
+		s_allocPeakSize = s_allocTotalSize;
+	s_allocTotalTagSize[tag] += size;
+	if (s_allocTotalTagSize[tag] > s_allocPeakTagSize[tag])
+		s_allocPeakTagSize[tag] = s_allocTotalTagSize[tag];
+	auto redzone = (uint32_t *)(newPtr + size - sizeof(kAllocRedzone));
+	*redzone = kAllocRedzone;
+	return newPtr + sizeof(AllocHeader);
+}
+
+static void ReportLeaks()
+{
+	printf("Checking for memory leaks...\n");
+	bool anyLeaks = false;
+	AllocHeader *header = s_allocRoot;
+	while (header) {
+		if (!header->free) {
+			printf("   Leak: %zu bytes %s %d\n", header->size, header->file, header->line);
+			anyLeaks = true;
+		}
+		auto redzone = (const uint32_t *)((const uint8_t *)header + header->size - sizeof(kAllocRedzone));
+		if (*redzone != kAllocRedzone)
+			printf("   Redzone corrupted: %zu bytes %s %d\n", header->size, header->file, header->line);
+		header = header->next;
+	}
+	if (!anyLeaks)
+		printf("   No memory leaks\n");
+	header = s_allocRoot;
+	while (header) {
+		AllocHeader *destroy = header;
+		header = header->next;
+		s_realloc(destroy, 0);
+	}
+	s_allocRoot = nullptr;
+	s_allocTotalSize = s_allocPeakSize = 0;
+	for (int i = 0; i < MemTag::Count; i++)
+		s_allocTotalTagSize[i] = s_allocPeakTagSize[i] = 0;
+}
+
+static void PrintMemoryUsage()
+{
+	XA_PRINT("Memory usage: %0.2fMB current, %0.2fMB peak\n", internal::s_allocTotalSize / 1024.0f / 1024.0f, internal::s_allocPeakSize / 1024.0f / 1024.0f);
+	static const char *labels[] = { // Sync with MemTag
+		"Default",
+		"Mesh",
+		"MeshBoundaries",
+		"MeshColocals",
+		"MeshEdgeMap",
+		"MeshIndices",
+		"MeshNormals",
+		"MeshPositions",
+		"MeshTexcoords"
+	};
+	for (int i = 0; i < MemTag::Count; i++) {
+		XA_PRINT("   %s: %0.2fMB current, %0.2fMB peak\n", labels[i], internal::s_allocTotalTagSize[i] / 1024.0f / 1024.0f, internal::s_allocPeakTagSize[i] / 1024.0f / 1024.0f);
+	}
+}
+
+#define XA_PRINT_MEM_USAGE internal::PrintMemoryUsage();
+#else
+static void *Realloc(void *ptr, size_t size, int /*tag*/, const char * /*file*/, int /*line*/)
+{
+	void *mem = s_realloc(ptr, size);
+	if (size > 0) {
+		XA_DEBUG_ASSERT(mem);
+	}
+	return mem;
+}
+#define XA_PRINT_MEM_USAGE
+#endif
+
+#if XA_PROFILE
+#define XA_PROFILE_START(var) const clock_t var##Start = clock();
+#define XA_PROFILE_END(var) internal::s_profile.var += clock() - var##Start;
+#define XA_PROFILE_PRINT(label, var) XA_PRINT("%s%.2f seconds (%g ms)\n", label, internal::clockToSeconds(internal::s_profile.var), internal::clockToMs(internal::s_profile.var));
+
+struct ProfileData
+{
+	clock_t addMeshConcurrent;
+	std::atomic<clock_t> addMesh;
+	std::atomic<clock_t> addMeshCreateColocals;
+	std::atomic<clock_t> addMeshCreateFaceGroups;
+	std::atomic<clock_t> addMeshCreateBoundaries;
+	std::atomic<clock_t> addMeshCreateChartGroupsConcurrent;
+	std::atomic<clock_t> addMeshCreateChartGroups;
+	clock_t computeChartsConcurrent;
+	std::atomic<clock_t> computeCharts;
+	std::atomic<clock_t> atlasBuilder;
+	std::atomic<clock_t> atlasBuilderInit;
+	std::atomic<clock_t> atlasBuilderCreateInitialCharts;
+	std::atomic<clock_t> atlasBuilderGrowCharts;
+	std::atomic<clock_t> atlasBuilderMergeCharts;
+	std::atomic<clock_t> createChartMeshes;
+	std::atomic<clock_t> fixChartMeshTJunctions;
+	std::atomic<clock_t> closeChartMeshHoles;
+	clock_t parameterizeChartsConcurrent;
+	std::atomic<clock_t> parameterizeCharts;
+	std::atomic<clock_t> parameterizeChartsOrthogonal;
+	std::atomic<clock_t> parameterizeChartsLSCM;
+	std::atomic<clock_t> parameterizeChartsEvaluateQuality;
+	clock_t packCharts;
+	clock_t packChartsRasterize;
+	clock_t packChartsDilate;
+	clock_t packChartsFindLocation;
+	clock_t packChartsBlit;
+};
+
+static ProfileData s_profile;
+
+static double clockToMs(clock_t c)
+{
+	return c * 1000.0 / CLOCKS_PER_SEC;
+}
+
+static double clockToSeconds(clock_t c)
+{
+	return c / (double)CLOCKS_PER_SEC;
+}
+#else
+#define XA_PROFILE_START(var)
+#define XA_PROFILE_END(var)
+#define XA_PROFILE_PRINT(label, var)
+#endif
+
+static constexpr float kPi = 3.14159265358979323846f;
+static constexpr float kPi2 = 6.28318530717958647692f;
+static constexpr float kEpsilon = 0.0001f;
+static constexpr float kAreaEpsilon = FLT_EPSILON;
+static constexpr float kNormalEpsilon = 0.001f;
 
 static int align(int x, int a)
 {
 	return (x + a - 1) & ~(a - 1);
 }
 
-static bool isAligned(int x, int a)
+template <typename T>
+static T max(const T &a, const T &b)
 {
-	return (x & (a - 1)) == 0;
+	return a > b ? a : b;
+}
+
+template <typename T>
+static T min(const T &a, const T &b)
+{
+	return a < b ? a : b;
 }
 
-/// Return the maximum of the three arguments.
 template <typename T>
 static T max3(const T &a, const T &b, const T &c)
 {
-	return std::max(a, std::max(b, c));
+	return max(a, max(b, c));
 }
 
 /// Return the maximum of the three arguments.
 template <typename T>
 static T min3(const T &a, const T &b, const T &c)
 {
-	return std::min(a, std::min(b, c));
+	return min(a, min(b, c));
 }
 
 /// Clamp between two values.
 template <typename T>
 static T clamp(const T &x, const T &a, const T &b)
 {
-	return std::min(std::max(x, a), b);
+	return min(max(x, a), b);
 }
 
-static float saturate(float f)
+template <typename T>
+static void swap(T &a, T &b)
 {
-	return clamp(f, 0.0f, 1.0f);
+	T temp;
+	temp = a;
+	a = b;
+	b = temp;
+	temp = T();
 }
 
-// Robust floating point comparisons:
-// http://realtimecollisiondetection.net/blog/?p=89
-static bool equal(const float f0, const float f1, const float epsilon = NV_EPSILON)
+union FloatUint32
 {
-	//return fabs(f0-f1) <= epsilon;
-	return fabs(f0 - f1) <= epsilon * max3(1.0f, fabsf(f0), fabsf(f1));
-}
+	float f;
+	uint32_t u;
+};
 
-NV_FORCEINLINE static int ftoi_floor(float val)
+static bool isFinite(float f)
 {
-	return (int)val;
+	FloatUint32 fu;
+	fu.f = f;
+	return fu.u != 0x7F800000u && fu.u != 0x7F800001u;
 }
 
-NV_FORCEINLINE static int ftoi_ceil(float val)
+static bool isNan(float f)
 {
-	return (int)ceilf(val);
+	return f != f;
 }
 
-NV_FORCEINLINE static int ftoi_round(float f)
+// Robust floating point comparisons:
+// http://realtimecollisiondetection.net/blog/?p=89
+static bool equal(const float f0, const float f1, const float epsilon)
 {
-	return int(floorf(f + 0.5f));
+	//return fabs(f0-f1) <= epsilon;
+	return fabs(f0 - f1) <= epsilon * max3(1.0f, fabsf(f0), fabsf(f1));
 }
 
-static bool isZero(const float f, const float epsilon = NV_EPSILON)
+static int ftoi_ceil(float val)
 {
-	return fabs(f) <= epsilon;
+	return (int)ceilf(val);
 }
 
-static float lerp(float f0, float f1, float t)
+static bool isZero(const float f, const float epsilon)
 {
-	const float s = 1.0f - t;
-	return f0 * s + f1 * t;
+	return fabs(f) <= epsilon;
 }
 
 static float square(float f)
@@ -130,11 +443,6 @@ static float square(float f)
 	return f * f;
 }
 
-static int square(int i)
-{
-	return i * i;
-}
-
 /** Return the next power of two.
 * @see http://graphics.stanford.edu/~seander/bithacks.html
 * @warning Behaviour for 0 is undefined.
@@ -143,7 +451,7 @@ static int square(int i)
 */
 static uint32_t nextPowerOfTwo(uint32_t x)
 {
-	xaDebugAssert( x != 0 );
+	XA_DEBUG_ASSERT( x != 0 );
 	// On modern CPUs this is supposed to be as fast as using the bsr instruction.
 	x--;
 	x |= x >> 1;
@@ -154,16 +462,6 @@ static uint32_t nextPowerOfTwo(uint32_t x)
 	return x + 1;
 }
 
-static uint64_t nextPowerOfTwo(uint64_t x)
-{
-	xaDebugAssert(x != 0);
-	uint32_t p = 1;
-	while (x > p) {
-		p += p;
-	}
-	return p;
-}
-
 static uint32_t sdbmHash(const void *data_in, uint32_t size, uint32_t h = 5381)
 {
 	const uint8_t *data = (const uint8_t *) data_in;
@@ -174,31 +472,12 @@ static uint32_t sdbmHash(const void *data_in, uint32_t size, uint32_t h = 5381)
 	return h;
 }
 
-// Note that this hash does not handle NaN properly.
-static uint32_t sdbmFloatHash(const float *f, uint32_t count, uint32_t h = 5381)
-{
-	for (uint32_t i = 0; i < count; i++) {
-		union {
-			float f;
-			uint32_t i;
-		} x = { f[i] };
-		if (x.i == 0x80000000) x.i = 0;
-		h = sdbmHash(&x, 4, h);
-	}
-	return h;
-}
-
 template <typename T>
 static uint32_t hash(const T &t, uint32_t h = 5381)
 {
 	return sdbmHash(&t, sizeof(T), h);
 }
 
-static uint32_t hash(const float &f, uint32_t h)
-{
-	return sdbmFloatHash(&f, 1, h);
-}
-
 // Functors for hash table:
 template <typename Key> struct Hash
 {
@@ -213,40 +492,22 @@ template <typename Key> struct Equal
 class Vector2
 {
 public:
-	typedef Vector2 const &Arg;
-
 	Vector2() {}
 	explicit Vector2(float f) : x(f), y(f) {}
 	Vector2(float x, float y): x(x), y(y) {}
-	Vector2(Vector2::Arg v) : x(v.x), y(v.y) {}
-
-	const Vector2 &operator=(Vector2::Arg v)
-	{
-		x = v.x;
-		y = v.y;
-		return
-			*this;
-	}
-	const float *ptr() const { return &x; }
-
-	void set(float _x, float _y)
-	{
-		x = _x;
-		y = _y;
-	}
 
 	Vector2 operator-() const
 	{
 		return Vector2(-x, -y);
 	}
 
-	void operator+=(Vector2::Arg v)
+	void operator+=(const Vector2 &v)
 	{
 		x += v.x;
 		y += v.y;
 	}
 
-	void operator-=(Vector2::Arg v)
+	void operator-=(const Vector2 &v)
 	{
 		x -= v.x;
 		y -= v.y;
@@ -258,138 +519,99 @@ public:
 		y *= s;
 	}
 
-	void operator*=(Vector2::Arg v)
+	void operator*=(const Vector2 &v)
 	{
 		x *= v.x;
 		y *= v.y;
 	}
 
-	friend bool operator==(Vector2::Arg a, Vector2::Arg b)
-	{
-		return a.x == b.x && a.y == b.y;
-	}
-
-	friend bool operator!=(Vector2::Arg a, Vector2::Arg b)
-	{
-		return a.x != b.x || a.y != b.y;
-	}
-
-	union
-	{
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4201)
-#endif
-		struct
-		{
-			float x, y;
-		};
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-		float component[2];
-	};
+	float x, y;
 };
 
-Vector2 operator+(Vector2::Arg a, Vector2::Arg b)
+static bool operator==(const Vector2 &a, const Vector2 &b)
 {
-	return Vector2(a.x + b.x, a.y + b.y);
+	return a.x == b.x && a.y == b.y;
 }
 
-Vector2 operator-(Vector2::Arg a, Vector2::Arg b)
+static bool operator!=(const Vector2 &a, const Vector2 &b)
 {
-	return Vector2(a.x - b.x, a.y - b.y);
+	return a.x != b.x || a.y != b.y;
 }
 
-Vector2 operator*(Vector2::Arg v, float s)
+static Vector2 operator+(const Vector2 &a, const Vector2 &b)
 {
-	return Vector2(v.x * s, v.y * s);
-}
-
-Vector2 operator*(Vector2::Arg v1, Vector2::Arg v2)
-{
-	return Vector2(v1.x * v2.x, v1.y * v2.y);
+	return Vector2(a.x + b.x, a.y + b.y);
 }
 
-Vector2 operator/(Vector2::Arg v, float s)
+static Vector2 operator-(const Vector2 &a, const Vector2 &b)
 {
-	return Vector2(v.x / s, v.y / s);
+	return Vector2(a.x - b.x, a.y - b.y);
 }
 
-Vector2 lerp(Vector2::Arg v1, Vector2::Arg v2, float t)
+static Vector2 operator*(const Vector2 &v, float s)
 {
-	const float s = 1.0f - t;
-	return Vector2(v1.x * s + t * v2.x, v1.y * s + t * v2.y);
+	return Vector2(v.x * s, v.y * s);
 }
 
-float dot(Vector2::Arg a, Vector2::Arg b)
+static float dot(const Vector2 &a, const Vector2 &b)
 {
 	return a.x * b.x + a.y * b.y;
 }
 
-float lengthSquared(Vector2::Arg v)
+static float lengthSquared(const Vector2 &v)
 {
 	return v.x * v.x + v.y * v.y;
 }
 
-float length(Vector2::Arg v)
+static float length(const Vector2 &v)
 {
 	return sqrtf(lengthSquared(v));
 }
 
-float distance(Vector2::Arg a, Vector2::Arg b)
-{
-	return length(a - b);
-}
-
-bool isNormalized(Vector2::Arg v, float epsilon = NV_NORMAL_EPSILON)
+#if XA_DEBUG
+static bool isNormalized(const Vector2 &v, float epsilon = kNormalEpsilon)
 {
 	return equal(length(v), 1, epsilon);
 }
+#endif
 
-Vector2 normalize(Vector2::Arg v, float epsilon = NV_EPSILON)
+static Vector2 normalize(const Vector2 &v, float epsilon)
 {
 	float l = length(v);
-	xaDebugAssert(!isZero(l, epsilon));
-#ifdef NDEBUG
-	epsilon = 0; // silence unused parameter warning
-#endif
+	XA_DEBUG_ASSERT(!isZero(l, epsilon));
+	XA_UNUSED(epsilon);
 	Vector2 n = v * (1.0f / l);
-	xaDebugAssert(isNormalized(n));
+	XA_DEBUG_ASSERT(isNormalized(n));
 	return n;
 }
 
-Vector2 normalizeSafe(Vector2::Arg v, Vector2::Arg fallback, float epsilon = NV_EPSILON)
+static bool equal(const Vector2 &v1, const Vector2 &v2, float epsilon)
 {
-	float l = length(v);
-	if (isZero(l, epsilon)) {
-		return fallback;
-	}
-	return v * (1.0f / l);
+	return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon);
 }
 
-bool equal(Vector2::Arg v1, Vector2::Arg v2, float epsilon = NV_EPSILON)
+static Vector2 min(const Vector2 &a, const Vector2 &b)
 {
-	return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon);
+	return Vector2(min(a.x, b.x), min(a.y, b.y));
 }
 
-Vector2 max(Vector2::Arg a, Vector2::Arg b)
+static Vector2 max(const Vector2 &a, const Vector2 &b)
 {
-	return Vector2(std::max(a.x, b.x), std::max(a.y, b.y));
+	return Vector2(max(a.x, b.x), max(a.y, b.y));
 }
 
-bool isFinite(Vector2::Arg v)
+static bool isFinite(const Vector2 &v)
 {
-	return std::isfinite(v.x) && std::isfinite(v.y);
+	return isFinite(v.x) && isFinite(v.y);
 }
 
 // Note, this is the area scaled by 2!
-float triangleArea(Vector2::Arg v0, Vector2::Arg v1)
+static float triangleArea(const Vector2 &v0, const Vector2 &v1)
 {
 	return (v0.x * v1.y - v0.y * v1.x); // * 0.5f;
 }
-float triangleArea(Vector2::Arg a, Vector2::Arg b, Vector2::Arg c)
+
+static float triangleArea(const Vector2 &a, const Vector2 &b, const Vector2 &c)
 {
 	// IC: While it may be appealing to use the following expression:
 	//return (c.x * a.y + a.x * b.y + b.x * c.y - b.x * a.y - c.x * b.y - a.x * c.y); // * 0.5f;
@@ -402,62 +624,54 @@ float triangleArea(Vector2::Arg a, Vector2::Arg b, Vector2::Arg c)
 	return triangleArea(a - c, b - c);
 }
 
-float triangleArea2(Vector2::Arg v1, Vector2::Arg v2, Vector2::Arg v3)
+static bool linesIntersect(const Vector2 &a1, const Vector2 &a2, const Vector2 &b1, const Vector2 &b2, float epsilon)
 {
-	return 0.5f * (v3.x * v1.y + v1.x * v2.y + v2.x * v3.y - v2.x * v1.y - v3.x * v2.y - v1.x * v3.y);
+	const Vector2 v0 = a2 - a1;
+	const Vector2 v1 = b2 - b1;
+	const float denom = -v1.x * v0.y + v0.x * v1.y;
+	if (equal(denom, 0.0f, epsilon))
+		return false;
+	const float s = (-v0.y * (a1.x - b1.x) + v0.x * (a1.y - b1.y)) / denom;
+	if (s > epsilon && s < 1.0f - epsilon) {
+		const float t = ( v1.x * (a1.y - b1.y) - v1.y * (a1.x - b1.x)) / denom;
+		return t > epsilon && t < 1.0f - epsilon;
+	}
+	return false;
 }
 
-static uint32_t hash(const Vector2 &v, uint32_t h)
+struct Vector2i
 {
-	return sdbmFloatHash(v.component, 2, h);
-}
+	Vector2i(int32_t x, int32_t y) : x(x), y(y) {}
+
+	int32_t x, y;
+};
 
 class Vector3
 {
 public:
-	typedef Vector3 const &Arg;
-
 	Vector3() {}
 	explicit Vector3(float f) : x(f), y(f), z(f) {}
 	Vector3(float x, float y, float z) : x(x), y(y), z(z) {}
-	Vector3(Vector2::Arg v, float z) : x(v.x), y(v.y), z(z) {}
-	Vector3(Vector3::Arg v) : x(v.x), y(v.y), z(v.z) {}
-
-	const Vector3 &operator=(Vector3::Arg v)
-	{
-		x = v.x;
-		y = v.y;
-		z = v.z;
-		return *this;
-	}
+	Vector3(const Vector2 &v, float z) : x(v.x), y(v.y), z(z) {}
 
 	Vector2 xy() const
 	{
 		return Vector2(x, y);
 	}
 
-	const float *ptr() const { return &x; }
-
-	void set(float _x, float _y, float _z)
-	{
-		x = _x;
-		y = _y;
-		z = _z;
-	}
-
 	Vector3 operator-() const
 	{
 		return Vector3(-x, -y, -z);
 	}
 
-	void operator+=(Vector3::Arg v)
+	void operator+=(const Vector3 &v)
 	{
 		x += v.x;
 		y += v.y;
 		z += v.z;
 	}
 
-	void operator-=(Vector3::Arg v)
+	void operator-=(const Vector3 &v)
 	{
 		x -= v.x;
 		y -= v.y;
@@ -479,159 +693,89 @@ public:
 		z *= is;
 	}
 
-	void operator*=(Vector3::Arg v)
+	void operator*=(const Vector3 &v)
 	{
 		x *= v.x;
 		y *= v.y;
 		z *= v.z;
 	}
 
-	void operator/=(Vector3::Arg v)
+	void operator/=(const Vector3 &v)
 	{
 		x /= v.x;
 		y /= v.y;
 		z /= v.z;
 	}
 
-	friend bool operator==(Vector3::Arg a, Vector3::Arg b)
-	{
-		return a.x == b.x && a.y == b.y && a.z == b.z;
-	}
-
-	friend bool operator!=(Vector3::Arg a, Vector3::Arg b)
-	{
-		return a.x != b.x || a.y != b.y || a.z != b.z;
-	}
-
-	union
-	{
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4201)
-#endif
-		struct
-		{
-			float x, y, z;
-		};
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-		float component[3];
-	};
+	float x, y, z;
 };
 
-Vector3 add(Vector3::Arg a, Vector3::Arg b)
-{
-	return Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
-}
-Vector3 add(Vector3::Arg a, float b)
-{
-	return Vector3(a.x + b, a.y + b, a.z + b);
-}
-Vector3 operator+(Vector3::Arg a, Vector3::Arg b)
+static bool operator!=(const Vector3 &a, const Vector3 &b)
 {
-	return add(a, b);
-}
-Vector3 operator+(Vector3::Arg a, float b)
-{
-	return add(a, b);
+	return a.x != b.x || a.y != b.y || a.z != b.z;
 }
 
-Vector3 sub(Vector3::Arg a, Vector3::Arg b)
+static Vector3 operator+(const Vector3 &a, const Vector3 &b)
 {
-	return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
-}
-
-Vector3 sub(Vector3::Arg a, float b)
-{
-	return Vector3(a.x - b, a.y - b, a.z - b);
-}
-
-Vector3 operator-(Vector3::Arg a, Vector3::Arg b)
-{
-	return sub(a, b);
+	return Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
 }
 
-Vector3 operator-(Vector3::Arg a, float b)
+static Vector3 operator-(const Vector3 &a, const Vector3 &b)
 {
-	return sub(a, b);
+	return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
 }
 
-Vector3 cross(Vector3::Arg a, Vector3::Arg b)
+static Vector3 cross(const Vector3 &a, const Vector3 &b)
 {
 	return Vector3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
 }
 
-Vector3 operator*(Vector3::Arg v, float s)
+static Vector3 operator*(const Vector3 &v, float s)
 {
 	return Vector3(v.x * s, v.y * s, v.z * s);
 }
 
-Vector3 operator*(float s, Vector3::Arg v)
+static Vector3 operator*(float s, const Vector3 &v)
 {
 	return Vector3(v.x * s, v.y * s, v.z * s);
 }
 
-Vector3 operator*(Vector3::Arg v, Vector3::Arg s)
-{
-	return Vector3(v.x * s.x, v.y * s.y, v.z * s.z);
-}
-
-Vector3 operator/(Vector3::Arg v, float s)
+static Vector3 operator/(const Vector3 &v, float s)
 {
 	return v * (1.0f / s);
 }
 
-Vector3 lerp(Vector3::Arg v1, Vector3::Arg v2, float t)
-{
-	const float s = 1.0f - t;
-	return Vector3(v1.x * s + t * v2.x, v1.y * s + t * v2.y, v1.z * s + t * v2.z);
-}
-
-float dot(Vector3::Arg a, Vector3::Arg b)
+static float dot(const Vector3 &a, const Vector3 &b)
 {
 	return a.x * b.x + a.y * b.y + a.z * b.z;
 }
 
-float lengthSquared(Vector3::Arg v)
+static float lengthSquared(const Vector3 &v)
 {
 	return v.x * v.x + v.y * v.y + v.z * v.z;
 }
 
-float length(Vector3::Arg v)
+static float length(const Vector3 &v)
 {
 	return sqrtf(lengthSquared(v));
 }
 
-float distance(Vector3::Arg a, Vector3::Arg b)
-{
-	return length(a - b);
-}
-
-float distanceSquared(Vector3::Arg a, Vector3::Arg b)
-{
-	return lengthSquared(a - b);
-}
-
-bool isNormalized(Vector3::Arg v, float epsilon = NV_NORMAL_EPSILON)
+static bool isNormalized(const Vector3 &v, float epsilon = kNormalEpsilon)
 {
 	return equal(length(v), 1, epsilon);
 }
 
-Vector3 normalize(Vector3::Arg v, float epsilon = NV_EPSILON)
+static Vector3 normalize(const Vector3 &v, float epsilon)
 {
 	float l = length(v);
-	xaDebugAssert(!isZero(l, epsilon));
-#ifdef NDEBUG
-	epsilon = 0; // silence unused parameter warning
-#endif
+	XA_DEBUG_ASSERT(!isZero(l, epsilon));
+	XA_UNUSED(epsilon);
 	Vector3 n = v * (1.0f / l);
-	xaDebugAssert(isNormalized(n));
+	XA_DEBUG_ASSERT(isNormalized(n));
 	return n;
 }
 
-Vector3 normalizeSafe(Vector3::Arg v, Vector3::Arg fallback, float epsilon = NV_EPSILON)
+static Vector3 normalizeSafe(const Vector3 &v, const Vector3 &fallback, float epsilon)
 {
 	float l = length(v);
 	if (isZero(l, epsilon)) {
@@ -640,57 +784,423 @@ Vector3 normalizeSafe(Vector3::Arg v, Vector3::Arg fallback, float epsilon = NV_
 	return v * (1.0f / l);
 }
 
-bool equal(Vector3::Arg v1, Vector3::Arg v2, float epsilon = NV_EPSILON)
+static bool equal(const Vector3 &v0, const Vector3 &v1, float epsilon)
 {
-	return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon) && equal(v1.z, v2.z, epsilon);
+	return fabs(v0.x - v1.x) <= epsilon && fabs(v0.y - v1.y) <= epsilon && fabs(v0.z - v1.z) <= epsilon;
 }
 
-Vector3 min(Vector3::Arg a, Vector3::Arg b)
+static Vector3 min(const Vector3 &a, const Vector3 &b)
 {
-	return Vector3(std::min(a.x, b.x), std::min(a.y, b.y), std::min(a.z, b.z));
+	return Vector3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
 }
 
-Vector3 max(Vector3::Arg a, Vector3::Arg b)
+static Vector3 max(const Vector3 &a, const Vector3 &b)
 {
-	return Vector3(std::max(a.x, b.x), std::max(a.y, b.y), std::max(a.z, b.z));
+	return Vector3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
 }
 
-Vector3 clamp(Vector3::Arg v, float min, float max)
+#if XA_DEBUG
+bool isFinite(const Vector3 &v)
 {
-	return Vector3(clamp(v.x, min, max), clamp(v.y, min, max), clamp(v.z, min, max));
+	return isFinite(v.x) && isFinite(v.y) && isFinite(v.z);
 }
+#endif
 
-Vector3 saturate(Vector3::Arg v)
+struct Plane
 {
-	return Vector3(saturate(v.x), saturate(v.y), saturate(v.z));
+	Plane() = default;
+	
+	Plane(const Vector3 &p1, const Vector3 &p2, const Vector3 &p3)
+	{
+		normal = cross(p2 - p1, p3 - p1);
+		dist = dot(normal, p1);
+	}
+
+	float distance(const Vector3 &p) const
+	{
+		return dot(normal, p) - dist;
+	}
+
+	void normalize()
+	{
+		const float len = length(normal);
+		if (len > 0.0f) {
+			const float il = 1.0f / len;
+			normal *= il;
+			dist *= il;
+		}
+	}
+
+	Vector3 normal;
+	float dist;
+};
+
+static bool lineIntersectsPoint(const Vector3 &point, const Vector3 &lineStart, const Vector3 &lineEnd, float *t, float epsilon)
+{
+	float tt;
+	if (!t)
+		t = &tt;
+	*t = 0.0f;
+	if (equal(lineStart, point, epsilon) || equal(lineEnd, point, epsilon))
+		return false; // Vertex lies on either line vertices.
+	const Vector3 v01 = point - lineStart;
+	const Vector3 v21 = lineEnd - lineStart;
+	const float l = length(v21);
+	const float d = length(cross(v01, v21)) / l;
+	if (!isZero(d, epsilon))
+		return false;
+	*t = dot(v01, v21) / (l * l);
+	return *t > kEpsilon && *t < 1.0f - kEpsilon;
 }
 
-Vector3 floor(Vector3::Arg v)
+static bool sameSide(const Vector3 &p1, const Vector3 &p2, const Vector3 &a, const Vector3 &b)
 {
-	return Vector3(floorf(v.x), floorf(v.y), floorf(v.z));
+	const Vector3 &ab = b - a;
+	return dot(cross(ab, p1 - a), cross(ab, p2 - a)) >= 0.0f;
 }
 
-bool isFinite(Vector3::Arg v)
+// http://blackpawn.com/texts/pointinpoly/default.html
+static bool pointInTriangle(const Vector3 &p, const Vector3 &a, const Vector3 &b, const Vector3 &c)
 {
-	return std::isfinite(v.x) && std::isfinite(v.y) && std::isfinite(v.z);
+	return sameSide(p, a, b, c) && sameSide(p, b, a, c) && sameSide(p, c, a, b);
 }
 
-static uint32_t hash(const Vector3 &v, uint32_t h)
+#if XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION
+// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+static bool rayIntersectsTriangle(const Vector3 &rayOrigin, const Vector3 &rayDir, const Vector3 *tri, float *t)
+{
+	*t = 0.0f;
+	const Vector3 &edge1 = tri[1] - tri[0];
+	const Vector3 &edge2 = tri[2] - tri[0];
+	const Vector3 h = cross(rayDir, edge2);
+	const float a = dot(edge1, h);
+	if (a > -kEpsilon && a < kEpsilon)
+		return false; // This ray is parallel to this triangle.
+	const float f = 1.0f / a;
+	const Vector3 s = rayOrigin - tri[0];
+	const float u = f * dot(s, h);
+	if (u < 0.0f || u > 1.0f)
+		return false;
+	const Vector3 q = cross(s, edge1);
+	const float v = f * dot(rayDir, q);
+	if (v < 0.0f || u + v > 1.0f)
+		return false;
+	// At this stage we can compute t to find out where the intersection point is on the line.
+	*t = f * dot(edge2, q);
+	if (*t > kEpsilon && *t < 1.0f - kEpsilon)
+		return true;
+	// This means that there is a line intersection but not a ray intersection.
+	return false;
+}
+#endif
+
+// From Fast-BVH
+struct AABB
 {
-	return sdbmFloatHash(v.component, 3, h);
+	AABB() : min(FLT_MAX, FLT_MAX, FLT_MAX), max(-FLT_MAX, -FLT_MAX, -FLT_MAX) {}
+	AABB(const Vector3 &min, const Vector3 &max) : min(min), max(max) { }
+	AABB(const Vector3 &p, float radius = 0.0f) : min(p), max(p) { if (radius > 0.0f) expand(radius); }
+
+	bool intersect(const AABB &other) const
+	{
+		return min.x <= other.max.x && max.x >= other.min.x && min.y <= other.max.y && max.y >= other.min.y && min.z <= other.max.z && max.z >= other.min.z;
+	}
+
+	void expandToInclude(const Vector3 &p)
+	{
+		min = internal::min(min, p);
+		max = internal::max(max, p);
+	}
+
+	void expandToInclude(const AABB &aabb)
+	{
+		min = internal::min(min, aabb.min);
+		max = internal::max(max, aabb.max);
+	}
+
+	void expand(float amount)
+	{
+		min -= Vector3(amount);
+		max += Vector3(amount);
+	}
+
+	Vector3 centroid() const
+	{
+		return min + (max - min) * 0.5f;
+	}
+
+	uint32_t maxDimension() const
+	{
+		const Vector3 extent = max - min;
+		uint32_t result = 0;
+		if (extent.y > extent.x) {
+			result = 1;
+			if (extent.z > extent.y)
+				result = 2;
+		}
+		else if(extent.z > extent.x)
+			result = 2;
+		return result;
+	}
+
+	Vector3 min, max;
+};
+
+template <typename T>
+static void construct_range(T * ptr, uint32_t new_size, uint32_t old_size) {
+	for (uint32_t i = old_size; i < new_size; i++) {
+		new(ptr+i) T; // placement new
+	}
+}
+
+template <typename T>
+static void construct_range(T * ptr, uint32_t new_size, uint32_t old_size, const T & elem) {
+	for (uint32_t i = old_size; i < new_size; i++) {
+		new(ptr+i) T(elem); // placement new
+	}
 }
 
+template <typename T>
+static void construct_range(T * ptr, uint32_t new_size, uint32_t old_size, const T * src) {
+	for (uint32_t i = old_size; i < new_size; i++) {
+		new(ptr+i) T(src[i]); // placement new
+	}
+}
+
+template <typename T>
+static void destroy_range(T * ptr, uint32_t new_size, uint32_t old_size) {
+	for (uint32_t i = new_size; i < old_size; i++) {
+		(ptr+i)->~T(); // Explicit call to the destructor
+	}
+}
+
+/**
+* Replacement for std::vector that is easier to debug and provides
+* some nice foreach enumerators. 
+*/
+template<typename T>
+class Array {
+public:
+	typedef uint32_t size_type;
+
+	Array(int memTag = MemTag::Default) : m_memTag(memTag), m_buffer(nullptr), m_capacity(0), m_size(0) {}
+
+	Array(const Array &a) : m_memTag(a.m_memTag), m_buffer(nullptr), m_capacity(0), m_size(0)
+	{
+		copy(a.m_buffer, a.m_size);
+	}
+
+	~Array()
+	{
+		destroy();
+	}
+
+	const Array<T> &operator=(const Array<T> &other)
+	{
+		m_memTag = other.m_memTag;
+		m_buffer = other.m_buffer;
+		m_capacity = other.m_capacity;
+		m_size = other.m_size;
+		return *this;
+	}
+
+	const T & operator[]( uint32_t index ) const
+	{
+		XA_DEBUG_ASSERT(index < m_size);
+		return m_buffer[index];
+	}
+	
+	T & operator[] ( uint32_t index )
+	{
+		XA_DEBUG_ASSERT(index < m_size);
+		return m_buffer[index];
+	}
+
+	uint32_t size() const { return m_size; }
+	const T * data() const { return m_buffer; }
+	T * data() { return m_buffer; }
+	T * begin() { return m_buffer; }
+	T * end() { return m_buffer + m_size; }
+	const T * begin() const { return m_buffer; }
+	const T * end() const { return m_buffer + m_size; }
+	bool isEmpty() const { return m_size == 0; }
+
+	void push_back( const T & val )
+	{
+		XA_DEBUG_ASSERT(&val < m_buffer || &val >= m_buffer+m_size);
+		uint32_t old_size = m_size;
+		uint32_t new_size = m_size + 1;
+		setArraySize(new_size);
+		construct_range(m_buffer, new_size, old_size, val);
+	}
+
+	void pop_back()
+	{
+		XA_DEBUG_ASSERT( m_size > 0 );
+		resize( m_size - 1 );
+	}
+
+	const T & back() const
+	{
+		XA_DEBUG_ASSERT( m_size > 0 );
+		return m_buffer[m_size-1];
+	}
+
+	T & back()
+	{
+		XA_DEBUG_ASSERT( m_size > 0 );
+		return m_buffer[m_size-1];
+	}
+
+	const T & front() const
+	{
+		XA_DEBUG_ASSERT( m_size > 0 );
+		return m_buffer[0];
+	}
+
+	T & front()
+	{
+		XA_DEBUG_ASSERT( m_size > 0 );
+		return m_buffer[0];
+	}
+
+	// Remove the element at the given index. This is an expensive operation!
+	void removeAt(uint32_t index)
+	{
+		XA_DEBUG_ASSERT(index >= 0 && index < m_size);
+		if (m_size == 1) {
+			clear();
+		}
+		else {
+			m_buffer[index].~T();
+			memmove(m_buffer+index, m_buffer+index+1, sizeof(T) * (m_size - 1 - index));
+			m_size--;
+		}
+	}
+
+	// Insert the given element at the given index shifting all the elements up.
+	void insertAt(uint32_t index, const T & val = T())
+	{
+		XA_DEBUG_ASSERT( index >= 0 && index <= m_size );
+		setArraySize(m_size + 1);
+		if (index < m_size - 1) {
+			memmove(m_buffer+index+1, m_buffer+index, sizeof(T) * (m_size - 1 - index));
+		}
+		// Copy-construct into the newly opened slot.
+		new(m_buffer+index) T(val);
+	}
+
+	void append(const Array<T> & other)
+	{
+		append(other.m_buffer, other.m_size);
+	}
+
+	void resize(uint32_t new_size)
+	{
+		uint32_t old_size = m_size;
+		// Destruct old elements (if we're shrinking).
+		destroy_range(m_buffer, new_size, old_size);
+		setArraySize(new_size);
+		// Call default constructors
+		construct_range(m_buffer, new_size, old_size);
+	}
+
+	void resize(uint32_t new_size, const T & elem)
+	{
+		XA_DEBUG_ASSERT(&elem < m_buffer || &elem > m_buffer+m_size);
+		uint32_t old_size = m_size;
+		// Destruct old elements (if we're shrinking).
+		destroy_range(m_buffer, new_size, old_size);
+		setArraySize(new_size);
+		// Call copy constructors
+		construct_range(m_buffer, new_size, old_size, elem);
+	}
+
+	void clear()
+	{
+		// Destruct old elements
+		destroy_range(m_buffer, 0, m_size);
+		m_size = 0;
+	}
+
+	void destroy()
+	{
+		clear();
+		XA_FREE(m_buffer);
+		m_buffer = nullptr;
+		m_capacity = 0;
+		m_size = 0;
+	}
+
+	void reserve(uint32_t desired_size)
+	{
+		if (desired_size > m_capacity) {
+			setArrayCapacity(desired_size);
+		}
+	}
+
+	void copy(const T * data, uint32_t count)
+	{
+		destroy_range(m_buffer, 0, m_size);
+		setArraySize(count);
+		construct_range(m_buffer, count, 0, data);
+	}
+
+	void moveTo(Array<T> &other)
+	{
+		other.destroy();
+		swap(m_buffer, other.m_buffer);
+		swap(m_capacity, other.m_capacity);
+		swap(m_size, other.m_size);
+	}
+
+protected:
+	void setArraySize(uint32_t new_size)
+	{
+		m_size = new_size;
+		if (new_size > m_capacity) {
+			uint32_t new_buffer_size;
+			if (m_capacity == 0) {
+				// first allocation is exact
+				new_buffer_size = new_size;
+			}
+			else {
+				// following allocations grow array by 25%
+				new_buffer_size = new_size + (new_size >> 2);
+			}
+			setArrayCapacity( new_buffer_size );
+		}
+	}
+	void setArrayCapacity(uint32_t new_capacity)
+	{
+		XA_DEBUG_ASSERT(new_capacity >= m_size);
+		if (new_capacity == 0) {
+			// free the buffer.
+			if (m_buffer != nullptr) {
+				XA_FREE(m_buffer);
+				m_buffer = nullptr;
+			}
+		}
+		else {
+			// realloc the buffer
+			m_buffer = XA_REALLOC(m_memTag, m_buffer, T, new_capacity);
+		}
+		m_capacity = new_capacity;
+	}
+
+	int m_memTag;
+	T * m_buffer;
+	uint32_t m_capacity;
+	uint32_t m_size;
+};
+
 /// Basis class to compute tangent space basis, ortogonalizations and to
 /// transform vectors from one space to another.
-class Basis
+struct Basis
 {
-public:
-	/// Create a null basis.
-	Basis() : tangent(0, 0, 0), bitangent(0, 0, 0), normal(0, 0, 0) {}
-
-	void buildFrameForDirection(Vector3::Arg d, float angle = 0)
+	void buildFrameForDirection(const Vector3 &d, float angle = 0)
 	{
-		xaAssert(isNormalized(d));
+		XA_ASSERT(isNormalized(d));
 		normal = d;
 		// Choose minimum axis.
 		if (fabsf(normal.x) < fabsf(normal.y) && fabsf(normal.x) < fabsf(normal.z)) {
@@ -702,7 +1212,7 @@ public:
 		}
 		// Ortogonalize
 		tangent -= normal * dot(normal, tangent);
-		tangent = normalize(tangent);
+		tangent = normalize(tangent, kEpsilon);
 		bitangent = cross(normal, tangent);
 		// Rotate frame around normal according to angle.
 		if (angle != 0.0f) {
@@ -714,9 +1224,9 @@ public:
 		}
 	}
 
-	Vector3 tangent;
-	Vector3 bitangent;
-	Vector3 normal;
+	Vector3 tangent = Vector3(0.0f);
+	Vector3 bitangent = Vector3(0.0f);
+	Vector3 normal = Vector3(0.0f);
 };
 
 // Simple bit array.
@@ -724,21 +1234,12 @@ class BitArray
 {
 public:
 	BitArray() : m_size(0) {}
+
 	BitArray(uint32_t sz)
 	{
 		resize(sz);
 	}
 
-	uint32_t size() const
-	{
-		return m_size;
-	}
-
-	void clear()
-	{
-		resize(0);
-	}
-
 	void resize(uint32_t new_size)
 	{
 		m_size = new_size;
@@ -748,162 +1249,311 @@ public:
 	/// Get bit.
 	bool bitAt(uint32_t b) const
 	{
-		xaDebugAssert( b < m_size );
+		XA_DEBUG_ASSERT( b < m_size );
 		return (m_wordArray[b >> 5] & (1 << (b & 31))) != 0;
 	}
 
 	// Set a bit.
 	void setBitAt(uint32_t idx)
 	{
-		xaDebugAssert(idx < m_size);
+		XA_DEBUG_ASSERT(idx < m_size);
 		m_wordArray[idx >> 5] |=  (1 << (idx & 31));
 	}
 
-	// Toggle a bit.
-	void toggleBitAt(uint32_t idx)
-	{
-		xaDebugAssert(idx < m_size);
-		m_wordArray[idx >> 5] ^= (1 << (idx & 31));
-	}
-
-	// Set a bit to the given value. @@ Rename modifyBitAt?
-	void setBitAt(uint32_t idx, bool b)
-	{
-		xaDebugAssert(idx < m_size);
-		m_wordArray[idx >> 5] = setBits(m_wordArray[idx >> 5], 1 << (idx & 31), b);
-		xaDebugAssert(bitAt(idx) == b);
-	}
-
 	// Clear all the bits.
 	void clearAll()
 	{
-		memset(m_wordArray.data(), 0, m_wordArray.size() * sizeof(uint32_t ));
-	}
-
-	// Set all the bits.
-	void setAll()
-	{
-		memset(m_wordArray.data(), 0xFF, m_wordArray.size() * sizeof(uint32_t ));
+		memset(m_wordArray.data(), 0, m_wordArray.size() * sizeof(uint32_t));
 	}
 
 private:
-	// See "Conditionally set or clear bits without branching" at http://graphics.stanford.edu/~seander/bithacks.html
-	uint32_t setBits(uint32_t w, uint32_t m, bool b)
-	{
-		return (w & ~m) | (-int(b) & m);
-	}
-
 	// Number of bits stored.
 	uint32_t m_size;
 
 	// Array of bits.
-	std::vector<uint32_t> m_wordArray;
+	Array<uint32_t> m_wordArray;
 };
 
-/// Bit map. This should probably be called BitImage.
-class BitMap
+class BitImage
 {
 public:
-	BitMap() : m_width(0), m_height(0) {}
-	BitMap(uint32_t w, uint32_t h) : m_width(w), m_height(h), m_bitArray(w * h) {}
+	BitImage() : m_width(0), m_height(0), m_rowStride(0) {}
 
-	uint32_t width() const
+	BitImage(uint32_t w, uint32_t h) : m_width(w), m_height(h)
 	{
-		return m_width;
+		m_rowStride = (m_width + 63) >> 6;
+		m_data.resize(m_rowStride * m_height);
 	}
-	uint32_t height() const
+
+	BitImage(const BitImage &other)
 	{
-		return m_height;
+		m_width = other.m_width;
+		m_height = other.m_height;
+		m_rowStride = other.m_rowStride;
+		m_data.resize(m_rowStride * m_height);
+		memcpy(m_data.data(), other.m_data.data(), m_rowStride * m_height * sizeof(uint64_t));
 	}
 
-	void resize(uint32_t w, uint32_t h, bool initValue)
+	const BitImage &operator=(const BitImage &other)
 	{
-		BitArray tmp(w * h);
-		if (initValue) tmp.setAll();
-		else tmp.clearAll();
-		// @@ Copying one bit at a time. This could be much faster.
-		for (uint32_t y = 0; y < m_height; y++) {
-			for (uint32_t x = 0; x < m_width; x++) {
-				//tmp.setBitAt(y*w + x, bitAt(x, y));
-				if (bitAt(x, y) != initValue) tmp.toggleBitAt(y * w + x);
-			}
+		m_width = other.m_width;
+		m_height = other.m_height;
+		m_rowStride = other.m_rowStride;
+		m_data = other.m_data;
+		return *this;
+	}
+
+	uint32_t width() const { return m_width; }
+	uint32_t height() const { return m_height; }
+
+	void resize(uint32_t w, uint32_t h, bool discard)
+	{
+		const uint32_t rowStride = (w + 63) >> 6;
+		if (discard) {
+			m_data.resize(rowStride * h);
+			memset(m_data.data(), 0, m_data.size() * sizeof(uint64_t));
+		} else {
+			Array<uint64_t> tmp;
+			tmp.resize(rowStride * h);
+			memset(tmp.data(), 0, tmp.size() * sizeof(uint64_t));
+			// If only height has changed, can copy all rows at once.
+			if (rowStride == m_rowStride) {
+				memcpy(tmp.data(), m_data.data(), m_rowStride * min(m_height, h) * sizeof(uint64_t));
+			} else if (m_width > 0 && m_height > 0) {
+				const uint32_t height = min(m_height, h);
+				for (uint32_t i = 0; i < height; i++)
+					memcpy(&tmp[i * rowStride], &m_data[i * m_rowStride], min(rowStride, m_rowStride) * sizeof(uint64_t));
+			}
+			tmp.moveTo(m_data);
 		}
-		std::swap(m_bitArray, tmp);
 		m_width = w;
 		m_height = h;
+		m_rowStride = rowStride;
 	}
 
 	bool bitAt(uint32_t x, uint32_t y) const
 	{
-		xaDebugAssert(x < m_width && y < m_height);
-		return m_bitArray.bitAt(y * m_width + x);
+		XA_DEBUG_ASSERT(x < m_width && y < m_height);
+		const uint32_t index = (x >> 6) + y * m_rowStride;
+		return (m_data[index] & (UINT64_C(1) << (uint64_t(x) & UINT64_C(63)))) != 0;
 	}
 
 	void setBitAt(uint32_t x, uint32_t y)
 	{
-		xaDebugAssert(x < m_width && y < m_height);
-		m_bitArray.setBitAt(y * m_width + x);
+		XA_DEBUG_ASSERT(x < m_width && y < m_height);
+		const uint32_t index = (x >> 6) + y * m_rowStride;
+		m_data[index] |= UINT64_C(1) << (uint64_t(x) & UINT64_C(63));
+		XA_DEBUG_ASSERT(bitAt(x, y));
 	}
 
 	void clearAll()
 	{
-		m_bitArray.clearAll();
+		memset(m_data.data(), 0, m_data.size() * sizeof(uint64_t));
+	}
+
+	bool canBlit(const BitImage &image, uint32_t offsetX, uint32_t offsetY) const
+	{
+		for (uint32_t y = 0; y < image.m_height; y++) {
+			const uint32_t thisY = y + offsetY;
+			if (thisY >= m_height)
+				continue;
+			uint32_t x = 0;
+			for (;;) {
+				const uint32_t thisX = x + offsetX;
+				if (thisX >= m_width)
+					break;
+				const uint32_t thisBlockShift = thisX % 64;
+				const uint64_t thisBlock = m_data[(thisX >> 6) + thisY * m_rowStride] >> thisBlockShift;
+				const uint32_t blockShift = x % 64;
+				const uint64_t block = image.m_data[(x >> 6) + y * image.m_rowStride] >> blockShift;
+				if ((thisBlock & block) != 0)
+					return false;
+				x += 64 - max(thisBlockShift, blockShift);
+				if (x >= image.m_width)
+					break;
+			}
+		}
+		return true;
+	}
+
+	void dilate(uint32_t padding)
+	{
+		BitImage tmp(m_width, m_height);
+		for (uint32_t p = 0; p < padding; p++) {
+			tmp.clearAll();
+			for (uint32_t y = 0; y < m_height; y++) {
+				for (uint32_t x = 0; x < m_width; x++) {
+					bool b = bitAt(x, y);
+					if (!b) {
+						if (x > 0) {
+							b |= bitAt(x - 1, y);
+							if (y > 0) b |= bitAt(x - 1, y - 1);
+							if (y < m_height - 1) b |= bitAt(x - 1, y + 1);
+						}
+						if (y > 0) b |= bitAt(x, y - 1);
+						if (y < m_height - 1) b |= bitAt(x, y + 1);
+						if (x < m_width - 1) {
+							b |= bitAt(x + 1, y);
+							if (y > 0) b |= bitAt(x + 1, y - 1);
+							if (y < m_height - 1) b |= bitAt(x + 1, y + 1);
+						}
+					}
+					if (b)
+						tmp.setBitAt(x, y);
+				}
+			}
+			swap(m_data, tmp.m_data);
+		}
 	}
 
 private:
 	uint32_t m_width;
 	uint32_t m_height;
-	BitArray m_bitArray;
+	uint32_t m_rowStride; // In uint64_t's
+	Array<uint64_t> m_data;
 };
 
-// Axis Aligned Bounding Box.
-class Box
+// From Fast-BVH
+class BVH
 {
 public:
-	Box() {}
-	Box(const Box &b) : minCorner(b.minCorner), maxCorner(b.maxCorner) {}
-	Box(const Vector3 &mins, const Vector3 &maxs) : minCorner(mins), maxCorner(maxs) {}
-
-	operator const float *() const
-	{
-		return reinterpret_cast<const float *>(this);
-	}
-
-	// Clear the bounds.
-	void clearBounds()
-	{
-		minCorner.set(FLT_MAX, FLT_MAX, FLT_MAX);
-		maxCorner.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
-	}
-
-	// Return extents of the box.
-	Vector3 extents() const
+	BVH(const Array<AABB> &objectAabbs, uint32_t leafSize = 4)
 	{
-		return (maxCorner - minCorner) * 0.5f;
+		m_objectAabbs = &objectAabbs;
+		if (m_objectAabbs->isEmpty())
+			return;
+		m_objectIds.resize(objectAabbs.size());
+		for (uint32_t i = 0; i < m_objectIds.size(); i++)
+			m_objectIds[i] = i;
+		BuildEntry todo[128];
+		uint32_t stackptr = 0;
+		const uint32_t kRoot = 0xfffffffc;
+		const uint32_t kUntouched = 0xffffffff;
+		const uint32_t kTouchedTwice = 0xfffffffd;
+		// Push the root
+		todo[stackptr].start = 0;
+		todo[stackptr].end = objectAabbs.size();
+		todo[stackptr].parent = kRoot;
+		stackptr++;
+		Node node;
+		m_nodes.reserve(objectAabbs.size() * 2);
+		uint32_t nNodes = 0;
+		while(stackptr > 0) {
+			// Pop the next item off of the stack
+			const BuildEntry &bnode = todo[--stackptr];
+			const uint32_t start = bnode.start;
+			const uint32_t end = bnode.end;
+			const uint32_t nPrims = end - start;
+			nNodes++;
+			node.start = start;
+			node.nPrims = nPrims;
+			node.rightOffset = kUntouched;
+			// Calculate the bounding box for this node
+			AABB bb(objectAabbs[m_objectIds[start]]);
+			AABB bc(objectAabbs[m_objectIds[start]].centroid());
+			for(uint32_t p = start + 1; p < end; ++p) {
+				bb.expandToInclude(objectAabbs[m_objectIds[p]]);
+				bc.expandToInclude(objectAabbs[m_objectIds[p]].centroid());
+			}
+			node.aabb = bb;
+			// If the number of primitives at this point is less than the leaf
+			// size, then this will become a leaf. (Signified by rightOffset == 0)
+			if (nPrims <= leafSize)
+				node.rightOffset = 0;
+			m_nodes.push_back(node);
+			// Child touches parent...
+			// Special case: Don't do this for the root.
+			if (bnode.parent != kRoot) {
+				m_nodes[bnode.parent].rightOffset--;
+				// When this is the second touch, this is the right child.
+				// The right child sets up the offset for the flat tree.
+				if (m_nodes[bnode.parent].rightOffset == kTouchedTwice )
+					m_nodes[bnode.parent].rightOffset = nNodes - 1 - bnode.parent;
+			}
+			// If this is a leaf, no need to subdivide.
+			if (node.rightOffset == 0)
+				continue;
+			// Set the split dimensions
+			const uint32_t split_dim = bc.maxDimension();
+			// Split on the center of the longest axis
+			const float split_coord = 0.5f * ((&bc.min.x)[split_dim] + (&bc.max.x)[split_dim]);
+			// Partition the list of objects on this split
+			uint32_t mid = start;
+			for (uint32_t i = start; i < end; ++i) {
+				const Vector3 centroid(objectAabbs[m_objectIds[i]].centroid());
+				if ((&centroid.x)[split_dim] < split_coord) {
+					swap(m_objectIds[i], m_objectIds[mid]);
+					++mid;
+				}
+			}
+			// If we get a bad split, just choose the center...
+			if (mid == start || mid == end)
+				mid = start + (end - start) / 2;
+			// Push right child
+			todo[stackptr].start = mid;
+			todo[stackptr].end = end;
+			todo[stackptr].parent = nNodes - 1;
+			stackptr++;
+			// Push left child
+			todo[stackptr].start = start;
+			todo[stackptr].end = mid;
+			todo[stackptr].parent = nNodes - 1;
+			stackptr++;
+		}
+	}
+
+	void query(const AABB &queryAabb, Array<uint32_t> &result) const
+	{
+		result.clear();
+		// Working set
+		uint32_t todo[64];
+		int32_t stackptr = 0;
+		// "Push" on the root node to the working set
+		todo[stackptr] = 0;
+		while(stackptr >= 0) {
+			// Pop off the next node to work on.
+			const int ni = todo[stackptr--];
+			const Node &node = m_nodes[ni];
+			// Is leaf -> Intersect
+			if (node.rightOffset == 0) {
+				for(uint32_t o = 0; o < node.nPrims; ++o) {
+					const uint32_t obj = node.start + o;
+					if (queryAabb.intersect((*m_objectAabbs)[m_objectIds[obj]]))
+						result.push_back(m_objectIds[obj]);
+				}
+			} else { // Not a leaf
+				const uint32_t left = ni + 1;
+				const uint32_t right = ni + node.rightOffset;
+				if (queryAabb.intersect(m_nodes[left].aabb))
+					todo[++stackptr] = left;
+				if (queryAabb.intersect(m_nodes[right].aabb))
+					todo[++stackptr] = right;
+			}
+		}
 	}
 
-	// Add a point to this box.
-	void addPointToBounds(const Vector3 &p)
+private:
+	struct BuildEntry
 	{
-		minCorner = min(minCorner, p);
-		maxCorner = max(maxCorner, p);
-	}
+		uint32_t parent; // If non-zero then this is the index of the parent. (used in offsets)
+		uint32_t start, end; // The range of objects in the object list covered by this node.
+	};
 
-	// Get the volume of the box.
-	float volume() const
+	struct Node
 	{
-		Vector3 d = extents();
-		return 8.0f * (d.x * d.y * d.z);
-	}
+		AABB aabb;
+		uint32_t start, nPrims, rightOffset;
+	};
 
-	Vector3 minCorner;
-	Vector3 maxCorner;
+	const Array<AABB> *m_objectAabbs;
+	Array<uint32_t> m_objectIds;
+	Array<Node> m_nodes;
 };
 
 class Fit
 {
 public:
-	static Vector3 computeCentroid(int n, const Vector3 *__restrict points)
+	static Vector3 computeCentroid(int n, const Vector3 * points)
 	{
 		Vector3 centroid(0.0f);
 		for (int i = 0; i < n; i++) {
@@ -913,7 +1563,7 @@ public:
 		return centroid;
 	}
 
-	static Vector3 computeCovariance(int n, const Vector3 *__restrict points, float *__restrict covariance)
+	static Vector3 computeCovariance(int n, const Vector3 * points, float * covariance)
 	{
 		// compute the centroid
 		Vector3 centroid = computeCentroid(n, points);
@@ -933,25 +1583,12 @@ public:
 		return centroid;
 	}
 
-	static bool isPlanar(int n, const Vector3 *points, float epsilon = NV_EPSILON)
-	{
-		// compute the centroid and covariance
-		float matrix[6];
-		computeCovariance(n, points, matrix);
-		float eigenValues[3];
-		Vector3 eigenVectors[3];
-		if (!eigenSolveSymmetric3(matrix, eigenValues, eigenVectors)) {
-			return false;
-		}
-		return eigenValues[2] < epsilon;
-	}
-
 	// Tridiagonal solver from Charles Bloom.
 	// Householder transforms followed by QL decomposition.
 	// Seems to be based on the code from Numerical Recipes in C.
 	static bool eigenSolveSymmetric3(const float matrix[6], float eigenValues[3], Vector3 eigenVectors[3])
 	{
-		xaDebugAssert(matrix != NULL && eigenValues != NULL && eigenVectors != NULL);
+		XA_DEBUG_ASSERT(matrix != nullptr && eigenValues != nullptr && eigenVectors != nullptr);
 		float subd[3];
 		float diag[3];
 		float work[3][3];
@@ -975,24 +1612,24 @@ public:
 		// eigenvectors are the columns; make them the rows :
 		for (int i = 0; i < 3; i++) {
 			for (int j = 0; j < 3; j++) {
-				eigenVectors[j].component[i] = (float) work[i][j];
+				(&eigenVectors[j].x)[i] = (float) work[i][j];
 			}
 		}
 		// shuffle to sort by singular value :
 		if (eigenValues[2] > eigenValues[0] && eigenValues[2] > eigenValues[1]) {
-			std::swap(eigenValues[0], eigenValues[2]);
-			std::swap(eigenVectors[0], eigenVectors[2]);
+			swap(eigenValues[0], eigenValues[2]);
+			swap(eigenVectors[0], eigenVectors[2]);
 		}
 		if (eigenValues[1] > eigenValues[0]) {
-			std::swap(eigenValues[0], eigenValues[1]);
-			std::swap(eigenVectors[0], eigenVectors[1]);
+			swap(eigenValues[0], eigenValues[1]);
+			swap(eigenVectors[0], eigenVectors[1]);
 		}
 		if (eigenValues[2] > eigenValues[1]) {
-			std::swap(eigenValues[1], eigenValues[2]);
-			std::swap(eigenVectors[1], eigenVectors[2]);
+			swap(eigenValues[1], eigenValues[2]);
+			swap(eigenVectors[1], eigenVectors[2]);
 		}
-		xaDebugAssert(eigenValues[0] >= eigenValues[1] && eigenValues[0] >= eigenValues[2]);
-		xaDebugAssert(eigenValues[1] >= eigenValues[2]);
+		XA_DEBUG_ASSERT(eigenValues[0] >= eigenValues[1] && eigenValues[0] >= eigenValues[2]);
+		XA_DEBUG_ASSERT(eigenValues[1] >= eigenValues[2]);
 		return true;
 	}
 
@@ -1118,7 +1755,7 @@ public:
 
 	const FullVector &operator=(const FullVector &v)
 	{
-		xaAssert(dimension() == v.dimension());
+		XA_ASSERT(dimension() == v.dimension());
 		m_array = v.m_array;
 		return *this;
 	}
@@ -1135,1698 +1772,1695 @@ public:
 		}
 	}
 
-	void operator+=(const FullVector &v)
-	{
-		xaDebugAssert(dimension() == v.dimension());
-		const uint32_t dim = dimension();
-		for (uint32_t i = 0; i < dim; i++) {
-			m_array[i] += v.m_array[i];
-		}
-	}
-
-	void operator-=(const FullVector &v)
-	{
-		xaDebugAssert(dimension() == v.dimension());
-		const uint32_t dim = dimension();
-		for (uint32_t i = 0; i < dim; i++) {
-			m_array[i] -= v.m_array[i];
-		}
-	}
-
-	void operator*=(const FullVector &v)
-	{
-		xaDebugAssert(dimension() == v.dimension());
-		const uint32_t dim = dimension();
-		for (uint32_t i = 0; i < dim; i++) {
-			m_array[i] *= v.m_array[i];
-		}
-	}
-
-	void operator+=(float f)
-	{
-		const uint32_t dim = dimension();
-		for (uint32_t i = 0; i < dim; i++) {
-			m_array[i] += f;
-		}
-	}
-
-	void operator-=(float f)
-	{
-		const uint32_t dim = dimension();
-		for (uint32_t i = 0; i < dim; i++) {
-			m_array[i] -= f;
-		}
-	}
-
-	void operator*=(float f)
-	{
-		const uint32_t dim = dimension();
-		for (uint32_t i = 0; i < dim; i++) {
-			m_array[i] *= f;
-		}
-	}
-
 private:
-	std::vector<float> m_array;
+	Array<float> m_array;
 };
 
-namespace halfedge {
-class Face;
-class Vertex;
-
-class Edge
+template<typename Key, typename Value, typename H = Hash<Key>, typename E = Equal<Key> >
+class HashMap
 {
 public:
-	uint32_t id;
-	Edge *next;
-	Edge *prev;	// This is not strictly half-edge, but makes algorithms easier and faster.
-	Edge *pair;
-	Vertex *vertex;
-	Face *face;
-
-	// Default constructor.
-	Edge(uint32_t id) : id(id), next(NULL), prev(NULL), pair(NULL), vertex(NULL), face(NULL) {}
-
-	// Vertex queries.
-	const Vertex *from() const
+	HashMap(int memTag, uint32_t size) : m_memTag(memTag), m_size(size), m_numSlots(0), m_slots(nullptr), m_keys(memTag), m_values(memTag), m_next(memTag)
 	{
-		return vertex;
 	}
 
-	Vertex *from()
+	~HashMap()
 	{
-		return vertex;
+		if (m_slots)
+			XA_FREE(m_slots);
 	}
 
-	const Vertex *to() const
-	{
-		return pair->vertex;    // This used to be 'next->vertex', but that changed often when the connectivity of the mesh changes.
-	}
+	const Value &value(uint32_t index) const { return m_values[index]; }
 
-	Vertex *to()
+	void add(const Key &key, const Value &value)
 	{
-		return pair->vertex;
+		if (!m_slots)
+			alloc();
+		const uint32_t hash = computeHash(key);
+		m_keys.push_back(key);
+		m_values.push_back(value);
+		m_next.push_back(m_slots[hash]);
+		m_slots[hash] = m_next.size() - 1;
 	}
 
-	// Edge queries.
-	void setNext(Edge *e)
-	{
-		next = e;
-		if (e != NULL) e->prev = this;
-	}
-	void setPrev(Edge *e)
+	uint32_t get(const Key &key) const
 	{
-		prev = e;
-		if (e != NULL) e->next = this;
+		if (!m_slots)
+			return UINT32_MAX;
+		const uint32_t hash = computeHash(key);
+		uint32_t i = m_slots[hash];
+		E equal;
+		while (i != UINT32_MAX) {
+			if (equal(m_keys[i], key))
+				return i;
+			i = m_next[i];
+		}
+		return UINT32_MAX;
 	}
 
-	// @@ It would be more simple to only check m_pair == NULL
-	// Face queries.
-	bool isBoundary() const
+	uint32_t getNext(uint32_t current) const
 	{
-		return !(face && pair->face);
+		uint32_t i = m_next[current];
+		E equal;
+		while (i != UINT32_MAX) {
+			if (equal(m_keys[i], m_keys[current]))
+				return i;
+			i = m_next[i];
+		}
+		return UINT32_MAX;
 	}
 
-	// @@ This is not exactly accurate, we should compare the texture coordinates...
-	bool isSeam() const
+private:
+	void alloc()
 	{
-		return vertex != pair->next->vertex || next->vertex != pair->vertex;
+		XA_DEBUG_ASSERT(m_size > 0);
+		m_numSlots = (uint32_t)(m_size * 1.3);
+		m_slots = XA_ALLOC_ARRAY(m_memTag, uint32_t, m_numSlots);
+		for (uint32_t i = 0; i < m_numSlots; i++)
+			m_slots[i] = UINT32_MAX;
+		m_keys.reserve(m_size);
+		m_values.reserve(m_size);
+		m_next.reserve(m_size);
 	}
 
-	bool isNormalSeam() const;
-	bool isTextureSeam() const;
-
-	bool isValid() const
+	uint32_t computeHash(const Key &key) const
 	{
-		// null face is OK.
-		if (next == NULL || prev == NULL || pair == NULL || vertex == NULL) return false;
-		if (next->prev != this) return false;
-		if (prev->next != this) return false;
-		if (pair->pair != this) return false;
-		return true;
+		H hash;
+		return hash(key) % m_numSlots;
 	}
 
-	float length() const;
-
-	// Return angle between this edge and the previous one.
-	float angle() const;
+	int m_memTag;
+	uint32_t m_size;
+	uint32_t m_numSlots;
+	uint32_t *m_slots;
+	Array<Key> m_keys;
+	Array<Value> m_values;
+	Array<uint32_t> m_next;
 };
 
-class Vertex
+template<typename T>
+static void insertionSort(T *data, uint32_t length)
 {
-public:
-	uint32_t id;
-	// -- GODOT start --
-	uint32_t original_id;
-	// -- GODOT end --
-	Edge *edge;
-	Vertex *next;
-	Vertex *prev;
-	Vector3 pos;
-	Vector3 nor;
-	Vector2 tex;
-
-	// -- GODOT start --
-	//Vertex(uint32_t id) : id(id), edge(NULL), pos(0.0f), nor(0.0f), tex(0.0f)
-	Vertex(uint32_t id) : id(id), original_id(id), edge(NULL), pos(0.0f), nor(0.0f), tex(0.0f)
-	// -- GODOT end --
-	{
-		next = this;
-		prev = this;
-	}
-
-	// Set first edge of all colocals.
-	void setEdge(Edge *e)
-	{
-		for (VertexIterator it(colocals()); !it.isDone(); it.advance()) {
-			it.current()->edge = e;
+	for (int32_t i = 1; i < (int32_t)length; i++) {
+		T x = data[i];
+		int32_t j = i - 1;
+		while (j >= 0 && x < data[j]) {
+			data[j + 1] = data[j];
+			j--;
 		}
+		data[j + 1] = x;
 	}
+}
 
-	// Update position of all colocals.
-	void setPos(const Vector3 &p)
+class KISSRng
+{
+public:
+	uint32_t getRange(uint32_t range)
 	{
-		for (VertexIterator it(colocals()); !it.isDone(); it.advance()) {
-			it.current()->pos = p;
-		}
+		if (range == 0)
+			return 0;
+		x = 69069 * x + 12345;
+		y ^= (y << 13);
+		y ^= (y >> 17);
+		y ^= (y << 5);
+		uint64_t t = 698769069ULL * z + c;
+		c = (t >> 32);
+		return (x + y + (z = (uint32_t)t)) % range;
 	}
 
-	bool isFirstColocal() const
-	{
-		return firstColocal() == this;
-	}
+private:
+	uint32_t x = 123456789, y = 362436000, z = 521288629, c = 7654321;
+};
+
+// Based on Pierre Terdiman's and Michael Herf's source code.
+// http://www.codercorner.com/RadixSortRevisited.htm
+// http://www.stereopsis.com/radix.html
+class RadixSort
+{
+public:
+	RadixSort() : m_size(0), m_ranks(nullptr), m_ranks2(nullptr), m_validRanks(false) {}
 
-	const Vertex *firstColocal() const
+	~RadixSort()
 	{
-		uint32_t firstId = id;
-		const Vertex *vertex = this;
-		for (ConstVertexIterator it(colocals()); !it.isDone(); it.advance()) {
-			if (it.current()->id < firstId) {
-				firstId = vertex->id;
-				vertex = it.current();
-			}
-		}
-		return vertex;
+		// Release everything
+		XA_FREE(m_ranks2);
+		XA_FREE(m_ranks);
 	}
 
-	Vertex *firstColocal()
+	RadixSort &sort(const float *input, uint32_t count)
 	{
-		Vertex *vertex = this;
-		uint32_t firstId = id;
-		for (VertexIterator it(colocals()); !it.isDone(); it.advance()) {
-			if (it.current()->id < firstId) {
-				firstId = vertex->id;
-				vertex = it.current();
+		if (input == nullptr || count == 0) return *this;
+		// Resize lists if needed
+		if (count != m_size) {
+			if (count > m_size) {
+				m_ranks2 = XA_REALLOC(MemTag::Default, m_ranks2, uint32_t, count);
+				m_ranks = XA_REALLOC(MemTag::Default, m_ranks, uint32_t, count);
 			}
+			m_size = count;
+			m_validRanks = false;
 		}
-		return vertex;
-	}
-
-	bool isColocal(const Vertex *v) const
-	{
-		if (this == v) return true;
-		if (pos != v->pos) return false;
-		for (ConstVertexIterator it(colocals()); !it.isDone(); it.advance()) {
-			if (v == it.current()) {
-				return true;
+		if (count < 32) {
+			insertionSort(input, count);
+		} else {
+			// @@ Avoid touching the input multiple times.
+			for (uint32_t i = 0; i < count; i++) {
+				FloatFlip((uint32_t &)input[i]);
+			}
+			radixSort<uint32_t>((const uint32_t *)input, count);
+			for (uint32_t i = 0; i < count; i++) {
+				IFloatFlip((uint32_t &)input[i]);
 			}
 		}
-		return false;
+		return *this;
 	}
 
-	void linkColocal(Vertex *v)
-	{
-		next->prev = v;
-		v->next = next;
-		next = v;
-		v->prev = this;
-	}
-	void unlinkColocal()
+	RadixSort &sort(const Array<float> &input)
 	{
-		next->prev = prev;
-		prev->next = next;
-		next = this;
-		prev = this;
+		return sort(input.data(), input.size());
 	}
 
-	// @@ Note: This only works if linkBoundary has been called.
-	bool isBoundary() const
+	// Access to results. m_ranks is a list of indices in sorted order, i.e. in the order you may further process your data
+	const uint32_t *ranks() const
 	{
-		return (edge && !edge->face);
+		XA_DEBUG_ASSERT(m_validRanks);
+		return m_ranks;
 	}
 
-	// Iterator that visits the edges around this vertex in counterclockwise order.
-	class EdgeIterator //: public Iterator<Edge *>
+	uint32_t *ranks()
 	{
-	public:
-		EdgeIterator(Edge *e) : m_end(NULL), m_current(e) { }
-
-		virtual void advance()
-		{
-			if (m_end == NULL) m_end = m_current;
-			m_current = m_current->pair->next;
-			//m_current = m_current->prev->pair;
-		}
-
-		virtual bool isDone() const
-		{
-			return m_end == m_current;
-		}
-		virtual Edge *current() const
-		{
-			return m_current;
-		}
-		Vertex *vertex() const
-		{
-			return m_current->vertex;
-		}
+		XA_DEBUG_ASSERT(m_validRanks);
+		return m_ranks;
+	}
 
-	private:
-		Edge *m_end;
-		Edge *m_current;
-	};
+private:
+	uint32_t m_size;
+	uint32_t *m_ranks;
+	uint32_t *m_ranks2;
+	bool m_validRanks;
 
-	EdgeIterator edges()
+	void FloatFlip(uint32_t &f)
 	{
-		return EdgeIterator(edge);
+		int32_t mask = (int32_t(f) >> 31) | 0x80000000; // Warren Hunt, Manchor Ko.
+		f ^= mask;
 	}
-	EdgeIterator edges(Edge *e)
+
+	void IFloatFlip(uint32_t &f)
 	{
-		return EdgeIterator(e);
+		uint32_t mask = ((f >> 31) - 1) | 0x80000000; // Michael Herf.
+		f ^= mask;
 	}
 
-	// Iterator that visits the edges around this vertex in counterclockwise order.
-	class ConstEdgeIterator //: public Iterator<Edge *>
+	template<typename T>
+	void createHistograms(const T *buffer, uint32_t count, uint32_t *histogram)
 	{
-	public:
-		ConstEdgeIterator(const Edge *e) : m_end(NULL), m_current(e) { }
-		ConstEdgeIterator(EdgeIterator it) : m_end(NULL), m_current(it.current()) { }
-
-		virtual void advance()
-		{
-			if (m_end == NULL) m_end = m_current;
-			m_current = m_current->pair->next;
-			//m_current = m_current->prev->pair;
-		}
-
-		virtual bool isDone() const
-		{
-			return m_end == m_current;
-		}
-		virtual const Edge *current() const
-		{
-			return m_current;
+		const uint32_t bucketCount = sizeof(T); // (8 * sizeof(T)) / log2(radix)
+		// Init bucket pointers.
+		uint32_t *h[bucketCount];
+		for (uint32_t i = 0; i < bucketCount; i++) {
+			h[i] = histogram + 256 * i;
 		}
-		const Vertex *vertex() const
-		{
-			return m_current->to();
+		// Clear histograms.
+		memset(histogram, 0, 256 * bucketCount * sizeof(uint32_t ));
+		// @@ Add support for signed integers.
+		// Build histograms.
+		const uint8_t *p = (const uint8_t *)buffer;  // @@ Does this break aliasing rules?
+		const uint8_t *pe = p + count * sizeof(T);
+		while (p != pe) {
+			h[0][*p++]++, h[1][*p++]++, h[2][*p++]++, h[3][*p++]++;
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+			if (bucketCount == 8) h[4][*p++]++, h[5][*p++]++, h[6][*p++]++, h[7][*p++]++;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 		}
-
-	private:
-		const Edge *m_end;
-		const Edge *m_current;
-	};
-
-	ConstEdgeIterator edges() const
-	{
-		return ConstEdgeIterator(edge);
-	}
-	ConstEdgeIterator edges(const Edge *e) const
-	{
-		return ConstEdgeIterator(e);
 	}
 
-	// Iterator that visits all the colocal vertices.
-	class VertexIterator //: public Iterator<Edge *>
+	template <typename T> void insertionSort(const T *input, uint32_t count)
 	{
-	public:
-		VertexIterator(Vertex *v) : m_end(NULL), m_current(v) { }
-
-		virtual void advance()
-		{
-			if (m_end == NULL) m_end = m_current;
-			m_current = m_current->next;
-		}
-
-		virtual bool isDone() const
-		{
-			return m_end == m_current;
-		}
-		virtual Vertex *current() const
-		{
-			return m_current;
+		if (!m_validRanks) {
+			m_ranks[0] = 0;
+			for (uint32_t i = 1; i != count; ++i) {
+				int rank = m_ranks[i] = i;
+				uint32_t j = i;
+				while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
+					m_ranks[j] = m_ranks[j - 1];
+					--j;
+				}
+				if (i != j) {
+					m_ranks[j] = rank;
+				}
+			}
+			m_validRanks = true;
+		} else {
+			for (uint32_t i = 1; i != count; ++i) {
+				int rank = m_ranks[i];
+				uint32_t j = i;
+				while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
+					m_ranks[j] = m_ranks[j - 1];
+					--j;
+				}
+				if (i != j) {
+					m_ranks[j] = rank;
+				}
+			}
 		}
-
-	private:
-		Vertex *m_end;
-		Vertex *m_current;
-	};
-
-	VertexIterator colocals()
-	{
-		return VertexIterator(this);
 	}
 
-	// Iterator that visits all the colocal vertices.
-	class ConstVertexIterator //: public Iterator<Edge *>
+	template <typename T> void radixSort(const T *input, uint32_t count)
 	{
-	public:
-		ConstVertexIterator(const Vertex *v) : m_end(NULL), m_current(v) { }
-
-		virtual void advance()
-		{
-			if (m_end == NULL) m_end = m_current;
-			m_current = m_current->next;
-		}
-
-		virtual bool isDone() const
-		{
-			return m_end == m_current;
+		const uint32_t P = sizeof(T); // pass count
+		// Allocate histograms & offsets on the stack
+		uint32_t histogram[256 * P];
+		uint32_t *link[256];
+		createHistograms(input, count, histogram);
+		// Radix sort, j is the pass number (0=LSB, P=MSB)
+		for (uint32_t j = 0; j < P; j++) {
+			// Pointer to this bucket.
+			const uint32_t *h = &histogram[j * 256];
+			const uint8_t *inputBytes = (const uint8_t *)input; // @@ Is this aliasing legal?
+			inputBytes += j;
+			if (h[inputBytes[0]] == count) {
+				// Skip this pass, all values are the same.
+				continue;
+			}
+			// Create offsets
+			link[0] = m_ranks2;
+			for (uint32_t i = 1; i < 256; i++) link[i] = link[i - 1] + h[i - 1];
+			// Perform Radix Sort
+			if (!m_validRanks) {
+				for (uint32_t i = 0; i < count; i++) {
+					*link[inputBytes[i * P]]++ = i;
+				}
+				m_validRanks = true;
+			} else {
+				for (uint32_t i = 0; i < count; i++) {
+					const uint32_t idx = m_ranks[i];
+					*link[inputBytes[idx * P]]++ = idx;
+				}
+			}
+			// Swap pointers for next pass. Valid indices - the most recent ones - are in m_ranks after the swap.
+			swap(m_ranks, m_ranks2);
 		}
-		virtual const Vertex *current() const
-		{
-			return m_current;
+		// All values were equal, generate linear ranks.
+		if (!m_validRanks) {
+			for (uint32_t i = 0; i < count; i++) {
+				m_ranks[i] = i;
+			}
+			m_validRanks = true;
 		}
-
-	private:
-		const Vertex *m_end;
-		const Vertex *m_current;
-	};
-
-	ConstVertexIterator colocals() const
-	{
-		return ConstVertexIterator(this);
 	}
 };
 
-bool Edge::isNormalSeam() const
-{
-	return (vertex->nor != pair->next->vertex->nor || next->vertex->nor != pair->vertex->nor);
-}
-
-bool Edge::isTextureSeam() const
-{
-	return (vertex->tex != pair->next->vertex->tex || next->vertex->tex != pair->vertex->tex);
-}
-
-float Edge::length() const
-{
-	return internal::length(to()->pos - from()->pos);
-}
-
-float Edge::angle() const
-{
-	Vector3 p = vertex->pos;
-	Vector3 a = prev->vertex->pos;
-	Vector3 b = next->vertex->pos;
-	Vector3 v0 = a - p;
-	Vector3 v1 = b - p;
-	return acosf(dot(v0, v1) / (internal::length(v0) * internal::length(v1)));
-}
-
-class Face
+// Wrapping this in a class allows temporary arrays to be re-used.
+class BoundingBox2D
 {
 public:
-	uint32_t id;
-	uint16_t group;
-	uint16_t material;
-	Edge *edge;
-
-	Face(uint32_t id) : id(id), group(uint16_t(~0)), material(uint16_t(~0)), edge(NULL) {}
+	Vector2 majorAxis() const { return m_majorAxis; }
+	Vector2 minorAxis() const { return m_minorAxis; }
+	Vector2 minCorner() const { return m_minCorner; }
+	Vector2 maxCorner() const { return m_maxCorner; }
 
-	float area() const
-	{
-		float area = 0;
-		const Vector3 &v0 = edge->from()->pos;
-		for (ConstEdgeIterator it(edges(edge->next)); it.current() != edge->prev; it.advance()) {
-			const Edge *e = it.current();
-			const Vector3 &v1 = e->vertex->pos;
-			const Vector3 &v2 = e->next->vertex->pos;
-			area += length(cross(v1 - v0, v2 - v0));
-		}
-		return area * 0.5f;
-	}
-
-	float parametricArea() const
-	{
-		float area = 0;
-		const Vector2 &v0 = edge->from()->tex;
-		for (ConstEdgeIterator it(edges(edge->next)); it.current() != edge->prev; it.advance()) {
-			const Edge *e = it.current();
-			const Vector2 &v1 = e->vertex->tex;
-			const Vector2 &v2 = e->next->vertex->tex;
-			area += triangleArea(v0, v1, v2);
-		}
-		return area * 0.5f;
-	}
-
-	Vector3 normal() const
+	// This should compute convex hull and use rotating calipers to find the best box. Currently it uses a brute force method.
+	void compute(const Vector2 *boundaryVertices, uint32_t boundaryVertexCount, const Vector2 *vertices, uint32_t vertexCount)
 	{
-		Vector3 n(0);
-		const Vertex *vertex0 = NULL;
-		for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
-			const Edge *e = it.current();
-			xaAssert(e != NULL);
-			if (vertex0 == NULL) {
-				vertex0 = e->vertex;
-			} else if (e->next->vertex != vertex0) {
-				const halfedge::Vertex *vertex1 = e->from();
-				const halfedge::Vertex *vertex2 = e->to();
-				const Vector3 &p0 = vertex0->pos;
-				const Vector3 &p1 = vertex1->pos;
-				const Vector3 &p2 = vertex2->pos;
-				Vector3 v10 = p1 - p0;
-				Vector3 v20 = p2 - p0;
-				n += cross(v10, v20);
+		convexHull(boundaryVertices, boundaryVertexCount, m_hull, 0.00001f);
+		// @@ Ideally I should use rotating calipers to find the best box. Using brute force for now.
+		float best_area = FLT_MAX;
+		Vector2 best_min(0);
+		Vector2 best_max(0);
+		Vector2 best_axis(0);
+		const uint32_t hullCount = m_hull.size();
+		for (uint32_t i = 0, j = hullCount - 1; i < hullCount; j = i, i++) {
+			if (equal(m_hull[i], m_hull[j], kEpsilon))
+				continue;
+			Vector2 axis = normalize(m_hull[i] - m_hull[j], 0.0f);
+			XA_DEBUG_ASSERT(isFinite(axis));
+			// Compute bounding box.
+			Vector2 box_min(FLT_MAX, FLT_MAX);
+			Vector2 box_max(-FLT_MAX, -FLT_MAX);
+			// Consider all points, not only boundary points, in case the input chart is malformed.
+			for (uint32_t v = 0; v < vertexCount; v++) {
+				const Vector2 &point = vertices[v];
+				const float x = dot(axis, point);
+				const float y = dot(Vector2(-axis.y, axis.x), point);
+				box_min.x = min(box_min.x, x);
+				box_max.x = max(box_max.x, x);
+				box_min.y = min(box_min.y, y);
+				box_max.y = max(box_max.y, y);
+			}
+			// Compute box area.
+			const float area = (box_max.x - box_min.x) * (box_max.y - box_min.y);
+			if (area < best_area) {
+				best_area = area;
+				best_min = box_min;
+				best_max = box_max;
+				best_axis = axis;
 			}
 		}
-		return normalizeSafe(n, Vector3(0, 0, 1), 0.0f);
-	}
-
-	Vector3 centroid() const
-	{
-		Vector3 sum(0.0f);
-		uint32_t count = 0;
-		for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
-			const Edge *e = it.current();
-			sum += e->from()->pos;
-			count++;
-		}
-		return sum / float(count);
-	}
-
-	// Unnormalized face normal assuming it's a triangle.
-	Vector3 triangleNormal() const
-	{
-		Vector3 p0 = edge->vertex->pos;
-		Vector3 p1 = edge->next->vertex->pos;
-		Vector3 p2 = edge->next->next->vertex->pos;
-		Vector3 e0 = p2 - p0;
-		Vector3 e1 = p1 - p0;
-		return normalizeSafe(cross(e0, e1), Vector3(0), 0.0f);
-	}
-
-	Vector3 triangleNormalAreaScaled() const
-	{
-		Vector3 p0 = edge->vertex->pos;
-		Vector3 p1 = edge->next->vertex->pos;
-		Vector3 p2 = edge->next->next->vertex->pos;
-		Vector3 e0 = p2 - p0;
-		Vector3 e1 = p1 - p0;
-		return cross(e0, e1);
-	}
-
-	// Average of the edge midpoints weighted by the edge length.
-	// I want a point inside the triangle, but closer to the cirumcenter.
-	Vector3 triangleCenter() const
-	{
-		Vector3 p0 = edge->vertex->pos;
-		Vector3 p1 = edge->next->vertex->pos;
-		Vector3 p2 = edge->next->next->vertex->pos;
-		float l0 = length(p1 - p0);
-		float l1 = length(p2 - p1);
-		float l2 = length(p0 - p2);
-		Vector3 m0 = (p0 + p1) * l0 / (l0 + l1 + l2);
-		Vector3 m1 = (p1 + p2) * l1 / (l0 + l1 + l2);
-		Vector3 m2 = (p2 + p0) * l2 / (l0 + l1 + l2);
-		return m0 + m1 + m2;
-	}
-
-	bool isValid() const
-	{
-		uint32_t count = 0;
-		for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
-			const Edge *e = it.current();
-			if (e->face != this) return false;
-			if (!e->isValid()) return false;
-			if (!e->pair->isValid()) return false;
-			count++;
-		}
-		if (count < 3) return false;
-		return true;
-	}
-
-	bool contains(const Edge *e) const
-	{
-		for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
-			if (it.current() == e) return true;
-		}
-		return false;
-	}
-
-	uint32_t edgeCount() const
-	{
-		uint32_t count = 0;
-		for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
-			++count;
-		}
-		return count;
+		m_majorAxis = best_axis;
+		m_minorAxis = Vector2(-best_axis.y, best_axis.x);
+		m_minCorner = best_min;
+		m_maxCorner = best_max;
+		XA_ASSERT(isFinite(m_majorAxis) && isFinite(m_minorAxis) && isFinite(m_minCorner));
 	}
 
-	// The iterator that visits the edges of this face in clockwise order.
-	class EdgeIterator //: public Iterator<Edge *>
+private:
+	// Compute the convex hull using Graham Scan.
+	void convexHull(const Vector2 *input, uint32_t inputCount, Array<Vector2> &output, float epsilon)
 	{
-	public:
-		EdgeIterator(Edge *e) : m_end(NULL), m_current(e) { }
-
-		virtual void advance()
-		{
-			if (m_end == NULL) m_end = m_current;
-			m_current = m_current->next;
+		m_coords.resize(inputCount);
+		for (uint32_t i = 0; i < inputCount; i++)
+			m_coords[i] = input[i].x;
+		RadixSort radix;
+		radix.sort(m_coords);
+		const uint32_t *ranks = radix.ranks();
+		m_top.clear();
+		m_bottom.clear();
+		m_top.reserve(inputCount);
+		m_bottom.reserve(inputCount);
+		Vector2 P = input[ranks[0]];
+		Vector2 Q = input[ranks[inputCount - 1]];
+		float topy = max(P.y, Q.y);
+		float boty = min(P.y, Q.y);
+		for (uint32_t i = 0; i < inputCount; i++) {
+			Vector2 p = input[ranks[i]];
+			if (p.y >= boty)
+				m_top.push_back(p);
 		}
-
-		virtual bool isDone() const
-		{
-			return m_end == m_current;
+		for (uint32_t i = 0; i < inputCount; i++) {
+			Vector2 p = input[ranks[inputCount - 1 - i]];
+			if (p.y <= topy)
+				m_bottom.push_back(p);
 		}
-		virtual Edge *current() const
-		{
-			return m_current;
+		// Filter top list.
+		output.clear();
+		output.push_back(m_top[0]);
+		output.push_back(m_top[1]);
+		for (uint32_t i = 2; i < m_top.size(); ) {
+			Vector2 a = output[output.size() - 2];
+			Vector2 b = output[output.size() - 1];
+			Vector2 c = m_top[i];
+			float area = triangleArea(a, b, c);
+			if (area >= -epsilon)
+				output.pop_back();
+			if (area < -epsilon || output.size() == 1) {
+				output.push_back(c);
+				i++;
+			}
 		}
-		Vertex *vertex() const
-		{
-			return m_current->vertex;
+		uint32_t top_count = output.size();
+		output.push_back(m_bottom[1]);
+		// Filter bottom list.
+		for (uint32_t i = 2; i < m_bottom.size(); ) {
+			Vector2 a = output[output.size() - 2];
+			Vector2 b = output[output.size() - 1];
+			Vector2 c = m_bottom[i];
+			float area = triangleArea(a, b, c);
+			if (area >= -epsilon)
+				output.pop_back();
+			if (area < -epsilon || output.size() == top_count) {
+				output.push_back(c);
+				i++;
+			}
 		}
-
-	private:
-		Edge *m_end;
-		Edge *m_current;
-	};
-
-	EdgeIterator edges()
-	{
-		return EdgeIterator(edge);
-	}
-	EdgeIterator edges(Edge *e)
-	{
-		xaDebugAssert(contains(e));
-		return EdgeIterator(e);
+		// Remove duplicate element.
+		XA_DEBUG_ASSERT(output.front() == output.back());
+		output.pop_back();
 	}
 
-	// The iterator that visits the edges of this face in clockwise order.
-	class ConstEdgeIterator //: public Iterator<const Edge *>
-	{
-	public:
-		ConstEdgeIterator(const Edge *e) : m_end(NULL), m_current(e) { }
-		ConstEdgeIterator(const EdgeIterator &it) : m_end(NULL), m_current(it.current()) { }
+	Array<float> m_coords;
+	Array<Vector2> m_top, m_bottom, m_hull;
+	Vector2 m_majorAxis, m_minorAxis, m_minCorner, m_maxCorner;
+};
 
-		virtual void advance()
-		{
-			if (m_end == NULL) m_end = m_current;
-			m_current = m_current->next;
-		}
+static uint32_t meshEdgeFace(uint32_t edge) { return edge / 3; }
+static uint32_t meshEdgeIndex0(uint32_t edge) { return edge; }
 
-		virtual bool isDone() const
-		{
-			return m_end == m_current;
-		}
-		virtual const Edge *current() const
-		{
-			return m_current;
-		}
-		const Vertex *vertex() const
-		{
-			return m_current->vertex;
-		}
-
-	private:
-		const Edge *m_end;
-		const Edge *m_current;
-	};
+static uint32_t meshEdgeIndex1(uint32_t edge)
+{
+	const uint32_t faceFirstEdge = edge / 3 * 3;
+	return faceFirstEdge + (edge - faceFirstEdge + 1) % 3;
+}
 
-	ConstEdgeIterator edges() const
-	{
-		return ConstEdgeIterator(edge);
-	}
-	ConstEdgeIterator edges(const Edge *e) const
+struct MeshFlags
+{
+	enum
 	{
-		xaDebugAssert(contains(e));
-		return ConstEdgeIterator(e);
-	}
+		HasFaceGroups = 1<<0,
+		HasIgnoredFaces = 1<<1,
+		HasNormals = 1<<2
+	};
 };
 
-/// Simple half edge mesh designed for dynamic mesh manipulation.
+class Mesh;
+static void meshGetBoundaryLoops(const Mesh &mesh, Array<uint32_t> &boundaryLoops);
+
 class Mesh
 {
 public:
-	Mesh() : m_colocalVertexCount(0) {}
-
-	Mesh(const Mesh *mesh)
-	{
-		// Copy mesh vertices.
-		const uint32_t vertexCount = mesh->vertexCount();
-		m_vertexArray.resize(vertexCount);
-		for (uint32_t v = 0; v < vertexCount; v++) {
-			const Vertex *vertex = mesh->vertexAt(v);
-			xaDebugAssert(vertex->id == v);
-			m_vertexArray[v] = new Vertex(v);
-			m_vertexArray[v]->pos = vertex->pos;
-			m_vertexArray[v]->nor = vertex->nor;
-			m_vertexArray[v]->tex = vertex->tex;
-		}
-		m_colocalVertexCount = vertexCount;
-		// Copy mesh faces.
-		const uint32_t faceCount = mesh->faceCount();
-		std::vector<uint32_t> indexArray;
-		indexArray.reserve(3);
-		for (uint32_t f = 0; f < faceCount; f++) {
-			const Face *face = mesh->faceAt(f);
-			for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const Vertex *vertex = it.current()->from();
-				indexArray.push_back(vertex->id);
-			}
-			addFace(indexArray);
-			indexArray.clear();
-		}
-	}
-
-	~Mesh()
+	Mesh(float epsilon, uint32_t approxVertexCount, uint32_t approxFaceCount, uint32_t flags = 0, uint32_t id = UINT32_MAX) : m_epsilon(epsilon), m_flags(flags), m_id(id), m_faceIgnore(MemTag::Mesh), m_faceGroups(MemTag::Mesh), m_indices(MemTag::MeshIndices), m_positions(MemTag::MeshPositions), m_normals(MemTag::MeshNormals), m_texcoords(MemTag::MeshTexcoords), m_colocalVertexCount(0), m_nextColocalVertex(MemTag::MeshColocals), m_boundaryVertices(MemTag::MeshBoundaries), m_oppositeEdges(MemTag::MeshBoundaries), m_nextBoundaryEdges(MemTag::MeshBoundaries), m_edgeMap(MemTag::MeshEdgeMap, approxFaceCount * 3)
 	{
-		clear();
+		m_indices.reserve(approxFaceCount * 3);
+		m_positions.reserve(approxVertexCount);
+		m_texcoords.reserve(approxVertexCount);
+		if (m_flags & MeshFlags::HasFaceGroups)
+			m_faceGroups.reserve(approxFaceCount);
+		if (m_flags & MeshFlags::HasIgnoredFaces)
+			m_faceIgnore.reserve(approxFaceCount);
+		if (m_flags & MeshFlags::HasNormals)
+			m_normals.reserve(approxVertexCount);
 	}
 
-	void clear()
-	{
-		for (size_t i = 0; i < m_vertexArray.size(); i++)
-			delete m_vertexArray[i];
-		m_vertexArray.clear();
-		for (auto it = m_edgeMap.begin(); it != m_edgeMap.end(); it++)
-			delete it->second;
-		m_edgeArray.clear();
-		m_edgeMap.clear();
-		for (size_t i = 0; i < m_faceArray.size(); i++)
-			delete m_faceArray[i];
-		m_faceArray.clear();
-	}
+	uint32_t flags() const { return m_flags; }
+	uint32_t id() const { return m_id; }
 
-	Vertex *addVertex(const Vector3 &pos)
+	void addVertex(const Vector3 &pos, const Vector3 &normal = Vector3(0.0f), const Vector2 &texcoord = Vector2(0.0f))
 	{
-		xaDebugAssert(isFinite(pos));
-		Vertex *v = new Vertex(m_vertexArray.size());
-		v->pos = pos;
-		m_vertexArray.push_back(v);
-		return v;
-	}
-
-	/// Link colocal vertices based on geometric location only.
-	void linkColocals()
-	{
-		xaPrint("--- Linking colocals:\n");
-		const uint32_t vertexCount = this->vertexCount();
-		std::unordered_map<Vector3, Vertex *, Hash<Vector3>, Equal<Vector3> > vertexMap;
-		vertexMap.reserve(vertexCount);
-		for (uint32_t v = 0; v < vertexCount; v++) {
-			Vertex *vertex = vertexAt(v);
-			Vertex *colocal = vertexMap[vertex->pos];
-			if (colocal) {
-				colocal->linkColocal(vertex);
-			} else {
-				vertexMap[vertex->pos] = vertex;
-			}
-		}
-		m_colocalVertexCount = vertexMap.size();
-		xaPrint("---   %d vertex positions.\n", m_colocalVertexCount);
-		// @@ Remove duplicated vertices? or just leave them as colocals?
+		XA_DEBUG_ASSERT(isFinite(pos));
+		m_positions.push_back(pos);
+		if (m_flags & MeshFlags::HasNormals)
+			m_normals.push_back(normal);
+		m_texcoords.push_back(texcoord);
 	}
 
-	void linkColocalsWithCanonicalMap(const std::vector<uint32_t> &canonicalMap)
+	struct AddFaceResult
 	{
-		xaPrint("--- Linking colocals:\n");
-		uint32_t vertexMapSize = 0;
-		for (uint32_t i = 0; i < canonicalMap.size(); i++) {
-			vertexMapSize = std::max(vertexMapSize, canonicalMap[i] + 1);
-		}
-		std::vector<Vertex *> vertexMap;
-		vertexMap.resize(vertexMapSize, NULL);
-		m_colocalVertexCount = 0;
-		const uint32_t vertexCount = this->vertexCount();
-		for (uint32_t v = 0; v < vertexCount; v++) {
-			Vertex *vertex = vertexAt(v);
-			Vertex *colocal = vertexMap[canonicalMap[v]];
-			if (colocal != NULL) {
-				xaDebugAssert(vertex->pos == colocal->pos);
-				colocal->linkColocal(vertex);
-			} else {
-				vertexMap[canonicalMap[v]] = vertex;
-				m_colocalVertexCount++;
-			}
-		}
-		xaPrint("---   %d vertex positions.\n", m_colocalVertexCount);
-	}
-
-	Face *addFace()
-	{
-		Face *f = new Face(m_faceArray.size());
-		m_faceArray.push_back(f);
-		return f;
-	}
+		enum Enum
+		{
+			OK,
+			DuplicateEdge = 1
+		};
+	};
 
-	Face *addFace(uint32_t v0, uint32_t v1, uint32_t v2)
+	AddFaceResult::Enum addFace(uint32_t v0, uint32_t v1, uint32_t v2, bool ignore = false, bool hashEdge = true)
 	{
 		uint32_t indexArray[3];
 		indexArray[0] = v0;
 		indexArray[1] = v1;
 		indexArray[2] = v2;
-		return addFace(indexArray, 3, 0, 3);
-	}
-
-	Face *addFace(uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3)
-	{
-		uint32_t indexArray[4];
-		indexArray[0] = v0;
-		indexArray[1] = v1;
-		indexArray[2] = v2;
-		indexArray[3] = v3;
-		return addFace(indexArray, 4, 0, 4);
+		return addFace(indexArray, ignore, hashEdge);
 	}
 
-	Face *addFace(const std::vector<uint32_t> &indexArray)
+	AddFaceResult::Enum addFace(const uint32_t *indices, bool ignore = false, bool hashEdge = true)
 	{
-		return addFace(indexArray, 0, indexArray.size());
+		AddFaceResult::Enum result = AddFaceResult::OK;
+		if (m_flags & MeshFlags::HasFaceGroups)
+			m_faceGroups.push_back(UINT32_MAX);
+		if (m_flags & MeshFlags::HasIgnoredFaces)
+			m_faceIgnore.push_back(ignore);
+		const uint32_t firstIndex = m_indices.size();
+		for (uint32_t i = 0; i < 3; i++)
+			m_indices.push_back(indices[i]);
+		if (hashEdge) {
+			for (uint32_t i = 0; i < 3; i++) {
+				const uint32_t vertex0 = m_indices[firstIndex + i];
+				const uint32_t vertex1 = m_indices[firstIndex + (i + 1) % 3];
+				const EdgeKey key(vertex0, vertex1);
+				if (m_edgeMap.get(key) != UINT32_MAX)
+					result = AddFaceResult::DuplicateEdge;
+				m_edgeMap.add(key, firstIndex + i);
+			}
+		}
+		return result;
 	}
 
-	Face *addFace(const std::vector<uint32_t> &indexArray, uint32_t first, uint32_t num)
+	void createColocals()
 	{
-		return addFace(indexArray.data(), (uint32_t)indexArray.size(), first, num);
+		const uint32_t vertexCount = m_positions.size();
+		Array<AABB> aabbs;
+		aabbs.resize(vertexCount);
+		for (uint32_t i = 0; i < m_positions.size(); i++)
+			aabbs[i] = AABB(m_positions[i], m_epsilon);
+		BVH bvh(aabbs);
+		Array<uint32_t> colocals;
+		Array<uint32_t> potential;
+		m_colocalVertexCount = 0;
+		m_nextColocalVertex.resize(vertexCount, UINT32_MAX);
+		for (uint32_t i = 0; i < vertexCount; i++) {
+			if (m_nextColocalVertex[i] != UINT32_MAX)
+				continue; // Already linked.
+			// Find other vertices colocal to this one.
+			colocals.clear();
+			colocals.push_back(i); // Always add this vertex.
+			bvh.query(AABB(m_positions[i], m_epsilon), potential);
+			for (uint32_t j = 0; j < potential.size(); j++) {
+				const uint32_t otherVertex = potential[j];
+				if (otherVertex != i && equal(m_positions[i], m_positions[otherVertex], m_epsilon) && m_nextColocalVertex[otherVertex] == UINT32_MAX)
+					colocals.push_back(otherVertex);
+			}
+			if (colocals.size() == 1) {
+				// No colocals for this vertex.
+				m_nextColocalVertex[i] = i;
+				continue; 
+			}
+			m_colocalVertexCount += colocals.size();
+			// Link in ascending order.
+			insertionSort(colocals.data(), colocals.size());
+			for (uint32_t j = 0; j < colocals.size(); j++)
+				m_nextColocalVertex[colocals[j]] = colocals[(j + 1) % colocals.size()];
+			XA_DEBUG_ASSERT(m_nextColocalVertex[i] != UINT32_MAX);
+		}
 	}
 
-	Face *addFace(const uint32_t *indexArray, uint32_t indexCount, uint32_t first, uint32_t num)
+	// Check if the face duplicates any edges of any face already in the group.
+	bool faceDuplicatesGroupEdge(uint32_t group, uint32_t face) const
 	{
-		xaDebugAssert(first < indexCount);
-		xaDebugAssert(num <= indexCount - first);
-		xaDebugAssert(num > 2);
-		if (!canAddFace(indexArray, first, num)) {
-			return NULL;
-		}
-		Face *f = new Face(m_faceArray.size());
-		Edge *firstEdge = NULL;
-		Edge *last = NULL;
-		Edge *current = NULL;
-		for (uint32_t i = 0; i < num - 1; i++) {
-			current = addEdge(indexArray[first + i], indexArray[first + i + 1]);
-			xaAssert(current != NULL && current->face == NULL);
-			current->face = f;
-			if (last != NULL) last->setNext(current);
-			else firstEdge = current;
-			last = current;
+		for (FaceEdgeIterator edgeIt(this, face); !edgeIt.isDone(); edgeIt.advance()) {
+			for (ColocalEdgeIterator colocalEdgeIt(this, edgeIt.vertex0(), edgeIt.vertex1()); !colocalEdgeIt.isDone(); colocalEdgeIt.advance()) {
+				if (m_faceGroups[meshEdgeFace(colocalEdgeIt.edge())] == group)
+					return true;
+			}
 		}
-		current = addEdge(indexArray[first + num - 1], indexArray[first]);
-		xaAssert(current != NULL && current->face == NULL);
-		current->face = f;
-		last->setNext(current);
-		current->setNext(firstEdge);
-		f->edge = firstEdge;
-		m_faceArray.push_back(f);
-		return f;
+		return false;
 	}
 
-	// -- GODOT start --
-	Face *addUniqueFace(uint32_t v0, uint32_t v1, uint32_t v2) {
-
-		int base_vertex = m_vertexArray.size();
-
-		uint32_t ids[3] = { v0, v1, v2 };
-
-		Vector3 base[3] = {
-			m_vertexArray[v0]->pos,
-			m_vertexArray[v1]->pos,
-			m_vertexArray[v2]->pos,
-		};
-
-		//make sure its not a degenerate
-		bool degenerate = distanceSquared(base[0], base[1]) < NV_EPSILON || distanceSquared(base[0], base[2]) < NV_EPSILON || distanceSquared(base[1], base[2]) < NV_EPSILON;
-		xaDebugAssert(!degenerate);
-
-		float min_x = 0;
-
-		for (int i = 0; i < 3; i++) {
-			if (i == 0 || m_vertexArray[v0]->pos.x < min_x) {
-				min_x = m_vertexArray[v0]->pos.x;
+	// Check if the face mirrors any face already in the group.
+	// i.e. don't want two-sided faces in the same group.
+	// A face mirrors another face if all edges match with opposite winding.
+	bool faceMirrorsGroupFace(uint32_t group, uint32_t face) const
+	{
+		FaceEdgeIterator edgeIt(this, face);
+		for (ColocalEdgeIterator colocalEdgeIt(this, edgeIt.vertex1(), edgeIt.vertex0()); !colocalEdgeIt.isDone(); colocalEdgeIt.advance()) {
+			const uint32_t candidateFace = meshEdgeFace(colocalEdgeIt.edge());
+			if (m_faceGroups[candidateFace] == group) {
+				// Found a match for mirrored first edge, try the other edges.
+				bool match = false;
+				for (; !edgeIt.isDone(); edgeIt.advance()) {
+					match = false;
+					for (ColocalEdgeIterator colocalEdgeIt2(this, edgeIt.vertex1(), edgeIt.vertex0()); !colocalEdgeIt2.isDone(); colocalEdgeIt2.advance()) {
+						if (meshEdgeFace(colocalEdgeIt2.edge()) == candidateFace) {
+							match = true;
+							break;
+						}
+					}
+					if (!match)
+						break;
+				}
+				if (match)
+					return true; // All edges are mirrored in this face.
+				// Try the next face.
+				edgeIt = FaceEdgeIterator(this, candidateFace);
 			}
 		}
+		return false;
+	}
 
-		float max_x = 0;
-
-		for (int j = 0; j < m_vertexArray.size(); j++) {
-			if (j == 0 || m_vertexArray[j]->pos.x > max_x) { //vertex already exists
-				max_x = m_vertexArray[j]->pos.x;
+	void createFaceGroups()
+	{
+		uint32_t group = 0;
+		Array<uint32_t> growFaces;
+		for (;;) {
+			// Find an unassigned face.
+			uint32_t face = UINT32_MAX;
+			for (uint32_t f = 0; f < faceCount(); f++) {
+				if (m_faceGroups[f] == UINT32_MAX && !isFaceIgnored(f)) {
+					face = f;
+					break;
+				}
 			}
+			if (face == UINT32_MAX)
+				break; // All faces assigned to a group (except ignored faces).
+			m_faceGroups[face] = group;
+			growFaces.clear();
+			growFaces.push_back(face);
+			// Find faces connected to the face and assign them to the same group as the face, unless they are already assigned to another group.
+			for (;;) {
+				if (growFaces.isEmpty())
+					break;
+				const uint32_t f = growFaces.back();
+				growFaces.pop_back();
+				for (FaceEdgeIterator edgeIt(this, f); !edgeIt.isDone(); edgeIt.advance()) {
+					// Iterate opposite edges. There may be more than one - non-manifold geometry can have duplicate edges.
+					// Prioritize the one with exact vertex match, not just colocal.
+					// If *any* of the opposite edges are already assigned to this group, don't do anything.
+					bool alreadyAssignedToThisGroup = false;
+					uint32_t bestConnectedFace = UINT32_MAX;
+					for (ColocalEdgeIterator oppositeEdgeIt(this, edgeIt.vertex1(), edgeIt.vertex0()); !oppositeEdgeIt.isDone(); oppositeEdgeIt.advance()) {
+						const uint32_t oppositeEdge = oppositeEdgeIt.edge();
+						const uint32_t oppositeFace = meshEdgeFace(oppositeEdge);
+						if (isFaceIgnored(oppositeFace))
+							continue; // Don't add ignored faces to group.
+						if (m_faceGroups[oppositeFace] == group) {
+							alreadyAssignedToThisGroup = true;
+							break;
+						}
+						if (m_faceGroups[oppositeFace] != UINT32_MAX)
+							continue; // Connected face is already assigned to another group.
+						if (faceDuplicatesGroupEdge(group, oppositeFace))
+							continue; // Don't want duplicate edges in a group.
+						if (faceMirrorsGroupFace(group, oppositeFace))
+							continue; // Don't want two-sided faces in a group.
+						const uint32_t oppositeVertex0 = m_indices[meshEdgeIndex0(oppositeEdge)];
+						const uint32_t oppositeVertex1 = m_indices[meshEdgeIndex1(oppositeEdge)];
+						if (bestConnectedFace == UINT32_MAX || (oppositeVertex0 == edgeIt.vertex1() && oppositeVertex1 == edgeIt.vertex0()))
+							bestConnectedFace = oppositeFace;
+					}
+					if (!alreadyAssignedToThisGroup && bestConnectedFace != UINT32_MAX) {
+						m_faceGroups[bestConnectedFace] = group;
+						growFaces.push_back(bestConnectedFace);
+					}
+				}
+			}
+			group++;
 		}
-
-		//separate from everything else, in x axis
-		for (int i = 0; i < 3; i++) {
-
-			base[i].x -= min_x;
-			base[i].x += max_x + 10.0;
-		}
-
-		for (int i = 0; i < 3; i++) {
-			Vertex *v = new Vertex(m_vertexArray.size());
-			v->pos = base[i];
-			v->nor = m_vertexArray[ids[i]]->nor,
-			v->tex = m_vertexArray[ids[i]]->tex,
-
-			v->original_id = ids[i];
-			m_vertexArray.push_back(v);
-		}
-
-		uint32_t indexArray[3];
-		indexArray[0] = base_vertex + 0;
-		indexArray[1] = base_vertex + 1;
-		indexArray[2] = base_vertex + 2;
-		return addFace(indexArray, 3, 0, 3);
 	}
-	// -- GODOT end --
-
-	// These functions disconnect the given element from the mesh and delete it.
 
-	// @@ We must always disconnect edge pairs simultaneously.
-	void disconnect(Edge *edge)
+	void createBoundaries()
 	{
-		xaDebugAssert(edge != NULL);
-		// Remove from edge list.
-		if ((edge->id & 1) == 0) {
-			xaDebugAssert(m_edgeArray[edge->id / 2] == edge);
-			m_edgeArray[edge->id / 2] = NULL;
-		}
-		// Remove edge from map. @@ Store map key inside edge?
-		xaDebugAssert(edge->from() != NULL && edge->to() != NULL);
-		size_t removed = m_edgeMap.erase(Key(edge->from()->id, edge->to()->id));
-		xaDebugAssert(removed == 1);
-#ifdef NDEBUG
-		removed = 0; // silence unused parameter warning
+		const uint32_t edgeCount = m_indices.size();
+		const uint32_t vertexCount = m_positions.size();
+		m_oppositeEdges.resize(edgeCount);
+		m_boundaryVertices.resize(vertexCount);
+		for (uint32_t i = 0; i < edgeCount; i++)
+			m_oppositeEdges[i] = UINT32_MAX;
+		for (uint32_t i = 0; i < vertexCount; i++)
+			m_boundaryVertices[i] = false;
+		const bool hasFaceGroups = m_flags & MeshFlags::HasFaceGroups;
+		for (uint32_t i = 0; i < faceCount(); i++) {
+			if (isFaceIgnored(i))
+				continue;
+			for (uint32_t j = 0; j < 3; j++) {
+				const uint32_t vertex0 = m_indices[i * 3 + j];
+				const uint32_t vertex1 = m_indices[i * 3 + (j + 1) % 3];
+				// If there is an edge with opposite winding to this one, the edge isn't on a boundary.
+				const uint32_t oppositeEdge = findEdge(hasFaceGroups ? m_faceGroups[i] : UINT32_MAX, vertex1, vertex0);
+				if (oppositeEdge != UINT32_MAX) {
+#if XA_DEBUG
+					if (hasFaceGroups)
+						XA_DEBUG_ASSERT(m_faceGroups[meshEdgeFace(oppositeEdge)] == m_faceGroups[i]);
 #endif
-		// Disconnect from vertex.
-		if (edge->vertex != NULL) {
-			if (edge->vertex->edge == edge) {
-				if (edge->prev && edge->prev->pair) {
-					edge->vertex->edge = edge->prev->pair;
-				} else if (edge->pair && edge->pair->next) {
-					edge->vertex->edge = edge->pair->next;
+					XA_DEBUG_ASSERT(!isFaceIgnored(meshEdgeFace(oppositeEdge)));
+					m_oppositeEdges[i * 3 + j] = oppositeEdge;
 				} else {
-					edge->vertex->edge = NULL;
-					// @@ Remove disconnected vertex?
+					m_boundaryVertices[vertex0] = m_boundaryVertices[vertex1] = true;
 				}
 			}
 		}
-		// Disconnect from face.
-		if (edge->face != NULL) {
-			if (edge->face->edge == edge) {
-				if (edge->next != NULL && edge->next != edge) {
-					edge->face->edge = edge->next;
-				} else if (edge->prev != NULL && edge->prev != edge) {
-					edge->face->edge = edge->prev;
-				} else {
-					edge->face->edge = NULL;
-					// @@ Remove disconnected face?
+	}
+
+	void linkBoundaries()
+	{
+		const uint32_t edgeCount = m_indices.size();
+		HashMap<uint32_t, uint32_t> vertexToEdgeMap(MemTag::Mesh, edgeCount);
+		for (uint32_t i = 0; i < edgeCount; i++) {
+			const uint32_t vertex0 = m_indices[meshEdgeIndex0(i)];
+			const uint32_t vertex1 = m_indices[meshEdgeIndex1(i)];
+			vertexToEdgeMap.add(vertex0, i);
+			vertexToEdgeMap.add(vertex1, i);
+		}
+		m_nextBoundaryEdges.resize(edgeCount);
+		for (uint32_t i = 0; i < edgeCount; i++)
+			m_nextBoundaryEdges[i] = UINT32_MAX;
+		uint32_t numBoundaryLoops = 0, numUnclosedBoundaries = 0;
+		BitArray linkedEdges(edgeCount);
+		linkedEdges.clearAll();
+		for (;;) {
+			// Find the first boundary edge that hasn't been linked yet.
+			uint32_t firstEdge = UINT32_MAX;
+			for (uint32_t i = 0; i < edgeCount; i++) {
+				if (m_oppositeEdges[i] == UINT32_MAX && !linkedEdges.bitAt(i)) {
+					firstEdge = i;
+					break;
 				}
 			}
-		}
-		// Disconnect from previous.
-		if (edge->prev) {
-			if (edge->prev->next == edge) {
-				edge->prev->setNext(NULL);
+			if (firstEdge == UINT32_MAX)
+				break;
+			uint32_t currentEdge = firstEdge;
+			for (;;) {
+				// Find the next boundary edge. The first vertex will be the same as (or colocal to) the current edge second vertex.
+				const uint32_t startVertex = m_indices[meshEdgeIndex1(currentEdge)];
+				uint32_t bestNextEdge = UINT32_MAX;
+				for (ColocalVertexIterator it(this, startVertex); !it.isDone(); it.advance()) {
+					uint32_t mapOtherEdgeIndex = vertexToEdgeMap.get(it.vertex());
+					while (mapOtherEdgeIndex != UINT32_MAX) {
+						const uint32_t otherEdge = vertexToEdgeMap.value(mapOtherEdgeIndex);
+						if (m_oppositeEdges[otherEdge] != UINT32_MAX)
+							goto next; // Not a boundary edge.
+						if (linkedEdges.bitAt(otherEdge))
+							goto next; // Already linked.
+						if (m_flags & MeshFlags::HasFaceGroups && m_faceGroups[meshEdgeFace(currentEdge)] != m_faceGroups[meshEdgeFace(otherEdge)])
+							goto next; // Don't cross face groups.
+						if (isFaceIgnored(meshEdgeFace(otherEdge)))
+							goto next; // Face is ignored.
+						if (m_indices[meshEdgeIndex0(otherEdge)] != it.vertex())
+							goto next; // Edge contains the vertex, but it's the wrong one.
+						// First edge (closing the boundary loop) has the highest priority.
+						// Non-colocal vertex has the next highest.
+						if (bestNextEdge != firstEdge && (bestNextEdge == UINT32_MAX || it.vertex() == startVertex))
+							bestNextEdge = otherEdge;
+					next:
+						mapOtherEdgeIndex = vertexToEdgeMap.getNext(mapOtherEdgeIndex);
+					}
+				}
+				if (bestNextEdge == UINT32_MAX) {
+					numUnclosedBoundaries++;
+					if (currentEdge == firstEdge)
+						linkedEdges.setBitAt(firstEdge); // Only 1 edge in this boundary "loop".
+					break; // Can't find a next edge.
+				}
+				m_nextBoundaryEdges[currentEdge] = bestNextEdge;
+				linkedEdges.setBitAt(bestNextEdge);
+				currentEdge = bestNextEdge;
+				if (currentEdge == firstEdge) {
+					numBoundaryLoops++;
+					break; // Closed the boundary loop.
+				}
 			}
-			//edge->setPrev(NULL);
 		}
-		// Disconnect from next.
-		if (edge->next) {
-			if (edge->next->prev == edge) {
-				edge->next->setPrev(NULL);
+		// Find internal boundary loops and separate them.
+		// Detect by finding two edges in a boundary loop that have a colocal end vertex.
+		// Fix by swapping their next boundary edge.
+		// Need to start over after every fix since known boundary loops have changed.
+		Array<uint32_t> boundaryLoops;
+	fixInternalBoundary:
+		meshGetBoundaryLoops(*this, boundaryLoops);
+		for (uint32_t loop = 0; loop < boundaryLoops.size(); loop++) {
+			linkedEdges.clearAll();
+			for (Mesh::BoundaryEdgeIterator it1(this, boundaryLoops[loop]); !it1.isDone(); it1.advance()) {
+				const uint32_t e1 = it1.edge();
+				if (linkedEdges.bitAt(e1))
+					continue;
+				for (Mesh::BoundaryEdgeIterator it2(this, boundaryLoops[loop]); !it2.isDone(); it2.advance()) {
+					const uint32_t e2 = it2.edge();
+					if (e1 == e2 || !isBoundaryEdge(e2) || linkedEdges.bitAt(e2))
+						continue;
+					if (!areColocal(m_indices[meshEdgeIndex1(e1)], m_indices[meshEdgeIndex1(e2)]))
+						continue;
+					swap(m_nextBoundaryEdges[e1], m_nextBoundaryEdges[e2]);
+					linkedEdges.setBitAt(e1);
+					linkedEdges.setBitAt(e2);
+					goto fixInternalBoundary; // start over
+				}
 			}
-			//edge->setNext(NULL);
 		}
 	}
 
-	void remove(Edge *edge)
-	{
-		xaDebugAssert(edge != NULL);
-		disconnect(edge);
-		delete edge;
+	/// Find edge, test all colocals.
+	uint32_t findEdge(uint32_t faceGroup, uint32_t vertex0, uint32_t vertex1) const
+	{
+		uint32_t result = UINT32_MAX;
+		if (m_nextColocalVertex.isEmpty()) {
+			EdgeKey key(vertex0, vertex1);
+			uint32_t mapEdgeIndex = m_edgeMap.get(key);
+			while (mapEdgeIndex != UINT32_MAX) {
+				const uint32_t edge = m_edgeMap.value(mapEdgeIndex);
+				// Don't find edges of ignored faces.
+				if ((faceGroup == UINT32_MAX || m_faceGroups[meshEdgeFace(edge)] == faceGroup) && !isFaceIgnored(meshEdgeFace(edge))) {
+					//XA_DEBUG_ASSERT(m_id != UINT32_MAX || (m_id == UINT32_MAX && result == UINT32_MAX)); // duplicate edge - ignore on initial meshes
+					result = edge;
+#if !XA_DEBUG
+					return result;
+#endif
+				}
+				mapEdgeIndex = m_edgeMap.getNext(mapEdgeIndex);
+			}
+		} else {
+			for (ColocalVertexIterator it0(this, vertex0); !it0.isDone(); it0.advance()) {
+				for (ColocalVertexIterator it1(this, vertex1); !it1.isDone(); it1.advance()) {
+					EdgeKey key(it0.vertex(), it1.vertex());
+					uint32_t mapEdgeIndex = m_edgeMap.get(key);
+					while (mapEdgeIndex != UINT32_MAX) {
+						const uint32_t edge = m_edgeMap.value(mapEdgeIndex);
+						// Don't find edges of ignored faces.
+						if ((faceGroup == UINT32_MAX || m_faceGroups[meshEdgeFace(edge)] == faceGroup) && !isFaceIgnored(meshEdgeFace(edge))) {
+							XA_DEBUG_ASSERT(m_id != UINT32_MAX || (m_id == UINT32_MAX && result == UINT32_MAX)); // duplicate edge - ignore on initial meshes
+							result = edge;
+#if !XA_DEBUG
+							return result;
+#endif
+						}
+						mapEdgeIndex = m_edgeMap.getNext(mapEdgeIndex);
+					}
+				}
+			}
+		}
+		return result;
 	}
 
-	void remove(Vertex *vertex)
+#if XA_DEBUG_EXPORT_OBJ
+	void writeObjVertices(FILE *file) const
 	{
-		xaDebugAssert(vertex != NULL);
-		// Remove from vertex list.
-		m_vertexArray[vertex->id] = NULL;
-		// Disconnect from colocals.
-		vertex->unlinkColocal();
-		// Disconnect from edges.
-		if (vertex->edge != NULL) {
-			// @@ Removing a connected vertex is asking for trouble...
-			if (vertex->edge->vertex == vertex) {
-				// @@ Connect edge to a colocal?
-				vertex->edge->vertex = NULL;
-			}
-			vertex->setEdge(NULL);
+		for (uint32_t i = 0; i < m_positions.size(); i++)
+			fprintf(file, "v %g %g %g\n", m_positions[i].x, m_positions[i].y, m_positions[i].z);
+		if (m_flags & MeshFlags::HasNormals) {
+			for (uint32_t i = 0; i < m_normals.size(); i++)
+				fprintf(file, "vn %g %g %g\n", m_normals[i].x, m_normals[i].y, m_normals[i].z);
 		}
-		delete vertex;
+		for (uint32_t i = 0; i < m_texcoords.size(); i++)
+			fprintf(file, "vt %g %g\n", m_texcoords[i].x, m_texcoords[i].y);
 	}
 
-	void remove(Face *face)
+	void writeObjFace(FILE *file, uint32_t face) const
 	{
-		xaDebugAssert(face != NULL);
-		// Remove from face list.
-		m_faceArray[face->id] = NULL;
-		// Disconnect from edges.
-		if (face->edge != NULL) {
-			xaDebugAssert(face->edge->face == face);
-			face->edge->face = NULL;
-			face->edge = NULL;
+		fprintf(file, "f ");
+		for (uint32_t j = 0; j < 3; j++) {
+			const uint32_t index = m_indices[face * 3 + j] + 1; // 1-indexed
+			fprintf(file, "%d/%d/%d%c", index, index, index, j == 2 ? '\n' : ' ');
 		}
-		delete face;
 	}
 
-	// Triangulate in place.
-	void triangulate()
+	void writeObjBoundaryEges(FILE *file) const
 	{
-		bool all_triangles = true;
-		const uint32_t faceCount = m_faceArray.size();
-		for (uint32_t f = 0; f < faceCount; f++) {
-			Face *face = m_faceArray[f];
-			if (face->edgeCount() != 3) {
-				all_triangles = false;
-				break;
-			}
-		}
-		if (all_triangles) {
-			return;
-		}
-		// Do not touch vertices, but rebuild edges and faces.
-		std::vector<Edge *> edgeArray;
-		std::vector<Face *> faceArray;
-		std::swap(edgeArray, m_edgeArray);
-		std::swap(faceArray, m_faceArray);
-		m_edgeMap.clear();
-		for (uint32_t f = 0; f < faceCount; f++) {
-			Face *face = faceArray[f];
-			// Trivial fan-like triangulation.
-			const uint32_t v0 = face->edge->vertex->id;
-			uint32_t v2, v1 = (uint32_t)-1;
-			for (Face::EdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				Edge *edge = it.current();
-				v2 = edge->to()->id;
-				if (v2 == v0) break;
-				if (v1 != -1) addFace(v0, v1, v2);
-				v1 = v2;
-			}
-		}
-		xaDebugAssert(m_faceArray.size() > faceCount); // triangle count > face count
-		linkBoundary();
-		for (size_t i = 0; i < edgeArray.size(); i++)
-			delete edgeArray[i];
-		for (size_t i = 0; i < faceArray.size(); i++)
-			delete faceArray[i];
-	}
-
-	/// Link boundary edges once the mesh has been created.
-	void linkBoundary()
-	{
-		xaPrint("--- Linking boundaries:\n");
-		int num = 0;
-		// Create boundary edges.
-		uint32_t edgeCount = this->edgeCount();
-		for (uint32_t e = 0; e < edgeCount; e++) {
-			Edge *edge = edgeAt(e);
-			if (edge != NULL && edge->pair == NULL) {
-				Edge *pair = new Edge(edge->id + 1);
-				uint32_t i = edge->from()->id;
-				uint32_t j = edge->next->from()->id;
-				Key key(j, i);
-				xaAssert(m_edgeMap.find(key) == m_edgeMap.end());
-				pair->vertex = m_vertexArray[j];
-				m_edgeMap[key] = pair;
-				edge->pair = pair;
-				pair->pair = edge;
-				num++;
-			}
-		}
-		// Link boundary edges.
-		for (uint32_t e = 0; e < edgeCount; e++) {
-			Edge *edge = edgeAt(e);
-			if (edge != NULL && edge->pair->face == NULL) {
-				linkBoundaryEdge(edge->pair);
+		if (m_oppositeEdges.isEmpty())
+			return; // Boundaries haven't been created.
+		fprintf(file, "o boundary_edges\n");
+		for (uint32_t i = 0; i < edgeCount(); i++) {
+			if (m_oppositeEdges[i] != UINT32_MAX)
+				continue;
+			fprintf(file, "l %d %d\n", m_indices[meshEdgeIndex0(i)] + 1, m_indices[meshEdgeIndex1(i)] + 1); // 1-indexed
+		}
+	}
+
+	void writeObjLinkedBoundaries(FILE *file) const
+	{
+		if (m_oppositeEdges.isEmpty() || m_nextBoundaryEdges.isEmpty())
+			return; // Boundaries haven't been created and/or linked.
+		Array<uint32_t> boundaryLoops;
+		meshGetBoundaryLoops(*this, boundaryLoops);
+		for (uint32_t i = 0; i < boundaryLoops.size(); i++) {
+			uint32_t edge = boundaryLoops[i];
+			fprintf(file, "o boundary_%04d\n", i);
+			fprintf(file, "l");
+			for (;;) {
+				const uint32_t vertex0 = m_indices[meshEdgeIndex0(edge)];
+				const uint32_t vertex1 = m_indices[meshEdgeIndex1(edge)];
+				fprintf(file, " %d", vertex0 + 1); // 1-indexed
+				edge = m_nextBoundaryEdges[edge];
+				if (edge == boundaryLoops[i] || edge == UINT32_MAX) {
+					fprintf(file, " %d\n", vertex1 + 1); // 1-indexed
+					break;
+				}
 			}
 		}
-		xaPrint("---   %d boundary edges.\n", num);
 	}
 
-	/*
-	Fixing T-junctions.
+	void writeObjFile(const char *filename) const
+	{
+		FILE *file;
+		XA_FOPEN(file, filename, "w");
+		if (!file)
+			return;
+		writeObjVertices(file);
+		fprintf(file, "s off\n");
+		fprintf(file, "o object\n");
+		for (uint32_t i = 0; i < faceCount(); i++)
+			writeObjFace(file, i);
+		writeObjBoundaryEges(file);
+		writeObjLinkedBoundaries(file);
+		fclose(file);
+	}
+#endif
 
-	- Find T-junctions. Find  vertices that are on an edge.
-		- This test is approximate.
-		- Insert edges on a spatial index to speedup queries.
-		- Consider only open edges, that is edges that have no pairs.
-		- Consider only vertices on boundaries.
-	- Close T-junction.
-		- Split edge.
+	float computeSurfaceArea() const
+	{
+		float area = 0;
+		for (uint32_t f = 0; f < faceCount(); f++)
+			area += faceArea(f);
+		XA_DEBUG_ASSERT(area >= 0);
+		return area;
+	}
 
-	*/
-	bool splitBoundaryEdges() // Returns true if any split was made.
-	{
-		std::vector<Vertex *> boundaryVertices;
-		for (uint32_t i = 0; i < m_vertexArray.size(); i++) {
-			Vertex *v = m_vertexArray[i];
-			if (v->isBoundary()) {
-				boundaryVertices.push_back(v);
-			}
-		}
-		xaPrint("Fixing T-junctions:\n");
-		int splitCount = 0;
-		for (uint32_t v = 0; v < boundaryVertices.size(); v++) {
-			Vertex *vertex = boundaryVertices[v];
-			Vector3 x0 = vertex->pos;
-			// Find edges that this vertex overlaps with.
-			for (uint32_t e = 0; e < m_edgeArray.size(); e++) {
-				Edge *edge = m_edgeArray[e];
-				if (edge != NULL && edge->isBoundary()) {
-					if (edge->from() == vertex || edge->to() == vertex) {
-						continue;
-					}
-					Vector3 x1 = edge->from()->pos;
-					Vector3 x2 = edge->to()->pos;
-					Vector3 v01 = x0 - x1;
-					Vector3 v21 = x2 - x1;
-					float l = length(v21);
-					float d = length(cross(v01, v21)) / l;
-					if (isZero(d)) {
-						float t = dot(v01, v21) / (l * l);
-						if (t > 0.0f + NV_EPSILON && t < 1.0f - NV_EPSILON) {
-							xaDebugAssert(equal(lerp(x1, x2, t), x0));
-							Vertex *splitVertex = splitBoundaryEdge(edge, t, x0);
-							vertex->linkColocal(splitVertex);   // @@ Should we do this here?
-							splitCount++;
-						}
-					}
-				}
-			}
-		}
-		xaPrint(" - %d edges split.\n", splitCount);
-		xaDebugAssert(isValid());
-		return splitCount != 0;
+	float computeParametricArea() const
+	{
+		float area = 0;
+		for (uint32_t f = 0; f < faceCount(); f++)
+			area += faceParametricArea(f);
+		return fabsf(area); // May be negative, depends on texcoord winding.
 	}
 
-	// Vertices
-	uint32_t vertexCount() const
+	float faceArea(uint32_t face) const
 	{
-		return m_vertexArray.size();
+		const Vector3 &p0 = m_positions[m_indices[face * 3 + 0]];
+		const Vector3 &p1 = m_positions[m_indices[face * 3 + 1]];
+		const Vector3 &p2 = m_positions[m_indices[face * 3 + 2]];
+		return length(cross(p1 - p0, p2 - p0)) * 0.5f;
 	}
-	const Vertex *vertexAt(int i) const
+
+	Vector3 faceCentroid(uint32_t face) const
 	{
-		return m_vertexArray[i];
+		Vector3 sum(0.0f);
+		for (uint32_t i = 0; i < 3; i++)
+			sum += m_positions[m_indices[face * 3 + i]];
+		return sum / 3.0f;
 	}
-	Vertex *vertexAt(int i)
+
+	Vector3 calculateFaceNormal(uint32_t face) const
 	{
-		return m_vertexArray[i];
+		return normalizeSafe(triangleNormalAreaScaled(face), Vector3(0, 0, 1), 0.0f);
 	}
 
-	uint32_t colocalVertexCount() const
+	float faceParametricArea(uint32_t face) const
 	{
-		return m_colocalVertexCount;
+		const Vector2 &t0 = m_texcoords[m_indices[face * 3 + 0]];
+		const Vector2 &t1 = m_texcoords[m_indices[face * 3 + 1]];
+		const Vector2 &t2 = m_texcoords[m_indices[face * 3 + 2]];
+		return triangleArea(t0, t1, t2) * 0.5f;
+	}
+	
+	// Average of the edge midpoints weighted by the edge length.
+	// I want a point inside the triangle, but closer to the cirumcenter.
+	Vector3 triangleCenter(uint32_t face) const
+	{
+		const Vector3 &p0 = m_positions[m_indices[face * 3 + 0]];
+		const Vector3 &p1 = m_positions[m_indices[face * 3 + 1]];
+		const Vector3 &p2 = m_positions[m_indices[face * 3 + 2]];
+		const float l0 = length(p1 - p0);
+		const float l1 = length(p2 - p1);
+		const float l2 = length(p0 - p2);
+		const Vector3 m0 = (p0 + p1) * l0 / (l0 + l1 + l2);
+		const Vector3 m1 = (p1 + p2) * l1 / (l0 + l1 + l2);
+		const Vector3 m2 = (p2 + p0) * l2 / (l0 + l1 + l2);
+		return m0 + m1 + m2;
 	}
 
-	// Faces
-	uint32_t faceCount() const
+	// Unnormalized face normal assuming it's a triangle.
+	Vector3 triangleNormal(uint32_t face) const
 	{
-		return m_faceArray.size();
+		return normalizeSafe(triangleNormalAreaScaled(face), Vector3(0), 0.0f);
 	}
-	const Face *faceAt(int i) const
+
+	Vector3 triangleNormalAreaScaled(uint32_t face) const
 	{
-		return m_faceArray[i];
+		const Vector3 &p0 = m_positions[m_indices[face * 3 + 0]];
+		const Vector3 &p1 = m_positions[m_indices[face * 3 + 1]];
+		const Vector3 &p2 = m_positions[m_indices[face * 3 + 2]];
+		const Vector3 e0 = p2 - p0;
+		const Vector3 e1 = p1 - p0;
+		return cross(e0, e1);
 	}
-	Face *faceAt(int i)
+
+	// @@ This is not exactly accurate, we should compare the texture coordinates...
+	bool isSeam(uint32_t edge) const
 	{
-		return m_faceArray[i];
+		const uint32_t oppositeEdge = m_oppositeEdges[edge];
+		if (oppositeEdge == UINT32_MAX)
+			return false; // boundary edge
+		const uint32_t e0 = meshEdgeIndex0(edge);
+		const uint32_t e1 = meshEdgeIndex1(edge);
+		const uint32_t oe0 = meshEdgeIndex0(oppositeEdge);
+		const uint32_t oe1 = meshEdgeIndex1(oppositeEdge);
+		return m_indices[e0] != m_indices[oe1] || m_indices[e1] != m_indices[oe0];
 	}
 
-	// Edges
-	uint32_t edgeCount() const
+	bool isTextureSeam(uint32_t edge) const
 	{
-		return m_edgeArray.size();
+		const uint32_t oppositeEdge = m_oppositeEdges[edge];
+		if (oppositeEdge == UINT32_MAX)
+			return false; // boundary edge
+		const uint32_t e0 = meshEdgeIndex0(edge);
+		const uint32_t e1 = meshEdgeIndex1(edge);
+		const uint32_t oe0 = meshEdgeIndex0(oppositeEdge);
+		const uint32_t oe1 = meshEdgeIndex1(oppositeEdge);
+		return m_texcoords[m_indices[e0]] != m_texcoords[m_indices[oe1]] || m_texcoords[m_indices[e1]] != m_texcoords[m_indices[oe0]];
 	}
-	const Edge *edgeAt(int i) const
+
+	uint32_t firstColocal(uint32_t vertex) const
 	{
-		return m_edgeArray[i];
+		for (ColocalVertexIterator it(this, vertex); !it.isDone(); it.advance()) {
+			if (it.vertex() < vertex)
+				vertex = it.vertex();
+		}
+		return vertex;
 	}
-	Edge *edgeAt(int i)
+
+	bool areColocal(uint32_t vertex0, uint32_t vertex1) const
 	{
-		return m_edgeArray[i];
+		if (vertex0 == vertex1)
+			return true;
+		if (m_nextColocalVertex.isEmpty())
+			return false;
+		for (ColocalVertexIterator it(this, vertex0); !it.isDone(); it.advance()) {
+			if (it.vertex() == vertex1)
+				return true;
+		}
+		return false;
 	}
 
-	class ConstVertexIterator;
+	float epsilon() const { return m_epsilon; }
+	uint32_t edgeCount() const { return m_indices.size(); }
+	uint32_t oppositeEdge(uint32_t edge) const { return m_oppositeEdges[edge]; }
+	bool isBoundaryEdge(uint32_t edge) const { return m_oppositeEdges[edge] == UINT32_MAX; }
+	bool isBoundaryVertex(uint32_t vertex) const { return m_boundaryVertices[vertex]; }
+	uint32_t colocalVertexCount() const { return m_colocalVertexCount; }
+	uint32_t vertexCount() const { return m_positions.size(); }
+	uint32_t vertexAt(uint32_t i) const { return m_indices[i]; }
+	const Vector3 &position(uint32_t vertex) const { return m_positions[vertex]; }
+	const Vector3 &normal(uint32_t vertex) const { XA_DEBUG_ASSERT(m_flags & MeshFlags::HasNormals); return m_normals[vertex]; }
+	const Vector2 &texcoord(uint32_t vertex) const { return m_texcoords[vertex]; }
+	Vector2 &texcoord(uint32_t vertex) { return m_texcoords[vertex]; }
+	Vector2 *texcoords() { return m_texcoords.data(); }
+	uint32_t faceCount() const { return m_indices.size() / 3; }
+	uint32_t faceGroupCount() const { XA_DEBUG_ASSERT(m_flags & MeshFlags::HasFaceGroups); return m_faceGroups.size(); }
+	uint32_t faceGroupAt(uint32_t face) const { XA_DEBUG_ASSERT(m_flags & MeshFlags::HasFaceGroups); return m_faceGroups[face]; }
+	const uint32_t *indices() const { return m_indices.data(); }
+	uint32_t indexCount() const { return m_indices.size(); }
+
+private:
+	bool isFaceIgnored(uint32_t face) const { return (m_flags & MeshFlags::HasIgnoredFaces) && m_faceIgnore[face]; }
+
+	float m_epsilon;
+	uint32_t m_flags;
+	uint32_t m_id;
+	Array<bool> m_faceIgnore;
+	Array<uint32_t> m_faceGroups;
+	Array<uint32_t> m_indices;
+	Array<Vector3> m_positions;
+	Array<Vector3> m_normals;
+	Array<Vector2> m_texcoords;
+
+	// Populated by createColocals
+	uint32_t m_colocalVertexCount;
+	Array<uint32_t> m_nextColocalVertex; // In: vertex index. Out: the vertex index of the next colocal position.
+
+	// Populated by createBoundaries
+	Array<bool> m_boundaryVertices;
+	Array<uint32_t> m_oppositeEdges; // In: edge index. Out: the index of the opposite edge (i.e. wound the opposite direction). UINT32_MAX if the input edge is a boundary edge.
 
-	class VertexIterator
+	// Populated by linkBoundaries
+	Array<uint32_t> m_nextBoundaryEdges; // The index of the next boundary edge. UINT32_MAX if the edge is not a boundary edge.
+
+	struct EdgeKey
 	{
-		friend class ConstVertexIterator;
-	public:
-		VertexIterator(Mesh *mesh) : m_mesh(mesh), m_current(0) { }
+		EdgeKey() {}
+		EdgeKey(const EdgeKey &k) : v0(k.v0), v1(k.v1) {}
+		EdgeKey(uint32_t v0, uint32_t v1) : v0(v0), v1(v1) {}
 
-		virtual void advance()
+		void operator=(const EdgeKey &k)
 		{
-			m_current++;
+			v0 = k.v0;
+			v1 = k.v1;
 		}
-		virtual bool isDone() const
+		bool operator==(const EdgeKey &k) const
 		{
-			return m_current == m_mesh->vertexCount();
-		}
-		virtual Vertex *current() const
-		{
-			return m_mesh->vertexAt(m_current);
+			return v0 == k.v0 && v1 == k.v1;
 		}
 
-	private:
-		halfedge::Mesh *m_mesh;
-		uint32_t m_current;
+		uint32_t v0;
+		uint32_t v1;
 	};
-	VertexIterator vertices()
-	{
-		return VertexIterator(this);
-	}
 
-	class ConstVertexIterator
+	HashMap<EdgeKey, uint32_t> m_edgeMap;
+
+public:
+	class BoundaryEdgeIterator
 	{
 	public:
-		ConstVertexIterator(const Mesh *mesh) : m_mesh(mesh), m_current(0) { }
-		ConstVertexIterator(class VertexIterator &it) : m_mesh(it.m_mesh), m_current(it.m_current) { }
+		BoundaryEdgeIterator(const Mesh *mesh, uint32_t edge) : m_mesh(mesh), m_first(UINT32_MAX), m_current(edge) {}
 
-		virtual void advance()
+		void advance()
 		{
-			m_current++;
+			if (m_first == UINT32_MAX)
+				m_first = m_current;
+			m_current = m_mesh->m_nextBoundaryEdges[m_current];
 		}
-		virtual bool isDone() const
+
+		bool isDone() const
 		{
-			return m_current == m_mesh->vertexCount();
+			return m_first == m_current || m_current == UINT32_MAX;
 		}
-		virtual const Vertex *current() const
+
+		uint32_t edge() const
 		{
-			return m_mesh->vertexAt(m_current);
+			return m_current;
+		}
+
+		uint32_t nextEdge() const
+		{
+			return m_mesh->m_nextBoundaryEdges[m_current];
 		}
 
 	private:
-		const halfedge::Mesh *m_mesh;
+		const Mesh *m_mesh;
+		uint32_t m_first;
 		uint32_t m_current;
 	};
-	ConstVertexIterator vertices() const
-	{
-		return ConstVertexIterator(this);
-	}
 
-	class ConstFaceIterator;
-
-	class FaceIterator
+	class ColocalVertexIterator
 	{
-		friend class ConstFaceIterator;
 	public:
-		FaceIterator(Mesh *mesh) : m_mesh(mesh), m_current(0) { }
+		ColocalVertexIterator(const Mesh *mesh, uint32_t v) : m_mesh(mesh), m_first(UINT32_MAX), m_current(v) {}
 
-		virtual void advance()
+		void advance()
 		{
-			m_current++;
+			if (m_first == UINT32_MAX)
+				m_first = m_current;
+			if (!m_mesh->m_nextColocalVertex.isEmpty())
+				m_current = m_mesh->m_nextColocalVertex[m_current];
 		}
-		virtual bool isDone() const
+
+		bool isDone() const
 		{
-			return m_current == m_mesh->faceCount();
+			return m_first == m_current;
 		}
-		virtual Face *current() const
+
+		uint32_t vertex() const
 		{
-			return m_mesh->faceAt(m_current);
+			return m_current;
+		}
+
+		const Vector3 *pos() const
+		{
+			return &m_mesh->m_positions[m_current];
 		}
 
 	private:
-		halfedge::Mesh *m_mesh;
+		const Mesh *m_mesh;
+		uint32_t m_first;
 		uint32_t m_current;
 	};
-	FaceIterator faces()
-	{
-		return FaceIterator(this);
-	}
 
-	class ConstFaceIterator
+	class ColocalEdgeIterator
 	{
 	public:
-		ConstFaceIterator(const Mesh *mesh) : m_mesh(mesh), m_current(0) { }
-		ConstFaceIterator(const FaceIterator &it) : m_mesh(it.m_mesh), m_current(it.m_current) { }
+		ColocalEdgeIterator(const Mesh *mesh, uint32_t vertex0, uint32_t vertex1) : m_mesh(mesh), m_vertex0It(mesh, vertex0), m_vertex1It(mesh, vertex1), m_vertex1(vertex1)
+		{
+			resetElement();
+		}
 
-		virtual void advance()
+		void advance()
 		{
-			m_current++;
+			advanceElement();
 		}
-		virtual bool isDone() const
+
+		bool isDone() const
 		{
-			return m_current == m_mesh->faceCount();
+			return m_vertex0It.isDone() && m_vertex1It.isDone() && m_mapEdgeIndex == UINT32_MAX;
 		}
-		virtual const Face *current() const
+
+		uint32_t edge() const
 		{
-			return m_mesh->faceAt(m_current);
+			return m_mesh->m_edgeMap.value(m_mapEdgeIndex);
 		}
 
 	private:
-		const halfedge::Mesh *m_mesh;
-		uint32_t m_current;
-	};
-	ConstFaceIterator faces() const
-	{
-		return ConstFaceIterator(this);
-	}
-
-	class ConstEdgeIterator;
+		void resetElement()
+		{
+			m_mapEdgeIndex = m_mesh->m_edgeMap.get(Mesh::EdgeKey(m_vertex0It.vertex(), m_vertex1It.vertex()));
+			while (m_mapEdgeIndex != UINT32_MAX) {
+				if (!isIgnoredFace())
+					break;
+				m_mapEdgeIndex = m_mesh->m_edgeMap.getNext(m_mapEdgeIndex);
+			}
+			if (m_mapEdgeIndex == UINT32_MAX)
+				advanceVertex1();
+		}
 
-	class EdgeIterator
-	{
-		friend class ConstEdgeIterator;
-	public:
-		EdgeIterator(Mesh *mesh) : m_mesh(mesh), m_current(0) { }
+		void advanceElement()
+		{
+			for (;;) {
+				m_mapEdgeIndex = m_mesh->m_edgeMap.getNext(m_mapEdgeIndex);
+				if (m_mapEdgeIndex == UINT32_MAX)
+					break;
+				if (!isIgnoredFace())
+					break;
+			}
+			if (m_mapEdgeIndex == UINT32_MAX)
+				advanceVertex1();
+		}
 
-		virtual void advance()
+		void advanceVertex0()
 		{
-			m_current++;
+			m_vertex0It.advance();
+			if (m_vertex0It.isDone())
+				return;
+			m_vertex1It = ColocalVertexIterator(m_mesh, m_vertex1);
+			resetElement();
 		}
-		virtual bool isDone() const
+
+		void advanceVertex1()
 		{
-			return m_current == m_mesh->edgeCount();
+			m_vertex1It.advance();
+			if (m_vertex1It.isDone())
+				advanceVertex0();
+			else
+				resetElement();
 		}
-		virtual Edge *current() const
+
+		bool isIgnoredFace() const
 		{
-			return m_mesh->edgeAt(m_current);
+			const uint32_t edge = m_mesh->m_edgeMap.value(m_mapEdgeIndex);
+			return m_mesh->m_faceIgnore[meshEdgeFace(edge)];
 		}
 
-	private:
-		halfedge::Mesh *m_mesh;
-		uint32_t m_current;
+		const Mesh *m_mesh;
+		ColocalVertexIterator m_vertex0It, m_vertex1It;
+		const uint32_t m_vertex1;
+		uint32_t m_mapEdgeIndex;
 	};
-	EdgeIterator edges()
-	{
-		return EdgeIterator(this);
-	}
 
-	class ConstEdgeIterator
+	class FaceEdgeIterator 
 	{
 	public:
-		ConstEdgeIterator(const Mesh *mesh) : m_mesh(mesh), m_current(0) { }
-		ConstEdgeIterator(const EdgeIterator &it) : m_mesh(it.m_mesh), m_current(it.m_current) { }
+		FaceEdgeIterator (const Mesh *mesh, uint32_t face) : m_mesh(mesh), m_face(face), m_relativeEdge(0)
+		{
+			m_edge = m_face * 3;
+		}
 
-		virtual void advance()
+		void advance()
 		{
-			m_current++;
+			if (m_relativeEdge < 3) {
+				m_edge++;
+				m_relativeEdge++;
+			}
 		}
-		virtual bool isDone() const
+
+		bool isDone() const
+		{
+			return m_relativeEdge == 3;
+		}
+
+		bool isBoundary() const { return m_mesh->m_oppositeEdges[m_edge] == UINT32_MAX; }
+		bool isSeam() const { return m_mesh->isSeam(m_edge); }
+		bool isTextureSeam() const { return m_mesh->isTextureSeam(m_edge); }
+		uint32_t edge() const { return m_edge; }
+		uint32_t relativeEdge() const { return m_relativeEdge; }
+		uint32_t face() const { return m_face; }
+		uint32_t oppositeEdge() const { return m_mesh->m_oppositeEdges[m_edge]; }
+		
+		uint32_t oppositeFace() const
 		{
-			return m_current == m_mesh->edgeCount();
+			const uint32_t oedge = m_mesh->m_oppositeEdges[m_edge];
+			if (oedge == UINT32_MAX)
+				return UINT32_MAX;
+			return meshEdgeFace(oedge);
 		}
-		virtual const Edge *current() const
+
+		uint32_t vertex0() const
 		{
-			return m_mesh->edgeAt(m_current);
+			return m_mesh->m_indices[m_face * 3 + m_relativeEdge];
 		}
 
+		uint32_t vertex1() const
+		{
+			return m_mesh->m_indices[m_face * 3 + (m_relativeEdge + 1) % 3];
+		}
+
+		const Vector3 &position0() const { return m_mesh->m_positions[vertex0()]; }
+		const Vector3 &position1() const { return m_mesh->m_positions[vertex1()]; }
+		const Vector3 &normal0() const { return m_mesh->m_normals[vertex0()]; }
+		const Vector3 &normal1() const { return m_mesh->m_normals[vertex1()]; }
+		const Vector2 &texcoord0() const { return m_mesh->m_texcoords[vertex0()]; }
+		const Vector2 &texcoord1() const { return m_mesh->m_texcoords[vertex1()]; }
+
 	private:
-		const halfedge::Mesh *m_mesh;
-		uint32_t m_current;
+		const Mesh *m_mesh;
+		uint32_t m_face;
+		uint32_t m_edge;
+		uint32_t m_relativeEdge;
 	};
-	ConstEdgeIterator edges() const
-	{
-		return ConstEdgeIterator(this);
-	}
-
-	// @@ Add half-edge iterator.
+};
 
-	bool isValid() const
-	{
-		// Make sure all edges are valid.
-		const uint32_t edgeCount = m_edgeArray.size();
-		for (uint32_t e = 0; e < edgeCount; e++) {
-			Edge *edge = m_edgeArray[e];
-			if (edge != NULL) {
-				if (edge->id != 2 * e) {
-					return false;
+static bool meshCloseHole(Mesh *mesh, const Array<uint32_t> &holeVertices, const Vector3 &normal)
+{
+#if XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION
+	const uint32_t faceCount = mesh->faceCount();
+#endif
+	const bool compareNormal = equal(normal, Vector3(0.0f), FLT_EPSILON);
+	uint32_t frontCount = holeVertices.size();
+	Array<uint32_t> frontVertices;
+	Array<Vector3> frontPoints;
+	Array<float> frontAngles;
+	frontVertices.resize(frontCount);
+	frontPoints.resize(frontCount);
+	for (uint32_t i = 0; i < frontCount; i++) {
+		frontVertices[i] = holeVertices[i];
+		frontPoints[i] = mesh->position(frontVertices[i]);
+	}
+	while (frontCount >= 3) {
+		frontAngles.resize(frontCount);
+		float smallestAngle = kPi2, smallestAngleIgnoringNormal = kPi2;
+		uint32_t smallestAngleIndex = UINT32_MAX, smallestAngleIndexIgnoringNormal = UINT32_MAX;
+		for (uint32_t i = 0; i < frontCount; i++) {
+			const uint32_t i1 = i == 0 ? frontCount - 1 : i - 1;
+			const uint32_t i2 = i;
+			const uint32_t i3 = (i + 1) % frontCount;
+			const Vector3 edge1 = frontPoints[i1] - frontPoints[i2];
+			const Vector3 edge2 = frontPoints[i3] - frontPoints[i2];
+			frontAngles[i] = acosf(dot(edge1, edge2) / (length(edge1) * length(edge2)));
+			if (frontAngles[i] >= smallestAngle || isNan(frontAngles[i]))
+				continue;
+			// Don't duplicate edges.
+			if (mesh->findEdge(UINT32_MAX, frontVertices[i1], frontVertices[i2]) != UINT32_MAX)
+				continue;
+			if (mesh->findEdge(UINT32_MAX, frontVertices[i2], frontVertices[i3]) != UINT32_MAX)
+				continue;
+			if (mesh->findEdge(UINT32_MAX, frontVertices[i3], frontVertices[i1]) != UINT32_MAX)
+				continue;
+			/*
+			Make sure he new edge that would be formed by (i3, i1) doesn't intersect any vertices. This often happens when fixing t-junctions.
+
+			       i2
+			       *
+			      / \
+			     /   \
+			 i1 *--*--* i3
+			     \ | /
+				  \|/
+				   *
+			*/
+			bool intersection = false;
+			for (uint32_t j = 0; j < frontCount; j++) {
+				if (j == i1 || j == i2 || j == i3)
+					continue;
+				if (lineIntersectsPoint(frontPoints[j], frontPoints[i3], frontPoints[i1], nullptr, mesh->epsilon())) {
+					intersection = true;
+					break;
 				}
-				if (!edge->isValid()) {
-					return false;
+			}
+			if (intersection)
+				continue;
+			// Don't add the triangle if a boundary point lies on the same plane as the triangle, and is inside it.
+			intersection = false;
+			const Plane plane(frontPoints[i1], frontPoints[i2], frontPoints[i3]);
+			for (uint32_t j = 0; j < frontCount; j++) {
+				if (j == i1 || j == i2 || j == i3)
+					continue;
+				if (!isZero(plane.distance(frontPoints[j]), mesh->epsilon()))
+					continue;
+				if (pointInTriangle(frontPoints[j], frontPoints[i1], frontPoints[i2], frontPoints[i3])) {
+					intersection = true;
+					break;
 				}
-				if (edge->pair->id != 2 * e + 1) {
-					return false;
+			}
+			if (intersection)
+				continue;
+#if XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION
+			// Don't add the triangle if the new edge (i3, i1), intersects any other triangle that isn't part of the filled hole.
+			intersection = false;
+			const Vector3 newEdgeVector = frontPoints[i1] - frontPoints[i3];
+			for (uint32_t f = 0; f < faceCount; f++) {
+				Vector3 tri[3];
+				for (uint32_t j = 0; j < 3; j++)
+					tri[j] = mesh->position(mesh->vertexAt(f * 3 + j));
+				float t;
+				if (rayIntersectsTriangle(frontPoints[i3], newEdgeVector, tri, &t)) {
+					intersection = true;
+					break;
 				}
-				if (!edge->pair->isValid()) {
-					return false;
+			}
+			if (intersection)
+				continue;
+#endif
+			// Skip backwards facing triangles.
+			if (compareNormal) {
+				if (frontAngles[i] < smallestAngleIgnoringNormal) {
+					smallestAngleIgnoringNormal = frontAngles[i];
+					smallestAngleIndexIgnoringNormal = i;
 				}
+				const Vector3 e0 = frontPoints[i3] - frontPoints[i1];
+				const Vector3 e1 = frontPoints[i2] - frontPoints[i1];
+				const Vector3 triNormal = normalizeSafe(cross(e0, e1), Vector3(0.0f), mesh->epsilon());
+				if (dot(normal, triNormal) <= 0.0f)
+					continue;
 			}
+			smallestAngle = smallestAngleIgnoringNormal = frontAngles[i];
+			smallestAngleIndex = smallestAngleIndexIgnoringNormal = i;
 		}
-		// @@ Make sure all faces are valid.
-		// @@ Make sure all vertices are valid.
-		return true;
+		// Closing holes failed if we don't have a smallest angle.
+		// Fallback to ignoring the backwards facing normal test if possible.
+		if (smallestAngleIndex == UINT32_MAX || smallestAngle <= 0.0f || smallestAngle >= kPi) {
+			if (smallestAngleIgnoringNormal == UINT32_MAX || smallestAngleIgnoringNormal <= 0.0f || smallestAngleIgnoringNormal >= kPi)
+				return false;
+			else
+				smallestAngleIndex = smallestAngleIndexIgnoringNormal;
+		}
+		const uint32_t i1 = smallestAngleIndex == 0 ? frontCount - 1 : smallestAngleIndex - 1;
+		const uint32_t i2 = smallestAngleIndex;
+		const uint32_t i3 = (smallestAngleIndex + 1) % frontCount;
+		const Mesh::AddFaceResult::Enum result = mesh->addFace(frontVertices[i1], frontVertices[i2], frontVertices[i3]);
+		XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK); // Shouldn't happen due to the findEdge calls above.
+		XA_UNUSED(result);
+		frontVertices.removeAt(i2);
+		frontPoints.removeAt(i2);
+		frontCount = frontVertices.size();
 	}
+	return true;
+}
 
-	// Error status:
-	
-	struct ErrorCode
-	{
-		enum Enum
-		{
-			AlreadyAddedEdge,
-			DegenerateColocalEdge,
-			DegenerateEdge,
-			DuplicateEdge
-		};
-	};
-
-	mutable ErrorCode::Enum errorCode;
-	mutable uint32_t errorIndex0;
-	mutable uint32_t errorIndex1;
+static bool meshCloseHoles(Mesh *mesh, const Array<uint32_t> &boundaryLoops, const Vector3 &normal, Array<uint32_t> &holeFaceCounts)
+{
+	holeFaceCounts.clear();
+	// Compute lengths.
+	const uint32_t boundaryCount = boundaryLoops.size();
+	Array<float> boundaryLengths;
+	Array<uint32_t> boundaryEdgeCounts;
+	boundaryEdgeCounts.resize(boundaryCount);
+	for (uint32_t i = 0; i < boundaryCount; i++) {
+		float boundaryLength = 0.0f;
+		boundaryEdgeCounts[i] = 0;
+		for (Mesh::BoundaryEdgeIterator it(mesh, boundaryLoops[i]); !it.isDone(); it.advance()) {
+			const Vector3 &t0 = mesh->position(mesh->vertexAt(meshEdgeIndex0(it.edge())));
+			const Vector3 &t1 = mesh->position(mesh->vertexAt(meshEdgeIndex1(it.edge())));
+			boundaryLength += length(t1 - t0);
+			boundaryEdgeCounts[i]++;
+		}
+		boundaryLengths.push_back(boundaryLength);
+	}
+	// Find disk boundary.
+	uint32_t diskBoundary = 0;
+	float maxLength = boundaryLengths[0];
+	for (uint32_t i = 1; i < boundaryCount; i++) {
+		if (boundaryLengths[i] > maxLength) {
+			maxLength = boundaryLengths[i];
+			diskBoundary = i;
+		}
+	}
+	// Close holes.
+	Array<uint32_t> holeVertices;
+	Array<Vector3> holePoints;
+	bool result = true;
+	for (uint32_t i = 0; i < boundaryCount; i++) {
+		if (diskBoundary == i)
+			continue; // Skip disk boundary.
+		holeVertices.resize(boundaryEdgeCounts[i]);
+		holePoints.resize(boundaryEdgeCounts[i]);
+		// Winding is backwards for internal boundaries.
+		uint32_t e = 0;
+		for (Mesh::BoundaryEdgeIterator it(mesh, boundaryLoops[i]); !it.isDone(); it.advance()) {
+			const uint32_t vertex = mesh->vertexAt(meshEdgeIndex0(it.edge()));
+			holeVertices[boundaryEdgeCounts[i] - 1 - e] = vertex;
+			holePoints[boundaryEdgeCounts[i] - 1 - e] = mesh->position(vertex);
+			e++;
+		}
+		const uint32_t oldFaceCount = mesh->faceCount();
+		if (!meshCloseHole(mesh, holeVertices, normal))
+			result = false; // Return false if any hole failed to close, but keep trying to close other holes.
+		holeFaceCounts.push_back(mesh->faceCount() - oldFaceCount);
+	}
+	return result;
+}
 
-private:
-	// Return true if the face can be added to the manifold mesh.
-	bool canAddFace(const std::vector<uint32_t> &indexArray, uint32_t first, uint32_t num) const
-	{
-		return canAddFace(indexArray.data(), first, num);
+static bool meshIsPlanar(const Mesh &mesh)
+{
+	const Vector3 p1 = mesh.position(mesh.vertexAt(0));
+	const Vector3 p2 = mesh.position(mesh.vertexAt(1));
+	const Vector3 p3 = mesh.position(mesh.vertexAt(2));
+	const Plane plane(p1, p2, p3);
+	const uint32_t vertexCount = mesh.vertexCount();
+	for (uint32_t v = 0; v < vertexCount; v++) {
+		const float d = plane.distance(mesh.position(v));
+		if (!isZero(d, mesh.epsilon()))
+			return false;
 	}
+	return true;
+}
 
-	bool canAddFace(const uint32_t *indexArray, uint32_t first, uint32_t num) const
-	{
-		for (uint32_t j = num - 1, i = 0; i < num; j = i++) {
-			if (!canAddEdge(indexArray[first + j], indexArray[first + i])) {
-				errorIndex0 = indexArray[first + j];
-				errorIndex1 = indexArray[first + i];
-				return false;
-			}
-		}
-		// We also have to make sure the face does not have any duplicate edge!
-		for (uint32_t i = 0; i < num; i++) {
-			int i0 = indexArray[first + i + 0];
-			int i1 = indexArray[first + (i + 1) % num];
-			for (uint32_t j = i + 1; j < num; j++) {
-				int j0 = indexArray[first + j + 0];
-				int j1 = indexArray[first + (j + 1) % num];
-				if (i0 == j0 && i1 == j1) {
-					errorCode = ErrorCode::DuplicateEdge;
-					errorIndex0 = i0;
-					errorIndex1 = i1;
-					return false;
-				}
-			}
-		}
-		return true;
-	}
+/*
+Fixing T-junctions.
 
-	// Return true if the edge doesn't exist or doesn't have any adjacent face.
-	bool canAddEdge(uint32_t i, uint32_t j) const
-	{
-		if (i == j) {
-			// Skip degenerate edges.
-			errorCode = ErrorCode::DegenerateEdge;
-			return false;
-		}
-		// Same check, but taking into account colocal vertices.
-		const Vertex *v0 = vertexAt(i);
-		const Vertex *v1 = vertexAt(j);
-		for (Vertex::ConstVertexIterator it(v0->colocals()); !it.isDone(); it.advance()) {
-			if (it.current() == v1) {
-				// Skip degenerate edges.
-				errorCode = ErrorCode::DegenerateColocalEdge;
-				return false;
-			}
-		}
-		// Make sure edge has not been added yet.
-		Edge *edge = findEdge(i, j);
-		// We ignore edges that don't have an adjacent face yet, since this face could become the edge's face.
-		if (!(edge == NULL || edge->face == NULL)) {
-			errorCode = ErrorCode::AlreadyAddedEdge;
-			return false;
-		}
-		return true;
-	}
+- Find T-junctions. Find  vertices that are on an edge.
+- This test is approximate.
+- Insert edges on a spatial index to speedup queries.
+- Consider only open edges, that is edges that have no pairs.
+- Consider only vertices on boundaries.
+- Close T-junction.
+- Split edge.
+
+*/
+struct SplitEdge
+{
+	uint32_t edge;
+	float t;
+	uint32_t vertex;
 
-	Edge *addEdge(uint32_t i, uint32_t j)
+	bool operator<(const SplitEdge &other) const
 	{
-		xaAssert(i != j);
-		Edge *edge = findEdge(i, j);
-		if (edge != NULL) {
-			// Edge may already exist, but its face must not be set.
-			xaDebugAssert(edge->face == NULL);
-			// Nothing else to do!
-		} else {
-			// Add new edge.
-			// Lookup pair.
-			Edge *pair = findEdge(j, i);
-			if (pair != NULL) {
-				// Create edge with same id.
-				edge = new Edge(pair->id + 1);
-				// Link edge pairs.
-				edge->pair = pair;
-				pair->pair = edge;
-				// @@ I'm not sure this is necessary!
-				pair->vertex->setEdge(pair);
-			} else {
-				// Create edge.
-				edge = new Edge(2 * m_edgeArray.size());
-				// Add only unpaired edges.
-				m_edgeArray.push_back(edge);
-			}
-			edge->vertex = m_vertexArray[i];
-			m_edgeMap[Key(i, j)] = edge;
+		if (edge < other.edge)
+			return true;
+		else if (edge == other.edge) {
+			if (t < other.t)
+				return true;
 		}
-		// Face and Next are set by addFace.
-		return edge;
+		return false;
 	}
+};
 
-	/// Find edge, test all colocals.
-	Edge *findEdge(uint32_t i, uint32_t j) const
-	{
-		Edge *edge = NULL;
-		const Vertex *v0 = vertexAt(i);
-		const Vertex *v1 = vertexAt(j);
-		// Test all colocal pairs.
-		for (Vertex::ConstVertexIterator it0(v0->colocals()); !it0.isDone(); it0.advance()) {
-			for (Vertex::ConstVertexIterator it1(v1->colocals()); !it1.isDone(); it1.advance()) {
-				Key key(it0.current()->id, it1.current()->id);
-				if (edge == NULL) {
-					auto edgeIt = m_edgeMap.find(key);
-					if (edgeIt != m_edgeMap.end())
-						edge = (*edgeIt).second;
-	#if !defined(_DEBUG)
-					if (edge != NULL) return edge;
-	#endif
-				} else {
-					// Make sure that only one edge is found.
-					xaDebugAssert(m_edgeMap.find(key) == m_edgeMap.end());
+// Returns nullptr if there were no t-junctions to fix.
+static Mesh *meshFixTJunctions(const Mesh &inputMesh, bool *duplicatedEdge, bool *failed, uint32_t *fixedTJunctionsCount)
+{
+	if (duplicatedEdge)
+		*duplicatedEdge = false;
+	if (failed)
+		*failed = false;
+	Array<SplitEdge> splitEdges;
+	const uint32_t vertexCount = inputMesh.vertexCount();
+	const uint32_t edgeCount = inputMesh.edgeCount();
+	for (uint32_t v = 0; v < vertexCount; v++) {
+		if (!inputMesh.isBoundaryVertex(v))
+			continue;
+		// Find edges that this vertex overlaps with.
+		const Vector3 &pos = inputMesh.position(v);
+		for (uint32_t e = 0; e < edgeCount; e++) {
+			if (!inputMesh.isBoundaryEdge(e))
+				continue;
+			const Vector3 &edgePos1 = inputMesh.position(inputMesh.vertexAt(meshEdgeIndex0(e)));
+			const Vector3 &edgePos2 = inputMesh.position(inputMesh.vertexAt(meshEdgeIndex1(e)));
+			float t;
+			if (!lineIntersectsPoint(pos, edgePos1, edgePos2, &t, inputMesh.epsilon()))
+				continue;
+			SplitEdge splitEdge;
+			splitEdge.edge = e;
+			splitEdge.t = t;
+			splitEdge.vertex = v;
+			splitEdges.push_back(splitEdge);
+		}
+	}
+	if (splitEdges.isEmpty())
+		return nullptr;
+	const uint32_t faceCount = inputMesh.faceCount();
+	Mesh *mesh = XA_NEW(MemTag::Mesh, Mesh, inputMesh.epsilon(), vertexCount + splitEdges.size(), faceCount);
+	for (uint32_t v = 0; v < vertexCount; v++)
+		mesh->addVertex(inputMesh.position(v));
+	Array<uint32_t> indexArray;
+	indexArray.reserve(4);
+	Array<SplitEdge> faceSplitEdges;
+	faceSplitEdges.reserve(4);
+	for (uint32_t f = 0; f < faceCount; f++) {
+		// Find t-junctions in this face.
+		faceSplitEdges.clear();
+		for (uint32_t i = 0; i < splitEdges.size(); i++) {
+			if (meshEdgeFace(splitEdges[i].edge) == f)
+				faceSplitEdges.push_back(splitEdges[i]);
+		}
+		if (!faceSplitEdges.isEmpty()) {
+			// Need to split edges in winding order when a single edge has multiple t-junctions.
+			insertionSort(faceSplitEdges.data(), faceSplitEdges.size());
+			indexArray.clear();
+			for (Mesh::FaceEdgeIterator it(&inputMesh, f); !it.isDone(); it.advance()) {
+				indexArray.push_back(it.vertex0());
+				for (uint32_t se = 0; se < faceSplitEdges.size(); se++) {
+					const SplitEdge &splitEdge = faceSplitEdges[se];
+					if (splitEdge.edge == it.edge())
+						indexArray.push_back(splitEdge.vertex);
 				}
 			}
+			if (!meshCloseHole(mesh, indexArray, Vector3(0.0f))) {
+				if (failed)
+					*failed = true;
+			}
+		} else {
+			// No t-junctions in this face. Copy from input mesh.
+			if (mesh->addFace(&inputMesh.indices()[f * 3]) == Mesh::AddFaceResult::DuplicateEdge) {
+				if (duplicatedEdge)
+					*duplicatedEdge = true;
+			}
 		}
-		return edge;
-	}
-
-	/// Link this boundary edge.
-	void linkBoundaryEdge(Edge *edge)
-	{
-		xaAssert(edge->face == NULL);
-		// Make sure next pointer has not been set. @@ We want to be able to relink boundary edges after mesh changes.
-		Edge *next = edge;
-		while (next->pair->face != NULL) {
-			// Get pair prev
-			Edge *e = next->pair->next;
-			while (e->next != next->pair) {
-				e = e->next;
-			}
-			next = e;
-		}
-		edge->setNext(next->pair);
-		// Adjust vertex edge, so that it's the boundary edge. (required for isBoundary())
-		if (edge->vertex->edge != edge) {
-			// Multiple boundaries in the same edge.
-			edge->vertex->edge = edge;
-		}
-	}
-
-	Vertex *splitBoundaryEdge(Edge *edge, float t, const Vector3 &pos)
-	{
-		/*
-		  We want to go from this configuration:
-
-				+   +
-				|   ^
-		   edge |<->|  pair
-				v   |
-				+   +
-
-		  To this one:
-
-				+   +
-				|   ^
-			 e0 |<->| p0
-				v   |
-		 vertex +   +
-				|   ^
-			 e1 |<->| p1
-				v   |
-				+   +
-
-		*/
-		Edge *pair = edge->pair;
-		// Make sure boundaries are linked.
-		xaDebugAssert(pair != NULL);
-		// Make sure edge is a boundary edge.
-		xaDebugAssert(pair->face == NULL);
-		// Add new vertex.
-		Vertex *vertex = addVertex(pos);
-		vertex->nor = lerp(edge->from()->nor, edge->to()->nor, t);
-		vertex->tex = lerp(edge->from()->tex, edge->to()->tex, t);
-		disconnect(edge);
-		disconnect(pair);
-		// Add edges.
-		Edge *e0 = addEdge(edge->from()->id, vertex->id);
-		Edge *p0 = addEdge(vertex->id, pair->to()->id);
-		Edge *e1 = addEdge(vertex->id, edge->to()->id);
-		Edge *p1 = addEdge(pair->from()->id, vertex->id);
-		// Link edges.
-		e0->setNext(e1);
-		p1->setNext(p0);
-		e0->setPrev(edge->prev);
-		e1->setNext(edge->next);
-		p1->setPrev(pair->prev);
-		p0->setNext(pair->next);
-		xaDebugAssert(e0->next == e1);
-		xaDebugAssert(e1->prev == e0);
-		xaDebugAssert(p1->next == p0);
-		xaDebugAssert(p0->prev == p1);
-		xaDebugAssert(p0->pair == e0);
-		xaDebugAssert(e0->pair == p0);
-		xaDebugAssert(p1->pair == e1);
-		xaDebugAssert(e1->pair == p1);
-		// Link faces.
-		e0->face = edge->face;
-		e1->face = edge->face;
-		// Link vertices.
-		edge->from()->setEdge(e0);
-		vertex->setEdge(e1);
-		delete edge;
-		delete pair;
-		return vertex;
 	}
+	if (fixedTJunctionsCount)
+		*fixedTJunctionsCount = splitEdges.size();
+	return mesh;
+}
 
-private:
-	std::vector<Vertex *> m_vertexArray;
-	std::vector<Edge *> m_edgeArray;
-	std::vector<Face *> m_faceArray;
-
-	struct Key
-	{
-		Key() {}
-		Key(const Key &k) : p0(k.p0), p1(k.p1) {}
-		Key(uint32_t v0, uint32_t v1) : p0(v0), p1(v1) {}
-		void operator=(const Key &k)
-		{
-			p0 = k.p0;
-			p1 = k.p1;
-		}
-		bool operator==(const Key &k) const
-		{
-			return p0 == k.p0 && p1 == k.p1;
-		}
-
-		uint32_t p0;
-		uint32_t p1;
-	};
-
-	friend struct Hash<Mesh::Key>;
-	std::unordered_map<Key, Edge *, Hash<Key>, Equal<Key> > m_edgeMap;
-	uint32_t m_colocalVertexCount;
-};
+// boundaryLoops are the first edges for each boundary loop.
+static void meshGetBoundaryLoops(const Mesh &mesh, Array<uint32_t> &boundaryLoops)
+{
+	const uint32_t edgeCount = mesh.edgeCount();
+	BitArray bitFlags(edgeCount);
+	bitFlags.clearAll();
+	boundaryLoops.clear();
+	// Search for boundary edges. Mark all the edges that belong to the same boundary.
+	for (uint32_t e = 0; e < edgeCount; e++) {
+		if (bitFlags.bitAt(e) || !mesh.isBoundaryEdge(e))
+			continue;
+		for (Mesh::BoundaryEdgeIterator it(&mesh, e); !it.isDone(); it.advance())
+			bitFlags.setBitAt(it.edge());
+		boundaryLoops.push_back(e);
+	}
+}
 
 class MeshTopology
 {
 public:
 	MeshTopology(const Mesh *mesh)
 	{
-		buildTopologyInfo(mesh);
-	}
-
-	/// Determine if the mesh is connected.
-	bool isConnected() const
-	{
-		return m_connectedCount == 1;
-	}
-
-	/// Determine if the mesh is closed. (Each edge is shared by two faces)
-	bool isClosed() const
-	{
-		return m_boundaryCount == 0;
-	}
-
-	/// Return true if the mesh has the topology of a disk.
-	bool isDisk() const
-	{
-		return isConnected() && m_boundaryCount == 1/* && m_eulerNumber == 1*/;
-	}
-
-private:
-	void buildTopologyInfo(const Mesh *mesh)
-	{
 		const uint32_t vertexCount = mesh->colocalVertexCount();
 		const uint32_t faceCount = mesh->faceCount();
 		const uint32_t edgeCount = mesh->edgeCount();
-		xaPrint( "--- Building mesh topology:\n" );
-		std::vector<uint32_t> stack(faceCount);
+		Array<uint32_t> stack(MemTag::Default);
+		stack.reserve(faceCount);
 		BitArray bitFlags(faceCount);
 		bitFlags.clearAll();
 		// Compute connectivity.
-		xaPrint( "---   Computing connectivity.\n" );
 		m_connectedCount = 0;
 		for (uint32_t f = 0; f < faceCount; f++ ) {
-			if ( bitFlags.bitAt(f) == false ) {
+			if (bitFlags.bitAt(f) == false) {
 				m_connectedCount++;
-				stack.push_back( f );
-				while ( !stack.empty() ) {
+				stack.push_back(f);
+				while (!stack.isEmpty()) {
 					const uint32_t top = stack.back();
-					xaAssert(top != uint32_t(~0));
+					XA_ASSERT(top != uint32_t(~0));
 					stack.pop_back();
-					if ( bitFlags.bitAt(top) == false ) {
+					if (bitFlags.bitAt(top) == false) {
 						bitFlags.setBitAt(top);
-						const Face *face = mesh->faceAt(top);
-						const Edge *firstEdge = face->edge;
-						const Edge *edge = firstEdge;
-						do {
-							const Face *neighborFace = edge->pair->face;
-							if (neighborFace != NULL) {
-								stack.push_back(neighborFace->id);
-							}
-							edge = edge->next;
-						} while (edge != firstEdge);
+						for (Mesh::FaceEdgeIterator it(mesh, top); !it.isDone(); it.advance()) {
+							const uint32_t oppositeFace = it.oppositeFace();
+							if (oppositeFace != UINT32_MAX)
+								stack.push_back(oppositeFace);
+						}
 					}
 				}
 			}
 		}
-		xaAssert(stack.empty());
-		xaPrint( "---   %d connected components.\n", m_connectedCount );
+		XA_ASSERT(stack.isEmpty());
 		// Count boundary loops.
-		xaPrint( "---   Counting boundary loops.\n" );
 		m_boundaryCount = 0;
 		bitFlags.resize(edgeCount);
 		bitFlags.clearAll();
 		// Don't forget to link the boundary otherwise this won't work.
 		for (uint32_t e = 0; e < edgeCount; e++) {
-			const Edge *startEdge = mesh->edgeAt(e);
-			if (startEdge != NULL && startEdge->isBoundary() && bitFlags.bitAt(e) == false) {
-				xaDebugAssert(startEdge->face != NULL);
-				xaDebugAssert(startEdge->pair->face == NULL);
-				startEdge = startEdge->pair;
-				m_boundaryCount++;
-				const Edge *edge = startEdge;
-				do {
-					bitFlags.setBitAt(edge->id / 2);
-					edge = edge->next;
-				} while (startEdge != edge);
-			}
-		}
-		xaPrint("---   %d boundary loops found.\n", m_boundaryCount );
+			if (bitFlags.bitAt(e) || !mesh->isBoundaryEdge(e))
+				continue;
+			m_boundaryCount++;
+			for (Mesh::BoundaryEdgeIterator it(mesh, e); !it.isDone(); it.advance())
+				bitFlags.setBitAt(it.edge());
+		}
 		// Compute euler number.
 		m_eulerNumber = vertexCount - edgeCount + faceCount;
-		xaPrint("---   Euler number: %d.\n", m_eulerNumber);
 		// Compute genus. (only valid on closed connected surfaces)
 		m_genus = -1;
-		if ( isClosed() && isConnected() ) {
+		if (isClosed() && isConnected())
 			m_genus = (2 - m_eulerNumber) / 2;
-			xaPrint("---   Genus: %d.\n", m_genus);
-		}
+	}
+
+	/// Determine if the mesh is connected.
+	bool isConnected() const
+	{
+		return m_connectedCount == 1;
+	}
+
+	/// Determine if the mesh is closed. (Each edge is shared by two faces)
+	bool isClosed() const
+	{
+		return m_boundaryCount == 0;
+	}
+
+	/// Return true if the mesh has the topology of a disk.
+	bool isDisk() const
+	{
+		return isConnected() && m_boundaryCount == 1/* && m_eulerNumber == 1*/;
 	}
 
 private:
@@ -2843,702 +3477,313 @@ private:
 	int m_genus;
 };
 
-float computeSurfaceArea(const halfedge::Mesh *mesh)
-{
-	float area = 0;
-	for (halfedge::Mesh::ConstFaceIterator it(mesh->faces()); !it.isDone(); it.advance()) {
-		const halfedge::Face *face = it.current();
-		area += face->area();
-	}
-	xaDebugAssert(area >= 0);
-	return area;
-}
-
-float computeParametricArea(const halfedge::Mesh *mesh)
-{
-	float area = 0;
-	for (halfedge::Mesh::ConstFaceIterator it(mesh->faces()); !it.isDone(); it.advance()) {
-		const halfedge::Face *face = it.current();
-		area += face->parametricArea();
-	}
-	return area;
-}
-
-uint32_t countMeshTriangles(const Mesh *mesh)
-{
-	const uint32_t faceCount = mesh->faceCount();
-	uint32_t triangleCount = 0;
-	for (uint32_t f = 0; f < faceCount; f++) {
-		const Face *face = mesh->faceAt(f);
-		uint32_t edgeCount = face->edgeCount();
-		xaDebugAssert(edgeCount > 2);
-		triangleCount += edgeCount - 2;
-	}
-	return triangleCount;
-}
-
-Mesh *unifyVertices(const Mesh *inputMesh)
-{
-	Mesh *mesh = new Mesh;
-	// Only add the first colocal.
-	const uint32_t vertexCount = inputMesh->vertexCount();
-	for (uint32_t v = 0; v < vertexCount; v++) {
-		const Vertex *vertex = inputMesh->vertexAt(v);
-		if (vertex->isFirstColocal()) {
-			mesh->addVertex(vertex->pos);
-		}
-	}
-	std::vector<uint32_t> indexArray;
-	// Add new faces pointing to first colocals.
-	uint32_t faceCount = inputMesh->faceCount();
-	for (uint32_t f = 0; f < faceCount; f++) {
-		const Face *face = inputMesh->faceAt(f);
-		indexArray.clear();
-		for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-			const Edge *edge = it.current();
-			const Vertex *vertex = edge->vertex->firstColocal();
-			indexArray.push_back(vertex->id);
-		}
-		mesh->addFace(indexArray);
-	}
-	mesh->linkBoundary();
-	return mesh;
-}
-
-static bool pointInTriangle(const Vector2 &p, const Vector2 &a, const Vector2 &b, const Vector2 &c)
+struct Progress
 {
-	return triangleArea(a, b, p) >= 0.00001f &&
-	       triangleArea(b, c, p) >= 0.00001f &&
-	       triangleArea(c, a, p) >= 0.00001f;
-}
-
-// This is doing a simple ear-clipping algorithm that skips invalid triangles. Ideally, we should
-// also sort the ears by angle, start with the ones that have the smallest angle and proceed in order.
-Mesh *triangulate(const Mesh *inputMesh)
-{
-	Mesh *mesh = new Mesh;
-	// Add all vertices.
-	const uint32_t vertexCount = inputMesh->vertexCount();
-	for (uint32_t v = 0; v < vertexCount; v++) {
-		const Vertex *vertex = inputMesh->vertexAt(v);
-		mesh->addVertex(vertex->pos);
-	}
-	std::vector<int> polygonVertices;
-	std::vector<float> polygonAngles;
-	std::vector<Vector2> polygonPoints;
-	const uint32_t faceCount = inputMesh->faceCount();
-	for (uint32_t f = 0; f < faceCount; f++) {
-		const Face *face = inputMesh->faceAt(f);
-		xaDebugAssert(face != NULL);
-		const uint32_t edgeCount = face->edgeCount();
-		xaDebugAssert(edgeCount >= 3);
-		polygonVertices.clear();
-		polygonVertices.reserve(edgeCount);
-		if (edgeCount == 3) {
-			// Simple case for triangles.
-			for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const Edge *edge = it.current();
-				const Vertex *vertex = edge->vertex;
-				polygonVertices.push_back(vertex->id);
-			}
-			int v0 = polygonVertices[0];
-			int v1 = polygonVertices[1];
-			int v2 = polygonVertices[2];
-			mesh->addFace(v0, v1, v2);
-		} else {
-			// Build 2D polygon projecting vertices onto normal plane.
-			// Faces are not necesarily planar, this is for example the case, when the face comes from filling a hole. In such cases
-			// it's much better to use the best fit plane.
-			const Vector3 fn = face->normal();
-			Basis basis;
-			basis.buildFrameForDirection(fn);
-			polygonPoints.clear();
-			polygonPoints.reserve(edgeCount);
-			polygonAngles.clear();
-			polygonAngles.reserve(edgeCount);
-			for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const Edge *edge = it.current();
-				const Vertex *vertex = edge->vertex;
-				polygonVertices.push_back(vertex->id);
-				Vector2 p;
-				p.x = dot(basis.tangent, vertex->pos);
-				p.y = dot(basis.bitangent, vertex->pos);
-				polygonPoints.push_back(p);
-			}
-			polygonAngles.resize(edgeCount);
-			while (polygonVertices.size() > 2) {
-				uint32_t size = polygonVertices.size();
-				// Update polygon angles. @@ Update only those that have changed.
-				float minAngle = 2 * PI;
-				uint32_t bestEar = 0; // Use first one if none of them is valid.
-				bool bestIsValid = false;
-				for (uint32_t i = 0; i < size; i++) {
-					uint32_t i0 = i;
-					uint32_t i1 = (i + 1) % size; // Use Sean's polygon interation trick.
-					uint32_t i2 = (i + 2) % size;
-					Vector2 p0 = polygonPoints[i0];
-					Vector2 p1 = polygonPoints[i1];
-					Vector2 p2 = polygonPoints[i2];
-
-					// -- GODOT start --
-					bool degenerate = distance(p0, p1) < NV_EPSILON || distance(p0, p2) < NV_EPSILON || distance(p1, p2) < NV_EPSILON;
-					if (degenerate) {
-						continue;
-					}
-					// -- GODOT end --
-
-					float d = clamp(dot(p0 - p1, p2 - p1) / (length(p0 - p1) * length(p2 - p1)), -1.0f, 1.0f);
-					float angle = acosf(d);
-					float area = triangleArea(p0, p1, p2);
-					if (area < 0.0f) angle = 2.0f * PI - angle;
-					polygonAngles[i1] = angle;
-					if (angle < minAngle || !bestIsValid) {
-						// Make sure this is a valid ear, if not, skip this point.
-						bool valid = true;
-						for (uint32_t j = 0; j < size; j++) {
-							if (j == i0 || j == i1 || j == i2) continue;
-							Vector2 p = polygonPoints[j];
-							if (pointInTriangle(p, p0, p1, p2)) {
-								valid = false;
-								break;
-							}
-						}
-						if (valid || !bestIsValid) {
-							minAngle = angle;
-							bestEar = i1;
-							bestIsValid = valid;
-						}
-					}
-				}
-				// -- GODOT start --
-				if (!bestIsValid)
-					break;
-				// -- GODOT end --
-
-				xaDebugAssert(minAngle <= 2 * PI);
-				// Clip best ear:
-				uint32_t i0 = (bestEar + size - 1) % size;
-				uint32_t i1 = (bestEar + 0) % size;
-				uint32_t i2 = (bestEar + 1) % size;
-				int v0 = polygonVertices[i0];
-				int v1 = polygonVertices[i1];
-				int v2 = polygonVertices[i2];
-				mesh->addFace(v0, v1, v2);
-				polygonVertices.erase(polygonVertices.begin() + i1);
-				polygonPoints.erase(polygonPoints.begin() + i1);
-				polygonAngles.erase(polygonAngles.begin() + i1);
-			}
-		}
-	}
-	mesh->linkBoundary();
-	return mesh;
-}
-
-} //  namespace halfedge
-
-/// Mersenne twister random number generator.
-class MTRand
-{
-public:
-	enum time_e { Time };
-	enum { N = 624 };       // length of state vector
-	enum { M = 397 };
-
-	/// Constructor that uses the current time as the seed.
-	MTRand( time_e )
+	Progress(ProgressCategory::Enum category, ProgressFunc func, void *userData, uint32_t maxValue) : value(0), cancel(false), m_category(category), m_func(func), m_userData(userData), m_maxValue(maxValue), m_progress(0)
 	{
-		seed((uint32_t )time(NULL));
-	}
-
-	/// Constructor that uses the given seed.
-	MTRand( uint32_t s = 0 )
-	{
-		seed(s);
-	}
-
-	/// Provide a new seed.
-	void seed( uint32_t s )
-	{
-		initialize(s);
-		reload();
+		if (m_func) {
+			if (!m_func(category, 0, userData))
+				cancel = true;
+		}
 	}
 
-	/// Get a random number between 0 - 65536.
-	uint32_t get()
+	~Progress()
 	{
-		// Pull a 32-bit integer from the generator state
-		// Every other access function simply transforms the numbers extracted here
-		if ( left == 0 ) {
-			reload();
+		if (m_func) {
+			if (!m_func(m_category, 100, m_userData))
+				cancel = true;
 		}
-		left--;
-		uint32_t s1;
-		s1 = *next++;
-		s1 ^= (s1 >> 11);
-		s1 ^= (s1 <<  7) & 0x9d2c5680U;
-		s1 ^= (s1 << 15) & 0xefc60000U;
-		return ( s1 ^ (s1 >> 18) );
-	};
-
-	/// Get a random number on [0, max] interval.
-	uint32_t getRange( uint32_t max )
-	{
-		if (max == 0) return 0;
-		if (max == NV_UINT32_MAX) return get();
-		const uint32_t np2 = nextPowerOfTwo( max + 1 ); // @@ This fails if max == NV_UINT32_MAX
-		const uint32_t mask = np2 - 1;
-		uint32_t n;
-		do {
-			n = get() & mask;
-		} while ( n > max );
-		return n;
 	}
 
-private:
-	void initialize( uint32_t seed )
+	void update()
 	{
-		// Initialize generator state with seed
-		// See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
-		// In previous versions, most significant bits (MSBs) of the seed affect
-		// only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto.
-		uint32_t *s = state;
-		uint32_t *r = state;
-		int i = 1;
-		*s++ = seed & 0xffffffffUL;
-		for ( ; i < N; ++i ) {
-			*s++ = ( 1812433253UL * ( *r ^ (*r >> 30) ) + i ) & 0xffffffffUL;
-			r++;
+		if (!m_func)
+			return;
+		m_mutex.lock();
+		const uint32_t newProgress = uint32_t(ceilf(value.load() / (float)m_maxValue * 100.0f));
+		if (newProgress != m_progress && newProgress < 100) {
+			m_progress = newProgress;
+			if (!m_func(m_category, m_progress, m_userData))
+				cancel = true;
 		}
+		m_mutex.unlock();
 	}
 
-	void reload()
+	void setMaxValue(uint32_t maxValue)
 	{
-		// Generate N new values in state
-		// Made clearer and faster by Matthew Bellew (matthew.bellew@home.com)
-		uint32_t *p = state;
-		int i;
-		for ( i = N - M; i--; ++p )
-			*p = twist( p[M], p[0], p[1] );
-		for ( i = M; --i; ++p )
-			*p = twist( p[M - N], p[0], p[1] );
-		*p = twist( p[M - N], p[0], state[0] );
-		left = N, next = state;
+		m_mutex.lock();
+		m_maxValue = maxValue;
+		m_mutex.unlock();
 	}
 
-	uint32_t hiBit( uint32_t u ) const
-	{
-		return u & 0x80000000U;
-	}
-	uint32_t loBit( uint32_t u ) const
-	{
-		return u & 0x00000001U;
-	}
-	uint32_t loBits( uint32_t u ) const
-	{
-		return u & 0x7fffffffU;
-	}
-	uint32_t mixBits( uint32_t u, uint32_t v ) const
-	{
-		return hiBit(u) | loBits(v);
-	}
-	uint32_t twist( uint32_t m, uint32_t s0, uint32_t s1 ) const
-	{
-		return m ^ (mixBits(s0, s1) >> 1) ^ ((~loBit(s1) + 1) & 0x9908b0dfU);
-	}
+	std::atomic<uint32_t> value;
+	std::atomic<bool> cancel;
 
-	uint32_t state[N];	// internal state
-	uint32_t *next;	// next value to get from state
-	int left;		// number of values left before reload needed
+private:
+	ProgressCategory::Enum m_category;
+	ProgressFunc m_func;
+	void *m_userData;
+	uint32_t m_maxValue;
+	uint32_t m_progress;
+	std::mutex m_mutex;
 };
 
-namespace morton {
-// Code from ryg:
-// http://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
-
-// Inverse of part1By1 - "delete" all odd-indexed bits
-uint32_t compact1By1(uint32_t x)
-{
-	x &= 0x55555555;                  // x = -f-e -d-c -b-a -9-8 -7-6 -5-4 -3-2 -1-0
-	x = (x ^ (x >>  1)) & 0x33333333; // x = --fe --dc --ba --98 --76 --54 --32 --10
-	x = (x ^ (x >>  2)) & 0x0f0f0f0f; // x = ---- fedc ---- ba98 ---- 7654 ---- 3210
-	x = (x ^ (x >>  4)) & 0x00ff00ff; // x = ---- ---- fedc ba98 ---- ---- 7654 3210
-	x = (x ^ (x >>  8)) & 0x0000ffff; // x = ---- ---- ---- ---- fedc ba98 7654 3210
-	return x;
-}
-
-// Inverse of part1By2 - "delete" all bits not at positions divisible by 3
-uint32_t compact1By2(uint32_t x)
-{
-	x &= 0x09249249;                  // x = ---- 9--8 --7- -6-- 5--4 --3- -2-- 1--0
-	x = (x ^ (x >>  2)) & 0x030c30c3; // x = ---- --98 ---- 76-- --54 ---- 32-- --10
-	x = (x ^ (x >>  4)) & 0x0300f00f; // x = ---- --98 ---- ---- 7654 ---- ---- 3210
-	x = (x ^ (x >>  8)) & 0xff0000ff; // x = ---- --98 ---- ---- ---- ---- 7654 3210
-	x = (x ^ (x >> 16)) & 0x000003ff; // x = ---- ---- ---- ---- ---- --98 7654 3210
-	return x;
-}
-
-uint32_t decodeMorton2X(uint32_t code)
-{
-	return compact1By1(code >> 0);
-}
-
-uint32_t decodeMorton2Y(uint32_t code)
-{
-	return compact1By1(code >> 1);
-}
-
-uint32_t decodeMorton3X(uint32_t code)
+struct TaskGroupHandle
 {
-	return compact1By2(code >> 0);
-}
+	uint32_t value = UINT32_MAX;
+};
 
-uint32_t decodeMorton3Y(uint32_t code)
+struct Task
 {
-	return compact1By2(code >> 1);
-}
+	void (*func)(void *userData);
+	void *userData;
+};
 
-uint32_t decodeMorton3Z(uint32_t code)
+#if XA_MULTITHREADED
+class TaskScheduler
 {
-	return compact1By2(code >> 2);
-}
-} // namespace morton
-
-// A simple, dynamic proximity grid based on Jon's code.
-// Instead of storing pointers here I store indices.
-struct ProximityGrid 
-{
-	void init(const Box &box, uint32_t count)
-	{
-		cellArray.clear();
-		// Determine grid size.
-		float cellWidth;
-		Vector3 diagonal = box.extents() * 2.f;
-		float volume = box.volume();
-		if (equal(volume, 0)) {
-			// Degenerate box, treat like a quad.
-			Vector2 quad;
-			if (diagonal.x < diagonal.y && diagonal.x < diagonal.z) {
-				quad.x = diagonal.y;
-				quad.y = diagonal.z;
-			} else if (diagonal.y < diagonal.x && diagonal.y < diagonal.z) {
-				quad.x = diagonal.x;
-				quad.y = diagonal.z;
-			} else {
-				quad.x = diagonal.x;
-				quad.y = diagonal.y;
-			}
-			float cellArea = quad.x * quad.y / count;
-			cellWidth = sqrtf(cellArea); // pow(cellArea, 1.0f / 2.0f);
-		} else {
-			// Ideally we want one cell per point.
-			float cellVolume = volume / count;
-			cellWidth = powf(cellVolume, 1.0f / 3.0f);
+public:
+	TaskScheduler() : m_shutdown(false)
+	{
+		m_workers.resize(std::thread::hardware_concurrency() <= 1 ? 1 : std::thread::hardware_concurrency() - 1);
+		for (uint32_t i = 0; i < m_workers.size(); i++) {
+			m_workers[i].wakeup = false;
+			m_workers[i].thread = XA_NEW(MemTag::Default, std::thread, workerThread, this, &m_workers[i]);
 		}
-		xaDebugAssert(cellWidth != 0);
-		sx = std::max(1, ftoi_ceil(diagonal.x / cellWidth));
-		sy = std::max(1, ftoi_ceil(diagonal.y / cellWidth));
-		sz = std::max(1, ftoi_ceil(diagonal.z / cellWidth));
-		invCellSize.x = float(sx) / diagonal.x;
-		invCellSize.y = float(sy) / diagonal.y;
-		invCellSize.z = float(sz) / diagonal.z;
-		cellArray.resize(sx * sy * sz);
-		corner = box.minCorner; // @@ Align grid better?
 	}
 
-	int index_x(float x) const
+	~TaskScheduler()
 	{
-		return clamp(ftoi_floor((x - corner.x) * invCellSize.x),  0, sx - 1);
+		m_shutdown = true;
+		for (uint32_t i = 0; i < m_workers.size(); i++) {
+			Worker &worker = m_workers[i];
+			XA_DEBUG_ASSERT(worker.thread);
+			worker.wakeup = true;
+			worker.cv.notify_one();
+			if (worker.thread->joinable())
+				worker.thread->join();
+			worker.thread->~thread();
+			XA_FREE(worker.thread);
+		}
+		for (uint32_t i = 0; i < m_groups.size(); i++)
+			destroyGroup(i);
 	}
 
-	int index_y(float y) const
+	void run(TaskGroupHandle *handle, Task task)
 	{
-		return clamp(ftoi_floor((y - corner.y) * invCellSize.y),  0, sy - 1);
+		// Allocate a task group if this is the first time using this handle.
+		TaskGroup *group;
+		if (handle->value == UINT32_MAX) {
+			group = XA_NEW(MemTag::Default, TaskGroup);
+			group->ref = 0;
+			std::lock_guard<std::mutex> lock(m_groupsMutex);
+			for (uint32_t i = 0; i < m_groups.size(); i++) {
+				if (!m_groups[i]) {
+					m_groups[i] = group;
+					handle->value = i;
+					break;
+				}
+			}
+			if (handle->value == UINT32_MAX) {
+				m_groups.push_back(group);
+				handle->value = m_groups.size() - 1;
+			}
+		}
+		group = m_groups[handle->value];
+		{
+			std::lock_guard<std::mutex> lock(group->queueMutex);
+			group->queue.push_back(task);
+		}
+		group->ref++;
+		// Wake up a worker to run this task.
+		for (uint32_t i = 0; i < m_workers.size(); i++) {
+			m_workers[i].wakeup = true;
+			m_workers[i].cv.notify_one();
+		}
 	}
 
-	int index_z(float z) const
+	void wait(TaskGroupHandle *handle)
 	{
-		return clamp(ftoi_floor((z - corner.z) * invCellSize.z),  0, sz - 1);
+		if (handle->value == UINT32_MAX) {
+			XA_DEBUG_ASSERT(false);
+			return;
+		}
+		// Run tasks from the group queue until empty.
+		TaskGroup *group = m_groups[handle->value];
+		for (;;) {
+			Task *task = nullptr;
+			{
+				std::lock_guard<std::mutex> lock(group->queueMutex);
+				if (group->queueHead < group->queue.size())
+					task = &group->queue[group->queueHead++];
+			}
+			if (!task)
+				break;
+			task->func(task->userData);
+			group->ref--;
+		}
+		// Even though the task queue is empty, workers can still be running tasks.
+		while (group->ref > 0)
+			std::this_thread::yield();
+		std::lock_guard<std::mutex> lock(m_groupsMutex);
+		destroyGroup(handle->value);
+		handle->value = UINT32_MAX;
 	}
 
-	int index(int x, int y, int z) const
+private:
+	struct TaskGroup
 	{
-		xaDebugAssert(x >= 0 && x < sx);
-		xaDebugAssert(y >= 0 && y < sy);
-		xaDebugAssert(z >= 0 && z < sz);
-		int idx = (z * sy + y) * sx + x;
-		xaDebugAssert(idx >= 0 && uint32_t(idx) < cellArray.size());
-		return idx;
-	}
+		Array<Task> queue; // Items are never removed. queueHead is incremented to pop items.
+		uint32_t queueHead = 0;
+		std::mutex queueMutex;
+		std::atomic<uint32_t> ref; // Increment when a task is enqueued, decrement when a task finishes.
+	};
 
-	uint32_t mortonCount() const
+	struct Worker
 	{
-		uint64_t s = uint64_t(max3(sx, sy, sz));
-		s = nextPowerOfTwo(s);
-		if (s > 1024) {
-			return uint32_t(s * s * min3(sx, sy, sz));
-		}
-		return uint32_t(s * s * s);
-	}
+		std::thread *thread = nullptr;
+		std::mutex mutex;
+		std::condition_variable cv;
+		std::atomic<bool> wakeup;
+	};
 
-	int mortonIndex(uint32_t code) const
-	{
-		uint32_t x, y, z;
-		uint32_t s = uint32_t(max3(sx, sy, sz));
-		if (s > 1024) {
-			// Use layered two-dimensional morton order.
-			s = nextPowerOfTwo(s);
-			uint32_t layer = code / (s * s);
-			code = code % (s * s);
-			uint32_t layer_count = uint32_t(min3(sx, sy, sz));
-			if (sx == (int)layer_count) {
-				x = layer;
-				y = morton::decodeMorton2X(code);
-				z = morton::decodeMorton2Y(code);
-			} else if (sy == (int)layer_count) {
-				x = morton::decodeMorton2Y(code);
-				y = layer;
-				z = morton::decodeMorton2X(code);
-			} else { /*if (sz == layer_count)*/
-				x = morton::decodeMorton2X(code);
-				y = morton::decodeMorton2Y(code);
-				z = layer;
-			}
-		} else {
-			x = morton::decodeMorton3X(code);
-			y = morton::decodeMorton3Y(code);
-			z = morton::decodeMorton3Z(code);
-		}
-		if (x >= uint32_t(sx) || y >= uint32_t(sy) || z >= uint32_t(sz)) {
-			return -1;
-		}
-		return index(x, y, z);
-	}
+	Array<TaskGroup *> m_groups;
+	std::mutex m_groupsMutex;
+	Array<Worker> m_workers;
+	std::atomic<bool> m_shutdown;
 
-	void add(const Vector3 &pos, uint32_t key)
+	void destroyGroup(uint32_t index)
 	{
-		int x = index_x(pos.x);
-		int y = index_y(pos.y);
-		int z = index_z(pos.z);
-		uint32_t idx = index(x, y, z);
-		cellArray[idx].indexArray.push_back(key);
+		TaskGroup *group = m_groups[index];
+		m_groups[index] = nullptr;
+		if (group) {
+			group->~TaskGroup();
+			XA_FREE(group);
+		}
 	}
 
-	// Gather all points inside the given sphere.
-	// Radius is assumed to be small, so we don't bother culling the cells.
-	void gather(const Vector3 &position, float radius, std::vector<uint32_t> &indexArray)
+	static void workerThread(TaskScheduler *scheduler, Worker *worker)
 	{
-		int x0 = index_x(position.x - radius);
-		int x1 = index_x(position.x + radius);
-		int y0 = index_y(position.y - radius);
-		int y1 = index_y(position.y + radius);
-		int z0 = index_z(position.z - radius);
-		int z1 = index_z(position.z + radius);
-		for (int z = z0; z <= z1; z++) {
-			for (int y = y0; y <= y1; y++) {
-				for (int x = x0; x <= x1; x++) {
-					int idx = index(x, y, z);
-					indexArray.insert(indexArray.begin(), cellArray[idx].indexArray.begin(), cellArray[idx].indexArray.end());
+		std::unique_lock<std::mutex> lock(worker->mutex);
+		for (;;) {
+			worker->cv.wait(lock, [=]{ return worker->wakeup.load(); });
+			worker->wakeup = false;
+			for (;;) {
+				if (scheduler->m_shutdown)
+					return;
+				// Look for a task in any of the groups and run it.
+				TaskGroup *group = nullptr;
+				Task *task = nullptr;
+				{
+					std::lock_guard<std::mutex> groupsLock(scheduler->m_groupsMutex);
+					for (uint32_t i = 0; i < scheduler->m_groups.size(); i++) {
+						group = scheduler->m_groups[i];
+						if (!group)
+							continue;
+						std::lock_guard<std::mutex> queueLock(group->queueMutex);
+						if (group->queueHead < group->queue.size()) {
+							task = &group->queue[group->queueHead++];
+							break;
+						}
+					}
 				}
+				if (!task)
+					break;
+				task->func(task->userData);
+				group->ref--;
 			}
 		}
 	}
-
-	struct Cell {
-		std::vector<uint32_t> indexArray;
-	};
-
-	std::vector<Cell> cellArray;
-
-	Vector3 corner;
-	Vector3 invCellSize;
-	int sx, sy, sz;
 };
-
-// Based on Pierre Terdiman's and Michael Herf's source code.
-// http://www.codercorner.com/RadixSortRevisited.htm
-// http://www.stereopsis.com/radix.html
-class RadixSort
+#else
+class TaskScheduler
 {
 public:
-	RadixSort() : m_size(0), m_ranks(NULL), m_ranks2(NULL), m_validRanks(false) {}
-	~RadixSort()
+	~TaskScheduler()
 	{
-		// Release everything
-		free(m_ranks2);
-		free(m_ranks);
+		for (uint32_t i = 0; i < m_groups.size(); i++)
+			destroyGroup({ i });
 	}
 
-	RadixSort &sort(const float *input, uint32_t count)
+	void run(TaskGroupHandle *handle, Task task)
 	{
-		if (input == NULL || count == 0) return *this;
-		// Resize lists if needed
-		if (count != m_size) {
-			if (count > m_size) {
-				m_ranks2 = (uint32_t *)realloc(m_ranks2, sizeof(uint32_t ) * count);
-				m_ranks = (uint32_t *)realloc(m_ranks, sizeof(uint32_t ) * count);
-			}
-			m_size = count;
-			m_validRanks = false;
-		}
-		if (count < 32) {
-			insertionSort(input, count);
-		} else {
-			// @@ Avoid touching the input multiple times.
-			for (uint32_t i = 0; i < count; i++) {
-				FloatFlip((uint32_t &)input[i]);
+		if (handle->value == UINT32_MAX) {
+			TaskGroup *group = XA_NEW(MemTag::Default, TaskGroup);
+			for (uint32_t i = 0; i < m_groups.size(); i++) {
+				if (!m_groups[i]) {
+					m_groups[i] = group;
+					handle->value = i;
+					break;
+				}
 			}
-			radixSort<uint32_t>((const uint32_t *)input, count);
-			for (uint32_t i = 0; i < count; i++) {
-				IFloatFlip((uint32_t &)input[i]);
+			if (handle->value == UINT32_MAX) {
+				m_groups.push_back(group);
+				handle->value = m_groups.size() - 1;
 			}
 		}
-		return *this;
+		m_groups[handle->value]->queue.push_back(task);
 	}
 
-	RadixSort &sort(const std::vector<float> &input)
+	void wait(TaskGroupHandle *handle)
 	{
-		return sort(input.data(), input.size());
-	}
-
-	// Access to results. m_ranks is a list of indices in sorted order, i.e. in the order you may further process your data
-	const uint32_t *ranks() const
-	{
-		xaDebugAssert(m_validRanks);
-		return m_ranks;
-	}
-	uint32_t *ranks()
-	{
-		xaDebugAssert(m_validRanks);
-		return m_ranks;
+		if (handle->value == UINT32_MAX) {
+			XA_DEBUG_ASSERT(false);
+			return;
+		}
+		TaskGroup *group = m_groups[handle->value];
+		for (uint32_t i = 0; i < group->queue.size(); i++)
+			group->queue[i].func(group->queue[i].userData);
+		group->queue.clear();
+		destroyGroup(*handle);
+		handle->value = UINT32_MAX;
 	}
 
 private:
-	uint32_t m_size;
-	uint32_t *m_ranks;
-	uint32_t *m_ranks2;
-	bool m_validRanks;
-
-	void FloatFlip(uint32_t &f)
+	void destroyGroup(TaskGroupHandle handle)
 	{
-		int32_t mask = (int32_t(f) >> 31) | 0x80000000; // Warren Hunt, Manchor Ko.
-		f ^= mask;
+		TaskGroup *group = m_groups[handle.value];
+		if (group) {
+			group->~TaskGroup();
+			XA_FREE(group);
+			m_groups[handle.value] = nullptr;
+		}
 	}
 
-	void IFloatFlip(uint32_t &f)
+	struct TaskGroup
 	{
-		uint32_t mask = ((f >> 31) - 1) | 0x80000000; // Michael Herf.
-		f ^= mask;
-	}
+		Array<Task> queue;
+	};
 
-	template<typename T>
-	void createHistograms(const T *buffer, uint32_t count, uint32_t *histogram)
-	{
-		const uint32_t bucketCount = sizeof(T); // (8 * sizeof(T)) / log2(radix)
-		// Init bucket pointers.
-		uint32_t *h[bucketCount];
-		for (uint32_t i = 0; i < bucketCount; i++) {
-			h[i] = histogram + 256 * i;
-		}
-		// Clear histograms.
-		memset(histogram, 0, 256 * bucketCount * sizeof(uint32_t ));
-		// @@ Add support for signed integers.
-		// Build histograms.
-		const uint8_t *p = (const uint8_t *)buffer;  // @@ Does this break aliasing rules?
-		const uint8_t *pe = p + count * sizeof(T);
-		while (p != pe) {
-			h[0][*p++]++, h[1][*p++]++, h[2][*p++]++, h[3][*p++]++;
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4127)
-#endif
-			if (bucketCount == 8) h[4][*p++]++, h[5][*p++]++, h[6][*p++]++, h[7][*p++]++;
-#ifdef _MSC_VER
-#pragma warning(pop)
+	Array<TaskGroup *> m_groups;
+};
 #endif
-		}
-	}
 
-	template <typename T> void insertionSort(const T *input, uint32_t count)
-	{
-		if (!m_validRanks) {
-			m_ranks[0] = 0;
-			for (uint32_t i = 1; i != count; ++i) {
-				int rank = m_ranks[i] = i;
-				uint32_t j = i;
-				while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
-					m_ranks[j] = m_ranks[j - 1];
-					--j;
-				}
-				if (i != j) {
-					m_ranks[j] = rank;
-				}
-			}
-			m_validRanks = true;
-		} else {
-			for (uint32_t i = 1; i != count; ++i) {
-				int rank = m_ranks[i];
-				uint32_t j = i;
-				while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
-					m_ranks[j] = m_ranks[j - 1];
-					--j;
-				}
-				if (i != j) {
-					m_ranks[j] = rank;
-				}
-			}
-		}
-	}
+struct UvMeshChart
+{
+	Array<uint32_t> indices;
+	uint32_t material;
+};
 
-	template <typename T> void radixSort(const T *input, uint32_t count)
-	{
-		const uint32_t P = sizeof(T); // pass count
-		// Allocate histograms & offsets on the stack
-		uint32_t histogram[256 * P];
-		uint32_t *link[256];
-		createHistograms(input, count, histogram);
-		// Radix sort, j is the pass number (0=LSB, P=MSB)
-		for (uint32_t j = 0; j < P; j++) {
-			// Pointer to this bucket.
-			const uint32_t *h = &histogram[j * 256];
-			const uint8_t *inputBytes = (const uint8_t *)input; // @@ Is this aliasing legal?
-			inputBytes += j;
-			if (h[inputBytes[0]] == count) {
-				// Skip this pass, all values are the same.
-				continue;
-			}
-			// Create offsets
-			link[0] = m_ranks2;
-			for (uint32_t i = 1; i < 256; i++) link[i] = link[i - 1] + h[i - 1];
-			// Perform Radix Sort
-			if (!m_validRanks) {
-				for (uint32_t i = 0; i < count; i++) {
-					*link[inputBytes[i * P]]++ = i;
-				}
-				m_validRanks = true;
-			} else {
-				for (uint32_t i = 0; i < count; i++) {
-					const uint32_t idx = m_ranks[i];
-					*link[inputBytes[idx * P]]++ = idx;
-				}
-			}
-			// Swap pointers for next pass. Valid indices - the most recent ones - are in m_ranks after the swap.
-			std::swap(m_ranks, m_ranks2);
-		}
-		// All values were equal, generate linear ranks.
-		if (!m_validRanks) {
-			for (uint32_t i = 0; i < count; i++) {
-				m_ranks[i] = i;
-			}
-			m_validRanks = true;
-		}
-	}
+struct UvMesh
+{
+	UvMeshDecl decl;
+	Array<uint32_t> indices;
+	Array<UvMeshChart *> charts;
+	Array<uint32_t> vertexToChartMap;
+};
+
+struct UvMeshInstance
+{
+	UvMesh *mesh;
+	Array<Vector2> texcoords;
+	bool rotateCharts;
 };
 
 namespace raster {
 class ClippedTriangle
 {
 public:
-	ClippedTriangle(Vector2::Arg a, Vector2::Arg b, Vector2::Arg c)
+	ClippedTriangle(const Vector2 &a, const Vector2 &b, const Vector2 &c)
 	{
 		m_numVertices = 3;
 		m_activeVertexBuffer = 0;
@@ -3549,16 +3794,6 @@ public:
 		m_vertexBuffers[1] = m_verticesB;
 	}
 
-	uint32_t vertexCount()
-	{
-		return m_numVertices;
-	}
-
-	const Vector2 *vertices()
-	{
-		return m_vertexBuffers[m_activeVertexBuffer];
-	}
-
 	void clipHorizontalPlane(float offset, float clipdirection)
 	{
 		Vector2 *v  = m_vertexBuffers[m_activeVertexBuffer];
@@ -3581,7 +3816,6 @@ public:
 			dy1in = dy2in;
 		}
 		m_numVertices = p;
-		//for (uint32_t k=0; k<m_numVertices; k++) printf("(%f, %f)\n", v2[k].x, v2[k].y); printf("\n");
 	}
 
 	void clipVerticalPlane(float offset, float clipdirection )
@@ -3608,7 +3842,7 @@ public:
 		m_numVertices = p;
 	}
 
-	void computeAreaCentroid()
+	void computeArea()
 	{
 		Vector2 *v  = m_vertexBuffers[m_activeVertexBuffer];
 		v[m_numVertices] = v[0];
@@ -3622,25 +3856,15 @@ public:
 			centroidy += f * (v[k].y + v[k + 1].y);
 		}
 		m_area = 0.5f * fabsf(m_area);
-		if (m_area == 0) {
-			m_centroid = Vector2(0.0f);
-		} else {
-			m_centroid = Vector2(centroidx / (6 * m_area), centroidy / (6 * m_area));
-		}
 	}
 
 	void clipAABox(float x0, float y0, float x1, float y1)
 	{
-		clipVerticalPlane  ( x0, -1);
-		clipHorizontalPlane( y0, -1);
-		clipVerticalPlane  ( x1,  1);
-		clipHorizontalPlane( y1,  1);
-		computeAreaCentroid();
-	}
-
-	Vector2 centroid()
-	{
-		return m_centroid;
+		clipVerticalPlane(x0, -1);
+		clipHorizontalPlane(y0, -1);
+		clipVerticalPlane(x1, 1);
+		clipHorizontalPlane(y1, 1);
+		computeArea();
 	}
 
 	float area()
@@ -3652,212 +3876,50 @@ private:
 	Vector2 m_verticesA[7 + 1];
 	Vector2 m_verticesB[7 + 1];
 	Vector2 *m_vertexBuffers[2];
-	uint32_t    m_numVertices;
-	uint32_t    m_activeVertexBuffer;
-	float   m_area;
-	Vector2 m_centroid;
+	uint32_t m_numVertices;
+	uint32_t m_activeVertexBuffer;
+	float m_area;
 };
 
 /// A callback to sample the environment. Return false to terminate rasterization.
-typedef bool (* SamplingCallback)(void *param, int x, int y, Vector3::Arg bar, Vector3::Arg dx, Vector3::Arg dy, float coverage);
+typedef bool (*SamplingCallback)(void *param, int x, int y);
 
 /// A triangle for rasterization.
 struct Triangle
 {
-	Triangle(Vector2::Arg v0, Vector2::Arg v1, Vector2::Arg v2, Vector3::Arg t0, Vector3::Arg t1, Vector3::Arg t2)
+	Triangle(const Vector2 &v0, const Vector2 &v1, const Vector2 &v2)
 	{
 		// Init vertices.
 		this->v1 = v0;
 		this->v2 = v2;
 		this->v3 = v1;
-		// Set barycentric coordinates.
-		this->t1 = t0;
-		this->t2 = t2;
-		this->t3 = t1;
 		// make sure every triangle is front facing.
 		flipBackface();
 		// Compute deltas.
-		valid = computeDeltas();
 		computeUnitInwardNormals();
 	}
 
-	/// Compute texture space deltas.
-	/// This method takes two edge vectors that form a basis, determines the
-	/// coordinates of the canonic vectors in that basis, and computes the
-	/// texture gradient that corresponds to those vectors.
-	bool computeDeltas()
+	bool isValid()
 	{
-		Vector2 e0 = v3 - v1;
-		Vector2 e1 = v2 - v1;
-		Vector3 de0 = t3 - t1;
-		Vector3 de1 = t2 - t1;
-		float denom = 1.0f / (e0.y * e1.x - e1.y * e0.x);
-		if (!std::isfinite(denom)) {
-			return false;
-		}
-		float lambda1 = - e1.y * denom;
-		float lambda2 = e0.y * denom;
-		float lambda3 = e1.x * denom;
-		float lambda4 = - e0.x * denom;
-		dx = de0 * lambda1 + de1 * lambda2;
-		dy = de0 * lambda3 + de1 * lambda4;
-		return true;
-	}
-
-	bool draw(const Vector2 &extents, bool enableScissors, SamplingCallback cb, void *param)
-	{
-		// 28.4 fixed-point coordinates
-		const int Y1 = ftoi_round(16.0f * v1.y);
-		const int Y2 = ftoi_round(16.0f * v2.y);
-		const int Y3 = ftoi_round(16.0f * v3.y);
-		const int X1 = ftoi_round(16.0f * v1.x);
-		const int X2 = ftoi_round(16.0f * v2.x);
-		const int X3 = ftoi_round(16.0f * v3.x);
-		// Deltas
-		const int DX12 = X1 - X2;
-		const int DX23 = X2 - X3;
-		const int DX31 = X3 - X1;
-		const int DY12 = Y1 - Y2;
-		const int DY23 = Y2 - Y3;
-		const int DY31 = Y3 - Y1;
-		// Fixed-point deltas
-		const int FDX12 = DX12 << 4;
-		const int FDX23 = DX23 << 4;
-		const int FDX31 = DX31 << 4;
-		const int FDY12 = DY12 << 4;
-		const int FDY23 = DY23 << 4;
-		const int FDY31 = DY31 << 4;
-		int minx, miny, maxx, maxy;
-		if (enableScissors) {
-			int frustumX0 =  0 << 4;
-			int frustumY0 =  0 << 4;
-			int frustumX1 =  (int)extents.x << 4;
-			int frustumY1 =  (int)extents.y << 4;
-			// Bounding rectangle
-			minx = (std::max(min3(X1, X2, X3), frustumX0) + 0xF) >> 4;
-			miny = (std::max(min3(Y1, Y2, Y3), frustumY0) + 0xF) >> 4;
-			maxx = (std::min(max3(X1, X2, X3), frustumX1) + 0xF) >> 4;
-			maxy = (std::min(max3(Y1, Y2, Y3), frustumY1) + 0xF) >> 4;
-		} else {
-			// Bounding rectangle
-			minx = (min3(X1, X2, X3) + 0xF) >> 4;
-			miny = (min3(Y1, Y2, Y3) + 0xF) >> 4;
-			maxx = (max3(X1, X2, X3) + 0xF) >> 4;
-			maxy = (max3(Y1, Y2, Y3) + 0xF) >> 4;
-		}
-		// Block size, standard 8x8 (must be power of two)
-		const int q = 8;
-		// @@ This won't work when minx,miny are negative. This code path is not used. Leaving as is for now.
-		xaAssert(minx >= 0);
-		xaAssert(miny >= 0);
-		// Start in corner of 8x8 block
-		minx &= ~(q - 1);
-		miny &= ~(q - 1);
-		// Half-edge constants
-		int C1 = DY12 * X1 - DX12 * Y1;
-		int C2 = DY23 * X2 - DX23 * Y2;
-		int C3 = DY31 * X3 - DX31 * Y3;
-		// Correct for fill convention
-		if (DY12 < 0 || (DY12 == 0 && DX12 > 0)) C1++;
-		if (DY23 < 0 || (DY23 == 0 && DX23 > 0)) C2++;
-		if (DY31 < 0 || (DY31 == 0 && DX31 > 0)) C3++;
-		// Loop through blocks
-		for (int y = miny; y < maxy; y += q) {
-			for (int x = minx; x < maxx; x += q) {
-				// Corners of block
-				int x0 = x << 4;
-				int x1 = (x + q - 1) << 4;
-				int y0 = y << 4;
-				int y1 = (y + q - 1) << 4;
-				// Evaluate half-space functions
-				bool a00 = C1 + DX12 * y0 - DY12 * x0 > 0;
-				bool a10 = C1 + DX12 * y0 - DY12 * x1 > 0;
-				bool a01 = C1 + DX12 * y1 - DY12 * x0 > 0;
-				bool a11 = C1 + DX12 * y1 - DY12 * x1 > 0;
-				int a = (a00 << 0) | (a10 << 1) | (a01 << 2) | (a11 << 3);
-				bool b00 = C2 + DX23 * y0 - DY23 * x0 > 0;
-				bool b10 = C2 + DX23 * y0 - DY23 * x1 > 0;
-				bool b01 = C2 + DX23 * y1 - DY23 * x0 > 0;
-				bool b11 = C2 + DX23 * y1 - DY23 * x1 > 0;
-				int b = (b00 << 0) | (b10 << 1) | (b01 << 2) | (b11 << 3);
-				bool c00 = C3 + DX31 * y0 - DY31 * x0 > 0;
-				bool c10 = C3 + DX31 * y0 - DY31 * x1 > 0;
-				bool c01 = C3 + DX31 * y1 - DY31 * x0 > 0;
-				bool c11 = C3 + DX31 * y1 - DY31 * x1 > 0;
-				int c = (c00 << 0) | (c10 << 1) | (c01 << 2) | (c11 << 3);
-				// Skip block when outside an edge
-				if (a == 0x0 || b == 0x0 || c == 0x0) continue;
-				// Accept whole block when totally covered
-				if (a == 0xF && b == 0xF && c == 0xF) {
-					Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
-					for (int iy = y; iy < y + q; iy++) {
-						Vector3 tex = texRow;
-						for (int ix = x; ix < x + q; ix++) {
-							//Vector3 tex = t1 + dx * (ix - v1.x) + dy * (iy - v1.y);
-							if (!cb(param, ix, iy, tex, dx, dy, 1.0)) {
-								// early out.
-								return false;
-							}
-							tex += dx;
-						}
-						texRow += dy;
-					}
-				} else { // Partially covered block
-					int CY1 = C1 + DX12 * y0 - DY12 * x0;
-					int CY2 = C2 + DX23 * y0 - DY23 * x0;
-					int CY3 = C3 + DX31 * y0 - DY31 * x0;
-					Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
-					for (int iy = y; iy < y + q; iy++) {
-						int CX1 = CY1;
-						int CX2 = CY2;
-						int CX3 = CY3;
-						Vector3 tex = texRow;
-						for (int ix = x; ix < x + q; ix++) {
-							if (CX1 > 0 && CX2 > 0 && CX3 > 0) {
-								if (!cb(param, ix, iy, tex, dx, dy, 1.0)) {
-									// early out.
-									return false;
-								}
-							}
-							CX1 -= FDY12;
-							CX2 -= FDY23;
-							CX3 -= FDY31;
-							tex += dx;
-						}
-						CY1 += FDX12;
-						CY2 += FDX23;
-						CY3 += FDX31;
-						texRow += dy;
-					}
-				}
-			}
-		}
-		return true;
+		const Vector2 e0 = v3 - v1;
+		const Vector2 e1 = v2 - v1;
+		const float denom = 1.0f / (e0.y * e1.x - e1.y * e0.x);
+		return isFinite(denom);
 	}
 
 	// extents has to be multiple of BK_SIZE!!
-	bool drawAA(const Vector2 &extents, bool enableScissors, SamplingCallback cb, void *param)
+	bool drawAA(const Vector2 &extents, SamplingCallback cb, void *param)
 	{
-		const float PX_INSIDE = 1.0f/sqrt(2.0f);
-		const float PX_OUTSIDE = -1.0f/sqrt(2.0f);
+		const float PX_INSIDE = 1.0f/sqrtf(2.0f);
+		const float PX_OUTSIDE = -1.0f/sqrtf(2.0f);
 		const float BK_SIZE = 8;
-		const float BK_INSIDE = sqrt(BK_SIZE*BK_SIZE/2.0f);
-		const float BK_OUTSIDE = -sqrt(BK_SIZE*BK_SIZE/2.0f);
-
-		float minx, miny, maxx, maxy;
-		if (enableScissors) {
-			// Bounding rectangle
-			minx = floorf(std::max(min3(v1.x, v2.x, v3.x), 0.0f));
-			miny = floorf(std::max(min3(v1.y, v2.y, v3.y), 0.0f));
-			maxx = ceilf( std::min(max3(v1.x, v2.x, v3.x), extents.x - 1.0f));
-			maxy = ceilf( std::min(max3(v1.y, v2.y, v3.y), extents.y - 1.0f));
-		} else {
-			// Bounding rectangle
-			minx = floorf(min3(v1.x, v2.x, v3.x));
-			miny = floorf(min3(v1.y, v2.y, v3.y));
-			maxx = ceilf( max3(v1.x, v2.x, v3.x));
-			maxy = ceilf( max3(v1.y, v2.y, v3.y));
-		}
+		const float BK_INSIDE = sqrtf(BK_SIZE*BK_SIZE/2.0f);
+		const float BK_OUTSIDE = -sqrtf(BK_SIZE*BK_SIZE/2.0f);
+		// Bounding rectangle
+		float minx = floorf(max(min3(v1.x, v2.x, v3.x), 0.0f));
+		float miny = floorf(max(min3(v1.y, v2.y, v3.y), 0.0f));
+		float maxx = ceilf( min(max3(v1.x, v2.x, v3.x), extents.x - 1.0f));
+		float maxy = ceilf( min(max3(v1.y, v2.y, v3.y), extents.y - 1.0f));
 		// There's no reason to align the blocks to the viewport, instead we align them to the origin of the triangle bounds.
 		minx = floorf(minx);
 		miny = floorf(miny);
@@ -3885,47 +3947,32 @@ struct Triangle
 				if ( (aC <= BK_OUTSIDE) || (bC <= BK_OUTSIDE) || (cC <= BK_OUTSIDE) ) continue;
 				// Accept whole block when totally covered
 				if ( (aC >= BK_INSIDE) && (bC >= BK_INSIDE) && (cC >= BK_INSIDE) ) {
-					Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
 					for (float y = y0; y < y0 + BK_SIZE; y++) {
-						Vector3 tex = texRow;
 						for (float x = x0; x < x0 + BK_SIZE; x++) {
-							if (!cb(param, (int)x, (int)y, tex, dx, dy, 1.0f)) {
+							if (!cb(param, (int)x, (int)y)) {
 								return false;
 							}
-							tex += dx;
 						}
-						texRow += dy;
 					}
 				} else { // Partially covered block
 					float CY1 = C1 + n1.x * x0 + n1.y * y0;
 					float CY2 = C2 + n2.x * x0 + n2.y * y0;
 					float CY3 = C3 + n3.x * x0 + n3.y * y0;
-					Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
 					for (float y = y0; y < y0 + BK_SIZE; y++) { // @@ This is not clipping to scissor rectangle correctly.
 						float CX1 = CY1;
 						float CX2 = CY2;
 						float CX3 = CY3;
-						Vector3 tex = texRow;
 						for (float x = x0; x < x0 + BK_SIZE; x++) { // @@ This is not clipping to scissor rectangle correctly.
 							if (CX1 >= PX_INSIDE && CX2 >= PX_INSIDE && CX3 >= PX_INSIDE) {
-								// pixel completely covered
-								Vector3 tex2 = t1 + dx * (x - v1.x) + dy * (y - v1.y);
-								if (!cb(param, (int)x, (int)y, tex2, dx, dy, 1.0f)) {
+								if (!cb(param, (int)x, (int)y)) {
 									return false;
 								}
 							} else if ((CX1 >= PX_OUTSIDE) && (CX2 >= PX_OUTSIDE) && (CX3 >= PX_OUTSIDE)) {
 								// triangle partially covers pixel. do clipping.
 								ClippedTriangle ct(v1 - Vector2(x, y), v2 - Vector2(x, y), v3 - Vector2(x, y));
 								ct.clipAABox(-0.5, -0.5, 0.5, 0.5);
-								Vector2 centroid = ct.centroid();
-								float area = ct.area();
-								if (area > 0.0f) {
-									Vector3 texCent = tex - dx * centroid.x - dy * centroid.y;
-									//xaAssert(texCent.x >= -0.1f && texCent.x <= 1.1f); // @@ Centroid is not very exact...
-									//xaAssert(texCent.y >= -0.1f && texCent.y <= 1.1f);
-									//xaAssert(texCent.z >= -0.1f && texCent.z <= 1.1f);
-									//Vector3 texCent2 = t1 + dx * (x - v1.x) + dy * (y - v1.y);
-									if (!cb(param, (int)x, (int)y, texCent, dx, dy, area)) {
+								if (ct.area() > 0.0f) {
+									if (!cb(param, (int)x, (int)y)) {
 										return false;
 									}
 								}
@@ -3933,12 +3980,10 @@ struct Triangle
 							CX1 += n1.x;
 							CX2 += n2.x;
 							CX3 += n3.x;
-							tex += dx;
 						}
 						CY1 += n1.y;
 						CY2 += n2.y;
 						CY3 += n3.y;
-						texRow += dy;
 					}
 				}
 			}
@@ -3953,9 +3998,6 @@ struct Triangle
 			Vector2 hv = v1;
 			v1 = v2;
 			v2 = hv; // swap pos
-			Vector3 ht = t1;
-			t1 = t2;
-			t2 = ht; // swap tex
 		}
 	}
 
@@ -3976,77 +4018,24 @@ struct Triangle
 	// Vertices.
 	Vector2 v1, v2, v3;
 	Vector2 n1, n2, n3; // unit inward normals
-	Vector3 t1, t2, t3;
-
-	// Deltas.
-	Vector3 dx, dy;
-
-	float sign;
-	bool valid;
-};
-
-enum Mode
-{
-	Mode_Nearest,
-	Mode_Antialiased
 };
 
 // Process the given triangle. Returns false if rasterization was interrupted by the callback.
-static bool drawTriangle(Mode mode, Vector2::Arg extents, bool enableScissors, const Vector2 v[3], SamplingCallback cb, void *param)
+static bool drawTriangle(const Vector2 &extents, const Vector2 v[3], SamplingCallback cb, void *param)
 {
-	Triangle tri(v[0], v[1], v[2], Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1));
+	Triangle tri(v[0], v[1], v[2]);
 	// @@ It would be nice to have a conservative drawing mode that enlarges the triangle extents by one texel and is able to handle degenerate triangles.
 	// @@ Maybe the simplest thing to do would be raster triangle edges.
-	if (tri.valid) {
-		if (mode == Mode_Antialiased) {
-			return tri.drawAA(extents, enableScissors, cb, param);
-		}
-		if (mode == Mode_Nearest) {
-			return tri.draw(extents, enableScissors, cb, param);
-		}
-	}
+	if (tri.isValid())
+		return tri.drawAA(extents, cb, param);
 	return true;
 }
 
-// Process the given quad. Returns false if rasterization was interrupted by the callback.
-static bool drawQuad(Mode mode, Vector2::Arg extents, bool enableScissors, const Vector2 v[4], SamplingCallback cb, void *param)
-{
-	bool sign0 = triangleArea2(v[0], v[1], v[2]) > 0.0f;
-	bool sign1 = triangleArea2(v[0], v[2], v[3]) > 0.0f;
-	// Divide the quad into two non overlapping triangles.
-	if (sign0 == sign1) {
-		Triangle tri0(v[0], v[1], v[2], Vector3(0, 0, 0), Vector3(1, 0, 0), Vector3(1, 1, 0));
-		Triangle tri1(v[0], v[2], v[3], Vector3(0, 0, 0), Vector3(1, 1, 0), Vector3(0, 1, 0));
-		if (tri0.valid && tri1.valid) {
-			if (mode == Mode_Antialiased) {
-				return tri0.drawAA(extents, enableScissors, cb, param) && tri1.drawAA(extents, enableScissors, cb, param);
-			} else {
-				return tri0.draw(extents, enableScissors, cb, param) && tri1.draw(extents, enableScissors, cb, param);
-			}
-		}
-	} else {
-		Triangle tri0(v[0], v[1], v[3], Vector3(0, 0, 0), Vector3(1, 0, 0), Vector3(0, 1, 0));
-		Triangle tri1(v[1], v[2], v[3], Vector3(1, 0, 0), Vector3(1, 1, 0), Vector3(0, 1, 0));
-		if (tri0.valid && tri1.valid) {
-			if (mode == Mode_Antialiased) {
-				return tri0.drawAA(extents, enableScissors, cb, param) && tri1.drawAA(extents, enableScissors, cb, param);
-			} else {
-				return tri0.draw(extents, enableScissors, cb, param) && tri1.draw(extents, enableScissors, cb, param);
-			}
-		}
-	}
-	return true;
-}
 } // namespace raster
 
 // Full and sparse vector and matrix classes. BLAS subset.
 // Pseudo-BLAS interface.
 namespace sparse {
-enum Transpose
-{
-	NoTransposed = 0,
-	Transposed = 1
-};
 
 /**
 * Sparse matrix class. The matrix is assumed to be sparse and to have
@@ -4072,8 +4061,8 @@ public:
 
 	const Matrix &operator=(const Matrix &m)
 	{
-		xaAssert(width() == m.width());
-		xaAssert(height() == m.height());
+		XA_ASSERT(width() == m.width());
+		XA_ASSERT(height() == m.height());
 		m_array = m.m_array;
 		return *this;
 	}
@@ -4085,8 +4074,8 @@ public:
 	// x is column, y is row
 	float getCoefficient(uint32_t x, uint32_t y) const
 	{
-		xaDebugAssert( x < width() );
-		xaDebugAssert( y < height() );
+		XA_DEBUG_ASSERT( x < width() );
+		XA_DEBUG_ASSERT( y < height() );
 		const uint32_t count = m_array[y].size();
 		for (uint32_t i = 0; i < count; i++) {
 			if (m_array[y][i].x == x) return m_array[y][i].v;
@@ -4096,8 +4085,8 @@ public:
 
 	void setCoefficient(uint32_t x, uint32_t y, float f)
 	{
-		xaDebugAssert( x < width() );
-		xaDebugAssert( y < height() );
+		XA_DEBUG_ASSERT( x < width() );
+		XA_DEBUG_ASSERT( y < height() );
 		const uint32_t count = m_array[y].size();
 		for (uint32_t i = 0; i < count; i++) {
 			if (m_array[y][i].x == x) {
@@ -4113,7 +4102,7 @@ public:
 
 	float dotRow(uint32_t y, const FullVector &v) const
 	{
-		xaDebugAssert( y < height() );
+		XA_DEBUG_ASSERT( y < height() );
 		const uint32_t count = m_array[y].size();
 		float sum = 0;
 		for (uint32_t i = 0; i < count; i++) {
@@ -4124,7 +4113,7 @@ public:
 
 	void madRow(uint32_t y, float alpha, FullVector &v) const
 	{
-		xaDebugAssert(y < height());
+		XA_DEBUG_ASSERT(y < height());
 		const uint32_t count = m_array[y].size();
 		for (uint32_t i = 0; i < count; i++) {
 			v[m_array[y][i].x] += alpha * m_array[y][i].v;
@@ -4133,33 +4122,24 @@ public:
 
 	void clearRow(uint32_t y)
 	{
-		xaDebugAssert( y < height() );
+		XA_DEBUG_ASSERT( y < height() );
 		m_array[y].clear();
 	}
 
-	void scaleRow(uint32_t y, float f)
-	{
-		xaDebugAssert( y < height() );
-		const uint32_t count = m_array[y].size();
-		for (uint32_t i = 0; i < count; i++) {
-			m_array[y][i].v *= f;
-		}
-	}
-
-	const std::vector<Coefficient> &getRow(uint32_t y) const { return m_array[y]; }
+	const Array<Coefficient> &getRow(uint32_t y) const { return m_array[y]; }
 
 private:
 	/// Number of columns.
 	const uint32_t m_width;
 
 	/// Array of matrix elements.
-	std::vector< std::vector<Coefficient> > m_array;
+	Array< Array<Coefficient> > m_array;
 };
 
 // y = a * x + y
 static void saxpy(float a, const FullVector &x, FullVector &y)
 {
-	xaDebugAssert(x.dimension() == y.dimension());
+	XA_DEBUG_ASSERT(x.dimension() == y.dimension());
 	const uint32_t dim = x.dimension();
 	for (uint32_t i = 0; i < dim; i++) {
 		y[i] += a * x[i];
@@ -4168,7 +4148,7 @@ static void saxpy(float a, const FullVector &x, FullVector &y)
 
 static void copy(const FullVector &x, FullVector &y)
 {
-	xaDebugAssert(x.dimension() == y.dimension());
+	XA_DEBUG_ASSERT(x.dimension() == y.dimension());
 	const uint32_t dim = x.dimension();
 	for (uint32_t i = 0; i < dim; i++) {
 		y[i] = x[i];
@@ -4185,7 +4165,7 @@ static void scal(float a, FullVector &x)
 
 static float dot(const FullVector &x, const FullVector &y)
 {
-	xaDebugAssert(x.dimension() == y.dimension());
+	XA_DEBUG_ASSERT(x.dimension() == y.dimension());
 	const uint32_t dim = x.dimension();
 	float sum = 0;
 	for (uint32_t i = 0; i < dim; i++) {
@@ -4194,61 +4174,35 @@ static float dot(const FullVector &x, const FullVector &y)
 	return sum;
 }
 
-static void mult(Transpose TM, const Matrix &M, const FullVector &x, FullVector &y)
-{
-	const uint32_t w = M.width();
-	const uint32_t h = M.height();
-	if (TM == Transposed) {
-		xaDebugAssert( h == x.dimension() );
-		xaDebugAssert( w == y.dimension() );
-		y.fill(0.0f);
-		for (uint32_t i = 0; i < h; i++) {
-			M.madRow(i, x[i], y);
-		}
-	} else {
-		xaDebugAssert( w == x.dimension() );
-		xaDebugAssert( h == y.dimension() );
-		for (uint32_t i = 0; i < h; i++) {
-			y[i] = M.dotRow(i, x);
-		}
-	}
-}
-
 // y = M * x
 static void mult(const Matrix &M, const FullVector &x, FullVector &y)
 {
-	mult(NoTransposed, M, x, y);
-}
-
-static void sgemv(float alpha, Transpose TA, const Matrix &A, const FullVector &x, float beta, FullVector &y)
-{
-	const uint32_t w = A.width();
-	const uint32_t h = A.height();
-	if (TA == Transposed) {
-		xaDebugAssert( h == x.dimension() );
-		xaDebugAssert( w == y.dimension() );
-		for (uint32_t i = 0; i < h; i++) {
-			A.madRow(i, alpha * x[i], y);
-		}
-	} else {
-		xaDebugAssert( w == x.dimension() );
-		xaDebugAssert( h == y.dimension() );
-		for (uint32_t i = 0; i < h; i++) {
-			y[i] = alpha * A.dotRow(i, x) + beta * y[i];
-		}
-	}
+	uint32_t w = M.width();
+	uint32_t h = M.height();
+	XA_DEBUG_ASSERT( w == x.dimension() );
+	XA_UNUSED(w);
+	XA_DEBUG_ASSERT( h == y.dimension() );
+	for (uint32_t i = 0; i < h; i++)
+		y[i] = M.dotRow(i, x);
 }
 
 // y = alpha*A*x + beta*y
 static void sgemv(float alpha, const Matrix &A, const FullVector &x, float beta, FullVector &y)
 {
-	sgemv(alpha, NoTransposed, A, x, beta, y);
+	const uint32_t w = A.width();
+	const uint32_t h = A.height();
+	XA_DEBUG_ASSERT( w == x.dimension() );
+	XA_DEBUG_ASSERT( h == y.dimension() );
+	XA_UNUSED(w);
+	XA_UNUSED(h);
+	for (uint32_t i = 0; i < h; i++)
+		y[i] = alpha * A.dotRow(i, x) + beta * y[i];
 }
 
 // dot y-row of A by x-column of B
 static float dotRowColumn(int y, const Matrix &A, int x, const Matrix &B)
 {
-	const std::vector<Matrix::Coefficient> &row = A.getRow(y);
+	const Array<Matrix::Coefficient> &row = A.getRow(y);
 	const uint32_t count = row.size();
 	float sum = 0.0f;
 	for (uint32_t i = 0; i < count; i++) {
@@ -4258,96 +4212,54 @@ static float dotRowColumn(int y, const Matrix &A, int x, const Matrix &B)
 	return sum;
 }
 
-// dot y-row of A by x-row of B
-static float dotRowRow(int y, const Matrix &A, int x, const Matrix &B)
-{
-	const std::vector<Matrix::Coefficient> &row = A.getRow(y);
-	const uint32_t count = row.size();
-	float sum = 0.0f;
-	for (uint32_t i = 0; i < count; i++) {
-		const Matrix::Coefficient &c = row[i];
-		sum += c.v * B.getCoefficient(c.x, x);
-	}
-	return sum;
-}
-
-// dot y-column of A by x-column of B
-static float dotColumnColumn(int y, const Matrix &A, int x, const Matrix &B)
-{
-	xaDebugAssert(A.height() == B.height());
-	const uint32_t h = A.height();
-	float sum = 0.0f;
-	for (uint32_t i = 0; i < h; i++) {
-		sum += A.getCoefficient(y, i) * B.getCoefficient(x, i);
-	}
-	return sum;
-}
-
 static void transpose(const Matrix &A, Matrix &B)
 {
-	xaDebugAssert(A.width() == B.height());
-	xaDebugAssert(B.width() == A.height());
+	XA_DEBUG_ASSERT(A.width() == B.height());
+	XA_DEBUG_ASSERT(B.width() == A.height());
 	const uint32_t w = A.width();
 	for (uint32_t x = 0; x < w; x++) {
 		B.clearRow(x);
 	}
 	const uint32_t h = A.height();
 	for (uint32_t y = 0; y < h; y++) {
-		const std::vector<Matrix::Coefficient> &row = A.getRow(y);
+		const Array<Matrix::Coefficient> &row = A.getRow(y);
 		const uint32_t count = row.size();
 		for (uint32_t i = 0; i < count; i++) {
 			const Matrix::Coefficient &c = row[i];
-			xaDebugAssert(c.x < w);
+			XA_DEBUG_ASSERT(c.x < w);
 			B.setCoefficient(y, c.x, c.v);
 		}
 	}
 }
 
-static void sgemm(float alpha, Transpose TA, const Matrix &A, Transpose TB, const Matrix &B, float beta, Matrix &C)
+static void sgemm(float alpha, const Matrix &A, const Matrix &B, float beta, Matrix &C)
 {
 	const uint32_t w = C.width();
 	const uint32_t h = C.height();
-	uint32_t aw = (TA == NoTransposed) ? A.width() : A.height();
-	uint32_t ah = (TA == NoTransposed) ? A.height() : A.width();
-	uint32_t bw = (TB == NoTransposed) ? B.width() : B.height();
-	uint32_t bh = (TB == NoTransposed) ? B.height() : B.width();
-	xaDebugAssert(aw == bh);
-	xaDebugAssert(bw == ah);
-	xaDebugAssert(w == bw);
-	xaDebugAssert(h == ah);
-#ifdef NDEBUG
-	aw = ah = bw = bh = 0; // silence unused parameter warning
+#if XA_DEBUG
+	const uint32_t aw = A.width();
+	const uint32_t ah = A.height();
+	const uint32_t bw = B.width();
+	const uint32_t bh = B.height();
+	XA_DEBUG_ASSERT(aw == bh);
+	XA_DEBUG_ASSERT(bw == ah);
+	XA_DEBUG_ASSERT(w == bw);
+	XA_DEBUG_ASSERT(h == ah);
 #endif
 	for (uint32_t y = 0; y < h; y++) {
 		for (uint32_t x = 0; x < w; x++) {
 			float c = beta * C.getCoefficient(x, y);
-			if (TA == NoTransposed && TB == NoTransposed) {
-				// dot y-row of A by x-column of B.
-				c += alpha * dotRowColumn(y, A, x, B);
-			} else if (TA == Transposed && TB == Transposed) {
-				// dot y-column of A by x-row of B.
-				c += alpha * dotRowColumn(x, B, y, A);
-			} else if (TA == Transposed && TB == NoTransposed) {
-				// dot y-column of A by x-column of B.
-				c += alpha * dotColumnColumn(y, A, x, B);
-			} else if (TA == NoTransposed && TB == Transposed) {
-				// dot y-row of A by x-row of B.
-				c += alpha * dotRowRow(y, A, x, B);
-			}
+			// dot y-row of A by x-column of B.
+			c += alpha * dotRowColumn(y, A, x, B);
 			C.setCoefficient(x, y, c);
 		}
 	}
 }
 
-static void mult(Transpose TA, const Matrix &A, Transpose TB, const Matrix &B, Matrix &C)
-{
-	sgemm(1.0f, TA, A, TB, B, 0.0f, C);
-}
-
 // C = A * B
 static void mult(const Matrix &A, const Matrix &B, Matrix &C)
 {
-	mult(NoTransposed, A, NoTransposed, B, C);
+	sgemm(1.0f, A, B, 0.0f, C);
 }
 
 } // namespace sparse
@@ -4357,10 +4269,10 @@ class JacobiPreconditioner
 public:
 	JacobiPreconditioner(const sparse::Matrix &M, bool symmetric) : m_inverseDiagonal(M.width())
 	{
-		xaAssert(M.isSquare());
+		XA_ASSERT(M.isSquare());
 		for (uint32_t x = 0; x < M.width(); x++) {
 			float elem = M.getCoefficient(x, x);
-			//xaDebugAssert( elem != 0.0f ); // This can be zero in the presence of zero area triangles.
+			//XA_DEBUG_ASSERT( elem != 0.0f ); // This can be zero in the presence of zero area triangles.
 			if (symmetric) {
 				m_inverseDiagonal[x] = (elem != 0) ? 1.0f / sqrtf(fabsf(elem)) : 1.0f;
 			} else {
@@ -4371,8 +4283,8 @@ public:
 
 	void apply(const FullVector &x, FullVector &y) const
 	{
-		xaDebugAssert(x.dimension() == m_inverseDiagonal.dimension());
-		xaDebugAssert(y.dimension() == m_inverseDiagonal.dimension());
+		XA_DEBUG_ASSERT(x.dimension() == m_inverseDiagonal.dimension());
+		XA_DEBUG_ASSERT(y.dimension() == m_inverseDiagonal.dimension());
 		// @@ Wrap vector component-wise product into a separate function.
 		const uint32_t D = x.dimension();
 		for (uint32_t i = 0; i < D; i++) {
@@ -4391,9 +4303,9 @@ public:
 	// Solve the symmetric system: At·A·x = At·b
 	static bool LeastSquaresSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon = 1e-5f)
 	{
-		xaDebugAssert(A.width() == x.dimension());
-		xaDebugAssert(A.height() == b.dimension());
-		xaDebugAssert(A.height() >= A.width()); // @@ If height == width we could solve it directly...
+		XA_DEBUG_ASSERT(A.width() == x.dimension());
+		XA_DEBUG_ASSERT(A.height() == b.dimension());
+		XA_DEBUG_ASSERT(A.height() >= A.width()); // @@ If height == width we could solve it directly...
 		const uint32_t D = A.width();
 		sparse::Matrix At(A.height(), A.width());
 		sparse::transpose(A, At);
@@ -4407,12 +4319,12 @@ public:
 	// See section 10.4.3 in: Mesh Parameterization: Theory and Practice, Siggraph Course Notes, August 2007
 	static bool LeastSquaresSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, const uint32_t *lockedParameters, uint32_t lockedCount, float epsilon = 1e-5f)
 	{
-		xaDebugAssert(A.width() == x.dimension());
-		xaDebugAssert(A.height() == b.dimension());
-		xaDebugAssert(A.height() >= A.width() - lockedCount);
+		XA_DEBUG_ASSERT(A.width() == x.dimension());
+		XA_DEBUG_ASSERT(A.height() == b.dimension());
+		XA_DEBUG_ASSERT(A.height() >= A.width() - lockedCount);
 		// @@ This is not the most efficient way of building a system with reduced degrees of freedom. It would be faster to do it on the fly.
 		const uint32_t D = A.width() - lockedCount;
-		xaDebugAssert(D > 0);
+		XA_DEBUG_ASSERT(D > 0);
 		// Compute: b - Al * xl
 		FullVector b_Alxl(b);
 		for (uint32_t y = 0; y < A.height(); y++) {
@@ -4504,62 +4416,12 @@ private:
 	* Jonhathan Richard Shewchuk.
 	*
 	**/
-	static bool ConjugateGradientSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon)
-	{
-		xaDebugAssert( A.isSquare() );
-		xaDebugAssert( A.width() == b.dimension() );
-		xaDebugAssert( A.width() == x.dimension() );
-		int i = 0;
-		const int D = A.width();
-		const int i_max = 4 * D;   // Convergence should be linear, but in some cases, it's not.
-		FullVector r(D);   // residual
-		FullVector p(D);   // search direction
-		FullVector q(D);   //
-		float delta_0;
-		float delta_old;
-		float delta_new;
-		float alpha;
-		float beta;
-		// r = b - A·x;
-		sparse::copy(b, r);
-		sparse::sgemv(-1, A, x, 1, r);
-		// p = r;
-		sparse::copy(r, p);
-		delta_new = sparse::dot( r, r );
-		delta_0 = delta_new;
-		while (i < i_max && delta_new > epsilon * epsilon * delta_0) {
-			i++;
-			// q = A·p
-			mult(A, p, q);
-			// alpha = delta_new / p·q
-			alpha = delta_new / sparse::dot( p, q );
-			// x = alfa·p + x
-			sparse::saxpy(alpha, p, x);
-			if ((i & 31) == 0) { // recompute r after 32 steps
-				// r = b - A·x
-				sparse::copy(b, r);
-				sparse::sgemv(-1, A, x, 1, r);
-			} else {
-				// r = r - alpha·q
-				sparse::saxpy(-alpha, q, r);
-			}
-			delta_old = delta_new;
-			delta_new = sparse::dot( r, r );
-			beta = delta_new / delta_old;
-			// p = beta·p + r
-			sparse::scal(beta, p);
-			sparse::saxpy(1, r, p);
-		}
-		return delta_new <= epsilon * epsilon * delta_0;
-	}
-
-
 	// Conjugate gradient with preconditioner.
 	static bool ConjugateGradientSolver(const JacobiPreconditioner &preconditioner, const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon)
 	{
-		xaDebugAssert( A.isSquare() );
-		xaDebugAssert( A.width() == b.dimension() );
-		xaDebugAssert( A.width() == x.dimension() );
+		XA_DEBUG_ASSERT( A.isSquare() );
+		XA_DEBUG_ASSERT( A.width() == b.dimension() );
+		XA_DEBUG_ASSERT( A.width() == x.dimension() );
 		int i = 0;
 		const int D = A.width();
 		const int i_max = 4 * D;   // Convergence should be linear, but in some cases, it's not.
@@ -4582,7 +4444,7 @@ private:
 		while (i < i_max && delta_new > epsilon * epsilon * delta_0) {
 			i++;
 			// q = A·p
-			mult(A, p, q);
+			sparse::mult(A, p, q);
 			// alpha = delta_new / p·q
 			alpha = delta_new / sparse::dot(p, q);
 			// x = alfa·p + x
@@ -4609,59 +4471,59 @@ private:
 
 	static bool SymmetricSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon = 1e-5f)
 	{
-		xaDebugAssert(A.height() == A.width());
-		xaDebugAssert(A.height() == b.dimension());
-		xaDebugAssert(b.dimension() == x.dimension());
+		XA_DEBUG_ASSERT(A.height() == A.width());
+		XA_DEBUG_ASSERT(A.height() == b.dimension());
+		XA_DEBUG_ASSERT(b.dimension() == x.dimension());
 		JacobiPreconditioner jacobi(A, true);
 		return ConjugateGradientSolver(jacobi, A, b, x, epsilon);
 	}
 };
 
 namespace param {
-class Atlas;
-class Chart;
 
 // Fast sweep in 3 directions
-static bool findApproximateDiameterVertices(halfedge::Mesh *mesh, halfedge::Vertex **a, halfedge::Vertex **b)
+static bool findApproximateDiameterVertices(Mesh *mesh, uint32_t *a, uint32_t *b)
 {
-	xaDebugAssert(mesh != NULL);
-	xaDebugAssert(a != NULL);
-	xaDebugAssert(b != NULL);
+	XA_DEBUG_ASSERT(a != nullptr);
+	XA_DEBUG_ASSERT(b != nullptr);
 	const uint32_t vertexCount = mesh->vertexCount();
-	halfedge::Vertex *minVertex[3];
-	halfedge::Vertex *maxVertex[3];
-	minVertex[0] = minVertex[1] = minVertex[2] = NULL;
-	maxVertex[0] = maxVertex[1] = maxVertex[2] = NULL;
+	uint32_t minVertex[3];
+	uint32_t maxVertex[3];
+	minVertex[0] = minVertex[1] = minVertex[2] = UINT32_MAX;
+	maxVertex[0] = maxVertex[1] = maxVertex[2] = UINT32_MAX;
 	for (uint32_t v = 1; v < vertexCount; v++) {
-		halfedge::Vertex *vertex = mesh->vertexAt(v);
-		xaDebugAssert(vertex != NULL);
-		if (vertex->isBoundary()) {
-			minVertex[0] = minVertex[1] = minVertex[2] = vertex;
-			maxVertex[0] = maxVertex[1] = maxVertex[2] = vertex;
+		if (mesh->isBoundaryVertex(v)) {
+			minVertex[0] = minVertex[1] = minVertex[2] = v;
+			maxVertex[0] = maxVertex[1] = maxVertex[2] = v;
 			break;
 		}
 	}
-	if (minVertex[0] == NULL) {
+	if (minVertex[0] == UINT32_MAX) {
 		// Input mesh has not boundaries.
 		return false;
 	}
 	for (uint32_t v = 1; v < vertexCount; v++) {
-		halfedge::Vertex *vertex = mesh->vertexAt(v);
-		xaDebugAssert(vertex != NULL);
-		if (!vertex->isBoundary()) {
+		if (!mesh->isBoundaryVertex(v)) {
 			// Skip interior vertices.
 			continue;
 		}
-		if (vertex->pos.x < minVertex[0]->pos.x) minVertex[0] = vertex;
-		else if (vertex->pos.x > maxVertex[0]->pos.x) maxVertex[0] = vertex;
-		if (vertex->pos.y < minVertex[1]->pos.y) minVertex[1] = vertex;
-		else if (vertex->pos.y > maxVertex[1]->pos.y) maxVertex[1] = vertex;
-		if (vertex->pos.z < minVertex[2]->pos.z) minVertex[2] = vertex;
-		else if (vertex->pos.z > maxVertex[2]->pos.z) maxVertex[2] = vertex;
+		const Vector3 &pos = mesh->position(v);
+		if (pos.x < mesh->position(minVertex[0]).x)
+			minVertex[0] = v;
+		else if (pos.x > mesh->position(maxVertex[0]).x)
+			maxVertex[0] = v;
+		if (pos.y < mesh->position(minVertex[1]).y)
+			minVertex[1] = v;
+		else if (pos.y > mesh->position(maxVertex[1]).y)
+			maxVertex[1] = v;
+		if (pos.z < mesh->position(minVertex[2]).z)
+			minVertex[2] = v;
+		else if (pos.z > mesh->position(maxVertex[2]).z)
+			maxVertex[2] = v;
 	}
 	float lengths[3];
 	for (int i = 0; i < 3; i++) {
-		lengths[i] = length(minVertex[i]->pos - maxVertex[i]->pos);
+		lengths[i] = length(mesh->position(minVertex[i]) - mesh->position(maxVertex[i]));
 	}
 	if (lengths[0] > lengths[1] && lengths[0] > lengths[2]) {
 		*a = minVertex[0];
@@ -4678,34 +4540,28 @@ static bool findApproximateDiameterVertices(halfedge::Mesh *mesh, halfedge::Vert
 
 // Conformal relations from Brecht Van Lommel (based on ABF):
 
-static float vec_angle_cos(Vector3::Arg v1, Vector3::Arg v2, Vector3::Arg v3)
+static float vec_angle_cos(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
 {
 	Vector3 d1 = v1 - v2;
 	Vector3 d2 = v3 - v2;
 	return clamp(dot(d1, d2) / (length(d1) * length(d2)), -1.0f, 1.0f);
 }
 
-static float vec_angle(Vector3::Arg v1, Vector3::Arg v2, Vector3::Arg v3)
+static float vec_angle(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
 {
 	float dot = vec_angle_cos(v1, v2, v3);
 	return acosf(dot);
 }
 
-static void triangle_angles(Vector3::Arg v1, Vector3::Arg v2, Vector3::Arg v3, float *a1, float *a2, float *a3)
+static void triangle_angles(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, float *a1, float *a2, float *a3)
 {
 	*a1 = vec_angle(v3, v1, v2);
 	*a2 = vec_angle(v1, v2, v3);
-	*a3 = PI - *a2 - *a1;
+	*a3 = kPi - *a2 - *a1;
 }
 
-static void setup_abf_relations(sparse::Matrix &A, int row, const halfedge::Vertex *v0, const halfedge::Vertex *v1, const halfedge::Vertex *v2)
+static void setup_abf_relations(sparse::Matrix &A, int row, int id0, int id1, int id2, const Vector3 &p0, const Vector3 &p1, const Vector3 &p2)
 {
-	int id0 = v0->id;
-	int id1 = v1->id;
-	int id2 = v2->id;
-	Vector3 p0 = v0->pos;
-	Vector3 p1 = v1->pos;
-	Vector3 p2 = v2->pos;
 	// @@ IC: Wouldn't it be more accurate to return cos and compute 1-cos^2?
 	// It does indeed seem to be a little bit more robust.
 	// @@ Need to revisit this more carefully!
@@ -4715,19 +4571,19 @@ static void setup_abf_relations(sparse::Matrix &A, int row, const halfedge::Vert
 	float s1 = sinf(a1);
 	float s2 = sinf(a2);
 	if (s1 > s0 && s1 > s2) {
-		std::swap(s1, s2);
-		std::swap(s0, s1);
-		std::swap(a1, a2);
-		std::swap(a0, a1);
-		std::swap(id1, id2);
-		std::swap(id0, id1);
+		swap(s1, s2);
+		swap(s0, s1);
+		swap(a1, a2);
+		swap(a0, a1);
+		swap(id1, id2);
+		swap(id0, id1);
 	} else if (s0 > s1 && s0 > s2) {
-		std::swap(s0, s2);
-		std::swap(s0, s1);
-		std::swap(a0, a2);
-		std::swap(a0, a1);
-		std::swap(id0, id2);
-		std::swap(id0, id1);
+		swap(s0, s2);
+		swap(s0, s1);
+		swap(a0, a2);
+		swap(a0, a1);
+		swap(id0, id2);
+		swap(id0, id1);
 	}
 	float c0 = cosf(a0);
 	float ratio = (s2 == 0.0f) ? 1.0f : s1 / s2;
@@ -4755,14 +4611,13 @@ static void setup_abf_relations(sparse::Matrix &A, int row, const halfedge::Vert
 	A.setCoefficient(v2_id, 2 * row + 1, 1);
 }
 
-bool computeLeastSquaresConformalMap(halfedge::Mesh *mesh)
+static bool computeLeastSquaresConformalMap(Mesh *mesh)
 {
-	xaDebugAssert(mesh != NULL);
 	// For this to work properly, mesh should not have colocals that have the same
 	// attributes, unless you want the vertices to actually have different texcoords.
 	const uint32_t vertexCount = mesh->vertexCount();
 	const uint32_t D = 2 * vertexCount;
-	const uint32_t N = 2 * halfedge::countMeshTriangles(mesh);
+	const uint32_t N = 2 * mesh->faceCount();
 	// N is the number of equations (one per triangle)
 	// D is the number of variables (one per vertex; there are 2 pinned vertices).
 	if (N < D - 4) {
@@ -4774,118 +4629,64 @@ bool computeLeastSquaresConformalMap(halfedge::Mesh *mesh)
 	// Fill b:
 	b.fill(0.0f);
 	// Fill x:
-	halfedge::Vertex *v0;
-	halfedge::Vertex *v1;
+	uint32_t v0, v1;
 	if (!findApproximateDiameterVertices(mesh, &v0, &v1)) {
 		// Mesh has no boundaries.
 		return false;
 	}
-	if (v0->tex == v1->tex) {
+	if (mesh->texcoord(v0) == mesh->texcoord(v1)) {
 		// LSCM expects an existing parameterization.
 		return false;
 	}
 	for (uint32_t v = 0; v < vertexCount; v++) {
-		halfedge::Vertex *vertex = mesh->vertexAt(v);
-		xaDebugAssert(vertex != NULL);
 		// Initial solution.
-		x[2 * v + 0] = vertex->tex.x;
-		x[2 * v + 1] = vertex->tex.y;
+		x[2 * v + 0] = mesh->texcoord(v).x;
+		x[2 * v + 1] = mesh->texcoord(v).y;
 	}
 	// Fill A:
 	const uint32_t faceCount = mesh->faceCount();
 	for (uint32_t f = 0, t = 0; f < faceCount; f++) {
-		const halfedge::Face *face = mesh->faceAt(f);
-		xaDebugAssert(face != NULL);
-		xaDebugAssert(face->edgeCount() == 3);
-		const halfedge::Vertex *vertex0 = NULL;
-		for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-			const halfedge::Edge *edge = it.current();
-			xaAssert(edge != NULL);
-			if (vertex0 == NULL) {
-				vertex0 = edge->vertex;
-			} else if (edge->next->vertex != vertex0) {
-				const halfedge::Vertex *vertex1 = edge->from();
-				const halfedge::Vertex *vertex2 = edge->to();
-				setup_abf_relations(A, t, vertex0, vertex1, vertex2);
-				//setup_conformal_map_relations(A, t, vertex0, vertex1, vertex2);
-				t++;
-			}
-		}
+		const uint32_t vertex0 = mesh->vertexAt(f * 3 + 0);
+		const uint32_t vertex1 = mesh->vertexAt(f * 3 + 1);
+		const uint32_t vertex2 = mesh->vertexAt(f * 3 + 2);
+		setup_abf_relations(A, t, vertex0, vertex1, vertex2, mesh->position(vertex0), mesh->position(vertex1), mesh->position(vertex2));
+		t++;
 	}
 	const uint32_t lockedParameters[] = {
-		2 * v0->id + 0,
-		2 * v0->id + 1,
-		2 * v1->id + 0,
-		2 * v1->id + 1
+		2 * v0 + 0,
+		2 * v0 + 1,
+		2 * v1 + 0,
+		2 * v1 + 1
 	};
 	// Solve
 	Solver::LeastSquaresSolver(A, b, x, lockedParameters, 4, 0.000001f);
 	// Map x back to texcoords:
-	for (uint32_t v = 0; v < vertexCount; v++) {
-		halfedge::Vertex *vertex = mesh->vertexAt(v);
-		xaDebugAssert(vertex != NULL);
-		vertex->tex = Vector2(x[2 * v + 0], x[2 * v + 1]);
-	}
+	for (uint32_t v = 0; v < vertexCount; v++)
+		mesh->texcoord(v) = Vector2(x[2 * v + 0], x[2 * v + 1]);
 	return true;
 }
 
-bool computeOrthogonalProjectionMap(halfedge::Mesh *mesh)
+static bool computeOrthogonalProjectionMap(Mesh *mesh)
 {
-	Vector3 axis[2];
 	uint32_t vertexCount = mesh->vertexCount();
-	std::vector<Vector3> points(vertexCount);
-	points.resize(vertexCount);
-	for (uint32_t i = 0; i < vertexCount; i++) {
-		points[i] = mesh->vertexAt(i)->pos;
-	}
 	// Avoid redundant computations.
 	float matrix[6];
-	Fit::computeCovariance(vertexCount, points.data(), matrix);
-	if (matrix[0] == 0 && matrix[3] == 0 && matrix[5] == 0) {
+	Fit::computeCovariance(vertexCount, &mesh->position(0), matrix);
+	if (matrix[0] == 0 && matrix[3] == 0 && matrix[5] == 0)
 		return false;
-	}
 	float eigenValues[3];
 	Vector3 eigenVectors[3];
-	if (!Fit::eigenSolveSymmetric3(matrix, eigenValues, eigenVectors)) {
+	if (!Fit::eigenSolveSymmetric3(matrix, eigenValues, eigenVectors))
 		return false;
-	}
-	axis[0] = normalize(eigenVectors[0]);
-	axis[1] = normalize(eigenVectors[1]);
+	Vector3 axis[2];
+	axis[0] = normalize(eigenVectors[0], kEpsilon);
+	axis[1] = normalize(eigenVectors[1], kEpsilon);
 	// Project vertices to plane.
-	for (halfedge::Mesh::VertexIterator it(mesh->vertices()); !it.isDone(); it.advance()) {
-		halfedge::Vertex *vertex = it.current();
-		vertex->tex.x = dot(axis[0], vertex->pos);
-		vertex->tex.y = dot(axis[1], vertex->pos);
-	}
+	for (uint32_t i = 0; i < vertexCount; i++)
+		mesh->texcoord(i) = Vector2(dot(axis[0], mesh->position(i)), dot(axis[1], mesh->position(i)));
 	return true;
 }
 
-void computeSingleFaceMap(halfedge::Mesh *mesh)
-{
-	xaDebugAssert(mesh != NULL);
-	xaDebugAssert(mesh->faceCount() == 1);
-	halfedge::Face *face = mesh->faceAt(0);
-	xaAssert(face != NULL);
-	Vector3 p0 = face->edge->from()->pos;
-	Vector3 p1 = face->edge->to()->pos;
-	Vector3 X = normalizeSafe(p1 - p0, Vector3(0.0f), 0.0f);
-	Vector3 Z = face->normal();
-	Vector3 Y = normalizeSafe(cross(Z, X), Vector3(0.0f), 0.0f);
-	uint32_t i = 0;
-	for (halfedge::Face::EdgeIterator it(face->edges()); !it.isDone(); it.advance(), i++) {
-		halfedge::Vertex *vertex = it.vertex();
-		xaAssert(vertex != NULL);
-		if (i == 0) {
-			vertex->tex = Vector2(0);
-		} else {
-			Vector3 pn = vertex->pos;
-			float xn = dot((pn - p0), X);
-			float yn = dot((pn - p0), Y);
-			vertex->tex = Vector2(xn, yn);
-		}
-	}
-}
-
 // Dummy implementation of a priority queue using sort at insertion.
 // - Insertion is o(n)
 // - Smallest element goes at the end, so that popping it is o(1).
@@ -4894,7 +4695,7 @@ void computeSingleFaceMap(halfedge::Mesh *mesh)
 // @@ Searcing at removal would remove the need for sorting when priorities change.
 struct PriorityQueue
 {
-	PriorityQueue(uint32_t size = UINT_MAX) : maxSize(size) {}
+	PriorityQueue(uint32_t size = UINT32_MAX) : maxSize(size) {}
 
 	void push(float priority, uint32_t face)
 	{
@@ -4904,10 +4705,9 @@ struct PriorityQueue
 			if (pairs[i].priority > priority) break;
 		}
 		Pair p = { priority, face };
-		pairs.insert(pairs.begin() + i, p);
-		if (pairs.size() > maxSize) {
-			pairs.erase(pairs.begin());
-		}
+		pairs.insertAt(i, p);
+		if (pairs.size() > maxSize)
+			pairs.removeAt(0);
 	}
 
 	// push face out of order, to be sorted later.
@@ -4949,7 +4749,7 @@ struct PriorityQueue
 
 	struct Pair
 	{
-		bool operator <(const Pair &p) const
+		bool operator<(const Pair &p) const
 		{
 			return priority > p.priority;    // !! Sort in inverse priority order!
 		}
@@ -4958,164 +4758,411 @@ struct PriorityQueue
 		uint32_t face;
 	};
 
-	std::vector<Pair> pairs;
+	Array<Pair> pairs;
 };
 
 struct ChartBuildData
 {
-	ChartBuildData(int id) : id(id)
-	{
-		planeNormal = Vector3(0);
-		centroid = Vector3(0);
-		coneAxis = Vector3(0);
-		coneAngle = 0;
-		area = 0;
-		boundaryLength = 0;
-		normalSum = Vector3(0);
-		centroidSum = Vector3(0);
-	}
-
-	int id;
-
-	// Proxy info:
-	Vector3 planeNormal;
-	Vector3 centroid;
-	Vector3 coneAxis;
-	float coneAngle;
-
-	float area;
-	float boundaryLength;
-	Vector3 normalSum;
-	Vector3 centroidSum;
-
-	std::vector<uint32_t> seeds;  // @@ These could be a pointers to the halfedge faces directly.
-	std::vector<uint32_t> faces;
+	int id = -1;
+	Vector3 averageNormal = Vector3(0.0f);
+	float area = 0.0f;
+	float boundaryLength = 0.0f;
+	Vector3 normalSum = Vector3(0.0f);
+	Vector3 centroidSum = Vector3(0.0f); // Sum of chart face centroids.
+	Vector3 centroid = Vector3(0.0f); // Average centroid of chart faces.
+	Array<uint32_t> seeds;
+	Array<uint32_t> faces;
 	PriorityQueue candidates;
+	Basis basis; // Of first face.
 };
 
 struct AtlasBuilder
 {
-	AtlasBuilder(const halfedge::Mesh *m) : mesh(m), facesLeft(m->faceCount())
+	// @@ Hardcoded to 10?
+	AtlasBuilder(const Mesh *mesh, Array<uint32_t> *meshFaces, const ChartOptions &options) : m_mesh(mesh), m_meshFaces(meshFaces), m_facesLeft(mesh->faceCount()), m_bestTriangles(10), m_options(options)
 	{
-		const uint32_t faceCount = m->faceCount();
-		faceChartArray.resize(faceCount, -1);
-		faceCandidateArray.resize(faceCount, (uint32_t)-1);
+		XA_PROFILE_START(atlasBuilderInit)
+		const uint32_t faceCount = m_mesh->faceCount();
+		if (meshFaces) {
+			m_ignoreFaces.resize(faceCount, true);
+			for (uint32_t f = 0; f < meshFaces->size(); f++)
+				m_ignoreFaces[(*meshFaces)[f]] = false;
+			m_facesLeft = meshFaces->size();
+		} else {
+			m_ignoreFaces.resize(faceCount, false);
+		}
+		m_faceChartArray.resize(faceCount, -1);
+		m_faceCandidateArray.resize(faceCount, (uint32_t)-1);
+		m_texcoords.resize(faceCount * 3);
 		// @@ Floyd for the whole mesh is too slow. We could compute floyd progressively per patch as the patch grows. We need a better solution to compute most central faces.
 		//computeShortestPaths();
 		// Precompute edge lengths and face areas.
-		uint32_t edgeCount = m->edgeCount();
-		edgeLengths.resize(edgeCount);
-		for (uint32_t i = 0; i < edgeCount; i++) {
-			uint32_t id = m->edgeAt(i)->id;
-			xaDebugAssert(id / 2 == i);
-#ifdef NDEBUG
-			id = 0; // silence unused parameter warning
-#endif
-			edgeLengths[i] = m->edgeAt(i)->length();
-		}
-		faceAreas.resize(faceCount);
-		for (uint32_t i = 0; i < faceCount; i++) {
-			faceAreas[i] = m->faceAt(i)->area();
+		const uint32_t edgeCount = m_mesh->edgeCount();
+		m_edgeLengths.resize(edgeCount, 0.0f);
+		m_faceAreas.resize(m_mesh->faceCount(), 0.0f);
+		m_faceNormals.resize(m_mesh->faceCount());
+		for (uint32_t f = 0; f < faceCount; f++) {
+			if (m_ignoreFaces[f])
+				continue;
+			for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+				m_edgeLengths[it.edge()] = internal::length(it.position1() - it.position0());
+				XA_DEBUG_ASSERT(m_edgeLengths[it.edge()] > 0.0f);
+			}
+			m_faceAreas[f] = mesh->faceArea(f);
+			XA_DEBUG_ASSERT(m_faceAreas[f] > 0.0f);
+			m_faceNormals[f] = m_mesh->triangleNormal(f);
 		}
+		XA_PROFILE_END(atlasBuilderInit)
 	}
 
 	~AtlasBuilder()
 	{
-		const uint32_t chartCount = chartArray.size();
+		const uint32_t chartCount = m_chartArray.size();
 		for (uint32_t i = 0; i < chartCount; i++) {
-			delete chartArray[i];
+			m_chartArray[i]->~ChartBuildData();
+			XA_FREE(m_chartArray[i]);
 		}
 	}
 
-	void markUnchartedFaces(const std::vector<uint32_t> &unchartedFaces)
+	uint32_t facesLeft() const { return m_facesLeft; }
+	uint32_t chartCount() const { return m_chartArray.size(); }
+	const Array<uint32_t> &chartFaces(uint32_t i) const { return m_chartArray[i]->faces; }
+	const Basis &chartBasis(uint32_t chartIndex) const { return m_chartArray[chartIndex]->basis; }
+
+	void placeSeeds(float threshold)
 	{
-		const uint32_t unchartedFaceCount = unchartedFaces.size();
-		for (uint32_t i = 0; i < unchartedFaceCount; i++) {
-			uint32_t f = unchartedFaces[i];
-			faceChartArray[f] = -2;
-			//faceCandidateArray[f] = -2; // @@ ?
-			removeCandidate(f);
-		}
-		xaDebugAssert(facesLeft >= unchartedFaceCount);
-		facesLeft -= unchartedFaceCount;
+		// Instead of using a predefiened number of seeds:
+		// - Add seeds one by one, growing chart until a certain treshold.
+		// - Undo charts and restart growing process.
+		// @@ How can we give preference to faces far from sharp features as in the LSCM paper?
+		//   - those points can be found using a simple flood filling algorithm.
+		//   - how do we weight the probabilities?
+		while (m_facesLeft > 0)
+			createRandomChart(threshold);
 	}
 
-	void computeShortestPaths()
+	// Returns true if any of the charts can grow more.
+	bool growCharts(float threshold, uint32_t faceCount)
 	{
-		const uint32_t faceCount = mesh->faceCount();
-		shortestPaths.resize(faceCount * faceCount, FLT_MAX);
-		// Fill edges:
+		XA_PROFILE_START(atlasBuilderGrowCharts)
+		// Using one global list.
+		faceCount = min(faceCount, m_facesLeft);
+		bool canAddAny = false;
 		for (uint32_t i = 0; i < faceCount; i++) {
-			shortestPaths[i * faceCount + i] = 0.0f;
-			const halfedge::Face *face_i = mesh->faceAt(i);
-			Vector3 centroid_i = face_i->centroid();
-			for (halfedge::Face::ConstEdgeIterator it(face_i->edges()); !it.isDone(); it.advance()) {
-				const halfedge::Edge *edge = it.current();
-				if (!edge->isBoundary()) {
-					const halfedge::Face *face_j = edge->pair->face;
-					uint32_t j = face_j->id;
-					Vector3 centroid_j = face_j->centroid();
-					shortestPaths[i * faceCount + j] = shortestPaths[j * faceCount + i] = length(centroid_i - centroid_j);
-				}
+			const Candidate &candidate = getBestCandidate();
+			if (candidate.metric > threshold) {
+				XA_PROFILE_END(atlasBuilderGrowCharts)
+				return false; // Can't grow more.
 			}
+			createFaceTexcoords(candidate.chart, candidate.face);
+			if (!canAddFaceToChart(candidate.chart, candidate.face))
+				continue;
+			addFaceToChart(candidate.chart, candidate.face);
+			canAddAny = true;
 		}
-		// Use Floyd-Warshall algorithm to compute all paths:
-		for (uint32_t k = 0; k < faceCount; k++) {
-			for (uint32_t i = 0; i < faceCount; i++) {
-				for (uint32_t j = 0; j < faceCount; j++) {
-					shortestPaths[i * faceCount + j] = std::min(shortestPaths[i * faceCount + j], shortestPaths[i * faceCount + k] + shortestPaths[k * faceCount + j]);
-				}
+		XA_PROFILE_END(atlasBuilderGrowCharts)
+		return canAddAny && m_facesLeft != 0; // Can continue growing.
+	}
+
+	void resetCharts()
+	{
+		const uint32_t faceCount = m_mesh->faceCount();
+		for (uint32_t i = 0; i < faceCount; i++) {
+			m_faceChartArray[i] = -1;
+			m_faceCandidateArray[i] = (uint32_t)-1;
+		}
+		m_facesLeft = m_meshFaces ? m_meshFaces->size() : faceCount;
+		m_candidateArray.clear();
+		const uint32_t chartCount = m_chartArray.size();
+		for (uint32_t i = 0; i < chartCount; i++) {
+			ChartBuildData *chart = m_chartArray[i];
+			const uint32_t seed = chart->seeds.back();
+			chart->area = 0.0f;
+			chart->boundaryLength = 0.0f;
+			chart->normalSum = Vector3(0.0f);
+			chart->centroidSum = Vector3(0.0f);
+			chart->centroid = Vector3(0.0f);
+			chart->faces.clear();
+			chart->candidates.clear();
+			addFaceToChart(chart, seed);
+		}
+#if XA_GROW_CHARTS_COPLANAR
+		for (uint32_t i = 0; i < chartCount; i++) {
+			ChartBuildData *chart = m_chartArray[i];
+			growChartCoplanar(chart);
+		}
+#endif
+	}
+
+	void updateCandidates(ChartBuildData *chart, uint32_t f)
+	{
+		// Traverse neighboring faces, add the ones that do not belong to any chart yet.
+		for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+			if (!it.isBoundary() && !m_ignoreFaces[it.oppositeFace()] && m_faceChartArray[it.oppositeFace()] == -1)
+				chart->candidates.push(it.oppositeFace());
+		}
+	}
+
+	void updateProxies()
+	{
+		const uint32_t chartCount = m_chartArray.size();
+		for (uint32_t i = 0; i < chartCount; i++)
+			updateProxy(m_chartArray[i]);
+	}
+
+	bool relocateSeeds()
+	{
+		bool anySeedChanged = false;
+		const uint32_t chartCount = m_chartArray.size();
+		for (uint32_t i = 0; i < chartCount; i++) {
+			if (relocateSeed(m_chartArray[i])) {
+				anySeedChanged = true;
 			}
 		}
+		return anySeedChanged;
 	}
 
-	void placeSeeds(float threshold, uint32_t maxSeedCount)
+	void fillHoles(float threshold)
 	{
-		// Instead of using a predefiened number of seeds:
-		// - Add seeds one by one, growing chart until a certain treshold.
-		// - Undo charts and restart growing process.
-		// @@ How can we give preference to faces far from sharp features as in the LSCM paper?
-		//   - those points can be found using a simple flood filling algorithm.
-		//   - how do we weight the probabilities?
-		for (uint32_t i = 0; i < maxSeedCount; i++) {
-			if (facesLeft == 0) {
-				// No faces left, stop creating seeds.
+		while (m_facesLeft > 0)
+			createRandomChart(threshold);
+	}
+
+#if XA_MERGE_CHARTS
+	void mergeCharts()
+	{
+		XA_PROFILE_START(atlasBuilderMergeCharts)
+		Array<float> sharedBoundaryLengths;
+		Array<float> sharedBoundaryLengthsNoSeams;
+		Array<uint32_t> sharedBoundaryEdgeCountNoSeams;
+		Array<Vector2> tempTexcoords;
+		const uint32_t chartCount = m_chartArray.size();
+		// Merge charts progressively until there's none left to merge.
+		for (;;) {
+			bool merged = false;
+			for (int c = chartCount - 1; c >= 0; c--) {
+				ChartBuildData *chart = m_chartArray[c];
+				if (chart == nullptr)
+					continue;
+				float externalBoundaryLength = 0.0f;
+				sharedBoundaryLengths.clear();
+				sharedBoundaryLengths.resize(chartCount, 0.0f);
+				sharedBoundaryLengthsNoSeams.clear();
+				sharedBoundaryLengthsNoSeams.resize(chartCount, 0.0f);
+				sharedBoundaryEdgeCountNoSeams.clear();
+				sharedBoundaryEdgeCountNoSeams.resize(chartCount, 0u);
+				const uint32_t faceCount = chart->faces.size();
+				for (uint32_t i = 0; i < faceCount; i++) {
+					const uint32_t f = chart->faces[i];
+					for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+						const float l = m_edgeLengths[it.edge()];
+						if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()]) {
+							externalBoundaryLength += l;
+						} else {
+							const int neighborChart = m_faceChartArray[it.oppositeFace()];
+							if (m_chartArray[neighborChart] != chart) {
+								if ((it.isSeam() && (isNormalSeam(it.edge()) || it.isTextureSeam()))) {
+									externalBoundaryLength += l;
+								} else {
+									sharedBoundaryLengths[neighborChart] += l;
+								}
+								sharedBoundaryLengthsNoSeams[neighborChart] += l;
+								sharedBoundaryEdgeCountNoSeams[neighborChart]++;
+							}
+						}
+					}
+				}
+				for (int cc = chartCount - 1; cc >= 0; cc--) {
+					if (cc == c)
+						continue;
+					ChartBuildData *chart2 = m_chartArray[cc];
+					if (chart2 == nullptr)
+						continue;
+					// Compare proxies.
+					if (dot(chart2->averageNormal, chart->averageNormal) < XA_MERGE_CHARTS_MIN_NORMAL_DEVIATION)
+						continue;
+					// Obey max chart area and boundary length.
+					if (m_options.maxChartArea > 0.0f && chart->area + chart2->area > m_options.maxChartArea)
+						continue;
+					if (m_options.maxBoundaryLength > 0.0f && chart->boundaryLength + chart2->boundaryLength - sharedBoundaryLengthsNoSeams[cc] > m_options.maxBoundaryLength)
+						continue;
+					// Merge if chart2 has a single face.
+					// chart1 must have more than 1 face.
+					// chart2 area must be <= 10% of chart1 area.
+					if (sharedBoundaryLengthsNoSeams[cc] > 0.0f && chart->faces.size() > 1 && chart2->faces.size() == 1 && chart2->area <= chart->area * 0.1f) 
+						goto merge;
+					// Merge if chart2 has two faces (probably a quad), and chart1 bounds at least 2 of its edges.
+					if (chart2->faces.size() == 2 && sharedBoundaryEdgeCountNoSeams[cc] >= 2)
+						goto merge;
+					// Merge if chart2 is wholely inside chart1, ignoring seams.
+					if (sharedBoundaryLengthsNoSeams[cc] > 0.0f && equal(sharedBoundaryLengthsNoSeams[cc], chart2->boundaryLength, kEpsilon))
+						goto merge;
+					if (sharedBoundaryLengths[cc] > 0.2f * max(0.0f, chart->boundaryLength - externalBoundaryLength) || 
+						sharedBoundaryLengths[cc] > 0.75f * chart2->boundaryLength)
+						goto merge;
+					continue;
+				merge:
+					// Create texcoords for chart 2 using chart 1 basis. Backup chart 2 texcoords for restoration if charts cannot be merged.
+					tempTexcoords.resize(chart2->faces.size());
+					for (uint32_t i = 0; i < chart2->faces.size(); i++) {
+						const uint32_t face = chart2->faces[i];
+						tempTexcoords[i] = m_texcoords[face];
+						createFaceTexcoords(chart, face);
+					}
+					if (!canMergeCharts(chart, chart2)) {
+						// Restore chart 2 texcoords.
+						for (uint32_t i = 0; i < chart2->faces.size(); i++)
+							m_texcoords[chart2->faces[i]] = tempTexcoords[i];
+						continue;
+					}
+					mergeChart(chart, chart2, sharedBoundaryLengthsNoSeams[cc]);
+					merged = true;
+					break;
+				}
+				if (merged)
+					break;
+			}
+			if (!merged)
 				break;
+		}
+		// Remove deleted charts.
+		for (int c = 0; c < int32_t(m_chartArray.size()); /*do not increment if removed*/) {
+			if (m_chartArray[c] == nullptr) {
+				m_chartArray.removeAt(c);
+				// Update m_faceChartArray.
+				const uint32_t faceCount = m_faceChartArray.size();
+				for (uint32_t i = 0; i < faceCount; i++) {
+					XA_DEBUG_ASSERT(m_faceChartArray[i] != c);
+					XA_DEBUG_ASSERT(m_faceChartArray[i] <= int32_t(m_chartArray.size()));
+					if (m_faceChartArray[i] > c) {
+						m_faceChartArray[i]--;
+					}
+				}
+			} else {
+				m_chartArray[c]->id = c;
+				c++;
 			}
-			createRandomChart(threshold);
 		}
+		XA_PROFILE_END(atlasBuilderMergeCharts)
 	}
+#endif
 
+private:
 	void createRandomChart(float threshold)
 	{
-		ChartBuildData *chart = new ChartBuildData(chartArray.size());
-		chartArray.push_back(chart);
+		ChartBuildData *chart = XA_NEW(MemTag::Default, ChartBuildData);
+		chart->id = (int)m_chartArray.size();
+		m_chartArray.push_back(chart);
 		// Pick random face that is not used by any chart yet.
-		uint32_t randomFaceIdx = rand.getRange(facesLeft - 1);
-		uint32_t i = 0;
-		for (uint32_t f = 0; f != randomFaceIdx; f++, i++) {
-			while (faceChartArray[i] != -1) i++;
-		}
-		while (faceChartArray[i] != -1) i++;
-		chart->seeds.push_back(i);
-		addFaceToChart(chart, i, true);
+		uint32_t face = m_rand.getRange(m_mesh->faceCount() - 1);
+		while (m_ignoreFaces[face] || m_faceChartArray[face] != -1) {
+			if (++face >= m_mesh->faceCount())
+				face = 0;
+		}
+		chart->seeds.push_back(face);
+		addFaceToChart(chart, face, true);
+#if XA_GROW_CHARTS_COPLANAR
+		growChartCoplanar(chart);
+#endif
 		// Grow the chart as much as possible within the given threshold.
-		growChart(chart, threshold * 0.5f, facesLeft);
-		//growCharts(threshold - threshold * 0.75f / chartCount(), facesLeft);
+		growChart(chart, threshold, m_facesLeft);
+	}
+
+	void createFaceTexcoords(ChartBuildData *chart, uint32_t face)
+	{
+		for (uint32_t i = 0; i < 3; i++) {
+			const Vector3 &pos = m_mesh->position(m_mesh->vertexAt(face * 3 + i));
+			m_texcoords[face * 3 + i] = Vector2(dot(chart->basis.tangent, pos), dot(chart->basis.bitangent, pos));
+		}
+	}
+
+	bool isChartBoundaryEdge(ChartBuildData *chart, uint32_t edge) const
+	{
+		const uint32_t oppositeEdge = m_mesh->oppositeEdge(edge);
+		const uint32_t oppositeFace = meshEdgeFace(oppositeEdge);
+		return oppositeEdge == UINT32_MAX || m_ignoreFaces[oppositeFace] || m_faceChartArray[oppositeFace] != chart->id;
+	}
+
+	bool canAddFaceToChart(ChartBuildData *chart, uint32_t face)
+	{
+		// Find face edges that are on a mesh boundary or form a boundary with another chart.
+		uint32_t edgesToCompare[3];
+		for (uint32_t i = 0; i < 3; i++) {
+			const uint32_t edge = face * 3 + i;
+			const uint32_t oppositeEdge = m_mesh->oppositeEdge(edge);
+			const uint32_t oppositeFace = meshEdgeFace(oppositeEdge);
+			if (oppositeEdge == UINT32_MAX || m_ignoreFaces[oppositeFace] || m_faceChartArray[oppositeFace] != chart->id)
+				edgesToCompare[i] = edge;
+			else
+				edgesToCompare[i] = UINT32_MAX;
+		}
+		// All edges on boundary? This can happen if the face is surrounded by the chart.
+		if (edgesToCompare[0] == UINT32_MAX && edgesToCompare[1] == UINT32_MAX && edgesToCompare[2] == UINT32_MAX)
+			return true;
+		// Check if any valid face edge intersects the chart boundary.
+		for (uint32_t i = 0; i < chart->faces.size(); i++) {
+			const uint32_t chartFace = chart->faces[i];
+			for (uint32_t j = 0; j < 3; j++) {
+				const uint32_t chartEdge = chartFace * 3 + j;
+				if (!isChartBoundaryEdge(chart, chartEdge))
+					continue;
+				// Don't check chart boundary edges that border the face.
+				const uint32_t oppositeChartEdge = m_mesh->oppositeEdge(chartEdge);
+				if (meshEdgeFace(oppositeChartEdge) == face)
+					continue;
+				for (uint32_t k = 0; k < 3; k++) {
+					if (edgesToCompare[k] == UINT32_MAX)
+						continue;
+					const uint32_t e1 = chartEdge;
+					const uint32_t e2 = edgesToCompare[k];
+					if (linesIntersect(m_texcoords[meshEdgeIndex0(e1)], m_texcoords[meshEdgeIndex1(e1)], m_texcoords[meshEdgeIndex0(e2)], m_texcoords[meshEdgeIndex1(e2)], m_mesh->epsilon()))
+						return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	bool canMergeCharts(ChartBuildData *chart1, ChartBuildData *chart2)
+	{
+		for (uint32_t f1 = 0; f1 < chart1->faces.size(); f1++) {
+			const uint32_t face1 = chart1->faces[f1];
+			for (uint32_t i = 0; i < 3; i++) {
+				const uint32_t edge1 = face1 * 3 + i;
+				if (!isChartBoundaryEdge(chart1, edge1))
+					continue;
+				for (uint32_t f2 = 0; f2 < chart2->faces.size(); f2++) {
+					const uint32_t face2 = chart2->faces[f2];
+					for (uint32_t j = 0; j < 3; j++) {
+						const uint32_t edge2 = face2 * 3 + j;
+						if (!isChartBoundaryEdge(chart2, edge2))
+							continue;
+						if (linesIntersect(m_texcoords[meshEdgeIndex0(edge1)], m_texcoords[meshEdgeIndex1(edge1)], m_texcoords[meshEdgeIndex0(edge2)], m_texcoords[meshEdgeIndex1(edge2)], m_mesh->epsilon()))
+							return false;
+					}
+				}
+			}
+		}
+		return true;
 	}
 
 	void addFaceToChart(ChartBuildData *chart, uint32_t f, bool recomputeProxy = false)
 	{
+		// Use the first face normal as the chart basis.
+		if (chart->faces.isEmpty()) {
+			chart->basis.buildFrameForDirection(m_faceNormals[f]);
+			createFaceTexcoords(chart, f);
+		}
 		// Add face to chart.
 		chart->faces.push_back(f);
-		xaDebugAssert(faceChartArray[f] == -1);
-		faceChartArray[f] = chart->id;
-		facesLeft--;
+		XA_DEBUG_ASSERT(m_faceChartArray[f] == -1);
+		m_faceChartArray[f] = chart->id;
+		m_facesLeft--;
 		// Update area and boundary length.
 		chart->area = evaluateChartArea(chart, f);
 		chart->boundaryLength = evaluateBoundaryLength(chart, f);
 		chart->normalSum = evaluateChartNormalSum(chart, f);
-		chart->centroidSum = evaluateChartCentroidSum(chart, f);
+		chart->centroidSum += m_mesh->triangleCenter(f);
 		if (recomputeProxy) {
 			// Update proxy and candidate's priorities.
 			updateProxy(chart);
@@ -5126,142 +5173,93 @@ struct AtlasBuilder
 		updatePriorities(chart);
 	}
 
-	// Returns true if any of the charts can grow more.
-	bool growCharts(float threshold, uint32_t faceCount)
-	{
-		// Using one global list.
-		faceCount = std::min(faceCount, facesLeft);
-		for (uint32_t i = 0; i < faceCount; i++) {
-			const Candidate &candidate = getBestCandidate();
-			if (candidate.metric > threshold) {
-				return false; // Can't grow more.
-			}
-			addFaceToChart(candidate.chart, candidate.face);
-		}
-		return facesLeft != 0; // Can continue growing.
-	}
-
 	bool growChart(ChartBuildData *chart, float threshold, uint32_t faceCount)
 	{
 		// Try to add faceCount faces within threshold to chart.
 		for (uint32_t i = 0; i < faceCount; ) {
-			if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold) {
+			if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold)
 				return false;
-			}
-			uint32_t f = chart->candidates.pop();
-			if (faceChartArray[f] == -1) {
-				addFaceToChart(chart, f);
-				i++;
-			}
+			const uint32_t f = chart->candidates.pop();
+			if (m_faceChartArray[f] != -1)
+				continue;
+			createFaceTexcoords(chart, f);
+			if (!canAddFaceToChart(chart, f))
+				continue;
+			addFaceToChart(chart, f);
+			i++;
 		}
-		if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold) {
+		if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold)
 			return false;
-		}
 		return true;
 	}
 
-	void resetCharts()
+#if XA_GROW_CHARTS_COPLANAR
+	void growChartCoplanar(ChartBuildData *chart)
 	{
-		const uint32_t faceCount = mesh->faceCount();
-		for (uint32_t i = 0; i < faceCount; i++) {
-			faceChartArray[i] = -1;
-			faceCandidateArray[i] = (uint32_t)-1;
-		}
-		facesLeft = faceCount;
-		candidateArray.clear();
-		const uint32_t chartCount = chartArray.size();
-		for (uint32_t i = 0; i < chartCount; i++) {
-			ChartBuildData *chart = chartArray[i];
-			const uint32_t seed = chart->seeds.back();
-			chart->area = 0.0f;
-			chart->boundaryLength = 0.0f;
-			chart->normalSum = Vector3(0);
-			chart->centroidSum = Vector3(0);
-			chart->faces.clear();
-			chart->candidates.clear();
-			addFaceToChart(chart, seed);
-		}
-	}
-
-	void updateCandidates(ChartBuildData *chart, uint32_t f)
-	{
-		const halfedge::Face *face = mesh->faceAt(f);
-		// Traverse neighboring faces, add the ones that do not belong to any chart yet.
-		for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-			const halfedge::Edge *edge = it.current()->pair;
-			if (!edge->isBoundary()) {
-				uint32_t faceId = edge->face->id;
-				if (faceChartArray[faceId] == -1) {
-					chart->candidates.push(faceId);
+		XA_DEBUG_ASSERT(!chart->faces.isEmpty());
+		const Vector3 chartNormal = m_faceNormals[chart->faces[0]];
+		m_growFaces.clear();
+		for (uint32_t f = 0; f < chart->faces.size(); f++)
+			m_growFaces.push_back(chart->faces[f]);
+		for (;;) {
+			if (m_growFaces.isEmpty())
+				break;
+			const uint32_t face = m_growFaces.back();
+			m_growFaces.pop_back();
+			for (Mesh::FaceEdgeIterator it(m_mesh, face); !it.isDone(); it.advance()) {
+				if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()] || m_faceChartArray[it.oppositeFace()] != -1)
+					continue;
+				if (equal(dot(chartNormal, m_faceNormals[it.oppositeFace()]), 1.0f, kEpsilon)) {
+					createFaceTexcoords(chart, it.oppositeFace());
+					addFaceToChart(chart, it.oppositeFace());
+					m_growFaces.push_back(it.oppositeFace());
 				}
 			}
 		}
 	}
+#endif
 
-	void updateProxies()
-	{
-		const uint32_t chartCount = chartArray.size();
-		for (uint32_t i = 0; i < chartCount; i++) {
-			updateProxy(chartArray[i]);
-		}
-	}
-
-	void updateProxy(ChartBuildData *chart)
+	void updateProxy(ChartBuildData *chart) const
 	{
 		//#pragma message(NV_FILE_LINE "TODO: Use best fit plane instead of average normal.")
-		chart->planeNormal = normalizeSafe(chart->normalSum, Vector3(0), 0.0f);
+		chart->averageNormal = normalizeSafe(chart->normalSum, Vector3(0), 0.0f);
 		chart->centroid = chart->centroidSum / float(chart->faces.size());
 	}
 
-	bool relocateSeeds()
-	{
-		bool anySeedChanged = false;
-		const uint32_t chartCount = chartArray.size();
-		for (uint32_t i = 0; i < chartCount; i++) {
-			if (relocateSeed(chartArray[i])) {
-				anySeedChanged = true;
-			}
-		}
-		return anySeedChanged;
-	}
-
 	bool relocateSeed(ChartBuildData *chart)
 	{
-		Vector3 centroid = computeChartCentroid(chart);
-		const uint32_t N = 10;  // @@ Hardcoded to 10?
-		PriorityQueue bestTriangles(N);
 		// Find the first N triangles that fit the proxy best.
 		const uint32_t faceCount = chart->faces.size();
+		m_bestTriangles.clear();
 		for (uint32_t i = 0; i < faceCount; i++) {
 			float priority = evaluateProxyFitMetric(chart, chart->faces[i]);
-			bestTriangles.push(priority, chart->faces[i]);
+			m_bestTriangles.push(priority, chart->faces[i]);
 		}
-		// Of those, choose the most central triangle.
-		uint32_t mostCentral;
+		// Of those, choose the least central triangle.
+		uint32_t leastCentral = 0;
 		float maxDistance = -1;
-		const uint32_t bestCount = bestTriangles.count();
+		const uint32_t bestCount = m_bestTriangles.count();
 		for (uint32_t i = 0; i < bestCount; i++) {
-			const halfedge::Face *face = mesh->faceAt(bestTriangles.pairs[i].face);
-			Vector3 faceCentroid = face->triangleCenter();
-			float distance = length(centroid - faceCentroid);
+			Vector3 faceCentroid = m_mesh->triangleCenter(m_bestTriangles.pairs[i].face);
+			float distance = length(chart->centroid - faceCentroid);
 			if (distance > maxDistance) {
 				maxDistance = distance;
-				mostCentral = bestTriangles.pairs[i].face;
+				leastCentral = m_bestTriangles.pairs[i].face;
 			}
 		}
-		xaDebugAssert(maxDistance >= 0);
+		XA_DEBUG_ASSERT(maxDistance >= 0);
 		// In order to prevent k-means cyles we record all the previously chosen seeds.
-		uint32_t index = std::find(chart->seeds.begin(), chart->seeds.end(), mostCentral) - chart->seeds.begin();
-		if (index < chart->seeds.size()) {
-			// Move new seed to the end of the seed array.
-			uint32_t last = chart->seeds.size() - 1;
-			std::swap(chart->seeds[index], chart->seeds[last]);
-			return false;
-		} else {
-			// Append new seed.
-			chart->seeds.push_back(mostCentral);
-			return true;
+		for (uint32_t i = 0; i < chart->seeds.size(); i++) {
+			if (chart->seeds[i] == leastCentral) {
+				// Move new seed to the end of the seed array.
+				uint32_t last = chart->seeds.size() - 1;
+				swap(chart->seeds[i], chart->seeds[last]);
+				return false;
+			}
 		}
+		// Append new seed.
+		chart->seeds.push_back(leastCentral);
+		return true;
 	}
 
 	void updatePriorities(ChartBuildData *chart)
@@ -5269,299 +5267,197 @@ struct AtlasBuilder
 		// Re-evaluate candidate priorities.
 		uint32_t candidateCount = chart->candidates.count();
 		for (uint32_t i = 0; i < candidateCount; i++) {
-			chart->candidates.pairs[i].priority = evaluatePriority(chart, chart->candidates.pairs[i].face);
-			if (faceChartArray[chart->candidates.pairs[i].face] == -1) {
-				updateCandidate(chart, chart->candidates.pairs[i].face, chart->candidates.pairs[i].priority);
-			}
+			PriorityQueue::Pair &pair = chart->candidates.pairs[i];
+			pair.priority = evaluatePriority(chart, pair.face);
+			if (m_faceChartArray[pair.face] == -1)
+				updateCandidate(chart, pair.face, pair.priority);
 		}
 		// Sort candidates.
 		chart->candidates.sort();
 	}
 
 	// Evaluate combined metric.
-	float evaluatePriority(ChartBuildData *chart, uint32_t face)
+	float evaluatePriority(ChartBuildData *chart, uint32_t face) const
 	{
 		// Estimate boundary length and area:
-		float newBoundaryLength = evaluateBoundaryLength(chart, face);
-		float newChartArea = evaluateChartArea(chart, face);
-		float F = evaluateProxyFitMetric(chart, face);
-		float C = evaluateRoundnessMetric(chart, face, newBoundaryLength, newChartArea);
-		float P = evaluateStraightnessMetric(chart, face);
+		const float newChartArea = evaluateChartArea(chart, face);
+		const float newBoundaryLength = evaluateBoundaryLength(chart, face);
+		// Enforce limits strictly:
+		if (m_options.maxChartArea > 0.0f && newChartArea > m_options.maxChartArea)
+			return FLT_MAX;
+		if (m_options.maxBoundaryLength > 0.0f && newBoundaryLength > m_options.maxBoundaryLength)
+			return FLT_MAX;
+		if (dot(m_faceNormals[face], chart->averageNormal) < 0.5f)
+			return FLT_MAX;
 		// Penalize faces that cross seams, reward faces that close seams or reach boundaries.
-		float N = evaluateNormalSeamMetric(chart, face);
-		float T = evaluateTextureSeamMetric(chart, face);
+		// Make sure normal seams are fully respected:
+		const float N = evaluateNormalSeamMetric(chart, face);
+		if (m_options.normalSeamMetricWeight >= 1000.0f && N > 0.0f)
+			return FLT_MAX;
+		float cost = m_options.normalSeamMetricWeight * N;
+		if (m_options.proxyFitMetricWeight > 0.0f)
+			cost += m_options.proxyFitMetricWeight * evaluateProxyFitMetric(chart, face);
+		if (m_options.roundnessMetricWeight > 0.0f)
+			cost += m_options.roundnessMetricWeight * evaluateRoundnessMetric(chart, face, newBoundaryLength, newChartArea);
+		if (m_options.straightnessMetricWeight > 0.0f)
+			cost += m_options.straightnessMetricWeight * evaluateStraightnessMetric(chart, face);
+		if (m_options.textureSeamMetricWeight > 0.0f)
+			cost += m_options.textureSeamMetricWeight * evaluateTextureSeamMetric(chart, face);
 		//float R = evaluateCompletenessMetric(chart, face);
 		//float D = evaluateDihedralAngleMetric(chart, face);
 		// @@ Add a metric based on local dihedral angle.
 		// @@ Tweaking the normal and texture seam metrics.
 		// - Cause more impedance. Never cross 90 degree edges.
-		// -
-		float cost = float(
-						 options.proxyFitMetricWeight * F +
-						 options.roundnessMetricWeight * C +
-						 options.straightnessMetricWeight * P +
-						 options.normalSeamMetricWeight * N +
-						 options.textureSeamMetricWeight * T);
-		// Enforce limits strictly:
-		if (newChartArea > options.maxChartArea) cost = FLT_MAX;
-		if (newBoundaryLength > options.maxBoundaryLength) cost = FLT_MAX;
-		// Make sure normal seams are fully respected:
-		if (options.normalSeamMetricWeight >= 1000 && N != 0) cost = FLT_MAX;
-		xaAssert(std::isfinite(cost));
+		XA_DEBUG_ASSERT(isFinite(cost));
 		return cost;
 	}
 
 	// Returns a value in [0-1].
-	float evaluateProxyFitMetric(ChartBuildData *chart, uint32_t f)
+	float evaluateProxyFitMetric(ChartBuildData *chart, uint32_t f) const
 	{
-		const halfedge::Face *face = mesh->faceAt(f);
-		Vector3 faceNormal = face->triangleNormal();
+		const Vector3 faceNormal = m_faceNormals[f];
 		// Use plane fitting metric for now:
-		return 1 - dot(faceNormal, chart->planeNormal); // @@ normal deviations should be weighted by face area
+		return 1 - dot(faceNormal, chart->averageNormal); // @@ normal deviations should be weighted by face area
 	}
 
-	float evaluateRoundnessMetric(ChartBuildData *chart, uint32_t /*face*/, float newBoundaryLength, float newChartArea)
+	float evaluateRoundnessMetric(ChartBuildData *chart, uint32_t /*face*/, float newBoundaryLength, float newChartArea) const
 	{
 		float roundness = square(chart->boundaryLength) / chart->area;
 		float newRoundness = square(newBoundaryLength) / newChartArea;
 		if (newRoundness > roundness) {
-			return square(newBoundaryLength) / (newChartArea * 4 * PI);
+			return square(newBoundaryLength) / (newChartArea * 4.0f * kPi);
 		} else {
 			// Offer no impedance to faces that improve roundness.
 			return 0;
 		}
 	}
 
-	float evaluateStraightnessMetric(ChartBuildData *chart, uint32_t f)
+	float evaluateStraightnessMetric(ChartBuildData *chart, uint32_t f) const
 	{
 		float l_out = 0.0f;
 		float l_in = 0.0f;
-		const halfedge::Face *face = mesh->faceAt(f);
-		for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-			const halfedge::Edge *edge = it.current();
-			float l = edgeLengths[edge->id / 2];
-			if (edge->isBoundary()) {
+		for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+			float l = m_edgeLengths[it.edge()];
+			if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()]) {
 				l_out += l;
 			} else {
-				uint32_t neighborFaceId = edge->pair->face->id;
-				if (faceChartArray[neighborFaceId] != chart->id) {
+				if (m_faceChartArray[it.oppositeFace()] != chart->id) {
 					l_out += l;
 				} else {
 					l_in += l;
 				}
 			}
 		}
-		xaDebugAssert(l_in != 0.0f); // Candidate face must be adjacent to chart. @@ This is not true if the input mesh has zero-length edges.
+		XA_DEBUG_ASSERT(l_in != 0.0f); // Candidate face must be adjacent to chart. @@ This is not true if the input mesh has zero-length edges.
 		float ratio = (l_out - l_in) / (l_out + l_in);
-		return std::min(ratio, 0.0f); // Only use the straightness metric to close gaps.
+		return min(ratio, 0.0f); // Only use the straightness metric to close gaps.
 	}
 
-	float evaluateNormalSeamMetric(ChartBuildData *chart, uint32_t f)
+	bool isNormalSeam(uint32_t edge) const
+	{
+		const uint32_t oppositeEdge = m_mesh->oppositeEdge(edge);
+		if (oppositeEdge == UINT32_MAX)
+			return false; // boundary edge
+		if (m_mesh->flags() & MeshFlags::HasNormals) {
+			const uint32_t v0 = m_mesh->vertexAt(meshEdgeIndex0(edge));
+			const uint32_t v1 = m_mesh->vertexAt(meshEdgeIndex1(edge));
+			const uint32_t ov0 = m_mesh->vertexAt(meshEdgeIndex0(oppositeEdge));
+			const uint32_t ov1 = m_mesh->vertexAt(meshEdgeIndex1(oppositeEdge));
+			return m_mesh->normal(v0) != m_mesh->normal(ov1) || m_mesh->normal(v1) != m_mesh->normal(ov0);
+		}
+		return m_faceNormals[meshEdgeFace(edge)] != m_faceNormals[meshEdgeFace(oppositeEdge)];
+	}
+
+	float evaluateNormalSeamMetric(ChartBuildData *chart, uint32_t f) const
 	{
 		float seamFactor = 0.0f;
 		float totalLength = 0.0f;
-		const halfedge::Face *face = mesh->faceAt(f);
-		for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-			const halfedge::Edge *edge = it.current();
-			if (edge->isBoundary()) {
+		for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+			if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()])
 				continue;
-			}
-			const uint32_t neighborFaceId = edge->pair->face->id;
-			if (faceChartArray[neighborFaceId] != chart->id) {
+			if (m_faceChartArray[it.oppositeFace()] != chart->id)
 				continue;
-			}
-			//float l = edge->length();
-			float l = edgeLengths[edge->id / 2];
+			float l = m_edgeLengths[it.edge()];
 			totalLength += l;
-			if (!edge->isSeam()) {
+			if (!it.isSeam())
 				continue;
-			}
 			// Make sure it's a normal seam.
-			if (edge->isNormalSeam()) {
-				float d0 = clamp(dot(edge->vertex->nor, edge->pair->next->vertex->nor), 0.0f, 1.0f);
-				float d1 = clamp(dot(edge->next->vertex->nor, edge->pair->vertex->nor), 0.0f, 1.0f);
-				l *= 1 - (d0 + d1) * 0.5f;
+			if (isNormalSeam(it.edge())) {
+				float d;
+				if (m_mesh->flags() & MeshFlags::HasNormals) {
+					const Vector3 &n0 = m_mesh->normal(it.vertex0());
+					const Vector3 &n1 = m_mesh->normal(it.vertex1());
+					const Vector3 &on0 = m_mesh->normal(m_mesh->vertexAt(meshEdgeIndex0(it.oppositeEdge())));
+					const Vector3 &on1 = m_mesh->normal(m_mesh->vertexAt(meshEdgeIndex1(it.oppositeEdge())));
+					const float d0 = clamp(dot(n0, on1), 0.0f, 1.0f);
+					const float d1 = clamp(dot(n1, on0), 0.0f, 1.0f);
+					d = (d0 + d1) * 0.5f;
+				} else {
+					d = clamp(dot(m_faceNormals[f], m_faceNormals[meshEdgeFace(it.oppositeEdge())]), 0.0f, 1.0f);
+				}
+				l *= 1 - d;
 				seamFactor += l;
 			}
 		}
-		if (seamFactor == 0) return 0.0f;
+		if (seamFactor <= 0.0f)
+			return 0.0f;
 		return seamFactor / totalLength;
 	}
 
-	float evaluateTextureSeamMetric(ChartBuildData *chart, uint32_t f)
+	float evaluateTextureSeamMetric(ChartBuildData *chart, uint32_t f) const
 	{
 		float seamLength = 0.0f;
 		float totalLength = 0.0f;
-		const halfedge::Face *face = mesh->faceAt(f);
-		for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-			const halfedge::Edge *edge = it.current();
-			if (edge->isBoundary()) {
+		for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+			if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()])
 				continue;
-			}
-			const uint32_t neighborFaceId = edge->pair->face->id;
-			if (faceChartArray[neighborFaceId] != chart->id) {
+			if (m_faceChartArray[it.oppositeFace()] != chart->id)
 				continue;
-			}
-			//float l = edge->length();
-			float l = edgeLengths[edge->id / 2];
+			float l = m_edgeLengths[it.edge()];
 			totalLength += l;
-			if (!edge->isSeam()) {
+			if (!it.isSeam())
 				continue;
-			}
 			// Make sure it's a texture seam.
-			if (edge->isTextureSeam()) {
+			if (it.isTextureSeam())
 				seamLength += l;
-			}
 		}
-		if (seamLength == 0.0f) {
+		if (seamLength == 0.0f)
 			return 0.0f; // Avoid division by zero.
-		}
 		return seamLength / totalLength;
 	}
 
-	float evaluateChartArea(ChartBuildData *chart, uint32_t f)
+	float evaluateChartArea(ChartBuildData *chart, uint32_t f) const
 	{
-		const halfedge::Face *face = mesh->faceAt(f);
-		return chart->area + faceAreas[face->id];
+		return chart->area + m_faceAreas[f];
 	}
 
-	float evaluateBoundaryLength(ChartBuildData *chart, uint32_t f)
+	float evaluateBoundaryLength(ChartBuildData *chart, uint32_t f) const
 	{
 		float boundaryLength = chart->boundaryLength;
 		// Add new edges, subtract edges shared with the chart.
-		const halfedge::Face *face = mesh->faceAt(f);
-		for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-			const halfedge::Edge *edge = it.current();
-			//float edgeLength = edge->length();
-			float edgeLength = edgeLengths[edge->id / 2];
-			if (edge->isBoundary()) {
+		for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+			const float edgeLength = m_edgeLengths[it.edge()];
+			if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()]) {
 				boundaryLength += edgeLength;
 			} else {
-				uint32_t neighborFaceId = edge->pair->face->id;
-				if (faceChartArray[neighborFaceId] != chart->id) {
+				if (m_faceChartArray[it.oppositeFace()] != chart->id)
 					boundaryLength += edgeLength;
-				} else {
+				else
 					boundaryLength -= edgeLength;
-				}
 			}
 		}
-		return std::max(0.0f, boundaryLength);  // @@ Hack!
-	}
-
-	Vector3 evaluateChartNormalSum(ChartBuildData *chart, uint32_t f)
-	{
-		const halfedge::Face *face = mesh->faceAt(f);
-		return chart->normalSum + face->triangleNormalAreaScaled();
+		return max(0.0f, boundaryLength);  // @@ Hack!
 	}
 
-	Vector3 evaluateChartCentroidSum(ChartBuildData *chart, uint32_t f)
+	Vector3 evaluateChartNormalSum(ChartBuildData *chart, uint32_t f) const
 	{
-		const halfedge::Face *face = mesh->faceAt(f);
-		return chart->centroidSum + face->centroid();
-	}
-
-	Vector3 computeChartCentroid(const ChartBuildData *chart)
-	{
-		Vector3 centroid(0);
-		const uint32_t faceCount = chart->faces.size();
-		for (uint32_t i = 0; i < faceCount; i++) {
-			const halfedge::Face *face = mesh->faceAt(chart->faces[i]);
-			centroid += face->triangleCenter();
-		}
-		return centroid / float(faceCount);
-	}
-
-	void fillHoles(float threshold)
-	{
-		while (facesLeft > 0)
-			createRandomChart(threshold);
-	}
-
-	void mergeCharts()
-	{
-		std::vector<float> sharedBoundaryLengths;
-		const uint32_t chartCount = chartArray.size();
-		for (int c = chartCount - 1; c >= 0; c--) {
-			sharedBoundaryLengths.clear();
-			sharedBoundaryLengths.resize(chartCount, 0.0f);
-			ChartBuildData *chart = chartArray[c];
-			float externalBoundary = 0.0f;
-			const uint32_t faceCount = chart->faces.size();
-			for (uint32_t i = 0; i < faceCount; i++) {
-				uint32_t f = chart->faces[i];
-				const halfedge::Face *face = mesh->faceAt(f);
-				for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-					const halfedge::Edge *edge = it.current();
-					//float l = edge->length();
-					float l = edgeLengths[edge->id / 2];
-					if (edge->isBoundary()) {
-						externalBoundary += l;
-					} else {
-						uint32_t neighborFace = edge->pair->face->id;
-						uint32_t neighborChart = faceChartArray[neighborFace];
-						if (neighborChart != (uint32_t)c) {
-							if ((edge->isSeam() && (edge->isNormalSeam() || edge->isTextureSeam())) || neighborChart == -2) {
-								externalBoundary += l;
-							} else {
-								sharedBoundaryLengths[neighborChart] += l;
-							}
-						}
-					}
-				}
-			}
-			for (int cc = chartCount - 1; cc >= 0; cc--) {
-				if (cc == c)
-					continue;
-				ChartBuildData *chart2 = chartArray[cc];
-				if (chart2 == NULL)
-					continue;
-				if (sharedBoundaryLengths[cc] > 0.8 * std::max(0.0f, chart->boundaryLength - externalBoundary)) {
-					// Try to avoid degenerate configurations.
-					if (chart2->boundaryLength > sharedBoundaryLengths[cc]) {
-						if (dot(chart2->planeNormal, chart->planeNormal) > -0.25) {
-							mergeChart(chart2, chart, sharedBoundaryLengths[cc]);
-							delete chart;
-							chartArray[c] = NULL;
-							break;
-						}
-					}
-				}
-				if (sharedBoundaryLengths[cc] > 0.20 * std::max(0.0f, chart->boundaryLength - externalBoundary)) {
-					// Compare proxies.
-					if (dot(chart2->planeNormal, chart->planeNormal) > 0) {
-						mergeChart(chart2, chart, sharedBoundaryLengths[cc]);
-						delete chart;
-						chartArray[c] = NULL;
-						break;
-					}
-				}
-			}
-		}
-		// Remove deleted charts.
-		for (int c = 0; c < int32_t(chartArray.size()); /*do not increment if removed*/) {
-			if (chartArray[c] == NULL) {
-				chartArray.erase(chartArray.begin() + c);
-				// Update faceChartArray.
-				const uint32_t faceCount = faceChartArray.size();
-				for (uint32_t i = 0; i < faceCount; i++) {
-					xaDebugAssert (faceChartArray[i] != -1);
-					xaDebugAssert (faceChartArray[i] != c);
-					xaDebugAssert (faceChartArray[i] <= int32_t(chartArray.size()));
-					if (faceChartArray[i] > c) {
-						faceChartArray[i]--;
-					}
-				}
-			} else {
-				chartArray[c]->id = c;
-				c++;
-			}
-		}
+		return chart->normalSum + m_mesh->triangleNormalAreaScaled(f);
 	}
 
 	// @@ Cleanup.
 	struct Candidate {
-		uint32_t face;
 		ChartBuildData *chart;
+		uint32_t face;
 		float metric;
 	};
 
@@ -5570,48 +5466,48 @@ struct AtlasBuilder
 	{
 		uint32_t best = 0;
 		float bestCandidateMetric = FLT_MAX;
-		const uint32_t candidateCount = candidateArray.size();
-		xaAssert(candidateCount > 0);
+		const uint32_t candidateCount = m_candidateArray.size();
+		XA_ASSERT(candidateCount > 0);
 		for (uint32_t i = 0; i < candidateCount; i++) {
-			const Candidate &candidate = candidateArray[i];
+			const Candidate &candidate = m_candidateArray[i];
 			if (candidate.metric < bestCandidateMetric) {
 				bestCandidateMetric = candidate.metric;
 				best = i;
 			}
 		}
-		return candidateArray[best];
+		return m_candidateArray[best];
 	}
 
 	void removeCandidate(uint32_t f)
 	{
-		int c = faceCandidateArray[f];
+		int c = m_faceCandidateArray[f];
 		if (c != -1) {
-			faceCandidateArray[f] = (uint32_t)-1;
-			if (c == int(candidateArray.size() - 1)) {
-				candidateArray.pop_back();
+			m_faceCandidateArray[f] = (uint32_t)-1;
+			if (c == int(m_candidateArray.size() - 1)) {
+				m_candidateArray.pop_back();
 			} else {
 				// Replace with last.
-				candidateArray[c] = candidateArray[candidateArray.size() - 1];
-				candidateArray.pop_back();
-				faceCandidateArray[candidateArray[c].face] = c;
+				m_candidateArray[c] = m_candidateArray[m_candidateArray.size() - 1];
+				m_candidateArray.pop_back();
+				m_faceCandidateArray[m_candidateArray[c].face] = c;
 			}
 		}
 	}
 
 	void updateCandidate(ChartBuildData *chart, uint32_t f, float metric)
 	{
-		if (faceCandidateArray[f] == -1) {
-			const uint32_t index = candidateArray.size();
-			faceCandidateArray[f] = index;
-			candidateArray.resize(index + 1);
-			candidateArray[index].face = f;
-			candidateArray[index].chart = chart;
-			candidateArray[index].metric = metric;
+		if (m_faceCandidateArray[f] == (uint32_t)-1) {
+			const uint32_t index = m_candidateArray.size();
+			m_faceCandidateArray[f] = index;
+			m_candidateArray.resize(index + 1);
+			m_candidateArray[index].face = f;
+			m_candidateArray[index].chart = chart;
+			m_candidateArray[index].metric = metric;
 		} else {
-			int c = faceCandidateArray[f];
-			xaDebugAssert(c != -1);
-			Candidate &candidate = candidateArray[c];
-			xaDebugAssert(candidate.face == f);
+			const uint32_t c = m_faceCandidateArray[f];
+			XA_DEBUG_ASSERT(c != (uint32_t)-1);
+			Candidate &candidate = m_candidateArray[c];
+			XA_DEBUG_ASSERT(candidate.face == f);
 			if (metric < candidate.metric || chart == candidate.chart) {
 				candidate.metric = metric;
 				candidate.chart = chart;
@@ -5624,803 +5520,533 @@ struct AtlasBuilder
 		const uint32_t faceCount = chart->faces.size();
 		for (uint32_t i = 0; i < faceCount; i++) {
 			uint32_t f = chart->faces[i];
-			xaDebugAssert(faceChartArray[f] == chart->id);
-			faceChartArray[f] = owner->id;
+			XA_DEBUG_ASSERT(m_faceChartArray[f] == chart->id);
+			m_faceChartArray[f] = owner->id;
 			owner->faces.push_back(f);
 		}
 		// Update adjacencies?
 		owner->area += chart->area;
 		owner->boundaryLength += chart->boundaryLength - sharedBoundaryLength;
 		owner->normalSum += chart->normalSum;
-		owner->centroidSum += chart->centroidSum;
 		updateProxy(owner);
-	}
+		// Delete chart.
+		m_chartArray[chart->id] = nullptr;
+		chart->~ChartBuildData();
+		XA_FREE(chart);
+	}
+
+	const Mesh *m_mesh;
+	const Array<uint32_t> *m_meshFaces;
+	Array<bool> m_ignoreFaces;
+	Array<float> m_edgeLengths;
+	Array<float> m_faceAreas;
+	Array<Vector3> m_faceNormals;
+	Array<Vector2> m_texcoords;
+	Array<uint32_t> m_growFaces;
+	uint32_t m_facesLeft;
+	Array<int> m_faceChartArray;
+	Array<ChartBuildData *> m_chartArray;
+	Array<Candidate> m_candidateArray;
+	Array<uint32_t> m_faceCandidateArray; // Map face index to candidate index.
+	PriorityQueue m_bestTriangles;
+	KISSRng m_rand;
+	ChartOptions m_options;
+};
 
+// Estimate quality of existing parameterization.
+struct ParameterizationQuality
+{
+	uint32_t totalTriangleCount = 0;
+	uint32_t flippedTriangleCount = 0;
+	uint32_t zeroAreaTriangleCount = 0;
+	float parametricArea = 0.0f;
+	float geometricArea = 0.0f;
+	float stretchMetric = 0.0f;
+	float maxStretchMetric = 0.0f;
+	float conformalMetric = 0.0f;
+	float authalicMetric = 0.0f;
+	bool boundaryIntersection = false;
+};
 
-	uint32_t chartCount() const { return chartArray.size(); }
-	const std::vector<uint32_t> &chartFaces(uint32_t i) const { return chartArray[i]->faces; }
+static ParameterizationQuality calculateParameterizationQuality(const Mesh *mesh, Array<uint32_t> *flippedFaces)
+{
+	XA_DEBUG_ASSERT(mesh != nullptr);
+	ParameterizationQuality quality;
+	const uint32_t faceCount = mesh->faceCount();
+	uint32_t firstBoundaryEdge = UINT32_MAX;
+	for (uint32_t e = 0; e < mesh->edgeCount(); e++) {
+		if (mesh->isBoundaryEdge(e)) {
+			firstBoundaryEdge = e;
+		}
+	}
+	XA_DEBUG_ASSERT(firstBoundaryEdge != UINT32_MAX);
+	for (Mesh::BoundaryEdgeIterator it1(mesh, firstBoundaryEdge); !it1.isDone(); it1.advance()) {
+		const uint32_t edge1 = it1.edge();
+		for (Mesh::BoundaryEdgeIterator it2(mesh, firstBoundaryEdge); !it2.isDone(); it2.advance()) {
+			const uint32_t edge2 = it2.edge();
+			// Skip self and edges directly connected to edge1.
+			if (edge1 == edge2 || it1.nextEdge() == edge2 || it2.nextEdge() == edge1)
+				continue;
+			const Vector2 &a1 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex0(edge1)));
+			const Vector2 &a2 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex1(edge1)));
+			const Vector2 &b1 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex0(edge2)));
+			const Vector2 &b2 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex1(edge2)));
+			if (linesIntersect(a1, a2, b1, b2, mesh->epsilon())) {
+				quality.boundaryIntersection = true;
+				break;
+			}
+		}
+		if (quality.boundaryIntersection)
+			break;
+	}
+	if (flippedFaces)
+		flippedFaces->clear();
+	for (uint32_t f = 0; f < faceCount; f++) {
+		Vector3 pos[3];
+		Vector2 texcoord[3];
+		for (int i = 0; i < 3; i++) {
+			const uint32_t v = mesh->vertexAt(f * 3 + i);
+			pos[i] = mesh->position(v);
+			texcoord[i] = mesh->texcoord(v);
+		}
+		quality.totalTriangleCount++;
+		// Evaluate texture stretch metric. See:
+		// - "Texture Mapping Progressive Meshes", Sander, Snyder, Gortler & Hoppe
+		// - "Mesh Parameterization: Theory and Practice", Siggraph'07 Course Notes, Hormann, Levy & Sheffer.
+		const float t1 = texcoord[0].x;
+		const float s1 = texcoord[0].y;
+		const float t2 = texcoord[1].x;
+		const float s2 = texcoord[1].y;
+		const float t3 = texcoord[2].x;
+		const float s3 = texcoord[2].y;
+		float parametricArea = ((s2 - s1) * (t3 - t1) - (s3 - s1) * (t2 - t1)) / 2;
+		if (isZero(parametricArea, kAreaEpsilon)) {
+			quality.zeroAreaTriangleCount++;
+			continue;
+		}
+		if (parametricArea < 0.0f) {
+			// Count flipped triangles.
+			quality.flippedTriangleCount++;
+			if (flippedFaces)
+				flippedFaces->push_back(f);
+			parametricArea = fabsf(parametricArea);
+		}
+		const float geometricArea = length(cross(pos[1] - pos[0], pos[2] - pos[0])) / 2;
+		const Vector3 Ss = (pos[0] * (t2 - t3) + pos[1] * (t3 - t1) + pos[2] * (t1 - t2)) / (2 * parametricArea);
+		const Vector3 St = (pos[0] * (s3 - s2) + pos[1] * (s1 - s3) + pos[2] * (s2 - s1)) / (2 * parametricArea);
+		const float a = dot(Ss, Ss); // E
+		const float b = dot(Ss, St); // F
+		const float c = dot(St, St); // G
+		// Compute eigen-values of the first fundamental form:
+		const float sigma1 = sqrtf(0.5f * max(0.0f, a + c - sqrtf(square(a - c) + 4 * square(b)))); // gamma uppercase, min eigenvalue.
+		const float sigma2 = sqrtf(0.5f * max(0.0f, a + c + sqrtf(square(a - c) + 4 * square(b)))); // gamma lowercase, max eigenvalue.
+		XA_ASSERT(sigma2 > sigma1 || equal(sigma1, sigma2, kEpsilon));
+		// isometric: sigma1 = sigma2 = 1
+		// conformal: sigma1 / sigma2 = 1
+		// authalic: sigma1 * sigma2 = 1
+		const float rmsStretch = sqrtf((a + c) * 0.5f);
+		const float rmsStretch2 = sqrtf((square(sigma1) + square(sigma2)) * 0.5f);
+		XA_DEBUG_ASSERT(equal(rmsStretch, rmsStretch2, 0.01f));
+		XA_UNUSED(rmsStretch2);
+		quality.stretchMetric += square(rmsStretch) * geometricArea;
+		quality.maxStretchMetric = max(quality.maxStretchMetric, sigma2);
+		if (!isZero(sigma1, 0.000001f)) {
+			// sigma1 is zero when geometricArea is zero.
+			quality.conformalMetric += (sigma2 / sigma1) * geometricArea;
+		}
+		quality.authalicMetric += (sigma1 * sigma2) * geometricArea;
+		// Accumulate total areas.
+		quality.geometricArea += geometricArea;
+		quality.parametricArea += parametricArea;
+		//triangleConformalEnergy(q, p);
+	}
+	if (quality.flippedTriangleCount + quality.zeroAreaTriangleCount == quality.totalTriangleCount) {
+		// If all triangles are flipped, then none are.
+		if (flippedFaces)
+			flippedFaces->clear();
+		quality.flippedTriangleCount = 0;
+	}
+	if (quality.flippedTriangleCount > quality.totalTriangleCount / 2)
+	{
+		// If more than half the triangles are flipped, reverse the flipped / not flipped classification.
+		quality.flippedTriangleCount = quality.totalTriangleCount - quality.flippedTriangleCount;
+		if (flippedFaces) {
+			Array<uint32_t> temp(*flippedFaces);
+			flippedFaces->clear();
+			for (uint32_t f = 0; f < faceCount; f++) {
+				bool match = false;
+				for (uint32_t ff = 0; ff < temp.size(); ff++) {
+					if (temp[ff] == f) {
+						match = true;
+						break;
+					}
+				}
+				if (!match)
+					flippedFaces->push_back(f);
+			}
+		}
+	}
+	XA_DEBUG_ASSERT(isFinite(quality.parametricArea) && quality.parametricArea >= 0);
+	XA_DEBUG_ASSERT(isFinite(quality.geometricArea) && quality.geometricArea >= 0);
+	XA_DEBUG_ASSERT(isFinite(quality.stretchMetric));
+	XA_DEBUG_ASSERT(isFinite(quality.maxStretchMetric));
+	XA_DEBUG_ASSERT(isFinite(quality.conformalMetric));
+	XA_DEBUG_ASSERT(isFinite(quality.authalicMetric));
+	if (quality.geometricArea <= 0.0f) {
+		quality.stretchMetric = 0.0f;
+		quality.maxStretchMetric = 0.0f;
+		quality.conformalMetric = 0.0f;
+		quality.authalicMetric = 0.0f;
+	} else {
+		const float normFactor = sqrtf(quality.parametricArea / quality.geometricArea);
+		quality.stretchMetric = sqrtf(quality.stretchMetric / quality.geometricArea) * normFactor;
+		quality.maxStretchMetric  *= normFactor;
+		quality.conformalMetric = sqrtf(quality.conformalMetric / quality.geometricArea);
+		quality.authalicMetric = sqrtf(quality.authalicMetric / quality.geometricArea);
+	}
+	return quality;
+}
 
-	const halfedge::Mesh *mesh;
-	uint32_t facesLeft;
-	std::vector<int> faceChartArray;
-	std::vector<ChartBuildData *> chartArray;
-	std::vector<float> shortestPaths;
-	std::vector<float> edgeLengths;
-	std::vector<float> faceAreas;
-	std::vector<Candidate> candidateArray; //
-	std::vector<uint32_t> faceCandidateArray; // Map face index to candidate index.
-	MTRand rand;
-	CharterOptions options;
+struct ChartWarningFlags
+{
+	enum Enum
+	{
+		CloseHolesFailed = 1<<1,
+		FixTJunctionsDuplicatedEdge = 1<<2,
+		FixTJunctionsFailed = 1<<3,
+		TriangulateDuplicatedEdge = 1<<4,
+	};
 };
 
 /// A chart is a connected set of faces with a certain topology (usually a disk).
 class Chart
 {
 public:
-	Chart() : m_isDisk(false), m_isVertexMapped(false) {}
-
-	void build(const halfedge::Mesh *originalMesh, const std::vector<uint32_t> &faceArray)
+	Chart(const Mesh *originalMesh, const Array<uint32_t> &faceArray, const Basis &basis, uint32_t meshId, uint32_t chartGroupId, uint32_t chartId) : m_basis(basis), m_mesh(nullptr), m_unifiedMesh(nullptr), m_isDisk(false), m_isOrtho(false), m_isPlanar(false), m_warningFlags(0), m_closedHolesCount(0), m_fixedTJunctionsCount(0), m_faceArray(faceArray)
 	{
+		XA_UNUSED(meshId);
+		XA_UNUSED(chartGroupId);
+		XA_UNUSED(chartId);
 		// Copy face indices.
-		m_faceArray = faceArray;
-		const uint32_t meshVertexCount = originalMesh->vertexCount();
-		m_chartMesh.reset(new halfedge::Mesh());
-		m_unifiedMesh.reset(new halfedge::Mesh());
-		std::vector<uint32_t> chartMeshIndices(meshVertexCount, (uint32_t)~0);
-		std::vector<uint32_t> unifiedMeshIndices(meshVertexCount, (uint32_t)~0);
+		m_mesh = XA_NEW(MemTag::Mesh, Mesh, originalMesh->epsilon(), faceArray.size() * 3, faceArray.size());
+		m_unifiedMesh = XA_NEW(MemTag::Mesh, Mesh, originalMesh->epsilon(), faceArray.size() * 3, faceArray.size());
+		Array<uint32_t> chartMeshIndices;
+		chartMeshIndices.resize(originalMesh->vertexCount(), (uint32_t)~0);
+		Array<uint32_t> unifiedMeshIndices;
+		unifiedMeshIndices.resize(originalMesh->vertexCount(), (uint32_t)~0);
 		// Add vertices.
 		const uint32_t faceCount = faceArray.size();
 		for (uint32_t f = 0; f < faceCount; f++) {
-			const halfedge::Face *face = originalMesh->faceAt(faceArray[f]);
-			xaDebugAssert(face != NULL);
-			for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const halfedge::Vertex *vertex = it.current()->vertex;
-				const halfedge::Vertex *unifiedVertex = vertex->firstColocal();
-				if (unifiedMeshIndices[unifiedVertex->id] == ~0) {
-					unifiedMeshIndices[unifiedVertex->id] = m_unifiedMesh->vertexCount();
-					xaDebugAssert(vertex->pos == unifiedVertex->pos);
-					m_unifiedMesh->addVertex(vertex->pos);
+			for (uint32_t i = 0; i < 3; i++) {
+				const uint32_t vertex = originalMesh->vertexAt(faceArray[f] * 3 + i);
+				const uint32_t unifiedVertex = originalMesh->firstColocal(vertex);
+				if (unifiedMeshIndices[unifiedVertex] == (uint32_t)~0) {
+					unifiedMeshIndices[unifiedVertex] = m_unifiedMesh->vertexCount();
+					XA_DEBUG_ASSERT(equal(originalMesh->position(vertex), originalMesh->position(unifiedVertex), originalMesh->epsilon()));
+					m_unifiedMesh->addVertex(originalMesh->position(vertex));
 				}
-				if (chartMeshIndices[vertex->id] == ~0) {
-					chartMeshIndices[vertex->id] = m_chartMesh->vertexCount();
-					// -- GODOT start --
-					//m_chartToOriginalMap.push_back(vertex->id);
-					m_chartToOriginalMap.push_back(vertex->original_id);
-					// -- GODOT end --
-					m_chartToUnifiedMap.push_back(unifiedMeshIndices[unifiedVertex->id]);
-					halfedge::Vertex *v = m_chartMesh->addVertex(vertex->pos);
-					v->nor = vertex->nor;
-					v->tex = vertex->tex;
+				if (chartMeshIndices[vertex] == (uint32_t)~0) {
+					chartMeshIndices[vertex] = m_mesh->vertexCount();
+					m_chartToOriginalMap.push_back(vertex);
+					m_chartToUnifiedMap.push_back(unifiedMeshIndices[unifiedVertex]);
+					m_mesh->addVertex(originalMesh->position(vertex), Vector3(0.0f), originalMesh->texcoord(vertex));
 				}
 			}
 		}
-		// This is ignoring the canonical map:
-		// - Is it really necessary to link colocals?
-		m_chartMesh->linkColocals();
-		//m_unifiedMesh->linkColocals();  // Not strictly necessary, no colocals in the unified mesh. # Wrong.
-		// This check is not valid anymore, if the original mesh vertices were linked with a canonical map, then it might have
-		// some colocal vertices that were unlinked. So, the unified mesh might have some duplicate vertices, because firstColocal()
-		// is not guaranteed to return the same vertex for two colocal vertices.
-		//xaAssert(m_chartMesh->colocalVertexCount() == m_unifiedMesh->vertexCount());
-		// Is that OK? What happens in meshes were that happens? Does anything break? Apparently not...
-		std::vector<uint32_t> faceIndices;
-		faceIndices.reserve(7);
 		// Add faces.
 		for (uint32_t f = 0; f < faceCount; f++) {
-			const halfedge::Face *face = originalMesh->faceAt(faceArray[f]);
-			xaDebugAssert(face != NULL);
-			faceIndices.clear();
-			for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const halfedge::Vertex *vertex = it.current()->vertex;
-				xaDebugAssert(vertex != NULL);
-				faceIndices.push_back(chartMeshIndices[vertex->id]);
-			}
-			m_chartMesh->addFace(faceIndices);
-			faceIndices.clear();
-			for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const halfedge::Vertex *vertex = it.current()->vertex;
-				xaDebugAssert(vertex != NULL);
-				vertex = vertex->firstColocal();
-				faceIndices.push_back(unifiedMeshIndices[vertex->id]);
-			}
-			m_unifiedMesh->addFace(faceIndices);
-		}
-		m_chartMesh->linkBoundary();
-		m_unifiedMesh->linkBoundary();
-		//exportMesh(m_unifiedMesh.ptr(), "debug_input.obj");
-		if (m_unifiedMesh->splitBoundaryEdges()) {
-			m_unifiedMesh.reset(halfedge::unifyVertices(m_unifiedMesh.get()));
-		}
-		//exportMesh(m_unifiedMesh.ptr(), "debug_split.obj");
-		// Closing the holes is not always the best solution and does not fix all the problems.
-		// We need to do some analysis of the holes and the genus to:
-		// - Find cuts that reduce genus.
-		// - Find cuts to connect holes.
-		// - Use minimal spanning trees or seamster.
-		if (!closeHoles()) {
-			/*static int pieceCount = 0;
-			StringBuilder fileName;
-			fileName.format("debug_hole_%d.obj", pieceCount++);
-			exportMesh(m_unifiedMesh.ptr(), fileName.str());*/
-		}
-		m_unifiedMesh.reset(halfedge::triangulate(m_unifiedMesh.get()));
-		//exportMesh(m_unifiedMesh.ptr(), "debug_triangulated.obj");
-		// Analyze chart topology.
-		halfedge::MeshTopology topology(m_unifiedMesh.get());
-		m_isDisk = topology.isDisk();
-	}
-
-	void buildVertexMap(const halfedge::Mesh *originalMesh, const std::vector<uint32_t> &unchartedMaterialArray)
-	{
-		xaAssert(m_chartMesh.get() == NULL && m_unifiedMesh.get() == NULL);
-		m_isVertexMapped = true;
-		// Build face indices.
-		m_faceArray.clear();
-		const uint32_t meshFaceCount = originalMesh->faceCount();
-		for (uint32_t f = 0; f < meshFaceCount; f++) {
-			const halfedge::Face *face = originalMesh->faceAt(f);
-			if (std::find(unchartedMaterialArray.begin(), unchartedMaterialArray.end(), face->material) != unchartedMaterialArray.end()) {
-				m_faceArray.push_back(f);
-			}
-		}
-		const uint32_t faceCount = m_faceArray.size();
-		if (faceCount == 0) {
-			return;
-		}
-		// @@ The chartMesh construction is basically the same as with regular charts, don't duplicate!
-		const uint32_t meshVertexCount = originalMesh->vertexCount();
-		m_chartMesh.reset(new halfedge::Mesh());
-		std::vector<uint32_t> chartMeshIndices(meshVertexCount, (uint32_t)~0);
-		// Vertex map mesh only has disconnected vertices.
-		for (uint32_t f = 0; f < faceCount; f++) {
-			const halfedge::Face *face = originalMesh->faceAt(m_faceArray[f]);
-			xaDebugAssert(face != NULL);
-			for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const halfedge::Vertex *vertex = it.current()->vertex;
-				if (chartMeshIndices[vertex->id] == ~0) {
-					chartMeshIndices[vertex->id] = m_chartMesh->vertexCount();
-					// -- GODOT start --
-					//m_chartToOriginalMap.push_back(vertex->id);
-					m_chartToOriginalMap.push_back(vertex->original_id);
-					// -- GODOT end --
-					halfedge::Vertex *v = m_chartMesh->addVertex(vertex->pos);
-					v->nor = vertex->nor;
-					v->tex = vertex->tex; // @@ Not necessary.
-				}
+			uint32_t indices[3], unifiedIndices[3];
+			for (uint32_t i = 0; i < 3; i++) {
+				const uint32_t vertex = originalMesh->vertexAt(faceArray[f] * 3 + i);
+				indices[i] = chartMeshIndices[vertex];
+				unifiedIndices[i] = unifiedMeshIndices[originalMesh->firstColocal(vertex)];
+			}
+			Mesh::AddFaceResult::Enum result = m_mesh->addFace(indices);
+			XA_UNUSED(result);
+			XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK);
+#if XA_DEBUG
+			// Unifying colocals may create degenerate edges. e.g. if two triangle vertices are colocal.
+			for (int i = 0; i < 3; i++) {
+				const uint32_t index1 = unifiedIndices[i];
+				const uint32_t index2 = unifiedIndices[(i + 1) % 3];
+				XA_DEBUG_ASSERT(index1 != index2);
 			}
-		}
-		// @@ Link colocals using the original mesh canonical map? Build canonical map on the fly? Do we need to link colocals at all for this?
-		//m_chartMesh->linkColocals();
-		std::vector<uint32_t> faceIndices;
-		faceIndices.reserve(7);
-		// Add faces.
-		for (uint32_t f = 0; f < faceCount; f++) {
-			const halfedge::Face *face = originalMesh->faceAt(m_faceArray[f]);
-			xaDebugAssert(face != NULL);
-			faceIndices.clear();
-			for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const halfedge::Vertex *vertex = it.current()->vertex;
-				xaDebugAssert(vertex != NULL);
-				xaDebugAssert(chartMeshIndices[vertex->id] != ~0);
-				faceIndices.push_back(chartMeshIndices[vertex->id]);
-			}
-			halfedge::Face *new_face = m_chartMesh->addFace(faceIndices);
-			xaDebugAssert(new_face != NULL);
-#ifdef NDEBUG
-			new_face = NULL; // silence unused parameter warning
 #endif
-		}
-		m_chartMesh->linkBoundary();
-		const uint32_t chartVertexCount = m_chartMesh->vertexCount();
-		Box bounds;
-		bounds.clearBounds();
-		for (uint32_t i = 0; i < chartVertexCount; i++) {
-			halfedge::Vertex *vertex = m_chartMesh->vertexAt(i);
-			bounds.addPointToBounds(vertex->pos);
-		}
-		ProximityGrid grid;
-		grid.init(bounds, chartVertexCount);
-		for (uint32_t i = 0; i < chartVertexCount; i++) {
-			halfedge::Vertex *vertex = m_chartMesh->vertexAt(i);
-			grid.add(vertex->pos, i);
-		}
-		uint32_t texelCount = 0;
-		const float positionThreshold = 0.01f;
-		const float normalThreshold = 0.01f;
-		uint32_t verticesVisited = 0;
-		uint32_t cellsVisited = 0;
-		std::vector<int> vertexIndexArray(chartVertexCount, -1); // Init all indices to -1.
-		// Traverse vertices in morton order. @@ It may be more interesting to sort them based on orientation.
-		const uint32_t cellCodeCount = grid.mortonCount();
-		for (uint32_t cellCode = 0; cellCode < cellCodeCount; cellCode++) {
-			int cell = grid.mortonIndex(cellCode);
-			if (cell < 0) continue;
-			cellsVisited++;
-			const std::vector<uint32_t> &indexArray = grid.cellArray[cell].indexArray;
-			for (uint32_t i = 0; i < indexArray.size(); i++) {
-				uint32_t idx = indexArray[i];
-				halfedge::Vertex *vertex = m_chartMesh->vertexAt(idx);
-				xaDebugAssert(vertexIndexArray[idx] == -1);
-				std::vector<uint32_t> neighbors;
-				grid.gather(vertex->pos, positionThreshold, /*ref*/neighbors);
-				// Compare against all nearby vertices, cluster greedily.
-				for (uint32_t j = 0; j < neighbors.size(); j++) {
-					uint32_t otherIdx = neighbors[j];
-					if (vertexIndexArray[otherIdx] != -1) {
-						halfedge::Vertex *otherVertex = m_chartMesh->vertexAt(otherIdx);
-						if (distance(vertex->pos, otherVertex->pos) < positionThreshold &&
-								distance(vertex->nor, otherVertex->nor) < normalThreshold) {
-							vertexIndexArray[idx] = vertexIndexArray[otherIdx];
-							break;
+			result = m_unifiedMesh->addFace(unifiedIndices);
+			XA_UNUSED(result);
+			XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK);
+		}
+		m_mesh->createBoundaries(); // For AtlasPacker::computeBoundingBox
+		m_unifiedMesh->createBoundaries();
+		m_unifiedMesh->linkBoundaries();
+		m_isPlanar = meshIsPlanar(*m_unifiedMesh);
+		if (m_isPlanar) {
+			m_isDisk = true;
+		} else {
+#if XA_DEBUG_EXPORT_OBJ_BEFORE_FIX_TJUNCTION
+			m_unifiedMesh->writeObjFile("debug_before_fix_tjunction.obj");
+#endif
+			bool duplicatedEdge = false, failed = false;
+			XA_PROFILE_START(fixChartMeshTJunctions)
+			Mesh *fixedUnifiedMesh = meshFixTJunctions(*m_unifiedMesh, &duplicatedEdge, &failed, &m_fixedTJunctionsCount);
+			XA_PROFILE_END(fixChartMeshTJunctions)
+			if (fixedUnifiedMesh) {
+				if (duplicatedEdge)
+					m_warningFlags |= ChartWarningFlags::FixTJunctionsDuplicatedEdge;
+				if (failed)
+					m_warningFlags |= ChartWarningFlags::FixTJunctionsFailed;
+				m_unifiedMesh->~Mesh();
+				XA_FREE(m_unifiedMesh);
+				m_unifiedMesh = fixedUnifiedMesh;
+				m_unifiedMesh->createBoundaries();
+				m_unifiedMesh->linkBoundaries();
+			}
+			// See if there are any holes that need closing.
+			Array<uint32_t> boundaryLoops;
+			meshGetBoundaryLoops(*m_unifiedMesh, boundaryLoops);
+			if (boundaryLoops.size() > 1) {
+#if XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR
+				const uint32_t faceCountBeforeHolesClosed = m_unifiedMesh->faceCount();
+#endif
+				// Closing the holes is not always the best solution and does not fix all the problems.
+				// We need to do some analysis of the holes and the genus to:
+				// - Find cuts that reduce genus.
+				// - Find cuts to connect holes.
+				// - Use minimal spanning trees or seamster.
+				Array<uint32_t> holeFaceCounts;
+				XA_PROFILE_START(closeChartMeshHoles)
+				failed = !meshCloseHoles(m_unifiedMesh, boundaryLoops, basis.normal, holeFaceCounts);
+				XA_PROFILE_END(closeChartMeshHoles)
+				m_unifiedMesh->createBoundaries();
+				m_unifiedMesh->linkBoundaries();
+				meshGetBoundaryLoops(*m_unifiedMesh, boundaryLoops);
+				if (failed || boundaryLoops.size() > 1)
+					m_warningFlags |= ChartWarningFlags::CloseHolesFailed;
+				m_closedHolesCount = holeFaceCounts.size();
+#if XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR
+				if (m_warningFlags & ChartWarningFlags::CloseHolesFailed) {
+					char filename[256];
+					XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_chart_%03u_close_holes_error.obj", meshId, chartGroupId, chartId);
+					FILE *file;
+					XA_FOPEN(file, filename, "w");
+					if (file) {
+						m_unifiedMesh->writeObjVertices(file);
+						fprintf(file, "s off\n");
+						fprintf(file, "o object\n");
+						for (uint32_t i = 0; i < faceCountBeforeHolesClosed; i++)
+							m_unifiedMesh->writeObjFace(file, i);
+						uint32_t face = faceCountBeforeHolesClosed;
+						for (uint32_t i = 0; i < holeFaceCounts.size(); i++) {
+							fprintf(file, "s off\n");
+							fprintf(file, "o hole%u\n", i);
+							for (uint32_t j = 0; j < holeFaceCounts[i]; j++) {
+								m_unifiedMesh->writeObjFace(file, face);
+								face++;
+							}
 						}
+						m_unifiedMesh->writeObjBoundaryEges(file);
+						m_unifiedMesh->writeObjLinkedBoundaries(file);
+						fclose(file);
 					}
 				}
-				// If index not assigned, assign new one.
-				if (vertexIndexArray[idx] == -1) {
-					vertexIndexArray[idx] = texelCount++;
-				}
-				verticesVisited++;
-			}
-		}
-		xaDebugAssert(cellsVisited == grid.cellArray.size());
-		xaDebugAssert(verticesVisited == chartVertexCount);
-		vertexMapWidth = ftoi_ceil(sqrtf(float(texelCount)));
-		vertexMapWidth = (vertexMapWidth + 3) & ~3;                             // Width aligned to 4.
-		vertexMapHeight = vertexMapWidth == 0 ? 0 : (texelCount + vertexMapWidth - 1) / vertexMapWidth;
-		//vertexMapHeight = (vertexMapHeight + 3) & ~3;                           // Height aligned to 4.
-		xaDebugAssert(vertexMapWidth >= vertexMapHeight);
-		xaPrint("Reduced vertex count from %d to %d.\n", chartVertexCount, texelCount);
-		// Lay down the clustered vertices in morton order.
-		std::vector<uint32_t> texelCodes(texelCount);
-		// For each texel, assign one morton code.
-		uint32_t texelCode = 0;
-		for (uint32_t i = 0; i < texelCount; i++) {
-			uint32_t x, y;
-			do {
-				x = morton::decodeMorton2X(texelCode);
-				y = morton::decodeMorton2Y(texelCode);
-				texelCode++;
-			} while (x >= uint32_t(vertexMapWidth) || y >= uint32_t(vertexMapHeight));
-			texelCodes[i] = texelCode - 1;
-		}
-		for (uint32_t i = 0; i < chartVertexCount; i++) {
-			halfedge::Vertex *vertex = m_chartMesh->vertexAt(i);
-			int idx = vertexIndexArray[i];
-			if (idx != -1) {
-				uint32_t tc = texelCodes[idx];
-				uint32_t x = morton::decodeMorton2X(tc);
-				uint32_t y = morton::decodeMorton2Y(tc);
-				vertex->tex.x = float(x);
-				vertex->tex.y = float(y);
-			}
-		}
-	}
-
-	bool closeHoles()
-	{
-		xaDebugAssert(!m_isVertexMapped);
-		std::vector<halfedge::Edge *> boundaryEdges;
-		getBoundaryEdges(m_unifiedMesh.get(), boundaryEdges);
-		uint32_t boundaryCount = boundaryEdges.size();
-		if (boundaryCount <= 1) {
-			// Nothing to close.
-			return true;
-		}
-		// Compute lengths and areas.
-		std::vector<float> boundaryLengths;
-		for (uint32_t i = 0; i < boundaryCount; i++) {
-			const halfedge::Edge *startEdge = boundaryEdges[i];
-			xaAssert(startEdge->face == NULL);
-			//float boundaryEdgeCount = 0;
-			float boundaryLength = 0.0f;
-			//Vector3 boundaryCentroid(zero);
-			const halfedge::Edge *edge = startEdge;
-			do {
-				Vector3 t0 = edge->from()->pos;
-				Vector3 t1 = edge->to()->pos;
-				//boundaryEdgeCount++;
-				boundaryLength += length(t1 - t0);
-				//boundaryCentroid += edge->vertex()->pos;
-				edge = edge->next;
-			} while (edge != startEdge);
-			boundaryLengths.push_back(boundaryLength);
-			//boundaryCentroids.append(boundaryCentroid / boundaryEdgeCount);
-		}
-		// Find disk boundary.
-		uint32_t diskBoundary = 0;
-		float maxLength = boundaryLengths[0];
-		for (uint32_t i = 1; i < boundaryCount; i++) {
-			if (boundaryLengths[i] > maxLength) {
-				maxLength = boundaryLengths[i];
-				diskBoundary = i;
-			}
-		}
-		// Close holes.
-		for (uint32_t i = 0; i < boundaryCount; i++) {
-			if (diskBoundary == i) {
-				// Skip disk boundary.
-				continue;
+#endif
 			}
-			halfedge::Edge *startEdge = boundaryEdges[i];
-			xaDebugAssert(startEdge != NULL);
-			xaDebugAssert(startEdge->face == NULL);
-			std::vector<halfedge::Vertex *> vertexLoop;
-			std::vector<halfedge::Edge *> edgeLoop;
-			halfedge::Edge *edge = startEdge;
-			do {
-				halfedge::Vertex *vertex = edge->next->vertex;  // edge->to()
-				uint32_t j;
-				for (j = 0; j < vertexLoop.size(); j++) {
-					if (vertex->isColocal(vertexLoop[j])) {
-						break;
-					}
-				}
-				bool isCrossing = (j != vertexLoop.size());
-				if (isCrossing) {
-					halfedge::Edge *prev = edgeLoop[j];     // Previous edge before the loop.
-					halfedge::Edge *next = edge->next;    // Next edge after the loop.
-					xaDebugAssert(prev->to()->isColocal(next->from()));
-					// Close loop.
-					edgeLoop.push_back(edge);
-					closeLoop(j + 1, edgeLoop);
-					// Link boundary loop.
-					prev->setNext(next);
-					vertex->setEdge(next);
-					// Start over again.
-					vertexLoop.clear();
-					edgeLoop.clear();
-					edge = startEdge;
-					vertex = edge->to();
-				}
-				vertexLoop.push_back(vertex);
-				edgeLoop.push_back(edge);
-				edge = edge->next;
-			} while (edge != startEdge);
-			closeLoop(0, edgeLoop);
+			// Note: MeshTopology needs linked boundaries.
+			MeshTopology topology(m_unifiedMesh);
+			m_isDisk = topology.isDisk();
+#if XA_DEBUG_EXPORT_OBJ_NOT_DISK
+			if (!m_isDisk) {
+				char filename[256];
+				XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_chart_%03u_not_disk.obj", meshId, chartGroupId, chartId);
+				m_unifiedMesh->writeObjFile(filename);
+			}
+#endif
 		}
-		getBoundaryEdges(m_unifiedMesh.get(), boundaryEdges);
-		boundaryCount = boundaryEdges.size();
-		xaDebugAssert(boundaryCount == 1);
-		return boundaryCount == 1;
-	}
-
-	bool isDisk() const
-	{
-		return m_isDisk;
-	}
-	bool isVertexMapped() const
-	{
-		return m_isVertexMapped;
 	}
 
-	uint32_t vertexCount() const
+	~Chart()
 	{
-		return m_chartMesh->vertexCount();
-	}
-	uint32_t colocalVertexCount() const
-	{
-		return m_unifiedMesh->vertexCount();
-	}
-
-	uint32_t faceCount() const
-	{
-		return m_faceArray.size();
-	}
-	uint32_t faceAt(uint32_t i) const
-	{
-		return m_faceArray[i];
-	}
-
-	const halfedge::Mesh *chartMesh() const
-	{
-		return m_chartMesh.get();
-	}
-	halfedge::Mesh *chartMesh()
-	{
-		return m_chartMesh.get();
-	}
-	const halfedge::Mesh *unifiedMesh() const
-	{
-		return m_unifiedMesh.get();
-	}
-	halfedge::Mesh *unifiedMesh()
-	{
-		return m_unifiedMesh.get();
+		if (m_mesh) {
+			m_mesh->~Mesh();
+			XA_FREE(m_mesh);
+		}
+		if (m_unifiedMesh) {
+			m_unifiedMesh->~Mesh();
+			XA_FREE(m_unifiedMesh);
+		}
 	}
 
-	//uint32_t vertexIndex(uint32_t i) const { return m_vertexIndexArray[i]; }
+	const Basis &basis() const { return m_basis; }
+	bool isDisk() const { return m_isDisk; }
+	bool isOrtho() const { return m_isOrtho; }
+	bool isPlanar() const { return m_isPlanar; }
+	uint32_t warningFlags() const { return m_warningFlags; }
+	uint32_t closedHolesCount() const { return m_closedHolesCount; }
+	uint32_t fixedTJunctionsCount() const { return m_fixedTJunctionsCount; }
+	const ParameterizationQuality &paramQuality() const { return m_paramQuality; }
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+	const Array<uint32_t> &paramFlippedFaces() const { return m_paramFlippedFaces; }
+#endif
+	uint32_t mapFaceToSourceFace(uint32_t i) const { return m_faceArray[i]; }
+	const Mesh *mesh() const { return m_mesh; }
+	Mesh *mesh() { return m_mesh; }
+	const Mesh *unifiedMesh() const { return m_unifiedMesh; }
+	Mesh *unifiedMesh() { return m_unifiedMesh; }
+	uint32_t mapChartVertexToOriginalVertex(uint32_t i) const { return m_chartToOriginalMap[i]; }
 
-	uint32_t mapChartVertexToOriginalVertex(uint32_t i) const
-	{
-		return m_chartToOriginalMap[i];
-	}
-	uint32_t mapChartVertexToUnifiedVertex(uint32_t i) const
+	void evaluateOrthoParameterizationQuality()
 	{
-		return m_chartToUnifiedMap[i];
+		XA_PROFILE_START(parameterizeChartsEvaluateQuality)
+		m_paramQuality = calculateParameterizationQuality(m_unifiedMesh, nullptr);
+		XA_PROFILE_END(parameterizeChartsEvaluateQuality)
+		// Use orthogonal parameterization if quality is acceptable.
+		if (!m_paramQuality.boundaryIntersection && m_paramQuality.geometricArea > 0.0f && m_paramQuality.stretchMetric <= 1.1f && m_paramQuality.maxStretchMetric <= 1.25f)
+			m_isOrtho = true;
 	}
 
-	const std::vector<uint32_t> &faceArray() const
+	void evaluateParameterizationQuality()
 	{
-		return m_faceArray;
+		XA_PROFILE_START(parameterizeChartsEvaluateQuality)
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+		m_paramQuality = calculateParameterizationQuality(m_unifiedMesh, &m_paramFlippedFaces);
+#else
+		m_paramQuality = calculateParameterizationQuality(m_unifiedMesh, nullptr);
+#endif
+		XA_PROFILE_END(parameterizeChartsEvaluateQuality)
 	}
 
 	// Transfer parameterization from unified mesh to chart mesh.
 	void transferParameterization()
 	{
-		xaDebugAssert(!m_isVertexMapped);
-		uint32_t vertexCount = m_chartMesh->vertexCount();
-		for (uint32_t v = 0; v < vertexCount; v++) {
-			halfedge::Vertex *vertex = m_chartMesh->vertexAt(v);
-			halfedge::Vertex *unifiedVertex = m_unifiedMesh->vertexAt(mapChartVertexToUnifiedVertex(v));
-			vertex->tex = unifiedVertex->tex;
-		}
+		const uint32_t vertexCount = m_mesh->vertexCount();
+		for (uint32_t v = 0; v < vertexCount; v++)
+			m_mesh->texcoord(v) = m_unifiedMesh->texcoord(m_chartToUnifiedMap[v]);
 	}
 
 	float computeSurfaceArea() const
 	{
-		return halfedge::computeSurfaceArea(m_chartMesh.get()) * scale;
+		return m_mesh->computeSurfaceArea();
 	}
 
 	float computeParametricArea() const
 	{
-		// This only makes sense in parameterized meshes.
-		xaDebugAssert(m_isDisk);
-		xaDebugAssert(!m_isVertexMapped);
-		return halfedge::computeParametricArea(m_chartMesh.get());
+		return m_mesh->computeParametricArea();
 	}
 
 	Vector2 computeParametricBounds() const
 	{
-		// This only makes sense in parameterized meshes.
-		xaDebugAssert(m_isDisk);
-		xaDebugAssert(!m_isVertexMapped);
-		Box bounds;
-		bounds.clearBounds();
-		uint32_t vertexCount = m_chartMesh->vertexCount();
+		Vector2 minCorner(FLT_MAX, FLT_MAX);
+		Vector2 maxCorner(-FLT_MAX, -FLT_MAX);
+		const uint32_t vertexCount = m_mesh->vertexCount();
 		for (uint32_t v = 0; v < vertexCount; v++) {
-			halfedge::Vertex *vertex = m_chartMesh->vertexAt(v);
-			bounds.addPointToBounds(Vector3(vertex->tex, 0));
+			minCorner = min(minCorner, m_mesh->texcoord(v));
+			maxCorner = max(maxCorner, m_mesh->texcoord(v));
 		}
-		return bounds.extents().xy();
+		return (maxCorner - minCorner) * 0.5f;
 	}
 
-	float scale = 1.0f;
-	uint32_t vertexMapWidth;
-	uint32_t vertexMapHeight;
-	bool blockAligned = true;
-
 private:
-	bool closeLoop(uint32_t start, const std::vector<halfedge::Edge *> &loop)
-	{
-		const uint32_t vertexCount = loop.size() - start;
-		xaDebugAssert(vertexCount >= 3);
-		if (vertexCount < 3) return false;
-		xaDebugAssert(loop[start]->vertex->isColocal(loop[start + vertexCount - 1]->to()));
-		// If the hole is planar, then we add a single face that will be properly triangulated later.
-		// If the hole is not planar, we add a triangle fan with a vertex at the hole centroid.
-		// This is still a bit of a hack. There surely are better hole filling algorithms out there.
-		std::vector<Vector3> points(vertexCount);
-		for (uint32_t i = 0; i < vertexCount; i++) {
-			points[i] = loop[start + i]->vertex->pos;
-		}
-		bool isPlanar = Fit::isPlanar(vertexCount, points.data());
-		if (isPlanar) {
-			// Add face and connect edges.
-			halfedge::Face *face = m_unifiedMesh->addFace();
-			for (uint32_t i = 0; i < vertexCount; i++) {
-				halfedge::Edge *edge = loop[start + i];
-				edge->face = face;
-				edge->setNext(loop[start + (i + 1) % vertexCount]);
-			}
-			face->edge = loop[start];
-			xaDebugAssert(face->isValid());
-		} else {
-			// If the polygon is not planar, we just cross our fingers, and hope this will work:
-			// Compute boundary centroid:
-			Vector3 centroidPos(0);
-			for (uint32_t i = 0; i < vertexCount; i++) {
-				centroidPos += points[i];
-			}
-			centroidPos *= (1.0f / vertexCount);
-			halfedge::Vertex *centroid = m_unifiedMesh->addVertex(centroidPos);
-			// Add one pair of edges for each boundary vertex.
-			for (uint32_t j = vertexCount - 1, i = 0; i < vertexCount; j = i++) {
-				halfedge::Face *face = m_unifiedMesh->addFace(centroid->id, loop[start + j]->vertex->id, loop[start + i]->vertex->id);
-				xaDebugAssert(face != NULL);
-#ifdef NDEBUG
-				face = NULL; // silence unused parameter warning
-#endif
-			}
-		}
-		return true;
-	}
-
-	static void getBoundaryEdges(halfedge::Mesh *mesh, std::vector<halfedge::Edge *> &boundaryEdges)
-	{
-		xaDebugAssert(mesh != NULL);
-		const uint32_t edgeCount = mesh->edgeCount();
-		BitArray bitFlags(edgeCount);
-		bitFlags.clearAll();
-		boundaryEdges.clear();
-		// Search for boundary edges. Mark all the edges that belong to the same boundary.
-		for (uint32_t e = 0; e < edgeCount; e++) {
-			halfedge::Edge *startEdge = mesh->edgeAt(e);
-			if (startEdge != NULL && startEdge->isBoundary() && bitFlags.bitAt(e) == false) {
-				xaDebugAssert(startEdge->face != NULL);
-				xaDebugAssert(startEdge->pair->face == NULL);
-				startEdge = startEdge->pair;
-				const halfedge::Edge *edge = startEdge;
-				do {
-					xaDebugAssert(edge->face == NULL);
-					xaDebugAssert(bitFlags.bitAt(edge->id / 2) == false);
-					bitFlags.setBitAt(edge->id / 2);
-					edge = edge->next;
-				} while (startEdge != edge);
-				boundaryEdges.push_back(startEdge);
-			}
-		}
-	}
-
-	// Chart mesh.
-	std::auto_ptr<halfedge::Mesh> m_chartMesh;
+	Basis m_basis;
+	Mesh *m_mesh;
+	Mesh *m_unifiedMesh;
+	bool m_isDisk, m_isOrtho, m_isPlanar;
+	uint32_t m_warningFlags;
+	uint32_t m_closedHolesCount, m_fixedTJunctionsCount;
 
-	std::auto_ptr<halfedge::Mesh> m_unifiedMesh;
-	bool m_isDisk;
-	bool m_isVertexMapped;
-	
 	// List of faces of the original mesh that belong to this chart.
-	std::vector<uint32_t> m_faceArray;
+	Array<uint32_t> m_faceArray;
 
 	// Map vertices of the chart mesh to vertices of the original mesh.
-	std::vector<uint32_t> m_chartToOriginalMap;
+	Array<uint32_t> m_chartToOriginalMap;
 
-	std::vector<uint32_t> m_chartToUnifiedMap;
+	Array<uint32_t> m_chartToUnifiedMap;
+
+	ParameterizationQuality m_paramQuality;
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+	Array<uint32_t> m_paramFlippedFaces;
+#endif
 };
 
-// Estimate quality of existing parameterization.
-class ParameterizationQuality
+// Set of charts corresponding to mesh faces in the same face group.
+class ChartGroup
 {
 public:
-	ParameterizationQuality()
-	{
-		m_totalTriangleCount = 0;
-		m_flippedTriangleCount = 0;
-		m_zeroAreaTriangleCount = 0;
-		m_parametricArea = 0.0f;
-		m_geometricArea = 0.0f;
-		m_stretchMetric = 0.0f;
-		m_maxStretchMetric = 0.0f;
-		m_conformalMetric = 0.0f;
-		m_authalicMetric = 0.0f;
-	}
-
-	ParameterizationQuality(const halfedge::Mesh *mesh)
-	{
-		xaDebugAssert(mesh != NULL);
-		m_totalTriangleCount = 0;
-		m_flippedTriangleCount = 0;
-		m_zeroAreaTriangleCount = 0;
-		m_parametricArea = 0.0f;
-		m_geometricArea = 0.0f;
-		m_stretchMetric = 0.0f;
-		m_maxStretchMetric = 0.0f;
-		m_conformalMetric = 0.0f;
-		m_authalicMetric = 0.0f;
-		const uint32_t faceCount = mesh->faceCount();
+	ChartGroup(uint32_t id, const Mesh *sourceMesh, uint32_t faceGroup) : m_sourceId(sourceMesh->id()), m_id(id), m_isVertexMap(faceGroup == UINT32_MAX), m_paramAddedChartsCount(0), m_paramDeletedChartsCount(0)
+	{
+		// Create new mesh from the source mesh, using faces that belong to this group.
+		const uint32_t sourceFaceCount = sourceMesh->faceCount();
+		for (uint32_t f = 0; f < sourceFaceCount; f++) {
+			if (sourceMesh->faceGroupAt(f) == faceGroup)
+				m_faceToSourceFaceMap.push_back(f);
+		}
+		// Only initial meshes have face groups and ignored faces. The only flag we care about is HasNormals.
+		const uint32_t faceCount = m_faceToSourceFaceMap.size();
+		m_mesh = XA_NEW(MemTag::Mesh, Mesh, sourceMesh->epsilon(), faceCount * 3, faceCount, sourceMesh->flags() & MeshFlags::HasNormals);
+		XA_DEBUG_ASSERT(faceCount > 0);
+		Array<uint32_t> meshIndices;
+		meshIndices.resize(sourceMesh->vertexCount(), (uint32_t)~0);
 		for (uint32_t f = 0; f < faceCount; f++) {
-			const halfedge::Face *face = mesh->faceAt(f);
-			const halfedge::Vertex *vertex0 = NULL;
-			Vector3 p[3];
-			Vector2 t[3];
-			for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				const halfedge::Edge *edge = it.current();
-				if (vertex0 == NULL) {
-					vertex0 = edge->vertex;
-					p[0] = vertex0->pos;
-					t[0] = vertex0->tex;
-				} else if (edge->to() != vertex0) {
-					p[1] = edge->from()->pos;
-					p[2] = edge->to()->pos;
-					t[1] = edge->from()->tex;
-					t[2] = edge->to()->tex;
-					processTriangle(p, t);
+			const uint32_t face = m_faceToSourceFaceMap[f];
+			for (uint32_t i = 0; i < 3; i++) {
+				const uint32_t vertex = sourceMesh->vertexAt(face * 3 + i);
+				if (meshIndices[vertex] == (uint32_t)~0) {
+					meshIndices[vertex] = m_mesh->vertexCount();
+					m_vertexToSourceVertexMap.push_back(vertex);
+					Vector3 normal(0.0f);
+					if (sourceMesh->flags() & MeshFlags::HasNormals)
+						normal = sourceMesh->normal(vertex);
+					m_mesh->addVertex(sourceMesh->position(vertex), normal, sourceMesh->texcoord(vertex));
 				}
 			}
 		}
-		if (m_flippedTriangleCount + m_zeroAreaTriangleCount == faceCount) {
-			// If all triangles are flipped, then none is.
-			m_flippedTriangleCount = 0;
-		}
-		xaDebugAssert(std::isfinite(m_parametricArea) && m_parametricArea >= 0);
-		xaDebugAssert(std::isfinite(m_geometricArea) && m_geometricArea >= 0);
-		xaDebugAssert(std::isfinite(m_stretchMetric));
-		xaDebugAssert(std::isfinite(m_maxStretchMetric));
-		xaDebugAssert(std::isfinite(m_conformalMetric));
-		xaDebugAssert(std::isfinite(m_authalicMetric));
-	}
-
-	bool isValid() const
-	{
-		return m_flippedTriangleCount == 0; // @@ Does not test for self-overlaps.
-	}
-
-	float rmsStretchMetric() const
-	{
-		if (m_geometricArea == 0) return 0.0f;
-		float normFactor = sqrtf(m_parametricArea / m_geometricArea);
-		return sqrtf(m_stretchMetric / m_geometricArea) * normFactor;
-	}
-
-	float maxStretchMetric() const
-	{
-		if (m_geometricArea == 0) return 0.0f;
-		float normFactor = sqrtf(m_parametricArea / m_geometricArea);
-		return m_maxStretchMetric * normFactor;
-	}
-
-	float rmsConformalMetric() const
-	{
-		if (m_geometricArea == 0) return 0.0f;
-		return sqrtf(m_conformalMetric / m_geometricArea);
-	}
-
-	float maxAuthalicMetric() const
-	{
-		if (m_geometricArea == 0) return 0.0f;
-		return sqrtf(m_authalicMetric / m_geometricArea);
-	}
-
-	void operator+=(const ParameterizationQuality &pq)
-	{
-		m_totalTriangleCount += pq.m_totalTriangleCount;
-		m_flippedTriangleCount += pq.m_flippedTriangleCount;
-		m_zeroAreaTriangleCount += pq.m_zeroAreaTriangleCount;
-		m_parametricArea += pq.m_parametricArea;
-		m_geometricArea += pq.m_geometricArea;
-		m_stretchMetric += pq.m_stretchMetric;
-		m_maxStretchMetric = std::max(m_maxStretchMetric, pq.m_maxStretchMetric);
-		m_conformalMetric += pq.m_conformalMetric;
-		m_authalicMetric += pq.m_authalicMetric;
-	}
-
-private:
-	void processTriangle(Vector3 q[3], Vector2 p[3])
-	{
-		m_totalTriangleCount++;
-		// Evaluate texture stretch metric. See:
-		// - "Texture Mapping Progressive Meshes", Sander, Snyder, Gortler & Hoppe
-		// - "Mesh Parameterization: Theory and Practice", Siggraph'07 Course Notes, Hormann, Levy & Sheffer.
-		float t1 = p[0].x;
-		float s1 = p[0].y;
-		float t2 = p[1].x;
-		float s2 = p[1].y;
-		float t3 = p[2].x;
-		float s3 = p[2].y;
-		float geometricArea = length(cross(q[1] - q[0], q[2] - q[0])) / 2;
-		float parametricArea = ((s2 - s1) * (t3 - t1) - (s3 - s1) * (t2 - t1)) / 2;
-		if (isZero(parametricArea)) {
-			m_zeroAreaTriangleCount++;
-			return;
-		}
-		Vector3 Ss = (q[0] * (t2 - t3) + q[1] * (t3 - t1) + q[2] * (t1 - t2)) / (2 * parametricArea);
-		Vector3 St = (q[0] * (s3 - s2) + q[1] * (s1 - s3) + q[2] * (s2 - s1)) / (2 * parametricArea);
-		float a = dot(Ss, Ss); // E
-		float b = dot(Ss, St); // F
-		float c = dot(St, St); // G
-		// Compute eigen-values of the first fundamental form:
-		float sigma1 = sqrtf(0.5f * std::max(0.0f, a + c - sqrtf(square(a - c) + 4 * square(b)))); // gamma uppercase, min eigenvalue.
-		float sigma2 = sqrtf(0.5f * std::max(0.0f, a + c + sqrtf(square(a - c) + 4 * square(b)))); // gamma lowercase, max eigenvalue.
-		xaAssert(sigma2 >= sigma1);
-		// isometric: sigma1 = sigma2 = 1
-		// conformal: sigma1 / sigma2 = 1
-		// authalic: sigma1 * sigma2 = 1
-		float rmsStretch = sqrtf((a + c) * 0.5f);
-		float rmsStretch2 = sqrtf((square(sigma1) + square(sigma2)) * 0.5f);
-		xaDebugAssert(equal(rmsStretch, rmsStretch2, 0.01f));
-#ifdef NDEBUG
-		rmsStretch2 = 0; // silence unused parameter warning
+		// Add faces.
+		for (uint32_t f = 0; f < faceCount; f++) {
+			const uint32_t face = m_faceToSourceFaceMap[f];
+			uint32_t indices[3];
+			for (uint32_t i = 0; i < 3; i++) {
+				const uint32_t vertex = sourceMesh->vertexAt(face * 3 + i);
+				XA_DEBUG_ASSERT(meshIndices[vertex] != (uint32_t)~0);
+				indices[i] = meshIndices[vertex];
+			}
+			// Don't copy flags, it doesn't matter if a face is ignored after this point. All ignored faces get their own vertex map (m_isVertexMap) ChartGroup.
+			// Don't hash edges if m_isVertexMap, they may be degenerate.
+			Mesh::AddFaceResult::Enum result = m_mesh->addFace(indices, false, !m_isVertexMap);
+			XA_UNUSED(result);
+			XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK);
+		}
+		if (!m_isVertexMap) {
+			m_mesh->createColocals();
+			m_mesh->createBoundaries();
+			m_mesh->linkBoundaries();
+		}
+#if XA_DEBUG_EXPORT_OBJ_CHART_GROUPS
+		char filename[256];
+		XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u.obj", m_sourceId, m_id);
+		m_mesh->writeObjFile(filename);
+#else
+		XA_UNUSED(m_id);
 #endif
-		if (parametricArea < 0.0f) {
-			// Count flipped triangles.
-			m_flippedTriangleCount++;
-			parametricArea = fabsf(parametricArea);
-		}
-		m_stretchMetric += square(rmsStretch) * geometricArea;
-		m_maxStretchMetric = std::max(m_maxStretchMetric, sigma2);
-		if (!isZero(sigma1, 0.000001f)) {
-			// sigma1 is zero when geometricArea is zero.
-			m_conformalMetric += (sigma2 / sigma1) * geometricArea;
-		}
-		m_authalicMetric += (sigma1 * sigma2) * geometricArea;
-		// Accumulate total areas.
-		m_geometricArea += geometricArea;
-		m_parametricArea += parametricArea;
-		//triangleConformalEnergy(q, p);
 	}
 
-	uint32_t m_totalTriangleCount;
-	uint32_t m_flippedTriangleCount;
-	uint32_t m_zeroAreaTriangleCount;
-	float m_parametricArea;
-	float m_geometricArea;
-	float m_stretchMetric;
-	float m_maxStretchMetric;
-	float m_conformalMetric;
-	float m_authalicMetric;
-};
-
-// Set of charts corresponding to a single mesh.
-class MeshCharts
-{
-public:
-	MeshCharts(const halfedge::Mesh *mesh) : m_mesh(mesh) {}
-
-	~MeshCharts()
+	~ChartGroup()
 	{
-		for (size_t i = 0; i < m_chartArray.size(); i++)
-			delete m_chartArray[i];
-	}
-
-	uint32_t chartCount() const
-	{
-		return m_chartArray.size();
-	}
-	uint32_t vertexCount () const
-	{
-		return m_totalVertexCount;
-	}
-
-	const Chart *chartAt(uint32_t i) const
-	{
-		return m_chartArray[i];
-	}
-	Chart *chartAt(uint32_t i)
-	{
-		return m_chartArray[i];
-	}
-
-	// Extract the charts of the input mesh.
-	void extractCharts()
-	{
-		const uint32_t faceCount = m_mesh->faceCount();
-		int first = 0;
-		std::vector<uint32_t> queue;
-		queue.reserve(faceCount);
-		BitArray bitFlags(faceCount);
-		bitFlags.clearAll();
-		for (uint32_t f = 0; f < faceCount; f++) {
-			if (bitFlags.bitAt(f) == false) {
-				// Start new patch. Reset queue.
-				first = 0;
-				queue.clear();
-				queue.push_back(f);
-				bitFlags.setBitAt(f);
-				while (first != (int)queue.size()) {
-					const halfedge::Face *face = m_mesh->faceAt(queue[first]);
-					// Visit face neighbors of queue[first]
-					for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-						const halfedge::Edge *edge = it.current();
-						xaDebugAssert(edge->pair != NULL);
-						if (!edge->isBoundary() && /*!edge->isSeam()*/
-								//!(edge->from()->tex() != edge->pair()->to()->tex() || edge->to()->tex() != edge->pair()->from()->tex()))
-								!(edge->from() != edge->pair->to() || edge->to() != edge->pair->from())) { // Preserve existing seams (not just texture seams).
-							const halfedge::Face *neighborFace = edge->pair->face;
-							xaDebugAssert(neighborFace != NULL);
-							if (bitFlags.bitAt(neighborFace->id) == false) {
-								queue.push_back(neighborFace->id);
-								bitFlags.setBitAt(neighborFace->id);
-							}
-						}
-					}
-					first++;
-				}
-				Chart *chart = new Chart();
-				chart->build(m_mesh, queue);
-				m_chartArray.push_back(chart);
-			}
+		m_mesh->~Mesh();
+		XA_FREE(m_mesh);
+		for (uint32_t i = 0; i < m_chartArray.size(); i++) {
+			m_chartArray[i]->~Chart();
+			XA_FREE(m_chartArray[i]);
 		}
 	}
 
+	uint32_t chartCount() const { return m_chartArray.size(); }
+	Chart *chartAt(uint32_t i) const { return m_chartArray[i]; }
+	uint32_t paramAddedChartsCount() const { return m_paramAddedChartsCount; }
+	uint32_t paramDeletedChartsCount() const { return m_paramDeletedChartsCount; }
+	bool isVertexMap() const { return m_isVertexMap; }
+	uint32_t mapFaceToSourceFace(uint32_t face) const { return m_faceToSourceFaceMap[face]; }
+	uint32_t mapVertexToSourceVertex(uint32_t i) const { return m_vertexToSourceVertexMap[i]; }
+	const Mesh *mesh() const { return m_mesh; }
+
 	/*
 	Compute charts using a simple segmentation algorithm.
 
@@ -6481,617 +6107,1122 @@ public:
 		  - emphasize roundness metrics to prevent those cases.
 	  - If interior self-overlaps: preserve boundary parameterization and use mean-value map.
 	*/
-	void computeCharts(const CharterOptions &options, const std::vector<uint32_t> &unchartedMaterialArray)
-	{
-		Chart *vertexMap = NULL;
-		if (unchartedMaterialArray.size() != 0) {
-			vertexMap = new Chart();
-			vertexMap->buildVertexMap(m_mesh, unchartedMaterialArray);
-			if (vertexMap->faceCount() == 0) {
-				delete vertexMap;
-				vertexMap = NULL;
-			}
-		}
-		AtlasBuilder builder(m_mesh);
-		if (vertexMap != NULL) {
-			// Mark faces that do not need to be charted.
-			builder.markUnchartedFaces(vertexMap->faceArray());
-			m_chartArray.push_back(vertexMap);
-		}
-		if (builder.facesLeft != 0) {
-			// Tweak these values:
-			const float maxThreshold = 2;
-			const uint32_t growFaceCount = 32;
-			const uint32_t maxIterations = 4;
-			builder.options = options;
-			//builder.options.proxyFitMetricWeight *= 0.75; // relax proxy fit weight during initial seed placement.
-			//builder.options.roundnessMetricWeight = 0;
-			//builder.options.straightnessMetricWeight = 0;
-			// This seems a reasonable estimate.
-			uint32_t maxSeedCount = std::max(6U, builder.facesLeft);
-			// Create initial charts greedely.
-			xaPrint("### Placing seeds\n");
-			builder.placeSeeds(maxThreshold, maxSeedCount);
-			xaPrint("###   Placed %d seeds (max = %d)\n", builder.chartCount(), maxSeedCount);
-			builder.updateProxies();
-			builder.mergeCharts();
-	#if 1
-			xaPrint("### Relocating seeds\n");
-			builder.relocateSeeds();
-			xaPrint("### Reset charts\n");
-			builder.resetCharts();
-			if (vertexMap != NULL) {
-				builder.markUnchartedFaces(vertexMap->faceArray());
-			}
-			builder.options = options;
-			xaPrint("### Growing charts\n");
-			// Restart process growing charts in parallel.
-			uint32_t iteration = 0;
-			while (true) {
-				if (!builder.growCharts(maxThreshold, growFaceCount)) {
-					xaPrint("### Can't grow anymore\n");
-					// If charts cannot grow more: fill holes, merge charts, relocate seeds and start new iteration.
-					xaPrint("### Filling holes\n");
-					builder.fillHoles(maxThreshold);
-					xaPrint("###   Using %d charts now\n", builder.chartCount());
-					builder.updateProxies();
-					xaPrint("### Merging charts\n");
-					builder.mergeCharts();
-					xaPrint("###   Using %d charts now\n", builder.chartCount());
-					xaPrint("### Reseeding\n");
-					if (!builder.relocateSeeds()) {
-						xaPrint("### Cannot relocate seeds anymore\n");
-						// Done!
-						break;
-					}
-					if (iteration == maxIterations) {
-						xaPrint("### Reached iteration limit\n");
-						break;
-					}
-					iteration++;
-					xaPrint("### Reset charts\n");
-					builder.resetCharts();
-					if (vertexMap != NULL) {
-						builder.markUnchartedFaces(vertexMap->faceArray());
-					}
-					xaPrint("### Growing charts\n");
-				}
-			};
-	#endif
-			// Make sure no holes are left!
-			xaDebugAssert(builder.facesLeft == 0);
-			const uint32_t chartCount = builder.chartArray.size();
-			for (uint32_t i = 0; i < chartCount; i++) {
-				Chart *chart = new Chart();
-				m_chartArray.push_back(chart);
-				chart->build(m_mesh, builder.chartFaces(i));
-			}
-		}
-		const uint32_t chartCount = m_chartArray.size();
-		// Build face indices.
-		m_faceChart.resize(m_mesh->faceCount());
-		m_faceIndex.resize(m_mesh->faceCount());
+	void computeCharts(const ChartOptions &options)
+	{
+		m_chartOptions = options;
+		// This function may be called multiple times, so destroy existing charts.
+		for (uint32_t i = 0; i < m_chartArray.size(); i++) {
+			m_chartArray[i]->~Chart();
+			XA_FREE(m_chartArray[i]);
+		}
+		m_chartArray.clear();
+#if XA_DEBUG_SINGLE_CHART
+		Array<uint32_t> chartFaces;
+		chartFaces.resize(m_mesh->faceCount());
+		for (uint32_t i = 0; i < chartFaces.size(); i++)
+			chartFaces[i] = i;
+		Chart *chart = XA_NEW(MemTag::Default, Chart, m_mesh, chartFaces, m_sourceId, m_id, 0);
+		m_chartArray.push_back(chart);
+#else
+		XA_PROFILE_START(atlasBuilder)
+		AtlasBuilder builder(m_mesh, nullptr, options);
+		runAtlasBuilder(builder, options);
+		XA_PROFILE_END(atlasBuilder)
+		XA_PROFILE_START(createChartMeshes)
+		const uint32_t chartCount = builder.chartCount();
 		for (uint32_t i = 0; i < chartCount; i++) {
-			const Chart *chart = m_chartArray[i];
-			const uint32_t faceCount = chart->faceCount();
-			for (uint32_t f = 0; f < faceCount; f++) {
-				uint32_t idx = chart->faceAt(f);
-				m_faceChart[idx] = i;
-				m_faceIndex[idx] = f;
-			}
+			Chart *chart = XA_NEW(MemTag::Default, Chart, m_mesh, builder.chartFaces(i), builder.chartBasis(i), m_sourceId, m_id, i);
+			m_chartArray.push_back(chart);
 		}
-		// Build an exclusive prefix sum of the chart vertex counts.
-		m_chartVertexCountPrefixSum.resize(chartCount);
-		if (chartCount > 0) {
-			m_chartVertexCountPrefixSum[0] = 0;
-			for (uint32_t i = 1; i < chartCount; i++) {
-				const Chart *chart = m_chartArray[i - 1];
-				m_chartVertexCountPrefixSum[i] = m_chartVertexCountPrefixSum[i - 1] + chart->vertexCount();
+		XA_PROFILE_END(createChartMeshes)
+#endif
+#if XA_DEBUG_EXPORT_OBJ_CHARTS
+		char filename[256];
+		XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_charts.obj", m_sourceId, m_id);
+		FILE *file;
+		XA_FOPEN(file, filename, "w");
+		if (file) {
+			m_mesh->writeObjVertices(file);
+			for (uint32_t i = 0; i < chartCount; i++) {
+				fprintf(file, "o chart_%04d\n", i);
+				fprintf(file, "s off\n");
+				const Array<uint32_t> &faces = builder.chartFaces(i);
+				for (uint32_t f = 0; f < faces.size(); f++)
+					m_mesh->writeObjFace(file, faces[f]);
 			}
-			m_totalVertexCount = m_chartVertexCountPrefixSum[chartCount - 1] + m_chartArray[chartCount - 1]->vertexCount();
-		} else {
-			m_totalVertexCount = 0;
+			m_mesh->writeObjBoundaryEges(file);
+			m_mesh->writeObjLinkedBoundaries(file);
+			fclose(file);
 		}
+#endif
 	}
 
-	void parameterizeCharts()
+	void parameterizeCharts(ParameterizeFunc func)
 	{
-		ParameterizationQuality globalParameterizationQuality;
-		// Parameterize the charts.
-		uint32_t diskCount = 0;
+#if XA_RECOMPUTE_CHARTS
+		Array<Chart *> invalidCharts;
 		const uint32_t chartCount = m_chartArray.size();
-		for (uint32_t i = 0; i < chartCount; i++)
-		{
+		for (uint32_t i = 0; i < chartCount; i++) {
 			Chart *chart = m_chartArray[i];
-
-			bool isValid = false;
-
-			if (chart->isVertexMapped())
-			{
-				continue;
-			}
-
-			if (chart->isDisk())
-			{
-				diskCount++;
-				ParameterizationQuality chartParameterizationQuality;
-				if (chart->faceCount() == 1) {
-					computeSingleFaceMap(chart->unifiedMesh());
-					chartParameterizationQuality = ParameterizationQuality(chart->unifiedMesh());
-				} else {
-					computeOrthogonalProjectionMap(chart->unifiedMesh());
-					ParameterizationQuality orthogonalQuality(chart->unifiedMesh());
-					computeLeastSquaresConformalMap(chart->unifiedMesh());
-					ParameterizationQuality lscmQuality(chart->unifiedMesh());
-					chartParameterizationQuality = lscmQuality;
-				}
-				isValid = chartParameterizationQuality.isValid();
-				if (!isValid) {
-					xaPrint("*** Invalid parameterization.\n");
+			parameterizeChart(chart, func);
+			const ParameterizationQuality &quality = chart->paramQuality();
+			if (quality.boundaryIntersection || quality.flippedTriangleCount > 0)
+				invalidCharts.push_back(chart);
+		}
+		// Recompute charts with invalid parameterizations.
+		Array<uint32_t> meshFaces;
+		for (uint32_t i = 0; i < invalidCharts.size(); i++) {
+			Chart *invalidChart = invalidCharts[i];
+			const Mesh *invalidMesh = invalidChart->mesh();
+			const uint32_t faceCount = invalidMesh->faceCount();
+			meshFaces.resize(faceCount);
+			float invalidChartArea = 0.0f;
+			for (uint32_t j = 0; j < faceCount; j++) {
+				meshFaces[j] = invalidChart->mapFaceToSourceFace(j);
+				invalidChartArea += invalidMesh->faceArea(j);
+			}
+			ChartOptions options = m_chartOptions;
+			options.maxChartArea = invalidChartArea * 0.2f;
+			options.maxThreshold = 0.25f;
+			options.maxIterations = 3;
+			AtlasBuilder builder(m_mesh, &meshFaces, options);
+			runAtlasBuilder(builder, options);
+			for (uint32_t j = 0; j < builder.chartCount(); j++) {
+				Chart *chart = XA_NEW(MemTag::Default, Chart, m_mesh, builder.chartFaces(j), builder.chartBasis(j), m_sourceId, m_id, m_chartArray.size());
+				m_chartArray.push_back(chart);
+				m_paramAddedChartsCount++;
+			}
+#if XA_DEBUG_EXPORT_OBJ_RECOMPUTED_CHARTS
+			char filename[256];
+			XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_recomputed_chart_%u.obj", m_sourceId, m_id, i);
+			FILE *file;
+			XA_FOPEN(file, filename, "w");
+			if (file) {
+				m_mesh->writeObjVertices(file);
+				for (uint32_t j = 0; j < builder.chartCount(); j++) {
+					fprintf(file, "o chart_%04d\n", j);
+					fprintf(file, "s off\n");
+					const Array<uint32_t> &faces = builder.chartFaces(j);
+					for (uint32_t f = 0; f < faces.size(); f++)
+						m_mesh->writeObjFace(file, faces[f]);
 				}
-				// @@ Check that parameterization quality is above a certain threshold.
-				// @@ Detect boundary self-intersections.
-				globalParameterizationQuality += chartParameterizationQuality;
+				fclose(file);
 			}
-
-			// Transfer parameterization from unified mesh to chart mesh.
-			chart->transferParameterization();
-
+#endif
+		}
+		// Parameterize the new charts.
+		for (uint32_t i = chartCount; i < m_chartArray.size(); i++)
+			parameterizeChart(m_chartArray[i], func);
+		// Remove and delete the invalid charts.
+		for (uint32_t i = 0; i < invalidCharts.size(); i++) {
+			Chart *chart = invalidCharts[i];
+			removeChart(chart);
+			chart->~Chart();
+			XA_FREE(chart);
+			m_paramDeletedChartsCount++;
 		}
-		xaPrint("  Parameterized %d/%d charts.\n", diskCount, chartCount);
-		xaPrint("  RMS stretch metric: %f\n", globalParameterizationQuality.rmsStretchMetric());
-		xaPrint("  MAX stretch metric: %f\n", globalParameterizationQuality.maxStretchMetric());
-		xaPrint("  RMS conformal metric: %f\n", globalParameterizationQuality.rmsConformalMetric());
-		xaPrint("  RMS authalic metric: %f\n", globalParameterizationQuality.maxAuthalicMetric());
+#else
+		const uint32_t chartCount = m_chartArray.size();
+		for (uint32_t i = 0; i < chartCount; i++) {
+			Chart *chart = m_chartArray[i];
+			parameterizeChart(chart, func);
+		}
+#endif
 	}
 
-	uint32_t faceChartAt(uint32_t i) const
-	{
-		return m_faceChart[i];
-	}
-	uint32_t faceIndexWithinChartAt(uint32_t i) const
+private:
+	void runAtlasBuilder(AtlasBuilder &builder, const ChartOptions &options)
 	{
-		return m_faceIndex[i];
+		if (builder.facesLeft() == 0)
+			return;
+		// This seems a reasonable estimate.
+		XA_PROFILE_START(atlasBuilderCreateInitialCharts)
+		// Create initial charts greedely.
+		builder.placeSeeds(options.maxThreshold * 0.5f);
+		if (options.maxIterations == 0) {
+			XA_DEBUG_ASSERT(builder.facesLeft() == 0);
+			XA_PROFILE_END(atlasBuilderCreateInitialCharts)
+			return;
+		}
+		builder.updateProxies();
+		builder.relocateSeeds();
+		builder.resetCharts();
+		XA_PROFILE_END(atlasBuilderCreateInitialCharts)
+		// Restart process growing charts in parallel.
+		uint32_t iteration = 0;
+		while (true) {
+			if (!builder.growCharts(options.maxThreshold, options.growFaceCount)) {
+				// If charts cannot grow more: fill holes, merge charts, relocate seeds and start new iteration.
+				builder.fillHoles(options.maxThreshold * 0.5f);
+				builder.updateProxies();
+#if XA_MERGE_CHARTS
+				builder.mergeCharts();
+#endif
+				if (++iteration == options.maxIterations)
+					break;
+				if (!builder.relocateSeeds())
+					break;
+				builder.resetCharts();
+			}
+		}
+		// Make sure no holes are left!
+		XA_DEBUG_ASSERT(builder.facesLeft() == 0);
 	}
 
-	uint32_t vertexCountBeforeChartAt(uint32_t i) const
+	void parameterizeChart(Chart *chart, ParameterizeFunc func)
 	{
-		return m_chartVertexCountPrefixSum[i];
+		Mesh *mesh = chart->unifiedMesh();
+		XA_PROFILE_START(parameterizeChartsOrthogonal)
+#if 1
+		computeOrthogonalProjectionMap(mesh);
+#else
+		for (uint32_t i = 0; i < vertexCount; i++)
+			mesh->texcoord(i) = Vector2(dot(chart->basis().tangent, mesh->position(i)), dot(chart->basis().bitangent, mesh->position(i)));
+#endif
+		XA_PROFILE_END(parameterizeChartsOrthogonal)
+		chart->evaluateOrthoParameterizationQuality();
+		if (!chart->isOrtho() && !chart->isPlanar()) {
+			XA_PROFILE_START(parameterizeChartsLSCM)
+			if (func)
+				func(&mesh->position(0).x, &mesh->texcoord(0).x, mesh->vertexCount(), mesh->indices(), mesh->indexCount());
+			else if (chart->isDisk())
+				computeLeastSquaresConformalMap(mesh);
+			XA_PROFILE_END(parameterizeChartsLSCM)
+			chart->evaluateParameterizationQuality();
+		}
+		// @@ Check that parameterization quality is above a certain threshold.
+		// Transfer parameterization from unified mesh to chart mesh.
+		chart->transferParameterization();
+	}
+
+	void removeChart(const Chart *chart)
+	{
+		for (uint32_t i = 0; i < m_chartArray.size(); i++) {
+			if (m_chartArray[i] == chart) {
+				m_chartArray.removeAt(i);
+				return;
+			}
+		}
 	}
 
-private:
+	uint32_t m_sourceId, m_id;
+	bool m_isVertexMap;
+	Mesh *m_mesh;
+	Array<uint32_t> m_faceToSourceFaceMap; // List of faces of the source mesh that belong to this chart group.
+	Array<uint32_t> m_vertexToSourceVertexMap; // Map vertices of the mesh to vertices of the source mesh.
+	Array<Chart *> m_chartArray;
+	ChartOptions m_chartOptions;
+	uint32_t m_paramAddedChartsCount; // Number of new charts added by recomputing charts with invalid parameterizations.
+	uint32_t m_paramDeletedChartsCount; // Number of charts with invalid parameterizations that were deleted, after charts were recomputed.
+};
 
-	const halfedge::Mesh *m_mesh;
+struct CreateChartGroupTaskArgs
+{
+	uint32_t faceGroup;
+	uint32_t groupId;
+	const Mesh *mesh;
+	ChartGroup **chartGroup;
+};
 
-	std::vector<Chart *> m_chartArray;
+static void runCreateChartGroupTask(void *userData)
+{
+	XA_PROFILE_START(addMeshCreateChartGroups)
+	auto args = (CreateChartGroupTaskArgs *)userData;
+	*(args->chartGroup) = XA_NEW(MemTag::Default, ChartGroup, args->groupId, args->mesh, args->faceGroup);
+	XA_PROFILE_END(addMeshCreateChartGroups)
+}
 
-	std::vector<uint32_t> m_chartVertexCountPrefixSum;
-	uint32_t m_totalVertexCount;
+struct ComputeChartsTaskArgs
+{
+	ChartGroup *chartGroup;
+	const ChartOptions *options;
+	Progress *progress;
+};
+
+static void runComputeChartsJob(void *userData)
+{
+	ComputeChartsTaskArgs *args = (ComputeChartsTaskArgs *)userData;
+	if (args->progress->cancel)
+		return;
+	XA_PROFILE_START(computeCharts)
+	args->chartGroup->computeCharts(*args->options);
+	XA_PROFILE_END(computeCharts)
+	args->progress->value++;
+	args->progress->update();
+}
 
-	std::vector<uint32_t> m_faceChart; // the chart of every face of the input mesh.
-	std::vector<uint32_t> m_faceIndex; // the index within the chart for every face of the input mesh.
+struct ParameterizeChartsTaskArgs
+{
+	ChartGroup *chartGroup;
+	ParameterizeFunc func;
+	Progress *progress;
 };
 
-/// An atlas is a set of charts.
+static void runParameterizeChartsJob(void *userData)
+{
+	ParameterizeChartsTaskArgs *args = (ParameterizeChartsTaskArgs *)userData;
+	if (args->progress->cancel)
+		return;
+	XA_PROFILE_START(parameterizeCharts)
+	args->chartGroup->parameterizeCharts(args->func);
+	XA_PROFILE_END(parameterizeCharts)
+	args->progress->value++;
+	args->progress->update();
+}
+
+/// An atlas is a set of chart groups.
 class Atlas
 {
 public:
+	Atlas() : m_chartsComputed(false), m_chartsParameterized(false) {}
+
 	~Atlas()
 	{
-		for (size_t i = 0; i < m_meshChartsArray.size(); i++)
-			delete m_meshChartsArray[i];
+		for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+			m_chartGroups[i]->~ChartGroup();
+			XA_FREE(m_chartGroups[i]);
+		}
 	}
 
-	uint32_t meshCount() const
-	{
-		return m_meshChartsArray.size();
-	}
+	bool chartsComputed() const { return m_chartsComputed; }
+	bool chartsParameterized() const { return m_chartsParameterized; }
 
-	const MeshCharts *meshAt(uint32_t i) const
+	uint32_t chartGroupCount(uint32_t mesh) const
 	{
-		return m_meshChartsArray[i];
+		uint32_t count = 0;
+		for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+			if (m_chartGroupSourceMeshes[i] == mesh)
+				count++;
+		}
+		return count;
 	}
 
-	MeshCharts *meshAt(uint32_t i)
+	const ChartGroup *chartGroupAt(uint32_t mesh, uint32_t group) const
 	{
-		return m_meshChartsArray[i];
+		for (uint32_t c = 0; c < m_chartGroups.size(); c++) {
+			if (m_chartGroupSourceMeshes[c] != mesh)
+				continue;
+			if (group == 0)
+				return m_chartGroups[c];
+			group--;
+		}
+		return nullptr;
 	}
 
 	uint32_t chartCount() const
 	{
 		uint32_t count = 0;
-		for (uint32_t c = 0; c < m_meshChartsArray.size(); c++) {
-			count += m_meshChartsArray[c]->chartCount();
-		}
+		for (uint32_t i = 0; i < m_chartGroups.size(); i++)
+			count += m_chartGroups[i]->chartCount();
 		return count;
 	}
 
-	const Chart *chartAt(uint32_t i) const
+	Chart *chartAt(uint32_t i)
 	{
-		for (uint32_t c = 0; c < m_meshChartsArray.size(); c++) {
-			uint32_t count = m_meshChartsArray[c]->chartCount();
+		for (uint32_t c = 0; c < m_chartGroups.size(); c++) {
+			uint32_t count = m_chartGroups[c]->chartCount();
 			if (i < count) {
-				return m_meshChartsArray[c]->chartAt(i);
+				return m_chartGroups[c]->chartAt(i);
 			}
 			i -= count;
 		}
-		return NULL;
+		return nullptr;
 	}
 
-	Chart *chartAt(uint32_t i)
+	// This function is thread safe.
+	void addMesh(TaskScheduler *taskScheduler, const Mesh *mesh)
 	{
-		for (uint32_t c = 0; c < m_meshChartsArray.size(); c++) {
-			uint32_t count = m_meshChartsArray[c]->chartCount();
-			if (i < count) {
-				return m_meshChartsArray[c]->chartAt(i);
+		// Get list of face groups.
+		const uint32_t faceCount = mesh->faceCount();
+		Array<uint32_t> faceGroups;
+		for (uint32_t f = 0; f < faceCount; f++) {
+			const uint32_t group = mesh->faceGroupAt(f);
+			bool exists = false;
+			for (uint32_t g = 0; g < faceGroups.size(); g++) {
+				if (faceGroups[g] == group) {
+					exists = true;
+					break;
+				}
+			}
+			if (!exists)
+				faceGroups.push_back(group);
+		}
+		// Create one chart group per face group.
+		// Chart group creation is slow since it copies a chunk of the source mesh, so use tasks.
+		Array<ChartGroup *> chartGroups;
+		chartGroups.resize(faceGroups.size());
+		Array<CreateChartGroupTaskArgs> taskArgs;
+		taskArgs.resize(chartGroups.size());
+		for (uint32_t g = 0; g < chartGroups.size(); g++) {
+			CreateChartGroupTaskArgs &args = taskArgs[g];
+			args.chartGroup = &chartGroups[g];
+			args.faceGroup = faceGroups[g];
+			args.groupId = g;
+			args.mesh = mesh;
+		}
+		TaskGroupHandle taskGroup;
+		for (uint32_t g = 0; g < chartGroups.size(); g++) {
+			Task task;
+			task.userData = &taskArgs[g];
+			task.func = runCreateChartGroupTask;
+			taskScheduler->run(&taskGroup, task);
+		}
+		taskScheduler->wait(&taskGroup);
+		// Thread-safe append.
+		m_addMeshMutex.lock();
+		for (uint32_t g = 0; g < chartGroups.size(); g++) {
+			m_chartGroups.push_back(chartGroups[g]);
+			m_chartGroupSourceMeshes.push_back(mesh->id());
+		}
+		m_addMeshMutex.unlock();
+	}
+
+	bool computeCharts(TaskScheduler *taskScheduler, const ChartOptions &options, ProgressFunc progressFunc, void *progressUserData)
+	{
+		m_chartsComputed = false;
+		m_chartsParameterized = false;
+		uint32_t taskCount = 0;
+		for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+			if (!m_chartGroups[i]->isVertexMap())
+				taskCount++;
+		}
+		Progress progress(ProgressCategory::ComputeCharts, progressFunc, progressUserData, taskCount);
+		Array<ComputeChartsTaskArgs> taskArgs;
+		taskArgs.reserve(taskCount);
+		for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+			if (!m_chartGroups[i]->isVertexMap()) {
+				ComputeChartsTaskArgs args;
+				args.chartGroup = m_chartGroups[i];
+				args.options = &options;
+				args.progress = &progress;
+				taskArgs.push_back(args);
+			}
+		}
+		TaskGroupHandle taskGroup;
+		for (uint32_t i = 0; i < taskCount; i++) {
+			Task task;
+			task.userData = &taskArgs[i];
+			task.func = runComputeChartsJob;
+			taskScheduler->run(&taskGroup, task);
+		}
+		taskScheduler->wait(&taskGroup);
+		if (progress.cancel)
+			return false;
+		m_chartsComputed = true;
+		return true;
+	}
+
+	bool parameterizeCharts(TaskScheduler *taskScheduler, ParameterizeFunc func, ProgressFunc progressFunc, void *progressUserData)
+	{
+		m_chartsParameterized = false;
+		uint32_t taskCount = 0;
+		for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+			if (!m_chartGroups[i]->isVertexMap())
+				taskCount++;
+		}
+		Progress progress(ProgressCategory::ParameterizeCharts, progressFunc, progressUserData, taskCount);
+		Array<ParameterizeChartsTaskArgs> taskArgs;
+		taskArgs.reserve(taskCount);
+		for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+			if (!m_chartGroups[i]->isVertexMap()) {
+				ParameterizeChartsTaskArgs args;
+				args.chartGroup = m_chartGroups[i];
+				args.func = func;
+				args.progress = &progress;
+				taskArgs.push_back(args);
 			}
-			i -= count;
 		}
-		return NULL;
+		TaskGroupHandle taskGroup;
+		for (uint32_t i = 0; i < taskCount; i++) {
+			Task task;
+			task.userData = &taskArgs[i];
+			task.func = runParameterizeChartsJob;
+			taskScheduler->run(&taskGroup, task);
+		}
+		taskScheduler->wait(&taskGroup);
+		if (progress.cancel)
+			return false;
+		// Save original texcoords so PackCharts can be called multiple times (packing overwrites the texcoords).
+		const uint32_t nCharts = chartCount();
+		m_originalChartTexcoords.resize(nCharts);
+		for (uint32_t i = 0; i < nCharts; i++) {
+			const Mesh *mesh = chartAt(i)->mesh();
+			m_originalChartTexcoords[i].resize(mesh->vertexCount());
+			for (uint32_t j = 0; j < mesh->vertexCount(); j++)
+				m_originalChartTexcoords[i][j] = mesh->texcoord(j);
+		}
+		m_chartsParameterized = true;
+		return true;
 	}
 
-	// Add mesh charts and takes ownership.
-	// Extract the charts and add to this atlas.
-	void addMeshCharts(MeshCharts *meshCharts)
+	void restoreOriginalChartTexcoords()
 	{
-		m_meshChartsArray.push_back(meshCharts);
+		const uint32_t nCharts = chartCount();
+		for (uint32_t i = 0; i < nCharts; i++) {
+			Mesh *mesh = chartAt(i)->mesh();
+			for (uint32_t j = 0; j < mesh->vertexCount(); j++)
+				mesh->texcoord(j) = m_originalChartTexcoords[i][j];
+		}
 	}
 
-	void extractCharts(const halfedge::Mesh *mesh)
+private:
+	std::mutex m_addMeshMutex;
+	bool m_chartsComputed;
+	bool m_chartsParameterized;
+	Array<ChartGroup *> m_chartGroups;
+	Array<uint32_t> m_chartGroupSourceMeshes;
+	Array<Array<Vector2> > m_originalChartTexcoords;
+};
+
+} // namespace param
+
+namespace pack {
+
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+const uint8_t TGA_TYPE_RGB = 2;
+const uint8_t TGA_ORIGIN_UPPER = 0x20;
+
+#pragma pack(push, 1)
+struct TgaHeader
+{
+	uint8_t id_length;
+	uint8_t colormap_type;
+	uint8_t image_type;
+	uint16_t colormap_index;
+	uint16_t colormap_length;
+	uint8_t colormap_size;
+	uint16_t x_origin;
+	uint16_t y_origin;
+	uint16_t width;
+	uint16_t height;
+	uint8_t pixel_size;
+	uint8_t flags;
+	enum { Size = 18 };
+};
+#pragma pack(pop)
+
+static void WriteTga(const char *filename, const uint8_t *data, uint32_t width, uint32_t height)
+{
+	XA_DEBUG_ASSERT(sizeof(TgaHeader) == TgaHeader::Size);
+	FILE *f;
+	XA_FOPEN(f, filename, "wb");
+	if (!f)
+		return;
+	TgaHeader tga;
+	tga.id_length = 0;
+	tga.colormap_type = 0;
+	tga.image_type = TGA_TYPE_RGB;
+	tga.colormap_index = 0;
+	tga.colormap_length = 0;
+	tga.colormap_size = 0;
+	tga.x_origin = 0;
+	tga.y_origin = 0;
+	tga.width = (uint16_t)width;
+	tga.height = (uint16_t)height;
+	tga.pixel_size = 24;
+	tga.flags = TGA_ORIGIN_UPPER;
+	fwrite(&tga, sizeof(TgaHeader), 1, f);
+	fwrite(data, sizeof(uint8_t), width * height * 3, f);
+	fclose(f);
+}
+#endif
+
+class AtlasImage
+{
+public:
+	AtlasImage(uint32_t width, uint32_t height) : m_width(width), m_height(height)
 	{
-		MeshCharts *meshCharts = new MeshCharts(mesh);
-		meshCharts->extractCharts();
-		addMeshCharts(meshCharts);
+		m_data.resize(m_width * m_height);
+		memset(m_data.data(), 0, sizeof(uint32_t) * m_data.size());
 	}
 
-	void computeCharts(const halfedge::Mesh *mesh, const CharterOptions &options, const std::vector<uint32_t> &unchartedMaterialArray)
+	void resize(uint32_t width, uint32_t height)
 	{
-		MeshCharts *meshCharts = new MeshCharts(mesh);
-		meshCharts->computeCharts(options, unchartedMaterialArray);
-		addMeshCharts(meshCharts);
+		Array<uint32_t> data;
+		data.resize(width * height);
+		memset(data.data(), 0, sizeof(uint32_t) * data.size());
+		for (uint32_t y = 0; y < min(m_height, height); y++)
+			memcpy(&data[y * width], &m_data[y * m_width], min(m_width, width) * sizeof(uint32_t));
+		m_width = width;
+		m_height = height;
+		swap(m_data, data);
 	}
 
-	void parameterizeCharts()
+	void addChart(uint32_t chartIndex, const BitImage *image, bool imageHasPadding, int atlas_w, int atlas_h, int offset_x, int offset_y)
 	{
-		for (uint32_t i = 0; i < m_meshChartsArray.size(); i++) {
-			m_meshChartsArray[i]->parameterizeCharts();
+		const int w = image->width();
+		const int h = image->height();
+		for (int y = 0; y < h; y++) {
+			const int yy = y + offset_y;
+			if (yy < 0)
+				continue;
+			for (int x = 0; x < w; x++) {
+				const int xx = x + offset_x;
+				if (xx >= 0 && xx < atlas_w && yy < atlas_h && image->bitAt(x, y)) {
+					const uint32_t dataOffset = xx + yy * m_width;
+					if (m_data[dataOffset] != 0)
+						continue;
+					uint32_t value = chartIndex | kImageHasChartIndexBit;
+					if (imageHasPadding)
+						value |= kImageIsPaddingBit;
+					m_data[dataOffset] = value;
+				}
+			}
+		}
+	}
+
+	void copyTo(uint32_t *dest, uint32_t destWidth, uint32_t destHeight) const
+	{
+		for (uint32_t y = 0; y < destHeight; y++)
+			memcpy(&dest[y * destWidth], &m_data[y * m_width], destWidth * sizeof(uint32_t));
+	}
+
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+	void writeTga(const char *filename, uint32_t width, uint32_t height) const
+	{
+		Array<uint8_t> image;
+		image.resize(width * height * 3);
+		for (uint32_t y = 0; y < height; y++) {
+			if (y >= m_height)
+				continue;
+			for (uint32_t x = 0; x < width; x++) {
+				if (x >= m_width)
+					continue;
+				const uint32_t data = m_data[x + y * m_width];
+				if (!(data & kImageHasChartIndexBit))
+					continue;
+				const uint32_t chartIndex = data & kImageChartIndexMask;
+				uint8_t *color = &image[(x + y * width) * 3];
+				if (data & kImageIsPaddingBit) {
+					color[0] = 255;
+					color[1] = 0;
+					color[2] = 255;
+				} else {
+					const int mix = 192;
+					srand((unsigned int)chartIndex);
+					color[0] = uint8_t((rand() % 255 + mix) * 0.5f);
+					color[1] = uint8_t((rand() % 255 + mix) * 0.5f);
+					color[2] = uint8_t((rand() % 255 + mix) * 0.5f);
+				}
+			}
 		}
+		WriteTga(filename, image.data(), width, height);
 	}
+#endif
 
 private:
-	std::vector<MeshCharts *> m_meshChartsArray;
+	uint32_t m_width, m_height;
+	Array<uint32_t> m_data;
 };
 
-struct AtlasPacker
+struct Chart
+{
+	int32_t atlasIndex;
+	uint32_t material;
+	uint32_t indexCount;
+	const uint32_t *indices;
+	float parametricArea;
+	float surfaceArea;
+	Vector2 *vertices;
+	uint32_t vertexCount;
+	Array<uint32_t> uniqueVertices;
+	bool allowRotate;
+	// bounding box
+	Vector2 majorAxis, minorAxis, minCorner, maxCorner;
+
+	Vector2 &uniqueVertexAt(uint32_t v) { return uniqueVertices.isEmpty() ? vertices[v] : vertices[uniqueVertices[v]]; }
+	uint32_t uniqueVertexCount() const { return uniqueVertices.isEmpty() ? vertexCount : uniqueVertices.size(); }
+};
+
+struct Atlas
 {
-	AtlasPacker(Atlas *atlas) : m_atlas(atlas), m_width(0), m_height(0)
+	~Atlas()
 	{
-		// Save the original uvs.
-		m_originalChartUvs.resize(m_atlas->chartCount());
-		for (uint32_t i = 0; i < m_atlas->chartCount(); i++) {
-			const halfedge::Mesh *mesh = atlas->chartAt(i)->chartMesh();
-			m_originalChartUvs[i].resize(mesh->vertexCount());
-			for (uint32_t j = 0; j < mesh->vertexCount(); j++)
-				m_originalChartUvs[i][j] = mesh->vertexAt(j)->tex;
+		for (uint32_t i = 0; i < m_bitImages.size(); i++) {
+			m_bitImages[i]->~BitImage();
+			XA_FREE(m_bitImages[i]);
+		}
+		for (uint32_t i = 0; i < m_charts.size(); i++) {
+			m_charts[i]->~Chart();
+			XA_FREE(m_charts[i]);
 		}
 	}
 
 	uint32_t getWidth() const { return m_width; }
 	uint32_t getHeight() const { return m_height; }
+	uint32_t getNumAtlases() const { return m_bitImages.size(); }
+	float getTexelsPerUnit() const { return m_texelsPerUnit; }
+	const Chart *getChart(uint32_t index) const { return m_charts[index]; }
+	uint32_t getChartCount() const { return m_charts.size(); }
+	const Array<AtlasImage *> &getImages() const { return m_atlasImages; }
+	float getUtilization(uint32_t atlas) const { return m_utilization[atlas]; }
+
+	void addChart(param::Chart *paramChart)
+	{
+		Mesh *mesh = paramChart->mesh();
+		Chart *chart = XA_NEW(MemTag::Default, Chart);
+		chart->atlasIndex = -1;
+		chart->material = 0;
+		chart->indexCount = mesh->indexCount();
+		chart->indices = mesh->indices();
+		chart->parametricArea = paramChart->computeParametricArea();
+		if (chart->parametricArea < kAreaEpsilon) {
+			// When the parametric area is too small we use a rough approximation to prevent divisions by very small numbers.
+			const Vector2 bounds = paramChart->computeParametricBounds();
+			chart->parametricArea = bounds.x * bounds.y;
+		}
+		chart->surfaceArea = paramChart->computeSurfaceArea();
+		chart->vertices = mesh->texcoords();
+		chart->vertexCount = mesh->vertexCount();
+		chart->allowRotate = true;
+		// Compute list of boundary vertices.
+		Array<Vector2> boundary;
+		boundary.reserve(16);
+		for (uint32_t v = 0; v < chart->vertexCount; v++) {
+			if (mesh->isBoundaryVertex(v))
+				boundary.push_back(mesh->texcoord(v));
+		}
+		XA_DEBUG_ASSERT(boundary.size() > 0);
+		// Compute bounding box of chart.
+		m_boundingBox.compute(boundary.data(), boundary.size(), mesh->texcoords(), mesh->vertexCount());
+		chart->majorAxis = m_boundingBox.majorAxis();
+		chart->minorAxis = m_boundingBox.minorAxis();
+		chart->minCorner = m_boundingBox.minCorner();
+		chart->maxCorner = m_boundingBox.maxCorner();
+		m_charts.push_back(chart);
+	}
+
+	void addUvMeshCharts(UvMeshInstance *mesh)
+	{
+		BitArray vertexUsed(mesh->texcoords.size());
+		Array<Vector2> boundary;
+		boundary.reserve(16);
+		for (uint32_t c = 0; c < mesh->mesh->charts.size(); c++) {
+			UvMeshChart *uvChart = mesh->mesh->charts[c];
+			Chart *chart = XA_NEW(MemTag::Default, Chart);
+			chart->atlasIndex = -1;
+			chart->material = uvChart->material;
+			chart->indexCount = uvChart->indices.size();
+			chart->indices = uvChart->indices.data();
+			chart->vertices = mesh->texcoords.data();
+			chart->vertexCount = mesh->texcoords.size();
+			chart->allowRotate = mesh->rotateCharts;
+			// Find unique vertices.
+			vertexUsed.clearAll();
+			for (uint32_t i = 0; i < chart->indexCount; i++) {
+				const uint32_t vertex = chart->indices[i];
+				if (!vertexUsed.bitAt(vertex)) {
+					vertexUsed.setBitAt(vertex);
+					chart->uniqueVertices.push_back(vertex);
+				}
+			}
+			// Compute parametric and surface areas.
+			chart->parametricArea = 0.0f;
+			for (uint32_t f = 0; f < chart->indexCount / 3; f++) {
+				const Vector2 &v1 = chart->vertices[chart->indices[f * 3 + 0]];
+				const Vector2 &v2 = chart->vertices[chart->indices[f * 3 + 1]];
+				const Vector2 &v3 = chart->vertices[chart->indices[f * 3 + 2]];
+				chart->parametricArea += fabsf(triangleArea(v1, v2, v3));
+			}
+			chart->parametricArea *= 0.5f;
+			chart->surfaceArea = chart->parametricArea; // Identical for UV meshes.
+			if (chart->parametricArea < kAreaEpsilon) {
+				// When the parametric area is too small we use a rough approximation to prevent divisions by very small numbers.
+				Vector2 minCorner(FLT_MAX, FLT_MAX);
+				Vector2 maxCorner(-FLT_MAX, -FLT_MAX);
+				for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++) {
+					minCorner = min(minCorner, chart->uniqueVertexAt(v));
+					maxCorner = max(maxCorner, chart->uniqueVertexAt(v));
+				}
+				const Vector2 bounds = (maxCorner - minCorner) * 0.5f;
+				chart->parametricArea = bounds.x * bounds.y;
+			}
+			// Compute list of boundary vertices.
+			// Using all unique vertices for simplicity, can compute real boundaries if this is too slow.
+			boundary.clear();
+			for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++)
+				boundary.push_back(chart->uniqueVertexAt(v));
+			XA_DEBUG_ASSERT(boundary.size() > 0);
+			// Compute bounding box of chart.
+			m_boundingBox.compute(boundary.data(), boundary.size(), boundary.data(), boundary.size());
+			chart->majorAxis = m_boundingBox.majorAxis();
+			chart->minorAxis = m_boundingBox.minorAxis();
+			chart->minCorner = m_boundingBox.minCorner();
+			chart->maxCorner = m_boundingBox.maxCorner();
+			m_charts.push_back(chart);
+		}
+	}
 
 	// Pack charts in the smallest possible rectangle.
-	void packCharts(const PackerOptions &options)
-	{
-		const uint32_t chartCount = m_atlas->chartCount();
-		if (chartCount == 0) return;
-		float texelsPerUnit = 1;
-		if (options.method == PackMethod::TexelArea)
-			texelsPerUnit = options.texelArea;
-		for (int iteration = 0;; iteration++) {
-			m_rand = MTRand();
-			std::vector<float> chartOrderArray(chartCount);
-			std::vector<Vector2> chartExtents(chartCount);
+	bool packCharts(const PackOptions &options, ProgressFunc progressFunc, void *progressUserData)
+	{
+		if (progressFunc) {
+			if (!progressFunc(ProgressCategory::PackCharts, 0, progressUserData))
+				return false;
+		}
+		const uint32_t chartCount = m_charts.size();
+		XA_PRINT("Packing %u charts\n", chartCount);
+		if (chartCount == 0) {
+			if (progressFunc) {
+				if (!progressFunc(ProgressCategory::PackCharts, 100, progressUserData))
+					return false;
+			}
+			return true;
+		}
+		uint32_t resolution = options.resolution;
+		m_texelsPerUnit = options.texelsPerUnit;
+		if (resolution <= 0 || m_texelsPerUnit <= 0) {
+			if (resolution <= 0 && m_texelsPerUnit <= 0)
+				resolution = 1024;
 			float meshArea = 0;
-			for (uint32_t c = 0; c < chartCount; c++) {
-				Chart *chart = m_atlas->chartAt(c);
-				if (!chart->isVertexMapped() && !chart->isDisk()) {
-					chartOrderArray[c] = 0;
-					// Skip non-disks.
-					continue;
-				}
-				Vector2 extents(0.0f);
-				if (chart->isVertexMapped()) {
-					// Arrange vertices in a rectangle.
-					extents.x = float(chart->vertexMapWidth);
-					extents.y = float(chart->vertexMapHeight);
+			for (uint32_t c = 0; c < chartCount; c++)
+				meshArea += m_charts[c]->surfaceArea;
+			if (resolution <= 0) {
+				// Estimate resolution based on the mesh surface area and given texel scale.
+				const float texelCount = max(1.0f, meshArea * square(m_texelsPerUnit) / 0.75f); // Assume 75% utilization.
+				resolution = max(1u, nextPowerOfTwo(uint32_t(sqrtf(texelCount))));
+			}
+			if (m_texelsPerUnit <= 0) {
+				// Estimate a suitable texelsPerUnit to fit the given resolution.
+				const float texelCount = max(1.0f, meshArea / 0.75f); // Assume 75% utilization.
+				m_texelsPerUnit = sqrtf((resolution * resolution) / texelCount);
+				XA_PRINT("   Estimating texelsPerUnit as %g\n", m_texelsPerUnit);
+			}
+		}
+		Array<float> chartOrderArray;
+		chartOrderArray.resize(chartCount);
+		Array<Vector2> chartExtents;
+		chartExtents.resize(chartCount);
+		float minChartPerimeter = FLT_MAX, maxChartPerimeter = 0.0f;
+		for (uint32_t c = 0; c < chartCount; c++) {
+			Chart *chart = m_charts[c];
+			//chartOrderArray[c] = chart.surfaceArea;
+			// Compute chart scale
+			float scale = (chart->surfaceArea / chart->parametricArea) * m_texelsPerUnit;
+			if (chart->parametricArea == 0) { // < kAreaEpsilon)
+				scale = 0;
+			}
+			XA_ASSERT(isFinite(scale));
+			// Sort charts by perimeter. @@ This is sometimes producing somewhat unexpected results. Is this right?
+			//chartOrderArray[c] = ((chart->maxCorner.x - chart->minCorner.x) + (chart->maxCorner.y - chart->minCorner.y)) * scale;
+			// Translate, rotate and scale vertices. Compute extents.
+			Vector2 minCorner(FLT_MAX, FLT_MAX);
+			if (!chart->allowRotate) {
+				for (uint32_t i = 0; i < chart->uniqueVertexCount(); i++)
+					minCorner = min(minCorner, chart->uniqueVertexAt(i));
+			}
+			Vector2 extents(0.0f);
+			for (uint32_t i = 0; i < chart->uniqueVertexCount(); i++) {
+				Vector2 &texcoord = chart->uniqueVertexAt(i);
+				if (chart->allowRotate) {
+					const float x = dot(texcoord, chart->majorAxis);
+					const float y = dot(texcoord, chart->minorAxis);
+					texcoord.x = x;
+					texcoord.y = y;
+					texcoord -= chart->minCorner;
 				} else {
-					// Compute surface area to sort charts.
-					float chartArea = chart->computeSurfaceArea();
-					meshArea += chartArea;
-					//chartOrderArray[c] = chartArea;
-					// Compute chart scale
-					float parametricArea = fabsf(chart->computeParametricArea());    // @@ There doesn't seem to be anything preventing parametric area to be negative.
-					if (parametricArea < NV_EPSILON) {
-						// When the parametric area is too small we use a rough approximation to prevent divisions by very small numbers.
-						Vector2 bounds = chart->computeParametricBounds();
-						parametricArea = bounds.x * bounds.y;
-					}
-					float scale = (chartArea / parametricArea) * texelsPerUnit;
-					if (parametricArea == 0) { // < NV_EPSILON)
-						scale = 0;
-					}
-					xaAssert(std::isfinite(scale));
-					// Compute bounding box of chart.
-					Vector2 majorAxis, minorAxis, origin, end;
-					computeBoundingBox(chart, &majorAxis, &minorAxis, &origin, &end);
-					xaAssert(isFinite(majorAxis) && isFinite(minorAxis) && isFinite(origin));
-					// Sort charts by perimeter. @@ This is sometimes producing somewhat unexpected results. Is this right?
-					//chartOrderArray[c] = ((end.x - origin.x) + (end.y - origin.y)) * scale;
-					// Translate, rotate and scale vertices. Compute extents.
-					halfedge::Mesh *mesh = chart->chartMesh();
-					const uint32_t vertexCount = mesh->vertexCount();
-					for (uint32_t i = 0; i < vertexCount; i++) {
-						halfedge::Vertex *vertex = mesh->vertexAt(i);
-						//Vector2 t = vertex->tex - origin;
-						Vector2 tmp;
-						tmp.x = dot(vertex->tex, majorAxis);
-						tmp.y = dot(vertex->tex, minorAxis);
-						tmp -= origin;
-						tmp *= scale;
-						if (tmp.x < 0 || tmp.y < 0) {
-							xaPrint("tmp: %f %f\n", tmp.x, tmp.y);
-							xaPrint("scale: %f\n", scale);
-							xaPrint("origin: %f %f\n", origin.x, origin.y);
-							xaPrint("majorAxis: %f %f\n", majorAxis.x, majorAxis.y);
-							xaPrint("minorAxis: %f %f\n", minorAxis.x, minorAxis.y);
-							xaDebugAssert(false);
-						}
-						//xaAssert(tmp.x >= 0 && tmp.y >= 0);
-						vertex->tex = tmp;
-						xaAssert(std::isfinite(vertex->tex.x) && std::isfinite(vertex->tex.y));
-						extents = max(extents, tmp);
-					}
-					xaDebugAssert(extents.x >= 0 && extents.y >= 0);
-					// Limit chart size.
-					if (extents.x > 1024 || extents.y > 1024) {
-						float limit = std::max(extents.x, extents.y);
-						scale = 1024 / (limit + 1);
-						for (uint32_t i = 0; i < vertexCount; i++) {
-							halfedge::Vertex *vertex = mesh->vertexAt(i);
-							vertex->tex *= scale;
-						}
-						extents *= scale;
-						xaDebugAssert(extents.x <= 1024 && extents.y <= 1024);
-					}
-					// Scale the charts to use the entire texel area available. So, if the width is 0.1 we could scale it to 1 without increasing the lightmap usage and making a better
-					// use of it. In many cases this also improves the look of the seams, since vertices on the chart boundaries have more chances of being aligned with the texel centers.
-					float scale_x = 1.0f;
-					float scale_y = 1.0f;
-					float divide_x = 1.0f;
-					float divide_y = 1.0f;
-					if (extents.x > 0) {
-						int cw = ftoi_ceil(extents.x);
-						if (options.blockAlign && chart->blockAligned) {
-							// Align all chart extents to 4x4 blocks, but taking padding into account.
-							if (options.conservative) {
-								cw = align(cw + 2, 4) - 2;
-							} else {
-								cw = align(cw + 1, 4) - 1;
-							}
-						}
-						scale_x = (float(cw) - NV_EPSILON);
-						divide_x = extents.x;
-						extents.x = float(cw);
-					}
-					if (extents.y > 0) {
-						int ch = ftoi_ceil(extents.y);
-						if (options.blockAlign && chart->blockAligned) {
-							// Align all chart extents to 4x4 blocks, but taking padding into account.
-							if (options.conservative) {
-								ch = align(ch + 2, 4) - 2;
-							} else {
-								ch = align(ch + 1, 4) - 1;
-							}
-						}
-						scale_y = (float(ch) - NV_EPSILON);
-						divide_y = extents.y;
-						extents.y = float(ch);
-					}
-					for (uint32_t v = 0; v < vertexCount; v++) {
-						halfedge::Vertex *vertex = mesh->vertexAt(v);
-						vertex->tex.x /= divide_x;
-						vertex->tex.y /= divide_y;
-						vertex->tex.x *= scale_x;
-						vertex->tex.y *= scale_y;
-						xaAssert(std::isfinite(vertex->tex.x) && std::isfinite(vertex->tex.y));
-					}
+					texcoord -= minCorner;
+				}
+				texcoord *= scale;
+				XA_DEBUG_ASSERT(texcoord.x >= 0 && texcoord.y >= 0);
+				XA_DEBUG_ASSERT(isFinite(texcoord.x) && isFinite(texcoord.y));
+				extents = max(extents, texcoord);
+			}
+			XA_DEBUG_ASSERT(extents.x >= 0 && extents.y >= 0);
+			// Limit chart size.
+			const float maxChartSize = (float)options.maxChartSize;
+			if (extents.x > maxChartSize || extents.y > maxChartSize) {
+				const float limit = max(extents.x, extents.y);
+				scale = maxChartSize / (limit + 1.0f);
+				for (uint32_t i = 0; i < chart->uniqueVertexCount(); i++)
+					chart->uniqueVertexAt(i) *= scale;
+				extents *= scale;
+				XA_DEBUG_ASSERT(extents.x <= maxChartSize && extents.y <= maxChartSize);
+			}
+			// Scale the charts to use the entire texel area available. So, if the width is 0.1 we could scale it to 1 without increasing the lightmap usage and making a better
+			// use of it. In many cases this also improves the look of the seams, since vertices on the chart boundaries have more chances of being aligned with the texel centers.
+			float scale_x = 1.0f;
+			float scale_y = 1.0f;
+			float divide_x = 1.0f;
+			float divide_y = 1.0f;
+			if (extents.x > 0) {
+				int cw = ftoi_ceil(extents.x);
+				if (options.blockAlign) {
+					// Align all chart extents to 4x4 blocks, but taking padding into account.
+					cw = align(cw + 2, 4) - 2;
+				}
+				scale_x = (float(cw) - kEpsilon);
+				divide_x = extents.x;
+				extents.x = float(cw);
+			}
+			if (extents.y > 0) {
+				int ch = ftoi_ceil(extents.y);
+				if (options.blockAlign) {
+					// Align all chart extents to 4x4 blocks, but taking padding into account.
+					ch = align(ch + 2, 4) - 2;
+				}
+				scale_y = (float(ch) - kEpsilon);
+				divide_y = extents.y;
+				extents.y = float(ch);
+			}
+			for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++) {
+				Vector2 &texcoord = chart->uniqueVertexAt(v);
+				texcoord.x /= divide_x;
+				texcoord.y /= divide_y;
+				texcoord.x *= scale_x;
+				texcoord.y *= scale_y;
+				XA_ASSERT(isFinite(texcoord.x) && isFinite(texcoord.y));
+			}
+			chartExtents[c] = extents;
+			// Sort charts by perimeter.
+			chartOrderArray[c] = extents.x + extents.y;
+			minChartPerimeter = min(minChartPerimeter, chartOrderArray[c]);
+			maxChartPerimeter = max(maxChartPerimeter, chartOrderArray[c]);
+		}
+		// Sort charts by perimeter.
+		m_radix = RadixSort();
+		m_radix.sort(chartOrderArray);
+		const uint32_t *ranks = m_radix.ranks();
+		// Divide chart perimeter range into buckets.
+		const float chartPerimeterBucketSize = (maxChartPerimeter - minChartPerimeter) / 16.0f;
+		uint32_t currentChartBucket = 0;
+		Array<Vector2i> chartStartPositions; // per atlas
+		chartStartPositions.push_back(Vector2i(0, 0));
+		// Pack sorted charts.
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+		const bool createImage = true;
+#else
+		const bool createImage = options.createImage;
+#endif
+		BitImage chartBitImage, chartBitImageRotated;
+		int atlasWidth = 0, atlasHeight = 0;
+		const bool resizableAtlas = !(options.resolution > 0 && options.texelsPerUnit > 0.0f);
+		int progress = 0;
+		for (uint32_t i = 0; i < chartCount; i++) {
+			uint32_t c = ranks[chartCount - i - 1]; // largest chart first
+			Chart *chart = m_charts[c];
+			// @@ Add special cases for dot and line charts. @@ Lightmap rasterizer also needs to handle these special cases.
+			// @@ We could also have a special case for chart quads. If the quad surface <= 4 texels, align vertices with texel centers and do not add padding. May be very useful for foliage.
+			// @@ In general we could reduce the padding of all charts by one texel by using a rasterizer that takes into account the 2-texel footprint of the tent bilinear filter. For example,
+			// if we have a chart that is less than 1 texel wide currently we add one texel to the left and one texel to the right creating a 3-texel-wide bitImage. However, if we know that the
+			// chart is only 1 texel wide we could align it so that it only touches the footprint of two texels:
+			//      |   |      <- Touches texels 0, 1 and 2.
+			//    |   |        <- Only touches texels 0 and 1.
+			// \   \ / \ /   /
+			//  \   X   X   /
+			//   \ / \ / \ /
+			//    V   V   V
+			//    0   1   2
+			XA_PROFILE_START(packChartsRasterize)
+			// Leave room for padding.
+			chartBitImage.resize(ftoi_ceil(chartExtents[c].x) + 1 + options.padding * 2, ftoi_ceil(chartExtents[c].y) + 1 + options.padding * 2, true);
+			if (chart->allowRotate)
+				chartBitImageRotated.resize(chartBitImage.height(), chartBitImage.width(), true);
+			// Rasterize chart faces.
+			const uint32_t faceCount = chart->indexCount / 3;
+			for (uint32_t f = 0; f < faceCount; f++) {
+				// Offset vertices by padding.
+				Vector2 vertices[3];
+				for (uint32_t v = 0; v < 3; v++)
+					vertices[v] = chart->vertices[chart->indices[f * 3 + v]] + Vector2(0.5f) + Vector2(float(options.padding));
+				DrawTriangleCallbackArgs args;
+				args.chartBitImage = &chartBitImage;
+				args.chartBitImageRotated = chart->allowRotate ? &chartBitImageRotated : nullptr;
+				raster::drawTriangle(Vector2((float)chartBitImage.width(), (float)chartBitImage.height()), vertices, drawTriangleCallback, &args);
+			}
+			// Expand chart by padding pixels. (dilation)
+			BitImage chartBitImageNoPadding(chartBitImage), chartBitImageNoPaddingRotated(chartBitImageRotated);
+			if (options.padding > 0) {
+				XA_PROFILE_START(packChartsDilate)
+				chartBitImage.dilate(options.padding);
+				if (chart->allowRotate)
+					chartBitImageRotated.dilate(options.padding);
+				XA_PROFILE_END(packChartsDilate)
+			}
+			XA_PROFILE_END(packChartsRasterize)
+			// Update brute force bucketing.
+			if (options.bruteForce) {
+				if (chartOrderArray[c] > minChartPerimeter && chartOrderArray[c] <= maxChartPerimeter - (chartPerimeterBucketSize * (currentChartBucket + 1))) {
+					// Moved to a smaller bucket, reset start location.
+					for (uint32_t j = 0; j < chartStartPositions.size(); j++)
+						chartStartPositions[j] = Vector2i(0, 0);
+					currentChartBucket++;
 				}
-				chartExtents[c] = extents;
-				// Sort charts by perimeter.
-				chartOrderArray[c] = extents.x + extents.y;
-			}
-			// @@ We can try to improve compression of small charts by sorting them by proximity like we do with vertex samples.
-			// @@ How to do that? One idea: compute chart centroid, insert into grid, compute morton index of the cell, sort based on morton index.
-			// @@ We would sort by morton index, first, then quantize the chart sizes, so that all small charts have the same size, and sort by size preserving the morton order.
-			//xaPrint("Sorting charts.\n");
-			// Sort charts by area.
-			m_radix = RadixSort();
-			m_radix.sort(chartOrderArray);
-			const uint32_t *ranks = m_radix.ranks();
-			// First iteration - guess texelsPerUnit.
-			if (options.method != PackMethod::TexelArea && iteration == 0) {
-				// Estimate size of the map based on the mesh surface area and given texel scale.
-				const float texelCount = std::max(1.0f, meshArea * square(texelsPerUnit) / 0.75f); // Assume 75% utilization.
-				texelsPerUnit = sqrt((options.resolution * options.resolution) / texelCount);
-				resetUvs();
-				continue;
 			}
-			// Init bit map.
-			m_bitmap.clearAll();
-			m_bitmap.resize(options.resolution, options.resolution, false);
-			int w = 0;
-			int h = 0;
-			// Add sorted charts to bitmap.
-			for (uint32_t i = 0; i < chartCount; i++) {
-				uint32_t c = ranks[chartCount - i - 1]; // largest chart first
-				Chart *chart = m_atlas->chartAt(c);
-				if (!chart->isVertexMapped() && !chart->isDisk()) continue;
-				//float scale_x = 1;
-				//float scale_y = 1;
-				BitMap chart_bitmap;
-				if (chart->isVertexMapped()) {
-					chart->blockAligned = false;
-					// Init all bits to 1.
-					chart_bitmap.resize(ftoi_ceil(chartExtents[c].x), ftoi_ceil(chartExtents[c].y), /*initValue=*/true);
-					// @@ Another alternative would be to try to map each vertex to a different texel trying to fill all the available unused texels.
-				} else {
-					// @@ Add special cases for dot and line charts. @@ Lightmap rasterizer also needs to handle these special cases.
-					// @@ We could also have a special case for chart quads. If the quad surface <= 4 texels, align vertices with texel centers and do not add padding. May be very useful for foliage.
-					// @@ In general we could reduce the padding of all charts by one texel by using a rasterizer that takes into account the 2-texel footprint of the tent bilinear filter. For example,
-					// if we have a chart that is less than 1 texel wide currently we add one texel to the left and one texel to the right creating a 3-texel-wide bitmap. However, if we know that the
-					// chart is only 1 texel wide we could align it so that it only touches the footprint of two texels:
-					//      |   |      <- Touches texels 0, 1 and 2.
-					//    |   |        <- Only touches texels 0 and 1.
-					// \   \ / \ /   /
-					//  \   X   X   /
-					//   \ / \ / \ /
-					//    V   V   V
-					//    0   1   2
-					if (options.conservative) {
-						// Init all bits to 0.
-						chart_bitmap.resize(ftoi_ceil(chartExtents[c].x) + 1 + options.padding, ftoi_ceil(chartExtents[c].y) + 1 + options.padding, /*initValue=*/false);  // + 2 to add padding on both sides.
-						// Rasterize chart and dilate.
-						drawChartBitmapDilate(chart, &chart_bitmap, options.padding);
-					} else {
-						// Init all bits to 0.
-						chart_bitmap.resize(ftoi_ceil(chartExtents[c].x) + 1, ftoi_ceil(chartExtents[c].y) + 1, /*initValue=*/false);  // Add half a texels on each side.
-						// Rasterize chart and dilate.
-						drawChartBitmap(chart, &chart_bitmap, Vector2(1), Vector2(0.5));
-					}
+			// Find a location to place the chart in the atlas.
+			uint32_t currentAtlas = 0;
+			int best_x = 0, best_y = 0;
+			int best_cw = 0, best_ch = 0;
+			int best_r = 0;
+			for (;;)
+			{
+				bool firstChartInBitImage = false;
+				if (currentAtlas + 1 > m_bitImages.size()) {
+					// Chart doesn't fit in the current bitImage, create a new one.
+					BitImage *bi = XA_NEW(MemTag::Default, BitImage);
+					bi->resize(resolution, resolution, true);
+					m_bitImages.push_back(bi);
+					firstChartInBitImage = true;
+					if (createImage)
+						m_atlasImages.push_back(XA_NEW(MemTag::Default, AtlasImage, resolution, resolution));
+					// Start positions are per-atlas, so create a new one of those too.
+					chartStartPositions.push_back(Vector2i(0, 0));
 				}
-				int best_x, best_y;
-				int best_cw, best_ch;   // Includes padding now.
-				int best_r;
-				findChartLocation(options.quality, &chart_bitmap, chartExtents[c], w, h, &best_x, &best_y, &best_cw, &best_ch, &best_r, chart->blockAligned);
-				/*if (w < best_x + best_cw || h < best_y + best_ch)
-				{
-					xaPrint("Resize extents to (%d, %d).\n", best_x + best_cw, best_y + best_ch);
-				}*/
-				// Update parametric extents.
-				w = std::max(w, best_x + best_cw);
-				h = std::max(h, best_y + best_ch);
-				w = align(w, 4);
-				h = align(h, 4);
-				// Resize bitmap if necessary.
-				if (uint32_t(w) > m_bitmap.width() || uint32_t(h) > m_bitmap.height()) {
-					//xaPrint("Resize bitmap (%d, %d).\n", nextPowerOfTwo(w), nextPowerOfTwo(h));
-					m_bitmap.resize(nextPowerOfTwo(uint32_t(w)), nextPowerOfTwo(uint32_t(h)), false);
+				XA_PROFILE_START(packChartsFindLocation)
+				const bool foundLocation = findChartLocation(chartStartPositions[currentAtlas], options.bruteForce, m_bitImages[currentAtlas], &chartBitImage, &chartBitImageRotated, atlasWidth, atlasHeight, &best_x, &best_y, &best_cw, &best_ch, &best_r, options.blockAlign, resizableAtlas, chart->allowRotate);
+				XA_PROFILE_END(packChartsFindLocation)
+				if (firstChartInBitImage && !foundLocation) {
+					// Chart doesn't fit in an empty, newly allocated bitImage. texelsPerUnit must be too large for the resolution.
+					XA_ASSERT(true && "chart doesn't fit");
+					break;
+				}
+				if (resizableAtlas) {
+					XA_DEBUG_ASSERT(foundLocation);
+					break;
+				}
+				if (foundLocation)
+					break;
+				// Chart doesn't fit in the current bitImage, try the next one.
+				currentAtlas++;
+			}
+			// Update brute force start location.
+			if (options.bruteForce) {
+				// Reset start location if the chart expanded the atlas.
+				if (best_x + best_cw > atlasWidth || best_y + best_ch > atlasHeight) {
+					for (uint32_t j = 0; j < chartStartPositions.size(); j++)
+						chartStartPositions[j] = Vector2i(0, 0);
 				}
-				//xaPrint("Add chart at (%d, %d).\n", best_x, best_y);
-				addChart(&chart_bitmap, w, h, best_x, best_y, best_r);
-				//float best_angle = 2 * PI * best_r;
-				// Translate and rotate chart texture coordinates.
-				halfedge::Mesh *mesh = chart->chartMesh();
-				const uint32_t vertexCount = mesh->vertexCount();
-				for (uint32_t v = 0; v < vertexCount; v++) {
-					halfedge::Vertex *vertex = mesh->vertexAt(v);
-					Vector2 t = vertex->tex;
-					if (best_r) std::swap(t.x, t.y);
-					//vertex->tex.x = best_x + t.x * cosf(best_angle) - t.y * sinf(best_angle);
-					//vertex->tex.y = best_y + t.x * sinf(best_angle) + t.y * cosf(best_angle);
-					vertex->tex.x = best_x + t.x + 0.5f;
-					vertex->tex.y = best_y + t.y + 0.5f;
-					xaAssert(vertex->tex.x >= 0 && vertex->tex.y >= 0);
-					xaAssert(std::isfinite(vertex->tex.x) && std::isfinite(vertex->tex.y));
+				else {
+					chartStartPositions[currentAtlas] = Vector2i(best_x, best_y);
 				}
 			}
-			//w -= padding - 1; // Leave one pixel border!
-			//h -= padding - 1;
-			m_width = std::max(0, w);
-			m_height = std::max(0, h);
-			xaAssert(isAligned(m_width, 4));
-			xaAssert(isAligned(m_height, 4));
-			if (options.method == PackMethod::ExactResolution) {
-				texelsPerUnit *= sqrt((options.resolution * options.resolution) / (float)(m_width * m_height));
-				if (iteration > 1 && m_width <= options.resolution && m_height <= options.resolution) {
-					m_width = m_height = options.resolution;
-					return;
+			// Update parametric extents.
+			atlasWidth = max(atlasWidth, best_x + best_cw);
+			atlasHeight = max(atlasHeight, best_y + best_ch);
+			if (resizableAtlas) {
+				// Resize bitImage if necessary.
+				if (uint32_t(atlasWidth) > m_bitImages[0]->width() || uint32_t(atlasHeight) > m_bitImages[0]->height()) {
+					m_bitImages[0]->resize(nextPowerOfTwo(uint32_t(atlasWidth)), nextPowerOfTwo(uint32_t(atlasHeight)), false);
+					if (createImage)
+						m_atlasImages[0]->resize(m_bitImages[0]->width(), m_bitImages[0]->height());
 				}
-				resetUvs();
 			} else {
-				return;
+				atlasWidth = min((int)options.resolution, atlasWidth);
+				atlasHeight = min((int)options.resolution, atlasHeight);
+			}
+			XA_PROFILE_START(packChartsBlit)
+			addChart(m_bitImages[currentAtlas], &chartBitImage, &chartBitImageRotated, atlasWidth, atlasHeight, best_x, best_y, best_r);
+			XA_PROFILE_END(packChartsBlit)
+			if (createImage) {
+				m_atlasImages[currentAtlas]->addChart(c, best_r == 0 ? &chartBitImageNoPadding : &chartBitImageNoPaddingRotated, false, atlasWidth, atlasHeight, best_x, best_y);
+				m_atlasImages[currentAtlas]->addChart(c, best_r == 0 ? &chartBitImage : &chartBitImageRotated, true, atlasWidth, atlasHeight, best_x, best_y);
+			}
+			chart->atlasIndex = (int32_t)currentAtlas;
+			// Translate and rotate chart texture coordinates.
+			for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++) {
+				Vector2 &texcoord = chart->uniqueVertexAt(v);
+				Vector2 t = texcoord;
+				if (best_r) {
+					XA_DEBUG_ASSERT(chart->allowRotate);
+					swap(t.x, t.y);
+				}
+				texcoord.x = best_x + t.x + 0.5f;
+				texcoord.y = best_y + t.y + 0.5f;
+				XA_ASSERT(texcoord.x >= 0 && texcoord.y >= 0);
+				XA_ASSERT(isFinite(texcoord.x) && isFinite(texcoord.y));
+			}
+			if (progressFunc) {
+				const int newProgress = int((i + 1) / (float)chartCount * 100.0f);
+				if (newProgress != progress) {
+					progress = newProgress;
+					if (!progressFunc(ProgressCategory::PackCharts, progress, progressUserData))
+						return false;
+				}
 			}
 		}
-	}
-
-	float computeAtlasUtilization() const
-	{
-		const uint32_t w = m_width;
-		const uint32_t h = m_height;
-		xaDebugAssert(w <= m_bitmap.width());
-		xaDebugAssert(h <= m_bitmap.height());
-		uint32_t count = 0;
-		for (uint32_t y = 0; y < h; y++) {
-			for (uint32_t x = 0; x < w; x++) {
-				count += m_bitmap.bitAt(x, y);
+		if (resizableAtlas) {
+			m_width = max(0, atlasWidth - (int)options.padding * 2);
+			m_height = max(0, atlasHeight - (int)options.padding * 2);
+		} else {
+			m_width = m_height = options.resolution;
+		}
+		XA_PRINT("   %dx%d resolution\n", m_width, m_height);
+		m_utilization.resize(m_bitImages.size());
+		for (uint32_t i = 0; i < m_utilization.size(); i++) {
+			uint32_t count = 0;
+			for (uint32_t y = 0; y < m_height; y++) {
+				for (uint32_t x = 0; x < m_width; x++)
+					count += m_bitImages[i]->bitAt(x, y);
+			}
+			m_utilization[i] = float(count) / (m_width * m_height);
+			if (m_utilization.size() > 1) {
+				XA_PRINT("   %u: %f%% utilization\n", i, m_utilization[i] * 100.0f);
+			}
+			else {
+				XA_PRINT("   %f%% utilization\n", m_utilization[i] * 100.0f);
 			}
 		}
-		return float(count) / (w * h);
-	}
-
-private:
-	void resetUvs()
-	{
-		for (uint32_t i = 0; i < m_atlas->chartCount(); i++) {
-			halfedge::Mesh *mesh = m_atlas->chartAt(i)->chartMesh();
-			for (uint32_t j = 0; j < mesh->vertexCount(); j++)
-				mesh->vertexAt(j)->tex = m_originalChartUvs[i][j];
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+		for (uint32_t i = 0; i < m_atlasImages.size(); i++) {
+			char filename[256];
+			XA_SPRINTF(filename, sizeof(filename), "debug_atlas_image%02u.tga", i);
+			m_atlasImages[i]->writeTga(filename, m_width, m_height);
+		}
+#endif
+		if (progressFunc && progress != 100) {
+			if (!progressFunc(ProgressCategory::PackCharts, 100, progressUserData))
+				return false;
 		}
+		return true;
 	}
 
+private:
 	// IC: Brute force is slow, and random may take too much time to converge. We start inserting large charts in a small atlas. Using brute force is lame, because most of the space
 	// is occupied at this point. At the end we have many small charts and a large atlas with sparse holes. Finding those holes randomly is slow. A better approach would be to
 	// start stacking large charts as if they were tetris pieces. Once charts get small try to place them randomly. It may be interesting to try a intermediate strategy, first try
 	// along one axis and then try exhaustively along that axis.
-	void findChartLocation(int quality, const BitMap *bitmap, Vector2::Arg extents, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned)
-	{
-		int attempts = 256;
-		if (quality == 1) attempts = 4096;
-		if (quality == 2) attempts = 2048;
-		if (quality == 3) attempts = 1024;
-		if (quality == 4) attempts = 512;
-		if (quality == 0 || w * h < attempts) {
-			findChartLocation_bruteForce(bitmap, extents, w, h, best_x, best_y, best_w, best_h, best_r, blockAligned);
-		} else {
-			findChartLocation_random(bitmap, extents, w, h, best_x, best_y, best_w, best_h, best_r, attempts, blockAligned);
-		}
+	bool findChartLocation(const Vector2i &startPosition, bool bruteForce, const BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned, bool resizableAtlas, bool allowRotate)
+	{
+		const int attempts = 4096;
+		if (bruteForce || attempts >= w * h)
+			return findChartLocation_bruteForce(startPosition, atlasBitImage, chartBitImage, chartBitImageRotated, w, h, best_x, best_y, best_w, best_h, best_r, blockAligned, resizableAtlas, allowRotate);
+		return findChartLocation_random(atlasBitImage, chartBitImage, chartBitImageRotated, w, h, best_x, best_y, best_w, best_h, best_r, attempts, blockAligned, resizableAtlas, allowRotate);
 	}
 
-	void findChartLocation_bruteForce(const BitMap *bitmap, Vector2::Arg /*extents*/, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned)
+	bool findChartLocation_bruteForce(const Vector2i &startPosition, const BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned, bool resizableAtlas, bool allowRotate)
 	{
+		bool result = false;
 		const int BLOCK_SIZE = 4;
 		int best_metric = INT_MAX;
 		int step_size = blockAligned ? BLOCK_SIZE : 1;
 		// Try two different orientations.
 		for (int r = 0; r < 2; r++) {
-			int cw = bitmap->width();
-			int ch = bitmap->height();
-			if (r & 1) std::swap(cw, ch);
-			for (int y = 0; y <= h + 1; y += step_size) { // + 1 to extend atlas in case atlas full.
-				for (int x = 0; x <= w + 1; x += step_size) { // + 1 not really necessary here.
+			int cw = chartBitImage->width();
+			int ch = chartBitImage->height();
+			if (r == 1) {
+				if (allowRotate)
+					swap(cw, ch);
+				else
+					break;
+			}
+			for (int y = startPosition.y; y <= h + step_size; y += step_size) { // + 1 to extend atlas in case atlas full.
+				for (int x = (y == startPosition.y ? startPosition.x : 0); x <= w + step_size; x += step_size) { // + 1 not really necessary here.
+					if (!resizableAtlas && (x > (int)atlasBitImage->width() - cw || y > (int)atlasBitImage->height() - ch))
+						continue;
 					// Early out.
-					int area = std::max(w, x + cw) * std::max(h, y + ch);
+					int area = max(w, x + cw) * max(h, y + ch);
 					//int perimeter = max(w, x+cw) + max(h, y+ch);
-					int extents = std::max(std::max(w, x + cw), std::max(h, y + ch));
+					int extents = max(max(w, x + cw), max(h, y + ch));
 					int metric = extents * extents + area;
 					if (metric > best_metric) {
 						continue;
 					}
-					if (metric == best_metric && std::max(x, y) >= std::max(*best_x, *best_y)) {
+					if (metric == best_metric && max(x, y) >= max(*best_x, *best_y)) {
 						// If metric is the same, pick the one closest to the origin.
 						continue;
 					}
-					if (canAddChart(bitmap, w, h, x, y, r)) {
+					if (atlasBitImage->canBlit(r == 1 ? *chartBitImageRotated : *chartBitImage, x, y)) {
+						result = true;
 						best_metric = metric;
 						*best_x = x;
 						*best_y = y;
@@ -7107,241 +7238,81 @@ private:
 			}
 		}
 	done:
-		xaDebugAssert (best_metric != INT_MAX);
+		XA_DEBUG_ASSERT (best_metric != INT_MAX);
+		return result;
 	}
 
-	void findChartLocation_random(const BitMap *bitmap, Vector2::Arg /*extents*/, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, int minTrialCount, bool blockAligned)
+	bool findChartLocation_random(const BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, int minTrialCount, bool blockAligned, bool resizableAtlas, bool allowRotate)
 	{
+		bool result = false;
 		const int BLOCK_SIZE = 4;
 		int best_metric = INT_MAX;
-		for (int i = 0; i < minTrialCount || best_metric == INT_MAX; i++) {
-			int r = m_rand.getRange(1);
-			int x = m_rand.getRange(w + 1); // + 1 to extend atlas in case atlas full. We may want to use a higher number to increase probability of extending atlas.
-			int y = m_rand.getRange(h + 1); // + 1 to extend atlas in case atlas full.
+		for (int i = 0; i < minTrialCount; i++) {
+			int cw = chartBitImage->width();
+			int ch = chartBitImage->height();
+			int r = allowRotate ? m_rand.getRange(1) : 0;
+			if (r == 1)
+				swap(cw, ch);
+			// + 1 to extend atlas in case atlas full. We may want to use a higher number to increase probability of extending atlas.
+			int xRange = w + 1;
+			int yRange = h + 1;
+			if (!resizableAtlas) {
+				xRange = min(xRange, (int)atlasBitImage->width() - cw);
+				yRange = min(yRange, (int)atlasBitImage->height() - ch);
+			}
+			int x = m_rand.getRange(xRange);
+			int y = m_rand.getRange(yRange);
 			if (blockAligned) {
 				x = align(x, BLOCK_SIZE);
 				y = align(y, BLOCK_SIZE);
+				if (!resizableAtlas && (x > (int)atlasBitImage->width() - cw || y > (int)atlasBitImage->height() - ch))
+					continue; // Block alignment pushed the chart outside the atlas.
 			}
-			int cw = bitmap->width();
-			int ch = bitmap->height();
-			if (r & 1) std::swap(cw, ch);
 			// Early out.
-			int area = std::max(w, x + cw) * std::max(h, y + ch);
+			int area = max(w, x + cw) * max(h, y + ch);
 			//int perimeter = max(w, x+cw) + max(h, y+ch);
-			int extents = std::max(std::max(w, x + cw), std::max(h, y + ch));
+			int extents = max(max(w, x + cw), max(h, y + ch));
 			int metric = extents * extents + area;
 			if (metric > best_metric) {
 				continue;
 			}
-			if (metric == best_metric && std::min(x, y) > std::min(*best_x, *best_y)) {
+			if (metric == best_metric && min(x, y) > min(*best_x, *best_y)) {
 				// If metric is the same, pick the one closest to the origin.
 				continue;
 			}
-			if (canAddChart(bitmap, w, h, x, y, r)) {
+			if (atlasBitImage->canBlit(r == 1 ? *chartBitImageRotated : *chartBitImage, x, y)) {
+				result = true;
 				best_metric = metric;
 				*best_x = x;
 				*best_y = y;
 				*best_w = cw;
 				*best_h = ch;
-				*best_r = r;
+				*best_r = allowRotate ? r : 0;
 				if (area == w * h) {
 					// Chart is completely inside, do not look at any other location.
 					break;
 				}
 			}
 		}
+		return result;
 	}
 
-	void drawChartBitmapDilate(const Chart *chart, BitMap *bitmap, int padding)
-	{
-		const int w = bitmap->width();
-		const int h = bitmap->height();
-		const Vector2 extents = Vector2(float(w), float(h));
-		// Rasterize chart faces, check that all bits are not set.
-		const uint32_t faceCount = chart->faceCount();
-		for (uint32_t f = 0; f < faceCount; f++) {
-			const halfedge::Face *face = chart->chartMesh()->faceAt(f);
-			Vector2 vertices[4];
-			uint32_t edgeCount = 0;
-			for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-				if (edgeCount < 4) {
-					vertices[edgeCount] = it.vertex()->tex + Vector2(0.5) + Vector2(float(padding), float(padding));
-				}
-				edgeCount++;
-			}
-			if (edgeCount == 3) {
-				raster::drawTriangle(raster::Mode_Antialiased, extents, true, vertices, AtlasPacker::setBitsCallback, bitmap);
-			} else {
-				raster::drawQuad(raster::Mode_Antialiased, extents, true, vertices, AtlasPacker::setBitsCallback, bitmap);
-			}
-		}
-		// Expand chart by padding pixels. (dilation)
-		BitMap tmp(w, h);
-		for (int i = 0; i < padding; i++) {
-			tmp.clearAll();
-			for (int y = 0; y < h; y++) {
-				for (int x = 0; x < w; x++) {
-					bool b = bitmap->bitAt(x, y);
-					if (!b) {
-						if (x > 0) {
-							b |= bitmap->bitAt(x - 1, y);
-							if (y > 0) b |= bitmap->bitAt(x - 1, y - 1);
-							if (y < h - 1) b |= bitmap->bitAt(x - 1, y + 1);
-						}
-						if (y > 0) b |= bitmap->bitAt(x, y - 1);
-						if (y < h - 1) b |= bitmap->bitAt(x, y + 1);
-						if (x < w - 1) {
-							b |= bitmap->bitAt(x + 1, y);
-							if (y > 0) b |= bitmap->bitAt(x + 1, y - 1);
-							if (y < h - 1) b |= bitmap->bitAt(x + 1, y + 1);
-						}
-					}
-					if (b) tmp.setBitAt(x, y);
-				}
-			}
-			std::swap(tmp, *bitmap);
-		}
-	}
-
-	void drawChartBitmap(const Chart *chart, BitMap *bitmap, const Vector2 &scale, const Vector2 &offset)
+	void addChart(BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int atlas_w, int atlas_h, int offset_x, int offset_y, int r)
 	{
-		const int w = bitmap->width();
-		const int h = bitmap->height();
-		const Vector2 extents = Vector2(float(w), float(h));
-		static const Vector2 pad[4] = {
-			Vector2(-0.5, -0.5),
-			Vector2(0.5, -0.5),
-			Vector2(-0.5, 0.5),
-			Vector2(0.5, 0.5)
-		};
-		// Rasterize 4 times to add proper padding.
-		for (int i = 0; i < 4; i++) {
-			// Rasterize chart faces, check that all bits are not set.
-			const uint32_t faceCount = chart->chartMesh()->faceCount();
-			for (uint32_t f = 0; f < faceCount; f++) {
-				const halfedge::Face *face = chart->chartMesh()->faceAt(f);
-				Vector2 vertices[4];
-				uint32_t edgeCount = 0;
-				for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
-					if (edgeCount < 4) {
-						vertices[edgeCount] = it.vertex()->tex * scale + offset + pad[i];
-						xaAssert(ftoi_ceil(vertices[edgeCount].x) >= 0);
-						xaAssert(ftoi_ceil(vertices[edgeCount].y) >= 0);
-						xaAssert(ftoi_ceil(vertices[edgeCount].x) <= w);
-						xaAssert(ftoi_ceil(vertices[edgeCount].y) <= h);
-					}
-					edgeCount++;
-				}
-				if (edgeCount == 3) {
-					raster::drawTriangle(raster::Mode_Antialiased, extents, /*enableScissors=*/true, vertices, AtlasPacker::setBitsCallback, bitmap);
-				} else {
-					raster::drawQuad(raster::Mode_Antialiased, extents, /*enableScissors=*/true, vertices, AtlasPacker::setBitsCallback, bitmap);
-				}
-			}
-		}
-		// Expand chart by padding pixels. (dilation)
-		BitMap tmp(w, h);
-		tmp.clearAll();
+		XA_DEBUG_ASSERT(r == 0 || r == 1);
+		const BitImage *image = r == 0 ? chartBitImage : chartBitImageRotated;
+		const int w = image->width();
+		const int h = image->height();
 		for (int y = 0; y < h; y++) {
-			for (int x = 0; x < w; x++) {
-				bool b = bitmap->bitAt(x, y);
-				if (!b) {
-					if (x > 0) {
-						b |= bitmap->bitAt(x - 1, y);
-						if (y > 0) b |= bitmap->bitAt(x - 1, y - 1);
-						if (y < h - 1) b |= bitmap->bitAt(x - 1, y + 1);
-					}
-					if (y > 0) b |= bitmap->bitAt(x, y - 1);
-					if (y < h - 1) b |= bitmap->bitAt(x, y + 1);
-					if (x < w - 1) {
-						b |= bitmap->bitAt(x + 1, y);
-						if (y > 0) b |= bitmap->bitAt(x + 1, y - 1);
-						if (y < h - 1) b |= bitmap->bitAt(x + 1, y + 1);
-					}
-				}
-				if (b) tmp.setBitAt(x, y);
-			}
-		}
-		std::swap(tmp, *bitmap);
-	}
-
-	bool canAddChart(const BitMap *bitmap, int atlas_w, int atlas_h, int offset_x, int offset_y, int r)
-	{
-		xaDebugAssert(r == 0 || r == 1);
-		// Check whether the two bitmaps overlap.
-		const int w = bitmap->width();
-		const int h = bitmap->height();
-		if (r == 0) {
-			for (int y = 0; y < h; y++) {
-				int yy = y + offset_y;
-				if (yy >= 0) {
-					for (int x = 0; x < w; x++) {
-						int xx = x + offset_x;
-						if (xx >= 0) {
-							if (bitmap->bitAt(x, y)) {
-								if (xx < atlas_w && yy < atlas_h) {
-									if (m_bitmap.bitAt(xx, yy)) return false;
-								}
-							}
-						}
-					}
-				}
-			}
-		} else if (r == 1) {
-			for (int y = 0; y < h; y++) {
-				int xx = y + offset_x;
-				if (xx >= 0) {
-					for (int x = 0; x < w; x++) {
-						int yy = x + offset_y;
-						if (yy >= 0) {
-							if (bitmap->bitAt(x, y)) {
-								if (xx < atlas_w && yy < atlas_h) {
-									if (m_bitmap.bitAt(xx, yy)) return false;
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-		return true;
-	}
-
-	void addChart(const BitMap *bitmap, int atlas_w, int atlas_h, int offset_x, int offset_y, int r)
-	{
-		xaDebugAssert(r == 0 || r == 1);
-		// Check whether the two bitmaps overlap.
-		const int w = bitmap->width();
-		const int h = bitmap->height();
-		if (r == 0) {
-			for (int y = 0; y < h; y++) {
-				int yy = y + offset_y;
-				if (yy >= 0) {
-					for (int x = 0; x < w; x++) {
-						int xx = x + offset_x;
-						if (xx >= 0) {
-							if (bitmap->bitAt(x, y)) {
-								if (xx < atlas_w && yy < atlas_h) {
-									xaDebugAssert(m_bitmap.bitAt(xx, yy) == false);
-									m_bitmap.setBitAt(xx, yy);
-								}
-							}
-						}
-					}
-				}
-			}
-		} else if (r == 1) {
-			for (int y = 0; y < h; y++) {
-				int xx = y + offset_x;
-				if (xx >= 0) {
-					for (int x = 0; x < w; x++) {
-						int yy = x + offset_y;
-						if (yy >= 0) {
-							if (bitmap->bitAt(x, y)) {
-								if (xx < atlas_w && yy < atlas_h) {
-									xaDebugAssert(m_bitmap.bitAt(xx, yy) == false);
-									m_bitmap.setBitAt(xx, yy);
-								}
+			int yy = y + offset_y;
+			if (yy >= 0) {
+				for (int x = 0; x < w; x++) {
+					int xx = x + offset_x;
+					if (xx >= 0) {
+						if (image->bitAt(x, y)) {
+							if (xx < atlas_w && yy < atlas_h) {
+								XA_DEBUG_ASSERT(atlasBitImage->bitAt(xx, yy) == false);
+								atlasBitImage->setBitAt(xx, yy);
 							}
 						}
 					}
@@ -7350,458 +7321,992 @@ private:
 		}
 	}
 
-	static bool setBitsCallback(void *param, int x, int y, Vector3::Arg, Vector3::Arg, Vector3::Arg, float area)
+	struct DrawTriangleCallbackArgs
 	{
-		BitMap *bitmap = (BitMap * )param;
-		if (area > 0.0) {
-			bitmap->setBitAt(x, y);
-		}
-		return true;
-	}
+		BitImage *chartBitImage;
+		BitImage *chartBitImageRotated;
+	};
 
-	// Compute the convex hull using Graham Scan.
-	static void convexHull(const std::vector<Vector2> &input, std::vector<Vector2> &output, float epsilon)
+	static bool drawTriangleCallback(void *param, int x, int y)
 	{
-		const uint32_t inputCount = input.size();
-		std::vector<float> coords(inputCount);
-		for (uint32_t i = 0; i < inputCount; i++) {
-			coords[i] = input[i].x;
-		}
-		RadixSort radix;
-		radix.sort(coords);
-		const uint32_t *ranks = radix.ranks();
-		std::vector<Vector2> top;
-		top.reserve(inputCount);
-		std::vector<Vector2> bottom;
-		bottom.reserve(inputCount);
-		Vector2 P = input[ranks[0]];
-		Vector2 Q = input[ranks[inputCount - 1]];
-		float topy = std::max(P.y, Q.y);
-		float boty = std::min(P.y, Q.y);
-		for (uint32_t i = 0; i < inputCount; i++) {
-			Vector2 p = input[ranks[i]];
-			if (p.y >= boty) top.push_back(p);
-		}
-		for (uint32_t i = 0; i < inputCount; i++) {
-			Vector2 p = input[ranks[inputCount - 1 - i]];
-			if (p.y <= topy) bottom.push_back(p);
-		}
-		// Filter top list.
-		output.clear();
-		output.push_back(top[0]);
-		output.push_back(top[1]);
-		for (uint32_t i = 2; i < top.size(); ) {
-			Vector2 a = output[output.size() - 2];
-			Vector2 b = output[output.size() - 1];
-			Vector2 c = top[i];
-			float area = triangleArea(a, b, c);
-			if (area >= -epsilon) {
-				output.pop_back();
-			}
-			if (area < -epsilon || output.size() == 1) {
-				output.push_back(c);
-				i++;
-			}
-		}
-		uint32_t top_count = output.size();
-		output.push_back(bottom[1]);
-		// Filter bottom list.
-		for (uint32_t i = 2; i < bottom.size(); ) {
-			Vector2 a = output[output.size() - 2];
-			Vector2 b = output[output.size() - 1];
-			Vector2 c = bottom[i];
-			float area = triangleArea(a, b, c);
-			if (area >= -epsilon) {
-				output.pop_back();
-			}
-			if (area < -epsilon || output.size() == top_count) {
-				output.push_back(c);
-				i++;
-			}
-		}
-		// Remove duplicate element.
-		xaDebugAssert(output.front() == output.back());
-		output.pop_back();
+		auto args = (DrawTriangleCallbackArgs *)param;
+		args->chartBitImage->setBitAt(x, y);
+		if (args->chartBitImageRotated)
+			args->chartBitImageRotated->setBitAt(y, x);
+		return true;
 	}
 
-	// This should compute convex hull and use rotating calipers to find the best box. Currently it uses a brute force method.
-	static void computeBoundingBox(Chart *chart, Vector2 *majorAxis, Vector2 *minorAxis, Vector2 *minCorner, Vector2 *maxCorner)
-	{
-		// Compute list of boundary points.
-		std::vector<Vector2> points;
-		points.reserve(16);
-		halfedge::Mesh *mesh = chart->chartMesh();
-		const uint32_t vertexCount = mesh->vertexCount();
-		for (uint32_t i = 0; i < vertexCount; i++) {
-			halfedge::Vertex *vertex = mesh->vertexAt(i);
-			if (vertex->isBoundary()) {
-				points.push_back(vertex->tex);
-			}
-		}
-		xaDebugAssert(points.size() > 0);
-		std::vector<Vector2> hull;
-		convexHull(points, hull, 0.00001f);
-		// @@ Ideally I should use rotating calipers to find the best box. Using brute force for now.
-		float best_area = FLT_MAX;
-		Vector2 best_min;
-		Vector2 best_max;
-		Vector2 best_axis;
-		const uint32_t hullCount = hull.size();
-		for (uint32_t i = 0, j = hullCount - 1; i < hullCount; j = i, i++) {
-			if (equal(hull[i], hull[j])) {
-				continue;
-			}
-			Vector2 axis = normalize(hull[i] - hull[j], 0.0f);
-			xaDebugAssert(isFinite(axis));
-			// Compute bounding box.
-			Vector2 box_min(FLT_MAX, FLT_MAX);
-			Vector2 box_max(-FLT_MAX, -FLT_MAX);
-			for (uint32_t v = 0; v < hullCount; v++) {
-				Vector2 point = hull[v];
-				float x = dot(axis, point);
-				if (x < box_min.x) box_min.x = x;
-				if (x > box_max.x) box_max.x = x;
-				float y = dot(Vector2(-axis.y, axis.x), point);
-				if (y < box_min.y) box_min.y = y;
-				if (y > box_max.y) box_max.y = y;
-			}
-			// Compute box area.
-			float area = (box_max.x - box_min.x) * (box_max.y - box_min.y);
-			if (area < best_area) {
-				best_area = area;
-				best_min = box_min;
-				best_max = box_max;
-				best_axis = axis;
-			}
-		}
-		// Consider all points, not only boundary points, in case the input chart is malformed.
-		for (uint32_t i = 0; i < vertexCount; i++) {
-			halfedge::Vertex *vertex = mesh->vertexAt(i);
-			Vector2 point = vertex->tex;
-			float x = dot(best_axis, point);
-			if (x < best_min.x) best_min.x = x;
-			if (x > best_max.x) best_max.x = x;
-			float y = dot(Vector2(-best_axis.y, best_axis.x), point);
-			if (y < best_min.y) best_min.y = y;
-			if (y > best_max.y) best_max.y = y;
-		}
-		*majorAxis = best_axis;
-		*minorAxis = Vector2(-best_axis.y, best_axis.x);
-		*minCorner = best_min;
-		*maxCorner = best_max;
-	}
-
-	Atlas *m_atlas;
-	BitMap m_bitmap;
+	Array<AtlasImage *> m_atlasImages;
+	Array<float> m_utilization;
+	Array<BitImage *> m_bitImages;
+	BoundingBox2D m_boundingBox;
+	Array<Chart *> m_charts;
 	RadixSort m_radix;
-	uint32_t m_width;
-	uint32_t m_height;
-	MTRand m_rand;
-	std::vector<std::vector<Vector2> > m_originalChartUvs;
+	uint32_t m_width = 0;
+	uint32_t m_height = 0;
+	float m_texelsPerUnit = 0.0f;
+	KISSRng m_rand;
 };
 
-} // namespace param
+} // namespace pack
 } // namespace internal
 
-struct Atlas
-{
-	internal::param::Atlas atlas;
-	std::vector<internal::halfedge::Mesh *> heMeshes;
-	uint32_t width = 0;
-	uint32_t height = 0;
-	OutputMesh **outputMeshes = NULL;
+struct Context
+{
+	Atlas atlas;
+	uint32_t meshCount = 0;
+	internal::Progress *addMeshProgress = nullptr;
+	internal::TaskGroupHandle addMeshTaskGroup;
+	internal::param::Atlas paramAtlas;
+	ProgressFunc progressFunc = nullptr;
+	void *progressUserData = nullptr;
+	internal::TaskScheduler *taskScheduler;
+	internal::Array<internal::UvMesh *> uvMeshes;
+	internal::Array<internal::UvMeshInstance *> uvMeshInstances;
 };
 
-void SetPrint(PrintFunc print)
+Atlas *Create()
 {
-	internal::s_print = print;
+	Context *ctx = XA_NEW(internal::MemTag::Default, Context);
+	memset(&ctx->atlas, 0, sizeof(Atlas));
+	ctx->taskScheduler = XA_NEW(internal::MemTag::Default, internal::TaskScheduler);
+	return &ctx->atlas;
 }
 
-Atlas *Create()
-{
-	Atlas *atlas = new Atlas();
-	return atlas;
+static void DestroyOutputMeshes(Context *ctx)
+{
+	if (!ctx->atlas.meshes)
+		return;
+	for (int i = 0; i < (int)ctx->atlas.meshCount; i++) {
+		Mesh &mesh = ctx->atlas.meshes[i];
+		for (uint32_t j = 0; j < mesh.chartCount; j++) {
+			if (mesh.chartArray[j].indexArray)
+				XA_FREE(mesh.chartArray[j].indexArray);
+		}
+		if (mesh.chartArray)
+			XA_FREE(mesh.chartArray);
+		if (mesh.vertexArray)
+			XA_FREE(mesh.vertexArray);
+		if (mesh.indexArray)
+			XA_FREE(mesh.indexArray);
+	}
+	if (ctx->atlas.meshes)
+		XA_FREE(ctx->atlas.meshes);
+	ctx->atlas.meshes = nullptr;
 }
 
 void Destroy(Atlas *atlas)
 {
-	xaAssert(atlas);
-	for (int i = 0; i < (int)atlas->heMeshes.size(); i++) {
-		delete atlas->heMeshes[i];
-		if (atlas->outputMeshes) {
-			OutputMesh *outputMesh = atlas->outputMeshes[i];
-			for (uint32_t j = 0; j < outputMesh->chartCount; j++)
-				delete [] outputMesh->chartArray[j].indexArray;
-			delete [] outputMesh->chartArray;
-			delete [] outputMesh->vertexArray;
-			delete [] outputMesh->indexArray;
-			delete outputMesh;
-		}
-	}
-	delete [] atlas->outputMeshes;
-	delete atlas;
+	XA_DEBUG_ASSERT(atlas);
+	Context *ctx = (Context *)atlas;
+	if (atlas->utilization)
+		XA_FREE(atlas->utilization);
+	if (atlas->image)
+		XA_FREE(atlas->image);
+	DestroyOutputMeshes(ctx);
+	if (ctx->addMeshProgress) {
+		ctx->addMeshProgress->cancel = true;
+		AddMeshJoin(atlas); // frees addMeshProgress
+	}
+	ctx->taskScheduler->~TaskScheduler();
+	XA_FREE(ctx->taskScheduler);
+	for (uint32_t i = 0; i < ctx->uvMeshes.size(); i++) {
+		internal::UvMesh *mesh = ctx->uvMeshes[i];
+		for (uint32_t j = 0; j < mesh->charts.size(); j++) {
+			mesh->charts[j]->~UvMeshChart();
+			XA_FREE(mesh->charts[j]);
+		}
+		mesh->~UvMesh();
+		XA_FREE(mesh);
+	}
+	for (uint32_t i = 0; i < ctx->uvMeshInstances.size(); i++) {
+		internal::UvMeshInstance *mesh = ctx->uvMeshInstances[i];
+		mesh->~UvMeshInstance();
+		XA_FREE(mesh);
+	}
+	ctx->~Context();
+	XA_FREE(ctx);
+#if XA_DEBUG_HEAP
+	internal::ReportLeaks();
+#endif
 }
 
-static internal::Vector3 DecodePosition(const InputMesh &mesh, uint32_t index)
+struct AddMeshTaskArgs
 {
-	xaAssert(mesh.vertexPositionData);
-	return *((const internal::Vector3 *)&((const uint8_t *)mesh.vertexPositionData)[mesh.vertexPositionStride * index]);
+	Context *ctx;
+	internal::Mesh *mesh;
+};
+
+static void runAddMeshTask(void *userData)
+{
+	XA_PROFILE_START(addMesh)
+	auto args = (AddMeshTaskArgs *)userData; // Responsible for freeing this.
+	internal::Mesh *mesh = args->mesh;
+	internal::Progress *progress = args->ctx->addMeshProgress;
+	if (progress->cancel)
+		goto cleanup;
+	XA_PROFILE_START(addMeshCreateColocals)
+	mesh->createColocals();
+	XA_PROFILE_END(addMeshCreateColocals)
+	if (progress->cancel)
+		goto cleanup;
+	XA_PROFILE_START(addMeshCreateFaceGroups)
+	mesh->createFaceGroups();
+	XA_PROFILE_END(addMeshCreateFaceGroups)
+	if (progress->cancel)
+		goto cleanup;
+	XA_PROFILE_START(addMeshCreateBoundaries)
+	mesh->createBoundaries();
+	XA_PROFILE_END(addMeshCreateBoundaries)
+	if (progress->cancel)
+		goto cleanup;
+#if XA_DEBUG_EXPORT_OBJ_SOURCE_MESHES
+	char filename[256];
+	XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u.obj", mesh->id());
+	FILE *file;
+	XA_FOPEN(file, filename, "w");
+	if (file) {
+		mesh->writeObjVertices(file);
+		// groups
+		uint32_t numGroups = 0;
+		for (uint32_t i = 0; i < mesh->faceGroupCount(); i++) {
+			if (mesh->faceGroupAt(i) != UINT32_MAX)
+				numGroups = internal::max(numGroups, mesh->faceGroupAt(i) + 1);
+		}
+		for (uint32_t i = 0; i < numGroups; i++) {
+			fprintf(file, "o group_%04d\n", i);
+			fprintf(file, "s off\n");
+			for (uint32_t f = 0; f < mesh->faceGroupCount(); f++) {
+				if (mesh->faceGroupAt(f) == i)
+					mesh->writeObjFace(file, f);
+			}
+		}
+		fprintf(file, "o group_ignored\n");
+		fprintf(file, "s off\n");
+		for (uint32_t f = 0; f < mesh->faceGroupCount(); f++) {
+			if (mesh->faceGroupAt(f) == UINT32_MAX)
+				mesh->writeObjFace(file, f);
+		}
+		mesh->writeObjBoundaryEges(file);
+		fclose(file);
+	}
+#endif
+	XA_PROFILE_START(addMeshCreateChartGroupsConcurrent)
+	args->ctx->paramAtlas.addMesh(args->ctx->taskScheduler, mesh); // addMesh is thread safe
+	XA_PROFILE_END(addMeshCreateChartGroupsConcurrent)
+	if (progress->cancel)
+		goto cleanup;
+	progress->value++;
+	progress->update();
+cleanup:
+	mesh->~Mesh();
+	XA_FREE(mesh);
+	args->~AddMeshTaskArgs();
+	XA_FREE(args);
+	XA_PROFILE_END(addMesh)
 }
 
-static internal::Vector3 DecodeNormal(const InputMesh &mesh, uint32_t index)
+static internal::Vector3 DecodePosition(const MeshDecl &meshDecl, uint32_t index)
 {
-	xaAssert(mesh.vertexNormalData);
-	return *((const internal::Vector3 *)&((const uint8_t *)mesh.vertexNormalData)[mesh.vertexNormalStride * index]);
+	XA_DEBUG_ASSERT(meshDecl.vertexPositionData);
+	XA_DEBUG_ASSERT(meshDecl.vertexPositionStride > 0);
+	return *((const internal::Vector3 *)&((const uint8_t *)meshDecl.vertexPositionData)[meshDecl.vertexPositionStride * index]);
 }
 
-static internal::Vector2 DecodeUv(const InputMesh &mesh, uint32_t index)
+static internal::Vector3 DecodeNormal(const MeshDecl &meshDecl, uint32_t index)
 {
-	xaAssert(mesh.vertexUvData);
-	return *((const internal::Vector2 *)&((const uint8_t *)mesh.vertexUvData)[mesh.vertexUvStride * index]);
+	XA_DEBUG_ASSERT(meshDecl.vertexNormalData);
+	XA_DEBUG_ASSERT(meshDecl.vertexNormalStride > 0);
+	return *((const internal::Vector3 *)&((const uint8_t *)meshDecl.vertexNormalData)[meshDecl.vertexNormalStride * index]);
 }
 
-static uint32_t DecodeIndex(IndexFormat::Enum format, const void *indexData, uint32_t i)
+static internal::Vector2 DecodeUv(const MeshDecl &meshDecl, uint32_t index)
 {
-	if (format == IndexFormat::HalfFloat)
-		return (uint32_t)((const uint16_t *)indexData)[i];
-	return ((const uint32_t *)indexData)[i];
+	XA_DEBUG_ASSERT(meshDecl.vertexUvData);
+	XA_DEBUG_ASSERT(meshDecl.vertexUvStride > 0);
+	return *((const internal::Vector2 *)&((const uint8_t *)meshDecl.vertexUvData)[meshDecl.vertexUvStride * index]);
 }
 
-static float EdgeLength(internal::Vector3 pos1, internal::Vector3 pos2)
+static uint32_t DecodeIndex(IndexFormat::Enum format, const void *indexData, int32_t offset, uint32_t i)
 {
-	return internal::length(pos2 - pos1);
+	XA_DEBUG_ASSERT(indexData);
+	if (format == IndexFormat::UInt16)
+		return uint16_t((int32_t)((const uint16_t *)indexData)[i] + offset);
+	return uint32_t((int32_t)((const uint32_t *)indexData)[i] + offset);
 }
 
-AddMeshError AddMesh(Atlas *atlas, const InputMesh &mesh, bool useColocalVertices)
+AddMeshError::Enum AddMesh(Atlas *atlas, const MeshDecl &meshDecl, uint32_t meshCountHint)
 {
-	xaAssert(atlas);
-	AddMeshError error;
-	error.code = AddMeshErrorCode::Success;
-	error.face = error.index0 = error.index1 = UINT32_MAX;
-	// Expecting triangle faces.
-	if ((mesh.indexCount % 3) != 0)
-	{
-		error.code = AddMeshErrorCode::InvalidIndexCount;
-		return error;
-	}
-	// Check if any index is out of range.
-	for (uint32_t j = 0; j < mesh.indexCount; j++) {
-		const uint32_t index = DecodeIndex(mesh.indexFormat, mesh.indexData, j);
-		if (index < 0 || index >= mesh.vertexCount) {
-			error.code = AddMeshErrorCode::IndexOutOfRange;
-			error.index0 = index;
-			return error;
-		}
-	}
-	// Build half edge mesh.
-	internal::halfedge::Mesh *heMesh = new internal::halfedge::Mesh;
-	std::vector<uint32_t> canonicalMap;
-	canonicalMap.reserve(mesh.vertexCount);
-	for (uint32_t i = 0; i < mesh.vertexCount; i++) {
-		internal::halfedge::Vertex *vertex = heMesh->addVertex(DecodePosition(mesh, i));
-		if (mesh.vertexNormalData)
-			vertex->nor = DecodeNormal(mesh, i);
-		if (mesh.vertexUvData)
-			vertex->tex = DecodeUv(mesh, i);
-		// Link colocals. You probably want to do this more efficiently! Sort by one axis or use a hash or grid.
-		uint32_t firstColocal = i;
-		if (useColocalVertices) {
-			for (uint32_t j = 0; j < i; j++) {
-				if (vertex->pos != DecodePosition(mesh, j))
-					continue;
-#if 0
-				if (mesh.vertexNormalData && vertex->nor != DecodeNormal(mesh, j))
-					continue;
+	XA_DEBUG_ASSERT(atlas);
+	if (!atlas) {
+		XA_PRINT_WARNING("AddMesh: atlas is null.\n");
+		return AddMeshError::Error;
+	}
+	Context *ctx = (Context *)atlas;
+	if (!ctx->uvMeshes.isEmpty()) {
+		XA_PRINT_WARNING("AddMesh: Meshes and UV meshes cannot be added to the same atlas.\n");
+		return AddMeshError::Error;
+	}
+	// Don't know how many times AddMesh will be called, so progress needs to adjusted each time.
+	if (!ctx->addMeshProgress) {
+		ctx->addMeshProgress = XA_NEW(internal::MemTag::Default, internal::Progress, ProgressCategory::AddMesh, ctx->progressFunc, ctx->progressUserData, 1);
+#if XA_PROFILE
+		internal::s_profile.addMeshConcurrent = clock();
 #endif
-				if (mesh.vertexUvData && vertex->tex != DecodeUv(mesh, j))
-					continue;
-				firstColocal = j;
-				break;
-			}
-		}
-		canonicalMap.push_back(firstColocal);
 	}
-	heMesh->linkColocalsWithCanonicalMap(canonicalMap);
-	for (uint32_t i = 0; i < mesh.indexCount / 3; i++) {
+	else {
+		ctx->addMeshProgress->setMaxValue(internal::max(ctx->meshCount + 1, meshCountHint));
+	}
+	bool decoded = (meshDecl.indexCount <= 0);
+	uint32_t indexCount = decoded ? meshDecl.vertexCount : meshDecl.indexCount;
+	XA_PRINT("Adding mesh %d: %u vertices, %u triangles\n", ctx->meshCount, meshDecl.vertexCount, indexCount / 3);
+	XA_PROFILE_START(addMesh)
+	// Expecting triangle faces.
+	if ((indexCount % 3) != 0)
+		return AddMeshError::InvalidIndexCount;
+	if (!decoded) {
+		// Check if any index is out of range.
+		for (uint32_t i = 0; i < indexCount; i++) {
+			const uint32_t index = DecodeIndex(meshDecl.indexFormat, meshDecl.indexData, meshDecl.indexOffset, i);
+			if (index >= meshDecl.vertexCount)
+				return AddMeshError::IndexOutOfRange;
+		}
+	}
+	uint32_t meshFlags = internal::MeshFlags::HasFaceGroups | internal::MeshFlags::HasIgnoredFaces;
+	if (meshDecl.vertexNormalData)
+		meshFlags |= internal::MeshFlags::HasNormals;
+	internal::Mesh *mesh = XA_NEW(internal::MemTag::Mesh, internal::Mesh, meshDecl.epsilon, meshDecl.vertexCount, indexCount / 3, meshFlags, ctx->meshCount);
+	for (uint32_t i = 0; i < meshDecl.vertexCount; i++) {
+		internal::Vector3 normal(0.0f);
+		internal::Vector2 texcoord(0.0f);
+		if (meshDecl.vertexNormalData)
+			normal = DecodeNormal(meshDecl, i);
+		if (meshDecl.vertexUvData)
+			texcoord = DecodeUv(meshDecl, i);
+		mesh->addVertex(DecodePosition(meshDecl, i), normal, texcoord);
+	}
+	for (uint32_t i = 0; i < indexCount / 3; i++) {
 		uint32_t tri[3];
 		for (int j = 0; j < 3; j++)
-			tri[j] = DecodeIndex(mesh.indexFormat, mesh.indexData, i * 3 + j);
-		// Check for zero length edges.
+			tri[j] = decoded ? i * 3 + j : DecodeIndex(meshDecl.indexFormat, meshDecl.indexData, meshDecl.indexOffset, i * 3 + j);
+		bool ignore = false;
+		// Check for degenerate or zero length edges.
 		for (int j = 0; j < 3; j++) {
-			const uint32_t edges[6] = { 0, 1, 1, 2, 2, 0 };
-			const uint32_t index1 = tri[edges[j * 2 + 0]];
-			const uint32_t index2 = tri[edges[j * 2 + 1]];
-			const internal::Vector3 pos1 = DecodePosition(mesh, index1);
-			const internal::Vector3 pos2 = DecodePosition(mesh, index2);
-			if (EdgeLength(pos1, pos2) <= 0.0f) {
-				delete heMesh;
-				error.code = AddMeshErrorCode::ZeroLengthEdge;
-				error.face = i;
-				error.index0 = index1;
-				error.index1 = index2;
-				return error;
-			}
-		}
-		// Check for zero area faces.
-		{
-			const internal::Vector3 a = DecodePosition(mesh, tri[0]);
-			const internal::Vector3 b = DecodePosition(mesh, tri[1]);
-			const internal::Vector3 c = DecodePosition(mesh, tri[2]);
-			const float area = internal::length(internal::cross(b - a, c - a)) * 0.5f;
-			if (area <= 0.0f) {
-				delete heMesh;
-				error.code = AddMeshErrorCode::ZeroAreaFace;
-				error.face = i;
-				return error;
-			}
-		}
-		internal::halfedge::Face *face = heMesh->addFace(tri[0], tri[1], tri[2]);
-
-		// -- GODOT start --
-		if (!face && heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::AlreadyAddedEdge) {
-			//there is still hope for this, no reason to not add, at least add as separate
-			face = heMesh->addUniqueFace(tri[0], tri[1], tri[2]);
-		}
-		// -- GODOT end --
-
-		if (!face) {
-			if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::AlreadyAddedEdge)
-				error.code = AddMeshErrorCode::AlreadyAddedEdge;
-			else if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::DegenerateColocalEdge)
-				error.code = AddMeshErrorCode::DegenerateColocalEdge;
-			else if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::DegenerateEdge)
-				error.code = AddMeshErrorCode::DegenerateEdge;
-			else if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::DuplicateEdge)
-				error.code = AddMeshErrorCode::DuplicateEdge;
-			error.face = i;
-			error.index0 = heMesh->errorIndex0;
-			error.index1 = heMesh->errorIndex1;
-			delete heMesh;
-			return error;
-		}
-		if (mesh.faceMaterialData)
-			face->material = mesh.faceMaterialData[i];
-	}
-	heMesh->linkBoundary();
-	atlas->heMeshes.push_back(heMesh);
-	return error;
+			const uint32_t index1 = tri[j];
+			const uint32_t index2 = tri[(j + 1) % 3];
+			if (index1 == index2) {
+				ignore = true;
+				XA_PRINT("   Degenerate edge: index %d, index %d\n", index1, index2);
+				break;
+			}
+			const internal::Vector3 &pos1 = mesh->position(index1);
+			const internal::Vector3 &pos2 = mesh->position(index2);
+			if (internal::length(pos2 - pos1) <= 0.0f) {
+				ignore = true;
+				XA_PRINT("   Zero length edge: index %d position (%g %g %g), index %d position (%g %g %g)\n", index1, pos1.x, pos1.y, pos1.z, index2, pos2.x, pos2.y, pos2.z);
+				break;
+			}
+		}
+		const internal::Vector3 &a = mesh->position(tri[0]);
+		const internal::Vector3 &b = mesh->position(tri[1]);
+		const internal::Vector3 &c = mesh->position(tri[2]);
+		// Check for zero area faces. Don't bother if a degenerate or zero length edge was already detected.
+		float area = 0.0f;
+		if (!ignore) {
+			area = internal::length(internal::cross(b - a, c - a)) * 0.5f;
+			if (area <= internal::kAreaEpsilon) {
+				ignore = true;
+				XA_PRINT("   Zero area face: %d, indices (%d %d %d), area is %f\n", i, tri[0], tri[1], tri[2], area);
+			}
+		}
+		if (!ignore) {
+			if (internal::equal(a, b, meshDecl.epsilon) || internal::equal(a, c, meshDecl.epsilon) || internal::equal(b, c, meshDecl.epsilon)) {
+				ignore = true;
+				XA_PRINT("   Degenerate face: %d, area is %f\n", i, area);
+			}
+		}
+		if (meshDecl.faceIgnoreData && meshDecl.faceIgnoreData[i])
+			ignore = true;
+		mesh->addFace(tri[0], tri[1], tri[2], ignore);
+	}
+	AddMeshTaskArgs *taskArgs = XA_NEW(internal::MemTag::Default, AddMeshTaskArgs); // The task frees this.
+	taskArgs->ctx = ctx;
+	taskArgs->mesh = mesh;
+	internal::Task task;
+	task.userData = taskArgs;
+	task.func = runAddMeshTask;
+	ctx->taskScheduler->run(&ctx->addMeshTaskGroup, task);
+	ctx->meshCount++;
+	XA_PROFILE_END(addMesh)
+	return AddMeshError::Success;
+}
+
+void AddMeshJoin(Atlas *atlas)
+{
+	XA_DEBUG_ASSERT(atlas);
+	if (!atlas) {
+		XA_PRINT_WARNING("AddMeshJoin: atlas is null.\n");
+		return;
+	}
+	Context *ctx = (Context *)atlas;
+	if (!ctx->addMeshProgress)
+		return;
+	ctx->taskScheduler->wait(&ctx->addMeshTaskGroup);
+	ctx->addMeshProgress->~Progress();
+	XA_FREE(ctx->addMeshProgress);
+	ctx->addMeshProgress = nullptr;
+#if XA_PROFILE
+	XA_PRINT("Added %u meshes\n", ctx->meshCount);
+	internal::s_profile.addMeshConcurrent = clock() - internal::s_profile.addMeshConcurrent;
+#endif
+	XA_PROFILE_PRINT("   Total (concurrent): ", addMeshConcurrent)
+	XA_PROFILE_PRINT("   Total: ", addMesh)
+	XA_PROFILE_PRINT("      Create colocals: ", addMeshCreateColocals)
+	XA_PROFILE_PRINT("      Create face groups: ", addMeshCreateFaceGroups)
+	XA_PROFILE_PRINT("      Create boundaries: ", addMeshCreateBoundaries)
+	XA_PROFILE_PRINT("      Create chart groups (concurrent): ", addMeshCreateChartGroupsConcurrent)
+	XA_PROFILE_PRINT("      Create chart groups: ", addMeshCreateChartGroups)
+	XA_PRINT_MEM_USAGE
+}
+
+struct EdgeKey
+{
+	EdgeKey() {}
+	EdgeKey(const EdgeKey &k) : v0(k.v0), v1(k.v1) {}
+	EdgeKey(uint32_t v0, uint32_t v1) : v0(v0), v1(v1) {}
+
+	void operator=(const EdgeKey &k)
+	{
+		v0 = k.v0;
+		v1 = k.v1;
+	}
+	bool operator==(const EdgeKey &k) const
+	{
+		return v0 == k.v0 && v1 == k.v1;
+	}
+
+	uint32_t v0;
+	uint32_t v1;
+};
+
+AddMeshError::Enum AddUvMesh(Atlas *atlas, const UvMeshDecl &decl)
+{
+	XA_DEBUG_ASSERT(atlas);
+	if (!atlas) {
+		XA_PRINT_WARNING("AddUvMesh: atlas is null.\n");
+		return AddMeshError::Error;
+	}
+	Context *ctx = (Context *)atlas;
+	if (ctx->meshCount > 0) {
+		XA_PRINT_WARNING("AddUvMesh: Meshes and UV meshes cannot be added to the same atlas.\n");
+		return AddMeshError::Error;
+	}
+	const bool decoded = (decl.indexCount <= 0);
+	const uint32_t indexCount = decoded ? decl.vertexCount : decl.indexCount;
+	XA_PRINT("Adding UV mesh %d: %u vertices, %u triangles\n", ctx->uvMeshes.size(), decl.vertexCount, indexCount / 3);
+	// Expecting triangle faces.
+	if ((indexCount % 3) != 0)
+		return AddMeshError::InvalidIndexCount;
+	if (!decoded) {
+		// Check if any index is out of range.
+		for (uint32_t i = 0; i < indexCount; i++) {
+			const uint32_t index = DecodeIndex(decl.indexFormat, decl.indexData, decl.indexOffset, i);
+			if (index >= decl.vertexCount)
+				return AddMeshError::IndexOutOfRange;
+		}
+	}
+	internal::UvMeshInstance *meshInstance = XA_NEW(internal::MemTag::Default, internal::UvMeshInstance);
+	meshInstance->texcoords.resize(decl.vertexCount);
+	for (uint32_t i = 0; i < decl.vertexCount; i++)
+		meshInstance->texcoords[i] = *((const internal::Vector2 *)&((const uint8_t *)decl.vertexUvData)[decl.vertexStride * i]);
+	meshInstance->rotateCharts = decl.rotateCharts;
+	// See if this is an instance of an already existing mesh.
+	internal::UvMesh *mesh = nullptr;
+	for (uint32_t m = 0; m < ctx->uvMeshes.size(); m++) {
+		if (memcmp(&ctx->uvMeshes[m]->decl, &decl, sizeof(UvMeshDecl)) == 0) {
+			meshInstance->mesh = mesh = ctx->uvMeshes[m];
+			break;
+		}
+	}
+	if (!mesh) {
+		// Copy geometry to mesh.
+		meshInstance->mesh = mesh = XA_NEW(internal::MemTag::Default, internal::UvMesh);
+		mesh->decl = decl;
+		mesh->indices.resize(decl.indexCount);
+		for (uint32_t i = 0; i < indexCount; i++)
+			mesh->indices[i] = decoded ? i : DecodeIndex(decl.indexFormat, decl.indexData, decl.indexOffset, i);
+		mesh->vertexToChartMap.resize(decl.vertexCount);
+		for (uint32_t i = 0; i < mesh->vertexToChartMap.size(); i++)
+			mesh->vertexToChartMap[i] = UINT32_MAX;
+		// Calculate charts (incident faces).
+		internal::HashMap<internal::Vector2, uint32_t> vertexToFaceMap(internal::MemTag::Default, indexCount);
+		const uint32_t faceCount = indexCount / 3;
+		for (uint32_t i = 0; i < indexCount; i++)
+			vertexToFaceMap.add(meshInstance->texcoords[mesh->indices[i]], i / 3);
+		internal::BitArray faceAssigned(faceCount);
+		faceAssigned.clearAll();
+		internal::Array<uint32_t> chartFaces;
+		for (uint32_t f = 0; f < faceCount; f++) {
+			if (faceAssigned.bitAt(f))
+				continue;
+			// Found an unassigned face, create a new chart.
+			internal::UvMeshChart *chart = XA_NEW(internal::MemTag::Default, internal::UvMeshChart);
+			chart->material = decl.faceMaterialData ? decl.faceMaterialData[f] : 0;
+			// Walk incident faces and assign them to the chart.
+			faceAssigned.setBitAt(f);
+			chartFaces.clear();
+			chartFaces.push_back(f);
+			for (;;) {
+				bool newFaceAssigned = false;
+				const uint32_t faceCount2 = chartFaces.size();
+				for (uint32_t f2 = 0; f2 < faceCount2; f2++) {
+					const uint32_t face = chartFaces[f2];
+					for (uint32_t i = 0; i < 3; i++) {
+						const internal::Vector2 &texcoord = meshInstance->texcoords[meshInstance->mesh->indices[face * 3 + i]];
+						uint32_t mapFaceIndex = vertexToFaceMap.get(texcoord);
+						while (mapFaceIndex != UINT32_MAX) {
+							const uint32_t face2 = vertexToFaceMap.value(mapFaceIndex);
+							// Materials must match.
+							if (!faceAssigned.bitAt(face2) && (!decl.faceMaterialData || decl.faceMaterialData[face] == decl.faceMaterialData[face2])) {
+								faceAssigned.setBitAt(face2);
+								chartFaces.push_back(face2);
+								newFaceAssigned = true;
+							}
+							mapFaceIndex = vertexToFaceMap.getNext(mapFaceIndex);
+						}
+					}
+				}
+				if (!newFaceAssigned)
+					break;
+			}
+			for (uint32_t i = 0; i < chartFaces.size(); i++) {
+				for (uint32_t j = 0; j < 3; j++) {
+					const uint32_t vertex = meshInstance->mesh->indices[chartFaces[i] * 3 + j];
+					chart->indices.push_back(vertex);
+					mesh->vertexToChartMap[vertex] = mesh->charts.size();
+				}
+			}
+			mesh->charts.push_back(chart);
+		}
+		ctx->uvMeshes.push_back(mesh);
+	} else {
+		XA_PRINT("   instance of a previous UV mesh\n");
+	}
+	XA_PRINT("   %u charts\n", meshInstance->mesh->charts.size());
+	ctx->uvMeshInstances.push_back(meshInstance);
+	return AddMeshError::Success;
+}
+
+void ComputeCharts(Atlas *atlas, ChartOptions chartOptions)
+{
+	if (!atlas) {
+		XA_PRINT_WARNING("ComputeCharts: atlas is null.\n");
+		return;
+	}
+	Context *ctx = (Context *)atlas;
+	if (!ctx->uvMeshInstances.isEmpty()) {
+		XA_PRINT_WARNING("ComputeCharts: This function should not be called with UV meshes.\n");
+		return;
+	}
+	AddMeshJoin(atlas);
+	if (ctx->meshCount == 0) {
+		XA_PRINT_WARNING("ComputeCharts: No meshes. Call AddMesh first.\n");
+		return;
+	}
+	XA_PRINT("Computing charts\n");
+	uint32_t chartCount = 0, chartsWithHolesCount = 0, holesCount = 0, chartsWithTJunctionsCount = 0, tJunctionsCount = 0;
+	XA_PROFILE_START(computeChartsConcurrent)
+	if (!ctx->paramAtlas.computeCharts(ctx->taskScheduler, chartOptions, ctx->progressFunc, ctx->progressUserData)) {
+		XA_PRINT("   Cancelled by user\n");
+		return;
+	}
+	XA_PROFILE_END(computeChartsConcurrent)
+	// Count charts and print warnings.
+	for (uint32_t i = 0; i < ctx->meshCount; i++) {
+		for (uint32_t j = 0; j < ctx->paramAtlas.chartGroupCount(i); j++) {
+			const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, j);
+			if (chartGroup->isVertexMap())
+				continue;
+			for (uint32_t k = 0; k < chartGroup->chartCount(); k++) {
+				const internal::param::Chart *chart = chartGroup->chartAt(k);
+				if (chart->warningFlags() & internal::param::ChartWarningFlags::CloseHolesFailed)
+					XA_PRINT_WARNING("   Chart %u (mesh %u, group %u, id %u): failed to close holes\n", chartCount, i, j, k);
+				if (chart->warningFlags() & internal::param::ChartWarningFlags::FixTJunctionsDuplicatedEdge)
+					XA_PRINT_WARNING("   Chart %u (mesh %u, group %u, id %u): fixing t-junctions created non-manifold geometry\n", chartCount, i, j, k);
+				if (chart->warningFlags() & internal::param::ChartWarningFlags::FixTJunctionsFailed)
+					XA_PRINT_WARNING("   Chart %u (mesh %u, group %u, id %u): fixing t-junctions failed\n", chartCount, i, j, k);
+				if (chart->warningFlags() & internal::param::ChartWarningFlags::TriangulateDuplicatedEdge)
+					XA_PRINT_WARNING("   Chart %u (mesh %u, group %u, id %u): triangulation created non-manifold geometry\n", chartCount, i, j, k);
+				if (!chart->isDisk())
+					XA_PRINT_WARNING("   Chart %u (mesh %u, group %u, id %u): doesn't have disk topology\n", chartCount, i, j, k);
+				holesCount += chart->closedHolesCount();
+				if (chart->closedHolesCount() > 0)
+					chartsWithHolesCount++;
+				tJunctionsCount += chart->fixedTJunctionsCount();
+				if (chart->fixedTJunctionsCount() > 0)
+					chartsWithTJunctionsCount++;
+				chartCount++;
+			}
+		}
+	}
+	if (holesCount > 0)
+		XA_PRINT("   Closed %u holes in %u charts\n", holesCount, chartsWithHolesCount);
+	if (tJunctionsCount > 0)
+		XA_PRINT("   Fixed %u t-junctions in %u charts\n", tJunctionsCount, chartsWithTJunctionsCount);
+	XA_PRINT("   %u charts\n", chartCount);
+	XA_PROFILE_PRINT("   Total (concurrent): ", computeChartsConcurrent)
+	XA_PROFILE_PRINT("   Total: ", computeCharts)
+	XA_PROFILE_PRINT("      Atlas builder: ", atlasBuilder)
+	XA_PROFILE_PRINT("         Init: ", atlasBuilderInit)
+	XA_PROFILE_PRINT("         Create initial charts: ", atlasBuilderCreateInitialCharts)
+	XA_PROFILE_PRINT("         Grow charts: ", atlasBuilderGrowCharts)
+	XA_PROFILE_PRINT("         Merge charts: ", atlasBuilderMergeCharts)
+	XA_PROFILE_PRINT("      Create chart meshes: ", createChartMeshes)
+	XA_PROFILE_PRINT("         Fix t-junctions: ", fixChartMeshTJunctions);
+	XA_PROFILE_PRINT("         Close holes: ", closeChartMeshHoles)
+	XA_PRINT_MEM_USAGE
 }
 
-void Generate(Atlas *atlas, CharterOptions charterOptions, PackerOptions packerOptions)
-{
-	xaAssert(atlas);
-	xaAssert(packerOptions.texelArea > 0);
-	// Chart meshes.
-	for (int i = 0; i < (int)atlas->heMeshes.size(); i++) {
-		std::vector<uint32_t> uncharted_materials;
-		atlas->atlas.computeCharts(atlas->heMeshes[i], charterOptions, uncharted_materials);
-	}
-	atlas->atlas.parameterizeCharts();
-	internal::param::AtlasPacker packer(&atlas->atlas);
-	packer.packCharts(packerOptions);
-	//float utilization = return packer.computeAtlasUtilization();
-	atlas->width = packer.getWidth();
-	atlas->height = packer.getHeight();
-	// Build output meshes.
-	atlas->outputMeshes = new OutputMesh*[atlas->heMeshes.size()];
-	for (int i = 0; i < (int)atlas->heMeshes.size(); i++) {
-		const internal::halfedge::Mesh *heMesh = atlas->heMeshes[i];
-		OutputMesh *outputMesh = atlas->outputMeshes[i] = new OutputMesh;
-		const internal::param::MeshCharts *charts = atlas->atlas.meshAt(i);
-		// Vertices.
-		outputMesh->vertexCount = charts->vertexCount();
-		outputMesh->vertexArray = new OutputVertex[outputMesh->vertexCount];
-		for (uint32_t i = 0; i < charts->chartCount(); i++) {
-			const internal::param::Chart *chart = charts->chartAt(i);
-			const uint32_t vertexOffset = charts->vertexCountBeforeChartAt(i);
-			for (uint32_t v = 0; v < chart->vertexCount(); v++) {
-				OutputVertex &output_vertex = outputMesh->vertexArray[vertexOffset + v];
-				output_vertex.xref = chart->mapChartVertexToOriginalVertex(v);
-				internal::Vector2 uv = chart->chartMesh()->vertexAt(v)->tex;
-				output_vertex.uv[0] = uv.x;
-				output_vertex.uv[1] = uv.y;
-			}
-		}
-		// Indices.
-		outputMesh->indexCount = heMesh->faceCount() * 3;
-		outputMesh->indexArray = new uint32_t[outputMesh->indexCount];
-		for (uint32_t f = 0; f < heMesh->faceCount(); f++) {
-			const uint32_t c = charts->faceChartAt(f);
-			const uint32_t i = charts->faceIndexWithinChartAt(f);
-			const uint32_t vertexOffset = charts->vertexCountBeforeChartAt(c);
-			const internal::param::Chart *chart = charts->chartAt(c);
-			xaDebugAssert(i < chart->chartMesh()->faceCount());
-			xaDebugAssert(chart->faceAt(i) == f);
-			const internal::halfedge::Face *face = chart->chartMesh()->faceAt(i);
-			const internal::halfedge::Edge *edge = face->edge;
-			outputMesh->indexArray[3 * f + 0] = vertexOffset + edge->vertex->id;
-			outputMesh->indexArray[3 * f + 1] = vertexOffset + edge->next->vertex->id;
-			outputMesh->indexArray[3 * f + 2] = vertexOffset + edge->next->next->vertex->id;
-		}
-		// Charts.
-		outputMesh->chartCount = charts->chartCount();
-		outputMesh->chartArray = new OutputChart[outputMesh->chartCount];
-		for (uint32_t i = 0; i < charts->chartCount(); i++) {
-			OutputChart *outputChart = &outputMesh->chartArray[i];
-			const internal::param::Chart *chart = charts->chartAt(i);
-			const uint32_t vertexOffset = charts->vertexCountBeforeChartAt(i);
-			const internal::halfedge::Mesh *mesh = chart->chartMesh();
-			outputChart->indexCount = mesh->faceCount() * 3;
-			outputChart->indexArray = new uint32_t[outputChart->indexCount];
-			for (uint32_t j = 0; j < mesh->faceCount(); j++) {
-				const internal::halfedge::Face *face = mesh->faceAt(j);
-				const internal::halfedge::Edge *edge = face->edge;
-				outputChart->indexArray[3 * j + 0] = vertexOffset + edge->vertex->id;
-				outputChart->indexArray[3 * j + 1] = vertexOffset + edge->next->vertex->id;
-				outputChart->indexArray[3 * j + 2] = vertexOffset + edge->next->next->vertex->id;
+void ParameterizeCharts(Atlas *atlas, ParameterizeFunc func)
+{
+	if (!atlas) {
+		XA_PRINT_WARNING("ParameterizeCharts: atlas is null.\n");
+		return;
+	}
+	Context *ctx = (Context *)atlas;
+	if (!ctx->uvMeshInstances.isEmpty()) {
+		XA_PRINT_WARNING("ParameterizeCharts: This function should not be called with UV meshes.\n");
+		return;
+	}
+	if (!ctx->paramAtlas.chartsComputed()) {
+		XA_PRINT_WARNING("ParameterizeCharts: ComputeCharts must be called first.\n");
+		return;
+	}
+	atlas->atlasCount = 0;
+	atlas->height = 0;
+	atlas->texelsPerUnit = 0;
+	atlas->width = 0;
+	if (atlas->utilization) {
+		XA_FREE(atlas->utilization);
+		atlas->utilization = nullptr;
+	}
+	if (atlas->image) {
+		XA_FREE(atlas->image);
+		atlas->image = nullptr;
+	}
+	DestroyOutputMeshes(ctx);
+	XA_PRINT("Parameterizing charts\n");
+	XA_PROFILE_START(parameterizeChartsConcurrent)
+	if (!ctx->paramAtlas.parameterizeCharts(ctx->taskScheduler, func, ctx->progressFunc, ctx->progressUserData)) {
+		XA_PRINT("   Cancelled by user\n");
+			return;
+	}
+	XA_PROFILE_END(parameterizeChartsConcurrent)
+	uint32_t chartCount = 0, orthoChartsCount = 0, planarChartsCount = 0, chartsAddedCount = 0, chartsDeletedCount = 0;
+	for (uint32_t i = 0; i < ctx->meshCount; i++) {
+		for (uint32_t j = 0; j < ctx->paramAtlas.chartGroupCount(i); j++) {
+			const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, j);
+			if (chartGroup->isVertexMap())
+				continue;
+			for (uint32_t k = 0; k < chartGroup->chartCount(); k++) {
+				const internal::param::Chart *chart = chartGroup->chartAt(k);
+				if (chart->isPlanar())
+					planarChartsCount++;
+				else if (chart->isOrtho())
+					orthoChartsCount++;
+			}
+			chartCount += chartGroup->chartCount();
+			chartsAddedCount += chartGroup->paramAddedChartsCount();
+			chartsDeletedCount += chartGroup->paramDeletedChartsCount();
+		}
+	}
+	XA_PRINT("   %u planar charts, %u ortho charts, %u other\n", planarChartsCount, orthoChartsCount, chartCount - (planarChartsCount + orthoChartsCount));
+	if (chartsDeletedCount > 0) {
+		XA_PRINT("   %u charts deleted due to invalid parameterizations, %u new charts added\n", chartsDeletedCount, chartsAddedCount);
+		XA_PRINT("   %u charts\n", ctx->paramAtlas.chartCount());
+	}
+	uint32_t chartIndex = 0, invalidParamCount = 0;
+	for (uint32_t i = 0; i < ctx->meshCount; i++) {
+		for (uint32_t j = 0; j < ctx->paramAtlas.chartGroupCount(i); j++) {
+			const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, j);
+			if (chartGroup->isVertexMap())
+				continue;
+			for (uint32_t k = 0; k < chartGroup->chartCount(); k++) {
+				const internal::param::Chart *chart = chartGroup->chartAt(k);
+				const internal::param::ParameterizationQuality &quality = chart->paramQuality();
+#if XA_DEBUG_EXPORT_OBJ_CHARTS_AFTER_PARAMETERIZATION
+				{
+					char filename[256];
+					XA_SPRINTF(filename, sizeof(filename), "debug_chart_%03u_after_parameterization.obj", chartIndex);
+					chart->unifiedMesh()->writeObjFile(filename);
+				}
+#endif
+				bool invalid = false;
+				if (quality.boundaryIntersection) {
+					invalid = true;
+					XA_PRINT_WARNING("   Chart %u (mesh %u, group %u, id %u) (%s): invalid parameterization, self-intersecting boundary.\n", chartIndex, i, j, k, chart->isPlanar() ? "planar" : chart->isOrtho() ? "ortho" : "other");
+				}
+				if (quality.flippedTriangleCount > 0) {
+					invalid = true;
+					XA_PRINT_WARNING("   Chart %u  (mesh %u, group %u, id %u) (%s): invalid parameterization, %u / %u flipped triangles.\n", chartIndex, i, j, k, chart->isPlanar() ? "planar" : chart->isOrtho() ? "ortho" : "other", quality.flippedTriangleCount, quality.totalTriangleCount);
+				}
+				if (invalid)
+					invalidParamCount++;
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+				if (invalid) {
+					char filename[256];
+					XA_SPRINTF(filename, sizeof(filename), "debug_chart_%03u_invalid_parameterization.obj", chartIndex);
+					const internal::Mesh *mesh = chart->unifiedMesh();
+					FILE *file;
+					XA_FOPEN(file, filename, "w");
+					if (file) {
+						mesh->writeObjVertices(file);
+						fprintf(file, "s off\n");
+						fprintf(file, "o object\n");
+						for (uint32_t f = 0; f < mesh->faceCount(); f++)
+							mesh->writeObjFace(file, f);
+						if (!chart->paramFlippedFaces().isEmpty()) {
+							fprintf(file, "o flipped_faces\n");
+							for (uint32_t f = 0; f < chart->paramFlippedFaces().size(); f++)
+								mesh->writeObjFace(file, chart->paramFlippedFaces()[f]);
+						}
+						mesh->writeObjBoundaryEges(file);
+						mesh->writeObjLinkedBoundaries(file);
+						fclose(file);
+					}
+				}
+#endif
+				chartIndex++;
 			}
 		}
 	}
+	if (invalidParamCount > 0)
+		XA_PRINT_WARNING("   %u charts with invalid parameterizations\n", invalidParamCount);
+	XA_PROFILE_PRINT("   Total (concurrent): ", parameterizeChartsConcurrent)
+	XA_PROFILE_PRINT("   Total: ", parameterizeCharts)
+	XA_PROFILE_PRINT("      Orthogonal: ", parameterizeChartsOrthogonal)
+	XA_PROFILE_PRINT("      LSCM: ", parameterizeChartsLSCM)
+	XA_PROFILE_PRINT("      Evaluate quality: ", parameterizeChartsEvaluateQuality)
+	XA_PRINT_MEM_USAGE
 }
 
-uint32_t GetWidth(const Atlas *atlas)
+void PackCharts(Atlas *atlas, PackOptions packOptions)
 {
-	xaAssert(atlas);
-	return atlas->width;
+	// Validate arguments and context state.
+	if (!atlas) {
+		XA_PRINT_WARNING("PackCharts: atlas is null.\n");
+		return;
+	}
+	Context *ctx = (Context *)atlas;
+	if (ctx->meshCount == 0 && ctx->uvMeshInstances.isEmpty()) {
+		XA_PRINT_WARNING("PackCharts: No meshes. Call AddMesh or AddUvMesh first.\n");
+		return;
+	}
+	if (ctx->uvMeshInstances.isEmpty()) {
+		if (!ctx->paramAtlas.chartsComputed()) {
+			XA_PRINT_WARNING("PackCharts: ComputeCharts must be called first.\n");
+			return;
+		}
+		if (!ctx->paramAtlas.chartsParameterized()) {
+			XA_PRINT_WARNING("PackCharts: ParameterizeCharts must be called first.\n");
+			return;
+		}
+	}
+	if (packOptions.texelsPerUnit < 0.0f) {
+		XA_PRINT_WARNING("PackCharts: PackOptions::texelsPerUnit is negative.\n");
+		packOptions.texelsPerUnit = 0.0f;
+	}
+	// Cleanup atlas.
+	DestroyOutputMeshes(ctx);
+	if (atlas->utilization) {
+		XA_FREE(atlas->utilization);
+		atlas->utilization = nullptr;
+	}
+	if (atlas->image) {
+		XA_FREE(atlas->image);
+		atlas->image = nullptr;
+	}
+	atlas->meshCount = 0;
+	// Pack charts.
+	internal::pack::Atlas packAtlas;
+	if (!ctx->uvMeshInstances.isEmpty()) {
+		for (uint32_t i = 0; i < ctx->uvMeshInstances.size(); i++)
+			packAtlas.addUvMeshCharts(ctx->uvMeshInstances[i]);
+	}
+	else if (ctx->paramAtlas.chartCount() > 0) {
+		ctx->paramAtlas.restoreOriginalChartTexcoords();
+		for (uint32_t i = 0; i < ctx->paramAtlas.chartCount(); i++)
+			packAtlas.addChart(ctx->paramAtlas.chartAt(i));
+	}
+	XA_PROFILE_START(packCharts)
+	if (!packAtlas.packCharts(packOptions, ctx->progressFunc, ctx->progressUserData))
+		return;
+	XA_PROFILE_END(packCharts)
+	// Populate atlas object with pack results.
+	atlas->atlasCount = packAtlas.getNumAtlases();
+	atlas->chartCount = packAtlas.getChartCount();
+	atlas->width = packAtlas.getWidth();
+	atlas->height = packAtlas.getHeight();
+	atlas->texelsPerUnit = packAtlas.getTexelsPerUnit();
+	if (atlas->atlasCount > 0) {
+		atlas->utilization = XA_ALLOC_ARRAY(internal::MemTag::Default, float, atlas->atlasCount);
+		for (uint32_t i = 0; i < atlas->atlasCount; i++)
+			atlas->utilization[i] = packAtlas.getUtilization(i);
+	}
+	if (packOptions.createImage) {
+		atlas->image = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, atlas->atlasCount * atlas->width * atlas->height);
+		for (uint32_t i = 0; i < atlas->atlasCount; i++)
+			packAtlas.getImages()[i]->copyTo(&atlas->image[atlas->width * atlas->height * i], atlas->width, atlas->height);
+	}
+	XA_PROFILE_PRINT("   Total: ", packCharts)
+	XA_PROFILE_PRINT("      Rasterize: ", packChartsRasterize)
+	XA_PROFILE_PRINT("      Dilate (padding): ", packChartsDilate)
+	XA_PROFILE_PRINT("      Find location: ", packChartsFindLocation)
+	XA_PROFILE_PRINT("      Blit: ", packChartsBlit)
+	XA_PRINT_MEM_USAGE
+#if XA_PROFILE
+	internal::s_profile.packCharts = 0;
+	internal::s_profile.packChartsRasterize = 0;
+	internal::s_profile.packChartsDilate = 0;
+	internal::s_profile.packChartsFindLocation = 0;
+	internal::s_profile.packChartsBlit = 0;
+#endif
+	XA_PRINT("Building output meshes\n");
+	int progress = 0;
+	if (ctx->progressFunc) {
+		if (!ctx->progressFunc(ProgressCategory::BuildOutputMeshes, 0, ctx->progressUserData))
+			return;
+	}
+	if (ctx->uvMeshInstances.isEmpty())
+		atlas->meshCount = ctx->meshCount;
+	else
+		atlas->meshCount = ctx->uvMeshInstances.size();
+	atlas->meshes = XA_ALLOC_ARRAY(internal::MemTag::Default, Mesh, atlas->meshCount);
+	memset(atlas->meshes, 0, sizeof(Mesh) * atlas->meshCount);
+	if (ctx->uvMeshInstances.isEmpty()) {
+		uint32_t chartIndex = 0;
+		for (uint32_t i = 0; i < ctx->meshCount; i++) {
+			Mesh &outputMesh = atlas->meshes[i];
+			// Count and alloc arrays. Ignore vertex mapped chart groups in Mesh::chartCount, since they're ignored faces.
+			for (uint32_t cg = 0; cg < ctx->paramAtlas.chartGroupCount(i); cg++) {
+				const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, cg);
+				if (chartGroup->isVertexMap()) {
+					outputMesh.vertexCount += chartGroup->mesh()->vertexCount();
+					outputMesh.indexCount += chartGroup->mesh()->faceCount() * 3;
+				} else {
+					for (uint32_t c = 0; c < chartGroup->chartCount(); c++) {
+						const internal::param::Chart *chart = chartGroup->chartAt(c);
+						outputMesh.vertexCount += chart->mesh()->vertexCount();
+						outputMesh.indexCount += chart->mesh()->faceCount() * 3;
+						outputMesh.chartCount++;
+					}
+				}
+			}
+			outputMesh.vertexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Vertex, outputMesh.vertexCount);
+			outputMesh.indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputMesh.indexCount);
+			outputMesh.chartArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Chart, outputMesh.chartCount);
+			XA_PRINT("   mesh %u: %u vertices, %u triangles, %u charts\n", i, outputMesh.vertexCount, outputMesh.indexCount / 3, outputMesh.chartCount);
+			// Copy mesh data.
+			uint32_t firstVertex = 0;
+			uint32_t meshChartIndex = 0;
+			for (uint32_t cg = 0; cg < ctx->paramAtlas.chartGroupCount(i); cg++) {
+				const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, cg);
+				if (chartGroup->isVertexMap()) {
+					const internal::Mesh *mesh = chartGroup->mesh();
+					// Vertices.
+					for (uint32_t v = 0; v < mesh->vertexCount(); v++) {
+						Vertex &vertex = outputMesh.vertexArray[firstVertex + v];
+						vertex.atlasIndex = -1;
+						vertex.chartIndex = -1;
+						vertex.uv[0] = vertex.uv[1] = 0.0f;
+						vertex.xref = chartGroup->mapVertexToSourceVertex(v);
+					}
+					// Indices.
+					for (uint32_t f = 0; f < mesh->faceCount(); f++) {
+						const uint32_t indexOffset = chartGroup->mapFaceToSourceFace(f) * 3;
+						for (uint32_t j = 0; j < 3; j++)
+							outputMesh.indexArray[indexOffset + j] = firstVertex + mesh->vertexAt(f * 3 + j);
+					}
+					firstVertex += mesh->vertexCount();
+				} else {
+					for (uint32_t c = 0; c < chartGroup->chartCount(); c++) {
+						const internal::param::Chart *chart = chartGroup->chartAt(c);
+						const internal::Mesh *mesh = chart->mesh();
+						// Vertices.
+						for (uint32_t v = 0; v < mesh->vertexCount(); v++) {
+							Vertex &vertex = outputMesh.vertexArray[firstVertex + v];
+							vertex.atlasIndex = packAtlas.getChart(chartIndex)->atlasIndex;
+							XA_DEBUG_ASSERT(vertex.atlasIndex >= 0);
+							vertex.chartIndex = (int32_t)chartIndex;
+							const internal::Vector2 &uv = mesh->texcoord(v);
+							vertex.uv[0] = internal::max(0.0f, uv.x);
+							vertex.uv[1] = internal::max(0.0f, uv.y);
+							vertex.xref = chartGroup->mapVertexToSourceVertex(chart->mapChartVertexToOriginalVertex(v));
+						}
+						// Indices.
+						for (uint32_t f = 0; f < mesh->faceCount(); f++) {
+							const uint32_t indexOffset = chartGroup->mapFaceToSourceFace(chart->mapFaceToSourceFace(f)) * 3;
+							for (uint32_t j = 0; j < 3; j++)
+								outputMesh.indexArray[indexOffset + j] = firstVertex + mesh->vertexAt(f * 3 + j);
+						}
+						// Charts.
+						Chart *outputChart = &outputMesh.chartArray[meshChartIndex];
+						const int32_t atlasIndex = packAtlas.getChart(chartIndex)->atlasIndex;
+						XA_DEBUG_ASSERT(atlasIndex >= 0);
+						outputChart->atlasIndex = (uint32_t)atlasIndex;
+						outputChart->flags = 0;
+						if (chart->paramQuality().boundaryIntersection || chart->paramQuality().flippedTriangleCount > 0)
+							outputChart->flags |= ChartFlags::Invalid;
+						outputChart->indexCount = mesh->faceCount() * 3;
+						outputChart->indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputChart->indexCount);
+						for (uint32_t f = 0; f < mesh->faceCount(); f++) {
+							for (uint32_t j = 0; j < 3; j++)
+								outputChart->indexArray[3 * f + j] = firstVertex + mesh->vertexAt(f * 3 + j);
+						}
+						outputChart->material = 0;
+						meshChartIndex++;
+						chartIndex++;
+						firstVertex += chart->mesh()->vertexCount();
+					}
+				}
+			}
+			XA_DEBUG_ASSERT(outputMesh.vertexCount == firstVertex);
+			XA_DEBUG_ASSERT(outputMesh.chartCount == meshChartIndex);
+			if (ctx->progressFunc) {
+				const int newProgress = int((i + 1) / (float)atlas->meshCount * 100.0f);
+				if (newProgress != progress) {
+					progress = newProgress;
+					if (!ctx->progressFunc(ProgressCategory::BuildOutputMeshes, progress, ctx->progressUserData))
+						return;
+				}
+			}
+		}
+	} else {
+		uint32_t chartIndex = 0;
+		for (uint32_t m = 0; m < ctx->uvMeshInstances.size(); m++) {
+			Mesh &outputMesh = atlas->meshes[m];
+			const internal::UvMeshInstance *mesh = ctx->uvMeshInstances[m];
+			// Alloc arrays.
+			outputMesh.vertexCount = mesh->texcoords.size();
+			outputMesh.indexCount = mesh->mesh->indices.size();
+			outputMesh.chartCount = mesh->mesh->charts.size();
+			outputMesh.vertexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Vertex, outputMesh.vertexCount);
+			outputMesh.indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputMesh.indexCount);
+			outputMesh.chartArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Chart, outputMesh.chartCount);
+			XA_PRINT("   UV mesh %u: %u vertices, %u triangles, %u charts\n", m, outputMesh.vertexCount, outputMesh.indexCount / 3, outputMesh.chartCount);
+			// Copy mesh data.
+			// Vertices.
+			for (uint32_t v = 0; v < mesh->texcoords.size(); v++) {
+				Vertex &vertex = outputMesh.vertexArray[v];
+				vertex.uv[0] = mesh->texcoords[v].x;
+				vertex.uv[1] = mesh->texcoords[v].y;
+				vertex.xref = v;
+				const uint32_t meshChartIndex = mesh->mesh->vertexToChartMap[v];
+				if (meshChartIndex == UINT32_MAX) {
+					// Vertex doesn't exist in any chart.
+					vertex.atlasIndex = -1;
+					vertex.chartIndex = -1;
+				} else {
+					const internal::pack::Chart *chart = packAtlas.getChart(chartIndex + meshChartIndex);
+					vertex.atlasIndex = chart->atlasIndex;
+					vertex.chartIndex = (int32_t)chartIndex + meshChartIndex;
+				}
+			}
+			// Indices.
+			memcpy(outputMesh.indexArray, mesh->mesh->indices.data(), mesh->mesh->indices.size() * sizeof(uint32_t));
+			// Charts.
+			for (uint32_t c = 0; c < mesh->mesh->charts.size(); c++) {
+				Chart *outputChart = &outputMesh.chartArray[c];
+				const internal::pack::Chart *chart = packAtlas.getChart(chartIndex);
+				XA_DEBUG_ASSERT(chart->atlasIndex >= 0);
+				outputChart->atlasIndex = (uint32_t)chart->atlasIndex;
+				outputChart->indexCount = chart->indexCount;
+				outputChart->indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputChart->indexCount);
+				outputChart->material = chart->material;
+				memcpy(outputChart->indexArray, chart->indices, chart->indexCount * sizeof(uint32_t));
+				chartIndex++;
+			}
+			if (ctx->progressFunc) {
+				const int newProgress = int((m + 1) / (float)atlas->meshCount * 100.0f);
+				if (newProgress != progress) {
+					progress = newProgress;
+					if (!ctx->progressFunc(ProgressCategory::BuildOutputMeshes, progress, ctx->progressUserData))
+						return;
+				}
+			}
+		}
+	}
+	if (ctx->progressFunc && progress != 100)
+		ctx->progressFunc(ProgressCategory::BuildOutputMeshes, 100, ctx->progressUserData);
+	XA_PRINT_MEM_USAGE
+}
+
+void Generate(Atlas *atlas, ChartOptions chartOptions, ParameterizeFunc paramFunc, PackOptions packOptions)
+{
+	if (!atlas) {
+		XA_PRINT_WARNING("Generate: atlas is null.\n");
+		return;
+	}
+	Context *ctx = (Context *)atlas;
+	if (!ctx->uvMeshInstances.isEmpty()) {
+		XA_PRINT_WARNING("Generate: This function should not be called with UV meshes.\n");
+		return;
+	}
+	if (ctx->meshCount == 0) {
+		XA_PRINT_WARNING("Generate: No meshes. Call AddMesh first.\n");
+		return;
+	}
+	ComputeCharts(atlas, chartOptions);
+	ParameterizeCharts(atlas, paramFunc);
+	PackCharts(atlas, packOptions);
 }
 
-uint32_t GetHeight(const Atlas *atlas)
+void SetProgressCallback(Atlas *atlas, ProgressFunc progressFunc, void *progressUserData)
 {
-	xaAssert(atlas);
-	return atlas->height;
+	if (!atlas) {
+		XA_PRINT_WARNING("SetProgressCallback: atlas is null.\n");
+		return;
+	}
+	Context *ctx = (Context *)atlas;
+	ctx->progressFunc = progressFunc;
+	ctx->progressUserData = progressUserData;
 }
 
-uint32_t GetNumCharts(const Atlas *atlas)
+void SetRealloc(ReallocFunc reallocFunc)
 {
-	xaAssert(atlas);
-	return atlas->atlas.chartCount();
+	internal::s_realloc = reallocFunc;
+}
+
+void SetPrint(PrintFunc print, bool verbose)
+{
+	internal::s_print = print;
+	internal::s_printVerbose = verbose;
 }
 
-const OutputMesh * const *GetOutputMeshes(const Atlas *atlas)
+const char *StringForEnum(AddMeshError::Enum error)
 {
-	xaAssert(atlas);
-	return atlas->outputMeshes;
+	if (error == AddMeshError::Error)
+		return "Unspecified error";
+	if (error == AddMeshError::IndexOutOfRange)
+		return "Index out of range";
+	if (error == AddMeshError::InvalidIndexCount)
+		return "Invalid index count";
+	return "Success";
 }
 
-const char *StringForEnum(AddMeshErrorCode::Enum error)
-{
-	if (error == AddMeshErrorCode::AlreadyAddedEdge)
-		return "already added edge";
-	if (error == AddMeshErrorCode::DegenerateColocalEdge)
-		return "degenerate colocal edge";
-	if (error == AddMeshErrorCode::DegenerateEdge)
-		return "degenerate edge";
-	if (error == AddMeshErrorCode::DuplicateEdge)
-		return "duplicate edge";
-	if (error == AddMeshErrorCode::IndexOutOfRange)
-		return "index out of range";
-	if (error == AddMeshErrorCode::InvalidIndexCount)
-		return "invalid index count";
-	if (error == AddMeshErrorCode::ZeroAreaFace)
-		return "zero area face";
-	if (error == AddMeshErrorCode::ZeroLengthEdge)
-		return "zero length edge";
-	return "success";
+const char *StringForEnum(ProgressCategory::Enum category)
+{
+	if (category == ProgressCategory::AddMesh)
+		return "Adding mesh(es)";
+	if (category == ProgressCategory::ComputeCharts)
+		return "Computing charts";
+	if (category == ProgressCategory::ParameterizeCharts)
+		return "Parameterizing charts";
+	if (category == ProgressCategory::PackCharts)
+		return "Packing charts";
+	if (category == ProgressCategory::BuildOutputMeshes)
+		return "Building output meshes";
+	return "";
 }
 
 } // namespace xatlas
diff --git a/thirdparty/xatlas/xatlas.h b/thirdparty/xatlas/xatlas.h
index dbf8ca08c7..c123e800b4 100644
--- a/thirdparty/xatlas/xatlas.h
+++ b/thirdparty/xatlas/xatlas.h
@@ -1,176 +1,254 @@
-// This code is in the public domain -- castanyo@yahoo.es
+/*
+MIT License
+
+Copyright (c) 2018-2019 Jonathan Young
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+/*
+thekla_atlas
+MIT License
+https://github.com/Thekla/thekla_atlas
+Copyright (c) 2013 Thekla, Inc
+Copyright NVIDIA Corporation 2006 -- Ignacio Castano <icastano@nvidia.com>
+*/
 #pragma once
 #ifndef XATLAS_H
 #define XATLAS_H
-#include <float.h> // FLT_MAX
-// -- GODOT start --
-#include <limits.h> // INT_MAX, UINT_MAX
-// -- GODOT end --
+#include <stdint.h>
 
 namespace xatlas {
 
-typedef void (*PrintFunc)(const char *, ...);
+struct ChartFlags
+{
+	enum
+	{
+		Invalid = 1 << 0
+	};
+};
 
-struct Atlas;
+// A group of connected faces, belonging to a single atlas.
+struct Chart
+{
+	uint32_t atlasIndex; // Sub-atlas index.
+	uint32_t flags;
+	uint32_t *indexArray;
+	uint32_t indexCount;
+	uint32_t material;
+};
 
-struct CharterOptions
+// Output vertex.
+struct Vertex
 {
-	float proxyFitMetricWeight;
-	float roundnessMetricWeight;
-	float straightnessMetricWeight;
-	float normalSeamMetricWeight;
-	float textureSeamMetricWeight;
-	float maxChartArea;
-	float maxBoundaryLength;
-
-	CharterOptions()
-	{
-		// These are the default values we use on The Witness.
-		proxyFitMetricWeight = 2.0f;
-		roundnessMetricWeight = 0.01f;
-		straightnessMetricWeight = 6.0f;
-		normalSeamMetricWeight = 4.0f;
-		textureSeamMetricWeight = 0.5f;
-		/*
-		proxyFitMetricWeight = 1.0f;
-		roundnessMetricWeight = 0.1f;
-		straightnessMetricWeight = 0.25f;
-		normalSeamMetricWeight = 1.0f;
-		textureSeamMetricWeight = 0.1f;
-		*/
-		maxChartArea = FLT_MAX;
-		maxBoundaryLength = FLT_MAX;
-	}
+	int32_t atlasIndex; // Sub-atlas index. -1 if the vertex doesn't exist in any atlas.
+	int32_t chartIndex; // -1 if the vertex doesn't exist in any chart.
+	float uv[2]; // Not normalized - values are in Atlas width and height range.
+	uint32_t xref; // Index of input vertex from which this output vertex originated.
 };
 
-struct PackMethod
+// Output mesh.
+struct Mesh
 {
-	enum Enum
-	{
-		TexelArea, // texel_area determines resolution
-		ApproximateResolution, // guess texel_area to approximately match desired resolution
-		ExactResolution // run the packer multiple times to exactly match the desired resolution (slow)
-	};
+	Chart *chartArray;
+	uint32_t chartCount;
+	uint32_t *indexArray;
+	uint32_t indexCount;
+	Vertex *vertexArray;
+	uint32_t vertexCount;
 };
 
-struct PackerOptions
+static const uint32_t kImageChartIndexMask = 0x3FFFFFFF;
+static const uint32_t kImageHasChartIndexBit = 0x40000000;
+static const uint32_t kImageIsPaddingBit = 0x80000000;
+
+// Empty on creation. Populated after charts are packed.
+struct Atlas
 {
-	PackMethod::Enum method;
-
-	// 0 - brute force
-	// 1 - 4096 attempts
-	// 2 - 2048
-	// 3 - 1024
-	// 4 - 512
-	// other - 256
-	// Avoid brute force packing, since it can be unusably slow in some situations.
-	int quality;
-
-	float texelArea;       // This is not really texel area, but 1 / texel width?
-	uint32_t resolution;
-	bool blockAlign;       // Align charts to 4x4 blocks. 
-	bool conservative;      // Pack charts with extra padding.
-	int padding;
-
-	PackerOptions()
-	{
-		method = PackMethod::ApproximateResolution;
-		quality = 1;
-		texelArea = 8;
-		resolution = 512;
-		blockAlign = false;
-		conservative = false;
-		padding = 0;
-	}
+	uint32_t width; // Atlas width in texels.
+	uint32_t height; // Atlas height in texels.
+	uint32_t atlasCount; // Number of sub-atlases. Equal to 0 unless PackOptions resolution is changed from default (0).
+	uint32_t chartCount; // Total number of charts in all meshes.
+	uint32_t meshCount; // Number of output meshes. Equal to the number of times AddMesh was called.
+	Mesh *meshes; // The output meshes, corresponding to each AddMesh call.
+	float *utilization; // Normalized atlas texel utilization array. E.g. a value of 0.8 means 20% empty space. atlasCount in length.
+	float texelsPerUnit; // Equal to PackOptions texelsPerUnit if texelsPerUnit > 0, otherwise an estimated value to match PackOptions resolution.
+	uint32_t *image;
 };
 
-struct AddMeshErrorCode
+// Create an empty atlas.
+Atlas *Create();
+
+void Destroy(Atlas *atlas);
+
+struct IndexFormat
 {
 	enum Enum
 	{
-		Success,
-		AlreadyAddedEdge, // index0 and index1 are the edge indices
-		DegenerateColocalEdge, // index0 and index1 are the edge indices
-		DegenerateEdge, // index0 and index1 are the edge indices
-		DuplicateEdge, // index0 and index1 are the edge indices
-		IndexOutOfRange, // index0 is the index
-		InvalidIndexCount, // not evenly divisible by 3 - expecting triangles
-		ZeroAreaFace,
-		ZeroLengthEdge // index0 and index1 are the edge indices
+		UInt16,
+		UInt32
 	};
 };
 
-struct AddMeshError
+// Input mesh declaration.
+struct MeshDecl
 {
-	AddMeshErrorCode::Enum code;
-	uint32_t face;
-	uint32_t index0, index1;
+	uint32_t vertexCount = 0;
+	const void *vertexPositionData = nullptr;
+	uint32_t vertexPositionStride = 0;
+	const void *vertexNormalData = nullptr; // optional
+	uint32_t vertexNormalStride = 0; // optional
+	const void *vertexUvData = nullptr; // optional. The input UVs are provided as a hint to the chart generator.
+	uint32_t vertexUvStride = 0; // optional
+	uint32_t indexCount = 0;
+	const void *indexData = nullptr; // optional
+	int32_t indexOffset = 0; // optional. Add this offset to all indices.
+	IndexFormat::Enum indexFormat = IndexFormat::UInt16;
+	
+	// Optional. indexCount / 3 (triangle count) in length.
+	// Don't atlas faces set to true. Ignored faces still exist in the output meshes, Vertex uv is set to (0, 0) and Vertex atlasIndex to -1.
+	const bool *faceIgnoreData = nullptr;
+
+	// Vertex positions within epsilon distance of each other are considered colocal.
+	float epsilon = 1.192092896e-07F;
 };
 
-struct IndexFormat
+struct AddMeshError
 {
 	enum Enum
 	{
-		HalfFloat,
-		Float
+		Success, // No error.
+		Error, // Unspecified error.
+		IndexOutOfRange, // An index is >= MeshDecl vertexCount.
+		InvalidIndexCount // Not evenly divisible by 3 - expecting triangles.
 	};
 };
 
-struct InputMesh
-{
-	uint32_t vertexCount;
-	const void *vertexPositionData;
-	uint32_t vertexPositionStride;
-	const void *vertexNormalData; // optional
-	uint32_t vertexNormalStride; // optional
-
-	// optional
-	// The input UVs are provided as a hint to the chart generator.
-	const void *vertexUvData;
-	uint32_t vertexUvStride;
+// Add a mesh to the atlas. MeshDecl data is copied, so it can be freed after AddMesh returns.
+AddMeshError::Enum AddMesh(Atlas *atlas, const MeshDecl &meshDecl, uint32_t meshCountHint = 0);
 
-	uint32_t indexCount;
-	const void *indexData;
-	IndexFormat::Enum indexFormat;
+// Wait for AddMesh async processing to finish. ComputeCharts / Generate call this internally.
+void AddMeshJoin(Atlas *atlas);
 
-	// optional. indexCount / 3 in length.
-	// Charter also uses material boundaries as a hint to cut charts.
-	const uint16_t *faceMaterialData;
+struct UvMeshDecl
+{
+	uint32_t vertexCount = 0;
+	uint32_t vertexStride = 0;
+	const void *vertexUvData = nullptr;
+	uint32_t indexCount = 0;
+	const void *indexData = nullptr; // optional
+	int32_t indexOffset = 0; // optional. Add this offset to all indices.
+	IndexFormat::Enum indexFormat = IndexFormat::UInt16;
+	const uint32_t *faceMaterialData = nullptr; // Optional. Faces with different materials won't be assigned to the same chart. Must be indexCount / 3 in length.
+	bool rotateCharts = true;
 };
 
-struct OutputChart
+AddMeshError::Enum AddUvMesh(Atlas *atlas, const UvMeshDecl &decl);
+
+struct ChartOptions
 {
-	uint32_t *indexArray;
-	uint32_t indexCount;
+	float maxChartArea = 0.0f; // Don't grow charts to be larger than this. 0 means no limit.
+	float maxBoundaryLength = 0.0f; // Don't grow charts to have a longer boundary than this. 0 means no limit.
+
+	// Weights determine chart growth. Higher weights mean higher cost for that metric.
+	float proxyFitMetricWeight = 2.0f; // Angle between face and average chart normal.
+	float roundnessMetricWeight = 0.01f;
+	float straightnessMetricWeight = 6.0f;
+	float normalSeamMetricWeight = 4.0f; // If > 1000, normal seams are fully respected.
+	float textureSeamMetricWeight = 0.5f;
+
+	float maxThreshold = 2.0f; // If total of all metrics * weights > maxThreshold, don't grow chart. Lower values result in more charts.
+	uint32_t growFaceCount = 32; // Grow this many faces at a time.
+	uint32_t maxIterations = 1; // Number of iterations of the chart growing and seeding phases. Higher values result in better charts.
 };
 
-struct OutputVertex
+// Call after all AddMesh calls. Can be called multiple times to recompute charts with different options.
+void ComputeCharts(Atlas *atlas, ChartOptions chartOptions = ChartOptions());
+
+// Custom parameterization function. texcoords initial values are an orthogonal parameterization.
+typedef void (*ParameterizeFunc)(const float *positions, float *texcoords, uint32_t vertexCount, const uint32_t *indices, uint32_t indexCount);
+
+// Call after ComputeCharts. Can be called multiple times to re-parameterize charts with a different ParameterizeFunc.
+void ParameterizeCharts(Atlas *atlas, ParameterizeFunc func = nullptr);
+
+struct PackOptions
 {
-	float uv[2];
-	uint32_t xref;   // Index of input vertex from which this output vertex originated.
+	// Slower, but gives the best result. If false, use random chart placement.
+	bool bruteForce = false;
+
+	// Create Atlas::image
+	bool createImage = false;
+
+	// Unit to texel scale. e.g. a 1x1 quad with texelsPerUnit of 32 will take up approximately 32x32 texels in the atlas.
+	// If 0, an estimated value will be calculated to approximately match the given resolution.
+	// If resolution is also 0, the estimated value will approximately match a 1024x1024 atlas.
+	float texelsPerUnit = 0.0f;
+
+	// If 0, generate a single atlas with texelsPerUnit determining the final resolution.
+	// If not 0, and texelsPerUnit is not 0, generate one or more atlases with that exact resolution.
+	// If not 0, and texelsPerUnit is 0, texelsPerUnit is estimated to approximately match the resolution.
+	uint32_t resolution = 0;
+
+	// Charts larger than this will be scaled down.
+	uint32_t maxChartSize = 1024;
+
+	// Align charts to 4x4 blocks. Also improves packing speed, since there are fewer possible chart locations to consider.
+	bool blockAlign = false;
+
+	// Number of pixels to pad charts with.
+	uint32_t padding = 0;
 };
 
-struct OutputMesh
+// Call after ParameterizeCharts. Can be called multiple times to re-pack charts with different options.
+void PackCharts(Atlas *atlas, PackOptions packOptions = PackOptions());
+
+// Equivalent to calling ComputeCharts, ParameterizeCharts and PackCharts in sequence. Can be called multiple times to regenerate with different options.
+void Generate(Atlas *atlas, ChartOptions chartOptions = ChartOptions(), ParameterizeFunc paramFunc = nullptr, PackOptions packOptions = PackOptions());
+
+// Progress tracking.
+struct ProgressCategory
 {
-	OutputChart *chartArray;
-	uint32_t chartCount;
-	uint32_t *indexArray;
-	uint32_t indexCount;
-	OutputVertex *vertexArray;
-	uint32_t vertexCount;
+	enum Enum
+	{
+		AddMesh,
+		ComputeCharts,
+		ParameterizeCharts,
+		PackCharts,
+		BuildOutputMeshes
+	};
 };
 
-void SetPrint(PrintFunc print);
-Atlas *Create();
-void Destroy(Atlas *atlas);
-// useColocalVertices - generates fewer charts (good), but is more sensitive to bad geometry.
-AddMeshError AddMesh(Atlas *atlas, const InputMesh &mesh, bool useColocalVertices = true);
-void Generate(Atlas *atlas, CharterOptions charterOptions = CharterOptions(), PackerOptions packerOptions = PackerOptions());
-uint32_t GetWidth(const Atlas *atlas);
-uint32_t GetHeight(const Atlas *atlas);
-uint32_t GetNumCharts(const Atlas *atlas);
-const OutputMesh * const *GetOutputMeshes(const Atlas *atlas);
-const char *StringForEnum(AddMeshErrorCode::Enum error);
+// May be called from any thread. Return false to cancel.
+typedef bool (*ProgressFunc)(ProgressCategory::Enum category, int progress, void *userData);
+
+void SetProgressCallback(Atlas *atlas, ProgressFunc progressFunc = nullptr, void *progressUserData = nullptr);
+
+// Custom memory allocation.
+typedef void *(*ReallocFunc)(void *, size_t);
+void SetRealloc(ReallocFunc reallocFunc);
+
+// Custom print function.
+typedef int (*PrintFunc)(const char *, ...);
+void SetPrint(PrintFunc print, bool verbose);
+
+// Helper functions for error messages.
+const char *StringForEnum(AddMeshError::Enum error);
+const char *StringForEnum(ProgressCategory::Enum category);
 
 } // namespace xatlas