godot/thirdparty/xatlas/xatlas.cpp

// This code is in the public domain -- [email protected]
#include "xatlas.h"
#include <assert.h>
#include <float.h>
#include <math.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <algorithm>
#include <cmath>
#include <memory>
#include <unordered_map>
#include <vector>

#undef min
#undef max

#ifndef xaAssert
#define xaAssert(exp)                                    \
	if (!(exp)) {                                        \
		xaPrint("%s %s %s\n", #exp, __FILE__, __LINE__); \
	}
#endif
#ifndef xaDebugAssert
#define xaDebugAssert(exp) assert(exp)
#endif
#ifndef xaPrint
#define xaPrint(...)                            \
	if (xatlas::internal::s_print) {            \
		xatlas::internal::s_print(__VA_ARGS__); \
	}
#endif

#ifdef _MSC_VER
// Ignore gcc attributes.
#define __attribute__(X)
#endif

#ifdef _MSC_VER
#define restrict
#define NV_FORCEINLINE __forceinline
#else
#define restrict __restrict__
#define NV_FORCEINLINE __attribute__((always_inline)) inline
#endif

#define NV_UINT32_MAX 0xffffffff
#define NV_FLOAT_MAX 3.402823466e+38F

#ifndef PI
#define PI float(3.1415926535897932384626433833)
#endif

#define NV_EPSILON (0.0001f)
#define NV_NORMAL_EPSILON (0.001f)

namespace xatlas {
namespace internal {

static PrintFunc s_print = NULL;

static int align(int x, int a) {
	return (x + a - 1) & ~(a - 1);
}

static bool isAligned(int x, int a) {
	return (x & (a - 1)) == 0;
}

/// 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 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));
}

/// 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);
}

static float saturate(float f) {
	return clamp(f, 0.0f, 1.0f);
}

// Robust floating point comparisons:
// http://realtimecollisiondetection.net/blog/?p=89
static bool equal(const float f0, const float f1, const float epsilon = NV_EPSILON) {
	//return fabs(f0-f1) <= epsilon;
	return fabs(f0 - f1) <= epsilon * max3(1.0f, fabsf(f0), fabsf(f1));
}

NV_FORCEINLINE static int ftoi_floor(float val) {
	return (int)val;
}

NV_FORCEINLINE static int ftoi_ceil(float val) {
	return (int)ceilf(val);
}

NV_FORCEINLINE static int ftoi_round(float f) {
	return int(floorf(f + 0.5f));
}

static bool isZero(const float f, const float epsilon = NV_EPSILON) {
	return fabs(f) <= epsilon;
}

static float lerp(float f0, float f1, float t) {
	const float s = 1.0f - t;
	return f0 * s + f1 * t;
}

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.
* @note isPowerOfTwo(x) == true -> nextPowerOfTwo(x) == x
* @note nextPowerOfTwo(x) = 2 << log2(x-1)
*/
static uint32_t nextPowerOfTwo(uint32_t x) {
	xaDebugAssert(x != 0);
	// On modern CPUs this is supposed to be as fast as using the bsr instruction.
	x--;
	x |= x >> 1;
	x |= x >> 2;
	x |= x >> 4;
	x |= x >> 8;
	x |= x >> 16;
	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;
	uint32_t i = 0;
	while (i < size) {
		h = (h << 16) + (h << 6) - h + (uint32_t)data[i++];
	}
	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 {
	uint32_t operator()(const Key &k) const { return hash(k); }
};

template <typename Key>
struct Equal {
	bool operator()(const Key &k0, const Key &k1) const { return k0 == k1; }
};

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) {
		x += v.x;
		y += v.y;
	}

	void operator-=(Vector2::Arg v) {
		x -= v.x;
		y -= v.y;
	}

	void operator*=(float s) {
		x *= s;
		y *= s;
	}

	void operator*=(Vector2::Arg 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];
	};
};

Vector2 operator+(Vector2::Arg a, Vector2::Arg b) {
	return Vector2(a.x + b.x, a.y + b.y);
}

Vector2 operator-(Vector2::Arg a, Vector2::Arg b) {
	return Vector2(a.x - b.x, a.y - b.y);
}

Vector2 operator*(Vector2::Arg v, float s) {
	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);
}

Vector2 operator/(Vector2::Arg v, float s) {
	return Vector2(v.x / s, v.y / s);
}

Vector2 lerp(Vector2::Arg v1, Vector2::Arg v2, float t) {
	const float s = 1.0f - t;
	return Vector2(v1.x * s + t * v2.x, v1.y * s + t * v2.y);
}

float dot(Vector2::Arg a, Vector2::Arg b) {
	return a.x * b.x + a.y * b.y;
}

float lengthSquared(Vector2::Arg v) {
	return v.x * v.x + v.y * v.y;
}

float length(Vector2::Arg 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) {
	return equal(length(v), 1, epsilon);
}

Vector2 normalize(Vector2::Arg v, float epsilon = NV_EPSILON) {
	float l = length(v);
	xaDebugAssert(!isZero(l, epsilon));
#ifdef NDEBUG
	epsilon = 0; // silence unused parameter warning
#endif
	Vector2 n = v * (1.0f / l);
	xaDebugAssert(isNormalized(n));
	return n;
}

Vector2 normalizeSafe(Vector2::Arg v, Vector2::Arg fallback, float epsilon = NV_EPSILON) {
	float l = length(v);
	if (isZero(l, epsilon)) {
		return fallback;
	}
	return v * (1.0f / l);
}

bool equal(Vector2::Arg v1, Vector2::Arg v2, float epsilon = NV_EPSILON) {
	return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon);
}

Vector2 max(Vector2::Arg a, Vector2::Arg b) {
	return Vector2(std::max(a.x, b.x), std::max(a.y, b.y));
}

bool isFinite(Vector2::Arg v) {
	return std::isfinite(v.x) && std::isfinite(v.y);
}

// Note, this is the area scaled by 2!
float triangleArea(Vector2::Arg v0, Vector2::Arg v1) {
	return (v0.x * v1.y - v0.y * v1.x); // * 0.5f;
}
float triangleArea(Vector2::Arg a, Vector2::Arg b, Vector2::Arg 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;
	// That's actually a terrible idea. Small triangles far from the origin can end up producing fairly large floating point
	// numbers and the results becomes very unstable and dependent on the order of the factors.
	// Instead, it's preferable to subtract the vertices first, and multiply the resulting small values together. The result
	// in this case is always much more accurate (as long as the triangle is small) and less dependent of the location of
	// the triangle.
	//return ((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)); // * 0.5f;
	return triangleArea(a - c, b - c);
}

float triangleArea2(Vector2::Arg v1, Vector2::Arg v2, Vector2::Arg v3) {
	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);
}

static uint32_t hash(const Vector2 &v, uint32_t h) {
	return sdbmFloatHash(v.component, 2, h);
}

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;
	}

	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) {
		x += v.x;
		y += v.y;
		z += v.z;
	}

	void operator-=(Vector3::Arg v) {
		x -= v.x;
		y -= v.y;
		z -= v.z;
	}

	void operator*=(float s) {
		x *= s;
		y *= s;
		z *= s;
	}

	void operator/=(float s) {
		float is = 1.0f / s;
		x *= is;
		y *= is;
		z *= is;
	}

	void operator*=(Vector3::Arg v) {
		x *= v.x;
		y *= v.y;
		z *= v.z;
	}

	void operator/=(Vector3::Arg 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];
	};
};

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) {
	return add(a, b);
}
Vector3 operator+(Vector3::Arg a, float b) {
	return add(a, b);
}

Vector3 sub(Vector3::Arg a, Vector3::Arg 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);
}

Vector3 operator-(Vector3::Arg a, float b) {
	return sub(a, b);
}

Vector3 cross(Vector3::Arg a, Vector3::Arg 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) {
	return Vector3(v.x * s, v.y * s, v.z * s);
}

Vector3 operator*(float s, Vector3::Arg 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) {
	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) {
	return a.x * b.x + a.y * b.y + a.z * b.z;
}

float lengthSquared(Vector3::Arg v) {
	return v.x * v.x + v.y * v.y + v.z * v.z;
}

float length(Vector3::Arg 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) {
	return equal(length(v), 1, epsilon);
}

Vector3 normalize(Vector3::Arg v, float epsilon = NV_EPSILON) {
	float l = length(v);
	xaDebugAssert(!isZero(l, epsilon));
#ifdef NDEBUG
	epsilon = 0; // silence unused parameter warning
#endif
	Vector3 n = v * (1.0f / l);
	xaDebugAssert(isNormalized(n));
	return n;
}

Vector3 normalizeSafe(Vector3::Arg v, Vector3::Arg fallback, float epsilon = NV_EPSILON) {
	float l = length(v);
	if (isZero(l, epsilon)) {
		return fallback;
	}
	return v * (1.0f / l);
}

bool equal(Vector3::Arg v1, Vector3::Arg v2, float epsilon = NV_EPSILON) {
	return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon) && equal(v1.z, v2.z, epsilon);
}

Vector3 min(Vector3::Arg a, Vector3::Arg b) {
	return Vector3(std::min(a.x, b.x), std::min(a.y, b.y), std::min(a.z, b.z));
}

Vector3 max(Vector3::Arg a, Vector3::Arg b) {
	return Vector3(std::max(a.x, b.x), std::max(a.y, b.y), std::max(a.z, b.z));
}

Vector3 clamp(Vector3::Arg v, float min, float max) {
	return Vector3(clamp(v.x, min, max), clamp(v.y, min, max), clamp(v.z, min, max));
}

Vector3 saturate(Vector3::Arg v) {
	return Vector3(saturate(v.x), saturate(v.y), saturate(v.z));
}

Vector3 floor(Vector3::Arg v) {
	return Vector3(floorf(v.x), floorf(v.y), floorf(v.z));
}

bool isFinite(Vector3::Arg v) {
	return std::isfinite(v.x) && std::isfinite(v.y) && std::isfinite(v.z);
}

static uint32_t hash(const Vector3 &v, uint32_t h) {
	return sdbmFloatHash(v.component, 3, h);
}

/// Basis class to compute tangent space basis, ortogonalizations and to
/// transform vectors from one space to another.
class 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) {
		xaAssert(isNormalized(d));
		normal = d;
		// Choose minimum axis.
		if (fabsf(normal.x) < fabsf(normal.y) && fabsf(normal.x) < fabsf(normal.z)) {
			tangent = Vector3(1, 0, 0);
		} else if (fabsf(normal.y) < fabsf(normal.z)) {
			tangent = Vector3(0, 1, 0);
		} else {
			tangent = Vector3(0, 0, 1);
		}
		// Ortogonalize
		tangent -= normal * dot(normal, tangent);
		tangent = normalize(tangent);
		bitangent = cross(normal, tangent);
		// Rotate frame around normal according to angle.
		if (angle != 0.0f) {
			float c = cosf(angle);
			float s = sinf(angle);
			Vector3 tmp = c * tangent - s * bitangent;
			bitangent = s * tangent + c * bitangent;
			tangent = tmp;
		}
	}

	Vector3 tangent;
	Vector3 bitangent;
	Vector3 normal;
};

// Simple bit array.
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;
		m_wordArray.resize((m_size + 31) >> 5);
	}

	/// Get bit.
	bool bitAt(uint32_t b) const {
		xaDebugAssert(b < m_size);
		return (m_wordArray[b >> 5] & (1 << (b & 31))) != 0;
	}

	// Set a bit.
	void setBitAt(uint32_t idx) {
		xaDebugAssert(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));
	}

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;
};

/// Bit map. This should probably be called BitImage.
class BitMap {
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) {}

	uint32_t width() const {
		return m_width;
	}
	uint32_t height() const {
		return m_height;
	}

	void resize(uint32_t w, uint32_t h, bool initValue) {
		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);
			}
		}
		std::swap(m_bitArray, tmp);
		m_width = w;
		m_height = h;
	}

	bool bitAt(uint32_t x, uint32_t y) const {
		xaDebugAssert(x < m_width && y < m_height);
		return m_bitArray.bitAt(y * m_width + x);
	}

	void setBitAt(uint32_t x, uint32_t y) {
		xaDebugAssert(x < m_width && y < m_height);
		m_bitArray.setBitAt(y * m_width + x);
	}

	void clearAll() {
		m_bitArray.clearAll();
	}

private:
	uint32_t m_width;
	uint32_t m_height;
	BitArray m_bitArray;
};

// Axis Aligned Bounding Box.
class Box {
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 {
		return (maxCorner - minCorner) * 0.5f;
	}

	// Add a point to this box.
	void addPointToBounds(const Vector3 &p) {
		minCorner = min(minCorner, p);
		maxCorner = max(maxCorner, p);
	}

	// Get the volume of the box.
	float volume() const {
		Vector3 d = extents();
		return 8.0f * (d.x * d.y * d.z);
	}

	Vector3 minCorner;
	Vector3 maxCorner;
};

class Fit {
public:
	static Vector3 computeCentroid(int n, const Vector3 *__restrict points) {
		Vector3 centroid(0.0f);
		for (int i = 0; i < n; i++) {
			centroid += points[i];
		}
		centroid /= float(n);
		return centroid;
	}

	static Vector3 computeCovariance(int n, const Vector3 *__restrict points, float *__restrict covariance) {
		// compute the centroid
		Vector3 centroid = computeCentroid(n, points);
		// compute covariance matrix
		for (int i = 0; i < 6; i++) {
			covariance[i] = 0.0f;
		}
		for (int i = 0; i < n; i++) {
			Vector3 v = points[i] - centroid;
			covariance[0] += v.x * v.x;
			covariance[1] += v.x * v.y;
			covariance[2] += v.x * v.z;
			covariance[3] += v.y * v.y;
			covariance[4] += v.y * v.z;
			covariance[5] += v.z * v.z;
		}
		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);
		float subd[3];
		float diag[3];
		float work[3][3];
		work[0][0] = matrix[0];
		work[0][1] = work[1][0] = matrix[1];
		work[0][2] = work[2][0] = matrix[2];
		work[1][1] = matrix[3];
		work[1][2] = work[2][1] = matrix[4];
		work[2][2] = matrix[5];
		EigenSolver3_Tridiagonal(work, diag, subd);
		if (!EigenSolver3_QLAlgorithm(work, diag, subd)) {
			for (int i = 0; i < 3; i++) {
				eigenValues[i] = 0;
				eigenVectors[i] = Vector3(0);
			}
			return false;
		}
		for (int i = 0; i < 3; i++) {
			eigenValues[i] = (float)diag[i];
		}
		// 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];
			}
		}
		// 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]);
		}
		if (eigenValues[1] > eigenValues[0]) {
			std::swap(eigenValues[0], eigenValues[1]);
			std::swap(eigenVectors[0], eigenVectors[1]);
		}
		if (eigenValues[2] > eigenValues[1]) {
			std::swap(eigenValues[1], eigenValues[2]);
			std::swap(eigenVectors[1], eigenVectors[2]);
		}
		xaDebugAssert(eigenValues[0] >= eigenValues[1] && eigenValues[0] >= eigenValues[2]);
		xaDebugAssert(eigenValues[1] >= eigenValues[2]);
		return true;
	}

private:
	static void EigenSolver3_Tridiagonal(float mat[3][3], float *diag, float *subd) {
		// Householder reduction T = Q^t M Q
		//   Input:
		//     mat, symmetric 3x3 matrix M
		//   Output:
		//     mat, orthogonal matrix Q
		//     diag, diagonal entries of T
		//     subd, subdiagonal entries of T (T is symmetric)
		const float epsilon = 1e-08f;
		float a = mat[0][0];
		float b = mat[0][1];
		float c = mat[0][2];
		float d = mat[1][1];
		float e = mat[1][2];
		float f = mat[2][2];
		diag[0] = a;
		subd[2] = 0.f;
		if (fabsf(c) >= epsilon) {
			const float ell = sqrtf(b * b + c * c);
			b /= ell;
			c /= ell;
			const float q = 2 * b * e + c * (f - d);
			diag[1] = d + c * q;
			diag[2] = f - c * q;
			subd[0] = ell;
			subd[1] = e - b * q;
			mat[0][0] = 1;
			mat[0][1] = 0;
			mat[0][2] = 0;
			mat[1][0] = 0;
			mat[1][1] = b;
			mat[1][2] = c;
			mat[2][0] = 0;
			mat[2][1] = c;
			mat[2][2] = -b;
		} else {
			diag[1] = d;
			diag[2] = f;
			subd[0] = b;
			subd[1] = e;
			mat[0][0] = 1;
			mat[0][1] = 0;
			mat[0][2] = 0;
			mat[1][0] = 0;
			mat[1][1] = 1;
			mat[1][2] = 0;
			mat[2][0] = 0;
			mat[2][1] = 0;
			mat[2][2] = 1;
		}
	}

	static bool EigenSolver3_QLAlgorithm(float mat[3][3], float *diag, float *subd) {
		// QL iteration with implicit shifting to reduce matrix from tridiagonal
		// to diagonal
		const int maxiter = 32;
		for (int ell = 0; ell < 3; ell++) {
			int iter;
			for (iter = 0; iter < maxiter; iter++) {
				int m;
				for (m = ell; m <= 1; m++) {
					float dd = fabsf(diag[m]) + fabsf(diag[m + 1]);
					if (fabsf(subd[m]) + dd == dd)
						break;
				}
				if (m == ell)
					break;
				float g = (diag[ell + 1] - diag[ell]) / (2 * subd[ell]);
				float r = sqrtf(g * g + 1);
				if (g < 0)
					g = diag[m] - diag[ell] + subd[ell] / (g - r);
				else
					g = diag[m] - diag[ell] + subd[ell] / (g + r);
				float s = 1, c = 1, p = 0;
				for (int i = m - 1; i >= ell; i--) {
					float f = s * subd[i], b = c * subd[i];
					if (fabsf(f) >= fabsf(g)) {
						c = g / f;
						r = sqrtf(c * c + 1);
						subd[i + 1] = f * r;
						c *= (s = 1 / r);
					} else {
						s = f / g;
						r = sqrtf(s * s + 1);
						subd[i + 1] = g * r;
						s *= (c = 1 / r);
					}
					g = diag[i + 1] - p;
					r = (diag[i] - g) * s + 2 * b * c;
					p = s * r;
					diag[i + 1] = g + p;
					g = c * r - b;
					for (int k = 0; k < 3; k++) {
						f = mat[k][i + 1];
						mat[k][i + 1] = s * mat[k][i] + c * f;
						mat[k][i] = c * mat[k][i] - s * f;
					}
				}
				diag[ell] -= p;
				subd[ell] = g;
				subd[m] = 0;
			}
			if (iter == maxiter)
				// should not get here under normal circumstances
				return false;
		}
		return true;
	}
};

/// Fixed size vector class.
class FullVector {
public:
	FullVector(uint32_t dim) { m_array.resize(dim); }
	FullVector(const FullVector &v) :
			m_array(v.m_array) {}

	const FullVector &operator=(const FullVector &v) {
		xaAssert(dimension() == v.dimension());
		m_array = v.m_array;
		return *this;
	}

	uint32_t dimension() const { return m_array.size(); }
	const float &operator[](uint32_t index) const { return m_array[index]; }
	float &operator[](uint32_t index) { return m_array[index]; }

	void fill(float f) {
		const uint32_t dim = dimension();
		for (uint32_t i = 0; i < dim; i++) {
			m_array[i] = f;
		}
	}

	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;
};

namespace halfedge {
class Face;
class Vertex;

class Edge {
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 {
		return vertex;
	}

	Vertex *from() {
		return vertex;
	}

	const Vertex *to() const {
		return pair->vertex; // This used to be 'next->vertex', but that changed often when the connectivity of the mesh changes.
	}

	Vertex *to() {
		return pair->vertex;
	}

	// Edge queries.
	void setNext(Edge *e) {
		next = e;
		if (e != NULL) e->prev = this;
	}
	void setPrev(Edge *e) {
		prev = e;
		if (e != NULL) e->next = this;
	}

	// @@ It would be more simple to only check m_pair == NULL
	// Face queries.
	bool isBoundary() const {
		return !(face && pair->face);
	}

	// @@ This is not exactly accurate, we should compare the texture coordinates...
	bool isSeam() const {
		return vertex != pair->next->vertex || next->vertex != pair->vertex;
	}

	bool isNormalSeam() const;
	bool isTextureSeam() const;

	bool isValid() 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;
	}

	float length() const;

	// Return angle between this edge and the previous one.
	float angle() const;
};

class Vertex {
public:
	uint32_t id;
	uint32_t original_id;
	Edge *edge;
	Vertex *next;
	Vertex *prev;
	Vector3 pos;
	Vector3 nor;
	Vector2 tex;

	Vertex(uint32_t id) :
			id(id),
			original_id(id),
			edge(NULL),
			pos(0.0f),
			nor(0.0f),
			tex(0.0f) {
		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;
		}
	}

	// Update position of all colocals.
	void setPos(const Vector3 &p) {
		for (VertexIterator it(colocals()); !it.isDone(); it.advance()) {
			it.current()->pos = p;
		}
	}

	bool isFirstColocal() const {
		return firstColocal() == this;
	}

	const Vertex *firstColocal() const {
		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;
	}

	Vertex *firstColocal() {
		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();
			}
		}
		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;
			}
		}
		return false;
	}

	void linkColocal(Vertex *v) {
		next->prev = v;
		v->next = next;
		next = v;
		v->prev = this;
	}
	void unlinkColocal() {
		next->prev = prev;
		prev->next = next;
		next = this;
		prev = this;
	}

	// @@ Note: This only works if linkBoundary has been called.
	bool isBoundary() const {
		return (edge && !edge->face);
	}

	// Iterator that visits the edges around this vertex in counterclockwise order.
	class EdgeIterator //: public Iterator<Edge *>
	{
	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;
		}

	private:
		Edge *m_end;
		Edge *m_current;
	};

	EdgeIterator edges() {
		return EdgeIterator(edge);
	}
	EdgeIterator edges(Edge *e) {
		return EdgeIterator(e);
	}

	// Iterator that visits the edges around this vertex in counterclockwise order.
	class ConstEdgeIterator //: public Iterator<Edge *>
	{
	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 Vertex *vertex() const {
			return m_current->to();
		}

	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 *>
	{
	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;
		}

	private:
		Vertex *m_end;
		Vertex *m_current;
	};

	VertexIterator colocals() {
		return VertexIterator(this);
	}

	// Iterator that visits all the colocal vertices.
	class ConstVertexIterator //: public Iterator<Edge *>
	{
	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;
		}
		virtual const Vertex *current() const {
			return m_current;
		}

	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 {
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) {}

	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 {
		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);
			}
		}
		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;
	}

	// The iterator that visits the edges of this face in clockwise order.
	class EdgeIterator //: public Iterator<Edge *>
	{
	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;
		}

		virtual bool isDone() const {
			return m_end == m_current;
		}
		virtual Edge *current() const {
			return m_current;
		}
		Vertex *vertex() const {
			return m_current->vertex;
		}

	private:
		Edge *m_end;
		Edge *m_current;
	};

	EdgeIterator edges() {
		return EdgeIterator(edge);
	}
	EdgeIterator edges(Edge *e) {
		xaDebugAssert(contains(e));
		return EdgeIterator(e);
	}

	// 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()) {}

		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 const Edge *current() const {
			return m_current;
		}
		const Vertex *vertex() const {
			return m_current->vertex;
		}

	private:
		const Edge *m_end;
		const Edge *m_current;
	};

	ConstEdgeIterator edges() const {
		return ConstEdgeIterator(edge);
	}
	ConstEdgeIterator edges(const Edge *e) const {
		xaDebugAssert(contains(e));
		return ConstEdgeIterator(e);
	}
};

/// Simple half edge mesh designed for dynamic mesh manipulation.
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() {
		clear();
	}

	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();
	}

	Vertex *addVertex(const Vector3 &pos) {
		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?
	}

	void linkColocalsWithCanonicalMap(const std::vector<uint32_t> &canonicalMap) {
		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;
	}

	Face *addFace(uint32_t v0, uint32_t v1, uint32_t v2) {
		uint32_t indexArray[3];
		indexArray[0] = v0;
		indexArray[1] = v1;
		indexArray[2] = v2;
		return addFace(indexArray, 3, 0, 3);
	}

	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;
			}
		}

		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;
			}
		}

		//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);
	}

	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);
	}

	Face *addFace(const std::vector<uint32_t> &indexArray) {
		return addFace(indexArray, 0, indexArray.size());
	}

	Face *addFace(const std::vector<uint32_t> &indexArray, uint32_t first, uint32_t num) {
		return addFace(indexArray.data(), (uint32_t)indexArray.size(), first, num);
	}

	Face *addFace(const uint32_t *indexArray, uint32_t indexCount, uint32_t first, uint32_t num) {
		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;
		}
		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;
	}

	// These functions disconnect the given element from the mesh and delete it.

	// @@ We must always disconnect edge pairs simultaneously.
	void disconnect(Edge *edge) {
		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
#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;
				} else {
					edge->vertex->edge = NULL;
					// @@ Remove disconnected vertex?
				}
			}
		}
		// 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?
				}
			}
		}
		// Disconnect from previous.
		if (edge->prev) {
			if (edge->prev->next == edge) {
				edge->prev->setNext(NULL);
			}
			//edge->setPrev(NULL);
		}
		// Disconnect from next.
		if (edge->next) {
			if (edge->next->prev == edge) {
				edge->next->setPrev(NULL);
			}
			//edge->setNext(NULL);
		}
	}

	void remove(Edge *edge) {
		xaDebugAssert(edge != NULL);
		disconnect(edge);
		delete edge;
	}

	void remove(Vertex *vertex) {
		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);
		}
		delete vertex;
	}

	void remove(Face *face) {
		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;
		}
		delete face;
	}

	// Triangulate in place.
	void triangulate() {
		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);
			}
		}
		xaPrint("---   %d boundary edges.\n", num);
	}

	/*
	Fixing T-junctions.

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

	*/
	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;
	}

	// Vertices
	uint32_t vertexCount() const {
		return m_vertexArray.size();
	}
	const Vertex *vertexAt(int i) const {
		return m_vertexArray[i];
	}
	Vertex *vertexAt(int i) {
		return m_vertexArray[i];
	}

	uint32_t colocalVertexCount() const {
		return m_colocalVertexCount;
	}

	// Faces
	uint32_t faceCount() const {
		return m_faceArray.size();
	}
	const Face *faceAt(int i) const {
		return m_faceArray[i];
	}
	Face *faceAt(int i) {
		return m_faceArray[i];
	}

	// Edges
	uint32_t edgeCount() const {
		return m_edgeArray.size();
	}
	const Edge *edgeAt(int i) const {
		return m_edgeArray[i];
	}
	Edge *edgeAt(int i) {
		return m_edgeArray[i];
	}

	class ConstVertexIterator;

	class VertexIterator {
		friend class ConstVertexIterator;

	public:
		VertexIterator(Mesh *mesh) :
				m_mesh(mesh),
				m_current(0) {}

		virtual void advance() {
			m_current++;
		}
		virtual bool isDone() const {
			return m_current == m_mesh->vertexCount();
		}
		virtual Vertex *current() const {
			return m_mesh->vertexAt(m_current);
		}

	private:
		halfedge::Mesh *m_mesh;
		uint32_t m_current;
	};
	VertexIterator vertices() {
		return VertexIterator(this);
	}

	class ConstVertexIterator {
	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) {}

		virtual void advance() {
			m_current++;
		}
		virtual bool isDone() const {
			return m_current == m_mesh->vertexCount();
		}
		virtual const Vertex *current() const {
			return m_mesh->vertexAt(m_current);
		}

	private:
		const halfedge::Mesh *m_mesh;
		uint32_t m_current;
	};
	ConstVertexIterator vertices() const {
		return ConstVertexIterator(this);
	}

	class ConstFaceIterator;

	class FaceIterator {
		friend class ConstFaceIterator;

	public:
		FaceIterator(Mesh *mesh) :
				m_mesh(mesh),
				m_current(0) {}

		virtual void advance() {
			m_current++;
		}
		virtual bool isDone() const {
			return m_current == m_mesh->faceCount();
		}
		virtual Face *current() const {
			return m_mesh->faceAt(m_current);
		}

	private:
		halfedge::Mesh *m_mesh;
		uint32_t m_current;
	};
	FaceIterator faces() {
		return FaceIterator(this);
	}

	class ConstFaceIterator {
	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) {}

		virtual void advance() {
			m_current++;
		}
		virtual bool isDone() const {
			return m_current == m_mesh->faceCount();
		}
		virtual const Face *current() const {
			return m_mesh->faceAt(m_current);
		}

	private:
		const halfedge::Mesh *m_mesh;
		uint32_t m_current;
	};
	ConstFaceIterator faces() const {
		return ConstFaceIterator(this);
	}

	class ConstEdgeIterator;

	class EdgeIterator {
		friend class ConstEdgeIterator;

	public:
		EdgeIterator(Mesh *mesh) :
				m_mesh(mesh),
				m_current(0) {}

		virtual void advance() {
			m_current++;
		}
		virtual bool isDone() const {
			return m_current == m_mesh->edgeCount();
		}
		virtual Edge *current() const {
			return m_mesh->edgeAt(m_current);
		}

	private:
		halfedge::Mesh *m_mesh;
		uint32_t m_current;
	};
	EdgeIterator edges() {
		return EdgeIterator(this);
	}

	class ConstEdgeIterator {
	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) {}

		virtual void advance() {
			m_current++;
		}
		virtual bool isDone() const {
			return m_current == m_mesh->edgeCount();
		}
		virtual const Edge *current() const {
			return m_mesh->edgeAt(m_current);
		}

	private:
		const halfedge::Mesh *m_mesh;
		uint32_t m_current;
	};
	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;
				}
				if (!edge->isValid()) {
					return false;
				}
				if (edge->pair->id != 2 * e + 1) {
					return false;
				}
				if (!edge->pair->isValid()) {
					return false;
				}
			}
		}
		// @@ Make sure all faces are valid.
		// @@ Make sure all vertices are valid.
		return true;
	}

	// Error status:

	struct ErrorCode {
		enum Enum {
			AlreadyAddedEdge,
			DegenerateColocalEdge,
			DegenerateEdge,
			DuplicateEdge
		};
	};

	mutable ErrorCode::Enum errorCode;
	mutable uint32_t errorIndex0;
	mutable uint32_t errorIndex1;

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);
	}

	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;
	}

	// 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;
	}

	Edge *addEdge(uint32_t i, uint32_t j) {
		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;
		}
		// Face and Next are set by addFace.
		return edge;
	}

	/// 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());
				}
			}
		}
		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;
	}

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;
};

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);
		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) {
				m_connectedCount++;
				stack.push_back(f);
				while (!stack.empty()) {
					const uint32_t top = stack.back();
					xaAssert(top != uint32_t(~0));
					stack.pop_back();
					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);
					}
				}
			}
		}
		xaAssert(stack.empty());
		xaPrint("---   %d connected components.\n", m_connectedCount);
		// 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);
		// 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()) {
			m_genus = (2 - m_eulerNumber) / 2;
			xaPrint("---   Genus: %d.\n", m_genus);
		}
	}

private:
	///< Number of boundary loops.
	int m_boundaryCount;

	///< Number of connected components.
	int m_connectedCount;

	///< Euler number.
	int m_eulerNumber;

	/// Mesh genus.
	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) {
	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];

					bool degenerate = distance(p0, p1) < NV_EPSILON || distance(p0, p2) < NV_EPSILON || distance(p1, p2) < NV_EPSILON;
					if (degenerate) {
						continue;
					}

					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;
						}
					}
				}
				if (!bestIsValid)
					break;

				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) {
		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();
	}

	/// Get a random number between 0 - 65536.
	uint32_t get() {
		// Pull a 32-bit integer from the generator state
		// Every other access function simply transforms the numbers extracted here
		if (left == 0) {
			reload();
		}
		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) {
		// 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++;
		}
	}

	void reload() {
		// Generate N new values in state
		// Made clearer and faster by Matthew Bellew ([email protected])
		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;
	}

	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);
	}

	uint32_t state[N]; // internal state
	uint32_t *next; // next value to get from state
	int left; // number of values left before reload needed
};

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) {
	return compact1By2(code >> 0);
}

uint32_t decodeMorton3Y(uint32_t code) {
	return compact1By2(code >> 1);
}

uint32_t decodeMorton3Z(uint32_t code) {
	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);
		}
		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 {
		return clamp(ftoi_floor((x - corner.x) * invCellSize.x), 0, sx - 1);
	}

	int index_y(float y) const {
		return clamp(ftoi_floor((y - corner.y) * invCellSize.y), 0, sy - 1);
	}

	int index_z(float z) const {
		return clamp(ftoi_floor((z - corner.z) * invCellSize.z), 0, sz - 1);
	}

	int index(int x, int y, int z) const {
		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;
	}

	uint32_t mortonCount() const {
		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);
	}

	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);
	}

	void add(const Vector3 &pos, uint32_t key) {
		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);
	}

	// 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) {
		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());
				}
			}
		}
	}

	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 {
public:
	RadixSort() :
			m_size(0),
			m_ranks(NULL),
			m_ranks2(NULL),
			m_validRanks(false) {}
	~RadixSort() {
		// Release everything
		free(m_ranks2);
		free(m_ranks);
	}

	RadixSort &sort(const float *input, uint32_t count) {
		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]);
			}
			radixSort<uint32_t>((const uint32_t *)input, count);
			for (uint32_t i = 0; i < count; i++) {
				IFloatFlip((uint32_t &)input[i]);
			}
		}
		return *this;
	}

	RadixSort &sort(const std::vector<float> &input) {
		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;
	}

private:
	uint32_t m_size;
	uint32_t *m_ranks;
	uint32_t *m_ranks2;
	bool m_validRanks;

	void FloatFlip(uint32_t &f) {
		int32_t mask = (int32_t(f) >> 31) | 0x80000000; // Warren Hunt, Manchor Ko.
		f ^= mask;
	}

	void IFloatFlip(uint32_t &f) {
		uint32_t mask = ((f >> 31) - 1) | 0x80000000; // Michael Herf.
		f ^= mask;
	}

	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)
#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;
				}
			}
		}
	}

	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;
		}
	}
};

namespace raster {
class ClippedTriangle {
public:
	ClippedTriangle(Vector2::Arg a, Vector2::Arg b, Vector2::Arg c) {
		m_numVertices = 3;
		m_activeVertexBuffer = 0;
		m_verticesA[0] = a;
		m_verticesA[1] = b;
		m_verticesA[2] = c;
		m_vertexBuffers[0] = m_verticesA;
		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];
		m_activeVertexBuffer ^= 1;
		Vector2 *v2 = m_vertexBuffers[m_activeVertexBuffer];
		v[m_numVertices] = v[0];
		float dy2, dy1 = offset - v[0].y;
		int dy2in, dy1in = clipdirection * dy1 >= 0;
		uint32_t p = 0;
		for (uint32_t k = 0; k < m_numVertices; k++) {
			dy2 = offset - v[k + 1].y;
			dy2in = clipdirection * dy2 >= 0;
			if (dy1in) v2[p++] = v[k];
			if (dy1in + dy2in == 1) { // not both in/out
				float dx = v[k + 1].x - v[k].x;
				float dy = v[k + 1].y - v[k].y;
				v2[p++] = Vector2(v[k].x + dy1 * (dx / dy), offset);
			}
			dy1 = dy2;
			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) {
		Vector2 *v = m_vertexBuffers[m_activeVertexBuffer];
		m_activeVertexBuffer ^= 1;
		Vector2 *v2 = m_vertexBuffers[m_activeVertexBuffer];
		v[m_numVertices] = v[0];
		float dx2, dx1 = offset - v[0].x;
		int dx2in, dx1in = clipdirection * dx1 >= 0;
		uint32_t p = 0;
		for (uint32_t k = 0; k < m_numVertices; k++) {
			dx2 = offset - v[k + 1].x;
			dx2in = clipdirection * dx2 >= 0;
			if (dx1in) v2[p++] = v[k];
			if (dx1in + dx2in == 1) { // not both in/out
				float dx = v[k + 1].x - v[k].x;
				float dy = v[k + 1].y - v[k].y;
				v2[p++] = Vector2(offset, v[k].y + dx1 * (dy / dx));
			}
			dx1 = dx2;
			dx1in = dx2in;
		}
		m_numVertices = p;
	}

	void computeAreaCentroid() {
		Vector2 *v = m_vertexBuffers[m_activeVertexBuffer];
		v[m_numVertices] = v[0];
		m_area = 0;
		float centroidx = 0, centroidy = 0;
		for (uint32_t k = 0; k < m_numVertices; k++) {
			// http://local.wasp.uwa.edu.au/~pbourke/geometry/polyarea/
			float f = v[k].x * v[k + 1].y - v[k + 1].x * v[k].y;
			m_area += f;
			centroidx += f * (v[k].x + v[k + 1].x);
			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;
	}

	float area() {
		return m_area;
	}

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;
};

/// 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);

/// 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) {
		// 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() {
		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;
	}

	// extents has to be multiple of BK_SIZE!!
	bool drawAA(const Vector2 &extents, bool enableScissors, SamplingCallback cb, void *param) {
		const float PX_INSIDE = 1.0f / sqrt(2.0f);
		const float PX_OUTSIDE = -1.0f / sqrt(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));
		}
		// 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);
		//minx = (float)(((int)minx) & (~((int)BK_SIZE - 1))); // align to blocksize (we don't need to worry about blocks partially out of viewport)
		//miny = (float)(((int)miny) & (~((int)BK_SIZE - 1)));
		minx += 0.5;
		miny += 0.5; // sampling at texel centers!
		maxx += 0.5;
		maxy += 0.5;
		// Half-edge constants
		float C1 = n1.x * (-v1.x) + n1.y * (-v1.y);
		float C2 = n2.x * (-v2.x) + n2.y * (-v2.y);
		float C3 = n3.x * (-v3.x) + n3.y * (-v3.y);
		// Loop through blocks
		for (float y0 = miny; y0 <= maxy; y0 += BK_SIZE) {
			for (float x0 = minx; x0 <= maxx; x0 += BK_SIZE) {
				// Corners of block
				float xc = (x0 + (BK_SIZE - 1) / 2.0f);
				float yc = (y0 + (BK_SIZE - 1) / 2.0f);
				// Evaluate half-space functions
				float aC = C1 + n1.x * xc + n1.y * yc;
				float bC = C2 + n2.x * xc + n2.y * yc;
				float cC = C3 + n3.x * xc + n3.y * yc;
				// Skip block when outside an edge
				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)) {
								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)) {
									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)) {
										return false;
									}
								}
							}
							CX1 += n1.x;
							CX2 += n2.x;
							CX3 += n3.x;
							tex += dx;
						}
						CY1 += n1.y;
						CY2 += n2.y;
						CY3 += n3.y;
						texRow += dy;
					}
				}
			}
		}
		return true;
	}

	void flipBackface() {
		// check if triangle is backfacing, if so, swap two vertices
		if (((v3.x - v1.x) * (v2.y - v1.y) - (v3.y - v1.y) * (v2.x - v1.x)) < 0) {
			Vector2 hv = v1;
			v1 = v2;
			v2 = hv; // swap pos
			Vector3 ht = t1;
			t1 = t2;
			t2 = ht; // swap tex
		}
	}

	// compute unit inward normals for each edge.
	void computeUnitInwardNormals() {
		n1 = v1 - v2;
		n1 = Vector2(-n1.y, n1.x);
		n1 = n1 * (1.0f / sqrtf(n1.x * n1.x + n1.y * n1.y));
		n2 = v2 - v3;
		n2 = Vector2(-n2.y, n2.x);
		n2 = n2 * (1.0f / sqrtf(n2.x * n2.x + n2.y * n2.y));
		n3 = v3 - v1;
		n3 = Vector2(-n3.y, n3.x);
		n3 = n3 * (1.0f / sqrtf(n3.x * n3.x + n3.y * n3.y));
	}

	// 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) {
	Triangle tri(v[0], v[1], v[2], Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1));
	// @@ 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);
		}
	}
	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
* very few non-zero elements, for this reason it's stored in indexed
* format. To multiply column vectors efficiently, the matrix stores
* the elements in indexed-column order, there is a list of indexed
* elements for each row of the matrix. As with the FullVector the
* dimension of the matrix is constant.
**/
class Matrix {
public:
	// An element of the sparse array.
	struct Coefficient {
		uint32_t x; // column
		float v; // value
	};

	Matrix(uint32_t d) :
			m_width(d) { m_array.resize(d); }
	Matrix(uint32_t w, uint32_t h) :
			m_width(w) { m_array.resize(h); }
	Matrix(const Matrix &m) :
			m_width(m.m_width) { m_array = m.m_array; }

	const Matrix &operator=(const Matrix &m) {
		xaAssert(width() == m.width());
		xaAssert(height() == m.height());
		m_array = m.m_array;
		return *this;
	}

	uint32_t width() const { return m_width; }
	uint32_t height() const { return m_array.size(); }
	bool isSquare() const { return width() == height(); }

	// x is column, y is row
	float getCoefficient(uint32_t x, uint32_t y) const {
		xaDebugAssert(x < width());
		xaDebugAssert(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;
		}
		return 0.0f;
	}

	void setCoefficient(uint32_t x, uint32_t y, float f) {
		xaDebugAssert(x < width());
		xaDebugAssert(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) {
				m_array[y][i].v = f;
				return;
			}
		}
		if (f != 0.0f) {
			Coefficient c = { x, f };
			m_array[y].push_back(c);
		}
	}

	float dotRow(uint32_t y, const FullVector &v) const {
		xaDebugAssert(y < height());
		const uint32_t count = m_array[y].size();
		float sum = 0;
		for (uint32_t i = 0; i < count; i++) {
			sum += m_array[y][i].v * v[m_array[y][i].x];
		}
		return sum;
	}

	void madRow(uint32_t y, float alpha, FullVector &v) const {
		xaDebugAssert(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;
		}
	}

	void clearRow(uint32_t y) {
		xaDebugAssert(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]; }

private:
	/// Number of columns.
	const uint32_t m_width;

	/// Array of matrix elements.
	std::vector<std::vector<Coefficient> > m_array;
};

// y = a * x + y
static void saxpy(float a, const FullVector &x, FullVector &y) {
	xaDebugAssert(x.dimension() == y.dimension());
	const uint32_t dim = x.dimension();
	for (uint32_t i = 0; i < dim; i++) {
		y[i] += a * x[i];
	}
}

static void copy(const FullVector &x, FullVector &y) {
	xaDebugAssert(x.dimension() == y.dimension());
	const uint32_t dim = x.dimension();
	for (uint32_t i = 0; i < dim; i++) {
		y[i] = x[i];
	}
}

static void scal(float a, FullVector &x) {
	const uint32_t dim = x.dimension();
	for (uint32_t i = 0; i < dim; i++) {
		x[i] *= a;
	}
}

static float dot(const FullVector &x, const FullVector &y) {
	xaDebugAssert(x.dimension() == y.dimension());
	const uint32_t dim = x.dimension();
	float sum = 0;
	for (uint32_t i = 0; i < dim; i++) {
		sum += x[i] * y[i];
	}
	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];
		}
	}
}

// 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);
}

// 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 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(x, c.x);
	}
	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());
	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 uint32_t count = row.size();
		for (uint32_t i = 0; i < count; i++) {
			const Matrix::Coefficient &c = row[i];
			xaDebugAssert(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) {
	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
#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);
			}
			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);
}

} // namespace sparse

class JacobiPreconditioner {
public:
	JacobiPreconditioner(const sparse::Matrix &M, bool symmetric) :
			m_inverseDiagonal(M.width()) {
		xaAssert(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.
			if (symmetric) {
				m_inverseDiagonal[x] = (elem != 0) ? 1.0f / sqrtf(fabsf(elem)) : 1.0f;
			} else {
				m_inverseDiagonal[x] = (elem != 0) ? 1.0f / elem : 1.0f;
			}
		}
	}

	void apply(const FullVector &x, FullVector &y) const {
		xaDebugAssert(x.dimension() == m_inverseDiagonal.dimension());
		xaDebugAssert(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++) {
			y[i] = m_inverseDiagonal[i] * x[i];
		}
	}

private:
	FullVector m_inverseDiagonal;
};

// Linear solvers.
class Solver {
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...
		const uint32_t D = A.width();
		sparse::Matrix At(A.height(), A.width());
		sparse::transpose(A, At);
		FullVector Atb(D);
		sparse::mult(At, b, Atb);
		sparse::Matrix AtA(D);
		sparse::mult(At, A, AtA);
		return SymmetricSolver(AtA, Atb, x, epsilon);
	}

	// 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);
		// @@ 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);
		// Compute: b - Al * xl
		FullVector b_Alxl(b);
		for (uint32_t y = 0; y < A.height(); y++) {
			const uint32_t count = A.getRow(y).size();
			for (uint32_t e = 0; e < count; e++) {
				uint32_t column = A.getRow(y)[e].x;
				bool isFree = true;
				for (uint32_t i = 0; i < lockedCount; i++) {
					isFree &= (lockedParameters[i] != column);
				}
				if (!isFree) {
					b_Alxl[y] -= x[column] * A.getRow(y)[e].v;
				}
			}
		}
		// Remove locked columns from A.
		sparse::Matrix Af(D, A.height());
		for (uint32_t y = 0; y < A.height(); y++) {
			const uint32_t count = A.getRow(y).size();
			for (uint32_t e = 0; e < count; e++) {
				uint32_t column = A.getRow(y)[e].x;
				uint32_t ix = column;
				bool isFree = true;
				for (uint32_t i = 0; i < lockedCount; i++) {
					isFree &= (lockedParameters[i] != column);
					if (column > lockedParameters[i]) ix--; // shift columns
				}
				if (isFree) {
					Af.setCoefficient(ix, y, A.getRow(y)[e].v);
				}
			}
		}
		// Remove elements from x
		FullVector xf(D);
		for (uint32_t i = 0, j = 0; i < A.width(); i++) {
			bool isFree = true;
			for (uint32_t l = 0; l < lockedCount; l++) {
				isFree &= (lockedParameters[l] != i);
			}
			if (isFree) {
				xf[j++] = x[i];
			}
		}
		// Solve reduced system.
		bool result = LeastSquaresSolver(Af, b_Alxl, xf, epsilon);
		// Copy results back to x.
		for (uint32_t i = 0, j = 0; i < A.width(); i++) {
			bool isFree = true;
			for (uint32_t l = 0; l < lockedCount; l++) {
				isFree &= (lockedParameters[l] != i);
			}
			if (isFree) {
				x[i] = xf[j++];
			}
		}
		return result;
	}

private:
	/**
	* Compute the solution of the sparse linear system Ab=x using the Conjugate
	* Gradient method.
	*
	* Solving sparse linear systems:
	* (1)		A·x = b
	*
	* The conjugate gradient algorithm solves (1) only in the case that A is
	* symmetric and positive definite. It is based on the idea of minimizing the
	* function
	*
	* (2)		f(x) = 1/2·x·A·x - b·x
	*
	* This function is minimized when its gradient
	*
	* (3)		df = A·x - b
	*
	* is zero, which is equivalent to (1). The minimization is carried out by
	* generating a succession of search directions p.k and improved minimizers x.k.
	* At each stage a quantity alfa.k is found that minimizes f(x.k + alfa.k·p.k),
	* and x.k+1 is set equal to the new point x.k + alfa.k·p.k. The p.k and x.k are
	* built up in such a way that x.k+1 is also the minimizer of f over the whole
	* vector space of directions already taken, {p.1, p.2, . . . , p.k}. After N
	* iterations you arrive at the minimizer over the entire vector space, i.e., the
	* solution to (1).
	*
	* For a really good explanation of the method see:
	*
	* "An Introduction to the Conjugate Gradient Method Without the Agonizing Pain",
	* 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());
		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); //
		FullVector s(D); // preconditioned
		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 = M^-1 · r
		preconditioner.apply(r, p);
		delta_new = sparse::dot(r, p);
		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 - alfa·q
				sparse::saxpy(-alpha, q, r);
			}
			// s = M^-1 · r
			preconditioner.apply(r, s);
			delta_old = delta_new;
			delta_new = sparse::dot(r, s);
			beta = delta_new / delta_old;
			// p = s + beta·p
			sparse::scal(beta, p);
			sparse::saxpy(1, s, p);
		}
		return delta_new <= epsilon * epsilon * delta_0;
	}

	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());
		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) {
	xaDebugAssert(mesh != NULL);
	xaDebugAssert(a != NULL);
	xaDebugAssert(b != NULL);
	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;
	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;
			break;
		}
	}
	if (minVertex[0] == NULL) {
		// 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()) {
			// 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;
	}
	float lengths[3];
	for (int i = 0; i < 3; i++) {
		lengths[i] = length(minVertex[i]->pos - maxVertex[i]->pos);
	}
	if (lengths[0] > lengths[1] && lengths[0] > lengths[2]) {
		*a = minVertex[0];
		*b = maxVertex[0];
	} else if (lengths[1] > lengths[2]) {
		*a = minVertex[1];
		*b = maxVertex[1];
	} else {
		*a = minVertex[2];
		*b = maxVertex[2];
	}
	return true;
}

// Conformal relations from Brecht Van Lommel (based on ABF):

static float vec_angle_cos(Vector3::Arg v1, Vector3::Arg v2, Vector3::Arg 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) {
	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) {
	*a1 = vec_angle(v3, v1, v2);
	*a2 = vec_angle(v1, v2, v3);
	*a3 = PI - *a2 - *a1;
}

static void setup_abf_relations(sparse::Matrix &A, int row, const halfedge::Vertex *v0, const halfedge::Vertex *v1, const halfedge::Vertex *v2) {
	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!
	float a0, a1, a2;
	triangle_angles(p0, p1, p2, &a0, &a1, &a2);
	float s0 = sinf(a0);
	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);
	} 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);
	}
	float c0 = cosf(a0);
	float ratio = (s2 == 0.0f) ? 1.0f : s1 / s2;
	float cosine = c0 * ratio;
	float sine = s0 * ratio;
	// Note  : 2*id + 0 --> u
	//         2*id + 1 --> v
	int u0_id = 2 * id0 + 0;
	int v0_id = 2 * id0 + 1;
	int u1_id = 2 * id1 + 0;
	int v1_id = 2 * id1 + 1;
	int u2_id = 2 * id2 + 0;
	int v2_id = 2 * id2 + 1;
	// Real part
	A.setCoefficient(u0_id, 2 * row + 0, cosine - 1.0f);
	A.setCoefficient(v0_id, 2 * row + 0, -sine);
	A.setCoefficient(u1_id, 2 * row + 0, -cosine);
	A.setCoefficient(v1_id, 2 * row + 0, sine);
	A.setCoefficient(u2_id, 2 * row + 0, 1);
	// Imaginary part
	A.setCoefficient(u0_id, 2 * row + 1, sine);
	A.setCoefficient(v0_id, 2 * row + 1, cosine - 1.0f);
	A.setCoefficient(u1_id, 2 * row + 1, -sine);
	A.setCoefficient(v1_id, 2 * row + 1, -cosine);
	A.setCoefficient(v2_id, 2 * row + 1, 1);
}

bool computeLeastSquaresConformalMap(halfedge::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);
	// 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) {
		return false;
	}
	sparse::Matrix A(D, N);
	FullVector b(N);
	FullVector x(D);
	// Fill b:
	b.fill(0.0f);
	// Fill x:
	halfedge::Vertex *v0;
	halfedge::Vertex *v1;
	if (!findApproximateDiameterVertices(mesh, &v0, &v1)) {
		// Mesh has no boundaries.
		return false;
	}
	if (v0->tex == v1->tex) {
		// 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;
	}
	// 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 lockedParameters[] = {
		2 * v0->id + 0,
		2 * v0->id + 1,
		2 * v1->id + 0,
		2 * v1->id + 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]);
	}
	return true;
}

bool computeOrthogonalProjectionMap(halfedge::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) {
		return false;
	}
	float eigenValues[3];
	Vector3 eigenVectors[3];
	if (!Fit::eigenSolveSymmetric3(matrix, eigenValues, eigenVectors)) {
		return false;
	}
	axis[0] = normalize(eigenVectors[0]);
	axis[1] = normalize(eigenVectors[1]);
	// 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);
	}
	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).
// - Resorting is n*log(n)
// @@ Number of elements in the queue is usually small, and we'd have to rebalance often. I'm not sure it's worth implementing a heap.
// @@ Searcing at removal would remove the need for sorting when priorities change.
struct PriorityQueue {
	PriorityQueue(uint32_t size = UINT_MAX) :
			maxSize(size) {}

	void push(float priority, uint32_t face) {
		uint32_t i = 0;
		const uint32_t count = pairs.size();
		for (; i < count; i++) {
			if (pairs[i].priority > priority) break;
		}
		Pair p = { priority, face };
		pairs.insert(pairs.begin() + i, p);
		if (pairs.size() > maxSize) {
			pairs.erase(pairs.begin());
		}
	}

	// push face out of order, to be sorted later.
	void push(uint32_t face) {
		Pair p = { 0.0f, face };
		pairs.push_back(p);
	}

	uint32_t pop() {
		uint32_t f = pairs.back().face;
		pairs.pop_back();
		return f;
	}

	void sort() {
		//sort(pairs); // @@ My intro sort appears to be much slower than it should!
		std::sort(pairs.begin(), pairs.end());
	}

	void clear() {
		pairs.clear();
	}

	uint32_t count() const {
		return pairs.size();
	}

	float firstPriority() const {
		return pairs.back().priority;
	}

	const uint32_t maxSize;

	struct Pair {
		bool operator<(const Pair &p) const {
			return priority > p.priority; // !! Sort in inverse priority order!
		}

		float priority;
		uint32_t face;
	};

	std::vector<Pair> pairs;
};

struct ChartBuildData {
	ChartBuildData(int p_id) :
			id(p_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;
	PriorityQueue candidates;
};

struct AtlasBuilder {
	AtlasBuilder(const halfedge::Mesh *m) :
			mesh(m),
			facesLeft(m->faceCount()) {
		const uint32_t faceCount = m->faceCount();
		faceChartArray.resize(faceCount, -1);
		faceCandidateArray.resize(faceCount, (uint32_t)-1);
		// @@ 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();
		}
	}

	~AtlasBuilder() {
		const uint32_t chartCount = chartArray.size();
		for (uint32_t i = 0; i < chartCount; i++) {
			delete chartArray[i];
		}
	}

	void markUnchartedFaces(const std::vector<uint32_t> &unchartedFaces) {
		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;
	}

	void computeShortestPaths() {
		const uint32_t faceCount = mesh->faceCount();
		shortestPaths.resize(faceCount * faceCount, FLT_MAX);
		// Fill edges:
		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);
				}
			}
		}
		// 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]);
				}
			}
		}
	}

	void placeSeeds(float threshold, uint32_t maxSeedCount) {
		// 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.
				break;
			}
			createRandomChart(threshold);
		}
	}

	void createRandomChart(float threshold) {
		ChartBuildData *chart = new ChartBuildData(chartArray.size());
		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);
		// Grow the chart as much as possible within the given threshold.
		growChart(chart, threshold * 0.5f, facesLeft);
		//growCharts(threshold - threshold * 0.75f / chartCount(), facesLeft);
	}

	void addFaceToChart(ChartBuildData *chart, uint32_t f, bool recomputeProxy = false) {
		// Add face to chart.
		chart->faces.push_back(f);
		xaDebugAssert(faceChartArray[f] == -1);
		faceChartArray[f] = chart->id;
		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);
		if (recomputeProxy) {
			// Update proxy and candidate's priorities.
			updateProxy(chart);
		}
		// Update candidates.
		removeCandidate(f);
		updateCandidates(chart, f);
		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) {
				return false;
			}
			uint32_t f = chart->candidates.pop();
			if (faceChartArray[f] == -1) {
				addFaceToChart(chart, f);
				i++;
			}
		}
		if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold) {
			return false;
		}
		return true;
	}

	void resetCharts() {
		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);
				}
			}
		}
	}

	void updateProxies() {
		const uint32_t chartCount = chartArray.size();
		for (uint32_t i = 0; i < chartCount; i++) {
			updateProxy(chartArray[i]);
		}
	}

	void updateProxy(ChartBuildData *chart) {
		//#pragma message(NV_FILE_LINE "TODO: Use best fit plane instead of average normal.")
		chart->planeNormal = 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();
		for (uint32_t i = 0; i < faceCount; i++) {
			float priority = evaluateProxyFitMetric(chart, chart->faces[i]);
			bestTriangles.push(priority, chart->faces[i]);
		}
		// Of those, choose the most central triangle.
		uint32_t mostCentral;
		float maxDistance = -1;
		const uint32_t bestCount = 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);
			if (distance > maxDistance) {
				maxDistance = distance;
				mostCentral = bestTriangles.pairs[i].face;
			}
		}
		xaDebugAssert(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;
		}
	}

	void updatePriorities(ChartBuildData *chart) {
		// 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);
			}
		}
		// Sort candidates.
		chart->candidates.sort();
	}

	// Evaluate combined metric.
	float evaluatePriority(ChartBuildData *chart, uint32_t face) {
		// 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);
		// Penalize faces that cross seams, reward faces that close seams or reach boundaries.
		float N = evaluateNormalSeamMetric(chart, face);
		float T = 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));
		return cost;
	}

	// Returns a value in [0-1].
	float evaluateProxyFitMetric(ChartBuildData *chart, uint32_t f) {
		const halfedge::Face *face = mesh->faceAt(f);
		Vector3 faceNormal = face->triangleNormal();
		// Use plane fitting metric for now:
		return 1 - dot(faceNormal, chart->planeNormal); // @@ normal deviations should be weighted by face area
	}

	float evaluateRoundnessMetric(ChartBuildData *chart, uint32_t /*face*/, float newBoundaryLength, float newChartArea) {
		float roundness = square(chart->boundaryLength) / chart->area;
		float newRoundness = square(newBoundaryLength) / newChartArea;
		if (newRoundness > roundness) {
			return square(newBoundaryLength) / (newChartArea * 4 * PI);
		} else {
			// Offer no impedance to faces that improve roundness.
			return 0;
		}
	}

	float evaluateStraightnessMetric(ChartBuildData *chart, uint32_t f) {
		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()) {
				l_out += l;
			} else {
				uint32_t neighborFaceId = edge->pair->face->id;
				if (faceChartArray[neighborFaceId] != 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.
		float ratio = (l_out - l_in) / (l_out + l_in);
		return std::min(ratio, 0.0f); // Only use the straightness metric to close gaps.
	}

	float evaluateNormalSeamMetric(ChartBuildData *chart, uint32_t f) {
		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()) {
				continue;
			}
			const uint32_t neighborFaceId = edge->pair->face->id;
			if (faceChartArray[neighborFaceId] != chart->id) {
				continue;
			}
			//float l = edge->length();
			float l = edgeLengths[edge->id / 2];
			totalLength += l;
			if (!edge->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;
				seamFactor += l;
			}
		}
		if (seamFactor == 0) return 0.0f;
		return seamFactor / totalLength;
	}

	float evaluateTextureSeamMetric(ChartBuildData *chart, uint32_t f) {
		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()) {
				continue;
			}
			const uint32_t neighborFaceId = edge->pair->face->id;
			if (faceChartArray[neighborFaceId] != chart->id) {
				continue;
			}
			//float l = edge->length();
			float l = edgeLengths[edge->id / 2];
			totalLength += l;
			if (!edge->isSeam()) {
				continue;
			}
			// Make sure it's a texture seam.
			if (edge->isTextureSeam()) {
				seamLength += l;
			}
		}
		if (seamLength == 0.0f) {
			return 0.0f; // Avoid division by zero.
		}
		return seamLength / totalLength;
	}

	float evaluateChartArea(ChartBuildData *chart, uint32_t f) {
		const halfedge::Face *face = mesh->faceAt(f);
		return chart->area + faceAreas[face->id];
	}

	float evaluateBoundaryLength(ChartBuildData *chart, uint32_t f) {
		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()) {
				boundaryLength += edgeLength;
			} else {
				uint32_t neighborFaceId = edge->pair->face->id;
				if (faceChartArray[neighborFaceId] != chart->id) {
					boundaryLength += edgeLength;
				} 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();
	}

	Vector3 evaluateChartCentroidSum(ChartBuildData *chart, uint32_t f) {
		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++;
			}
		}
	}

	// @@ Cleanup.
	struct Candidate {
		uint32_t face;
		ChartBuildData *chart;
		float metric;
	};

	// @@ Get N best candidates in one pass.
	const Candidate &getBestCandidate() const {
		uint32_t best = 0;
		float bestCandidateMetric = FLT_MAX;
		const uint32_t candidateCount = candidateArray.size();
		xaAssert(candidateCount > 0);
		for (uint32_t i = 0; i < candidateCount; i++) {
			const Candidate &candidate = candidateArray[i];
			if (candidate.metric < bestCandidateMetric) {
				bestCandidateMetric = candidate.metric;
				best = i;
			}
		}
		return candidateArray[best];
	}

	void removeCandidate(uint32_t f) {
		int c = faceCandidateArray[f];
		if (c != -1) {
			faceCandidateArray[f] = (uint32_t)-1;
			if (c == int(candidateArray.size() - 1)) {
				candidateArray.pop_back();
			} else {
				// Replace with last.
				candidateArray[c] = candidateArray[candidateArray.size() - 1];
				candidateArray.pop_back();
				faceCandidateArray[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;
		} else {
			int c = faceCandidateArray[f];
			xaDebugAssert(c != -1);
			Candidate &candidate = candidateArray[c];
			xaDebugAssert(candidate.face == f);
			if (metric < candidate.metric || chart == candidate.chart) {
				candidate.metric = metric;
				candidate.chart = chart;
			}
		}
	}

	void mergeChart(ChartBuildData *owner, ChartBuildData *chart, float sharedBoundaryLength) {
		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;
			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);
	}

	uint32_t chartCount() const { return chartArray.size(); }
	const std::vector<uint32_t> &chartFaces(uint32_t i) const { return chartArray[i]->faces; }

	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;
};

/// 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) {
		// 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);
		// 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);
				}
				if (chartMeshIndices[vertex->id] == ~0) {
					chartMeshIndices[vertex->id] = m_chartMesh->vertexCount();
					m_chartToOriginalMap.push_back(vertex->original_id);
					m_chartToUnifiedMap.push_back(unifiedMeshIndices[unifiedVertex->id]);
					halfedge::Vertex *v = m_chartMesh->addVertex(vertex->pos);
					v->nor = vertex->nor;
					v->tex = vertex->tex;
				}
			}
		}
		// 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();
					m_chartToOriginalMap.push_back(vertex->original_id);
					halfedge::Vertex *v = m_chartMesh->addVertex(vertex->pos);
					v->nor = vertex->nor;
					v->tex = vertex->tex; // @@ Not necessary.
				}
			}
		}
		// @@ 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;
						}
					}
				}
				// 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;
			}
			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);
		}
		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 {
		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();
	}

	//uint32_t vertexIndex(uint32_t i) const { return m_vertexIndexArray[i]; }

	uint32_t mapChartVertexToOriginalVertex(uint32_t i) const {
		return m_chartToOriginalMap[i];
	}
	uint32_t mapChartVertexToUnifiedVertex(uint32_t i) const {
		return m_chartToUnifiedMap[i];
	}

	const std::vector<uint32_t> &faceArray() const {
		return m_faceArray;
	}

	// 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;
		}
	}

	float computeSurfaceArea() const {
		return halfedge::computeSurfaceArea(m_chartMesh.get()) * scale;
	}

	float computeParametricArea() const {
		// This only makes sense in parameterized meshes.
		xaDebugAssert(m_isDisk);
		xaDebugAssert(!m_isVertexMapped);
		return halfedge::computeParametricArea(m_chartMesh.get());
	}

	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();
		for (uint32_t v = 0; v < vertexCount; v++) {
			halfedge::Vertex *vertex = m_chartMesh->vertexAt(v);
			bounds.addPointToBounds(Vector3(vertex->tex, 0));
		}
		return bounds.extents().xy();
	}

	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;

	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;

	// Map vertices of the chart mesh to vertices of the original mesh.
	std::vector<uint32_t> m_chartToOriginalMap;

	std::vector<uint32_t> m_chartToUnifiedMap;
};

// Estimate quality of existing parameterization.
class ParameterizationQuality {
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();
		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);
				}
			}
		}
		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
#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() {
		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);
			}
		}
	}

	/*
	Compute charts using a simple segmentation algorithm.

	LSCM:
	- identify sharp features using local dihedral angles.
	- identify seed faces farthest from sharp features.
	- grow charts from these seeds.

	MCGIM:
	- phase 1: chart growth
	  - grow all charts simultaneously using dijkstra search on the dual graph of the mesh.
	  - graph edges are weighted based on planarity metric.
	  - metric uses distance to global chart normal.
	  - terminate when all faces have been assigned.
	- phase 2: seed computation:
	  - place new seed of the chart at the most interior face.
	  - most interior is evaluated using distance metric only.

	- method repeates the two phases, until the location of the seeds does not change.
	  - cycles are detected by recording all the previous seeds and chartification terminates.

	D-Charts:

	- Uniaxial conic metric:
	  - N_c = axis of the generalized cone that best fits the chart. (cone can a be cylinder or a plane).
	  - omega_c = angle between the face normals and the axis.
	  - Fitting error between chart C and tringle t: F(c,t) = (N_c*n_t - cos(omega_c))^2

	- Compactness metrics:
	  - Roundness:
		- C(c,t) = pi * D(S_c,t)^2 / A_c
		- S_c = chart seed.
		- D(S_c,t) = length of the shortest path inside the chart betwen S_c and t.
		- A_c = chart area.
	  - Straightness:
		- P(c,t) = l_out(c,t) / l_in(c,t)
		- l_out(c,t) = lenght of the edges not shared between C and t.
		- l_in(c,t) = lenght of the edges shared between C and t.

	- Combined metric:
	  - Cost(c,t) = F(c,t)^alpha + C(c,t)^beta + P(c,t)^gamma
	  - alpha = 1, beta = 0.7, gamma = 0.5

	Our basic approach:
	- Just one iteration of k-means?
	- Avoid dijkstra by greedily growing charts until a threshold is met. Increase threshold and repeat until no faces left.
	- If distortion metric is too high, split chart, add two seeds.
	- If chart size is low, try removing chart.

	Postprocess:
	- If topology is not disk:
	  - Fill holes, if new faces fit proxy.
	  - Find best cut, otherwise.
	- After parameterization:
	  - If boundary self-intersects:
		- cut chart along the closest two diametral boundary vertices, repeat parametrization.
		- what if the overlap is on an appendix? How do we find that out and cut appropiately?
		  - 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());
		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;
			}
		}
		// 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();
			}
			m_totalVertexCount = m_chartVertexCountPrefixSum[chartCount - 1] + m_chartArray[chartCount - 1]->vertexCount();
		} else {
			m_totalVertexCount = 0;
		}
	}

	void parameterizeCharts() {
		ParameterizationQuality globalParameterizationQuality;
		// Parameterize the charts.
		uint32_t diskCount = 0;
		const uint32_t chartCount = m_chartArray.size();
		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");
				}
				// @@ Check that parameterization quality is above a certain threshold.
				// @@ Detect boundary self-intersections.
				globalParameterizationQuality += chartParameterizationQuality;
			}

			// Transfer parameterization from unified mesh to chart mesh.
			chart->transferParameterization();
		}
		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());
	}

	uint32_t faceChartAt(uint32_t i) const {
		return m_faceChart[i];
	}
	uint32_t faceIndexWithinChartAt(uint32_t i) const {
		return m_faceIndex[i];
	}

	uint32_t vertexCountBeforeChartAt(uint32_t i) const {
		return m_chartVertexCountPrefixSum[i];
	}

private:
	const halfedge::Mesh *m_mesh;

	std::vector<Chart *> m_chartArray;

	std::vector<uint32_t> m_chartVertexCountPrefixSum;
	uint32_t m_totalVertexCount;

	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.
};

/// An atlas is a set of charts.
class Atlas {
public:
	~Atlas() {
		for (size_t i = 0; i < m_meshChartsArray.size(); i++)
			delete m_meshChartsArray[i];
	}

	uint32_t meshCount() const {
		return m_meshChartsArray.size();
	}

	const MeshCharts *meshAt(uint32_t i) const {
		return m_meshChartsArray[i];
	}

	MeshCharts *meshAt(uint32_t i) {
		return m_meshChartsArray[i];
	}

	uint32_t chartCount() const {
		uint32_t count = 0;
		for (uint32_t c = 0; c < m_meshChartsArray.size(); c++) {
			count += m_meshChartsArray[c]->chartCount();
		}
		return count;
	}

	const Chart *chartAt(uint32_t i) const {
		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);
			}
			i -= count;
		}
		return NULL;
	}

	Chart *chartAt(uint32_t i) {
		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);
			}
			i -= count;
		}
		return NULL;
	}

	// Add mesh charts and takes ownership.
	// Extract the charts and add to this atlas.
	void addMeshCharts(MeshCharts *meshCharts) {
		m_meshChartsArray.push_back(meshCharts);
	}

	void extractCharts(const halfedge::Mesh *mesh) {
		MeshCharts *meshCharts = new MeshCharts(mesh);
		meshCharts->extractCharts();
		addMeshCharts(meshCharts);
	}

	void computeCharts(const halfedge::Mesh *mesh, const CharterOptions &options, const std::vector<uint32_t> &unchartedMaterialArray) {
		MeshCharts *meshCharts = new MeshCharts(mesh);
		meshCharts->computeCharts(options, unchartedMaterialArray);
		addMeshCharts(meshCharts);
	}

	void parameterizeCharts() {
		for (uint32_t i = 0; i < m_meshChartsArray.size(); i++) {
			m_meshChartsArray[i]->parameterizeCharts();
		}
	}

private:
	std::vector<MeshCharts *> m_meshChartsArray;
};

struct AtlasPacker {
	AtlasPacker(Atlas *atlas) :
			m_atlas(atlas),
			m_width(0),
			m_height(0) {
		// 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;
		}
	}

	uint32_t getWidth() const { return m_width; }
	uint32_t getHeight() const { return m_height; }

	// 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);
			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);
				} 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));
					}
				}
				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));
					}
				}
				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);
				}
				//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));
				}
			}
			//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;
				}
				resetUvs();
			} else {
				return;
			}
		}
	}

	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);
			}
		}
		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];
		}
	}

	// 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);
		}
	}

	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) {
		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.
					// Early out.
					int area = std::max(w, x + cw) * std::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 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 is the same, pick the one closest to the origin.
						continue;
					}
					if (canAddChart(bitmap, w, h, x, y, r)) {
						best_metric = metric;
						*best_x = x;
						*best_y = y;
						*best_w = cw;
						*best_h = ch;
						*best_r = r;
						if (area == w * h) {
							// Chart is completely inside, do not look at any other location.
							goto done;
						}
					}
				}
			}
		}
	done:
		xaDebugAssert(best_metric != INT_MAX);
	}

	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) {
		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.
			if (blockAligned) {
				x = align(x, BLOCK_SIZE);
				y = align(y, BLOCK_SIZE);
			}
			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 perimeter = max(w, x+cw) + max(h, y+ch);
			int extents = std::max(std::max(w, x + cw), std::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 is the same, pick the one closest to the origin.
				continue;
			}
			if (canAddChart(bitmap, w, h, x, y, r)) {
				best_metric = metric;
				*best_x = x;
				*best_y = y;
				*best_w = cw;
				*best_h = ch;
				*best_r = r;
				if (area == w * h) {
					// Chart is completely inside, do not look at any other location.
					break;
				}
			}
		}
	}

	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) {
		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();
		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);
								}
							}
						}
					}
				}
			}
		}
	}

	static bool setBitsCallback(void *param, int x, int y, Vector3::Arg, Vector3::Arg, Vector3::Arg, float area) {
		BitMap *bitmap = (BitMap *)param;
		if (area > 0.0) {
			bitmap->setBitAt(x, y);
		}
		return true;
	}

	// Compute the convex hull using Graham Scan.
	static void convexHull(const std::vector<Vector2> &input, std::vector<Vector2> &output, float epsilon) {
		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();
	}

	// 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;
	RadixSort m_radix;
	uint32_t m_width;
	uint32_t m_height;
	MTRand m_rand;
	std::vector<std::vector<Vector2> > m_originalChartUvs;
};

} // namespace param
} // 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;
};

void SetPrint(PrintFunc print) {
	internal::s_print = print;
}

Atlas *Create() {
	Atlas *atlas = new Atlas();
	return atlas;
}

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;
}

static internal::Vector3 DecodePosition(const InputMesh &mesh, uint32_t index) {
	xaAssert(mesh.vertexPositionData);
	return *((const internal::Vector3 *)&((const uint8_t *)mesh.vertexPositionData)[mesh.vertexPositionStride * index]);
}

static internal::Vector3 DecodeNormal(const InputMesh &mesh, uint32_t index) {
	xaAssert(mesh.vertexNormalData);
	return *((const internal::Vector3 *)&((const uint8_t *)mesh.vertexNormalData)[mesh.vertexNormalStride * index]);
}

static internal::Vector2 DecodeUv(const InputMesh &mesh, uint32_t index) {
	xaAssert(mesh.vertexUvData);
	return *((const internal::Vector2 *)&((const uint8_t *)mesh.vertexUvData)[mesh.vertexUvStride * index]);
}

static uint32_t DecodeIndex(IndexFormat::Enum format, const void *indexData, uint32_t i) {
	if (format == IndexFormat::HalfFloat)
		return (uint32_t)((const uint16_t *)indexData)[i];
	return ((const uint32_t *)indexData)[i];
}

static float EdgeLength(internal::Vector3 pos1, internal::Vector3 pos2) {
	return internal::length(pos2 - pos1);
}

AddMeshError AddMesh(Atlas *atlas, const InputMesh &mesh, bool useColocalVertices) {
	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;
#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++) {
		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.
		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]);

		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]);
		}

		if (!face) {
			//continue;

			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;
}

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;
			}
		}
	}
}

uint32_t GetWidth(const Atlas *atlas) {
	xaAssert(atlas);
	return atlas->width;
}

uint32_t GetHeight(const Atlas *atlas) {
	xaAssert(atlas);
	return atlas->height;
}

uint32_t GetNumCharts(const Atlas *atlas) {
	xaAssert(atlas);
	return atlas->atlas.chartCount();
}

const OutputMesh *const *GetOutputMeshes(const Atlas *atlas) {
	xaAssert(atlas);
	return atlas->outputMeshes;
}

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";
}

} // namespace xatlas