summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--modules/xatlas_unwrap/register_types.cpp96
-rw-r--r--thirdparty/README.md2
-rw-r--r--thirdparty/xatlas/xatlas.cpp11077
-rw-r--r--thirdparty/xatlas/xatlas.h334
4 files changed, 6033 insertions, 5476 deletions
diff --git a/modules/xatlas_unwrap/register_types.cpp b/modules/xatlas_unwrap/register_types.cpp
index 903b57f017..c18aa04336 100644
--- a/modules/xatlas_unwrap/register_types.cpp
+++ b/modules/xatlas_unwrap/register_types.cpp
@@ -39,57 +39,37 @@ extern bool (*array_mesh_lightmap_unwrap_callback)(float p_texel_size, const flo
bool xatlas_mesh_lightmap_unwrap_callback(float p_texel_size, const float *p_vertices, const float *p_normals, int p_vertex_count, const int *p_indices, const int *p_face_materials, int p_index_count, float **r_uv, int **r_vertex, int *r_vertex_count, int **r_index, int *r_index_count, int *r_size_hint_x, int *r_size_hint_y) {
//set up input mesh
- xatlas::InputMesh input_mesh;
- input_mesh.indexData = malloc(sizeof(int) * p_index_count);
+ xatlas::MeshDecl input_mesh;
+ input_mesh.indexData = p_indices;
input_mesh.indexCount = p_index_count;
- input_mesh.indexFormat = xatlas::IndexFormat::Float; //really xatlas?
- input_mesh.faceMaterialData = (uint16_t *)malloc(sizeof(uint16_t) * p_index_count);
-
- for (int i = 0; i < p_index_count; i++) {
- int *index = (int *)input_mesh.indexData;
- index[i] = p_indices[i];
- }
- for (int i = 0; i < p_index_count / 3; i++) {
- uint16_t *mat_index = (uint16_t *)input_mesh.faceMaterialData;
- mat_index[i] = p_face_materials[i];
- }
+ input_mesh.indexFormat = xatlas::IndexFormat::UInt32;
input_mesh.vertexCount = p_vertex_count;
- input_mesh.vertexPositionData = malloc(sizeof(float) * p_vertex_count * 3);
+ input_mesh.vertexPositionData = p_vertices;
input_mesh.vertexPositionStride = sizeof(float) * 3;
- input_mesh.vertexNormalData = malloc(sizeof(float) * p_vertex_count * 3);
- input_mesh.vertexNormalStride = sizeof(float) * 3;
-
- //material is a better hint than this i guess?
+ input_mesh.vertexNormalData = p_normals;
+ input_mesh.vertexNormalStride = sizeof(uint32_t) * 3;
input_mesh.vertexUvData = NULL;
input_mesh.vertexUvStride = 0;
- for (int i = 0; i < p_vertex_count * 3; i++) {
- float *vertex_ptr = (float *)input_mesh.vertexPositionData;
- float *normal_ptr = (float *)input_mesh.vertexNormalData;
+ xatlas::ChartOptions chart_options;
+ xatlas::PackOptions pack_options;
- vertex_ptr[i] = p_vertices[i];
- normal_ptr[i] = p_normals[i];
- }
-
- xatlas::CharterOptions chart_options;
- xatlas::PackerOptions pack_options;
-
- pack_options.method = xatlas::PackMethod::TexelArea;
- pack_options.texelArea = 1.0 / p_texel_size;
- pack_options.quality = 3;
+ pack_options.maxChartSize = 4096;
+ pack_options.bruteForce = true;
+ pack_options.texelsPerUnit = 1.0 / p_texel_size;
xatlas::Atlas *atlas = xatlas::Create();
- printf("adding mesh..\n");
- xatlas::AddMeshError err = xatlas::AddMesh(atlas, input_mesh);
- ERR_EXPLAINC(xatlas::StringForEnum(err.code));
- ERR_FAIL_COND_V(err.code != xatlas::AddMeshErrorCode::Success, false);
+ printf("Adding mesh..\n");
+ xatlas::AddMeshError::Enum err = xatlas::AddMesh(atlas, input_mesh, 1);
+ ERR_EXPLAINC(xatlas::StringForEnum(err));
+ ERR_FAIL_COND_V(err != xatlas::AddMeshError::Enum::Success, false);
- printf("generate..\n");
- xatlas::Generate(atlas, chart_options, pack_options);
+ printf("Generate..\n");
+ xatlas::Generate(atlas, chart_options, NULL, pack_options);
- *r_size_hint_x = xatlas::GetWidth(atlas);
- *r_size_hint_y = xatlas::GetHeight(atlas);
+ *r_size_hint_x = atlas->width;
+ *r_size_hint_y = atlas->height;
float w = *r_size_hint_x;
float h = *r_size_hint_y;
@@ -98,39 +78,33 @@ bool xatlas_mesh_lightmap_unwrap_callback(float p_texel_size, const float *p_ver
return false; //could not bake
}
- const xatlas::OutputMesh *const *output_meshes = xatlas::GetOutputMeshes(atlas);
-
- const xatlas::OutputMesh *output = output_meshes[0];
+ const xatlas::Mesh &output = atlas->meshes[0];
- *r_vertex = (int *)malloc(sizeof(int) * output->vertexCount);
- *r_uv = (float *)malloc(sizeof(float) * output->vertexCount * 2);
- *r_index = (int *)malloc(sizeof(int) * output->indexCount);
+ *r_vertex = (int *)malloc(sizeof(int) * output.vertexCount);
+ *r_uv = (float *)malloc(sizeof(float) * output.vertexCount * 2);
+ *r_index = (int *)malloc(sizeof(int) * output.indexCount);
float max_x = 0;
float max_y = 0;
- for (uint32_t i = 0; i < output->vertexCount; i++) {
- (*r_vertex)[i] = output->vertexArray[i].xref;
- (*r_uv)[i * 2 + 0] = output->vertexArray[i].uv[0] / w;
- (*r_uv)[i * 2 + 1] = output->vertexArray[i].uv[1] / h;
- max_x = MAX(max_x, output->vertexArray[i].uv[0]);
- max_y = MAX(max_y, output->vertexArray[i].uv[1]);
+ for (uint32_t i = 0; i < output.vertexCount; i++) {
+ (*r_vertex)[i] = output.vertexArray[i].xref;
+ (*r_uv)[i * 2 + 0] = output.vertexArray[i].uv[0] / w;
+ (*r_uv)[i * 2 + 1] = output.vertexArray[i].uv[1] / h;
+ max_x = MAX(max_x, output.vertexArray[i].uv[0]);
+ max_y = MAX(max_y, output.vertexArray[i].uv[1]);
}
- printf("final texsize: %f,%f - max %f,%f\n", w, h, max_x, max_y);
- *r_vertex_count = output->vertexCount;
+ printf("Final texture size: %f,%f - max %f,%f\n", w, h, max_x, max_y);
+ *r_vertex_count = output.vertexCount;
- for (uint32_t i = 0; i < output->indexCount; i++) {
- (*r_index)[i] = output->indexArray[i];
+ for (uint32_t i = 0; i < output.indexCount; i++) {
+ (*r_index)[i] = output.indexArray[i];
}
- *r_index_count = output->indexCount;
+ *r_index_count = output.indexCount;
//xatlas::Destroy(atlas);
- free((void *)input_mesh.indexData);
- free((void *)input_mesh.vertexPositionData);
- free((void *)input_mesh.vertexNormalData);
- free((void *)input_mesh.faceMaterialData);
- printf("done");
+ printf("Done\n");
return true;
}
diff --git a/thirdparty/README.md b/thirdparty/README.md
index 8ade4024bb..cb29eadeca 100644
--- a/thirdparty/README.md
+++ b/thirdparty/README.md
@@ -511,7 +511,7 @@ folder.
## xatlas
- Upstream: https://github.com/jpcy/xatlas
-- Version: git (b8ec29b, 2018)
+- Version: git (b7d7bb, 2019)
- License: MIT
Files extracted from upstream source:
diff --git a/thirdparty/xatlas/xatlas.cpp b/thirdparty/xatlas/xatlas.cpp
index 2cc2905eee..c62be4e73a 100644
--- a/thirdparty/xatlas/xatlas.cpp
+++ b/thirdparty/xatlas/xatlas.cpp
@@ -1,128 +1,441 @@
-// This code is in the public domain -- castanyo@yahoo.es
+/*
+MIT License
+
+Copyright (c) 2018-2019 Jonathan Young
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+/*
+thekla_atlas
+https://github.com/Thekla/thekla_atlas
+MIT License
+Copyright (c) 2013 Thekla, Inc
+Copyright NVIDIA Corporation 2006 -- Ignacio Castano <icastano@nvidia.com>
+
+Fast-BVH
+https://github.com/brandonpelfrey/Fast-BVH
+MIT License
+Copyright (c) 2012 Brandon Pelfrey
+*/
#include <algorithm>
-#include <cmath>
-#include <memory>
-#include <unordered_map>
-#include <vector>
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
#include <assert.h>
-#include <float.h>
+#include <float.h> // FLT_MAX
+#include <limits.h>
#include <math.h>
-#include <stdarg.h>
+#define __STDC_LIMIT_MACROS
#include <stdint.h>
#include <stdio.h>
#include <string.h>
-#include <time.h>
#include "xatlas.h"
-#undef min
-#undef max
+#ifndef XA_DEBUG
+#ifdef NDEBUG
+#define XA_DEBUG 0
+#else
+#define XA_DEBUG 1
+#endif
+#endif
-#ifndef xaAssert
-#define xaAssert(exp) if (!(exp)) { xaPrint("%s %s %s\n", #exp, __FILE__, __LINE__); }
+#ifndef XA_PROFILE
+#define XA_PROFILE 0
#endif
-#ifndef xaDebugAssert
-#define xaDebugAssert(exp) assert(exp)
+#if XA_PROFILE
+#include <time.h>
#endif
-#ifndef xaPrint
-#define xaPrint(...) if (xatlas::internal::s_print) { xatlas::internal::s_print(__VA_ARGS__); }
+
+#ifndef XA_MULTITHREADED
+#define XA_MULTITHREADED 1
#endif
-#ifdef _MSC_VER
-// Ignore gcc attributes.
-#define __attribute__(X)
+#define XA_STR(x) #x
+#define XA_XSTR(x) XA_STR(x)
+
+#ifndef XA_ASSERT
+#define XA_ASSERT(exp) if (!(exp)) { XA_PRINT_WARNING("\rASSERT: %s %s %d\n", XA_XSTR(exp), __FILE__, __LINE__); }
#endif
-#ifdef _MSC_VER
-#define restrict
-#define NV_FORCEINLINE __forceinline
-#else
-#define restrict __restrict__
-#define NV_FORCEINLINE __attribute__((always_inline)) inline
+#ifndef XA_DEBUG_ASSERT
+#define XA_DEBUG_ASSERT(exp) assert(exp)
#endif
-#define NV_UINT32_MAX 0xffffffff
-#define NV_FLOAT_MAX 3.402823466e+38F
+#ifndef XA_PRINT
+#define XA_PRINT(...) \
+ if (xatlas::internal::s_print && xatlas::internal::s_printVerbose) \
+ xatlas::internal::s_print(__VA_ARGS__);
+#endif
-#ifndef PI
-#define PI float(3.1415926535897932384626433833)
+#ifndef XA_PRINT_WARNING
+#define XA_PRINT_WARNING(...) \
+ if (xatlas::internal::s_print) \
+ xatlas::internal::s_print(__VA_ARGS__);
#endif
-#define NV_EPSILON (0.0001f)
-#define NV_NORMAL_EPSILON (0.001f)
+#define XA_ALLOC(tag, type) (type *)internal::Realloc(nullptr, sizeof(type), tag, __FILE__, __LINE__)
+#define XA_ALLOC_ARRAY(tag, type, num) (type *)internal::Realloc(nullptr, sizeof(type) * num, tag, __FILE__, __LINE__)
+#define XA_REALLOC(tag, ptr, type, num) (type *)internal::Realloc(ptr, sizeof(type) * num, tag, __FILE__, __LINE__)
+#define XA_FREE(ptr) internal::Realloc(ptr, 0, internal::MemTag::Default, __FILE__, __LINE__)
+#define XA_NEW(tag, type, ...) new (XA_ALLOC(tag, type)) type(__VA_ARGS__)
+
+#define XA_UNUSED(a) ((void)(a))
+
+#define XA_GROW_CHARTS_COPLANAR 1
+#define XA_MERGE_CHARTS 1
+#define XA_MERGE_CHARTS_MIN_NORMAL_DEVIATION 0.5f
+#define XA_RECOMPUTE_CHARTS 1
+#define XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION 0
+
+#define XA_DEBUG_HEAP 0
+#define XA_DEBUG_SINGLE_CHART 0
+#define XA_DEBUG_EXPORT_ATLAS_IMAGES 0
+#define XA_DEBUG_EXPORT_OBJ_SOURCE_MESHES 0
+#define XA_DEBUG_EXPORT_OBJ_CHART_GROUPS 0
+#define XA_DEBUG_EXPORT_OBJ_CHARTS 0
+#define XA_DEBUG_EXPORT_OBJ_BEFORE_FIX_TJUNCTION 0
+#define XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR 0
+#define XA_DEBUG_EXPORT_OBJ_NOT_DISK 0
+#define XA_DEBUG_EXPORT_OBJ_CHARTS_AFTER_PARAMETERIZATION 0
+#define XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION 0
+#define XA_DEBUG_EXPORT_OBJ_RECOMPUTED_CHARTS 0
+
+#define XA_DEBUG_EXPORT_OBJ (0 \
+ || XA_DEBUG_EXPORT_OBJ_SOURCE_MESHES \
+ || XA_DEBUG_EXPORT_OBJ_CHART_GROUPS \
+ || XA_DEBUG_EXPORT_OBJ_CHARTS \
+ || XA_DEBUG_EXPORT_OBJ_BEFORE_FIX_TJUNCTION \
+ || XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR \
+ || XA_DEBUG_EXPORT_OBJ_NOT_DISK \
+ || XA_DEBUG_EXPORT_OBJ_CHARTS_AFTER_PARAMETERIZATION \
+ || XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION \
+ || XA_DEBUG_EXPORT_OBJ_RECOMPUTED_CHARTS)
+
+#ifdef _MSC_VER
+#define XA_FOPEN(_file, _filename, _mode) { if (fopen_s(&_file, _filename, _mode) != 0) _file = NULL; }
+#define XA_SPRINTF(_buffer, _size, _format, ...) sprintf_s(_buffer, _size, _format, __VA_ARGS__)
+#else
+#define XA_FOPEN(_file, _filename, _mode) _file = fopen(_filename, _mode)
+#define XA_SPRINTF(_buffer, _size, _format, ...) sprintf(_buffer, _format, __VA_ARGS__)
+#endif
namespace xatlas {
namespace internal {
-static PrintFunc s_print = NULL;
+static ReallocFunc s_realloc = realloc;
+static PrintFunc s_print = printf;
+static bool s_printVerbose = false;
+
+struct MemTag
+{
+ enum
+ {
+ Default,
+ Mesh,
+ MeshBoundaries,
+ MeshColocals,
+ MeshEdgeMap,
+ MeshIndices,
+ MeshNormals,
+ MeshPositions,
+ MeshTexcoords,
+ Count
+ };
+};
+
+#if XA_DEBUG_HEAP
+struct AllocHeader
+{
+ size_t size;
+ const char *file;
+ int line;
+ int tag;
+ AllocHeader *prev, *next;
+ bool free;
+};
+
+static std::mutex s_allocMutex;
+static AllocHeader *s_allocRoot = nullptr;
+static size_t s_allocTotalSize = 0, s_allocPeakSize = 0, s_allocTotalTagSize[MemTag::Count] = { 0 }, s_allocPeakTagSize[MemTag::Count] = { 0 };
+static constexpr uint32_t kAllocRedzone = 0x12345678;
+
+static void *Realloc(void *ptr, size_t size, int tag, const char *file, int line)
+{
+ std::unique_lock<std::mutex> lock(s_allocMutex);
+ if (!size && !ptr)
+ return nullptr;
+ uint8_t *realPtr = nullptr;
+ AllocHeader *header = nullptr;
+ if (ptr) {
+ realPtr = ((uint8_t *)ptr) - sizeof(AllocHeader);
+ header = (AllocHeader *)realPtr;
+ }
+ if (realPtr && size) {
+ s_allocTotalSize -= header->size;
+ s_allocTotalTagSize[header->tag] -= header->size;
+ // realloc, remove.
+ if (header->prev)
+ header->prev->next = header->next;
+ else
+ s_allocRoot = header->next;
+ if (header->next)
+ header->next->prev = header->prev;
+ }
+ if (!size) {
+ s_allocTotalSize -= header->size;
+ s_allocTotalTagSize[header->tag] -= header->size;
+ XA_ASSERT(!header->free); // double free
+ header->free = true;
+ return nullptr;
+ }
+ size += sizeof(AllocHeader) + sizeof(kAllocRedzone);
+ uint8_t *newPtr = (uint8_t *)s_realloc(realPtr, size);
+ if (!newPtr)
+ return nullptr;
+ header = (AllocHeader *)newPtr;
+ header->size = size;
+ header->file = file;
+ header->line = line;
+ header->tag = tag;
+ header->free = false;
+ if (!s_allocRoot) {
+ s_allocRoot = header;
+ header->prev = header->next = 0;
+ } else {
+ header->prev = nullptr;
+ header->next = s_allocRoot;
+ s_allocRoot = header;
+ header->next->prev = header;
+ }
+ s_allocTotalSize += size;
+ if (s_allocTotalSize > s_allocPeakSize)
+ s_allocPeakSize = s_allocTotalSize;
+ s_allocTotalTagSize[tag] += size;
+ if (s_allocTotalTagSize[tag] > s_allocPeakTagSize[tag])
+ s_allocPeakTagSize[tag] = s_allocTotalTagSize[tag];
+ auto redzone = (uint32_t *)(newPtr + size - sizeof(kAllocRedzone));
+ *redzone = kAllocRedzone;
+ return newPtr + sizeof(AllocHeader);
+}
+
+static void ReportLeaks()
+{
+ printf("Checking for memory leaks...\n");
+ bool anyLeaks = false;
+ AllocHeader *header = s_allocRoot;
+ while (header) {
+ if (!header->free) {
+ printf(" Leak: %zu bytes %s %d\n", header->size, header->file, header->line);
+ anyLeaks = true;
+ }
+ auto redzone = (const uint32_t *)((const uint8_t *)header + header->size - sizeof(kAllocRedzone));
+ if (*redzone != kAllocRedzone)
+ printf(" Redzone corrupted: %zu bytes %s %d\n", header->size, header->file, header->line);
+ header = header->next;
+ }
+ if (!anyLeaks)
+ printf(" No memory leaks\n");
+ header = s_allocRoot;
+ while (header) {
+ AllocHeader *destroy = header;
+ header = header->next;
+ s_realloc(destroy, 0);
+ }
+ s_allocRoot = nullptr;
+ s_allocTotalSize = s_allocPeakSize = 0;
+ for (int i = 0; i < MemTag::Count; i++)
+ s_allocTotalTagSize[i] = s_allocPeakTagSize[i] = 0;
+}
+
+static void PrintMemoryUsage()
+{
+ XA_PRINT("Memory usage: %0.2fMB current, %0.2fMB peak\n", internal::s_allocTotalSize / 1024.0f / 1024.0f, internal::s_allocPeakSize / 1024.0f / 1024.0f);
+ static const char *labels[] = { // Sync with MemTag
+ "Default",
+ "Mesh",
+ "MeshBoundaries",
+ "MeshColocals",
+ "MeshEdgeMap",
+ "MeshIndices",
+ "MeshNormals",
+ "MeshPositions",
+ "MeshTexcoords"
+ };
+ for (int i = 0; i < MemTag::Count; i++) {
+ XA_PRINT(" %s: %0.2fMB current, %0.2fMB peak\n", labels[i], internal::s_allocTotalTagSize[i] / 1024.0f / 1024.0f, internal::s_allocPeakTagSize[i] / 1024.0f / 1024.0f);
+ }
+}
+
+#define XA_PRINT_MEM_USAGE internal::PrintMemoryUsage();
+#else
+static void *Realloc(void *ptr, size_t size, int /*tag*/, const char * /*file*/, int /*line*/)
+{
+ void *mem = s_realloc(ptr, size);
+ if (size > 0) {
+ XA_DEBUG_ASSERT(mem);
+ }
+ return mem;
+}
+#define XA_PRINT_MEM_USAGE
+#endif
+
+#if XA_PROFILE
+#define XA_PROFILE_START(var) const clock_t var##Start = clock();
+#define XA_PROFILE_END(var) internal::s_profile.var += clock() - var##Start;
+#define XA_PROFILE_PRINT(label, var) XA_PRINT("%s%.2f seconds (%g ms)\n", label, internal::clockToSeconds(internal::s_profile.var), internal::clockToMs(internal::s_profile.var));
+
+struct ProfileData
+{
+ clock_t addMeshConcurrent;
+ std::atomic<clock_t> addMesh;
+ std::atomic<clock_t> addMeshCreateColocals;
+ std::atomic<clock_t> addMeshCreateFaceGroups;
+ std::atomic<clock_t> addMeshCreateBoundaries;
+ std::atomic<clock_t> addMeshCreateChartGroupsConcurrent;
+ std::atomic<clock_t> addMeshCreateChartGroups;
+ clock_t computeChartsConcurrent;
+ std::atomic<clock_t> computeCharts;
+ std::atomic<clock_t> atlasBuilder;
+ std::atomic<clock_t> atlasBuilderInit;
+ std::atomic<clock_t> atlasBuilderCreateInitialCharts;
+ std::atomic<clock_t> atlasBuilderGrowCharts;
+ std::atomic<clock_t> atlasBuilderMergeCharts;
+ std::atomic<clock_t> createChartMeshes;
+ std::atomic<clock_t> fixChartMeshTJunctions;
+ std::atomic<clock_t> closeChartMeshHoles;
+ clock_t parameterizeChartsConcurrent;
+ std::atomic<clock_t> parameterizeCharts;
+ std::atomic<clock_t> parameterizeChartsOrthogonal;
+ std::atomic<clock_t> parameterizeChartsLSCM;
+ std::atomic<clock_t> parameterizeChartsEvaluateQuality;
+ clock_t packCharts;
+ clock_t packChartsRasterize;
+ clock_t packChartsDilate;
+ clock_t packChartsFindLocation;
+ clock_t packChartsBlit;
+};
+
+static ProfileData s_profile;
+
+static double clockToMs(clock_t c)
+{
+ return c * 1000.0 / CLOCKS_PER_SEC;
+}
+
+static double clockToSeconds(clock_t c)
+{
+ return c / (double)CLOCKS_PER_SEC;
+}
+#else
+#define XA_PROFILE_START(var)
+#define XA_PROFILE_END(var)
+#define XA_PROFILE_PRINT(label, var)
+#endif
+
+static constexpr float kPi = 3.14159265358979323846f;
+static constexpr float kPi2 = 6.28318530717958647692f;
+static constexpr float kEpsilon = 0.0001f;
+static constexpr float kAreaEpsilon = FLT_EPSILON;
+static constexpr float kNormalEpsilon = 0.001f;
static int align(int x, int a)
{
return (x + a - 1) & ~(a - 1);
}
-static bool isAligned(int x, int a)
+template <typename T>
+static T max(const T &a, const T &b)
{
- return (x & (a - 1)) == 0;
+ return a > b ? a : b;
+}
+
+template <typename T>
+static T min(const T &a, const T &b)
+{
+ return a < b ? a : b;
}
-/// Return the maximum of the three arguments.
template <typename T>
static T max3(const T &a, const T &b, const T &c)
{
- return std::max(a, std::max(b, c));
+ return max(a, max(b, c));
}
/// Return the maximum of the three arguments.
template <typename T>
static T min3(const T &a, const T &b, const T &c)
{
- return std::min(a, std::min(b, c));
+ return min(a, min(b, c));
}
/// Clamp between two values.
template <typename T>
static T clamp(const T &x, const T &a, const T &b)
{
- return std::min(std::max(x, a), b);
+ return min(max(x, a), b);
}
-static float saturate(float f)
+template <typename T>
+static void swap(T &a, T &b)
{
- return clamp(f, 0.0f, 1.0f);
+ T temp;
+ temp = a;
+ a = b;
+ b = temp;
+ temp = T();
}
-// Robust floating point comparisons:
-// http://realtimecollisiondetection.net/blog/?p=89
-static bool equal(const float f0, const float f1, const float epsilon = NV_EPSILON)
+union FloatUint32
{
- //return fabs(f0-f1) <= epsilon;
- return fabs(f0 - f1) <= epsilon * max3(1.0f, fabsf(f0), fabsf(f1));
-}
+ float f;
+ uint32_t u;
+};
-NV_FORCEINLINE static int ftoi_floor(float val)
+static bool isFinite(float f)
{
- return (int)val;
+ FloatUint32 fu;
+ fu.f = f;
+ return fu.u != 0x7F800000u && fu.u != 0x7F800001u;
}
-NV_FORCEINLINE static int ftoi_ceil(float val)
+static bool isNan(float f)
{
- return (int)ceilf(val);
+ return f != f;
}
-NV_FORCEINLINE static int ftoi_round(float f)
+// Robust floating point comparisons:
+// http://realtimecollisiondetection.net/blog/?p=89
+static bool equal(const float f0, const float f1, const float epsilon)
{
- return int(floorf(f + 0.5f));
+ //return fabs(f0-f1) <= epsilon;
+ return fabs(f0 - f1) <= epsilon * max3(1.0f, fabsf(f0), fabsf(f1));
}
-static bool isZero(const float f, const float epsilon = NV_EPSILON)
+static int ftoi_ceil(float val)
{
- return fabs(f) <= epsilon;
+ return (int)ceilf(val);
}
-static float lerp(float f0, float f1, float t)
+static bool isZero(const float f, const float epsilon)
{
- const float s = 1.0f - t;
- return f0 * s + f1 * t;
+ return fabs(f) <= epsilon;
}
static float square(float f)
@@ -130,11 +443,6 @@ static float square(float f)
return f * f;
}
-static int square(int i)
-{
- return i * i;
-}
-
/** Return the next power of two.
* @see http://graphics.stanford.edu/~seander/bithacks.html
* @warning Behaviour for 0 is undefined.
@@ -143,7 +451,7 @@ static int square(int i)
*/
static uint32_t nextPowerOfTwo(uint32_t x)
{
- xaDebugAssert( x != 0 );
+ XA_DEBUG_ASSERT( x != 0 );
// On modern CPUs this is supposed to be as fast as using the bsr instruction.
x--;
x |= x >> 1;
@@ -154,16 +462,6 @@ static uint32_t nextPowerOfTwo(uint32_t x)
return x + 1;
}
-static uint64_t nextPowerOfTwo(uint64_t x)
-{
- xaDebugAssert(x != 0);
- uint32_t p = 1;
- while (x > p) {
- p += p;
- }
- return p;
-}
-
static uint32_t sdbmHash(const void *data_in, uint32_t size, uint32_t h = 5381)
{
const uint8_t *data = (const uint8_t *) data_in;
@@ -174,31 +472,12 @@ static uint32_t sdbmHash(const void *data_in, uint32_t size, uint32_t h = 5381)
return h;
}
-// Note that this hash does not handle NaN properly.
-static uint32_t sdbmFloatHash(const float *f, uint32_t count, uint32_t h = 5381)
-{
- for (uint32_t i = 0; i < count; i++) {
- union {
- float f;
- uint32_t i;
- } x = { f[i] };
- if (x.i == 0x80000000) x.i = 0;
- h = sdbmHash(&x, 4, h);
- }
- return h;
-}
-
template <typename T>
static uint32_t hash(const T &t, uint32_t h = 5381)
{
return sdbmHash(&t, sizeof(T), h);
}
-static uint32_t hash(const float &f, uint32_t h)
-{
- return sdbmFloatHash(&f, 1, h);
-}
-
// Functors for hash table:
template <typename Key> struct Hash
{
@@ -213,40 +492,22 @@ template <typename Key> struct Equal
class Vector2
{
public:
- typedef Vector2 const &Arg;
-
Vector2() {}
explicit Vector2(float f) : x(f), y(f) {}
Vector2(float x, float y): x(x), y(y) {}
- Vector2(Vector2::Arg v) : x(v.x), y(v.y) {}
-
- const Vector2 &operator=(Vector2::Arg v)
- {
- x = v.x;
- y = v.y;
- return
- *this;
- }
- const float *ptr() const { return &x; }
-
- void set(float _x, float _y)
- {
- x = _x;
- y = _y;
- }
Vector2 operator-() const
{
return Vector2(-x, -y);
}
- void operator+=(Vector2::Arg v)
+ void operator+=(const Vector2 &v)
{
x += v.x;
y += v.y;
}
- void operator-=(Vector2::Arg v)
+ void operator-=(const Vector2 &v)
{
x -= v.x;
y -= v.y;
@@ -258,138 +519,99 @@ public:
y *= s;
}
- void operator*=(Vector2::Arg v)
+ void operator*=(const Vector2 &v)
{
x *= v.x;
y *= v.y;
}
- friend bool operator==(Vector2::Arg a, Vector2::Arg b)
- {
- return a.x == b.x && a.y == b.y;
- }
-
- friend bool operator!=(Vector2::Arg a, Vector2::Arg b)
- {
- return a.x != b.x || a.y != b.y;
- }
-
- union
- {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4201)
-#endif
- struct
- {
- float x, y;
- };
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
- float component[2];
- };
+ float x, y;
};
-Vector2 operator+(Vector2::Arg a, Vector2::Arg b)
+static bool operator==(const Vector2 &a, const Vector2 &b)
{
- return Vector2(a.x + b.x, a.y + b.y);
+ return a.x == b.x && a.y == b.y;
}
-Vector2 operator-(Vector2::Arg a, Vector2::Arg b)
+static bool operator!=(const Vector2 &a, const Vector2 &b)
{
- return Vector2(a.x - b.x, a.y - b.y);
+ return a.x != b.x || a.y != b.y;
}
-Vector2 operator*(Vector2::Arg v, float s)
+static Vector2 operator+(const Vector2 &a, const Vector2 &b)
{
- return Vector2(v.x * s, v.y * s);
-}
-
-Vector2 operator*(Vector2::Arg v1, Vector2::Arg v2)
-{
- return Vector2(v1.x * v2.x, v1.y * v2.y);
+ return Vector2(a.x + b.x, a.y + b.y);
}
-Vector2 operator/(Vector2::Arg v, float s)
+static Vector2 operator-(const Vector2 &a, const Vector2 &b)
{
- return Vector2(v.x / s, v.y / s);
+ return Vector2(a.x - b.x, a.y - b.y);
}
-Vector2 lerp(Vector2::Arg v1, Vector2::Arg v2, float t)
+static Vector2 operator*(const Vector2 &v, float s)
{
- const float s = 1.0f - t;
- return Vector2(v1.x * s + t * v2.x, v1.y * s + t * v2.y);
+ return Vector2(v.x * s, v.y * s);
}
-float dot(Vector2::Arg a, Vector2::Arg b)
+static float dot(const Vector2 &a, const Vector2 &b)
{
return a.x * b.x + a.y * b.y;
}
-float lengthSquared(Vector2::Arg v)
+static float lengthSquared(const Vector2 &v)
{
return v.x * v.x + v.y * v.y;
}
-float length(Vector2::Arg v)
+static float length(const Vector2 &v)
{
return sqrtf(lengthSquared(v));
}
-float distance(Vector2::Arg a, Vector2::Arg b)
-{
- return length(a - b);
-}
-
-bool isNormalized(Vector2::Arg v, float epsilon = NV_NORMAL_EPSILON)
+#if XA_DEBUG
+static bool isNormalized(const Vector2 &v, float epsilon = kNormalEpsilon)
{
return equal(length(v), 1, epsilon);
}
+#endif
-Vector2 normalize(Vector2::Arg v, float epsilon = NV_EPSILON)
+static Vector2 normalize(const Vector2 &v, float epsilon)
{
float l = length(v);
- xaDebugAssert(!isZero(l, epsilon));
-#ifdef NDEBUG
- epsilon = 0; // silence unused parameter warning
-#endif
+ XA_DEBUG_ASSERT(!isZero(l, epsilon));
+ XA_UNUSED(epsilon);
Vector2 n = v * (1.0f / l);
- xaDebugAssert(isNormalized(n));
+ XA_DEBUG_ASSERT(isNormalized(n));
return n;
}
-Vector2 normalizeSafe(Vector2::Arg v, Vector2::Arg fallback, float epsilon = NV_EPSILON)
+static bool equal(const Vector2 &v1, const Vector2 &v2, float epsilon)
{
- float l = length(v);
- if (isZero(l, epsilon)) {
- return fallback;
- }
- return v * (1.0f / l);
+ return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon);
}
-bool equal(Vector2::Arg v1, Vector2::Arg v2, float epsilon = NV_EPSILON)
+static Vector2 min(const Vector2 &a, const Vector2 &b)
{
- return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon);
+ return Vector2(min(a.x, b.x), min(a.y, b.y));
}
-Vector2 max(Vector2::Arg a, Vector2::Arg b)
+static Vector2 max(const Vector2 &a, const Vector2 &b)
{
- return Vector2(std::max(a.x, b.x), std::max(a.y, b.y));
+ return Vector2(max(a.x, b.x), max(a.y, b.y));
}
-bool isFinite(Vector2::Arg v)
+static bool isFinite(const Vector2 &v)
{
- return std::isfinite(v.x) && std::isfinite(v.y);
+ return isFinite(v.x) && isFinite(v.y);
}
// Note, this is the area scaled by 2!
-float triangleArea(Vector2::Arg v0, Vector2::Arg v1)
+static float triangleArea(const Vector2 &v0, const Vector2 &v1)
{
return (v0.x * v1.y - v0.y * v1.x); // * 0.5f;
}
-float triangleArea(Vector2::Arg a, Vector2::Arg b, Vector2::Arg c)
+
+static float triangleArea(const Vector2 &a, const Vector2 &b, const Vector2 &c)
{
// IC: While it may be appealing to use the following expression:
//return (c.x * a.y + a.x * b.y + b.x * c.y - b.x * a.y - c.x * b.y - a.x * c.y); // * 0.5f;
@@ -402,62 +624,54 @@ float triangleArea(Vector2::Arg a, Vector2::Arg b, Vector2::Arg c)
return triangleArea(a - c, b - c);
}
-float triangleArea2(Vector2::Arg v1, Vector2::Arg v2, Vector2::Arg v3)
+static bool linesIntersect(const Vector2 &a1, const Vector2 &a2, const Vector2 &b1, const Vector2 &b2, float epsilon)
{
- return 0.5f * (v3.x * v1.y + v1.x * v2.y + v2.x * v3.y - v2.x * v1.y - v3.x * v2.y - v1.x * v3.y);
+ const Vector2 v0 = a2 - a1;
+ const Vector2 v1 = b2 - b1;
+ const float denom = -v1.x * v0.y + v0.x * v1.y;
+ if (equal(denom, 0.0f, epsilon))
+ return false;
+ const float s = (-v0.y * (a1.x - b1.x) + v0.x * (a1.y - b1.y)) / denom;
+ if (s > epsilon && s < 1.0f - epsilon) {
+ const float t = ( v1.x * (a1.y - b1.y) - v1.y * (a1.x - b1.x)) / denom;
+ return t > epsilon && t < 1.0f - epsilon;
+ }
+ return false;
}
-static uint32_t hash(const Vector2 &v, uint32_t h)
+struct Vector2i
{
- return sdbmFloatHash(v.component, 2, h);
-}
+ Vector2i(int32_t x, int32_t y) : x(x), y(y) {}
+
+ int32_t x, y;
+};
class Vector3
{
public:
- typedef Vector3 const &Arg;
-
Vector3() {}
explicit Vector3(float f) : x(f), y(f), z(f) {}
Vector3(float x, float y, float z) : x(x), y(y), z(z) {}
- Vector3(Vector2::Arg v, float z) : x(v.x), y(v.y), z(z) {}
- Vector3(Vector3::Arg v) : x(v.x), y(v.y), z(v.z) {}
-
- const Vector3 &operator=(Vector3::Arg v)
- {
- x = v.x;
- y = v.y;
- z = v.z;
- return *this;
- }
+ Vector3(const Vector2 &v, float z) : x(v.x), y(v.y), z(z) {}
Vector2 xy() const
{
return Vector2(x, y);
}
- const float *ptr() const { return &x; }
-
- void set(float _x, float _y, float _z)
- {
- x = _x;
- y = _y;
- z = _z;
- }
-
Vector3 operator-() const
{
return Vector3(-x, -y, -z);
}
- void operator+=(Vector3::Arg v)
+ void operator+=(const Vector3 &v)
{
x += v.x;
y += v.y;
z += v.z;
}
- void operator-=(Vector3::Arg v)
+ void operator-=(const Vector3 &v)
{
x -= v.x;
y -= v.y;
@@ -479,159 +693,89 @@ public:
z *= is;
}
- void operator*=(Vector3::Arg v)
+ void operator*=(const Vector3 &v)
{
x *= v.x;
y *= v.y;
z *= v.z;
}
- void operator/=(Vector3::Arg v)
+ void operator/=(const Vector3 &v)
{
x /= v.x;
y /= v.y;
z /= v.z;
}
- friend bool operator==(Vector3::Arg a, Vector3::Arg b)
- {
- return a.x == b.x && a.y == b.y && a.z == b.z;
- }
-
- friend bool operator!=(Vector3::Arg a, Vector3::Arg b)
- {
- return a.x != b.x || a.y != b.y || a.z != b.z;
- }
-
- union
- {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4201)
-#endif
- struct
- {
- float x, y, z;
- };
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
- float component[3];
- };
+ float x, y, z;
};
-Vector3 add(Vector3::Arg a, Vector3::Arg b)
-{
- return Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
-}
-Vector3 add(Vector3::Arg a, float b)
-{
- return Vector3(a.x + b, a.y + b, a.z + b);
-}
-Vector3 operator+(Vector3::Arg a, Vector3::Arg b)
+static bool operator!=(const Vector3 &a, const Vector3 &b)
{
- return add(a, b);
-}
-Vector3 operator+(Vector3::Arg a, float b)
-{
- return add(a, b);
+ return a.x != b.x || a.y != b.y || a.z != b.z;
}
-Vector3 sub(Vector3::Arg a, Vector3::Arg b)
+static Vector3 operator+(const Vector3 &a, const Vector3 &b)
{
- return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
-}
-
-Vector3 sub(Vector3::Arg a, float b)
-{
- return Vector3(a.x - b, a.y - b, a.z - b);
-}
-
-Vector3 operator-(Vector3::Arg a, Vector3::Arg b)
-{
- return sub(a, b);
+ return Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
}
-Vector3 operator-(Vector3::Arg a, float b)
+static Vector3 operator-(const Vector3 &a, const Vector3 &b)
{
- return sub(a, b);
+ return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
}
-Vector3 cross(Vector3::Arg a, Vector3::Arg b)
+static Vector3 cross(const Vector3 &a, const Vector3 &b)
{
return Vector3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
}
-Vector3 operator*(Vector3::Arg v, float s)
+static Vector3 operator*(const Vector3 &v, float s)
{
return Vector3(v.x * s, v.y * s, v.z * s);
}
-Vector3 operator*(float s, Vector3::Arg v)
+static Vector3 operator*(float s, const Vector3 &v)
{
return Vector3(v.x * s, v.y * s, v.z * s);
}
-Vector3 operator*(Vector3::Arg v, Vector3::Arg s)
-{
- return Vector3(v.x * s.x, v.y * s.y, v.z * s.z);
-}
-
-Vector3 operator/(Vector3::Arg v, float s)
+static Vector3 operator/(const Vector3 &v, float s)
{
return v * (1.0f / s);
}
-Vector3 lerp(Vector3::Arg v1, Vector3::Arg v2, float t)
-{
- const float s = 1.0f - t;
- return Vector3(v1.x * s + t * v2.x, v1.y * s + t * v2.y, v1.z * s + t * v2.z);
-}
-
-float dot(Vector3::Arg a, Vector3::Arg b)
+static float dot(const Vector3 &a, const Vector3 &b)
{
return a.x * b.x + a.y * b.y + a.z * b.z;
}
-float lengthSquared(Vector3::Arg v)
+static float lengthSquared(const Vector3 &v)
{
return v.x * v.x + v.y * v.y + v.z * v.z;
}
-float length(Vector3::Arg v)
+static float length(const Vector3 &v)
{
return sqrtf(lengthSquared(v));
}
-float distance(Vector3::Arg a, Vector3::Arg b)
-{
- return length(a - b);
-}
-
-float distanceSquared(Vector3::Arg a, Vector3::Arg b)
-{
- return lengthSquared(a - b);
-}
-
-bool isNormalized(Vector3::Arg v, float epsilon = NV_NORMAL_EPSILON)
+static bool isNormalized(const Vector3 &v, float epsilon = kNormalEpsilon)
{
return equal(length(v), 1, epsilon);
}
-Vector3 normalize(Vector3::Arg v, float epsilon = NV_EPSILON)
+static Vector3 normalize(const Vector3 &v, float epsilon)
{
float l = length(v);
- xaDebugAssert(!isZero(l, epsilon));
-#ifdef NDEBUG
- epsilon = 0; // silence unused parameter warning
-#endif
+ XA_DEBUG_ASSERT(!isZero(l, epsilon));
+ XA_UNUSED(epsilon);
Vector3 n = v * (1.0f / l);
- xaDebugAssert(isNormalized(n));
+ XA_DEBUG_ASSERT(isNormalized(n));
return n;
}
-Vector3 normalizeSafe(Vector3::Arg v, Vector3::Arg fallback, float epsilon = NV_EPSILON)
+static Vector3 normalizeSafe(const Vector3 &v, const Vector3 &fallback, float epsilon)
{
float l = length(v);
if (isZero(l, epsilon)) {
@@ -640,57 +784,423 @@ Vector3 normalizeSafe(Vector3::Arg v, Vector3::Arg fallback, float epsilon = NV_
return v * (1.0f / l);
}
-bool equal(Vector3::Arg v1, Vector3::Arg v2, float epsilon = NV_EPSILON)
+static bool equal(const Vector3 &v0, const Vector3 &v1, float epsilon)
{
- return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon) && equal(v1.z, v2.z, epsilon);
+ return fabs(v0.x - v1.x) <= epsilon && fabs(v0.y - v1.y) <= epsilon && fabs(v0.z - v1.z) <= epsilon;
}
-Vector3 min(Vector3::Arg a, Vector3::Arg b)
+static Vector3 min(const Vector3 &a, const Vector3 &b)
{
- return Vector3(std::min(a.x, b.x), std::min(a.y, b.y), std::min(a.z, b.z));
+ return Vector3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
}
-Vector3 max(Vector3::Arg a, Vector3::Arg b)
+static Vector3 max(const Vector3 &a, const Vector3 &b)
{
- return Vector3(std::max(a.x, b.x), std::max(a.y, b.y), std::max(a.z, b.z));
+ return Vector3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
}
-Vector3 clamp(Vector3::Arg v, float min, float max)
+#if XA_DEBUG
+bool isFinite(const Vector3 &v)
{
- return Vector3(clamp(v.x, min, max), clamp(v.y, min, max), clamp(v.z, min, max));
+ return isFinite(v.x) && isFinite(v.y) && isFinite(v.z);
}
+#endif
-Vector3 saturate(Vector3::Arg v)
+struct Plane
{
- return Vector3(saturate(v.x), saturate(v.y), saturate(v.z));
+ Plane() = default;
+
+ Plane(const Vector3 &p1, const Vector3 &p2, const Vector3 &p3)
+ {
+ normal = cross(p2 - p1, p3 - p1);
+ dist = dot(normal, p1);
+ }
+
+ float distance(const Vector3 &p) const
+ {
+ return dot(normal, p) - dist;
+ }
+
+ void normalize()
+ {
+ const float len = length(normal);
+ if (len > 0.0f) {
+ const float il = 1.0f / len;
+ normal *= il;
+ dist *= il;
+ }
+ }
+
+ Vector3 normal;
+ float dist;
+};
+
+static bool lineIntersectsPoint(const Vector3 &point, const Vector3 &lineStart, const Vector3 &lineEnd, float *t, float epsilon)
+{
+ float tt;
+ if (!t)
+ t = &tt;
+ *t = 0.0f;
+ if (equal(lineStart, point, epsilon) || equal(lineEnd, point, epsilon))
+ return false; // Vertex lies on either line vertices.
+ const Vector3 v01 = point - lineStart;
+ const Vector3 v21 = lineEnd - lineStart;
+ const float l = length(v21);
+ const float d = length(cross(v01, v21)) / l;
+ if (!isZero(d, epsilon))
+ return false;
+ *t = dot(v01, v21) / (l * l);
+ return *t > kEpsilon && *t < 1.0f - kEpsilon;
}
-Vector3 floor(Vector3::Arg v)
+static bool sameSide(const Vector3 &p1, const Vector3 &p2, const Vector3 &a, const Vector3 &b)
{
- return Vector3(floorf(v.x), floorf(v.y), floorf(v.z));
+ const Vector3 &ab = b - a;
+ return dot(cross(ab, p1 - a), cross(ab, p2 - a)) >= 0.0f;
}
-bool isFinite(Vector3::Arg v)
+// http://blackpawn.com/texts/pointinpoly/default.html
+static bool pointInTriangle(const Vector3 &p, const Vector3 &a, const Vector3 &b, const Vector3 &c)
{
- return std::isfinite(v.x) && std::isfinite(v.y) && std::isfinite(v.z);
+ return sameSide(p, a, b, c) && sameSide(p, b, a, c) && sameSide(p, c, a, b);
}
-static uint32_t hash(const Vector3 &v, uint32_t h)
+#if XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION
+// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+static bool rayIntersectsTriangle(const Vector3 &rayOrigin, const Vector3 &rayDir, const Vector3 *tri, float *t)
+{
+ *t = 0.0f;
+ const Vector3 &edge1 = tri[1] - tri[0];
+ const Vector3 &edge2 = tri[2] - tri[0];
+ const Vector3 h = cross(rayDir, edge2);
+ const float a = dot(edge1, h);
+ if (a > -kEpsilon && a < kEpsilon)
+ return false; // This ray is parallel to this triangle.
+ const float f = 1.0f / a;
+ const Vector3 s = rayOrigin - tri[0];
+ const float u = f * dot(s, h);
+ if (u < 0.0f || u > 1.0f)
+ return false;
+ const Vector3 q = cross(s, edge1);
+ const float v = f * dot(rayDir, q);
+ if (v < 0.0f || u + v > 1.0f)
+ return false;
+ // At this stage we can compute t to find out where the intersection point is on the line.
+ *t = f * dot(edge2, q);
+ if (*t > kEpsilon && *t < 1.0f - kEpsilon)
+ return true;
+ // This means that there is a line intersection but not a ray intersection.
+ return false;
+}
+#endif
+
+// From Fast-BVH
+struct AABB
{
- return sdbmFloatHash(v.component, 3, h);
+ AABB() : min(FLT_MAX, FLT_MAX, FLT_MAX), max(-FLT_MAX, -FLT_MAX, -FLT_MAX) {}
+ AABB(const Vector3 &min, const Vector3 &max) : min(min), max(max) { }
+ AABB(const Vector3 &p, float radius = 0.0f) : min(p), max(p) { if (radius > 0.0f) expand(radius); }
+
+ bool intersect(const AABB &other) const
+ {
+ return min.x <= other.max.x && max.x >= other.min.x && min.y <= other.max.y && max.y >= other.min.y && min.z <= other.max.z && max.z >= other.min.z;
+ }
+
+ void expandToInclude(const Vector3 &p)
+ {
+ min = internal::min(min, p);
+ max = internal::max(max, p);
+ }
+
+ void expandToInclude(const AABB &aabb)
+ {
+ min = internal::min(min, aabb.min);
+ max = internal::max(max, aabb.max);
+ }
+
+ void expand(float amount)
+ {
+ min -= Vector3(amount);
+ max += Vector3(amount);
+ }
+
+ Vector3 centroid() const
+ {
+ return min + (max - min) * 0.5f;
+ }
+
+ uint32_t maxDimension() const
+ {
+ const Vector3 extent = max - min;
+ uint32_t result = 0;
+ if (extent.y > extent.x) {
+ result = 1;
+ if (extent.z > extent.y)
+ result = 2;
+ }
+ else if(extent.z > extent.x)
+ result = 2;
+ return result;
+ }
+
+ Vector3 min, max;
+};
+
+template <typename T>
+static void construct_range(T * ptr, uint32_t new_size, uint32_t old_size) {
+ for (uint32_t i = old_size; i < new_size; i++) {
+ new(ptr+i) T; // placement new
+ }
+}
+
+template <typename T>
+static void construct_range(T * ptr, uint32_t new_size, uint32_t old_size, const T & elem) {
+ for (uint32_t i = old_size; i < new_size; i++) {
+ new(ptr+i) T(elem); // placement new
+ }
}
+template <typename T>
+static void construct_range(T * ptr, uint32_t new_size, uint32_t old_size, const T * src) {
+ for (uint32_t i = old_size; i < new_size; i++) {
+ new(ptr+i) T(src[i]); // placement new
+ }
+}
+
+template <typename T>
+static void destroy_range(T * ptr, uint32_t new_size, uint32_t old_size) {
+ for (uint32_t i = new_size; i < old_size; i++) {
+ (ptr+i)->~T(); // Explicit call to the destructor
+ }
+}
+
+/**
+* Replacement for std::vector that is easier to debug and provides
+* some nice foreach enumerators.
+*/
+template<typename T>
+class Array {
+public:
+ typedef uint32_t size_type;
+
+ Array(int memTag = MemTag::Default) : m_memTag(memTag), m_buffer(nullptr), m_capacity(0), m_size(0) {}
+
+ Array(const Array &a) : m_memTag(a.m_memTag), m_buffer(nullptr), m_capacity(0), m_size(0)
+ {
+ copy(a.m_buffer, a.m_size);
+ }
+
+ ~Array()
+ {
+ destroy();
+ }
+
+ const Array<T> &operator=(const Array<T> &other)
+ {
+ m_memTag = other.m_memTag;
+ m_buffer = other.m_buffer;
+ m_capacity = other.m_capacity;
+ m_size = other.m_size;
+ return *this;
+ }
+
+ const T & operator[]( uint32_t index ) const
+ {
+ XA_DEBUG_ASSERT(index < m_size);
+ return m_buffer[index];
+ }
+
+ T & operator[] ( uint32_t index )
+ {
+ XA_DEBUG_ASSERT(index < m_size);
+ return m_buffer[index];
+ }
+
+ uint32_t size() const { return m_size; }
+ const T * data() const { return m_buffer; }
+ T * data() { return m_buffer; }
+ T * begin() { return m_buffer; }
+ T * end() { return m_buffer + m_size; }
+ const T * begin() const { return m_buffer; }
+ const T * end() const { return m_buffer + m_size; }
+ bool isEmpty() const { return m_size == 0; }
+
+ void push_back( const T & val )
+ {
+ XA_DEBUG_ASSERT(&val < m_buffer || &val >= m_buffer+m_size);
+ uint32_t old_size = m_size;
+ uint32_t new_size = m_size + 1;
+ setArraySize(new_size);
+ construct_range(m_buffer, new_size, old_size, val);
+ }
+
+ void pop_back()
+ {
+ XA_DEBUG_ASSERT( m_size > 0 );
+ resize( m_size - 1 );
+ }
+
+ const T & back() const
+ {
+ XA_DEBUG_ASSERT( m_size > 0 );
+ return m_buffer[m_size-1];
+ }
+
+ T & back()
+ {
+ XA_DEBUG_ASSERT( m_size > 0 );
+ return m_buffer[m_size-1];
+ }
+
+ const T & front() const
+ {
+ XA_DEBUG_ASSERT( m_size > 0 );
+ return m_buffer[0];
+ }
+
+ T & front()
+ {
+ XA_DEBUG_ASSERT( m_size > 0 );
+ return m_buffer[0];
+ }
+
+ // Remove the element at the given index. This is an expensive operation!
+ void removeAt(uint32_t index)
+ {
+ XA_DEBUG_ASSERT(index >= 0 && index < m_size);
+ if (m_size == 1) {
+ clear();
+ }
+ else {
+ m_buffer[index].~T();
+ memmove(m_buffer+index, m_buffer+index+1, sizeof(T) * (m_size - 1 - index));
+ m_size--;
+ }
+ }
+
+ // Insert the given element at the given index shifting all the elements up.
+ void insertAt(uint32_t index, const T & val = T())
+ {
+ XA_DEBUG_ASSERT( index >= 0 && index <= m_size );
+ setArraySize(m_size + 1);
+ if (index < m_size - 1) {
+ memmove(m_buffer+index+1, m_buffer+index, sizeof(T) * (m_size - 1 - index));
+ }
+ // Copy-construct into the newly opened slot.
+ new(m_buffer+index) T(val);
+ }
+
+ void append(const Array<T> & other)
+ {
+ append(other.m_buffer, other.m_size);
+ }
+
+ void resize(uint32_t new_size)
+ {
+ uint32_t old_size = m_size;
+ // Destruct old elements (if we're shrinking).
+ destroy_range(m_buffer, new_size, old_size);
+ setArraySize(new_size);
+ // Call default constructors
+ construct_range(m_buffer, new_size, old_size);
+ }
+
+ void resize(uint32_t new_size, const T & elem)
+ {
+ XA_DEBUG_ASSERT(&elem < m_buffer || &elem > m_buffer+m_size);
+ uint32_t old_size = m_size;
+ // Destruct old elements (if we're shrinking).
+ destroy_range(m_buffer, new_size, old_size);
+ setArraySize(new_size);
+ // Call copy constructors
+ construct_range(m_buffer, new_size, old_size, elem);
+ }
+
+ void clear()
+ {
+ // Destruct old elements
+ destroy_range(m_buffer, 0, m_size);
+ m_size = 0;
+ }
+
+ void destroy()
+ {
+ clear();
+ XA_FREE(m_buffer);
+ m_buffer = nullptr;
+ m_capacity = 0;
+ m_size = 0;
+ }
+
+ void reserve(uint32_t desired_size)
+ {
+ if (desired_size > m_capacity) {
+ setArrayCapacity(desired_size);
+ }
+ }
+
+ void copy(const T * data, uint32_t count)
+ {
+ destroy_range(m_buffer, 0, m_size);
+ setArraySize(count);
+ construct_range(m_buffer, count, 0, data);
+ }
+
+ void moveTo(Array<T> &other)
+ {
+ other.destroy();
+ swap(m_buffer, other.m_buffer);
+ swap(m_capacity, other.m_capacity);
+ swap(m_size, other.m_size);
+ }
+
+protected:
+ void setArraySize(uint32_t new_size)
+ {
+ m_size = new_size;
+ if (new_size > m_capacity) {
+ uint32_t new_buffer_size;
+ if (m_capacity == 0) {
+ // first allocation is exact
+ new_buffer_size = new_size;
+ }
+ else {
+ // following allocations grow array by 25%
+ new_buffer_size = new_size + (new_size >> 2);
+ }
+ setArrayCapacity( new_buffer_size );
+ }
+ }
+ void setArrayCapacity(uint32_t new_capacity)
+ {
+ XA_DEBUG_ASSERT(new_capacity >= m_size);
+ if (new_capacity == 0) {
+ // free the buffer.
+ if (m_buffer != nullptr) {
+ XA_FREE(m_buffer);
+ m_buffer = nullptr;
+ }
+ }
+ else {
+ // realloc the buffer
+ m_buffer = XA_REALLOC(m_memTag, m_buffer, T, new_capacity);
+ }
+ m_capacity = new_capacity;
+ }
+
+ int m_memTag;
+ T * m_buffer;
+ uint32_t m_capacity;
+ uint32_t m_size;
+};
+
/// Basis class to compute tangent space basis, ortogonalizations and to
/// transform vectors from one space to another.
-class Basis
+struct Basis
{
-public:
- /// Create a null basis.
- Basis() : tangent(0, 0, 0), bitangent(0, 0, 0), normal(0, 0, 0) {}
-
- void buildFrameForDirection(Vector3::Arg d, float angle = 0)
+ void buildFrameForDirection(const Vector3 &d, float angle = 0)
{
- xaAssert(isNormalized(d));
+ XA_ASSERT(isNormalized(d));
normal = d;
// Choose minimum axis.
if (fabsf(normal.x) < fabsf(normal.y) && fabsf(normal.x) < fabsf(normal.z)) {
@@ -702,7 +1212,7 @@ public:
}
// Ortogonalize
tangent -= normal * dot(normal, tangent);
- tangent = normalize(tangent);
+ tangent = normalize(tangent, kEpsilon);
bitangent = cross(normal, tangent);
// Rotate frame around normal according to angle.
if (angle != 0.0f) {
@@ -714,9 +1224,9 @@ public:
}
}
- Vector3 tangent;
- Vector3 bitangent;
- Vector3 normal;
+ Vector3 tangent = Vector3(0.0f);
+ Vector3 bitangent = Vector3(0.0f);
+ Vector3 normal = Vector3(0.0f);
};
// Simple bit array.
@@ -724,21 +1234,12 @@ class BitArray
{
public:
BitArray() : m_size(0) {}
+
BitArray(uint32_t sz)
{
resize(sz);
}
- uint32_t size() const
- {
- return m_size;
- }
-
- void clear()
- {
- resize(0);
- }
-
void resize(uint32_t new_size)
{
m_size = new_size;
@@ -748,162 +1249,311 @@ public:
/// Get bit.
bool bitAt(uint32_t b) const
{
- xaDebugAssert( b < m_size );
+ XA_DEBUG_ASSERT( b < m_size );
return (m_wordArray[b >> 5] & (1 << (b & 31))) != 0;
}
// Set a bit.
void setBitAt(uint32_t idx)
{
- xaDebugAssert(idx < m_size);
+ XA_DEBUG_ASSERT(idx < m_size);
m_wordArray[idx >> 5] |= (1 << (idx & 31));
}
- // Toggle a bit.
- void toggleBitAt(uint32_t idx)
- {
- xaDebugAssert(idx < m_size);
- m_wordArray[idx >> 5] ^= (1 << (idx & 31));
- }
-
- // Set a bit to the given value. @@ Rename modifyBitAt?
- void setBitAt(uint32_t idx, bool b)
- {
- xaDebugAssert(idx < m_size);
- m_wordArray[idx >> 5] = setBits(m_wordArray[idx >> 5], 1 << (idx & 31), b);
- xaDebugAssert(bitAt(idx) == b);
- }
-
// Clear all the bits.
void clearAll()
{
- memset(m_wordArray.data(), 0, m_wordArray.size() * sizeof(uint32_t ));
- }
-
- // Set all the bits.
- void setAll()
- {
- memset(m_wordArray.data(), 0xFF, m_wordArray.size() * sizeof(uint32_t ));
+ memset(m_wordArray.data(), 0, m_wordArray.size() * sizeof(uint32_t));
}
private:
- // See "Conditionally set or clear bits without branching" at http://graphics.stanford.edu/~seander/bithacks.html
- uint32_t setBits(uint32_t w, uint32_t m, bool b)
- {
- return (w & ~m) | (-int(b) & m);
- }
-
// Number of bits stored.
uint32_t m_size;
// Array of bits.
- std::vector<uint32_t> m_wordArray;
+ Array<uint32_t> m_wordArray;
};
-/// Bit map. This should probably be called BitImage.
-class BitMap
+class BitImage
{
public:
- BitMap() : m_width(0), m_height(0) {}
- BitMap(uint32_t w, uint32_t h) : m_width(w), m_height(h), m_bitArray(w * h) {}
+ BitImage() : m_width(0), m_height(0), m_rowStride(0) {}
- uint32_t width() const
+ BitImage(uint32_t w, uint32_t h) : m_width(w), m_height(h)
{
- return m_width;
+ m_rowStride = (m_width + 63) >> 6;
+ m_data.resize(m_rowStride * m_height);
}
- uint32_t height() const
+
+ BitImage(const BitImage &other)
{
- return m_height;
+ m_width = other.m_width;
+ m_height = other.m_height;
+ m_rowStride = other.m_rowStride;
+ m_data.resize(m_rowStride * m_height);
+ memcpy(m_data.data(), other.m_data.data(), m_rowStride * m_height * sizeof(uint64_t));
}
- void resize(uint32_t w, uint32_t h, bool initValue)
+ const BitImage &operator=(const BitImage &other)
{
- BitArray tmp(w * h);
- if (initValue) tmp.setAll();
- else tmp.clearAll();
- // @@ Copying one bit at a time. This could be much faster.
- for (uint32_t y = 0; y < m_height; y++) {
- for (uint32_t x = 0; x < m_width; x++) {
- //tmp.setBitAt(y*w + x, bitAt(x, y));
- if (bitAt(x, y) != initValue) tmp.toggleBitAt(y * w + x);
- }
+ m_width = other.m_width;
+ m_height = other.m_height;
+ m_rowStride = other.m_rowStride;
+ m_data = other.m_data;
+ return *this;
+ }
+
+ uint32_t width() const { return m_width; }
+ uint32_t height() const { return m_height; }
+
+ void resize(uint32_t w, uint32_t h, bool discard)
+ {
+ const uint32_t rowStride = (w + 63) >> 6;
+ if (discard) {
+ m_data.resize(rowStride * h);
+ memset(m_data.data(), 0, m_data.size() * sizeof(uint64_t));
+ } else {
+ Array<uint64_t> tmp;
+ tmp.resize(rowStride * h);
+ memset(tmp.data(), 0, tmp.size() * sizeof(uint64_t));
+ // If only height has changed, can copy all rows at once.
+ if (rowStride == m_rowStride) {
+ memcpy(tmp.data(), m_data.data(), m_rowStride * min(m_height, h) * sizeof(uint64_t));
+ } else if (m_width > 0 && m_height > 0) {
+ const uint32_t height = min(m_height, h);
+ for (uint32_t i = 0; i < height; i++)
+ memcpy(&tmp[i * rowStride], &m_data[i * m_rowStride], min(rowStride, m_rowStride) * sizeof(uint64_t));
+ }
+ tmp.moveTo(m_data);
}
- std::swap(m_bitArray, tmp);
m_width = w;
m_height = h;
+ m_rowStride = rowStride;
}
bool bitAt(uint32_t x, uint32_t y) const
{
- xaDebugAssert(x < m_width && y < m_height);
- return m_bitArray.bitAt(y * m_width + x);
+ XA_DEBUG_ASSERT(x < m_width && y < m_height);
+ const uint32_t index = (x >> 6) + y * m_rowStride;
+ return (m_data[index] & (UINT64_C(1) << (uint64_t(x) & UINT64_C(63)))) != 0;
}
void setBitAt(uint32_t x, uint32_t y)
{
- xaDebugAssert(x < m_width && y < m_height);
- m_bitArray.setBitAt(y * m_width + x);
+ XA_DEBUG_ASSERT(x < m_width && y < m_height);
+ const uint32_t index = (x >> 6) + y * m_rowStride;
+ m_data[index] |= UINT64_C(1) << (uint64_t(x) & UINT64_C(63));
+ XA_DEBUG_ASSERT(bitAt(x, y));
}
void clearAll()
{
- m_bitArray.clearAll();
+ memset(m_data.data(), 0, m_data.size() * sizeof(uint64_t));
+ }
+
+ bool canBlit(const BitImage &image, uint32_t offsetX, uint32_t offsetY) const
+ {
+ for (uint32_t y = 0; y < image.m_height; y++) {
+ const uint32_t thisY = y + offsetY;
+ if (thisY >= m_height)
+ continue;
+ uint32_t x = 0;
+ for (;;) {
+ const uint32_t thisX = x + offsetX;
+ if (thisX >= m_width)
+ break;
+ const uint32_t thisBlockShift = thisX % 64;
+ const uint64_t thisBlock = m_data[(thisX >> 6) + thisY * m_rowStride] >> thisBlockShift;
+ const uint32_t blockShift = x % 64;
+ const uint64_t block = image.m_data[(x >> 6) + y * image.m_rowStride] >> blockShift;
+ if ((thisBlock & block) != 0)
+ return false;
+ x += 64 - max(thisBlockShift, blockShift);
+ if (x >= image.m_width)
+ break;
+ }
+ }
+ return true;
+ }
+
+ void dilate(uint32_t padding)
+ {
+ BitImage tmp(m_width, m_height);
+ for (uint32_t p = 0; p < padding; p++) {
+ tmp.clearAll();
+ for (uint32_t y = 0; y < m_height; y++) {
+ for (uint32_t x = 0; x < m_width; x++) {
+ bool b = bitAt(x, y);
+ if (!b) {
+ if (x > 0) {
+ b |= bitAt(x - 1, y);
+ if (y > 0) b |= bitAt(x - 1, y - 1);
+ if (y < m_height - 1) b |= bitAt(x - 1, y + 1);
+ }
+ if (y > 0) b |= bitAt(x, y - 1);
+ if (y < m_height - 1) b |= bitAt(x, y + 1);
+ if (x < m_width - 1) {
+ b |= bitAt(x + 1, y);
+ if (y > 0) b |= bitAt(x + 1, y - 1);
+ if (y < m_height - 1) b |= bitAt(x + 1, y + 1);
+ }
+ }
+ if (b)
+ tmp.setBitAt(x, y);
+ }
+ }
+ swap(m_data, tmp.m_data);
+ }
}
private:
uint32_t m_width;
uint32_t m_height;
- BitArray m_bitArray;
+ uint32_t m_rowStride; // In uint64_t's
+ Array<uint64_t> m_data;
};
-// Axis Aligned Bounding Box.
-class Box
+// From Fast-BVH
+class BVH
{
public:
- Box() {}
- Box(const Box &b) : minCorner(b.minCorner), maxCorner(b.maxCorner) {}
- Box(const Vector3 &mins, const Vector3 &maxs) : minCorner(mins), maxCorner(maxs) {}
-
- operator const float *() const
- {
- return reinterpret_cast<const float *>(this);
- }
-
- // Clear the bounds.
- void clearBounds()
- {
- minCorner.set(FLT_MAX, FLT_MAX, FLT_MAX);
- maxCorner.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
- }
-
- // Return extents of the box.
- Vector3 extents() const
+ BVH(const Array<AABB> &objectAabbs, uint32_t leafSize = 4)
{
- return (maxCorner - minCorner) * 0.5f;
+ m_objectAabbs = &objectAabbs;
+ if (m_objectAabbs->isEmpty())
+ return;
+ m_objectIds.resize(objectAabbs.size());
+ for (uint32_t i = 0; i < m_objectIds.size(); i++)
+ m_objectIds[i] = i;
+ BuildEntry todo[128];
+ uint32_t stackptr = 0;
+ const uint32_t kRoot = 0xfffffffc;
+ const uint32_t kUntouched = 0xffffffff;
+ const uint32_t kTouchedTwice = 0xfffffffd;
+ // Push the root
+ todo[stackptr].start = 0;
+ todo[stackptr].end = objectAabbs.size();
+ todo[stackptr].parent = kRoot;
+ stackptr++;
+ Node node;
+ m_nodes.reserve(objectAabbs.size() * 2);
+ uint32_t nNodes = 0;
+ while(stackptr > 0) {
+ // Pop the next item off of the stack
+ const BuildEntry &bnode = todo[--stackptr];
+ const uint32_t start = bnode.start;
+ const uint32_t end = bnode.end;
+ const uint32_t nPrims = end - start;
+ nNodes++;
+ node.start = start;
+ node.nPrims = nPrims;
+ node.rightOffset = kUntouched;
+ // Calculate the bounding box for this node
+ AABB bb(objectAabbs[m_objectIds[start]]);
+ AABB bc(objectAabbs[m_objectIds[start]].centroid());
+ for(uint32_t p = start + 1; p < end; ++p) {
+ bb.expandToInclude(objectAabbs[m_objectIds[p]]);
+ bc.expandToInclude(objectAabbs[m_objectIds[p]].centroid());
+ }
+ node.aabb = bb;
+ // If the number of primitives at this point is less than the leaf
+ // size, then this will become a leaf. (Signified by rightOffset == 0)
+ if (nPrims <= leafSize)
+ node.rightOffset = 0;
+ m_nodes.push_back(node);
+ // Child touches parent...
+ // Special case: Don't do this for the root.
+ if (bnode.parent != kRoot) {
+ m_nodes[bnode.parent].rightOffset--;
+ // When this is the second touch, this is the right child.
+ // The right child sets up the offset for the flat tree.
+ if (m_nodes[bnode.parent].rightOffset == kTouchedTwice )
+ m_nodes[bnode.parent].rightOffset = nNodes - 1 - bnode.parent;
+ }
+ // If this is a leaf, no need to subdivide.
+ if (node.rightOffset == 0)
+ continue;
+ // Set the split dimensions
+ const uint32_t split_dim = bc.maxDimension();
+ // Split on the center of the longest axis
+ const float split_coord = 0.5f * ((&bc.min.x)[split_dim] + (&bc.max.x)[split_dim]);
+ // Partition the list of objects on this split
+ uint32_t mid = start;
+ for (uint32_t i = start; i < end; ++i) {
+ const Vector3 centroid(objectAabbs[m_objectIds[i]].centroid());
+ if ((&centroid.x)[split_dim] < split_coord) {
+ swap(m_objectIds[i], m_objectIds[mid]);
+ ++mid;
+ }
+ }
+ // If we get a bad split, just choose the center...
+ if (mid == start || mid == end)
+ mid = start + (end - start) / 2;
+ // Push right child
+ todo[stackptr].start = mid;
+ todo[stackptr].end = end;
+ todo[stackptr].parent = nNodes - 1;
+ stackptr++;
+ // Push left child
+ todo[stackptr].start = start;
+ todo[stackptr].end = mid;
+ todo[stackptr].parent = nNodes - 1;
+ stackptr++;
+ }
+ }
+
+ void query(const AABB &queryAabb, Array<uint32_t> &result) const
+ {
+ result.clear();
+ // Working set
+ uint32_t todo[64];
+ int32_t stackptr = 0;
+ // "Push" on the root node to the working set
+ todo[stackptr] = 0;
+ while(stackptr >= 0) {
+ // Pop off the next node to work on.
+ const int ni = todo[stackptr--];
+ const Node &node = m_nodes[ni];
+ // Is leaf -> Intersect
+ if (node.rightOffset == 0) {
+ for(uint32_t o = 0; o < node.nPrims; ++o) {
+ const uint32_t obj = node.start + o;
+ if (queryAabb.intersect((*m_objectAabbs)[m_objectIds[obj]]))
+ result.push_back(m_objectIds[obj]);
+ }
+ } else { // Not a leaf
+ const uint32_t left = ni + 1;
+ const uint32_t right = ni + node.rightOffset;
+ if (queryAabb.intersect(m_nodes[left].aabb))
+ todo[++stackptr] = left;
+ if (queryAabb.intersect(m_nodes[right].aabb))
+ todo[++stackptr] = right;
+ }
+ }
}
- // Add a point to this box.
- void addPointToBounds(const Vector3 &p)
+private:
+ struct BuildEntry
{
- minCorner = min(minCorner, p);
- maxCorner = max(maxCorner, p);
- }
+ uint32_t parent; // If non-zero then this is the index of the parent. (used in offsets)
+ uint32_t start, end; // The range of objects in the object list covered by this node.
+ };
- // Get the volume of the box.
- float volume() const
+ struct Node
{
- Vector3 d = extents();
- return 8.0f * (d.x * d.y * d.z);
- }
+ AABB aabb;
+ uint32_t start, nPrims, rightOffset;
+ };
- Vector3 minCorner;
- Vector3 maxCorner;
+ const Array<AABB> *m_objectAabbs;
+ Array<uint32_t> m_objectIds;
+ Array<Node> m_nodes;
};
class Fit
{
public:
- static Vector3 computeCentroid(int n, const Vector3 *__restrict points)
+ static Vector3 computeCentroid(int n, const Vector3 * points)
{
Vector3 centroid(0.0f);
for (int i = 0; i < n; i++) {
@@ -913,7 +1563,7 @@ public:
return centroid;
}
- static Vector3 computeCovariance(int n, const Vector3 *__restrict points, float *__restrict covariance)
+ static Vector3 computeCovariance(int n, const Vector3 * points, float * covariance)
{
// compute the centroid
Vector3 centroid = computeCentroid(n, points);
@@ -933,25 +1583,12 @@ public:
return centroid;
}
- static bool isPlanar(int n, const Vector3 *points, float epsilon = NV_EPSILON)
- {
- // compute the centroid and covariance
- float matrix[6];
- computeCovariance(n, points, matrix);
- float eigenValues[3];
- Vector3 eigenVectors[3];
- if (!eigenSolveSymmetric3(matrix, eigenValues, eigenVectors)) {
- return false;
- }
- return eigenValues[2] < epsilon;
- }
-
// Tridiagonal solver from Charles Bloom.
// Householder transforms followed by QL decomposition.
// Seems to be based on the code from Numerical Recipes in C.
static bool eigenSolveSymmetric3(const float matrix[6], float eigenValues[3], Vector3 eigenVectors[3])
{
- xaDebugAssert(matrix != NULL && eigenValues != NULL && eigenVectors != NULL);
+ XA_DEBUG_ASSERT(matrix != nullptr && eigenValues != nullptr && eigenVectors != nullptr);
float subd[3];
float diag[3];
float work[3][3];
@@ -975,24 +1612,24 @@ public:
// eigenvectors are the columns; make them the rows :
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
- eigenVectors[j].component[i] = (float) work[i][j];
+ (&eigenVectors[j].x)[i] = (float) work[i][j];
}
}
// shuffle to sort by singular value :
if (eigenValues[2] > eigenValues[0] && eigenValues[2] > eigenValues[1]) {
- std::swap(eigenValues[0], eigenValues[2]);
- std::swap(eigenVectors[0], eigenVectors[2]);
+ swap(eigenValues[0], eigenValues[2]);
+ swap(eigenVectors[0], eigenVectors[2]);
}
if (eigenValues[1] > eigenValues[0]) {
- std::swap(eigenValues[0], eigenValues[1]);
- std::swap(eigenVectors[0], eigenVectors[1]);
+ swap(eigenValues[0], eigenValues[1]);
+ swap(eigenVectors[0], eigenVectors[1]);
}
if (eigenValues[2] > eigenValues[1]) {
- std::swap(eigenValues[1], eigenValues[2]);
- std::swap(eigenVectors[1], eigenVectors[2]);
+ swap(eigenValues[1], eigenValues[2]);
+ swap(eigenVectors[1], eigenVectors[2]);
}
- xaDebugAssert(eigenValues[0] >= eigenValues[1] && eigenValues[0] >= eigenValues[2]);
- xaDebugAssert(eigenValues[1] >= eigenValues[2]);
+ XA_DEBUG_ASSERT(eigenValues[0] >= eigenValues[1] && eigenValues[0] >= eigenValues[2]);
+ XA_DEBUG_ASSERT(eigenValues[1] >= eigenValues[2]);
return true;
}
@@ -1118,7 +1755,7 @@ public:
const FullVector &operator=(const FullVector &v)
{
- xaAssert(dimension() == v.dimension());
+ XA_ASSERT(dimension() == v.dimension());
m_array = v.m_array;
return *this;
}
@@ -1135,1698 +1772,1695 @@ public:
}
}
- void operator+=(const FullVector &v)
- {
- xaDebugAssert(dimension() == v.dimension());
- const uint32_t dim = dimension();
- for (uint32_t i = 0; i < dim; i++) {
- m_array[i] += v.m_array[i];
- }
- }
-
- void operator-=(const FullVector &v)
- {
- xaDebugAssert(dimension() == v.dimension());
- const uint32_t dim = dimension();
- for (uint32_t i = 0; i < dim; i++) {
- m_array[i] -= v.m_array[i];
- }
- }
-
- void operator*=(const FullVector &v)
- {
- xaDebugAssert(dimension() == v.dimension());
- const uint32_t dim = dimension();
- for (uint32_t i = 0; i < dim; i++) {
- m_array[i] *= v.m_array[i];
- }
- }
-
- void operator+=(float f)
- {
- const uint32_t dim = dimension();
- for (uint32_t i = 0; i < dim; i++) {
- m_array[i] += f;
- }
- }
-
- void operator-=(float f)
- {
- const uint32_t dim = dimension();
- for (uint32_t i = 0; i < dim; i++) {
- m_array[i] -= f;
- }
- }
-
- void operator*=(float f)
- {
- const uint32_t dim = dimension();
- for (uint32_t i = 0; i < dim; i++) {
- m_array[i] *= f;
- }
- }
-
private:
- std::vector<float> m_array;
+ Array<float> m_array;
};
-namespace halfedge {
-class Face;
-class Vertex;
-
-class Edge
+template<typename Key, typename Value, typename H = Hash<Key>, typename E = Equal<Key> >
+class HashMap
{
public:
- uint32_t id;
- Edge *next;
- Edge *prev; // This is not strictly half-edge, but makes algorithms easier and faster.
- Edge *pair;
- Vertex *vertex;
- Face *face;
-
- // Default constructor.
- Edge(uint32_t id) : id(id), next(NULL), prev(NULL), pair(NULL), vertex(NULL), face(NULL) {}
-
- // Vertex queries.
- const Vertex *from() const
+ HashMap(int memTag, uint32_t size) : m_memTag(memTag), m_size(size), m_numSlots(0), m_slots(nullptr), m_keys(memTag), m_values(memTag), m_next(memTag)
{
- return vertex;
}
- Vertex *from()
+ ~HashMap()
{
- return vertex;
+ if (m_slots)
+ XA_FREE(m_slots);
}
- const Vertex *to() const
- {
- return pair->vertex; // This used to be 'next->vertex', but that changed often when the connectivity of the mesh changes.
- }
+ const Value &value(uint32_t index) const { return m_values[index]; }
- Vertex *to()
+ void add(const Key &key, const Value &value)
{
- return pair->vertex;
+ if (!m_slots)
+ alloc();
+ const uint32_t hash = computeHash(key);
+ m_keys.push_back(key);
+ m_values.push_back(value);
+ m_next.push_back(m_slots[hash]);
+ m_slots[hash] = m_next.size() - 1;
}
- // Edge queries.
- void setNext(Edge *e)
- {
- next = e;
- if (e != NULL) e->prev = this;
- }
- void setPrev(Edge *e)
+ uint32_t get(const Key &key) const
{
- prev = e;
- if (e != NULL) e->next = this;
+ if (!m_slots)
+ return UINT32_MAX;
+ const uint32_t hash = computeHash(key);
+ uint32_t i = m_slots[hash];
+ E equal;
+ while (i != UINT32_MAX) {
+ if (equal(m_keys[i], key))
+ return i;
+ i = m_next[i];
+ }
+ return UINT32_MAX;
}
- // @@ It would be more simple to only check m_pair == NULL
- // Face queries.
- bool isBoundary() const
+ uint32_t getNext(uint32_t current) const
{
- return !(face && pair->face);
+ uint32_t i = m_next[current];
+ E equal;
+ while (i != UINT32_MAX) {
+ if (equal(m_keys[i], m_keys[current]))
+ return i;
+ i = m_next[i];
+ }
+ return UINT32_MAX;
}
- // @@ This is not exactly accurate, we should compare the texture coordinates...
- bool isSeam() const
+private:
+ void alloc()
{
- return vertex != pair->next->vertex || next->vertex != pair->vertex;
+ XA_DEBUG_ASSERT(m_size > 0);
+ m_numSlots = (uint32_t)(m_size * 1.3);
+ m_slots = XA_ALLOC_ARRAY(m_memTag, uint32_t, m_numSlots);
+ for (uint32_t i = 0; i < m_numSlots; i++)
+ m_slots[i] = UINT32_MAX;
+ m_keys.reserve(m_size);
+ m_values.reserve(m_size);
+ m_next.reserve(m_size);
}
- bool isNormalSeam() const;
- bool isTextureSeam() const;
-
- bool isValid() const
+ uint32_t computeHash(const Key &key) const
{
- // null face is OK.
- if (next == NULL || prev == NULL || pair == NULL || vertex == NULL) return false;
- if (next->prev != this) return false;
- if (prev->next != this) return false;
- if (pair->pair != this) return false;
- return true;
+ H hash;
+ return hash(key) % m_numSlots;
}
- float length() const;
-
- // Return angle between this edge and the previous one.
- float angle() const;
+ int m_memTag;
+ uint32_t m_size;
+ uint32_t m_numSlots;
+ uint32_t *m_slots;
+ Array<Key> m_keys;
+ Array<Value> m_values;
+ Array<uint32_t> m_next;
};
-class Vertex
+template<typename T>
+static void insertionSort(T *data, uint32_t length)
{
-public:
- uint32_t id;
- // -- GODOT start --
- uint32_t original_id;
- // -- GODOT end --
- Edge *edge;
- Vertex *next;
- Vertex *prev;
- Vector3 pos;
- Vector3 nor;
- Vector2 tex;
-
- // -- GODOT start --
- //Vertex(uint32_t id) : id(id), edge(NULL), pos(0.0f), nor(0.0f), tex(0.0f)
- Vertex(uint32_t id) : id(id), original_id(id), edge(NULL), pos(0.0f), nor(0.0f), tex(0.0f)
- // -- GODOT end --
- {
- next = this;
- prev = this;
- }
-
- // Set first edge of all colocals.
- void setEdge(Edge *e)
- {
- for (VertexIterator it(colocals()); !it.isDone(); it.advance()) {
- it.current()->edge = e;
+ for (int32_t i = 1; i < (int32_t)length; i++) {
+ T x = data[i];
+ int32_t j = i - 1;
+ while (j >= 0 && x < data[j]) {
+ data[j + 1] = data[j];
+ j--;
}
+ data[j + 1] = x;
}
+}
- // Update position of all colocals.
- void setPos(const Vector3 &p)
+class KISSRng
+{
+public:
+ uint32_t getRange(uint32_t range)
{
- for (VertexIterator it(colocals()); !it.isDone(); it.advance()) {
- it.current()->pos = p;
- }
+ if (range == 0)
+ return 0;
+ x = 69069 * x + 12345;
+ y ^= (y << 13);
+ y ^= (y >> 17);
+ y ^= (y << 5);
+ uint64_t t = 698769069ULL * z + c;
+ c = (t >> 32);
+ return (x + y + (z = (uint32_t)t)) % range;
}
- bool isFirstColocal() const
- {
- return firstColocal() == this;
- }
+private:
+ uint32_t x = 123456789, y = 362436000, z = 521288629, c = 7654321;
+};
+
+// Based on Pierre Terdiman's and Michael Herf's source code.
+// http://www.codercorner.com/RadixSortRevisited.htm
+// http://www.stereopsis.com/radix.html
+class RadixSort
+{
+public:
+ RadixSort() : m_size(0), m_ranks(nullptr), m_ranks2(nullptr), m_validRanks(false) {}
- const Vertex *firstColocal() const
+ ~RadixSort()
{
- uint32_t firstId = id;
- const Vertex *vertex = this;
- for (ConstVertexIterator it(colocals()); !it.isDone(); it.advance()) {
- if (it.current()->id < firstId) {
- firstId = vertex->id;
- vertex = it.current();
- }
- }
- return vertex;
+ // Release everything
+ XA_FREE(m_ranks2);
+ XA_FREE(m_ranks);
}
- Vertex *firstColocal()
+ RadixSort &sort(const float *input, uint32_t count)
{
- Vertex *vertex = this;
- uint32_t firstId = id;
- for (VertexIterator it(colocals()); !it.isDone(); it.advance()) {
- if (it.current()->id < firstId) {
- firstId = vertex->id;
- vertex = it.current();
+ if (input == nullptr || count == 0) return *this;
+ // Resize lists if needed
+ if (count != m_size) {
+ if (count > m_size) {
+ m_ranks2 = XA_REALLOC(MemTag::Default, m_ranks2, uint32_t, count);
+ m_ranks = XA_REALLOC(MemTag::Default, m_ranks, uint32_t, count);
}
+ m_size = count;
+ m_validRanks = false;
}
- return vertex;
- }
-
- bool isColocal(const Vertex *v) const
- {
- if (this == v) return true;
- if (pos != v->pos) return false;
- for (ConstVertexIterator it(colocals()); !it.isDone(); it.advance()) {
- if (v == it.current()) {
- return true;
+ if (count < 32) {
+ insertionSort(input, count);
+ } else {
+ // @@ Avoid touching the input multiple times.
+ for (uint32_t i = 0; i < count; i++) {
+ FloatFlip((uint32_t &)input[i]);
+ }
+ radixSort<uint32_t>((const uint32_t *)input, count);
+ for (uint32_t i = 0; i < count; i++) {
+ IFloatFlip((uint32_t &)input[i]);
}
}
- return false;
+ return *this;
}
- void linkColocal(Vertex *v)
- {
- next->prev = v;
- v->next = next;
- next = v;
- v->prev = this;
- }
- void unlinkColocal()
+ RadixSort &sort(const Array<float> &input)
{
- next->prev = prev;
- prev->next = next;
- next = this;
- prev = this;
+ return sort(input.data(), input.size());
}
- // @@ Note: This only works if linkBoundary has been called.
- bool isBoundary() const
+ // Access to results. m_ranks is a list of indices in sorted order, i.e. in the order you may further process your data
+ const uint32_t *ranks() const
{
- return (edge && !edge->face);
+ XA_DEBUG_ASSERT(m_validRanks);
+ return m_ranks;
}
- // Iterator that visits the edges around this vertex in counterclockwise order.
- class EdgeIterator //: public Iterator<Edge *>
+ uint32_t *ranks()
{
- public:
- EdgeIterator(Edge *e) : m_end(NULL), m_current(e) { }
-
- virtual void advance()
- {
- if (m_end == NULL) m_end = m_current;
- m_current = m_current->pair->next;
- //m_current = m_current->prev->pair;
- }
-
- virtual bool isDone() const
- {
- return m_end == m_current;
- }
- virtual Edge *current() const
- {
- return m_current;
- }
- Vertex *vertex() const
- {
- return m_current->vertex;
- }
+ XA_DEBUG_ASSERT(m_validRanks);
+ return m_ranks;
+ }
- private:
- Edge *m_end;
- Edge *m_current;
- };
+private:
+ uint32_t m_size;
+ uint32_t *m_ranks;
+ uint32_t *m_ranks2;
+ bool m_validRanks;
- EdgeIterator edges()
+ void FloatFlip(uint32_t &f)
{
- return EdgeIterator(edge);
+ int32_t mask = (int32_t(f) >> 31) | 0x80000000; // Warren Hunt, Manchor Ko.
+ f ^= mask;
}
- EdgeIterator edges(Edge *e)
+
+ void IFloatFlip(uint32_t &f)
{
- return EdgeIterator(e);
+ uint32_t mask = ((f >> 31) - 1) | 0x80000000; // Michael Herf.
+ f ^= mask;
}
- // Iterator that visits the edges around this vertex in counterclockwise order.
- class ConstEdgeIterator //: public Iterator<Edge *>
+ template<typename T>
+ void createHistograms(const T *buffer, uint32_t count, uint32_t *histogram)
{
- public:
- ConstEdgeIterator(const Edge *e) : m_end(NULL), m_current(e) { }
- ConstEdgeIterator(EdgeIterator it) : m_end(NULL), m_current(it.current()) { }
-
- virtual void advance()
- {
- if (m_end == NULL) m_end = m_current;
- m_current = m_current->pair->next;
- //m_current = m_current->prev->pair;
- }
-
- virtual bool isDone() const
- {
- return m_end == m_current;
- }
- virtual const Edge *current() const
- {
- return m_current;
+ const uint32_t bucketCount = sizeof(T); // (8 * sizeof(T)) / log2(radix)
+ // Init bucket pointers.
+ uint32_t *h[bucketCount];
+ for (uint32_t i = 0; i < bucketCount; i++) {
+ h[i] = histogram + 256 * i;
}
- const Vertex *vertex() const
- {
- return m_current->to();
+ // Clear histograms.
+ memset(histogram, 0, 256 * bucketCount * sizeof(uint32_t ));
+ // @@ Add support for signed integers.
+ // Build histograms.
+ const uint8_t *p = (const uint8_t *)buffer; // @@ Does this break aliasing rules?
+ const uint8_t *pe = p + count * sizeof(T);
+ while (p != pe) {
+ h[0][*p++]++, h[1][*p++]++, h[2][*p++]++, h[3][*p++]++;
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+ if (bucketCount == 8) h[4][*p++]++, h[5][*p++]++, h[6][*p++]++, h[7][*p++]++;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
}
-
- private:
- const Edge *m_end;
- const Edge *m_current;
- };
-
- ConstEdgeIterator edges() const
- {
- return ConstEdgeIterator(edge);
- }
- ConstEdgeIterator edges(const Edge *e) const
- {
- return ConstEdgeIterator(e);
}
- // Iterator that visits all the colocal vertices.
- class VertexIterator //: public Iterator<Edge *>
+ template <typename T> void insertionSort(const T *input, uint32_t count)
{
- public:
- VertexIterator(Vertex *v) : m_end(NULL), m_current(v) { }
-
- virtual void advance()
- {
- if (m_end == NULL) m_end = m_current;
- m_current = m_current->next;
- }
-
- virtual bool isDone() const
- {
- return m_end == m_current;
- }
- virtual Vertex *current() const
- {
- return m_current;
+ if (!m_validRanks) {
+ m_ranks[0] = 0;
+ for (uint32_t i = 1; i != count; ++i) {
+ int rank = m_ranks[i] = i;
+ uint32_t j = i;
+ while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
+ m_ranks[j] = m_ranks[j - 1];
+ --j;
+ }
+ if (i != j) {
+ m_ranks[j] = rank;
+ }
+ }
+ m_validRanks = true;
+ } else {
+ for (uint32_t i = 1; i != count; ++i) {
+ int rank = m_ranks[i];
+ uint32_t j = i;
+ while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
+ m_ranks[j] = m_ranks[j - 1];
+ --j;
+ }
+ if (i != j) {
+ m_ranks[j] = rank;
+ }
+ }
}
-
- private:
- Vertex *m_end;
- Vertex *m_current;
- };
-
- VertexIterator colocals()
- {
- return VertexIterator(this);
}
- // Iterator that visits all the colocal vertices.
- class ConstVertexIterator //: public Iterator<Edge *>
+ template <typename T> void radixSort(const T *input, uint32_t count)
{
- public:
- ConstVertexIterator(const Vertex *v) : m_end(NULL), m_current(v) { }
-
- virtual void advance()
- {
- if (m_end == NULL) m_end = m_current;
- m_current = m_current->next;
- }
-
- virtual bool isDone() const
- {
- return m_end == m_current;
+ const uint32_t P = sizeof(T); // pass count
+ // Allocate histograms & offsets on the stack
+ uint32_t histogram[256 * P];
+ uint32_t *link[256];
+ createHistograms(input, count, histogram);
+ // Radix sort, j is the pass number (0=LSB, P=MSB)
+ for (uint32_t j = 0; j < P; j++) {
+ // Pointer to this bucket.
+ const uint32_t *h = &histogram[j * 256];
+ const uint8_t *inputBytes = (const uint8_t *)input; // @@ Is this aliasing legal?
+ inputBytes += j;
+ if (h[inputBytes[0]] == count) {
+ // Skip this pass, all values are the same.
+ continue;
+ }
+ // Create offsets
+ link[0] = m_ranks2;
+ for (uint32_t i = 1; i < 256; i++) link[i] = link[i - 1] + h[i - 1];
+ // Perform Radix Sort
+ if (!m_validRanks) {
+ for (uint32_t i = 0; i < count; i++) {
+ *link[inputBytes[i * P]]++ = i;
+ }
+ m_validRanks = true;
+ } else {
+ for (uint32_t i = 0; i < count; i++) {
+ const uint32_t idx = m_ranks[i];
+ *link[inputBytes[idx * P]]++ = idx;
+ }
+ }
+ // Swap pointers for next pass. Valid indices - the most recent ones - are in m_ranks after the swap.
+ swap(m_ranks, m_ranks2);
}
- virtual const Vertex *current() const
- {
- return m_current;
+ // All values were equal, generate linear ranks.
+ if (!m_validRanks) {
+ for (uint32_t i = 0; i < count; i++) {
+ m_ranks[i] = i;
+ }
+ m_validRanks = true;
}
-
- private:
- const Vertex *m_end;
- const Vertex *m_current;
- };
-
- ConstVertexIterator colocals() const
- {
- return ConstVertexIterator(this);
}
};
-bool Edge::isNormalSeam() const
-{
- return (vertex->nor != pair->next->vertex->nor || next->vertex->nor != pair->vertex->nor);
-}
-
-bool Edge::isTextureSeam() const
-{
- return (vertex->tex != pair->next->vertex->tex || next->vertex->tex != pair->vertex->tex);
-}
-
-float Edge::length() const
-{
- return internal::length(to()->pos - from()->pos);
-}
-
-float Edge::angle() const
-{
- Vector3 p = vertex->pos;
- Vector3 a = prev->vertex->pos;
- Vector3 b = next->vertex->pos;
- Vector3 v0 = a - p;
- Vector3 v1 = b - p;
- return acosf(dot(v0, v1) / (internal::length(v0) * internal::length(v1)));
-}
-
-class Face
+// Wrapping this in a class allows temporary arrays to be re-used.
+class BoundingBox2D
{
public:
- uint32_t id;
- uint16_t group;
- uint16_t material;
- Edge *edge;
-
- Face(uint32_t id) : id(id), group(uint16_t(~0)), material(uint16_t(~0)), edge(NULL) {}
+ Vector2 majorAxis() const { return m_majorAxis; }
+ Vector2 minorAxis() const { return m_minorAxis; }
+ Vector2 minCorner() const { return m_minCorner; }
+ Vector2 maxCorner() const { return m_maxCorner; }
- float area() const
- {
- float area = 0;
- const Vector3 &v0 = edge->from()->pos;
- for (ConstEdgeIterator it(edges(edge->next)); it.current() != edge->prev; it.advance()) {
- const Edge *e = it.current();
- const Vector3 &v1 = e->vertex->pos;
- const Vector3 &v2 = e->next->vertex->pos;
- area += length(cross(v1 - v0, v2 - v0));
- }
- return area * 0.5f;
- }
-
- float parametricArea() const
- {
- float area = 0;
- const Vector2 &v0 = edge->from()->tex;
- for (ConstEdgeIterator it(edges(edge->next)); it.current() != edge->prev; it.advance()) {
- const Edge *e = it.current();
- const Vector2 &v1 = e->vertex->tex;
- const Vector2 &v2 = e->next->vertex->tex;
- area += triangleArea(v0, v1, v2);
- }
- return area * 0.5f;
- }
-
- Vector3 normal() const
+ // This should compute convex hull and use rotating calipers to find the best box. Currently it uses a brute force method.
+ void compute(const Vector2 *boundaryVertices, uint32_t boundaryVertexCount, const Vector2 *vertices, uint32_t vertexCount)
{
- Vector3 n(0);
- const Vertex *vertex0 = NULL;
- for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
- const Edge *e = it.current();
- xaAssert(e != NULL);
- if (vertex0 == NULL) {
- vertex0 = e->vertex;
- } else if (e->next->vertex != vertex0) {
- const halfedge::Vertex *vertex1 = e->from();
- const halfedge::Vertex *vertex2 = e->to();
- const Vector3 &p0 = vertex0->pos;
- const Vector3 &p1 = vertex1->pos;
- const Vector3 &p2 = vertex2->pos;
- Vector3 v10 = p1 - p0;
- Vector3 v20 = p2 - p0;
- n += cross(v10, v20);
+ convexHull(boundaryVertices, boundaryVertexCount, m_hull, 0.00001f);
+ // @@ Ideally I should use rotating calipers to find the best box. Using brute force for now.
+ float best_area = FLT_MAX;
+ Vector2 best_min(0);
+ Vector2 best_max(0);
+ Vector2 best_axis(0);
+ const uint32_t hullCount = m_hull.size();
+ for (uint32_t i = 0, j = hullCount - 1; i < hullCount; j = i, i++) {
+ if (equal(m_hull[i], m_hull[j], kEpsilon))
+ continue;
+ Vector2 axis = normalize(m_hull[i] - m_hull[j], 0.0f);
+ XA_DEBUG_ASSERT(isFinite(axis));
+ // Compute bounding box.
+ Vector2 box_min(FLT_MAX, FLT_MAX);
+ Vector2 box_max(-FLT_MAX, -FLT_MAX);
+ // Consider all points, not only boundary points, in case the input chart is malformed.
+ for (uint32_t v = 0; v < vertexCount; v++) {
+ const Vector2 &point = vertices[v];
+ const float x = dot(axis, point);
+ const float y = dot(Vector2(-axis.y, axis.x), point);
+ box_min.x = min(box_min.x, x);
+ box_max.x = max(box_max.x, x);
+ box_min.y = min(box_min.y, y);
+ box_max.y = max(box_max.y, y);
+ }
+ // Compute box area.
+ const float area = (box_max.x - box_min.x) * (box_max.y - box_min.y);
+ if (area < best_area) {
+ best_area = area;
+ best_min = box_min;
+ best_max = box_max;
+ best_axis = axis;
}
}
- return normalizeSafe(n, Vector3(0, 0, 1), 0.0f);
- }
-
- Vector3 centroid() const
- {
- Vector3 sum(0.0f);
- uint32_t count = 0;
- for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
- const Edge *e = it.current();
- sum += e->from()->pos;
- count++;
- }
- return sum / float(count);
- }
-
- // Unnormalized face normal assuming it's a triangle.
- Vector3 triangleNormal() const
- {
- Vector3 p0 = edge->vertex->pos;
- Vector3 p1 = edge->next->vertex->pos;
- Vector3 p2 = edge->next->next->vertex->pos;
- Vector3 e0 = p2 - p0;
- Vector3 e1 = p1 - p0;
- return normalizeSafe(cross(e0, e1), Vector3(0), 0.0f);
- }
-
- Vector3 triangleNormalAreaScaled() const
- {
- Vector3 p0 = edge->vertex->pos;
- Vector3 p1 = edge->next->vertex->pos;
- Vector3 p2 = edge->next->next->vertex->pos;
- Vector3 e0 = p2 - p0;
- Vector3 e1 = p1 - p0;
- return cross(e0, e1);
- }
-
- // Average of the edge midpoints weighted by the edge length.
- // I want a point inside the triangle, but closer to the cirumcenter.
- Vector3 triangleCenter() const
- {
- Vector3 p0 = edge->vertex->pos;
- Vector3 p1 = edge->next->vertex->pos;
- Vector3 p2 = edge->next->next->vertex->pos;
- float l0 = length(p1 - p0);
- float l1 = length(p2 - p1);
- float l2 = length(p0 - p2);
- Vector3 m0 = (p0 + p1) * l0 / (l0 + l1 + l2);
- Vector3 m1 = (p1 + p2) * l1 / (l0 + l1 + l2);
- Vector3 m2 = (p2 + p0) * l2 / (l0 + l1 + l2);
- return m0 + m1 + m2;
- }
-
- bool isValid() const
- {
- uint32_t count = 0;
- for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
- const Edge *e = it.current();
- if (e->face != this) return false;
- if (!e->isValid()) return false;
- if (!e->pair->isValid()) return false;
- count++;
- }
- if (count < 3) return false;
- return true;
- }
-
- bool contains(const Edge *e) const
- {
- for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
- if (it.current() == e) return true;
- }
- return false;
- }
-
- uint32_t edgeCount() const
- {
- uint32_t count = 0;
- for (ConstEdgeIterator it(edges()); !it.isDone(); it.advance()) {
- ++count;
- }
- return count;
+ m_majorAxis = best_axis;
+ m_minorAxis = Vector2(-best_axis.y, best_axis.x);
+ m_minCorner = best_min;
+ m_maxCorner = best_max;
+ XA_ASSERT(isFinite(m_majorAxis) && isFinite(m_minorAxis) && isFinite(m_minCorner));
}
- // The iterator that visits the edges of this face in clockwise order.
- class EdgeIterator //: public Iterator<Edge *>
+private:
+ // Compute the convex hull using Graham Scan.
+ void convexHull(const Vector2 *input, uint32_t inputCount, Array<Vector2> &output, float epsilon)
{
- public:
- EdgeIterator(Edge *e) : m_end(NULL), m_current(e) { }
-
- virtual void advance()
- {
- if (m_end == NULL) m_end = m_current;
- m_current = m_current->next;
+ m_coords.resize(inputCount);
+ for (uint32_t i = 0; i < inputCount; i++)
+ m_coords[i] = input[i].x;
+ RadixSort radix;
+ radix.sort(m_coords);
+ const uint32_t *ranks = radix.ranks();
+ m_top.clear();
+ m_bottom.clear();
+ m_top.reserve(inputCount);
+ m_bottom.reserve(inputCount);
+ Vector2 P = input[ranks[0]];
+ Vector2 Q = input[ranks[inputCount - 1]];
+ float topy = max(P.y, Q.y);
+ float boty = min(P.y, Q.y);
+ for (uint32_t i = 0; i < inputCount; i++) {
+ Vector2 p = input[ranks[i]];
+ if (p.y >= boty)
+ m_top.push_back(p);
}
-
- virtual bool isDone() const
- {
- return m_end == m_current;
+ for (uint32_t i = 0; i < inputCount; i++) {
+ Vector2 p = input[ranks[inputCount - 1 - i]];
+ if (p.y <= topy)
+ m_bottom.push_back(p);
}
- virtual Edge *current() const
- {
- return m_current;
+ // Filter top list.
+ output.clear();
+ output.push_back(m_top[0]);
+ output.push_back(m_top[1]);
+ for (uint32_t i = 2; i < m_top.size(); ) {
+ Vector2 a = output[output.size() - 2];
+ Vector2 b = output[output.size() - 1];
+ Vector2 c = m_top[i];
+ float area = triangleArea(a, b, c);
+ if (area >= -epsilon)
+ output.pop_back();
+ if (area < -epsilon || output.size() == 1) {
+ output.push_back(c);
+ i++;
+ }
}
- Vertex *vertex() const
- {
- return m_current->vertex;
+ uint32_t top_count = output.size();
+ output.push_back(m_bottom[1]);
+ // Filter bottom list.
+ for (uint32_t i = 2; i < m_bottom.size(); ) {
+ Vector2 a = output[output.size() - 2];
+ Vector2 b = output[output.size() - 1];
+ Vector2 c = m_bottom[i];
+ float area = triangleArea(a, b, c);
+ if (area >= -epsilon)
+ output.pop_back();
+ if (area < -epsilon || output.size() == top_count) {
+ output.push_back(c);
+ i++;
+ }
}
-
- private:
- Edge *m_end;
- Edge *m_current;
- };
-
- EdgeIterator edges()
- {
- return EdgeIterator(edge);
- }
- EdgeIterator edges(Edge *e)
- {
- xaDebugAssert(contains(e));
- return EdgeIterator(e);
+ // Remove duplicate element.
+ XA_DEBUG_ASSERT(output.front() == output.back());
+ output.pop_back();
}
- // The iterator that visits the edges of this face in clockwise order.
- class ConstEdgeIterator //: public Iterator<const Edge *>
- {
- public:
- ConstEdgeIterator(const Edge *e) : m_end(NULL), m_current(e) { }
- ConstEdgeIterator(const EdgeIterator &it) : m_end(NULL), m_current(it.current()) { }
+ Array<float> m_coords;
+ Array<Vector2> m_top, m_bottom, m_hull;
+ Vector2 m_majorAxis, m_minorAxis, m_minCorner, m_maxCorner;
+};
- virtual void advance()
- {
- if (m_end == NULL) m_end = m_current;
- m_current = m_current->next;
- }
+static uint32_t meshEdgeFace(uint32_t edge) { return edge / 3; }
+static uint32_t meshEdgeIndex0(uint32_t edge) { return edge; }
- virtual bool isDone() const
- {
- return m_end == m_current;
- }
- virtual const Edge *current() const
- {
- return m_current;
- }
- const Vertex *vertex() const
- {
- return m_current->vertex;
- }
-
- private:
- const Edge *m_end;
- const Edge *m_current;
- };
+static uint32_t meshEdgeIndex1(uint32_t edge)
+{
+ const uint32_t faceFirstEdge = edge / 3 * 3;
+ return faceFirstEdge + (edge - faceFirstEdge + 1) % 3;
+}
- ConstEdgeIterator edges() const
- {
- return ConstEdgeIterator(edge);
- }
- ConstEdgeIterator edges(const Edge *e) const
+struct MeshFlags
+{
+ enum
{
- xaDebugAssert(contains(e));
- return ConstEdgeIterator(e);
- }
+ HasFaceGroups = 1<<0,
+ HasIgnoredFaces = 1<<1,
+ HasNormals = 1<<2
+ };
};
-/// Simple half edge mesh designed for dynamic mesh manipulation.
+class Mesh;
+static void meshGetBoundaryLoops(const Mesh &mesh, Array<uint32_t> &boundaryLoops);
+
class Mesh
{
public:
- Mesh() : m_colocalVertexCount(0) {}
-
- Mesh(const Mesh *mesh)
- {
- // Copy mesh vertices.
- const uint32_t vertexCount = mesh->vertexCount();
- m_vertexArray.resize(vertexCount);
- for (uint32_t v = 0; v < vertexCount; v++) {
- const Vertex *vertex = mesh->vertexAt(v);
- xaDebugAssert(vertex->id == v);
- m_vertexArray[v] = new Vertex(v);
- m_vertexArray[v]->pos = vertex->pos;
- m_vertexArray[v]->nor = vertex->nor;
- m_vertexArray[v]->tex = vertex->tex;
- }
- m_colocalVertexCount = vertexCount;
- // Copy mesh faces.
- const uint32_t faceCount = mesh->faceCount();
- std::vector<uint32_t> indexArray;
- indexArray.reserve(3);
- for (uint32_t f = 0; f < faceCount; f++) {
- const Face *face = mesh->faceAt(f);
- for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const Vertex *vertex = it.current()->from();
- indexArray.push_back(vertex->id);
- }
- addFace(indexArray);
- indexArray.clear();
- }
- }
-
- ~Mesh()
+ Mesh(float epsilon, uint32_t approxVertexCount, uint32_t approxFaceCount, uint32_t flags = 0, uint32_t id = UINT32_MAX) : m_epsilon(epsilon), m_flags(flags), m_id(id), m_faceIgnore(MemTag::Mesh), m_faceGroups(MemTag::Mesh), m_indices(MemTag::MeshIndices), m_positions(MemTag::MeshPositions), m_normals(MemTag::MeshNormals), m_texcoords(MemTag::MeshTexcoords), m_colocalVertexCount(0), m_nextColocalVertex(MemTag::MeshColocals), m_boundaryVertices(MemTag::MeshBoundaries), m_oppositeEdges(MemTag::MeshBoundaries), m_nextBoundaryEdges(MemTag::MeshBoundaries), m_edgeMap(MemTag::MeshEdgeMap, approxFaceCount * 3)
{
- clear();
+ m_indices.reserve(approxFaceCount * 3);
+ m_positions.reserve(approxVertexCount);
+ m_texcoords.reserve(approxVertexCount);
+ if (m_flags & MeshFlags::HasFaceGroups)
+ m_faceGroups.reserve(approxFaceCount);
+ if (m_flags & MeshFlags::HasIgnoredFaces)
+ m_faceIgnore.reserve(approxFaceCount);
+ if (m_flags & MeshFlags::HasNormals)
+ m_normals.reserve(approxVertexCount);
}
- void clear()
- {
- for (size_t i = 0; i < m_vertexArray.size(); i++)
- delete m_vertexArray[i];
- m_vertexArray.clear();
- for (auto it = m_edgeMap.begin(); it != m_edgeMap.end(); it++)
- delete it->second;
- m_edgeArray.clear();
- m_edgeMap.clear();
- for (size_t i = 0; i < m_faceArray.size(); i++)
- delete m_faceArray[i];
- m_faceArray.clear();
- }
+ uint32_t flags() const { return m_flags; }
+ uint32_t id() const { return m_id; }
- Vertex *addVertex(const Vector3 &pos)
+ void addVertex(const Vector3 &pos, const Vector3 &normal = Vector3(0.0f), const Vector2 &texcoord = Vector2(0.0f))
{
- xaDebugAssert(isFinite(pos));
- Vertex *v = new Vertex(m_vertexArray.size());
- v->pos = pos;
- m_vertexArray.push_back(v);
- return v;
- }
-
- /// Link colocal vertices based on geometric location only.
- void linkColocals()
- {
- xaPrint("--- Linking colocals:\n");
- const uint32_t vertexCount = this->vertexCount();
- std::unordered_map<Vector3, Vertex *, Hash<Vector3>, Equal<Vector3> > vertexMap;
- vertexMap.reserve(vertexCount);
- for (uint32_t v = 0; v < vertexCount; v++) {
- Vertex *vertex = vertexAt(v);
- Vertex *colocal = vertexMap[vertex->pos];
- if (colocal) {
- colocal->linkColocal(vertex);
- } else {
- vertexMap[vertex->pos] = vertex;
- }
- }
- m_colocalVertexCount = vertexMap.size();
- xaPrint("--- %d vertex positions.\n", m_colocalVertexCount);
- // @@ Remove duplicated vertices? or just leave them as colocals?
+ XA_DEBUG_ASSERT(isFinite(pos));
+ m_positions.push_back(pos);
+ if (m_flags & MeshFlags::HasNormals)
+ m_normals.push_back(normal);
+ m_texcoords.push_back(texcoord);
}
- void linkColocalsWithCanonicalMap(const std::vector<uint32_t> &canonicalMap)
+ struct AddFaceResult
{
- xaPrint("--- Linking colocals:\n");
- uint32_t vertexMapSize = 0;
- for (uint32_t i = 0; i < canonicalMap.size(); i++) {
- vertexMapSize = std::max(vertexMapSize, canonicalMap[i] + 1);
- }
- std::vector<Vertex *> vertexMap;
- vertexMap.resize(vertexMapSize, NULL);
- m_colocalVertexCount = 0;
- const uint32_t vertexCount = this->vertexCount();
- for (uint32_t v = 0; v < vertexCount; v++) {
- Vertex *vertex = vertexAt(v);
- Vertex *colocal = vertexMap[canonicalMap[v]];
- if (colocal != NULL) {
- xaDebugAssert(vertex->pos == colocal->pos);
- colocal->linkColocal(vertex);
- } else {
- vertexMap[canonicalMap[v]] = vertex;
- m_colocalVertexCount++;
- }
- }
- xaPrint("--- %d vertex positions.\n", m_colocalVertexCount);
- }
-
- Face *addFace()
- {
- Face *f = new Face(m_faceArray.size());
- m_faceArray.push_back(f);
- return f;
- }
+ enum Enum
+ {
+ OK,
+ DuplicateEdge = 1
+ };
+ };
- Face *addFace(uint32_t v0, uint32_t v1, uint32_t v2)
+ AddFaceResult::Enum addFace(uint32_t v0, uint32_t v1, uint32_t v2, bool ignore = false, bool hashEdge = true)
{
uint32_t indexArray[3];
indexArray[0] = v0;
indexArray[1] = v1;
indexArray[2] = v2;
- return addFace(indexArray, 3, 0, 3);
- }
-
- Face *addFace(uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3)
- {
- uint32_t indexArray[4];
- indexArray[0] = v0;
- indexArray[1] = v1;
- indexArray[2] = v2;
- indexArray[3] = v3;
- return addFace(indexArray, 4, 0, 4);
+ return addFace(indexArray, ignore, hashEdge);
}
- Face *addFace(const std::vector<uint32_t> &indexArray)
+ AddFaceResult::Enum addFace(const uint32_t *indices, bool ignore = false, bool hashEdge = true)
{
- return addFace(indexArray, 0, indexArray.size());
+ AddFaceResult::Enum result = AddFaceResult::OK;
+ if (m_flags & MeshFlags::HasFaceGroups)
+ m_faceGroups.push_back(UINT32_MAX);
+ if (m_flags & MeshFlags::HasIgnoredFaces)
+ m_faceIgnore.push_back(ignore);
+ const uint32_t firstIndex = m_indices.size();
+ for (uint32_t i = 0; i < 3; i++)
+ m_indices.push_back(indices[i]);
+ if (hashEdge) {
+ for (uint32_t i = 0; i < 3; i++) {
+ const uint32_t vertex0 = m_indices[firstIndex + i];
+ const uint32_t vertex1 = m_indices[firstIndex + (i + 1) % 3];
+ const EdgeKey key(vertex0, vertex1);
+ if (m_edgeMap.get(key) != UINT32_MAX)
+ result = AddFaceResult::DuplicateEdge;
+ m_edgeMap.add(key, firstIndex + i);
+ }
+ }
+ return result;
}
- Face *addFace(const std::vector<uint32_t> &indexArray, uint32_t first, uint32_t num)
+ void createColocals()
{
- return addFace(indexArray.data(), (uint32_t)indexArray.size(), first, num);
+ const uint32_t vertexCount = m_positions.size();
+ Array<AABB> aabbs;
+ aabbs.resize(vertexCount);
+ for (uint32_t i = 0; i < m_positions.size(); i++)
+ aabbs[i] = AABB(m_positions[i], m_epsilon);
+ BVH bvh(aabbs);
+ Array<uint32_t> colocals;
+ Array<uint32_t> potential;
+ m_colocalVertexCount = 0;
+ m_nextColocalVertex.resize(vertexCount, UINT32_MAX);
+ for (uint32_t i = 0; i < vertexCount; i++) {
+ if (m_nextColocalVertex[i] != UINT32_MAX)
+ continue; // Already linked.
+ // Find other vertices colocal to this one.
+ colocals.clear();
+ colocals.push_back(i); // Always add this vertex.
+ bvh.query(AABB(m_positions[i], m_epsilon), potential);
+ for (uint32_t j = 0; j < potential.size(); j++) {
+ const uint32_t otherVertex = potential[j];
+ if (otherVertex != i && equal(m_positions[i], m_positions[otherVertex], m_epsilon) && m_nextColocalVertex[otherVertex] == UINT32_MAX)
+ colocals.push_back(otherVertex);
+ }
+ if (colocals.size() == 1) {
+ // No colocals for this vertex.
+ m_nextColocalVertex[i] = i;
+ continue;
+ }
+ m_colocalVertexCount += colocals.size();
+ // Link in ascending order.
+ insertionSort(colocals.data(), colocals.size());
+ for (uint32_t j = 0; j < colocals.size(); j++)
+ m_nextColocalVertex[colocals[j]] = colocals[(j + 1) % colocals.size()];
+ XA_DEBUG_ASSERT(m_nextColocalVertex[i] != UINT32_MAX);
+ }
}
- Face *addFace(const uint32_t *indexArray, uint32_t indexCount, uint32_t first, uint32_t num)
+ // Check if the face duplicates any edges of any face already in the group.
+ bool faceDuplicatesGroupEdge(uint32_t group, uint32_t face) const
{
- xaDebugAssert(first < indexCount);
- xaDebugAssert(num <= indexCount - first);
- xaDebugAssert(num > 2);
- if (!canAddFace(indexArray, first, num)) {
- return NULL;
- }
- Face *f = new Face(m_faceArray.size());
- Edge *firstEdge = NULL;
- Edge *last = NULL;
- Edge *current = NULL;
- for (uint32_t i = 0; i < num - 1; i++) {
- current = addEdge(indexArray[first + i], indexArray[first + i + 1]);
- xaAssert(current != NULL && current->face == NULL);
- current->face = f;
- if (last != NULL) last->setNext(current);
- else firstEdge = current;
- last = current;
+ for (FaceEdgeIterator edgeIt(this, face); !edgeIt.isDone(); edgeIt.advance()) {
+ for (ColocalEdgeIterator colocalEdgeIt(this, edgeIt.vertex0(), edgeIt.vertex1()); !colocalEdgeIt.isDone(); colocalEdgeIt.advance()) {
+ if (m_faceGroups[meshEdgeFace(colocalEdgeIt.edge())] == group)
+ return true;
+ }
}
- current = addEdge(indexArray[first + num - 1], indexArray[first]);
- xaAssert(current != NULL && current->face == NULL);
- current->face = f;
- last->setNext(current);
- current->setNext(firstEdge);
- f->edge = firstEdge;
- m_faceArray.push_back(f);
- return f;
+ return false;
}
- // -- GODOT start --
- Face *addUniqueFace(uint32_t v0, uint32_t v1, uint32_t v2) {
-
- int base_vertex = m_vertexArray.size();
-
- uint32_t ids[3] = { v0, v1, v2 };
-
- Vector3 base[3] = {
- m_vertexArray[v0]->pos,
- m_vertexArray[v1]->pos,
- m_vertexArray[v2]->pos,
- };
-
- //make sure its not a degenerate
- bool degenerate = distanceSquared(base[0], base[1]) < NV_EPSILON || distanceSquared(base[0], base[2]) < NV_EPSILON || distanceSquared(base[1], base[2]) < NV_EPSILON;
- xaDebugAssert(!degenerate);
-
- float min_x = 0;
-
- for (int i = 0; i < 3; i++) {
- if (i == 0 || m_vertexArray[v0]->pos.x < min_x) {
- min_x = m_vertexArray[v0]->pos.x;
+ // Check if the face mirrors any face already in the group.
+ // i.e. don't want two-sided faces in the same group.
+ // A face mirrors another face if all edges match with opposite winding.
+ bool faceMirrorsGroupFace(uint32_t group, uint32_t face) const
+ {
+ FaceEdgeIterator edgeIt(this, face);
+ for (ColocalEdgeIterator colocalEdgeIt(this, edgeIt.vertex1(), edgeIt.vertex0()); !colocalEdgeIt.isDone(); colocalEdgeIt.advance()) {
+ const uint32_t candidateFace = meshEdgeFace(colocalEdgeIt.edge());
+ if (m_faceGroups[candidateFace] == group) {
+ // Found a match for mirrored first edge, try the other edges.
+ bool match = false;
+ for (; !edgeIt.isDone(); edgeIt.advance()) {
+ match = false;
+ for (ColocalEdgeIterator colocalEdgeIt2(this, edgeIt.vertex1(), edgeIt.vertex0()); !colocalEdgeIt2.isDone(); colocalEdgeIt2.advance()) {
+ if (meshEdgeFace(colocalEdgeIt2.edge()) == candidateFace) {
+ match = true;
+ break;
+ }
+ }
+ if (!match)
+ break;
+ }
+ if (match)
+ return true; // All edges are mirrored in this face.
+ // Try the next face.
+ edgeIt = FaceEdgeIterator(this, candidateFace);
}
}
+ return false;
+ }
- float max_x = 0;
-
- for (int j = 0; j < m_vertexArray.size(); j++) {
- if (j == 0 || m_vertexArray[j]->pos.x > max_x) { //vertex already exists
- max_x = m_vertexArray[j]->pos.x;
+ void createFaceGroups()
+ {
+ uint32_t group = 0;
+ Array<uint32_t> growFaces;
+ for (;;) {
+ // Find an unassigned face.
+ uint32_t face = UINT32_MAX;
+ for (uint32_t f = 0; f < faceCount(); f++) {
+ if (m_faceGroups[f] == UINT32_MAX && !isFaceIgnored(f)) {
+ face = f;
+ break;
+ }
}
+ if (face == UINT32_MAX)
+ break; // All faces assigned to a group (except ignored faces).
+ m_faceGroups[face] = group;
+ growFaces.clear();
+ growFaces.push_back(face);
+ // Find faces connected to the face and assign them to the same group as the face, unless they are already assigned to another group.
+ for (;;) {
+ if (growFaces.isEmpty())
+ break;
+ const uint32_t f = growFaces.back();
+ growFaces.pop_back();
+ for (FaceEdgeIterator edgeIt(this, f); !edgeIt.isDone(); edgeIt.advance()) {
+ // Iterate opposite edges. There may be more than one - non-manifold geometry can have duplicate edges.
+ // Prioritize the one with exact vertex match, not just colocal.
+ // If *any* of the opposite edges are already assigned to this group, don't do anything.
+ bool alreadyAssignedToThisGroup = false;
+ uint32_t bestConnectedFace = UINT32_MAX;
+ for (ColocalEdgeIterator oppositeEdgeIt(this, edgeIt.vertex1(), edgeIt.vertex0()); !oppositeEdgeIt.isDone(); oppositeEdgeIt.advance()) {
+ const uint32_t oppositeEdge = oppositeEdgeIt.edge();
+ const uint32_t oppositeFace = meshEdgeFace(oppositeEdge);
+ if (isFaceIgnored(oppositeFace))
+ continue; // Don't add ignored faces to group.
+ if (m_faceGroups[oppositeFace] == group) {
+ alreadyAssignedToThisGroup = true;
+ break;
+ }
+ if (m_faceGroups[oppositeFace] != UINT32_MAX)
+ continue; // Connected face is already assigned to another group.
+ if (faceDuplicatesGroupEdge(group, oppositeFace))
+ continue; // Don't want duplicate edges in a group.
+ if (faceMirrorsGroupFace(group, oppositeFace))
+ continue; // Don't want two-sided faces in a group.
+ const uint32_t oppositeVertex0 = m_indices[meshEdgeIndex0(oppositeEdge)];
+ const uint32_t oppositeVertex1 = m_indices[meshEdgeIndex1(oppositeEdge)];
+ if (bestConnectedFace == UINT32_MAX || (oppositeVertex0 == edgeIt.vertex1() && oppositeVertex1 == edgeIt.vertex0()))
+ bestConnectedFace = oppositeFace;
+ }
+ if (!alreadyAssignedToThisGroup && bestConnectedFace != UINT32_MAX) {
+ m_faceGroups[bestConnectedFace] = group;
+ growFaces.push_back(bestConnectedFace);
+ }
+ }
+ }
+ group++;
}
-
- //separate from everything else, in x axis
- for (int i = 0; i < 3; i++) {
-
- base[i].x -= min_x;
- base[i].x += max_x + 10.0;
- }
-
- for (int i = 0; i < 3; i++) {
- Vertex *v = new Vertex(m_vertexArray.size());
- v->pos = base[i];
- v->nor = m_vertexArray[ids[i]]->nor,
- v->tex = m_vertexArray[ids[i]]->tex,
-
- v->original_id = ids[i];
- m_vertexArray.push_back(v);
- }
-
- uint32_t indexArray[3];
- indexArray[0] = base_vertex + 0;
- indexArray[1] = base_vertex + 1;
- indexArray[2] = base_vertex + 2;
- return addFace(indexArray, 3, 0, 3);
}
- // -- GODOT end --
-
- // These functions disconnect the given element from the mesh and delete it.
- // @@ We must always disconnect edge pairs simultaneously.
- void disconnect(Edge *edge)
+ void createBoundaries()
{
- xaDebugAssert(edge != NULL);
- // Remove from edge list.
- if ((edge->id & 1) == 0) {
- xaDebugAssert(m_edgeArray[edge->id / 2] == edge);
- m_edgeArray[edge->id / 2] = NULL;
- }
- // Remove edge from map. @@ Store map key inside edge?
- xaDebugAssert(edge->from() != NULL && edge->to() != NULL);
- size_t removed = m_edgeMap.erase(Key(edge->from()->id, edge->to()->id));
- xaDebugAssert(removed == 1);
-#ifdef NDEBUG
- removed = 0; // silence unused parameter warning
+ const uint32_t edgeCount = m_indices.size();
+ const uint32_t vertexCount = m_positions.size();
+ m_oppositeEdges.resize(edgeCount);
+ m_boundaryVertices.resize(vertexCount);
+ for (uint32_t i = 0; i < edgeCount; i++)
+ m_oppositeEdges[i] = UINT32_MAX;
+ for (uint32_t i = 0; i < vertexCount; i++)
+ m_boundaryVertices[i] = false;
+ const bool hasFaceGroups = m_flags & MeshFlags::HasFaceGroups;
+ for (uint32_t i = 0; i < faceCount(); i++) {
+ if (isFaceIgnored(i))
+ continue;
+ for (uint32_t j = 0; j < 3; j++) {
+ const uint32_t vertex0 = m_indices[i * 3 + j];
+ const uint32_t vertex1 = m_indices[i * 3 + (j + 1) % 3];
+ // If there is an edge with opposite winding to this one, the edge isn't on a boundary.
+ const uint32_t oppositeEdge = findEdge(hasFaceGroups ? m_faceGroups[i] : UINT32_MAX, vertex1, vertex0);
+ if (oppositeEdge != UINT32_MAX) {
+#if XA_DEBUG
+ if (hasFaceGroups)
+ XA_DEBUG_ASSERT(m_faceGroups[meshEdgeFace(oppositeEdge)] == m_faceGroups[i]);
#endif
- // Disconnect from vertex.
- if (edge->vertex != NULL) {
- if (edge->vertex->edge == edge) {
- if (edge->prev && edge->prev->pair) {
- edge->vertex->edge = edge->prev->pair;
- } else if (edge->pair && edge->pair->next) {
- edge->vertex->edge = edge->pair->next;
+ XA_DEBUG_ASSERT(!isFaceIgnored(meshEdgeFace(oppositeEdge)));
+ m_oppositeEdges[i * 3 + j] = oppositeEdge;
} else {
- edge->vertex->edge = NULL;
- // @@ Remove disconnected vertex?
+ m_boundaryVertices[vertex0] = m_boundaryVertices[vertex1] = true;
}
}
}
- // Disconnect from face.
- if (edge->face != NULL) {
- if (edge->face->edge == edge) {
- if (edge->next != NULL && edge->next != edge) {
- edge->face->edge = edge->next;
- } else if (edge->prev != NULL && edge->prev != edge) {
- edge->face->edge = edge->prev;
- } else {
- edge->face->edge = NULL;
- // @@ Remove disconnected face?
+ }
+
+ void linkBoundaries()
+ {
+ const uint32_t edgeCount = m_indices.size();
+ HashMap<uint32_t, uint32_t> vertexToEdgeMap(MemTag::Mesh, edgeCount);
+ for (uint32_t i = 0; i < edgeCount; i++) {
+ const uint32_t vertex0 = m_indices[meshEdgeIndex0(i)];
+ const uint32_t vertex1 = m_indices[meshEdgeIndex1(i)];
+ vertexToEdgeMap.add(vertex0, i);
+ vertexToEdgeMap.add(vertex1, i);
+ }
+ m_nextBoundaryEdges.resize(edgeCount);
+ for (uint32_t i = 0; i < edgeCount; i++)
+ m_nextBoundaryEdges[i] = UINT32_MAX;
+ uint32_t numBoundaryLoops = 0, numUnclosedBoundaries = 0;
+ BitArray linkedEdges(edgeCount);
+ linkedEdges.clearAll();
+ for (;;) {
+ // Find the first boundary edge that hasn't been linked yet.
+ uint32_t firstEdge = UINT32_MAX;
+ for (uint32_t i = 0; i < edgeCount; i++) {
+ if (m_oppositeEdges[i] == UINT32_MAX && !linkedEdges.bitAt(i)) {
+ firstEdge = i;
+ break;
}
}
- }
- // Disconnect from previous.
- if (edge->prev) {
- if (edge->prev->next == edge) {
- edge->prev->setNext(NULL);
+ if (firstEdge == UINT32_MAX)
+ break;
+ uint32_t currentEdge = firstEdge;
+ for (;;) {
+ // Find the next boundary edge. The first vertex will be the same as (or colocal to) the current edge second vertex.
+ const uint32_t startVertex = m_indices[meshEdgeIndex1(currentEdge)];
+ uint32_t bestNextEdge = UINT32_MAX;
+ for (ColocalVertexIterator it(this, startVertex); !it.isDone(); it.advance()) {
+ uint32_t mapOtherEdgeIndex = vertexToEdgeMap.get(it.vertex());
+ while (mapOtherEdgeIndex != UINT32_MAX) {
+ const uint32_t otherEdge = vertexToEdgeMap.value(mapOtherEdgeIndex);
+ if (m_oppositeEdges[otherEdge] != UINT32_MAX)
+ goto next; // Not a boundary edge.
+ if (linkedEdges.bitAt(otherEdge))
+ goto next; // Already linked.
+ if (m_flags & MeshFlags::HasFaceGroups && m_faceGroups[meshEdgeFace(currentEdge)] != m_faceGroups[meshEdgeFace(otherEdge)])
+ goto next; // Don't cross face groups.
+ if (isFaceIgnored(meshEdgeFace(otherEdge)))
+ goto next; // Face is ignored.
+ if (m_indices[meshEdgeIndex0(otherEdge)] != it.vertex())
+ goto next; // Edge contains the vertex, but it's the wrong one.
+ // First edge (closing the boundary loop) has the highest priority.
+ // Non-colocal vertex has the next highest.
+ if (bestNextEdge != firstEdge && (bestNextEdge == UINT32_MAX || it.vertex() == startVertex))
+ bestNextEdge = otherEdge;
+ next:
+ mapOtherEdgeIndex = vertexToEdgeMap.getNext(mapOtherEdgeIndex);
+ }
+ }
+ if (bestNextEdge == UINT32_MAX) {
+ numUnclosedBoundaries++;
+ if (currentEdge == firstEdge)
+ linkedEdges.setBitAt(firstEdge); // Only 1 edge in this boundary "loop".
+ break; // Can't find a next edge.
+ }
+ m_nextBoundaryEdges[currentEdge] = bestNextEdge;
+ linkedEdges.setBitAt(bestNextEdge);
+ currentEdge = bestNextEdge;
+ if (currentEdge == firstEdge) {
+ numBoundaryLoops++;
+ break; // Closed the boundary loop.
+ }
}
- //edge->setPrev(NULL);
}
- // Disconnect from next.
- if (edge->next) {
- if (edge->next->prev == edge) {
- edge->next->setPrev(NULL);
+ // Find internal boundary loops and separate them.
+ // Detect by finding two edges in a boundary loop that have a colocal end vertex.
+ // Fix by swapping their next boundary edge.
+ // Need to start over after every fix since known boundary loops have changed.
+ Array<uint32_t> boundaryLoops;
+ fixInternalBoundary:
+ meshGetBoundaryLoops(*this, boundaryLoops);
+ for (uint32_t loop = 0; loop < boundaryLoops.size(); loop++) {
+ linkedEdges.clearAll();
+ for (Mesh::BoundaryEdgeIterator it1(this, boundaryLoops[loop]); !it1.isDone(); it1.advance()) {
+ const uint32_t e1 = it1.edge();
+ if (linkedEdges.bitAt(e1))
+ continue;
+ for (Mesh::BoundaryEdgeIterator it2(this, boundaryLoops[loop]); !it2.isDone(); it2.advance()) {
+ const uint32_t e2 = it2.edge();
+ if (e1 == e2 || !isBoundaryEdge(e2) || linkedEdges.bitAt(e2))
+ continue;
+ if (!areColocal(m_indices[meshEdgeIndex1(e1)], m_indices[meshEdgeIndex1(e2)]))
+ continue;
+ swap(m_nextBoundaryEdges[e1], m_nextBoundaryEdges[e2]);
+ linkedEdges.setBitAt(e1);
+ linkedEdges.setBitAt(e2);
+ goto fixInternalBoundary; // start over
+ }
}
- //edge->setNext(NULL);
}
}
- void remove(Edge *edge)
- {
- xaDebugAssert(edge != NULL);
- disconnect(edge);
- delete edge;
+ /// Find edge, test all colocals.
+ uint32_t findEdge(uint32_t faceGroup, uint32_t vertex0, uint32_t vertex1) const
+ {
+ uint32_t result = UINT32_MAX;
+ if (m_nextColocalVertex.isEmpty()) {
+ EdgeKey key(vertex0, vertex1);
+ uint32_t mapEdgeIndex = m_edgeMap.get(key);
+ while (mapEdgeIndex != UINT32_MAX) {
+ const uint32_t edge = m_edgeMap.value(mapEdgeIndex);
+ // Don't find edges of ignored faces.
+ if ((faceGroup == UINT32_MAX || m_faceGroups[meshEdgeFace(edge)] == faceGroup) && !isFaceIgnored(meshEdgeFace(edge))) {
+ //XA_DEBUG_ASSERT(m_id != UINT32_MAX || (m_id == UINT32_MAX && result == UINT32_MAX)); // duplicate edge - ignore on initial meshes
+ result = edge;
+#if !XA_DEBUG
+ return result;
+#endif
+ }
+ mapEdgeIndex = m_edgeMap.getNext(mapEdgeIndex);
+ }
+ } else {
+ for (ColocalVertexIterator it0(this, vertex0); !it0.isDone(); it0.advance()) {
+ for (ColocalVertexIterator it1(this, vertex1); !it1.isDone(); it1.advance()) {
+ EdgeKey key(it0.vertex(), it1.vertex());
+ uint32_t mapEdgeIndex = m_edgeMap.get(key);
+ while (mapEdgeIndex != UINT32_MAX) {
+ const uint32_t edge = m_edgeMap.value(mapEdgeIndex);
+ // Don't find edges of ignored faces.
+ if ((faceGroup == UINT32_MAX || m_faceGroups[meshEdgeFace(edge)] == faceGroup) && !isFaceIgnored(meshEdgeFace(edge))) {
+ XA_DEBUG_ASSERT(m_id != UINT32_MAX || (m_id == UINT32_MAX && result == UINT32_MAX)); // duplicate edge - ignore on initial meshes
+ result = edge;
+#if !XA_DEBUG
+ return result;
+#endif
+ }
+ mapEdgeIndex = m_edgeMap.getNext(mapEdgeIndex);
+ }
+ }
+ }
+ }
+ return result;
}
- void remove(Vertex *vertex)
+#if XA_DEBUG_EXPORT_OBJ
+ void writeObjVertices(FILE *file) const
{
- xaDebugAssert(vertex != NULL);
- // Remove from vertex list.
- m_vertexArray[vertex->id] = NULL;
- // Disconnect from colocals.
- vertex->unlinkColocal();
- // Disconnect from edges.
- if (vertex->edge != NULL) {
- // @@ Removing a connected vertex is asking for trouble...
- if (vertex->edge->vertex == vertex) {
- // @@ Connect edge to a colocal?
- vertex->edge->vertex = NULL;
- }
- vertex->setEdge(NULL);
+ for (uint32_t i = 0; i < m_positions.size(); i++)
+ fprintf(file, "v %g %g %g\n", m_positions[i].x, m_positions[i].y, m_positions[i].z);
+ if (m_flags & MeshFlags::HasNormals) {
+ for (uint32_t i = 0; i < m_normals.size(); i++)
+ fprintf(file, "vn %g %g %g\n", m_normals[i].x, m_normals[i].y, m_normals[i].z);
}
- delete vertex;
+ for (uint32_t i = 0; i < m_texcoords.size(); i++)
+ fprintf(file, "vt %g %g\n", m_texcoords[i].x, m_texcoords[i].y);
}
- void remove(Face *face)
+ void writeObjFace(FILE *file, uint32_t face) const
{
- xaDebugAssert(face != NULL);
- // Remove from face list.
- m_faceArray[face->id] = NULL;
- // Disconnect from edges.
- if (face->edge != NULL) {
- xaDebugAssert(face->edge->face == face);
- face->edge->face = NULL;
- face->edge = NULL;
+ fprintf(file, "f ");
+ for (uint32_t j = 0; j < 3; j++) {
+ const uint32_t index = m_indices[face * 3 + j] + 1; // 1-indexed
+ fprintf(file, "%d/%d/%d%c", index, index, index, j == 2 ? '\n' : ' ');
}
- delete face;
}
- // Triangulate in place.
- void triangulate()
+ void writeObjBoundaryEges(FILE *file) const
{
- bool all_triangles = true;
- const uint32_t faceCount = m_faceArray.size();
- for (uint32_t f = 0; f < faceCount; f++) {
- Face *face = m_faceArray[f];
- if (face->edgeCount() != 3) {
- all_triangles = false;
- break;
- }
- }
- if (all_triangles) {
- return;
- }
- // Do not touch vertices, but rebuild edges and faces.
- std::vector<Edge *> edgeArray;
- std::vector<Face *> faceArray;
- std::swap(edgeArray, m_edgeArray);
- std::swap(faceArray, m_faceArray);
- m_edgeMap.clear();
- for (uint32_t f = 0; f < faceCount; f++) {
- Face *face = faceArray[f];
- // Trivial fan-like triangulation.
- const uint32_t v0 = face->edge->vertex->id;
- uint32_t v2, v1 = (uint32_t)-1;
- for (Face::EdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- Edge *edge = it.current();
- v2 = edge->to()->id;
- if (v2 == v0) break;
- if (v1 != -1) addFace(v0, v1, v2);
- v1 = v2;
- }
- }
- xaDebugAssert(m_faceArray.size() > faceCount); // triangle count > face count
- linkBoundary();
- for (size_t i = 0; i < edgeArray.size(); i++)
- delete edgeArray[i];
- for (size_t i = 0; i < faceArray.size(); i++)
- delete faceArray[i];
- }
-
- /// Link boundary edges once the mesh has been created.
- void linkBoundary()
- {
- xaPrint("--- Linking boundaries:\n");
- int num = 0;
- // Create boundary edges.
- uint32_t edgeCount = this->edgeCount();
- for (uint32_t e = 0; e < edgeCount; e++) {
- Edge *edge = edgeAt(e);
- if (edge != NULL && edge->pair == NULL) {
- Edge *pair = new Edge(edge->id + 1);
- uint32_t i = edge->from()->id;
- uint32_t j = edge->next->from()->id;
- Key key(j, i);
- xaAssert(m_edgeMap.find(key) == m_edgeMap.end());
- pair->vertex = m_vertexArray[j];
- m_edgeMap[key] = pair;
- edge->pair = pair;
- pair->pair = edge;
- num++;
- }
- }
- // Link boundary edges.
- for (uint32_t e = 0; e < edgeCount; e++) {
- Edge *edge = edgeAt(e);
- if (edge != NULL && edge->pair->face == NULL) {
- linkBoundaryEdge(edge->pair);
+ if (m_oppositeEdges.isEmpty())
+ return; // Boundaries haven't been created.
+ fprintf(file, "o boundary_edges\n");
+ for (uint32_t i = 0; i < edgeCount(); i++) {
+ if (m_oppositeEdges[i] != UINT32_MAX)
+ continue;
+ fprintf(file, "l %d %d\n", m_indices[meshEdgeIndex0(i)] + 1, m_indices[meshEdgeIndex1(i)] + 1); // 1-indexed
+ }
+ }
+
+ void writeObjLinkedBoundaries(FILE *file) const
+ {
+ if (m_oppositeEdges.isEmpty() || m_nextBoundaryEdges.isEmpty())
+ return; // Boundaries haven't been created and/or linked.
+ Array<uint32_t> boundaryLoops;
+ meshGetBoundaryLoops(*this, boundaryLoops);
+ for (uint32_t i = 0; i < boundaryLoops.size(); i++) {
+ uint32_t edge = boundaryLoops[i];
+ fprintf(file, "o boundary_%04d\n", i);
+ fprintf(file, "l");
+ for (;;) {
+ const uint32_t vertex0 = m_indices[meshEdgeIndex0(edge)];
+ const uint32_t vertex1 = m_indices[meshEdgeIndex1(edge)];
+ fprintf(file, " %d", vertex0 + 1); // 1-indexed
+ edge = m_nextBoundaryEdges[edge];
+ if (edge == boundaryLoops[i] || edge == UINT32_MAX) {
+ fprintf(file, " %d\n", vertex1 + 1); // 1-indexed
+ break;
+ }
}
}
- xaPrint("--- %d boundary edges.\n", num);
}
- /*
- Fixing T-junctions.
+ void writeObjFile(const char *filename) const
+ {
+ FILE *file;
+ XA_FOPEN(file, filename, "w");
+ if (!file)
+ return;
+ writeObjVertices(file);
+ fprintf(file, "s off\n");
+ fprintf(file, "o object\n");
+ for (uint32_t i = 0; i < faceCount(); i++)
+ writeObjFace(file, i);
+ writeObjBoundaryEges(file);
+ writeObjLinkedBoundaries(file);
+ fclose(file);
+ }
+#endif
- - Find T-junctions. Find vertices that are on an edge.
- - This test is approximate.
- - Insert edges on a spatial index to speedup queries.
- - Consider only open edges, that is edges that have no pairs.
- - Consider only vertices on boundaries.
- - Close T-junction.
- - Split edge.
+ float computeSurfaceArea() const
+ {
+ float area = 0;
+ for (uint32_t f = 0; f < faceCount(); f++)
+ area += faceArea(f);
+ XA_DEBUG_ASSERT(area >= 0);
+ return area;
+ }
- */
- bool splitBoundaryEdges() // Returns true if any split was made.
- {
- std::vector<Vertex *> boundaryVertices;
- for (uint32_t i = 0; i < m_vertexArray.size(); i++) {
- Vertex *v = m_vertexArray[i];
- if (v->isBoundary()) {
- boundaryVertices.push_back(v);
- }
- }
- xaPrint("Fixing T-junctions:\n");
- int splitCount = 0;
- for (uint32_t v = 0; v < boundaryVertices.size(); v++) {
- Vertex *vertex = boundaryVertices[v];
- Vector3 x0 = vertex->pos;
- // Find edges that this vertex overlaps with.
- for (uint32_t e = 0; e < m_edgeArray.size(); e++) {
- Edge *edge = m_edgeArray[e];
- if (edge != NULL && edge->isBoundary()) {
- if (edge->from() == vertex || edge->to() == vertex) {
- continue;
- }
- Vector3 x1 = edge->from()->pos;
- Vector3 x2 = edge->to()->pos;
- Vector3 v01 = x0 - x1;
- Vector3 v21 = x2 - x1;
- float l = length(v21);
- float d = length(cross(v01, v21)) / l;
- if (isZero(d)) {
- float t = dot(v01, v21) / (l * l);
- if (t > 0.0f + NV_EPSILON && t < 1.0f - NV_EPSILON) {
- xaDebugAssert(equal(lerp(x1, x2, t), x0));
- Vertex *splitVertex = splitBoundaryEdge(edge, t, x0);
- vertex->linkColocal(splitVertex); // @@ Should we do this here?
- splitCount++;
- }
- }
- }
- }
- }
- xaPrint(" - %d edges split.\n", splitCount);
- xaDebugAssert(isValid());
- return splitCount != 0;
+ float computeParametricArea() const
+ {
+ float area = 0;
+ for (uint32_t f = 0; f < faceCount(); f++)
+ area += faceParametricArea(f);
+ return fabsf(area); // May be negative, depends on texcoord winding.
}
- // Vertices
- uint32_t vertexCount() const
+ float faceArea(uint32_t face) const
{
- return m_vertexArray.size();
+ const Vector3 &p0 = m_positions[m_indices[face * 3 + 0]];
+ const Vector3 &p1 = m_positions[m_indices[face * 3 + 1]];
+ const Vector3 &p2 = m_positions[m_indices[face * 3 + 2]];
+ return length(cross(p1 - p0, p2 - p0)) * 0.5f;
}
- const Vertex *vertexAt(int i) const
+
+ Vector3 faceCentroid(uint32_t face) const
{
- return m_vertexArray[i];
+ Vector3 sum(0.0f);
+ for (uint32_t i = 0; i < 3; i++)
+ sum += m_positions[m_indices[face * 3 + i]];
+ return sum / 3.0f;
}
- Vertex *vertexAt(int i)
+
+ Vector3 calculateFaceNormal(uint32_t face) const
{
- return m_vertexArray[i];
+ return normalizeSafe(triangleNormalAreaScaled(face), Vector3(0, 0, 1), 0.0f);
}
- uint32_t colocalVertexCount() const
+ float faceParametricArea(uint32_t face) const
{
- return m_colocalVertexCount;
+ const Vector2 &t0 = m_texcoords[m_indices[face * 3 + 0]];
+ const Vector2 &t1 = m_texcoords[m_indices[face * 3 + 1]];
+ const Vector2 &t2 = m_texcoords[m_indices[face * 3 + 2]];
+ return triangleArea(t0, t1, t2) * 0.5f;
+ }
+
+ // Average of the edge midpoints weighted by the edge length.
+ // I want a point inside the triangle, but closer to the cirumcenter.
+ Vector3 triangleCenter(uint32_t face) const
+ {
+ const Vector3 &p0 = m_positions[m_indices[face * 3 + 0]];
+ const Vector3 &p1 = m_positions[m_indices[face * 3 + 1]];
+ const Vector3 &p2 = m_positions[m_indices[face * 3 + 2]];
+ const float l0 = length(p1 - p0);
+ const float l1 = length(p2 - p1);
+ const float l2 = length(p0 - p2);
+ const Vector3 m0 = (p0 + p1) * l0 / (l0 + l1 + l2);
+ const Vector3 m1 = (p1 + p2) * l1 / (l0 + l1 + l2);
+ const Vector3 m2 = (p2 + p0) * l2 / (l0 + l1 + l2);
+ return m0 + m1 + m2;
}
- // Faces
- uint32_t faceCount() const
+ // Unnormalized face normal assuming it's a triangle.
+ Vector3 triangleNormal(uint32_t face) const
{
- return m_faceArray.size();
+ return normalizeSafe(triangleNormalAreaScaled(face), Vector3(0), 0.0f);
}
- const Face *faceAt(int i) const
+
+ Vector3 triangleNormalAreaScaled(uint32_t face) const
{
- return m_faceArray[i];
+ const Vector3 &p0 = m_positions[m_indices[face * 3 + 0]];
+ const Vector3 &p1 = m_positions[m_indices[face * 3 + 1]];
+ const Vector3 &p2 = m_positions[m_indices[face * 3 + 2]];
+ const Vector3 e0 = p2 - p0;
+ const Vector3 e1 = p1 - p0;
+ return cross(e0, e1);
}
- Face *faceAt(int i)
+
+ // @@ This is not exactly accurate, we should compare the texture coordinates...
+ bool isSeam(uint32_t edge) const
{
- return m_faceArray[i];
+ const uint32_t oppositeEdge = m_oppositeEdges[edge];
+ if (oppositeEdge == UINT32_MAX)
+ return false; // boundary edge
+ const uint32_t e0 = meshEdgeIndex0(edge);
+ const uint32_t e1 = meshEdgeIndex1(edge);
+ const uint32_t oe0 = meshEdgeIndex0(oppositeEdge);
+ const uint32_t oe1 = meshEdgeIndex1(oppositeEdge);
+ return m_indices[e0] != m_indices[oe1] || m_indices[e1] != m_indices[oe0];
}
- // Edges
- uint32_t edgeCount() const
+ bool isTextureSeam(uint32_t edge) const
{
- return m_edgeArray.size();
+ const uint32_t oppositeEdge = m_oppositeEdges[edge];
+ if (oppositeEdge == UINT32_MAX)
+ return false; // boundary edge
+ const uint32_t e0 = meshEdgeIndex0(edge);
+ const uint32_t e1 = meshEdgeIndex1(edge);
+ const uint32_t oe0 = meshEdgeIndex0(oppositeEdge);
+ const uint32_t oe1 = meshEdgeIndex1(oppositeEdge);
+ return m_texcoords[m_indices[e0]] != m_texcoords[m_indices[oe1]] || m_texcoords[m_indices[e1]] != m_texcoords[m_indices[oe0]];
}
- const Edge *edgeAt(int i) const
+
+ uint32_t firstColocal(uint32_t vertex) const
{
- return m_edgeArray[i];
+ for (ColocalVertexIterator it(this, vertex); !it.isDone(); it.advance()) {
+ if (it.vertex() < vertex)
+ vertex = it.vertex();
+ }
+ return vertex;
}
- Edge *edgeAt(int i)
+
+ bool areColocal(uint32_t vertex0, uint32_t vertex1) const
{
- return m_edgeArray[i];
+ if (vertex0 == vertex1)
+ return true;
+ if (m_nextColocalVertex.isEmpty())
+ return false;
+ for (ColocalVertexIterator it(this, vertex0); !it.isDone(); it.advance()) {
+ if (it.vertex() == vertex1)
+ return true;
+ }
+ return false;
}
- class ConstVertexIterator;
+ float epsilon() const { return m_epsilon; }
+ uint32_t edgeCount() const { return m_indices.size(); }
+ uint32_t oppositeEdge(uint32_t edge) const { return m_oppositeEdges[edge]; }
+ bool isBoundaryEdge(uint32_t edge) const { return m_oppositeEdges[edge] == UINT32_MAX; }
+ bool isBoundaryVertex(uint32_t vertex) const { return m_boundaryVertices[vertex]; }
+ uint32_t colocalVertexCount() const { return m_colocalVertexCount; }
+ uint32_t vertexCount() const { return m_positions.size(); }
+ uint32_t vertexAt(uint32_t i) const { return m_indices[i]; }
+ const Vector3 &position(uint32_t vertex) const { return m_positions[vertex]; }
+ const Vector3 &normal(uint32_t vertex) const { XA_DEBUG_ASSERT(m_flags & MeshFlags::HasNormals); return m_normals[vertex]; }
+ const Vector2 &texcoord(uint32_t vertex) const { return m_texcoords[vertex]; }
+ Vector2 &texcoord(uint32_t vertex) { return m_texcoords[vertex]; }
+ Vector2 *texcoords() { return m_texcoords.data(); }
+ uint32_t faceCount() const { return m_indices.size() / 3; }
+ uint32_t faceGroupCount() const { XA_DEBUG_ASSERT(m_flags & MeshFlags::HasFaceGroups); return m_faceGroups.size(); }
+ uint32_t faceGroupAt(uint32_t face) const { XA_DEBUG_ASSERT(m_flags & MeshFlags::HasFaceGroups); return m_faceGroups[face]; }
+ const uint32_t *indices() const { return m_indices.data(); }
+ uint32_t indexCount() const { return m_indices.size(); }
+
+private:
+ bool isFaceIgnored(uint32_t face) const { return (m_flags & MeshFlags::HasIgnoredFaces) && m_faceIgnore[face]; }
+
+ float m_epsilon;
+ uint32_t m_flags;
+ uint32_t m_id;
+ Array<bool> m_faceIgnore;
+ Array<uint32_t> m_faceGroups;
+ Array<uint32_t> m_indices;
+ Array<Vector3> m_positions;
+ Array<Vector3> m_normals;
+ Array<Vector2> m_texcoords;
+
+ // Populated by createColocals
+ uint32_t m_colocalVertexCount;
+ Array<uint32_t> m_nextColocalVertex; // In: vertex index. Out: the vertex index of the next colocal position.
+
+ // Populated by createBoundaries
+ Array<bool> m_boundaryVertices;
+ Array<uint32_t> m_oppositeEdges; // In: edge index. Out: the index of the opposite edge (i.e. wound the opposite direction). UINT32_MAX if the input edge is a boundary edge.
- class VertexIterator
+ // Populated by linkBoundaries
+ Array<uint32_t> m_nextBoundaryEdges; // The index of the next boundary edge. UINT32_MAX if the edge is not a boundary edge.
+
+ struct EdgeKey
{
- friend class ConstVertexIterator;
- public:
- VertexIterator(Mesh *mesh) : m_mesh(mesh), m_current(0) { }
+ EdgeKey() {}
+ EdgeKey(const EdgeKey &k) : v0(k.v0), v1(k.v1) {}
+ EdgeKey(uint32_t v0, uint32_t v1) : v0(v0), v1(v1) {}
- virtual void advance()
+ void operator=(const EdgeKey &k)
{
- m_current++;
+ v0 = k.v0;
+ v1 = k.v1;
}
- virtual bool isDone() const
+ bool operator==(const EdgeKey &k) const
{
- return m_current == m_mesh->vertexCount();
- }
- virtual Vertex *current() const
- {
- return m_mesh->vertexAt(m_current);
+ return v0 == k.v0 && v1 == k.v1;
}
- private:
- halfedge::Mesh *m_mesh;
- uint32_t m_current;
+ uint32_t v0;
+ uint32_t v1;
};
- VertexIterator vertices()
- {
- return VertexIterator(this);
- }
- class ConstVertexIterator
+ HashMap<EdgeKey, uint32_t> m_edgeMap;
+
+public:
+ class BoundaryEdgeIterator
{
public:
- ConstVertexIterator(const Mesh *mesh) : m_mesh(mesh), m_current(0) { }
- ConstVertexIterator(class VertexIterator &it) : m_mesh(it.m_mesh), m_current(it.m_current) { }
+ BoundaryEdgeIterator(const Mesh *mesh, uint32_t edge) : m_mesh(mesh), m_first(UINT32_MAX), m_current(edge) {}
- virtual void advance()
+ void advance()
{
- m_current++;
+ if (m_first == UINT32_MAX)
+ m_first = m_current;
+ m_current = m_mesh->m_nextBoundaryEdges[m_current];
}
- virtual bool isDone() const
+
+ bool isDone() const
{
- return m_current == m_mesh->vertexCount();
+ return m_first == m_current || m_current == UINT32_MAX;
}
- virtual const Vertex *current() const
+
+ uint32_t edge() const
{
- return m_mesh->vertexAt(m_current);
+ return m_current;
+ }
+
+ uint32_t nextEdge() const
+ {
+ return m_mesh->m_nextBoundaryEdges[m_current];
}
private:
- const halfedge::Mesh *m_mesh;
+ const Mesh *m_mesh;
+ uint32_t m_first;
uint32_t m_current;
};
- ConstVertexIterator vertices() const
- {
- return ConstVertexIterator(this);
- }
- class ConstFaceIterator;
-
- class FaceIterator
+ class ColocalVertexIterator
{
- friend class ConstFaceIterator;
public:
- FaceIterator(Mesh *mesh) : m_mesh(mesh), m_current(0) { }
+ ColocalVertexIterator(const Mesh *mesh, uint32_t v) : m_mesh(mesh), m_first(UINT32_MAX), m_current(v) {}
- virtual void advance()
+ void advance()
{
- m_current++;
+ if (m_first == UINT32_MAX)
+ m_first = m_current;
+ if (!m_mesh->m_nextColocalVertex.isEmpty())
+ m_current = m_mesh->m_nextColocalVertex[m_current];
}
- virtual bool isDone() const
+
+ bool isDone() const
{
- return m_current == m_mesh->faceCount();
+ return m_first == m_current;
}
- virtual Face *current() const
+
+ uint32_t vertex() const
{
- return m_mesh->faceAt(m_current);
+ return m_current;
+ }
+
+ const Vector3 *pos() const
+ {
+ return &m_mesh->m_positions[m_current];
}
private:
- halfedge::Mesh *m_mesh;
+ const Mesh *m_mesh;
+ uint32_t m_first;
uint32_t m_current;
};
- FaceIterator faces()
- {
- return FaceIterator(this);
- }
- class ConstFaceIterator
+ class ColocalEdgeIterator
{
public:
- ConstFaceIterator(const Mesh *mesh) : m_mesh(mesh), m_current(0) { }
- ConstFaceIterator(const FaceIterator &it) : m_mesh(it.m_mesh), m_current(it.m_current) { }
+ ColocalEdgeIterator(const Mesh *mesh, uint32_t vertex0, uint32_t vertex1) : m_mesh(mesh), m_vertex0It(mesh, vertex0), m_vertex1It(mesh, vertex1), m_vertex1(vertex1)
+ {
+ resetElement();
+ }
- virtual void advance()
+ void advance()
{
- m_current++;
+ advanceElement();
}
- virtual bool isDone() const
+
+ bool isDone() const
{
- return m_current == m_mesh->faceCount();
+ return m_vertex0It.isDone() && m_vertex1It.isDone() && m_mapEdgeIndex == UINT32_MAX;
}
- virtual const Face *current() const
+
+ uint32_t edge() const
{
- return m_mesh->faceAt(m_current);
+ return m_mesh->m_edgeMap.value(m_mapEdgeIndex);
}
private:
- const halfedge::Mesh *m_mesh;
- uint32_t m_current;
- };
- ConstFaceIterator faces() const
- {
- return ConstFaceIterator(this);
- }
-
- class ConstEdgeIterator;
+ void resetElement()
+ {
+ m_mapEdgeIndex = m_mesh->m_edgeMap.get(Mesh::EdgeKey(m_vertex0It.vertex(), m_vertex1It.vertex()));
+ while (m_mapEdgeIndex != UINT32_MAX) {
+ if (!isIgnoredFace())
+ break;
+ m_mapEdgeIndex = m_mesh->m_edgeMap.getNext(m_mapEdgeIndex);
+ }
+ if (m_mapEdgeIndex == UINT32_MAX)
+ advanceVertex1();
+ }
- class EdgeIterator
- {
- friend class ConstEdgeIterator;
- public:
- EdgeIterator(Mesh *mesh) : m_mesh(mesh), m_current(0) { }
+ void advanceElement()
+ {
+ for (;;) {
+ m_mapEdgeIndex = m_mesh->m_edgeMap.getNext(m_mapEdgeIndex);
+ if (m_mapEdgeIndex == UINT32_MAX)
+ break;
+ if (!isIgnoredFace())
+ break;
+ }
+ if (m_mapEdgeIndex == UINT32_MAX)
+ advanceVertex1();
+ }
- virtual void advance()
+ void advanceVertex0()
{
- m_current++;
+ m_vertex0It.advance();
+ if (m_vertex0It.isDone())
+ return;
+ m_vertex1It = ColocalVertexIterator(m_mesh, m_vertex1);
+ resetElement();
}
- virtual bool isDone() const
+
+ void advanceVertex1()
{
- return m_current == m_mesh->edgeCount();
+ m_vertex1It.advance();
+ if (m_vertex1It.isDone())
+ advanceVertex0();
+ else
+ resetElement();
}
- virtual Edge *current() const
+
+ bool isIgnoredFace() const
{
- return m_mesh->edgeAt(m_current);
+ const uint32_t edge = m_mesh->m_edgeMap.value(m_mapEdgeIndex);
+ return m_mesh->m_faceIgnore[meshEdgeFace(edge)];
}
- private:
- halfedge::Mesh *m_mesh;
- uint32_t m_current;
+ const Mesh *m_mesh;
+ ColocalVertexIterator m_vertex0It, m_vertex1It;
+ const uint32_t m_vertex1;
+ uint32_t m_mapEdgeIndex;
};
- EdgeIterator edges()
- {
- return EdgeIterator(this);
- }
- class ConstEdgeIterator
+ class FaceEdgeIterator
{
public:
- ConstEdgeIterator(const Mesh *mesh) : m_mesh(mesh), m_current(0) { }
- ConstEdgeIterator(const EdgeIterator &it) : m_mesh(it.m_mesh), m_current(it.m_current) { }
+ FaceEdgeIterator (const Mesh *mesh, uint32_t face) : m_mesh(mesh), m_face(face), m_relativeEdge(0)
+ {
+ m_edge = m_face * 3;
+ }
- virtual void advance()
+ void advance()
{
- m_current++;
+ if (m_relativeEdge < 3) {
+ m_edge++;
+ m_relativeEdge++;
+ }
}
- virtual bool isDone() const
+
+ bool isDone() const
+ {
+ return m_relativeEdge == 3;
+ }
+
+ bool isBoundary() const { return m_mesh->m_oppositeEdges[m_edge] == UINT32_MAX; }
+ bool isSeam() const { return m_mesh->isSeam(m_edge); }
+ bool isTextureSeam() const { return m_mesh->isTextureSeam(m_edge); }
+ uint32_t edge() const { return m_edge; }
+ uint32_t relativeEdge() const { return m_relativeEdge; }
+ uint32_t face() const { return m_face; }
+ uint32_t oppositeEdge() const { return m_mesh->m_oppositeEdges[m_edge]; }
+
+ uint32_t oppositeFace() const
{
- return m_current == m_mesh->edgeCount();
+ const uint32_t oedge = m_mesh->m_oppositeEdges[m_edge];
+ if (oedge == UINT32_MAX)
+ return UINT32_MAX;
+ return meshEdgeFace(oedge);
}
- virtual const Edge *current() const
+
+ uint32_t vertex0() const
{
- return m_mesh->edgeAt(m_current);
+ return m_mesh->m_indices[m_face * 3 + m_relativeEdge];
}
+ uint32_t vertex1() const
+ {
+ return m_mesh->m_indices[m_face * 3 + (m_relativeEdge + 1) % 3];
+ }
+
+ const Vector3 &position0() const { return m_mesh->m_positions[vertex0()]; }
+ const Vector3 &position1() const { return m_mesh->m_positions[vertex1()]; }
+ const Vector3 &normal0() const { return m_mesh->m_normals[vertex0()]; }
+ const Vector3 &normal1() const { return m_mesh->m_normals[vertex1()]; }
+ const Vector2 &texcoord0() const { return m_mesh->m_texcoords[vertex0()]; }
+ const Vector2 &texcoord1() const { return m_mesh->m_texcoords[vertex1()]; }
+
private:
- const halfedge::Mesh *m_mesh;
- uint32_t m_current;
+ const Mesh *m_mesh;
+ uint32_t m_face;
+ uint32_t m_edge;
+ uint32_t m_relativeEdge;
};
- ConstEdgeIterator edges() const
- {
- return ConstEdgeIterator(this);
- }
-
- // @@ Add half-edge iterator.
+};
- bool isValid() const
- {
- // Make sure all edges are valid.
- const uint32_t edgeCount = m_edgeArray.size();
- for (uint32_t e = 0; e < edgeCount; e++) {
- Edge *edge = m_edgeArray[e];
- if (edge != NULL) {
- if (edge->id != 2 * e) {
- return false;
+static bool meshCloseHole(Mesh *mesh, const Array<uint32_t> &holeVertices, const Vector3 &normal)
+{
+#if XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION
+ const uint32_t faceCount = mesh->faceCount();
+#endif
+ const bool compareNormal = equal(normal, Vector3(0.0f), FLT_EPSILON);
+ uint32_t frontCount = holeVertices.size();
+ Array<uint32_t> frontVertices;
+ Array<Vector3> frontPoints;
+ Array<float> frontAngles;
+ frontVertices.resize(frontCount);
+ frontPoints.resize(frontCount);
+ for (uint32_t i = 0; i < frontCount; i++) {
+ frontVertices[i] = holeVertices[i];
+ frontPoints[i] = mesh->position(frontVertices[i]);
+ }
+ while (frontCount >= 3) {
+ frontAngles.resize(frontCount);
+ float smallestAngle = kPi2, smallestAngleIgnoringNormal = kPi2;
+ uint32_t smallestAngleIndex = UINT32_MAX, smallestAngleIndexIgnoringNormal = UINT32_MAX;
+ for (uint32_t i = 0; i < frontCount; i++) {
+ const uint32_t i1 = i == 0 ? frontCount - 1 : i - 1;
+ const uint32_t i2 = i;
+ const uint32_t i3 = (i + 1) % frontCount;
+ const Vector3 edge1 = frontPoints[i1] - frontPoints[i2];
+ const Vector3 edge2 = frontPoints[i3] - frontPoints[i2];
+ frontAngles[i] = acosf(dot(edge1, edge2) / (length(edge1) * length(edge2)));
+ if (frontAngles[i] >= smallestAngle || isNan(frontAngles[i]))
+ continue;
+ // Don't duplicate edges.
+ if (mesh->findEdge(UINT32_MAX, frontVertices[i1], frontVertices[i2]) != UINT32_MAX)
+ continue;
+ if (mesh->findEdge(UINT32_MAX, frontVertices[i2], frontVertices[i3]) != UINT32_MAX)
+ continue;
+ if (mesh->findEdge(UINT32_MAX, frontVertices[i3], frontVertices[i1]) != UINT32_MAX)
+ continue;
+ /*
+ Make sure he new edge that would be formed by (i3, i1) doesn't intersect any vertices. This often happens when fixing t-junctions.
+
+ i2
+ *
+ / \
+ / \
+ i1 *--*--* i3
+ \ | /
+ \|/
+ *
+ */
+ bool intersection = false;
+ for (uint32_t j = 0; j < frontCount; j++) {
+ if (j == i1 || j == i2 || j == i3)
+ continue;
+ if (lineIntersectsPoint(frontPoints[j], frontPoints[i3], frontPoints[i1], nullptr, mesh->epsilon())) {
+ intersection = true;
+ break;
}
- if (!edge->isValid()) {
- return false;
+ }
+ if (intersection)
+ continue;
+ // Don't add the triangle if a boundary point lies on the same plane as the triangle, and is inside it.
+ intersection = false;
+ const Plane plane(frontPoints[i1], frontPoints[i2], frontPoints[i3]);
+ for (uint32_t j = 0; j < frontCount; j++) {
+ if (j == i1 || j == i2 || j == i3)
+ continue;
+ if (!isZero(plane.distance(frontPoints[j]), mesh->epsilon()))
+ continue;
+ if (pointInTriangle(frontPoints[j], frontPoints[i1], frontPoints[i2], frontPoints[i3])) {
+ intersection = true;
+ break;
}
- if (edge->pair->id != 2 * e + 1) {
- return false;
+ }
+ if (intersection)
+ continue;
+#if XA_CLOSE_HOLES_CHECK_EDGE_INTERSECTION
+ // Don't add the triangle if the new edge (i3, i1), intersects any other triangle that isn't part of the filled hole.
+ intersection = false;
+ const Vector3 newEdgeVector = frontPoints[i1] - frontPoints[i3];
+ for (uint32_t f = 0; f < faceCount; f++) {
+ Vector3 tri[3];
+ for (uint32_t j = 0; j < 3; j++)
+ tri[j] = mesh->position(mesh->vertexAt(f * 3 + j));
+ float t;
+ if (rayIntersectsTriangle(frontPoints[i3], newEdgeVector, tri, &t)) {
+ intersection = true;
+ break;
}
- if (!edge->pair->isValid()) {
- return false;
+ }
+ if (intersection)
+ continue;
+#endif
+ // Skip backwards facing triangles.
+ if (compareNormal) {
+ if (frontAngles[i] < smallestAngleIgnoringNormal) {
+ smallestAngleIgnoringNormal = frontAngles[i];
+ smallestAngleIndexIgnoringNormal = i;
}
+ const Vector3 e0 = frontPoints[i3] - frontPoints[i1];
+ const Vector3 e1 = frontPoints[i2] - frontPoints[i1];
+ const Vector3 triNormal = normalizeSafe(cross(e0, e1), Vector3(0.0f), mesh->epsilon());
+ if (dot(normal, triNormal) <= 0.0f)
+ continue;
}
+ smallestAngle = smallestAngleIgnoringNormal = frontAngles[i];
+ smallestAngleIndex = smallestAngleIndexIgnoringNormal = i;
}
- // @@ Make sure all faces are valid.
- // @@ Make sure all vertices are valid.
- return true;
+ // Closing holes failed if we don't have a smallest angle.
+ // Fallback to ignoring the backwards facing normal test if possible.
+ if (smallestAngleIndex == UINT32_MAX || smallestAngle <= 0.0f || smallestAngle >= kPi) {
+ if (smallestAngleIgnoringNormal == UINT32_MAX || smallestAngleIgnoringNormal <= 0.0f || smallestAngleIgnoringNormal >= kPi)
+ return false;
+ else
+ smallestAngleIndex = smallestAngleIndexIgnoringNormal;
+ }
+ const uint32_t i1 = smallestAngleIndex == 0 ? frontCount - 1 : smallestAngleIndex - 1;
+ const uint32_t i2 = smallestAngleIndex;
+ const uint32_t i3 = (smallestAngleIndex + 1) % frontCount;
+ const Mesh::AddFaceResult::Enum result = mesh->addFace(frontVertices[i1], frontVertices[i2], frontVertices[i3]);
+ XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK); // Shouldn't happen due to the findEdge calls above.
+ XA_UNUSED(result);
+ frontVertices.removeAt(i2);
+ frontPoints.removeAt(i2);
+ frontCount = frontVertices.size();
}
+ return true;
+}
- // Error status:
-
- struct ErrorCode
- {
- enum Enum
- {
- AlreadyAddedEdge,
- DegenerateColocalEdge,
- DegenerateEdge,
- DuplicateEdge
- };
- };
-
- mutable ErrorCode::Enum errorCode;
- mutable uint32_t errorIndex0;
- mutable uint32_t errorIndex1;
+static bool meshCloseHoles(Mesh *mesh, const Array<uint32_t> &boundaryLoops, const Vector3 &normal, Array<uint32_t> &holeFaceCounts)
+{
+ holeFaceCounts.clear();
+ // Compute lengths.
+ const uint32_t boundaryCount = boundaryLoops.size();
+ Array<float> boundaryLengths;
+ Array<uint32_t> boundaryEdgeCounts;
+ boundaryEdgeCounts.resize(boundaryCount);
+ for (uint32_t i = 0; i < boundaryCount; i++) {
+ float boundaryLength = 0.0f;
+ boundaryEdgeCounts[i] = 0;
+ for (Mesh::BoundaryEdgeIterator it(mesh, boundaryLoops[i]); !it.isDone(); it.advance()) {
+ const Vector3 &t0 = mesh->position(mesh->vertexAt(meshEdgeIndex0(it.edge())));
+ const Vector3 &t1 = mesh->position(mesh->vertexAt(meshEdgeIndex1(it.edge())));
+ boundaryLength += length(t1 - t0);
+ boundaryEdgeCounts[i]++;
+ }
+ boundaryLengths.push_back(boundaryLength);
+ }
+ // Find disk boundary.
+ uint32_t diskBoundary = 0;
+ float maxLength = boundaryLengths[0];
+ for (uint32_t i = 1; i < boundaryCount; i++) {
+ if (boundaryLengths[i] > maxLength) {
+ maxLength = boundaryLengths[i];
+ diskBoundary = i;
+ }
+ }
+ // Close holes.
+ Array<uint32_t> holeVertices;
+ Array<Vector3> holePoints;
+ bool result = true;
+ for (uint32_t i = 0; i < boundaryCount; i++) {
+ if (diskBoundary == i)
+ continue; // Skip disk boundary.
+ holeVertices.resize(boundaryEdgeCounts[i]);
+ holePoints.resize(boundaryEdgeCounts[i]);
+ // Winding is backwards for internal boundaries.
+ uint32_t e = 0;
+ for (Mesh::BoundaryEdgeIterator it(mesh, boundaryLoops[i]); !it.isDone(); it.advance()) {
+ const uint32_t vertex = mesh->vertexAt(meshEdgeIndex0(it.edge()));
+ holeVertices[boundaryEdgeCounts[i] - 1 - e] = vertex;
+ holePoints[boundaryEdgeCounts[i] - 1 - e] = mesh->position(vertex);
+ e++;
+ }
+ const uint32_t oldFaceCount = mesh->faceCount();
+ if (!meshCloseHole(mesh, holeVertices, normal))
+ result = false; // Return false if any hole failed to close, but keep trying to close other holes.
+ holeFaceCounts.push_back(mesh->faceCount() - oldFaceCount);
+ }
+ return result;
+}
-private:
- // Return true if the face can be added to the manifold mesh.
- bool canAddFace(const std::vector<uint32_t> &indexArray, uint32_t first, uint32_t num) const
- {
- return canAddFace(indexArray.data(), first, num);
+static bool meshIsPlanar(const Mesh &mesh)
+{
+ const Vector3 p1 = mesh.position(mesh.vertexAt(0));
+ const Vector3 p2 = mesh.position(mesh.vertexAt(1));
+ const Vector3 p3 = mesh.position(mesh.vertexAt(2));
+ const Plane plane(p1, p2, p3);
+ const uint32_t vertexCount = mesh.vertexCount();
+ for (uint32_t v = 0; v < vertexCount; v++) {
+ const float d = plane.distance(mesh.position(v));
+ if (!isZero(d, mesh.epsilon()))
+ return false;
}
+ return true;
+}
- bool canAddFace(const uint32_t *indexArray, uint32_t first, uint32_t num) const
- {
- for (uint32_t j = num - 1, i = 0; i < num; j = i++) {
- if (!canAddEdge(indexArray[first + j], indexArray[first + i])) {
- errorIndex0 = indexArray[first + j];
- errorIndex1 = indexArray[first + i];
- return false;
- }
- }
- // We also have to make sure the face does not have any duplicate edge!
- for (uint32_t i = 0; i < num; i++) {
- int i0 = indexArray[first + i + 0];
- int i1 = indexArray[first + (i + 1) % num];
- for (uint32_t j = i + 1; j < num; j++) {
- int j0 = indexArray[first + j + 0];
- int j1 = indexArray[first + (j + 1) % num];
- if (i0 == j0 && i1 == j1) {
- errorCode = ErrorCode::DuplicateEdge;
- errorIndex0 = i0;
- errorIndex1 = i1;
- return false;
- }
- }
- }
- return true;
- }
+/*
+Fixing T-junctions.
- // Return true if the edge doesn't exist or doesn't have any adjacent face.
- bool canAddEdge(uint32_t i, uint32_t j) const
- {
- if (i == j) {
- // Skip degenerate edges.
- errorCode = ErrorCode::DegenerateEdge;
- return false;
- }
- // Same check, but taking into account colocal vertices.
- const Vertex *v0 = vertexAt(i);
- const Vertex *v1 = vertexAt(j);
- for (Vertex::ConstVertexIterator it(v0->colocals()); !it.isDone(); it.advance()) {
- if (it.current() == v1) {
- // Skip degenerate edges.
- errorCode = ErrorCode::DegenerateColocalEdge;
- return false;
- }
- }
- // Make sure edge has not been added yet.
- Edge *edge = findEdge(i, j);
- // We ignore edges that don't have an adjacent face yet, since this face could become the edge's face.
- if (!(edge == NULL || edge->face == NULL)) {
- errorCode = ErrorCode::AlreadyAddedEdge;
- return false;
- }
- return true;
- }
+- Find T-junctions. Find vertices that are on an edge.
+- This test is approximate.
+- Insert edges on a spatial index to speedup queries.
+- Consider only open edges, that is edges that have no pairs.
+- Consider only vertices on boundaries.
+- Close T-junction.
+- Split edge.
+
+*/
+struct SplitEdge
+{
+ uint32_t edge;
+ float t;
+ uint32_t vertex;
- Edge *addEdge(uint32_t i, uint32_t j)
+ bool operator<(const SplitEdge &other) const
{
- xaAssert(i != j);
- Edge *edge = findEdge(i, j);
- if (edge != NULL) {
- // Edge may already exist, but its face must not be set.
- xaDebugAssert(edge->face == NULL);
- // Nothing else to do!
- } else {
- // Add new edge.
- // Lookup pair.
- Edge *pair = findEdge(j, i);
- if (pair != NULL) {
- // Create edge with same id.
- edge = new Edge(pair->id + 1);
- // Link edge pairs.
- edge->pair = pair;
- pair->pair = edge;
- // @@ I'm not sure this is necessary!
- pair->vertex->setEdge(pair);
- } else {
- // Create edge.
- edge = new Edge(2 * m_edgeArray.size());
- // Add only unpaired edges.
- m_edgeArray.push_back(edge);
- }
- edge->vertex = m_vertexArray[i];
- m_edgeMap[Key(i, j)] = edge;
+ if (edge < other.edge)
+ return true;
+ else if (edge == other.edge) {
+ if (t < other.t)
+ return true;
}
- // Face and Next are set by addFace.
- return edge;
+ return false;
}
+};
- /// Find edge, test all colocals.
- Edge *findEdge(uint32_t i, uint32_t j) const
- {
- Edge *edge = NULL;
- const Vertex *v0 = vertexAt(i);
- const Vertex *v1 = vertexAt(j);
- // Test all colocal pairs.
- for (Vertex::ConstVertexIterator it0(v0->colocals()); !it0.isDone(); it0.advance()) {
- for (Vertex::ConstVertexIterator it1(v1->colocals()); !it1.isDone(); it1.advance()) {
- Key key(it0.current()->id, it1.current()->id);
- if (edge == NULL) {
- auto edgeIt = m_edgeMap.find(key);
- if (edgeIt != m_edgeMap.end())
- edge = (*edgeIt).second;
- #if !defined(_DEBUG)
- if (edge != NULL) return edge;
- #endif
- } else {
- // Make sure that only one edge is found.
- xaDebugAssert(m_edgeMap.find(key) == m_edgeMap.end());
+// Returns nullptr if there were no t-junctions to fix.
+static Mesh *meshFixTJunctions(const Mesh &inputMesh, bool *duplicatedEdge, bool *failed, uint32_t *fixedTJunctionsCount)
+{
+ if (duplicatedEdge)
+ *duplicatedEdge = false;
+ if (failed)
+ *failed = false;
+ Array<SplitEdge> splitEdges;
+ const uint32_t vertexCount = inputMesh.vertexCount();
+ const uint32_t edgeCount = inputMesh.edgeCount();
+ for (uint32_t v = 0; v < vertexCount; v++) {
+ if (!inputMesh.isBoundaryVertex(v))
+ continue;
+ // Find edges that this vertex overlaps with.
+ const Vector3 &pos = inputMesh.position(v);
+ for (uint32_t e = 0; e < edgeCount; e++) {
+ if (!inputMesh.isBoundaryEdge(e))
+ continue;
+ const Vector3 &edgePos1 = inputMesh.position(inputMesh.vertexAt(meshEdgeIndex0(e)));
+ const Vector3 &edgePos2 = inputMesh.position(inputMesh.vertexAt(meshEdgeIndex1(e)));
+ float t;
+ if (!lineIntersectsPoint(pos, edgePos1, edgePos2, &t, inputMesh.epsilon()))
+ continue;
+ SplitEdge splitEdge;
+ splitEdge.edge = e;
+ splitEdge.t = t;
+ splitEdge.vertex = v;
+ splitEdges.push_back(splitEdge);
+ }
+ }
+ if (splitEdges.isEmpty())
+ return nullptr;
+ const uint32_t faceCount = inputMesh.faceCount();
+ Mesh *mesh = XA_NEW(MemTag::Mesh, Mesh, inputMesh.epsilon(), vertexCount + splitEdges.size(), faceCount);
+ for (uint32_t v = 0; v < vertexCount; v++)
+ mesh->addVertex(inputMesh.position(v));
+ Array<uint32_t> indexArray;
+ indexArray.reserve(4);
+ Array<SplitEdge> faceSplitEdges;
+ faceSplitEdges.reserve(4);
+ for (uint32_t f = 0; f < faceCount; f++) {
+ // Find t-junctions in this face.
+ faceSplitEdges.clear();
+ for (uint32_t i = 0; i < splitEdges.size(); i++) {
+ if (meshEdgeFace(splitEdges[i].edge) == f)
+ faceSplitEdges.push_back(splitEdges[i]);
+ }
+ if (!faceSplitEdges.isEmpty()) {
+ // Need to split edges in winding order when a single edge has multiple t-junctions.
+ insertionSort(faceSplitEdges.data(), faceSplitEdges.size());
+ indexArray.clear();
+ for (Mesh::FaceEdgeIterator it(&inputMesh, f); !it.isDone(); it.advance()) {
+ indexArray.push_back(it.vertex0());
+ for (uint32_t se = 0; se < faceSplitEdges.size(); se++) {
+ const SplitEdge &splitEdge = faceSplitEdges[se];
+ if (splitEdge.edge == it.edge())
+ indexArray.push_back(splitEdge.vertex);
}
}
+ if (!meshCloseHole(mesh, indexArray, Vector3(0.0f))) {
+ if (failed)
+ *failed = true;
+ }
+ } else {
+ // No t-junctions in this face. Copy from input mesh.
+ if (mesh->addFace(&inputMesh.indices()[f * 3]) == Mesh::AddFaceResult::DuplicateEdge) {
+ if (duplicatedEdge)
+ *duplicatedEdge = true;
+ }
}
- return edge;
- }
-
- /// Link this boundary edge.
- void linkBoundaryEdge(Edge *edge)
- {
- xaAssert(edge->face == NULL);
- // Make sure next pointer has not been set. @@ We want to be able to relink boundary edges after mesh changes.
- Edge *next = edge;
- while (next->pair->face != NULL) {
- // Get pair prev
- Edge *e = next->pair->next;
- while (e->next != next->pair) {
- e = e->next;
- }
- next = e;
- }
- edge->setNext(next->pair);
- // Adjust vertex edge, so that it's the boundary edge. (required for isBoundary())
- if (edge->vertex->edge != edge) {
- // Multiple boundaries in the same edge.
- edge->vertex->edge = edge;
- }
- }
-
- Vertex *splitBoundaryEdge(Edge *edge, float t, const Vector3 &pos)
- {
- /*
- We want to go from this configuration:
-
- + +
- | ^
- edge |<->| pair
- v |
- + +
-
- To this one:
-
- + +
- | ^
- e0 |<->| p0
- v |
- vertex + +
- | ^
- e1 |<->| p1
- v |
- + +
-
- */
- Edge *pair = edge->pair;
- // Make sure boundaries are linked.
- xaDebugAssert(pair != NULL);
- // Make sure edge is a boundary edge.
- xaDebugAssert(pair->face == NULL);
- // Add new vertex.
- Vertex *vertex = addVertex(pos);
- vertex->nor = lerp(edge->from()->nor, edge->to()->nor, t);
- vertex->tex = lerp(edge->from()->tex, edge->to()->tex, t);
- disconnect(edge);
- disconnect(pair);
- // Add edges.
- Edge *e0 = addEdge(edge->from()->id, vertex->id);
- Edge *p0 = addEdge(vertex->id, pair->to()->id);
- Edge *e1 = addEdge(vertex->id, edge->to()->id);
- Edge *p1 = addEdge(pair->from()->id, vertex->id);
- // Link edges.
- e0->setNext(e1);
- p1->setNext(p0);
- e0->setPrev(edge->prev);
- e1->setNext(edge->next);
- p1->setPrev(pair->prev);
- p0->setNext(pair->next);
- xaDebugAssert(e0->next == e1);
- xaDebugAssert(e1->prev == e0);
- xaDebugAssert(p1->next == p0);
- xaDebugAssert(p0->prev == p1);
- xaDebugAssert(p0->pair == e0);
- xaDebugAssert(e0->pair == p0);
- xaDebugAssert(p1->pair == e1);
- xaDebugAssert(e1->pair == p1);
- // Link faces.
- e0->face = edge->face;
- e1->face = edge->face;
- // Link vertices.
- edge->from()->setEdge(e0);
- vertex->setEdge(e1);
- delete edge;
- delete pair;
- return vertex;
}
+ if (fixedTJunctionsCount)
+ *fixedTJunctionsCount = splitEdges.size();
+ return mesh;
+}
-private:
- std::vector<Vertex *> m_vertexArray;
- std::vector<Edge *> m_edgeArray;
- std::vector<Face *> m_faceArray;
-
- struct Key
- {
- Key() {}
- Key(const Key &k) : p0(k.p0), p1(k.p1) {}
- Key(uint32_t v0, uint32_t v1) : p0(v0), p1(v1) {}
- void operator=(const Key &k)
- {
- p0 = k.p0;
- p1 = k.p1;
- }
- bool operator==(const Key &k) const
- {
- return p0 == k.p0 && p1 == k.p1;
- }
-
- uint32_t p0;
- uint32_t p1;
- };
-
- friend struct Hash<Mesh::Key>;
- std::unordered_map<Key, Edge *, Hash<Key>, Equal<Key> > m_edgeMap;
- uint32_t m_colocalVertexCount;
-};
+// boundaryLoops are the first edges for each boundary loop.
+static void meshGetBoundaryLoops(const Mesh &mesh, Array<uint32_t> &boundaryLoops)
+{
+ const uint32_t edgeCount = mesh.edgeCount();
+ BitArray bitFlags(edgeCount);
+ bitFlags.clearAll();
+ boundaryLoops.clear();
+ // Search for boundary edges. Mark all the edges that belong to the same boundary.
+ for (uint32_t e = 0; e < edgeCount; e++) {
+ if (bitFlags.bitAt(e) || !mesh.isBoundaryEdge(e))
+ continue;
+ for (Mesh::BoundaryEdgeIterator it(&mesh, e); !it.isDone(); it.advance())
+ bitFlags.setBitAt(it.edge());
+ boundaryLoops.push_back(e);
+ }
+}
class MeshTopology
{
public:
MeshTopology(const Mesh *mesh)
{
- buildTopologyInfo(mesh);
- }
-
- /// Determine if the mesh is connected.
- bool isConnected() const
- {
- return m_connectedCount == 1;
- }
-
- /// Determine if the mesh is closed. (Each edge is shared by two faces)
- bool isClosed() const
- {
- return m_boundaryCount == 0;
- }
-
- /// Return true if the mesh has the topology of a disk.
- bool isDisk() const
- {
- return isConnected() && m_boundaryCount == 1/* && m_eulerNumber == 1*/;
- }
-
-private:
- void buildTopologyInfo(const Mesh *mesh)
- {
const uint32_t vertexCount = mesh->colocalVertexCount();
const uint32_t faceCount = mesh->faceCount();
const uint32_t edgeCount = mesh->edgeCount();
- xaPrint( "--- Building mesh topology:\n" );
- std::vector<uint32_t> stack(faceCount);
+ Array<uint32_t> stack(MemTag::Default);
+ stack.reserve(faceCount);
BitArray bitFlags(faceCount);
bitFlags.clearAll();
// Compute connectivity.
- xaPrint( "--- Computing connectivity.\n" );
m_connectedCount = 0;
for (uint32_t f = 0; f < faceCount; f++ ) {
- if ( bitFlags.bitAt(f) == false ) {
+ if (bitFlags.bitAt(f) == false) {
m_connectedCount++;
- stack.push_back( f );
- while ( !stack.empty() ) {
+ stack.push_back(f);
+ while (!stack.isEmpty()) {
const uint32_t top = stack.back();
- xaAssert(top != uint32_t(~0));
+ XA_ASSERT(top != uint32_t(~0));
stack.pop_back();
- if ( bitFlags.bitAt(top) == false ) {
+ if (bitFlags.bitAt(top) == false) {
bitFlags.setBitAt(top);
- const Face *face = mesh->faceAt(top);
- const Edge *firstEdge = face->edge;
- const Edge *edge = firstEdge;
- do {
- const Face *neighborFace = edge->pair->face;
- if (neighborFace != NULL) {
- stack.push_back(neighborFace->id);
- }
- edge = edge->next;
- } while (edge != firstEdge);
+ for (Mesh::FaceEdgeIterator it(mesh, top); !it.isDone(); it.advance()) {
+ const uint32_t oppositeFace = it.oppositeFace();
+ if (oppositeFace != UINT32_MAX)
+ stack.push_back(oppositeFace);
+ }
}
}
}
}
- xaAssert(stack.empty());
- xaPrint( "--- %d connected components.\n", m_connectedCount );
+ XA_ASSERT(stack.isEmpty());
// Count boundary loops.
- xaPrint( "--- Counting boundary loops.\n" );
m_boundaryCount = 0;
bitFlags.resize(edgeCount);
bitFlags.clearAll();
// Don't forget to link the boundary otherwise this won't work.
for (uint32_t e = 0; e < edgeCount; e++) {
- const Edge *startEdge = mesh->edgeAt(e);
- if (startEdge != NULL && startEdge->isBoundary() && bitFlags.bitAt(e) == false) {
- xaDebugAssert(startEdge->face != NULL);
- xaDebugAssert(startEdge->pair->face == NULL);
- startEdge = startEdge->pair;
- m_boundaryCount++;
- const Edge *edge = startEdge;
- do {
- bitFlags.setBitAt(edge->id / 2);
- edge = edge->next;
- } while (startEdge != edge);
- }
- }
- xaPrint("--- %d boundary loops found.\n", m_boundaryCount );
+ if (bitFlags.bitAt(e) || !mesh->isBoundaryEdge(e))
+ continue;
+ m_boundaryCount++;
+ for (Mesh::BoundaryEdgeIterator it(mesh, e); !it.isDone(); it.advance())
+ bitFlags.setBitAt(it.edge());
+ }
// Compute euler number.
m_eulerNumber = vertexCount - edgeCount + faceCount;
- xaPrint("--- Euler number: %d.\n", m_eulerNumber);
// Compute genus. (only valid on closed connected surfaces)
m_genus = -1;
- if ( isClosed() && isConnected() ) {
+ if (isClosed() && isConnected())
m_genus = (2 - m_eulerNumber) / 2;
- xaPrint("--- Genus: %d.\n", m_genus);
- }
+ }
+
+ /// Determine if the mesh is connected.
+ bool isConnected() const
+ {
+ return m_connectedCount == 1;
+ }
+
+ /// Determine if the mesh is closed. (Each edge is shared by two faces)
+ bool isClosed() const
+ {
+ return m_boundaryCount == 0;
+ }
+
+ /// Return true if the mesh has the topology of a disk.
+ bool isDisk() const
+ {
+ return isConnected() && m_boundaryCount == 1/* && m_eulerNumber == 1*/;
}
private:
@@ -2843,702 +3477,313 @@ private:
int m_genus;
};
-float computeSurfaceArea(const halfedge::Mesh *mesh)
-{
- float area = 0;
- for (halfedge::Mesh::ConstFaceIterator it(mesh->faces()); !it.isDone(); it.advance()) {
- const halfedge::Face *face = it.current();
- area += face->area();
- }
- xaDebugAssert(area >= 0);
- return area;
-}
-
-float computeParametricArea(const halfedge::Mesh *mesh)
-{
- float area = 0;
- for (halfedge::Mesh::ConstFaceIterator it(mesh->faces()); !it.isDone(); it.advance()) {
- const halfedge::Face *face = it.current();
- area += face->parametricArea();
- }
- return area;
-}
-
-uint32_t countMeshTriangles(const Mesh *mesh)
-{
- const uint32_t faceCount = mesh->faceCount();
- uint32_t triangleCount = 0;
- for (uint32_t f = 0; f < faceCount; f++) {
- const Face *face = mesh->faceAt(f);
- uint32_t edgeCount = face->edgeCount();
- xaDebugAssert(edgeCount > 2);
- triangleCount += edgeCount - 2;
- }
- return triangleCount;
-}
-
-Mesh *unifyVertices(const Mesh *inputMesh)
-{
- Mesh *mesh = new Mesh;
- // Only add the first colocal.
- const uint32_t vertexCount = inputMesh->vertexCount();
- for (uint32_t v = 0; v < vertexCount; v++) {
- const Vertex *vertex = inputMesh->vertexAt(v);
- if (vertex->isFirstColocal()) {
- mesh->addVertex(vertex->pos);
- }
- }
- std::vector<uint32_t> indexArray;
- // Add new faces pointing to first colocals.
- uint32_t faceCount = inputMesh->faceCount();
- for (uint32_t f = 0; f < faceCount; f++) {
- const Face *face = inputMesh->faceAt(f);
- indexArray.clear();
- for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const Edge *edge = it.current();
- const Vertex *vertex = edge->vertex->firstColocal();
- indexArray.push_back(vertex->id);
- }
- mesh->addFace(indexArray);
- }
- mesh->linkBoundary();
- return mesh;
-}
-
-static bool pointInTriangle(const Vector2 &p, const Vector2 &a, const Vector2 &b, const Vector2 &c)
+struct Progress
{
- return triangleArea(a, b, p) >= 0.00001f &&
- triangleArea(b, c, p) >= 0.00001f &&
- triangleArea(c, a, p) >= 0.00001f;
-}
-
-// This is doing a simple ear-clipping algorithm that skips invalid triangles. Ideally, we should
-// also sort the ears by angle, start with the ones that have the smallest angle and proceed in order.
-Mesh *triangulate(const Mesh *inputMesh)
-{
- Mesh *mesh = new Mesh;
- // Add all vertices.
- const uint32_t vertexCount = inputMesh->vertexCount();
- for (uint32_t v = 0; v < vertexCount; v++) {
- const Vertex *vertex = inputMesh->vertexAt(v);
- mesh->addVertex(vertex->pos);
- }
- std::vector<int> polygonVertices;
- std::vector<float> polygonAngles;
- std::vector<Vector2> polygonPoints;
- const uint32_t faceCount = inputMesh->faceCount();
- for (uint32_t f = 0; f < faceCount; f++) {
- const Face *face = inputMesh->faceAt(f);
- xaDebugAssert(face != NULL);
- const uint32_t edgeCount = face->edgeCount();
- xaDebugAssert(edgeCount >= 3);
- polygonVertices.clear();
- polygonVertices.reserve(edgeCount);
- if (edgeCount == 3) {
- // Simple case for triangles.
- for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const Edge *edge = it.current();
- const Vertex *vertex = edge->vertex;
- polygonVertices.push_back(vertex->id);
- }
- int v0 = polygonVertices[0];
- int v1 = polygonVertices[1];
- int v2 = polygonVertices[2];
- mesh->addFace(v0, v1, v2);
- } else {
- // Build 2D polygon projecting vertices onto normal plane.
- // Faces are not necesarily planar, this is for example the case, when the face comes from filling a hole. In such cases
- // it's much better to use the best fit plane.
- const Vector3 fn = face->normal();
- Basis basis;
- basis.buildFrameForDirection(fn);
- polygonPoints.clear();
- polygonPoints.reserve(edgeCount);
- polygonAngles.clear();
- polygonAngles.reserve(edgeCount);
- for (Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const Edge *edge = it.current();
- const Vertex *vertex = edge->vertex;
- polygonVertices.push_back(vertex->id);
- Vector2 p;
- p.x = dot(basis.tangent, vertex->pos);
- p.y = dot(basis.bitangent, vertex->pos);
- polygonPoints.push_back(p);
- }
- polygonAngles.resize(edgeCount);
- while (polygonVertices.size() > 2) {
- uint32_t size = polygonVertices.size();
- // Update polygon angles. @@ Update only those that have changed.
- float minAngle = 2 * PI;
- uint32_t bestEar = 0; // Use first one if none of them is valid.
- bool bestIsValid = false;
- for (uint32_t i = 0; i < size; i++) {
- uint32_t i0 = i;
- uint32_t i1 = (i + 1) % size; // Use Sean's polygon interation trick.
- uint32_t i2 = (i + 2) % size;
- Vector2 p0 = polygonPoints[i0];
- Vector2 p1 = polygonPoints[i1];
- Vector2 p2 = polygonPoints[i2];
-
- // -- GODOT start --
- bool degenerate = distance(p0, p1) < NV_EPSILON || distance(p0, p2) < NV_EPSILON || distance(p1, p2) < NV_EPSILON;
- if (degenerate) {
- continue;
- }
- // -- GODOT end --
-
- float d = clamp(dot(p0 - p1, p2 - p1) / (length(p0 - p1) * length(p2 - p1)), -1.0f, 1.0f);
- float angle = acosf(d);
- float area = triangleArea(p0, p1, p2);
- if (area < 0.0f) angle = 2.0f * PI - angle;
- polygonAngles[i1] = angle;
- if (angle < minAngle || !bestIsValid) {
- // Make sure this is a valid ear, if not, skip this point.
- bool valid = true;
- for (uint32_t j = 0; j < size; j++) {
- if (j == i0 || j == i1 || j == i2) continue;
- Vector2 p = polygonPoints[j];
- if (pointInTriangle(p, p0, p1, p2)) {
- valid = false;
- break;
- }
- }
- if (valid || !bestIsValid) {
- minAngle = angle;
- bestEar = i1;
- bestIsValid = valid;
- }
- }
- }
- // -- GODOT start --
- if (!bestIsValid)
- break;
- // -- GODOT end --
-
- xaDebugAssert(minAngle <= 2 * PI);
- // Clip best ear:
- uint32_t i0 = (bestEar + size - 1) % size;
- uint32_t i1 = (bestEar + 0) % size;
- uint32_t i2 = (bestEar + 1) % size;
- int v0 = polygonVertices[i0];
- int v1 = polygonVertices[i1];
- int v2 = polygonVertices[i2];
- mesh->addFace(v0, v1, v2);
- polygonVertices.erase(polygonVertices.begin() + i1);
- polygonPoints.erase(polygonPoints.begin() + i1);
- polygonAngles.erase(polygonAngles.begin() + i1);
- }
- }
- }
- mesh->linkBoundary();
- return mesh;
-}
-
-} // namespace halfedge
-
-/// Mersenne twister random number generator.
-class MTRand
-{
-public:
- enum time_e { Time };
- enum { N = 624 }; // length of state vector
- enum { M = 397 };
-
- /// Constructor that uses the current time as the seed.
- MTRand( time_e )
+ Progress(ProgressCategory::Enum category, ProgressFunc func, void *userData, uint32_t maxValue) : value(0), cancel(false), m_category(category), m_func(func), m_userData(userData), m_maxValue(maxValue), m_progress(0)
{
- seed((uint32_t )time(NULL));
- }
-
- /// Constructor that uses the given seed.
- MTRand( uint32_t s = 0 )
- {
- seed(s);
- }
-
- /// Provide a new seed.
- void seed( uint32_t s )
- {
- initialize(s);
- reload();
+ if (m_func) {
+ if (!m_func(category, 0, userData))
+ cancel = true;
+ }
}
- /// Get a random number between 0 - 65536.
- uint32_t get()
+ ~Progress()
{
- // Pull a 32-bit integer from the generator state
- // Every other access function simply transforms the numbers extracted here
- if ( left == 0 ) {
- reload();
+ if (m_func) {
+ if (!m_func(m_category, 100, m_userData))
+ cancel = true;
}
- left--;
- uint32_t s1;
- s1 = *next++;
- s1 ^= (s1 >> 11);
- s1 ^= (s1 << 7) & 0x9d2c5680U;
- s1 ^= (s1 << 15) & 0xefc60000U;
- return ( s1 ^ (s1 >> 18) );
- };
-
- /// Get a random number on [0, max] interval.
- uint32_t getRange( uint32_t max )
- {
- if (max == 0) return 0;
- if (max == NV_UINT32_MAX) return get();
- const uint32_t np2 = nextPowerOfTwo( max + 1 ); // @@ This fails if max == NV_UINT32_MAX
- const uint32_t mask = np2 - 1;
- uint32_t n;
- do {
- n = get() & mask;
- } while ( n > max );
- return n;
}
-private:
- void initialize( uint32_t seed )
+ void update()
{
- // Initialize generator state with seed
- // See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
- // In previous versions, most significant bits (MSBs) of the seed affect
- // only MSBs of the state array. Modified 9 Jan 2002 by Makoto Matsumoto.
- uint32_t *s = state;
- uint32_t *r = state;
- int i = 1;
- *s++ = seed & 0xffffffffUL;
- for ( ; i < N; ++i ) {
- *s++ = ( 1812433253UL * ( *r ^ (*r >> 30) ) + i ) & 0xffffffffUL;
- r++;
+ if (!m_func)
+ return;
+ m_mutex.lock();
+ const uint32_t newProgress = uint32_t(ceilf(value.load() / (float)m_maxValue * 100.0f));
+ if (newProgress != m_progress && newProgress < 100) {
+ m_progress = newProgress;
+ if (!m_func(m_category, m_progress, m_userData))
+ cancel = true;
}
+ m_mutex.unlock();
}
- void reload()
+ void setMaxValue(uint32_t maxValue)
{
- // Generate N new values in state
- // Made clearer and faster by Matthew Bellew (matthew.bellew@home.com)
- uint32_t *p = state;
- int i;
- for ( i = N - M; i--; ++p )
- *p = twist( p[M], p[0], p[1] );
- for ( i = M; --i; ++p )
- *p = twist( p[M - N], p[0], p[1] );
- *p = twist( p[M - N], p[0], state[0] );
- left = N, next = state;
+ m_mutex.lock();
+ m_maxValue = maxValue;
+ m_mutex.unlock();
}
- uint32_t hiBit( uint32_t u ) const
- {
- return u & 0x80000000U;
- }
- uint32_t loBit( uint32_t u ) const
- {
- return u & 0x00000001U;
- }
- uint32_t loBits( uint32_t u ) const
- {
- return u & 0x7fffffffU;
- }
- uint32_t mixBits( uint32_t u, uint32_t v ) const
- {
- return hiBit(u) | loBits(v);
- }
- uint32_t twist( uint32_t m, uint32_t s0, uint32_t s1 ) const
- {
- return m ^ (mixBits(s0, s1) >> 1) ^ ((~loBit(s1) + 1) & 0x9908b0dfU);
- }
+ std::atomic<uint32_t> value;
+ std::atomic<bool> cancel;
- uint32_t state[N]; // internal state
- uint32_t *next; // next value to get from state
- int left; // number of values left before reload needed
+private:
+ ProgressCategory::Enum m_category;
+ ProgressFunc m_func;
+ void *m_userData;
+ uint32_t m_maxValue;
+ uint32_t m_progress;
+ std::mutex m_mutex;
};
-namespace morton {
-// Code from ryg:
-// http://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
-
-// Inverse of part1By1 - "delete" all odd-indexed bits
-uint32_t compact1By1(uint32_t x)
-{
- x &= 0x55555555; // x = -f-e -d-c -b-a -9-8 -7-6 -5-4 -3-2 -1-0
- x = (x ^ (x >> 1)) & 0x33333333; // x = --fe --dc --ba --98 --76 --54 --32 --10
- x = (x ^ (x >> 2)) & 0x0f0f0f0f; // x = ---- fedc ---- ba98 ---- 7654 ---- 3210
- x = (x ^ (x >> 4)) & 0x00ff00ff; // x = ---- ---- fedc ba98 ---- ---- 7654 3210
- x = (x ^ (x >> 8)) & 0x0000ffff; // x = ---- ---- ---- ---- fedc ba98 7654 3210
- return x;
-}
-
-// Inverse of part1By2 - "delete" all bits not at positions divisible by 3
-uint32_t compact1By2(uint32_t x)
-{
- x &= 0x09249249; // x = ---- 9--8 --7- -6-- 5--4 --3- -2-- 1--0
- x = (x ^ (x >> 2)) & 0x030c30c3; // x = ---- --98 ---- 76-- --54 ---- 32-- --10
- x = (x ^ (x >> 4)) & 0x0300f00f; // x = ---- --98 ---- ---- 7654 ---- ---- 3210
- x = (x ^ (x >> 8)) & 0xff0000ff; // x = ---- --98 ---- ---- ---- ---- 7654 3210
- x = (x ^ (x >> 16)) & 0x000003ff; // x = ---- ---- ---- ---- ---- --98 7654 3210
- return x;
-}
-
-uint32_t decodeMorton2X(uint32_t code)
-{
- return compact1By1(code >> 0);
-}
-
-uint32_t decodeMorton2Y(uint32_t code)
-{
- return compact1By1(code >> 1);
-}
-
-uint32_t decodeMorton3X(uint32_t code)
+struct TaskGroupHandle
{
- return compact1By2(code >> 0);
-}
+ uint32_t value = UINT32_MAX;
+};
-uint32_t decodeMorton3Y(uint32_t code)
+struct Task
{
- return compact1By2(code >> 1);
-}
+ void (*func)(void *userData);
+ void *userData;
+};
-uint32_t decodeMorton3Z(uint32_t code)
+#if XA_MULTITHREADED
+class TaskScheduler
{
- return compact1By2(code >> 2);
-}
-} // namespace morton
-
-// A simple, dynamic proximity grid based on Jon's code.
-// Instead of storing pointers here I store indices.
-struct ProximityGrid
-{
- void init(const Box &box, uint32_t count)
- {
- cellArray.clear();
- // Determine grid size.
- float cellWidth;
- Vector3 diagonal = box.extents() * 2.f;
- float volume = box.volume();
- if (equal(volume, 0)) {
- // Degenerate box, treat like a quad.
- Vector2 quad;
- if (diagonal.x < diagonal.y && diagonal.x < diagonal.z) {
- quad.x = diagonal.y;
- quad.y = diagonal.z;
- } else if (diagonal.y < diagonal.x && diagonal.y < diagonal.z) {
- quad.x = diagonal.x;
- quad.y = diagonal.z;
- } else {
- quad.x = diagonal.x;
- quad.y = diagonal.y;
- }
- float cellArea = quad.x * quad.y / count;
- cellWidth = sqrtf(cellArea); // pow(cellArea, 1.0f / 2.0f);
- } else {
- // Ideally we want one cell per point.
- float cellVolume = volume / count;
- cellWidth = powf(cellVolume, 1.0f / 3.0f);
+public:
+ TaskScheduler() : m_shutdown(false)
+ {
+ m_workers.resize(std::thread::hardware_concurrency() <= 1 ? 1 : std::thread::hardware_concurrency() - 1);
+ for (uint32_t i = 0; i < m_workers.size(); i++) {
+ m_workers[i].wakeup = false;
+ m_workers[i].thread = XA_NEW(MemTag::Default, std::thread, workerThread, this, &m_workers[i]);
}
- xaDebugAssert(cellWidth != 0);
- sx = std::max(1, ftoi_ceil(diagonal.x / cellWidth));
- sy = std::max(1, ftoi_ceil(diagonal.y / cellWidth));
- sz = std::max(1, ftoi_ceil(diagonal.z / cellWidth));
- invCellSize.x = float(sx) / diagonal.x;
- invCellSize.y = float(sy) / diagonal.y;
- invCellSize.z = float(sz) / diagonal.z;
- cellArray.resize(sx * sy * sz);
- corner = box.minCorner; // @@ Align grid better?
}
- int index_x(float x) const
+ ~TaskScheduler()
{
- return clamp(ftoi_floor((x - corner.x) * invCellSize.x), 0, sx - 1);
+ m_shutdown = true;
+ for (uint32_t i = 0; i < m_workers.size(); i++) {
+ Worker &worker = m_workers[i];
+ XA_DEBUG_ASSERT(worker.thread);
+ worker.wakeup = true;
+ worker.cv.notify_one();
+ if (worker.thread->joinable())
+ worker.thread->join();
+ worker.thread->~thread();
+ XA_FREE(worker.thread);
+ }
+ for (uint32_t i = 0; i < m_groups.size(); i++)
+ destroyGroup(i);
}
- int index_y(float y) const
+ void run(TaskGroupHandle *handle, Task task)
{
- return clamp(ftoi_floor((y - corner.y) * invCellSize.y), 0, sy - 1);
+ // Allocate a task group if this is the first time using this handle.
+ TaskGroup *group;
+ if (handle->value == UINT32_MAX) {
+ group = XA_NEW(MemTag::Default, TaskGroup);
+ group->ref = 0;
+ std::lock_guard<std::mutex> lock(m_groupsMutex);
+ for (uint32_t i = 0; i < m_groups.size(); i++) {
+ if (!m_groups[i]) {
+ m_groups[i] = group;
+ handle->value = i;
+ break;
+ }
+ }
+ if (handle->value == UINT32_MAX) {
+ m_groups.push_back(group);
+ handle->value = m_groups.size() - 1;
+ }
+ }
+ group = m_groups[handle->value];
+ {
+ std::lock_guard<std::mutex> lock(group->queueMutex);
+ group->queue.push_back(task);
+ }
+ group->ref++;
+ // Wake up a worker to run this task.
+ for (uint32_t i = 0; i < m_workers.size(); i++) {
+ m_workers[i].wakeup = true;
+ m_workers[i].cv.notify_one();
+ }
}
- int index_z(float z) const
+ void wait(TaskGroupHandle *handle)
{
- return clamp(ftoi_floor((z - corner.z) * invCellSize.z), 0, sz - 1);
+ if (handle->value == UINT32_MAX) {
+ XA_DEBUG_ASSERT(false);
+ return;
+ }
+ // Run tasks from the group queue until empty.
+ TaskGroup *group = m_groups[handle->value];
+ for (;;) {
+ Task *task = nullptr;
+ {
+ std::lock_guard<std::mutex> lock(group->queueMutex);
+ if (group->queueHead < group->queue.size())
+ task = &group->queue[group->queueHead++];
+ }
+ if (!task)
+ break;
+ task->func(task->userData);
+ group->ref--;
+ }
+ // Even though the task queue is empty, workers can still be running tasks.
+ while (group->ref > 0)
+ std::this_thread::yield();
+ std::lock_guard<std::mutex> lock(m_groupsMutex);
+ destroyGroup(handle->value);
+ handle->value = UINT32_MAX;
}
- int index(int x, int y, int z) const
+private:
+ struct TaskGroup
{
- xaDebugAssert(x >= 0 && x < sx);
- xaDebugAssert(y >= 0 && y < sy);
- xaDebugAssert(z >= 0 && z < sz);
- int idx = (z * sy + y) * sx + x;
- xaDebugAssert(idx >= 0 && uint32_t(idx) < cellArray.size());
- return idx;
- }
+ Array<Task> queue; // Items are never removed. queueHead is incremented to pop items.
+ uint32_t queueHead = 0;
+ std::mutex queueMutex;
+ std::atomic<uint32_t> ref; // Increment when a task is enqueued, decrement when a task finishes.
+ };
- uint32_t mortonCount() const
+ struct Worker
{
- uint64_t s = uint64_t(max3(sx, sy, sz));
- s = nextPowerOfTwo(s);
- if (s > 1024) {
- return uint32_t(s * s * min3(sx, sy, sz));
- }
- return uint32_t(s * s * s);
- }
+ std::thread *thread = nullptr;
+ std::mutex mutex;
+ std::condition_variable cv;
+ std::atomic<bool> wakeup;
+ };
- int mortonIndex(uint32_t code) const
- {
- uint32_t x, y, z;
- uint32_t s = uint32_t(max3(sx, sy, sz));
- if (s > 1024) {
- // Use layered two-dimensional morton order.
- s = nextPowerOfTwo(s);
- uint32_t layer = code / (s * s);
- code = code % (s * s);
- uint32_t layer_count = uint32_t(min3(sx, sy, sz));
- if (sx == (int)layer_count) {
- x = layer;
- y = morton::decodeMorton2X(code);
- z = morton::decodeMorton2Y(code);
- } else if (sy == (int)layer_count) {
- x = morton::decodeMorton2Y(code);
- y = layer;
- z = morton::decodeMorton2X(code);
- } else { /*if (sz == layer_count)*/
- x = morton::decodeMorton2X(code);
- y = morton::decodeMorton2Y(code);
- z = layer;
- }
- } else {
- x = morton::decodeMorton3X(code);
- y = morton::decodeMorton3Y(code);
- z = morton::decodeMorton3Z(code);
- }
- if (x >= uint32_t(sx) || y >= uint32_t(sy) || z >= uint32_t(sz)) {
- return -1;
- }
- return index(x, y, z);
- }
+ Array<TaskGroup *> m_groups;
+ std::mutex m_groupsMutex;
+ Array<Worker> m_workers;
+ std::atomic<bool> m_shutdown;
- void add(const Vector3 &pos, uint32_t key)
+ void destroyGroup(uint32_t index)
{
- int x = index_x(pos.x);
- int y = index_y(pos.y);
- int z = index_z(pos.z);
- uint32_t idx = index(x, y, z);
- cellArray[idx].indexArray.push_back(key);
+ TaskGroup *group = m_groups[index];
+ m_groups[index] = nullptr;
+ if (group) {
+ group->~TaskGroup();
+ XA_FREE(group);
+ }
}
- // Gather all points inside the given sphere.
- // Radius is assumed to be small, so we don't bother culling the cells.
- void gather(const Vector3 &position, float radius, std::vector<uint32_t> &indexArray)
+ static void workerThread(TaskScheduler *scheduler, Worker *worker)
{
- int x0 = index_x(position.x - radius);
- int x1 = index_x(position.x + radius);
- int y0 = index_y(position.y - radius);
- int y1 = index_y(position.y + radius);
- int z0 = index_z(position.z - radius);
- int z1 = index_z(position.z + radius);
- for (int z = z0; z <= z1; z++) {
- for (int y = y0; y <= y1; y++) {
- for (int x = x0; x <= x1; x++) {
- int idx = index(x, y, z);
- indexArray.insert(indexArray.begin(), cellArray[idx].indexArray.begin(), cellArray[idx].indexArray.end());
+ std::unique_lock<std::mutex> lock(worker->mutex);
+ for (;;) {
+ worker->cv.wait(lock, [=]{ return worker->wakeup.load(); });
+ worker->wakeup = false;
+ for (;;) {
+ if (scheduler->m_shutdown)
+ return;
+ // Look for a task in any of the groups and run it.
+ TaskGroup *group = nullptr;
+ Task *task = nullptr;
+ {
+ std::lock_guard<std::mutex> groupsLock(scheduler->m_groupsMutex);
+ for (uint32_t i = 0; i < scheduler->m_groups.size(); i++) {
+ group = scheduler->m_groups[i];
+ if (!group)
+ continue;
+ std::lock_guard<std::mutex> queueLock(group->queueMutex);
+ if (group->queueHead < group->queue.size()) {
+ task = &group->queue[group->queueHead++];
+ break;
+ }
+ }
}
+ if (!task)
+ break;
+ task->func(task->userData);
+ group->ref--;
}
}
}
-
- struct Cell {
- std::vector<uint32_t> indexArray;
- };
-
- std::vector<Cell> cellArray;
-
- Vector3 corner;
- Vector3 invCellSize;
- int sx, sy, sz;
};
-
-// Based on Pierre Terdiman's and Michael Herf's source code.
-// http://www.codercorner.com/RadixSortRevisited.htm
-// http://www.stereopsis.com/radix.html
-class RadixSort
+#else
+class TaskScheduler
{
public:
- RadixSort() : m_size(0), m_ranks(NULL), m_ranks2(NULL), m_validRanks(false) {}
- ~RadixSort()
+ ~TaskScheduler()
{
- // Release everything
- free(m_ranks2);
- free(m_ranks);
+ for (uint32_t i = 0; i < m_groups.size(); i++)
+ destroyGroup({ i });
}
- RadixSort &sort(const float *input, uint32_t count)
+ void run(TaskGroupHandle *handle, Task task)
{
- if (input == NULL || count == 0) return *this;
- // Resize lists if needed
- if (count != m_size) {
- if (count > m_size) {
- m_ranks2 = (uint32_t *)realloc(m_ranks2, sizeof(uint32_t ) * count);
- m_ranks = (uint32_t *)realloc(m_ranks, sizeof(uint32_t ) * count);
- }
- m_size = count;
- m_validRanks = false;
- }
- if (count < 32) {
- insertionSort(input, count);
- } else {
- // @@ Avoid touching the input multiple times.
- for (uint32_t i = 0; i < count; i++) {
- FloatFlip((uint32_t &)input[i]);
+ if (handle->value == UINT32_MAX) {
+ TaskGroup *group = XA_NEW(MemTag::Default, TaskGroup);
+ for (uint32_t i = 0; i < m_groups.size(); i++) {
+ if (!m_groups[i]) {
+ m_groups[i] = group;
+ handle->value = i;
+ break;
+ }
}
- radixSort<uint32_t>((const uint32_t *)input, count);
- for (uint32_t i = 0; i < count; i++) {
- IFloatFlip((uint32_t &)input[i]);
+ if (handle->value == UINT32_MAX) {
+ m_groups.push_back(group);
+ handle->value = m_groups.size() - 1;
}
}
- return *this;
+ m_groups[handle->value]->queue.push_back(task);
}
- RadixSort &sort(const std::vector<float> &input)
+ void wait(TaskGroupHandle *handle)
{
- return sort(input.data(), input.size());
- }
-
- // Access to results. m_ranks is a list of indices in sorted order, i.e. in the order you may further process your data
- const uint32_t *ranks() const
- {
- xaDebugAssert(m_validRanks);
- return m_ranks;
- }
- uint32_t *ranks()
- {
- xaDebugAssert(m_validRanks);
- return m_ranks;
+ if (handle->value == UINT32_MAX) {
+ XA_DEBUG_ASSERT(false);
+ return;
+ }
+ TaskGroup *group = m_groups[handle->value];
+ for (uint32_t i = 0; i < group->queue.size(); i++)
+ group->queue[i].func(group->queue[i].userData);
+ group->queue.clear();
+ destroyGroup(*handle);
+ handle->value = UINT32_MAX;
}
private:
- uint32_t m_size;
- uint32_t *m_ranks;
- uint32_t *m_ranks2;
- bool m_validRanks;
-
- void FloatFlip(uint32_t &f)
+ void destroyGroup(TaskGroupHandle handle)
{
- int32_t mask = (int32_t(f) >> 31) | 0x80000000; // Warren Hunt, Manchor Ko.
- f ^= mask;
+ TaskGroup *group = m_groups[handle.value];
+ if (group) {
+ group->~TaskGroup();
+ XA_FREE(group);
+ m_groups[handle.value] = nullptr;
+ }
}
- void IFloatFlip(uint32_t &f)
+ struct TaskGroup
{
- uint32_t mask = ((f >> 31) - 1) | 0x80000000; // Michael Herf.
- f ^= mask;
- }
+ Array<Task> queue;
+ };
- template<typename T>
- void createHistograms(const T *buffer, uint32_t count, uint32_t *histogram)
- {
- const uint32_t bucketCount = sizeof(T); // (8 * sizeof(T)) / log2(radix)
- // Init bucket pointers.
- uint32_t *h[bucketCount];
- for (uint32_t i = 0; i < bucketCount; i++) {
- h[i] = histogram + 256 * i;
- }
- // Clear histograms.
- memset(histogram, 0, 256 * bucketCount * sizeof(uint32_t ));
- // @@ Add support for signed integers.
- // Build histograms.
- const uint8_t *p = (const uint8_t *)buffer; // @@ Does this break aliasing rules?
- const uint8_t *pe = p + count * sizeof(T);
- while (p != pe) {
- h[0][*p++]++, h[1][*p++]++, h[2][*p++]++, h[3][*p++]++;
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4127)
-#endif
- if (bucketCount == 8) h[4][*p++]++, h[5][*p++]++, h[6][*p++]++, h[7][*p++]++;
-#ifdef _MSC_VER
-#pragma warning(pop)
+ Array<TaskGroup *> m_groups;
+};
#endif
- }
- }
- template <typename T> void insertionSort(const T *input, uint32_t count)
- {
- if (!m_validRanks) {
- m_ranks[0] = 0;
- for (uint32_t i = 1; i != count; ++i) {
- int rank = m_ranks[i] = i;
- uint32_t j = i;
- while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
- m_ranks[j] = m_ranks[j - 1];
- --j;
- }
- if (i != j) {
- m_ranks[j] = rank;
- }
- }
- m_validRanks = true;
- } else {
- for (uint32_t i = 1; i != count; ++i) {
- int rank = m_ranks[i];
- uint32_t j = i;
- while (j != 0 && input[rank] < input[m_ranks[j - 1]]) {
- m_ranks[j] = m_ranks[j - 1];
- --j;
- }
- if (i != j) {
- m_ranks[j] = rank;
- }
- }
- }
- }
+struct UvMeshChart
+{
+ Array<uint32_t> indices;
+ uint32_t material;
+};
- template <typename T> void radixSort(const T *input, uint32_t count)
- {
- const uint32_t P = sizeof(T); // pass count
- // Allocate histograms & offsets on the stack
- uint32_t histogram[256 * P];
- uint32_t *link[256];
- createHistograms(input, count, histogram);
- // Radix sort, j is the pass number (0=LSB, P=MSB)
- for (uint32_t j = 0; j < P; j++) {
- // Pointer to this bucket.
- const uint32_t *h = &histogram[j * 256];
- const uint8_t *inputBytes = (const uint8_t *)input; // @@ Is this aliasing legal?
- inputBytes += j;
- if (h[inputBytes[0]] == count) {
- // Skip this pass, all values are the same.
- continue;
- }
- // Create offsets
- link[0] = m_ranks2;
- for (uint32_t i = 1; i < 256; i++) link[i] = link[i - 1] + h[i - 1];
- // Perform Radix Sort
- if (!m_validRanks) {
- for (uint32_t i = 0; i < count; i++) {
- *link[inputBytes[i * P]]++ = i;
- }
- m_validRanks = true;
- } else {
- for (uint32_t i = 0; i < count; i++) {
- const uint32_t idx = m_ranks[i];
- *link[inputBytes[idx * P]]++ = idx;
- }
- }
- // Swap pointers for next pass. Valid indices - the most recent ones - are in m_ranks after the swap.
- std::swap(m_ranks, m_ranks2);
- }
- // All values were equal, generate linear ranks.
- if (!m_validRanks) {
- for (uint32_t i = 0; i < count; i++) {
- m_ranks[i] = i;
- }
- m_validRanks = true;
- }
- }
+struct UvMesh
+{
+ UvMeshDecl decl;
+ Array<uint32_t> indices;
+ Array<UvMeshChart *> charts;
+ Array<uint32_t> vertexToChartMap;
+};
+
+struct UvMeshInstance
+{
+ UvMesh *mesh;
+ Array<Vector2> texcoords;
+ bool rotateCharts;
};
namespace raster {
class ClippedTriangle
{
public:
- ClippedTriangle(Vector2::Arg a, Vector2::Arg b, Vector2::Arg c)
+ ClippedTriangle(const Vector2 &a, const Vector2 &b, const Vector2 &c)
{
m_numVertices = 3;
m_activeVertexBuffer = 0;
@@ -3549,16 +3794,6 @@ public:
m_vertexBuffers[1] = m_verticesB;
}
- uint32_t vertexCount()
- {
- return m_numVertices;
- }
-
- const Vector2 *vertices()
- {
- return m_vertexBuffers[m_activeVertexBuffer];
- }
-
void clipHorizontalPlane(float offset, float clipdirection)
{
Vector2 *v = m_vertexBuffers[m_activeVertexBuffer];
@@ -3581,7 +3816,6 @@ public:
dy1in = dy2in;
}
m_numVertices = p;
- //for (uint32_t k=0; k<m_numVertices; k++) printf("(%f, %f)\n", v2[k].x, v2[k].y); printf("\n");
}
void clipVerticalPlane(float offset, float clipdirection )
@@ -3608,7 +3842,7 @@ public:
m_numVertices = p;
}
- void computeAreaCentroid()
+ void computeArea()
{
Vector2 *v = m_vertexBuffers[m_activeVertexBuffer];
v[m_numVertices] = v[0];
@@ -3622,25 +3856,15 @@ public:
centroidy += f * (v[k].y + v[k + 1].y);
}
m_area = 0.5f * fabsf(m_area);
- if (m_area == 0) {
- m_centroid = Vector2(0.0f);
- } else {
- m_centroid = Vector2(centroidx / (6 * m_area), centroidy / (6 * m_area));
- }
}
void clipAABox(float x0, float y0, float x1, float y1)
{
- clipVerticalPlane ( x0, -1);
- clipHorizontalPlane( y0, -1);
- clipVerticalPlane ( x1, 1);
- clipHorizontalPlane( y1, 1);
- computeAreaCentroid();
- }
-
- Vector2 centroid()
- {
- return m_centroid;
+ clipVerticalPlane(x0, -1);
+ clipHorizontalPlane(y0, -1);
+ clipVerticalPlane(x1, 1);
+ clipHorizontalPlane(y1, 1);
+ computeArea();
}
float area()
@@ -3652,212 +3876,50 @@ private:
Vector2 m_verticesA[7 + 1];
Vector2 m_verticesB[7 + 1];
Vector2 *m_vertexBuffers[2];
- uint32_t m_numVertices;
- uint32_t m_activeVertexBuffer;
- float m_area;
- Vector2 m_centroid;
+ uint32_t m_numVertices;
+ uint32_t m_activeVertexBuffer;
+ float m_area;
};
/// A callback to sample the environment. Return false to terminate rasterization.
-typedef bool (* SamplingCallback)(void *param, int x, int y, Vector3::Arg bar, Vector3::Arg dx, Vector3::Arg dy, float coverage);
+typedef bool (*SamplingCallback)(void *param, int x, int y);
/// A triangle for rasterization.
struct Triangle
{
- Triangle(Vector2::Arg v0, Vector2::Arg v1, Vector2::Arg v2, Vector3::Arg t0, Vector3::Arg t1, Vector3::Arg t2)
+ Triangle(const Vector2 &v0, const Vector2 &v1, const Vector2 &v2)
{
// Init vertices.
this->v1 = v0;
this->v2 = v2;
this->v3 = v1;
- // Set barycentric coordinates.
- this->t1 = t0;
- this->t2 = t2;
- this->t3 = t1;
// make sure every triangle is front facing.
flipBackface();
// Compute deltas.
- valid = computeDeltas();
computeUnitInwardNormals();
}
- /// Compute texture space deltas.
- /// This method takes two edge vectors that form a basis, determines the
- /// coordinates of the canonic vectors in that basis, and computes the
- /// texture gradient that corresponds to those vectors.
- bool computeDeltas()
+ bool isValid()
{
- Vector2 e0 = v3 - v1;
- Vector2 e1 = v2 - v1;
- Vector3 de0 = t3 - t1;
- Vector3 de1 = t2 - t1;
- float denom = 1.0f / (e0.y * e1.x - e1.y * e0.x);
- if (!std::isfinite(denom)) {
- return false;
- }
- float lambda1 = - e1.y * denom;
- float lambda2 = e0.y * denom;
- float lambda3 = e1.x * denom;
- float lambda4 = - e0.x * denom;
- dx = de0 * lambda1 + de1 * lambda2;
- dy = de0 * lambda3 + de1 * lambda4;
- return true;
- }
-
- bool draw(const Vector2 &extents, bool enableScissors, SamplingCallback cb, void *param)
- {
- // 28.4 fixed-point coordinates
- const int Y1 = ftoi_round(16.0f * v1.y);
- const int Y2 = ftoi_round(16.0f * v2.y);
- const int Y3 = ftoi_round(16.0f * v3.y);
- const int X1 = ftoi_round(16.0f * v1.x);
- const int X2 = ftoi_round(16.0f * v2.x);
- const int X3 = ftoi_round(16.0f * v3.x);
- // Deltas
- const int DX12 = X1 - X2;
- const int DX23 = X2 - X3;
- const int DX31 = X3 - X1;
- const int DY12 = Y1 - Y2;
- const int DY23 = Y2 - Y3;
- const int DY31 = Y3 - Y1;
- // Fixed-point deltas
- const int FDX12 = DX12 << 4;
- const int FDX23 = DX23 << 4;
- const int FDX31 = DX31 << 4;
- const int FDY12 = DY12 << 4;
- const int FDY23 = DY23 << 4;
- const int FDY31 = DY31 << 4;
- int minx, miny, maxx, maxy;
- if (enableScissors) {
- int frustumX0 = 0 << 4;
- int frustumY0 = 0 << 4;
- int frustumX1 = (int)extents.x << 4;
- int frustumY1 = (int)extents.y << 4;
- // Bounding rectangle
- minx = (std::max(min3(X1, X2, X3), frustumX0) + 0xF) >> 4;
- miny = (std::max(min3(Y1, Y2, Y3), frustumY0) + 0xF) >> 4;
- maxx = (std::min(max3(X1, X2, X3), frustumX1) + 0xF) >> 4;
- maxy = (std::min(max3(Y1, Y2, Y3), frustumY1) + 0xF) >> 4;
- } else {
- // Bounding rectangle
- minx = (min3(X1, X2, X3) + 0xF) >> 4;
- miny = (min3(Y1, Y2, Y3) + 0xF) >> 4;
- maxx = (max3(X1, X2, X3) + 0xF) >> 4;
- maxy = (max3(Y1, Y2, Y3) + 0xF) >> 4;
- }
- // Block size, standard 8x8 (must be power of two)
- const int q = 8;
- // @@ This won't work when minx,miny are negative. This code path is not used. Leaving as is for now.
- xaAssert(minx >= 0);
- xaAssert(miny >= 0);
- // Start in corner of 8x8 block
- minx &= ~(q - 1);
- miny &= ~(q - 1);
- // Half-edge constants
- int C1 = DY12 * X1 - DX12 * Y1;
- int C2 = DY23 * X2 - DX23 * Y2;
- int C3 = DY31 * X3 - DX31 * Y3;
- // Correct for fill convention
- if (DY12 < 0 || (DY12 == 0 && DX12 > 0)) C1++;
- if (DY23 < 0 || (DY23 == 0 && DX23 > 0)) C2++;
- if (DY31 < 0 || (DY31 == 0 && DX31 > 0)) C3++;
- // Loop through blocks
- for (int y = miny; y < maxy; y += q) {
- for (int x = minx; x < maxx; x += q) {
- // Corners of block
- int x0 = x << 4;
- int x1 = (x + q - 1) << 4;
- int y0 = y << 4;
- int y1 = (y + q - 1) << 4;
- // Evaluate half-space functions
- bool a00 = C1 + DX12 * y0 - DY12 * x0 > 0;
- bool a10 = C1 + DX12 * y0 - DY12 * x1 > 0;
- bool a01 = C1 + DX12 * y1 - DY12 * x0 > 0;
- bool a11 = C1 + DX12 * y1 - DY12 * x1 > 0;
- int a = (a00 << 0) | (a10 << 1) | (a01 << 2) | (a11 << 3);
- bool b00 = C2 + DX23 * y0 - DY23 * x0 > 0;
- bool b10 = C2 + DX23 * y0 - DY23 * x1 > 0;
- bool b01 = C2 + DX23 * y1 - DY23 * x0 > 0;
- bool b11 = C2 + DX23 * y1 - DY23 * x1 > 0;
- int b = (b00 << 0) | (b10 << 1) | (b01 << 2) | (b11 << 3);
- bool c00 = C3 + DX31 * y0 - DY31 * x0 > 0;
- bool c10 = C3 + DX31 * y0 - DY31 * x1 > 0;
- bool c01 = C3 + DX31 * y1 - DY31 * x0 > 0;
- bool c11 = C3 + DX31 * y1 - DY31 * x1 > 0;
- int c = (c00 << 0) | (c10 << 1) | (c01 << 2) | (c11 << 3);
- // Skip block when outside an edge
- if (a == 0x0 || b == 0x0 || c == 0x0) continue;
- // Accept whole block when totally covered
- if (a == 0xF && b == 0xF && c == 0xF) {
- Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
- for (int iy = y; iy < y + q; iy++) {
- Vector3 tex = texRow;
- for (int ix = x; ix < x + q; ix++) {
- //Vector3 tex = t1 + dx * (ix - v1.x) + dy * (iy - v1.y);
- if (!cb(param, ix, iy, tex, dx, dy, 1.0)) {
- // early out.
- return false;
- }
- tex += dx;
- }
- texRow += dy;
- }
- } else { // Partially covered block
- int CY1 = C1 + DX12 * y0 - DY12 * x0;
- int CY2 = C2 + DX23 * y0 - DY23 * x0;
- int CY3 = C3 + DX31 * y0 - DY31 * x0;
- Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
- for (int iy = y; iy < y + q; iy++) {
- int CX1 = CY1;
- int CX2 = CY2;
- int CX3 = CY3;
- Vector3 tex = texRow;
- for (int ix = x; ix < x + q; ix++) {
- if (CX1 > 0 && CX2 > 0 && CX3 > 0) {
- if (!cb(param, ix, iy, tex, dx, dy, 1.0)) {
- // early out.
- return false;
- }
- }
- CX1 -= FDY12;
- CX2 -= FDY23;
- CX3 -= FDY31;
- tex += dx;
- }
- CY1 += FDX12;
- CY2 += FDX23;
- CY3 += FDX31;
- texRow += dy;
- }
- }
- }
- }
- return true;
+ const Vector2 e0 = v3 - v1;
+ const Vector2 e1 = v2 - v1;
+ const float denom = 1.0f / (e0.y * e1.x - e1.y * e0.x);
+ return isFinite(denom);
}
// extents has to be multiple of BK_SIZE!!
- bool drawAA(const Vector2 &extents, bool enableScissors, SamplingCallback cb, void *param)
+ bool drawAA(const Vector2 &extents, SamplingCallback cb, void *param)
{
- const float PX_INSIDE = 1.0f/sqrt(2.0f);
- const float PX_OUTSIDE = -1.0f/sqrt(2.0f);
+ const float PX_INSIDE = 1.0f/sqrtf(2.0f);
+ const float PX_OUTSIDE = -1.0f/sqrtf(2.0f);
const float BK_SIZE = 8;
- const float BK_INSIDE = sqrt(BK_SIZE*BK_SIZE/2.0f);
- const float BK_OUTSIDE = -sqrt(BK_SIZE*BK_SIZE/2.0f);
-
- float minx, miny, maxx, maxy;
- if (enableScissors) {
- // Bounding rectangle
- minx = floorf(std::max(min3(v1.x, v2.x, v3.x), 0.0f));
- miny = floorf(std::max(min3(v1.y, v2.y, v3.y), 0.0f));
- maxx = ceilf( std::min(max3(v1.x, v2.x, v3.x), extents.x - 1.0f));
- maxy = ceilf( std::min(max3(v1.y, v2.y, v3.y), extents.y - 1.0f));
- } else {
- // Bounding rectangle
- minx = floorf(min3(v1.x, v2.x, v3.x));
- miny = floorf(min3(v1.y, v2.y, v3.y));
- maxx = ceilf( max3(v1.x, v2.x, v3.x));
- maxy = ceilf( max3(v1.y, v2.y, v3.y));
- }
+ const float BK_INSIDE = sqrtf(BK_SIZE*BK_SIZE/2.0f);
+ const float BK_OUTSIDE = -sqrtf(BK_SIZE*BK_SIZE/2.0f);
+ // Bounding rectangle
+ float minx = floorf(max(min3(v1.x, v2.x, v3.x), 0.0f));
+ float miny = floorf(max(min3(v1.y, v2.y, v3.y), 0.0f));
+ float maxx = ceilf( min(max3(v1.x, v2.x, v3.x), extents.x - 1.0f));
+ float maxy = ceilf( min(max3(v1.y, v2.y, v3.y), extents.y - 1.0f));
// There's no reason to align the blocks to the viewport, instead we align them to the origin of the triangle bounds.
minx = floorf(minx);
miny = floorf(miny);
@@ -3885,47 +3947,32 @@ struct Triangle
if ( (aC <= BK_OUTSIDE) || (bC <= BK_OUTSIDE) || (cC <= BK_OUTSIDE) ) continue;
// Accept whole block when totally covered
if ( (aC >= BK_INSIDE) && (bC >= BK_INSIDE) && (cC >= BK_INSIDE) ) {
- Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
for (float y = y0; y < y0 + BK_SIZE; y++) {
- Vector3 tex = texRow;
for (float x = x0; x < x0 + BK_SIZE; x++) {
- if (!cb(param, (int)x, (int)y, tex, dx, dy, 1.0f)) {
+ if (!cb(param, (int)x, (int)y)) {
return false;
}
- tex += dx;
}
- texRow += dy;
}
} else { // Partially covered block
float CY1 = C1 + n1.x * x0 + n1.y * y0;
float CY2 = C2 + n2.x * x0 + n2.y * y0;
float CY3 = C3 + n3.x * x0 + n3.y * y0;
- Vector3 texRow = t1 + dy * (y0 - v1.y) + dx * (x0 - v1.x);
for (float y = y0; y < y0 + BK_SIZE; y++) { // @@ This is not clipping to scissor rectangle correctly.
float CX1 = CY1;
float CX2 = CY2;
float CX3 = CY3;
- Vector3 tex = texRow;
for (float x = x0; x < x0 + BK_SIZE; x++) { // @@ This is not clipping to scissor rectangle correctly.
if (CX1 >= PX_INSIDE && CX2 >= PX_INSIDE && CX3 >= PX_INSIDE) {
- // pixel completely covered
- Vector3 tex2 = t1 + dx * (x - v1.x) + dy * (y - v1.y);
- if (!cb(param, (int)x, (int)y, tex2, dx, dy, 1.0f)) {
+ if (!cb(param, (int)x, (int)y)) {
return false;
}
} else if ((CX1 >= PX_OUTSIDE) && (CX2 >= PX_OUTSIDE) && (CX3 >= PX_OUTSIDE)) {
// triangle partially covers pixel. do clipping.
ClippedTriangle ct(v1 - Vector2(x, y), v2 - Vector2(x, y), v3 - Vector2(x, y));
ct.clipAABox(-0.5, -0.5, 0.5, 0.5);
- Vector2 centroid = ct.centroid();
- float area = ct.area();
- if (area > 0.0f) {
- Vector3 texCent = tex - dx * centroid.x - dy * centroid.y;
- //xaAssert(texCent.x >= -0.1f && texCent.x <= 1.1f); // @@ Centroid is not very exact...
- //xaAssert(texCent.y >= -0.1f && texCent.y <= 1.1f);
- //xaAssert(texCent.z >= -0.1f && texCent.z <= 1.1f);
- //Vector3 texCent2 = t1 + dx * (x - v1.x) + dy * (y - v1.y);
- if (!cb(param, (int)x, (int)y, texCent, dx, dy, area)) {
+ if (ct.area() > 0.0f) {
+ if (!cb(param, (int)x, (int)y)) {
return false;
}
}
@@ -3933,12 +3980,10 @@ struct Triangle
CX1 += n1.x;
CX2 += n2.x;
CX3 += n3.x;
- tex += dx;
}
CY1 += n1.y;
CY2 += n2.y;
CY3 += n3.y;
- texRow += dy;
}
}
}
@@ -3953,9 +3998,6 @@ struct Triangle
Vector2 hv = v1;
v1 = v2;
v2 = hv; // swap pos
- Vector3 ht = t1;
- t1 = t2;
- t2 = ht; // swap tex
}
}
@@ -3976,77 +4018,24 @@ struct Triangle
// Vertices.
Vector2 v1, v2, v3;
Vector2 n1, n2, n3; // unit inward normals
- Vector3 t1, t2, t3;
-
- // Deltas.
- Vector3 dx, dy;
-
- float sign;
- bool valid;
-};
-
-enum Mode
-{
- Mode_Nearest,
- Mode_Antialiased
};
// Process the given triangle. Returns false if rasterization was interrupted by the callback.
-static bool drawTriangle(Mode mode, Vector2::Arg extents, bool enableScissors, const Vector2 v[3], SamplingCallback cb, void *param)
+static bool drawTriangle(const Vector2 &extents, const Vector2 v[3], SamplingCallback cb, void *param)
{
- Triangle tri(v[0], v[1], v[2], Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1));
+ Triangle tri(v[0], v[1], v[2]);
// @@ It would be nice to have a conservative drawing mode that enlarges the triangle extents by one texel and is able to handle degenerate triangles.
// @@ Maybe the simplest thing to do would be raster triangle edges.
- if (tri.valid) {
- if (mode == Mode_Antialiased) {
- return tri.drawAA(extents, enableScissors, cb, param);
- }
- if (mode == Mode_Nearest) {
- return tri.draw(extents, enableScissors, cb, param);
- }
- }
+ if (tri.isValid())
+ return tri.drawAA(extents, cb, param);
return true;
}
-// Process the given quad. Returns false if rasterization was interrupted by the callback.
-static bool drawQuad(Mode mode, Vector2::Arg extents, bool enableScissors, const Vector2 v[4], SamplingCallback cb, void *param)
-{
- bool sign0 = triangleArea2(v[0], v[1], v[2]) > 0.0f;
- bool sign1 = triangleArea2(v[0], v[2], v[3]) > 0.0f;
- // Divide the quad into two non overlapping triangles.
- if (sign0 == sign1) {
- Triangle tri0(v[0], v[1], v[2], Vector3(0, 0, 0), Vector3(1, 0, 0), Vector3(1, 1, 0));
- Triangle tri1(v[0], v[2], v[3], Vector3(0, 0, 0), Vector3(1, 1, 0), Vector3(0, 1, 0));
- if (tri0.valid && tri1.valid) {
- if (mode == Mode_Antialiased) {
- return tri0.drawAA(extents, enableScissors, cb, param) && tri1.drawAA(extents, enableScissors, cb, param);
- } else {
- return tri0.draw(extents, enableScissors, cb, param) && tri1.draw(extents, enableScissors, cb, param);
- }
- }
- } else {
- Triangle tri0(v[0], v[1], v[3], Vector3(0, 0, 0), Vector3(1, 0, 0), Vector3(0, 1, 0));
- Triangle tri1(v[1], v[2], v[3], Vector3(1, 0, 0), Vector3(1, 1, 0), Vector3(0, 1, 0));
- if (tri0.valid && tri1.valid) {
- if (mode == Mode_Antialiased) {
- return tri0.drawAA(extents, enableScissors, cb, param) && tri1.drawAA(extents, enableScissors, cb, param);
- } else {
- return tri0.draw(extents, enableScissors, cb, param) && tri1.draw(extents, enableScissors, cb, param);
- }
- }
- }
- return true;
-}
} // namespace raster
// Full and sparse vector and matrix classes. BLAS subset.
// Pseudo-BLAS interface.
namespace sparse {
-enum Transpose
-{
- NoTransposed = 0,
- Transposed = 1
-};
/**
* Sparse matrix class. The matrix is assumed to be sparse and to have
@@ -4072,8 +4061,8 @@ public:
const Matrix &operator=(const Matrix &m)
{
- xaAssert(width() == m.width());
- xaAssert(height() == m.height());
+ XA_ASSERT(width() == m.width());
+ XA_ASSERT(height() == m.height());
m_array = m.m_array;
return *this;
}
@@ -4085,8 +4074,8 @@ public:
// x is column, y is row
float getCoefficient(uint32_t x, uint32_t y) const
{
- xaDebugAssert( x < width() );
- xaDebugAssert( y < height() );
+ XA_DEBUG_ASSERT( x < width() );
+ XA_DEBUG_ASSERT( y < height() );
const uint32_t count = m_array[y].size();
for (uint32_t i = 0; i < count; i++) {
if (m_array[y][i].x == x) return m_array[y][i].v;
@@ -4096,8 +4085,8 @@ public:
void setCoefficient(uint32_t x, uint32_t y, float f)
{
- xaDebugAssert( x < width() );
- xaDebugAssert( y < height() );
+ XA_DEBUG_ASSERT( x < width() );
+ XA_DEBUG_ASSERT( y < height() );
const uint32_t count = m_array[y].size();
for (uint32_t i = 0; i < count; i++) {
if (m_array[y][i].x == x) {
@@ -4113,7 +4102,7 @@ public:
float dotRow(uint32_t y, const FullVector &v) const
{
- xaDebugAssert( y < height() );
+ XA_DEBUG_ASSERT( y < height() );
const uint32_t count = m_array[y].size();
float sum = 0;
for (uint32_t i = 0; i < count; i++) {
@@ -4124,7 +4113,7 @@ public:
void madRow(uint32_t y, float alpha, FullVector &v) const
{
- xaDebugAssert(y < height());
+ XA_DEBUG_ASSERT(y < height());
const uint32_t count = m_array[y].size();
for (uint32_t i = 0; i < count; i++) {
v[m_array[y][i].x] += alpha * m_array[y][i].v;
@@ -4133,33 +4122,24 @@ public:
void clearRow(uint32_t y)
{
- xaDebugAssert( y < height() );
+ XA_DEBUG_ASSERT( y < height() );
m_array[y].clear();
}
- void scaleRow(uint32_t y, float f)
- {
- xaDebugAssert( y < height() );
- const uint32_t count = m_array[y].size();
- for (uint32_t i = 0; i < count; i++) {
- m_array[y][i].v *= f;
- }
- }
-
- const std::vector<Coefficient> &getRow(uint32_t y) const { return m_array[y]; }
+ const Array<Coefficient> &getRow(uint32_t y) const { return m_array[y]; }
private:
/// Number of columns.
const uint32_t m_width;
/// Array of matrix elements.
- std::vector< std::vector<Coefficient> > m_array;
+ Array< Array<Coefficient> > m_array;
};
// y = a * x + y
static void saxpy(float a, const FullVector &x, FullVector &y)
{
- xaDebugAssert(x.dimension() == y.dimension());
+ XA_DEBUG_ASSERT(x.dimension() == y.dimension());
const uint32_t dim = x.dimension();
for (uint32_t i = 0; i < dim; i++) {
y[i] += a * x[i];
@@ -4168,7 +4148,7 @@ static void saxpy(float a, const FullVector &x, FullVector &y)
static void copy(const FullVector &x, FullVector &y)
{
- xaDebugAssert(x.dimension() == y.dimension());
+ XA_DEBUG_ASSERT(x.dimension() == y.dimension());
const uint32_t dim = x.dimension();
for (uint32_t i = 0; i < dim; i++) {
y[i] = x[i];
@@ -4185,7 +4165,7 @@ static void scal(float a, FullVector &x)
static float dot(const FullVector &x, const FullVector &y)
{
- xaDebugAssert(x.dimension() == y.dimension());
+ XA_DEBUG_ASSERT(x.dimension() == y.dimension());
const uint32_t dim = x.dimension();
float sum = 0;
for (uint32_t i = 0; i < dim; i++) {
@@ -4194,61 +4174,35 @@ static float dot(const FullVector &x, const FullVector &y)
return sum;
}
-static void mult(Transpose TM, const Matrix &M, const FullVector &x, FullVector &y)
-{
- const uint32_t w = M.width();
- const uint32_t h = M.height();
- if (TM == Transposed) {
- xaDebugAssert( h == x.dimension() );
- xaDebugAssert( w == y.dimension() );
- y.fill(0.0f);
- for (uint32_t i = 0; i < h; i++) {
- M.madRow(i, x[i], y);
- }
- } else {
- xaDebugAssert( w == x.dimension() );
- xaDebugAssert( h == y.dimension() );
- for (uint32_t i = 0; i < h; i++) {
- y[i] = M.dotRow(i, x);
- }
- }
-}
-
// y = M * x
static void mult(const Matrix &M, const FullVector &x, FullVector &y)
{
- mult(NoTransposed, M, x, y);
-}
-
-static void sgemv(float alpha, Transpose TA, const Matrix &A, const FullVector &x, float beta, FullVector &y)
-{
- const uint32_t w = A.width();
- const uint32_t h = A.height();
- if (TA == Transposed) {
- xaDebugAssert( h == x.dimension() );
- xaDebugAssert( w == y.dimension() );
- for (uint32_t i = 0; i < h; i++) {
- A.madRow(i, alpha * x[i], y);
- }
- } else {
- xaDebugAssert( w == x.dimension() );
- xaDebugAssert( h == y.dimension() );
- for (uint32_t i = 0; i < h; i++) {
- y[i] = alpha * A.dotRow(i, x) + beta * y[i];
- }
- }
+ uint32_t w = M.width();
+ uint32_t h = M.height();
+ XA_DEBUG_ASSERT( w == x.dimension() );
+ XA_UNUSED(w);
+ XA_DEBUG_ASSERT( h == y.dimension() );
+ for (uint32_t i = 0; i < h; i++)
+ y[i] = M.dotRow(i, x);
}
// y = alpha*A*x + beta*y
static void sgemv(float alpha, const Matrix &A, const FullVector &x, float beta, FullVector &y)
{
- sgemv(alpha, NoTransposed, A, x, beta, y);
+ const uint32_t w = A.width();
+ const uint32_t h = A.height();
+ XA_DEBUG_ASSERT( w == x.dimension() );
+ XA_DEBUG_ASSERT( h == y.dimension() );
+ XA_UNUSED(w);
+ XA_UNUSED(h);
+ for (uint32_t i = 0; i < h; i++)
+ y[i] = alpha * A.dotRow(i, x) + beta * y[i];
}
// dot y-row of A by x-column of B
static float dotRowColumn(int y, const Matrix &A, int x, const Matrix &B)
{
- const std::vector<Matrix::Coefficient> &row = A.getRow(y);
+ const Array<Matrix::Coefficient> &row = A.getRow(y);
const uint32_t count = row.size();
float sum = 0.0f;
for (uint32_t i = 0; i < count; i++) {
@@ -4258,96 +4212,54 @@ static float dotRowColumn(int y, const Matrix &A, int x, const Matrix &B)
return sum;
}
-// dot y-row of A by x-row of B
-static float dotRowRow(int y, const Matrix &A, int x, const Matrix &B)
-{
- const std::vector<Matrix::Coefficient> &row = A.getRow(y);
- const uint32_t count = row.size();
- float sum = 0.0f;
- for (uint32_t i = 0; i < count; i++) {
- const Matrix::Coefficient &c = row[i];
- sum += c.v * B.getCoefficient(c.x, x);
- }
- return sum;
-}
-
-// dot y-column of A by x-column of B
-static float dotColumnColumn(int y, const Matrix &A, int x, const Matrix &B)
-{
- xaDebugAssert(A.height() == B.height());
- const uint32_t h = A.height();
- float sum = 0.0f;
- for (uint32_t i = 0; i < h; i++) {
- sum += A.getCoefficient(y, i) * B.getCoefficient(x, i);
- }
- return sum;
-}
-
static void transpose(const Matrix &A, Matrix &B)
{
- xaDebugAssert(A.width() == B.height());
- xaDebugAssert(B.width() == A.height());
+ XA_DEBUG_ASSERT(A.width() == B.height());
+ XA_DEBUG_ASSERT(B.width() == A.height());
const uint32_t w = A.width();
for (uint32_t x = 0; x < w; x++) {
B.clearRow(x);
}
const uint32_t h = A.height();
for (uint32_t y = 0; y < h; y++) {
- const std::vector<Matrix::Coefficient> &row = A.getRow(y);
+ const Array<Matrix::Coefficient> &row = A.getRow(y);
const uint32_t count = row.size();
for (uint32_t i = 0; i < count; i++) {
const Matrix::Coefficient &c = row[i];
- xaDebugAssert(c.x < w);
+ XA_DEBUG_ASSERT(c.x < w);
B.setCoefficient(y, c.x, c.v);
}
}
}
-static void sgemm(float alpha, Transpose TA, const Matrix &A, Transpose TB, const Matrix &B, float beta, Matrix &C)
+static void sgemm(float alpha, const Matrix &A, const Matrix &B, float beta, Matrix &C)
{
const uint32_t w = C.width();
const uint32_t h = C.height();
- uint32_t aw = (TA == NoTransposed) ? A.width() : A.height();
- uint32_t ah = (TA == NoTransposed) ? A.height() : A.width();
- uint32_t bw = (TB == NoTransposed) ? B.width() : B.height();
- uint32_t bh = (TB == NoTransposed) ? B.height() : B.width();
- xaDebugAssert(aw == bh);
- xaDebugAssert(bw == ah);
- xaDebugAssert(w == bw);
- xaDebugAssert(h == ah);
-#ifdef NDEBUG
- aw = ah = bw = bh = 0; // silence unused parameter warning
+#if XA_DEBUG
+ const uint32_t aw = A.width();
+ const uint32_t ah = A.height();
+ const uint32_t bw = B.width();
+ const uint32_t bh = B.height();
+ XA_DEBUG_ASSERT(aw == bh);
+ XA_DEBUG_ASSERT(bw == ah);
+ XA_DEBUG_ASSERT(w == bw);
+ XA_DEBUG_ASSERT(h == ah);
#endif
for (uint32_t y = 0; y < h; y++) {
for (uint32_t x = 0; x < w; x++) {
float c = beta * C.getCoefficient(x, y);
- if (TA == NoTransposed && TB == NoTransposed) {
- // dot y-row of A by x-column of B.
- c += alpha * dotRowColumn(y, A, x, B);
- } else if (TA == Transposed && TB == Transposed) {
- // dot y-column of A by x-row of B.
- c += alpha * dotRowColumn(x, B, y, A);
- } else if (TA == Transposed && TB == NoTransposed) {
- // dot y-column of A by x-column of B.
- c += alpha * dotColumnColumn(y, A, x, B);
- } else if (TA == NoTransposed && TB == Transposed) {
- // dot y-row of A by x-row of B.
- c += alpha * dotRowRow(y, A, x, B);
- }
+ // dot y-row of A by x-column of B.
+ c += alpha * dotRowColumn(y, A, x, B);
C.setCoefficient(x, y, c);
}
}
}
-static void mult(Transpose TA, const Matrix &A, Transpose TB, const Matrix &B, Matrix &C)
-{
- sgemm(1.0f, TA, A, TB, B, 0.0f, C);
-}
-
// C = A * B
static void mult(const Matrix &A, const Matrix &B, Matrix &C)
{
- mult(NoTransposed, A, NoTransposed, B, C);
+ sgemm(1.0f, A, B, 0.0f, C);
}
} // namespace sparse
@@ -4357,10 +4269,10 @@ class JacobiPreconditioner
public:
JacobiPreconditioner(const sparse::Matrix &M, bool symmetric) : m_inverseDiagonal(M.width())
{
- xaAssert(M.isSquare());
+ XA_ASSERT(M.isSquare());
for (uint32_t x = 0; x < M.width(); x++) {
float elem = M.getCoefficient(x, x);
- //xaDebugAssert( elem != 0.0f ); // This can be zero in the presence of zero area triangles.
+ //XA_DEBUG_ASSERT( elem != 0.0f ); // This can be zero in the presence of zero area triangles.
if (symmetric) {
m_inverseDiagonal[x] = (elem != 0) ? 1.0f / sqrtf(fabsf(elem)) : 1.0f;
} else {
@@ -4371,8 +4283,8 @@ public:
void apply(const FullVector &x, FullVector &y) const
{
- xaDebugAssert(x.dimension() == m_inverseDiagonal.dimension());
- xaDebugAssert(y.dimension() == m_inverseDiagonal.dimension());
+ XA_DEBUG_ASSERT(x.dimension() == m_inverseDiagonal.dimension());
+ XA_DEBUG_ASSERT(y.dimension() == m_inverseDiagonal.dimension());
// @@ Wrap vector component-wise product into a separate function.
const uint32_t D = x.dimension();
for (uint32_t i = 0; i < D; i++) {
@@ -4391,9 +4303,9 @@ public:
// Solve the symmetric system: At·A·x = At·b
static bool LeastSquaresSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon = 1e-5f)
{
- xaDebugAssert(A.width() == x.dimension());
- xaDebugAssert(A.height() == b.dimension());
- xaDebugAssert(A.height() >= A.width()); // @@ If height == width we could solve it directly...
+ XA_DEBUG_ASSERT(A.width() == x.dimension());
+ XA_DEBUG_ASSERT(A.height() == b.dimension());
+ XA_DEBUG_ASSERT(A.height() >= A.width()); // @@ If height == width we could solve it directly...
const uint32_t D = A.width();
sparse::Matrix At(A.height(), A.width());
sparse::transpose(A, At);
@@ -4407,12 +4319,12 @@ public:
// See section 10.4.3 in: Mesh Parameterization: Theory and Practice, Siggraph Course Notes, August 2007
static bool LeastSquaresSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, const uint32_t *lockedParameters, uint32_t lockedCount, float epsilon = 1e-5f)
{
- xaDebugAssert(A.width() == x.dimension());
- xaDebugAssert(A.height() == b.dimension());
- xaDebugAssert(A.height() >= A.width() - lockedCount);
+ XA_DEBUG_ASSERT(A.width() == x.dimension());
+ XA_DEBUG_ASSERT(A.height() == b.dimension());
+ XA_DEBUG_ASSERT(A.height() >= A.width() - lockedCount);
// @@ This is not the most efficient way of building a system with reduced degrees of freedom. It would be faster to do it on the fly.
const uint32_t D = A.width() - lockedCount;
- xaDebugAssert(D > 0);
+ XA_DEBUG_ASSERT(D > 0);
// Compute: b - Al * xl
FullVector b_Alxl(b);
for (uint32_t y = 0; y < A.height(); y++) {
@@ -4504,62 +4416,12 @@ private:
* Jonhathan Richard Shewchuk.
*
**/
- static bool ConjugateGradientSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon)
- {
- xaDebugAssert( A.isSquare() );
- xaDebugAssert( A.width() == b.dimension() );
- xaDebugAssert( A.width() == x.dimension() );
- int i = 0;
- const int D = A.width();
- const int i_max = 4 * D; // Convergence should be linear, but in some cases, it's not.
- FullVector r(D); // residual
- FullVector p(D); // search direction
- FullVector q(D); //
- float delta_0;
- float delta_old;
- float delta_new;
- float alpha;
- float beta;
- // r = b - A·x;
- sparse::copy(b, r);
- sparse::sgemv(-1, A, x, 1, r);
- // p = r;
- sparse::copy(r, p);
- delta_new = sparse::dot( r, r );
- delta_0 = delta_new;
- while (i < i_max && delta_new > epsilon * epsilon * delta_0) {
- i++;
- // q = A·p
- mult(A, p, q);
- // alpha = delta_new / p·q
- alpha = delta_new / sparse::dot( p, q );
- // x = alfa·p + x
- sparse::saxpy(alpha, p, x);
- if ((i & 31) == 0) { // recompute r after 32 steps
- // r = b - A·x
- sparse::copy(b, r);
- sparse::sgemv(-1, A, x, 1, r);
- } else {
- // r = r - alpha·q
- sparse::saxpy(-alpha, q, r);
- }
- delta_old = delta_new;
- delta_new = sparse::dot( r, r );
- beta = delta_new / delta_old;
- // p = beta·p + r
- sparse::scal(beta, p);
- sparse::saxpy(1, r, p);
- }
- return delta_new <= epsilon * epsilon * delta_0;
- }
-
-
// Conjugate gradient with preconditioner.
static bool ConjugateGradientSolver(const JacobiPreconditioner &preconditioner, const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon)
{
- xaDebugAssert( A.isSquare() );
- xaDebugAssert( A.width() == b.dimension() );
- xaDebugAssert( A.width() == x.dimension() );
+ XA_DEBUG_ASSERT( A.isSquare() );
+ XA_DEBUG_ASSERT( A.width() == b.dimension() );
+ XA_DEBUG_ASSERT( A.width() == x.dimension() );
int i = 0;
const int D = A.width();
const int i_max = 4 * D; // Convergence should be linear, but in some cases, it's not.
@@ -4582,7 +4444,7 @@ private:
while (i < i_max && delta_new > epsilon * epsilon * delta_0) {
i++;
// q = A·p
- mult(A, p, q);
+ sparse::mult(A, p, q);
// alpha = delta_new / p·q
alpha = delta_new / sparse::dot(p, q);
// x = alfa·p + x
@@ -4609,59 +4471,59 @@ private:
static bool SymmetricSolver(const sparse::Matrix &A, const FullVector &b, FullVector &x, float epsilon = 1e-5f)
{
- xaDebugAssert(A.height() == A.width());
- xaDebugAssert(A.height() == b.dimension());
- xaDebugAssert(b.dimension() == x.dimension());
+ XA_DEBUG_ASSERT(A.height() == A.width());
+ XA_DEBUG_ASSERT(A.height() == b.dimension());
+ XA_DEBUG_ASSERT(b.dimension() == x.dimension());
JacobiPreconditioner jacobi(A, true);
return ConjugateGradientSolver(jacobi, A, b, x, epsilon);
}
};
namespace param {
-class Atlas;
-class Chart;
// Fast sweep in 3 directions
-static bool findApproximateDiameterVertices(halfedge::Mesh *mesh, halfedge::Vertex **a, halfedge::Vertex **b)
+static bool findApproximateDiameterVertices(Mesh *mesh, uint32_t *a, uint32_t *b)
{
- xaDebugAssert(mesh != NULL);
- xaDebugAssert(a != NULL);
- xaDebugAssert(b != NULL);
+ XA_DEBUG_ASSERT(a != nullptr);
+ XA_DEBUG_ASSERT(b != nullptr);
const uint32_t vertexCount = mesh->vertexCount();
- halfedge::Vertex *minVertex[3];
- halfedge::Vertex *maxVertex[3];
- minVertex[0] = minVertex[1] = minVertex[2] = NULL;
- maxVertex[0] = maxVertex[1] = maxVertex[2] = NULL;
+ uint32_t minVertex[3];
+ uint32_t maxVertex[3];
+ minVertex[0] = minVertex[1] = minVertex[2] = UINT32_MAX;
+ maxVertex[0] = maxVertex[1] = maxVertex[2] = UINT32_MAX;
for (uint32_t v = 1; v < vertexCount; v++) {
- halfedge::Vertex *vertex = mesh->vertexAt(v);
- xaDebugAssert(vertex != NULL);
- if (vertex->isBoundary()) {
- minVertex[0] = minVertex[1] = minVertex[2] = vertex;
- maxVertex[0] = maxVertex[1] = maxVertex[2] = vertex;
+ if (mesh->isBoundaryVertex(v)) {
+ minVertex[0] = minVertex[1] = minVertex[2] = v;
+ maxVertex[0] = maxVertex[1] = maxVertex[2] = v;
break;
}
}
- if (minVertex[0] == NULL) {
+ if (minVertex[0] == UINT32_MAX) {
// Input mesh has not boundaries.
return false;
}
for (uint32_t v = 1; v < vertexCount; v++) {
- halfedge::Vertex *vertex = mesh->vertexAt(v);
- xaDebugAssert(vertex != NULL);
- if (!vertex->isBoundary()) {
+ if (!mesh->isBoundaryVertex(v)) {
// Skip interior vertices.
continue;
}
- if (vertex->pos.x < minVertex[0]->pos.x) minVertex[0] = vertex;
- else if (vertex->pos.x > maxVertex[0]->pos.x) maxVertex[0] = vertex;
- if (vertex->pos.y < minVertex[1]->pos.y) minVertex[1] = vertex;
- else if (vertex->pos.y > maxVertex[1]->pos.y) maxVertex[1] = vertex;
- if (vertex->pos.z < minVertex[2]->pos.z) minVertex[2] = vertex;
- else if (vertex->pos.z > maxVertex[2]->pos.z) maxVertex[2] = vertex;
+ const Vector3 &pos = mesh->position(v);
+ if (pos.x < mesh->position(minVertex[0]).x)
+ minVertex[0] = v;
+ else if (pos.x > mesh->position(maxVertex[0]).x)
+ maxVertex[0] = v;
+ if (pos.y < mesh->position(minVertex[1]).y)
+ minVertex[1] = v;
+ else if (pos.y > mesh->position(maxVertex[1]).y)
+ maxVertex[1] = v;
+ if (pos.z < mesh->position(minVertex[2]).z)
+ minVertex[2] = v;
+ else if (pos.z > mesh->position(maxVertex[2]).z)
+ maxVertex[2] = v;
}
float lengths[3];
for (int i = 0; i < 3; i++) {
- lengths[i] = length(minVertex[i]->pos - maxVertex[i]->pos);
+ lengths[i] = length(mesh->position(minVertex[i]) - mesh->position(maxVertex[i]));
}
if (lengths[0] > lengths[1] && lengths[0] > lengths[2]) {
*a = minVertex[0];
@@ -4678,34 +4540,28 @@ static bool findApproximateDiameterVertices(halfedge::Mesh *mesh, halfedge::Vert
// Conformal relations from Brecht Van Lommel (based on ABF):
-static float vec_angle_cos(Vector3::Arg v1, Vector3::Arg v2, Vector3::Arg v3)
+static float vec_angle_cos(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
{
Vector3 d1 = v1 - v2;
Vector3 d2 = v3 - v2;
return clamp(dot(d1, d2) / (length(d1) * length(d2)), -1.0f, 1.0f);
}
-static float vec_angle(Vector3::Arg v1, Vector3::Arg v2, Vector3::Arg v3)
+static float vec_angle(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
{
float dot = vec_angle_cos(v1, v2, v3);
return acosf(dot);
}
-static void triangle_angles(Vector3::Arg v1, Vector3::Arg v2, Vector3::Arg v3, float *a1, float *a2, float *a3)
+static void triangle_angles(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, float *a1, float *a2, float *a3)
{
*a1 = vec_angle(v3, v1, v2);
*a2 = vec_angle(v1, v2, v3);
- *a3 = PI - *a2 - *a1;
+ *a3 = kPi - *a2 - *a1;
}
-static void setup_abf_relations(sparse::Matrix &A, int row, const halfedge::Vertex *v0, const halfedge::Vertex *v1, const halfedge::Vertex *v2)
+static void setup_abf_relations(sparse::Matrix &A, int row, int id0, int id1, int id2, const Vector3 &p0, const Vector3 &p1, const Vector3 &p2)
{
- int id0 = v0->id;
- int id1 = v1->id;
- int id2 = v2->id;
- Vector3 p0 = v0->pos;
- Vector3 p1 = v1->pos;
- Vector3 p2 = v2->pos;
// @@ IC: Wouldn't it be more accurate to return cos and compute 1-cos^2?
// It does indeed seem to be a little bit more robust.
// @@ Need to revisit this more carefully!
@@ -4715,19 +4571,19 @@ static void setup_abf_relations(sparse::Matrix &A, int row, const halfedge::Vert
float s1 = sinf(a1);
float s2 = sinf(a2);
if (s1 > s0 && s1 > s2) {
- std::swap(s1, s2);
- std::swap(s0, s1);
- std::swap(a1, a2);
- std::swap(a0, a1);
- std::swap(id1, id2);
- std::swap(id0, id1);
+ swap(s1, s2);
+ swap(s0, s1);
+ swap(a1, a2);
+ swap(a0, a1);
+ swap(id1, id2);
+ swap(id0, id1);
} else if (s0 > s1 && s0 > s2) {
- std::swap(s0, s2);
- std::swap(s0, s1);
- std::swap(a0, a2);
- std::swap(a0, a1);
- std::swap(id0, id2);
- std::swap(id0, id1);
+ swap(s0, s2);
+ swap(s0, s1);
+ swap(a0, a2);
+ swap(a0, a1);
+ swap(id0, id2);
+ swap(id0, id1);
}
float c0 = cosf(a0);
float ratio = (s2 == 0.0f) ? 1.0f : s1 / s2;
@@ -4755,14 +4611,13 @@ static void setup_abf_relations(sparse::Matrix &A, int row, const halfedge::Vert
A.setCoefficient(v2_id, 2 * row + 1, 1);
}
-bool computeLeastSquaresConformalMap(halfedge::Mesh *mesh)
+static bool computeLeastSquaresConformalMap(Mesh *mesh)
{
- xaDebugAssert(mesh != NULL);
// For this to work properly, mesh should not have colocals that have the same
// attributes, unless you want the vertices to actually have different texcoords.
const uint32_t vertexCount = mesh->vertexCount();
const uint32_t D = 2 * vertexCount;
- const uint32_t N = 2 * halfedge::countMeshTriangles(mesh);
+ const uint32_t N = 2 * mesh->faceCount();
// N is the number of equations (one per triangle)
// D is the number of variables (one per vertex; there are 2 pinned vertices).
if (N < D - 4) {
@@ -4774,118 +4629,64 @@ bool computeLeastSquaresConformalMap(halfedge::Mesh *mesh)
// Fill b:
b.fill(0.0f);
// Fill x:
- halfedge::Vertex *v0;
- halfedge::Vertex *v1;
+ uint32_t v0, v1;
if (!findApproximateDiameterVertices(mesh, &v0, &v1)) {
// Mesh has no boundaries.
return false;
}
- if (v0->tex == v1->tex) {
+ if (mesh->texcoord(v0) == mesh->texcoord(v1)) {
// LSCM expects an existing parameterization.
return false;
}
for (uint32_t v = 0; v < vertexCount; v++) {
- halfedge::Vertex *vertex = mesh->vertexAt(v);
- xaDebugAssert(vertex != NULL);
// Initial solution.
- x[2 * v + 0] = vertex->tex.x;
- x[2 * v + 1] = vertex->tex.y;
+ x[2 * v + 0] = mesh->texcoord(v).x;
+ x[2 * v + 1] = mesh->texcoord(v).y;
}
// Fill A:
const uint32_t faceCount = mesh->faceCount();
for (uint32_t f = 0, t = 0; f < faceCount; f++) {
- const halfedge::Face *face = mesh->faceAt(f);
- xaDebugAssert(face != NULL);
- xaDebugAssert(face->edgeCount() == 3);
- const halfedge::Vertex *vertex0 = NULL;
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- xaAssert(edge != NULL);
- if (vertex0 == NULL) {
- vertex0 = edge->vertex;
- } else if (edge->next->vertex != vertex0) {
- const halfedge::Vertex *vertex1 = edge->from();
- const halfedge::Vertex *vertex2 = edge->to();
- setup_abf_relations(A, t, vertex0, vertex1, vertex2);
- //setup_conformal_map_relations(A, t, vertex0, vertex1, vertex2);
- t++;
- }
- }
+ const uint32_t vertex0 = mesh->vertexAt(f * 3 + 0);
+ const uint32_t vertex1 = mesh->vertexAt(f * 3 + 1);
+ const uint32_t vertex2 = mesh->vertexAt(f * 3 + 2);
+ setup_abf_relations(A, t, vertex0, vertex1, vertex2, mesh->position(vertex0), mesh->position(vertex1), mesh->position(vertex2));
+ t++;
}
const uint32_t lockedParameters[] = {
- 2 * v0->id + 0,
- 2 * v0->id + 1,
- 2 * v1->id + 0,
- 2 * v1->id + 1
+ 2 * v0 + 0,
+ 2 * v0 + 1,
+ 2 * v1 + 0,
+ 2 * v1 + 1
};
// Solve
Solver::LeastSquaresSolver(A, b, x, lockedParameters, 4, 0.000001f);
// Map x back to texcoords:
- for (uint32_t v = 0; v < vertexCount; v++) {
- halfedge::Vertex *vertex = mesh->vertexAt(v);
- xaDebugAssert(vertex != NULL);
- vertex->tex = Vector2(x[2 * v + 0], x[2 * v + 1]);
- }
+ for (uint32_t v = 0; v < vertexCount; v++)
+ mesh->texcoord(v) = Vector2(x[2 * v + 0], x[2 * v + 1]);
return true;
}
-bool computeOrthogonalProjectionMap(halfedge::Mesh *mesh)
+static bool computeOrthogonalProjectionMap(Mesh *mesh)
{
- Vector3 axis[2];
uint32_t vertexCount = mesh->vertexCount();
- std::vector<Vector3> points(vertexCount);
- points.resize(vertexCount);
- for (uint32_t i = 0; i < vertexCount; i++) {
- points[i] = mesh->vertexAt(i)->pos;
- }
// Avoid redundant computations.
float matrix[6];
- Fit::computeCovariance(vertexCount, points.data(), matrix);
- if (matrix[0] == 0 && matrix[3] == 0 && matrix[5] == 0) {
+ Fit::computeCovariance(vertexCount, &mesh->position(0), matrix);
+ if (matrix[0] == 0 && matrix[3] == 0 && matrix[5] == 0)
return false;
- }
float eigenValues[3];
Vector3 eigenVectors[3];
- if (!Fit::eigenSolveSymmetric3(matrix, eigenValues, eigenVectors)) {
+ if (!Fit::eigenSolveSymmetric3(matrix, eigenValues, eigenVectors))
return false;
- }
- axis[0] = normalize(eigenVectors[0]);
- axis[1] = normalize(eigenVectors[1]);
+ Vector3 axis[2];
+ axis[0] = normalize(eigenVectors[0], kEpsilon);
+ axis[1] = normalize(eigenVectors[1], kEpsilon);
// Project vertices to plane.
- for (halfedge::Mesh::VertexIterator it(mesh->vertices()); !it.isDone(); it.advance()) {
- halfedge::Vertex *vertex = it.current();
- vertex->tex.x = dot(axis[0], vertex->pos);
- vertex->tex.y = dot(axis[1], vertex->pos);
- }
+ for (uint32_t i = 0; i < vertexCount; i++)
+ mesh->texcoord(i) = Vector2(dot(axis[0], mesh->position(i)), dot(axis[1], mesh->position(i)));
return true;
}
-void computeSingleFaceMap(halfedge::Mesh *mesh)
-{
- xaDebugAssert(mesh != NULL);
- xaDebugAssert(mesh->faceCount() == 1);
- halfedge::Face *face = mesh->faceAt(0);
- xaAssert(face != NULL);
- Vector3 p0 = face->edge->from()->pos;
- Vector3 p1 = face->edge->to()->pos;
- Vector3 X = normalizeSafe(p1 - p0, Vector3(0.0f), 0.0f);
- Vector3 Z = face->normal();
- Vector3 Y = normalizeSafe(cross(Z, X), Vector3(0.0f), 0.0f);
- uint32_t i = 0;
- for (halfedge::Face::EdgeIterator it(face->edges()); !it.isDone(); it.advance(), i++) {
- halfedge::Vertex *vertex = it.vertex();
- xaAssert(vertex != NULL);
- if (i == 0) {
- vertex->tex = Vector2(0);
- } else {
- Vector3 pn = vertex->pos;
- float xn = dot((pn - p0), X);
- float yn = dot((pn - p0), Y);
- vertex->tex = Vector2(xn, yn);
- }
- }
-}
-
// Dummy implementation of a priority queue using sort at insertion.
// - Insertion is o(n)
// - Smallest element goes at the end, so that popping it is o(1).
@@ -4894,7 +4695,7 @@ void computeSingleFaceMap(halfedge::Mesh *mesh)
// @@ Searcing at removal would remove the need for sorting when priorities change.
struct PriorityQueue
{
- PriorityQueue(uint32_t size = UINT_MAX) : maxSize(size) {}
+ PriorityQueue(uint32_t size = UINT32_MAX) : maxSize(size) {}
void push(float priority, uint32_t face)
{
@@ -4904,10 +4705,9 @@ struct PriorityQueue
if (pairs[i].priority > priority) break;
}
Pair p = { priority, face };
- pairs.insert(pairs.begin() + i, p);
- if (pairs.size() > maxSize) {
- pairs.erase(pairs.begin());
- }
+ pairs.insertAt(i, p);
+ if (pairs.size() > maxSize)
+ pairs.removeAt(0);
}
// push face out of order, to be sorted later.
@@ -4949,7 +4749,7 @@ struct PriorityQueue
struct Pair
{
- bool operator <(const Pair &p) const
+ bool operator<(const Pair &p) const
{
return priority > p.priority; // !! Sort in inverse priority order!
}
@@ -4958,164 +4758,411 @@ struct PriorityQueue
uint32_t face;
};
- std::vector<Pair> pairs;
+ Array<Pair> pairs;
};
struct ChartBuildData
{
- ChartBuildData(int id) : id(id)
- {
- planeNormal = Vector3(0);
- centroid = Vector3(0);
- coneAxis = Vector3(0);
- coneAngle = 0;
- area = 0;
- boundaryLength = 0;
- normalSum = Vector3(0);
- centroidSum = Vector3(0);
- }
-
- int id;
-
- // Proxy info:
- Vector3 planeNormal;
- Vector3 centroid;
- Vector3 coneAxis;
- float coneAngle;
-
- float area;
- float boundaryLength;
- Vector3 normalSum;
- Vector3 centroidSum;
-
- std::vector<uint32_t> seeds; // @@ These could be a pointers to the halfedge faces directly.
- std::vector<uint32_t> faces;
+ int id = -1;
+ Vector3 averageNormal = Vector3(0.0f);
+ float area = 0.0f;
+ float boundaryLength = 0.0f;
+ Vector3 normalSum = Vector3(0.0f);
+ Vector3 centroidSum = Vector3(0.0f); // Sum of chart face centroids.
+ Vector3 centroid = Vector3(0.0f); // Average centroid of chart faces.
+ Array<uint32_t> seeds;
+ Array<uint32_t> faces;
PriorityQueue candidates;
+ Basis basis; // Of first face.
};
struct AtlasBuilder
{
- AtlasBuilder(const halfedge::Mesh *m) : mesh(m), facesLeft(m->faceCount())
+ // @@ Hardcoded to 10?
+ AtlasBuilder(const Mesh *mesh, Array<uint32_t> *meshFaces, const ChartOptions &options) : m_mesh(mesh), m_meshFaces(meshFaces), m_facesLeft(mesh->faceCount()), m_bestTriangles(10), m_options(options)
{
- const uint32_t faceCount = m->faceCount();
- faceChartArray.resize(faceCount, -1);
- faceCandidateArray.resize(faceCount, (uint32_t)-1);
+ XA_PROFILE_START(atlasBuilderInit)
+ const uint32_t faceCount = m_mesh->faceCount();
+ if (meshFaces) {
+ m_ignoreFaces.resize(faceCount, true);
+ for (uint32_t f = 0; f < meshFaces->size(); f++)
+ m_ignoreFaces[(*meshFaces)[f]] = false;
+ m_facesLeft = meshFaces->size();
+ } else {
+ m_ignoreFaces.resize(faceCount, false);
+ }
+ m_faceChartArray.resize(faceCount, -1);
+ m_faceCandidateArray.resize(faceCount, (uint32_t)-1);
+ m_texcoords.resize(faceCount * 3);
// @@ Floyd for the whole mesh is too slow. We could compute floyd progressively per patch as the patch grows. We need a better solution to compute most central faces.
//computeShortestPaths();
// Precompute edge lengths and face areas.
- uint32_t edgeCount = m->edgeCount();
- edgeLengths.resize(edgeCount);
- for (uint32_t i = 0; i < edgeCount; i++) {
- uint32_t id = m->edgeAt(i)->id;
- xaDebugAssert(id / 2 == i);
-#ifdef NDEBUG
- id = 0; // silence unused parameter warning
-#endif
- edgeLengths[i] = m->edgeAt(i)->length();
- }
- faceAreas.resize(faceCount);
- for (uint32_t i = 0; i < faceCount; i++) {
- faceAreas[i] = m->faceAt(i)->area();
+ const uint32_t edgeCount = m_mesh->edgeCount();
+ m_edgeLengths.resize(edgeCount, 0.0f);
+ m_faceAreas.resize(m_mesh->faceCount(), 0.0f);
+ m_faceNormals.resize(m_mesh->faceCount());
+ for (uint32_t f = 0; f < faceCount; f++) {
+ if (m_ignoreFaces[f])
+ continue;
+ for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+ m_edgeLengths[it.edge()] = internal::length(it.position1() - it.position0());
+ XA_DEBUG_ASSERT(m_edgeLengths[it.edge()] > 0.0f);
+ }
+ m_faceAreas[f] = mesh->faceArea(f);
+ XA_DEBUG_ASSERT(m_faceAreas[f] > 0.0f);
+ m_faceNormals[f] = m_mesh->triangleNormal(f);
}
+ XA_PROFILE_END(atlasBuilderInit)
}
~AtlasBuilder()
{
- const uint32_t chartCount = chartArray.size();
+ const uint32_t chartCount = m_chartArray.size();
for (uint32_t i = 0; i < chartCount; i++) {
- delete chartArray[i];
+ m_chartArray[i]->~ChartBuildData();
+ XA_FREE(m_chartArray[i]);
}
}
- void markUnchartedFaces(const std::vector<uint32_t> &unchartedFaces)
+ uint32_t facesLeft() const { return m_facesLeft; }
+ uint32_t chartCount() const { return m_chartArray.size(); }
+ const Array<uint32_t> &chartFaces(uint32_t i) const { return m_chartArray[i]->faces; }
+ const Basis &chartBasis(uint32_t chartIndex) const { return m_chartArray[chartIndex]->basis; }
+
+ void placeSeeds(float threshold)
{
- const uint32_t unchartedFaceCount = unchartedFaces.size();
- for (uint32_t i = 0; i < unchartedFaceCount; i++) {
- uint32_t f = unchartedFaces[i];
- faceChartArray[f] = -2;
- //faceCandidateArray[f] = -2; // @@ ?
- removeCandidate(f);
- }
- xaDebugAssert(facesLeft >= unchartedFaceCount);
- facesLeft -= unchartedFaceCount;
+ // Instead of using a predefiened number of seeds:
+ // - Add seeds one by one, growing chart until a certain treshold.
+ // - Undo charts and restart growing process.
+ // @@ How can we give preference to faces far from sharp features as in the LSCM paper?
+ // - those points can be found using a simple flood filling algorithm.
+ // - how do we weight the probabilities?
+ while (m_facesLeft > 0)
+ createRandomChart(threshold);
}
- void computeShortestPaths()
+ // Returns true if any of the charts can grow more.
+ bool growCharts(float threshold, uint32_t faceCount)
{
- const uint32_t faceCount = mesh->faceCount();
- shortestPaths.resize(faceCount * faceCount, FLT_MAX);
- // Fill edges:
+ XA_PROFILE_START(atlasBuilderGrowCharts)
+ // Using one global list.
+ faceCount = min(faceCount, m_facesLeft);
+ bool canAddAny = false;
for (uint32_t i = 0; i < faceCount; i++) {
- shortestPaths[i * faceCount + i] = 0.0f;
- const halfedge::Face *face_i = mesh->faceAt(i);
- Vector3 centroid_i = face_i->centroid();
- for (halfedge::Face::ConstEdgeIterator it(face_i->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- if (!edge->isBoundary()) {
- const halfedge::Face *face_j = edge->pair->face;
- uint32_t j = face_j->id;
- Vector3 centroid_j = face_j->centroid();
- shortestPaths[i * faceCount + j] = shortestPaths[j * faceCount + i] = length(centroid_i - centroid_j);
- }
+ const Candidate &candidate = getBestCandidate();
+ if (candidate.metric > threshold) {
+ XA_PROFILE_END(atlasBuilderGrowCharts)
+ return false; // Can't grow more.
}
+ createFaceTexcoords(candidate.chart, candidate.face);
+ if (!canAddFaceToChart(candidate.chart, candidate.face))
+ continue;
+ addFaceToChart(candidate.chart, candidate.face);
+ canAddAny = true;
}
- // Use Floyd-Warshall algorithm to compute all paths:
- for (uint32_t k = 0; k < faceCount; k++) {
- for (uint32_t i = 0; i < faceCount; i++) {
- for (uint32_t j = 0; j < faceCount; j++) {
- shortestPaths[i * faceCount + j] = std::min(shortestPaths[i * faceCount + j], shortestPaths[i * faceCount + k] + shortestPaths[k * faceCount + j]);
- }
+ XA_PROFILE_END(atlasBuilderGrowCharts)
+ return canAddAny && m_facesLeft != 0; // Can continue growing.
+ }
+
+ void resetCharts()
+ {
+ const uint32_t faceCount = m_mesh->faceCount();
+ for (uint32_t i = 0; i < faceCount; i++) {
+ m_faceChartArray[i] = -1;
+ m_faceCandidateArray[i] = (uint32_t)-1;
+ }
+ m_facesLeft = m_meshFaces ? m_meshFaces->size() : faceCount;
+ m_candidateArray.clear();
+ const uint32_t chartCount = m_chartArray.size();
+ for (uint32_t i = 0; i < chartCount; i++) {
+ ChartBuildData *chart = m_chartArray[i];
+ const uint32_t seed = chart->seeds.back();
+ chart->area = 0.0f;
+ chart->boundaryLength = 0.0f;
+ chart->normalSum = Vector3(0.0f);
+ chart->centroidSum = Vector3(0.0f);
+ chart->centroid = Vector3(0.0f);
+ chart->faces.clear();
+ chart->candidates.clear();
+ addFaceToChart(chart, seed);
+ }
+#if XA_GROW_CHARTS_COPLANAR
+ for (uint32_t i = 0; i < chartCount; i++) {
+ ChartBuildData *chart = m_chartArray[i];
+ growChartCoplanar(chart);
+ }
+#endif
+ }
+
+ void updateCandidates(ChartBuildData *chart, uint32_t f)
+ {
+ // Traverse neighboring faces, add the ones that do not belong to any chart yet.
+ for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+ if (!it.isBoundary() && !m_ignoreFaces[it.oppositeFace()] && m_faceChartArray[it.oppositeFace()] == -1)
+ chart->candidates.push(it.oppositeFace());
+ }
+ }
+
+ void updateProxies()
+ {
+ const uint32_t chartCount = m_chartArray.size();
+ for (uint32_t i = 0; i < chartCount; i++)
+ updateProxy(m_chartArray[i]);
+ }
+
+ bool relocateSeeds()
+ {
+ bool anySeedChanged = false;
+ const uint32_t chartCount = m_chartArray.size();
+ for (uint32_t i = 0; i < chartCount; i++) {
+ if (relocateSeed(m_chartArray[i])) {
+ anySeedChanged = true;
}
}
+ return anySeedChanged;
}
- void placeSeeds(float threshold, uint32_t maxSeedCount)
+ void fillHoles(float threshold)
{
- // Instead of using a predefiened number of seeds:
- // - Add seeds one by one, growing chart until a certain treshold.
- // - Undo charts and restart growing process.
- // @@ How can we give preference to faces far from sharp features as in the LSCM paper?
- // - those points can be found using a simple flood filling algorithm.
- // - how do we weight the probabilities?
- for (uint32_t i = 0; i < maxSeedCount; i++) {
- if (facesLeft == 0) {
- // No faces left, stop creating seeds.
+ while (m_facesLeft > 0)
+ createRandomChart(threshold);
+ }
+
+#if XA_MERGE_CHARTS
+ void mergeCharts()
+ {
+ XA_PROFILE_START(atlasBuilderMergeCharts)
+ Array<float> sharedBoundaryLengths;
+ Array<float> sharedBoundaryLengthsNoSeams;
+ Array<uint32_t> sharedBoundaryEdgeCountNoSeams;
+ Array<Vector2> tempTexcoords;
+ const uint32_t chartCount = m_chartArray.size();
+ // Merge charts progressively until there's none left to merge.
+ for (;;) {
+ bool merged = false;
+ for (int c = chartCount - 1; c >= 0; c--) {
+ ChartBuildData *chart = m_chartArray[c];
+ if (chart == nullptr)
+ continue;
+ float externalBoundaryLength = 0.0f;
+ sharedBoundaryLengths.clear();
+ sharedBoundaryLengths.resize(chartCount, 0.0f);
+ sharedBoundaryLengthsNoSeams.clear();
+ sharedBoundaryLengthsNoSeams.resize(chartCount, 0.0f);
+ sharedBoundaryEdgeCountNoSeams.clear();
+ sharedBoundaryEdgeCountNoSeams.resize(chartCount, 0u);
+ const uint32_t faceCount = chart->faces.size();
+ for (uint32_t i = 0; i < faceCount; i++) {
+ const uint32_t f = chart->faces[i];
+ for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+ const float l = m_edgeLengths[it.edge()];
+ if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()]) {
+ externalBoundaryLength += l;
+ } else {
+ const int neighborChart = m_faceChartArray[it.oppositeFace()];
+ if (m_chartArray[neighborChart] != chart) {
+ if ((it.isSeam() && (isNormalSeam(it.edge()) || it.isTextureSeam()))) {
+ externalBoundaryLength += l;
+ } else {
+ sharedBoundaryLengths[neighborChart] += l;
+ }
+ sharedBoundaryLengthsNoSeams[neighborChart] += l;
+ sharedBoundaryEdgeCountNoSeams[neighborChart]++;
+ }
+ }
+ }
+ }
+ for (int cc = chartCount - 1; cc >= 0; cc--) {
+ if (cc == c)
+ continue;
+ ChartBuildData *chart2 = m_chartArray[cc];
+ if (chart2 == nullptr)
+ continue;
+ // Compare proxies.
+ if (dot(chart2->averageNormal, chart->averageNormal) < XA_MERGE_CHARTS_MIN_NORMAL_DEVIATION)
+ continue;
+ // Obey max chart area and boundary length.
+ if (m_options.maxChartArea > 0.0f && chart->area + chart2->area > m_options.maxChartArea)
+ continue;
+ if (m_options.maxBoundaryLength > 0.0f && chart->boundaryLength + chart2->boundaryLength - sharedBoundaryLengthsNoSeams[cc] > m_options.maxBoundaryLength)
+ continue;
+ // Merge if chart2 has a single face.
+ // chart1 must have more than 1 face.
+ // chart2 area must be <= 10% of chart1 area.
+ if (sharedBoundaryLengthsNoSeams[cc] > 0.0f && chart->faces.size() > 1 && chart2->faces.size() == 1 && chart2->area <= chart->area * 0.1f)
+ goto merge;
+ // Merge if chart2 has two faces (probably a quad), and chart1 bounds at least 2 of its edges.
+ if (chart2->faces.size() == 2 && sharedBoundaryEdgeCountNoSeams[cc] >= 2)
+ goto merge;
+ // Merge if chart2 is wholely inside chart1, ignoring seams.
+ if (sharedBoundaryLengthsNoSeams[cc] > 0.0f && equal(sharedBoundaryLengthsNoSeams[cc], chart2->boundaryLength, kEpsilon))
+ goto merge;
+ if (sharedBoundaryLengths[cc] > 0.2f * max(0.0f, chart->boundaryLength - externalBoundaryLength) ||
+ sharedBoundaryLengths[cc] > 0.75f * chart2->boundaryLength)
+ goto merge;
+ continue;
+ merge:
+ // Create texcoords for chart 2 using chart 1 basis. Backup chart 2 texcoords for restoration if charts cannot be merged.
+ tempTexcoords.resize(chart2->faces.size());
+ for (uint32_t i = 0; i < chart2->faces.size(); i++) {
+ const uint32_t face = chart2->faces[i];
+ tempTexcoords[i] = m_texcoords[face];
+ createFaceTexcoords(chart, face);
+ }
+ if (!canMergeCharts(chart, chart2)) {
+ // Restore chart 2 texcoords.
+ for (uint32_t i = 0; i < chart2->faces.size(); i++)
+ m_texcoords[chart2->faces[i]] = tempTexcoords[i];
+ continue;
+ }
+ mergeChart(chart, chart2, sharedBoundaryLengthsNoSeams[cc]);
+ merged = true;
+ break;
+ }
+ if (merged)
+ break;
+ }
+ if (!merged)
break;
+ }
+ // Remove deleted charts.
+ for (int c = 0; c < int32_t(m_chartArray.size()); /*do not increment if removed*/) {
+ if (m_chartArray[c] == nullptr) {
+ m_chartArray.removeAt(c);
+ // Update m_faceChartArray.
+ const uint32_t faceCount = m_faceChartArray.size();
+ for (uint32_t i = 0; i < faceCount; i++) {
+ XA_DEBUG_ASSERT(m_faceChartArray[i] != c);
+ XA_DEBUG_ASSERT(m_faceChartArray[i] <= int32_t(m_chartArray.size()));
+ if (m_faceChartArray[i] > c) {
+ m_faceChartArray[i]--;
+ }
+ }
+ } else {
+ m_chartArray[c]->id = c;
+ c++;
}
- createRandomChart(threshold);
}
+ XA_PROFILE_END(atlasBuilderMergeCharts)
}
+#endif
+private:
void createRandomChart(float threshold)
{
- ChartBuildData *chart = new ChartBuildData(chartArray.size());
- chartArray.push_back(chart);
+ ChartBuildData *chart = XA_NEW(MemTag::Default, ChartBuildData);
+ chart->id = (int)m_chartArray.size();
+ m_chartArray.push_back(chart);
// Pick random face that is not used by any chart yet.
- uint32_t randomFaceIdx = rand.getRange(facesLeft - 1);
- uint32_t i = 0;
- for (uint32_t f = 0; f != randomFaceIdx; f++, i++) {
- while (faceChartArray[i] != -1) i++;
- }
- while (faceChartArray[i] != -1) i++;
- chart->seeds.push_back(i);
- addFaceToChart(chart, i, true);
+ uint32_t face = m_rand.getRange(m_mesh->faceCount() - 1);
+ while (m_ignoreFaces[face] || m_faceChartArray[face] != -1) {
+ if (++face >= m_mesh->faceCount())
+ face = 0;
+ }
+ chart->seeds.push_back(face);
+ addFaceToChart(chart, face, true);
+#if XA_GROW_CHARTS_COPLANAR
+ growChartCoplanar(chart);
+#endif
// Grow the chart as much as possible within the given threshold.
- growChart(chart, threshold * 0.5f, facesLeft);
- //growCharts(threshold - threshold * 0.75f / chartCount(), facesLeft);
+ growChart(chart, threshold, m_facesLeft);
+ }
+
+ void createFaceTexcoords(ChartBuildData *chart, uint32_t face)
+ {
+ for (uint32_t i = 0; i < 3; i++) {
+ const Vector3 &pos = m_mesh->position(m_mesh->vertexAt(face * 3 + i));
+ m_texcoords[face * 3 + i] = Vector2(dot(chart->basis.tangent, pos), dot(chart->basis.bitangent, pos));
+ }
+ }
+
+ bool isChartBoundaryEdge(ChartBuildData *chart, uint32_t edge) const
+ {
+ const uint32_t oppositeEdge = m_mesh->oppositeEdge(edge);
+ const uint32_t oppositeFace = meshEdgeFace(oppositeEdge);
+ return oppositeEdge == UINT32_MAX || m_ignoreFaces[oppositeFace] || m_faceChartArray[oppositeFace] != chart->id;
+ }
+
+ bool canAddFaceToChart(ChartBuildData *chart, uint32_t face)
+ {
+ // Find face edges that are on a mesh boundary or form a boundary with another chart.
+ uint32_t edgesToCompare[3];
+ for (uint32_t i = 0; i < 3; i++) {
+ const uint32_t edge = face * 3 + i;
+ const uint32_t oppositeEdge = m_mesh->oppositeEdge(edge);
+ const uint32_t oppositeFace = meshEdgeFace(oppositeEdge);
+ if (oppositeEdge == UINT32_MAX || m_ignoreFaces[oppositeFace] || m_faceChartArray[oppositeFace] != chart->id)
+ edgesToCompare[i] = edge;
+ else
+ edgesToCompare[i] = UINT32_MAX;
+ }
+ // All edges on boundary? This can happen if the face is surrounded by the chart.
+ if (edgesToCompare[0] == UINT32_MAX && edgesToCompare[1] == UINT32_MAX && edgesToCompare[2] == UINT32_MAX)
+ return true;
+ // Check if any valid face edge intersects the chart boundary.
+ for (uint32_t i = 0; i < chart->faces.size(); i++) {
+ const uint32_t chartFace = chart->faces[i];
+ for (uint32_t j = 0; j < 3; j++) {
+ const uint32_t chartEdge = chartFace * 3 + j;
+ if (!isChartBoundaryEdge(chart, chartEdge))
+ continue;
+ // Don't check chart boundary edges that border the face.
+ const uint32_t oppositeChartEdge = m_mesh->oppositeEdge(chartEdge);
+ if (meshEdgeFace(oppositeChartEdge) == face)
+ continue;
+ for (uint32_t k = 0; k < 3; k++) {
+ if (edgesToCompare[k] == UINT32_MAX)
+ continue;
+ const uint32_t e1 = chartEdge;
+ const uint32_t e2 = edgesToCompare[k];
+ if (linesIntersect(m_texcoords[meshEdgeIndex0(e1)], m_texcoords[meshEdgeIndex1(e1)], m_texcoords[meshEdgeIndex0(e2)], m_texcoords[meshEdgeIndex1(e2)], m_mesh->epsilon()))
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ bool canMergeCharts(ChartBuildData *chart1, ChartBuildData *chart2)
+ {
+ for (uint32_t f1 = 0; f1 < chart1->faces.size(); f1++) {
+ const uint32_t face1 = chart1->faces[f1];
+ for (uint32_t i = 0; i < 3; i++) {
+ const uint32_t edge1 = face1 * 3 + i;
+ if (!isChartBoundaryEdge(chart1, edge1))
+ continue;
+ for (uint32_t f2 = 0; f2 < chart2->faces.size(); f2++) {
+ const uint32_t face2 = chart2->faces[f2];
+ for (uint32_t j = 0; j < 3; j++) {
+ const uint32_t edge2 = face2 * 3 + j;
+ if (!isChartBoundaryEdge(chart2, edge2))
+ continue;
+ if (linesIntersect(m_texcoords[meshEdgeIndex0(edge1)], m_texcoords[meshEdgeIndex1(edge1)], m_texcoords[meshEdgeIndex0(edge2)], m_texcoords[meshEdgeIndex1(edge2)], m_mesh->epsilon()))
+ return false;
+ }
+ }
+ }
+ }
+ return true;
}
void addFaceToChart(ChartBuildData *chart, uint32_t f, bool recomputeProxy = false)
{
+ // Use the first face normal as the chart basis.
+ if (chart->faces.isEmpty()) {
+ chart->basis.buildFrameForDirection(m_faceNormals[f]);
+ createFaceTexcoords(chart, f);
+ }
// Add face to chart.
chart->faces.push_back(f);
- xaDebugAssert(faceChartArray[f] == -1);
- faceChartArray[f] = chart->id;
- facesLeft--;
+ XA_DEBUG_ASSERT(m_faceChartArray[f] == -1);
+ m_faceChartArray[f] = chart->id;
+ m_facesLeft--;
// Update area and boundary length.
chart->area = evaluateChartArea(chart, f);
chart->boundaryLength = evaluateBoundaryLength(chart, f);
chart->normalSum = evaluateChartNormalSum(chart, f);
- chart->centroidSum = evaluateChartCentroidSum(chart, f);
+ chart->centroidSum += m_mesh->triangleCenter(f);
if (recomputeProxy) {
// Update proxy and candidate's priorities.
updateProxy(chart);
@@ -5126,142 +5173,93 @@ struct AtlasBuilder
updatePriorities(chart);
}
- // Returns true if any of the charts can grow more.
- bool growCharts(float threshold, uint32_t faceCount)
- {
- // Using one global list.
- faceCount = std::min(faceCount, facesLeft);
- for (uint32_t i = 0; i < faceCount; i++) {
- const Candidate &candidate = getBestCandidate();
- if (candidate.metric > threshold) {
- return false; // Can't grow more.
- }
- addFaceToChart(candidate.chart, candidate.face);
- }
- return facesLeft != 0; // Can continue growing.
- }
-
bool growChart(ChartBuildData *chart, float threshold, uint32_t faceCount)
{
// Try to add faceCount faces within threshold to chart.
for (uint32_t i = 0; i < faceCount; ) {
- if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold) {
+ if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold)
return false;
- }
- uint32_t f = chart->candidates.pop();
- if (faceChartArray[f] == -1) {
- addFaceToChart(chart, f);
- i++;
- }
+ const uint32_t f = chart->candidates.pop();
+ if (m_faceChartArray[f] != -1)
+ continue;
+ createFaceTexcoords(chart, f);
+ if (!canAddFaceToChart(chart, f))
+ continue;
+ addFaceToChart(chart, f);
+ i++;
}
- if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold) {
+ if (chart->candidates.count() == 0 || chart->candidates.firstPriority() > threshold)
return false;
- }
return true;
}
- void resetCharts()
+#if XA_GROW_CHARTS_COPLANAR
+ void growChartCoplanar(ChartBuildData *chart)
{
- const uint32_t faceCount = mesh->faceCount();
- for (uint32_t i = 0; i < faceCount; i++) {
- faceChartArray[i] = -1;
- faceCandidateArray[i] = (uint32_t)-1;
- }
- facesLeft = faceCount;
- candidateArray.clear();
- const uint32_t chartCount = chartArray.size();
- for (uint32_t i = 0; i < chartCount; i++) {
- ChartBuildData *chart = chartArray[i];
- const uint32_t seed = chart->seeds.back();
- chart->area = 0.0f;
- chart->boundaryLength = 0.0f;
- chart->normalSum = Vector3(0);
- chart->centroidSum = Vector3(0);
- chart->faces.clear();
- chart->candidates.clear();
- addFaceToChart(chart, seed);
- }
- }
-
- void updateCandidates(ChartBuildData *chart, uint32_t f)
- {
- const halfedge::Face *face = mesh->faceAt(f);
- // Traverse neighboring faces, add the ones that do not belong to any chart yet.
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current()->pair;
- if (!edge->isBoundary()) {
- uint32_t faceId = edge->face->id;
- if (faceChartArray[faceId] == -1) {
- chart->candidates.push(faceId);
+ XA_DEBUG_ASSERT(!chart->faces.isEmpty());
+ const Vector3 chartNormal = m_faceNormals[chart->faces[0]];
+ m_growFaces.clear();
+ for (uint32_t f = 0; f < chart->faces.size(); f++)
+ m_growFaces.push_back(chart->faces[f]);
+ for (;;) {
+ if (m_growFaces.isEmpty())
+ break;
+ const uint32_t face = m_growFaces.back();
+ m_growFaces.pop_back();
+ for (Mesh::FaceEdgeIterator it(m_mesh, face); !it.isDone(); it.advance()) {
+ if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()] || m_faceChartArray[it.oppositeFace()] != -1)
+ continue;
+ if (equal(dot(chartNormal, m_faceNormals[it.oppositeFace()]), 1.0f, kEpsilon)) {
+ createFaceTexcoords(chart, it.oppositeFace());
+ addFaceToChart(chart, it.oppositeFace());
+ m_growFaces.push_back(it.oppositeFace());
}
}
}
}
+#endif
- void updateProxies()
- {
- const uint32_t chartCount = chartArray.size();
- for (uint32_t i = 0; i < chartCount; i++) {
- updateProxy(chartArray[i]);
- }
- }
-
- void updateProxy(ChartBuildData *chart)
+ void updateProxy(ChartBuildData *chart) const
{
//#pragma message(NV_FILE_LINE "TODO: Use best fit plane instead of average normal.")
- chart->planeNormal = normalizeSafe(chart->normalSum, Vector3(0), 0.0f);
+ chart->averageNormal = normalizeSafe(chart->normalSum, Vector3(0), 0.0f);
chart->centroid = chart->centroidSum / float(chart->faces.size());
}
- bool relocateSeeds()
- {
- bool anySeedChanged = false;
- const uint32_t chartCount = chartArray.size();
- for (uint32_t i = 0; i < chartCount; i++) {
- if (relocateSeed(chartArray[i])) {
- anySeedChanged = true;
- }
- }
- return anySeedChanged;
- }
-
bool relocateSeed(ChartBuildData *chart)
{
- Vector3 centroid = computeChartCentroid(chart);
- const uint32_t N = 10; // @@ Hardcoded to 10?
- PriorityQueue bestTriangles(N);
// Find the first N triangles that fit the proxy best.
const uint32_t faceCount = chart->faces.size();
+ m_bestTriangles.clear();
for (uint32_t i = 0; i < faceCount; i++) {
float priority = evaluateProxyFitMetric(chart, chart->faces[i]);
- bestTriangles.push(priority, chart->faces[i]);
+ m_bestTriangles.push(priority, chart->faces[i]);
}
- // Of those, choose the most central triangle.
- uint32_t mostCentral;
+ // Of those, choose the least central triangle.
+ uint32_t leastCentral = 0;
float maxDistance = -1;
- const uint32_t bestCount = bestTriangles.count();
+ const uint32_t bestCount = m_bestTriangles.count();
for (uint32_t i = 0; i < bestCount; i++) {
- const halfedge::Face *face = mesh->faceAt(bestTriangles.pairs[i].face);
- Vector3 faceCentroid = face->triangleCenter();
- float distance = length(centroid - faceCentroid);
+ Vector3 faceCentroid = m_mesh->triangleCenter(m_bestTriangles.pairs[i].face);
+ float distance = length(chart->centroid - faceCentroid);
if (distance > maxDistance) {
maxDistance = distance;
- mostCentral = bestTriangles.pairs[i].face;
+ leastCentral = m_bestTriangles.pairs[i].face;
}
}
- xaDebugAssert(maxDistance >= 0);
+ XA_DEBUG_ASSERT(maxDistance >= 0);
// In order to prevent k-means cyles we record all the previously chosen seeds.
- uint32_t index = std::find(chart->seeds.begin(), chart->seeds.end(), mostCentral) - chart->seeds.begin();
- if (index < chart->seeds.size()) {
- // Move new seed to the end of the seed array.
- uint32_t last = chart->seeds.size() - 1;
- std::swap(chart->seeds[index], chart->seeds[last]);
- return false;
- } else {
- // Append new seed.
- chart->seeds.push_back(mostCentral);
- return true;
+ for (uint32_t i = 0; i < chart->seeds.size(); i++) {
+ if (chart->seeds[i] == leastCentral) {
+ // Move new seed to the end of the seed array.
+ uint32_t last = chart->seeds.size() - 1;
+ swap(chart->seeds[i], chart->seeds[last]);
+ return false;
+ }
}
+ // Append new seed.
+ chart->seeds.push_back(leastCentral);
+ return true;
}
void updatePriorities(ChartBuildData *chart)
@@ -5269,299 +5267,197 @@ struct AtlasBuilder
// Re-evaluate candidate priorities.
uint32_t candidateCount = chart->candidates.count();
for (uint32_t i = 0; i < candidateCount; i++) {
- chart->candidates.pairs[i].priority = evaluatePriority(chart, chart->candidates.pairs[i].face);
- if (faceChartArray[chart->candidates.pairs[i].face] == -1) {
- updateCandidate(chart, chart->candidates.pairs[i].face, chart->candidates.pairs[i].priority);
- }
+ PriorityQueue::Pair &pair = chart->candidates.pairs[i];
+ pair.priority = evaluatePriority(chart, pair.face);
+ if (m_faceChartArray[pair.face] == -1)
+ updateCandidate(chart, pair.face, pair.priority);
}
// Sort candidates.
chart->candidates.sort();
}
// Evaluate combined metric.
- float evaluatePriority(ChartBuildData *chart, uint32_t face)
+ float evaluatePriority(ChartBuildData *chart, uint32_t face) const
{
// Estimate boundary length and area:
- float newBoundaryLength = evaluateBoundaryLength(chart, face);
- float newChartArea = evaluateChartArea(chart, face);
- float F = evaluateProxyFitMetric(chart, face);
- float C = evaluateRoundnessMetric(chart, face, newBoundaryLength, newChartArea);
- float P = evaluateStraightnessMetric(chart, face);
+ const float newChartArea = evaluateChartArea(chart, face);
+ const float newBoundaryLength = evaluateBoundaryLength(chart, face);
+ // Enforce limits strictly:
+ if (m_options.maxChartArea > 0.0f && newChartArea > m_options.maxChartArea)
+ return FLT_MAX;
+ if (m_options.maxBoundaryLength > 0.0f && newBoundaryLength > m_options.maxBoundaryLength)
+ return FLT_MAX;
+ if (dot(m_faceNormals[face], chart->averageNormal) < 0.5f)
+ return FLT_MAX;
// Penalize faces that cross seams, reward faces that close seams or reach boundaries.
- float N = evaluateNormalSeamMetric(chart, face);
- float T = evaluateTextureSeamMetric(chart, face);
+ // Make sure normal seams are fully respected:
+ const float N = evaluateNormalSeamMetric(chart, face);
+ if (m_options.normalSeamMetricWeight >= 1000.0f && N > 0.0f)
+ return FLT_MAX;
+ float cost = m_options.normalSeamMetricWeight * N;
+ if (m_options.proxyFitMetricWeight > 0.0f)
+ cost += m_options.proxyFitMetricWeight * evaluateProxyFitMetric(chart, face);
+ if (m_options.roundnessMetricWeight > 0.0f)
+ cost += m_options.roundnessMetricWeight * evaluateRoundnessMetric(chart, face, newBoundaryLength, newChartArea);
+ if (m_options.straightnessMetricWeight > 0.0f)
+ cost += m_options.straightnessMetricWeight * evaluateStraightnessMetric(chart, face);
+ if (m_options.textureSeamMetricWeight > 0.0f)
+ cost += m_options.textureSeamMetricWeight * evaluateTextureSeamMetric(chart, face);
//float R = evaluateCompletenessMetric(chart, face);
//float D = evaluateDihedralAngleMetric(chart, face);
// @@ Add a metric based on local dihedral angle.
// @@ Tweaking the normal and texture seam metrics.
// - Cause more impedance. Never cross 90 degree edges.
- // -
- float cost = float(
- options.proxyFitMetricWeight * F +
- options.roundnessMetricWeight * C +
- options.straightnessMetricWeight * P +
- options.normalSeamMetricWeight * N +
- options.textureSeamMetricWeight * T);
- // Enforce limits strictly:
- if (newChartArea > options.maxChartArea) cost = FLT_MAX;
- if (newBoundaryLength > options.maxBoundaryLength) cost = FLT_MAX;
- // Make sure normal seams are fully respected:
- if (options.normalSeamMetricWeight >= 1000 && N != 0) cost = FLT_MAX;
- xaAssert(std::isfinite(cost));
+ XA_DEBUG_ASSERT(isFinite(cost));
return cost;
}
// Returns a value in [0-1].
- float evaluateProxyFitMetric(ChartBuildData *chart, uint32_t f)
+ float evaluateProxyFitMetric(ChartBuildData *chart, uint32_t f) const
{
- const halfedge::Face *face = mesh->faceAt(f);
- Vector3 faceNormal = face->triangleNormal();
+ const Vector3 faceNormal = m_faceNormals[f];
// Use plane fitting metric for now:
- return 1 - dot(faceNormal, chart->planeNormal); // @@ normal deviations should be weighted by face area
+ return 1 - dot(faceNormal, chart->averageNormal); // @@ normal deviations should be weighted by face area
}
- float evaluateRoundnessMetric(ChartBuildData *chart, uint32_t /*face*/, float newBoundaryLength, float newChartArea)
+ float evaluateRoundnessMetric(ChartBuildData *chart, uint32_t /*face*/, float newBoundaryLength, float newChartArea) const
{
float roundness = square(chart->boundaryLength) / chart->area;
float newRoundness = square(newBoundaryLength) / newChartArea;
if (newRoundness > roundness) {
- return square(newBoundaryLength) / (newChartArea * 4 * PI);
+ return square(newBoundaryLength) / (newChartArea * 4.0f * kPi);
} else {
// Offer no impedance to faces that improve roundness.
return 0;
}
}
- float evaluateStraightnessMetric(ChartBuildData *chart, uint32_t f)
+ float evaluateStraightnessMetric(ChartBuildData *chart, uint32_t f) const
{
float l_out = 0.0f;
float l_in = 0.0f;
- const halfedge::Face *face = mesh->faceAt(f);
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- float l = edgeLengths[edge->id / 2];
- if (edge->isBoundary()) {
+ for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+ float l = m_edgeLengths[it.edge()];
+ if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()]) {
l_out += l;
} else {
- uint32_t neighborFaceId = edge->pair->face->id;
- if (faceChartArray[neighborFaceId] != chart->id) {
+ if (m_faceChartArray[it.oppositeFace()] != chart->id) {
l_out += l;
} else {
l_in += l;
}
}
}
- xaDebugAssert(l_in != 0.0f); // Candidate face must be adjacent to chart. @@ This is not true if the input mesh has zero-length edges.
+ XA_DEBUG_ASSERT(l_in != 0.0f); // Candidate face must be adjacent to chart. @@ This is not true if the input mesh has zero-length edges.
float ratio = (l_out - l_in) / (l_out + l_in);
- return std::min(ratio, 0.0f); // Only use the straightness metric to close gaps.
+ return min(ratio, 0.0f); // Only use the straightness metric to close gaps.
}
- float evaluateNormalSeamMetric(ChartBuildData *chart, uint32_t f)
+ bool isNormalSeam(uint32_t edge) const
+ {
+ const uint32_t oppositeEdge = m_mesh->oppositeEdge(edge);
+ if (oppositeEdge == UINT32_MAX)
+ return false; // boundary edge
+ if (m_mesh->flags() & MeshFlags::HasNormals) {
+ const uint32_t v0 = m_mesh->vertexAt(meshEdgeIndex0(edge));
+ const uint32_t v1 = m_mesh->vertexAt(meshEdgeIndex1(edge));
+ const uint32_t ov0 = m_mesh->vertexAt(meshEdgeIndex0(oppositeEdge));
+ const uint32_t ov1 = m_mesh->vertexAt(meshEdgeIndex1(oppositeEdge));
+ return m_mesh->normal(v0) != m_mesh->normal(ov1) || m_mesh->normal(v1) != m_mesh->normal(ov0);
+ }
+ return m_faceNormals[meshEdgeFace(edge)] != m_faceNormals[meshEdgeFace(oppositeEdge)];
+ }
+
+ float evaluateNormalSeamMetric(ChartBuildData *chart, uint32_t f) const
{
float seamFactor = 0.0f;
float totalLength = 0.0f;
- const halfedge::Face *face = mesh->faceAt(f);
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- if (edge->isBoundary()) {
+ for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+ if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()])
continue;
- }
- const uint32_t neighborFaceId = edge->pair->face->id;
- if (faceChartArray[neighborFaceId] != chart->id) {
+ if (m_faceChartArray[it.oppositeFace()] != chart->id)
continue;
- }
- //float l = edge->length();
- float l = edgeLengths[edge->id / 2];
+ float l = m_edgeLengths[it.edge()];
totalLength += l;
- if (!edge->isSeam()) {
+ if (!it.isSeam())
continue;
- }
// Make sure it's a normal seam.
- if (edge->isNormalSeam()) {
- float d0 = clamp(dot(edge->vertex->nor, edge->pair->next->vertex->nor), 0.0f, 1.0f);
- float d1 = clamp(dot(edge->next->vertex->nor, edge->pair->vertex->nor), 0.0f, 1.0f);
- l *= 1 - (d0 + d1) * 0.5f;
+ if (isNormalSeam(it.edge())) {
+ float d;
+ if (m_mesh->flags() & MeshFlags::HasNormals) {
+ const Vector3 &n0 = m_mesh->normal(it.vertex0());
+ const Vector3 &n1 = m_mesh->normal(it.vertex1());
+ const Vector3 &on0 = m_mesh->normal(m_mesh->vertexAt(meshEdgeIndex0(it.oppositeEdge())));
+ const Vector3 &on1 = m_mesh->normal(m_mesh->vertexAt(meshEdgeIndex1(it.oppositeEdge())));
+ const float d0 = clamp(dot(n0, on1), 0.0f, 1.0f);
+ const float d1 = clamp(dot(n1, on0), 0.0f, 1.0f);
+ d = (d0 + d1) * 0.5f;
+ } else {
+ d = clamp(dot(m_faceNormals[f], m_faceNormals[meshEdgeFace(it.oppositeEdge())]), 0.0f, 1.0f);
+ }
+ l *= 1 - d;
seamFactor += l;
}
}
- if (seamFactor == 0) return 0.0f;
+ if (seamFactor <= 0.0f)
+ return 0.0f;
return seamFactor / totalLength;
}
- float evaluateTextureSeamMetric(ChartBuildData *chart, uint32_t f)
+ float evaluateTextureSeamMetric(ChartBuildData *chart, uint32_t f) const
{
float seamLength = 0.0f;
float totalLength = 0.0f;
- const halfedge::Face *face = mesh->faceAt(f);
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- if (edge->isBoundary()) {
+ for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+ if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()])
continue;
- }
- const uint32_t neighborFaceId = edge->pair->face->id;
- if (faceChartArray[neighborFaceId] != chart->id) {
+ if (m_faceChartArray[it.oppositeFace()] != chart->id)
continue;
- }
- //float l = edge->length();
- float l = edgeLengths[edge->id / 2];
+ float l = m_edgeLengths[it.edge()];
totalLength += l;
- if (!edge->isSeam()) {
+ if (!it.isSeam())
continue;
- }
// Make sure it's a texture seam.
- if (edge->isTextureSeam()) {
+ if (it.isTextureSeam())
seamLength += l;
- }
}
- if (seamLength == 0.0f) {
+ if (seamLength == 0.0f)
return 0.0f; // Avoid division by zero.
- }
return seamLength / totalLength;
}
- float evaluateChartArea(ChartBuildData *chart, uint32_t f)
+ float evaluateChartArea(ChartBuildData *chart, uint32_t f) const
{
- const halfedge::Face *face = mesh->faceAt(f);
- return chart->area + faceAreas[face->id];
+ return chart->area + m_faceAreas[f];
}
- float evaluateBoundaryLength(ChartBuildData *chart, uint32_t f)
+ float evaluateBoundaryLength(ChartBuildData *chart, uint32_t f) const
{
float boundaryLength = chart->boundaryLength;
// Add new edges, subtract edges shared with the chart.
- const halfedge::Face *face = mesh->faceAt(f);
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- //float edgeLength = edge->length();
- float edgeLength = edgeLengths[edge->id / 2];
- if (edge->isBoundary()) {
+ for (Mesh::FaceEdgeIterator it(m_mesh, f); !it.isDone(); it.advance()) {
+ const float edgeLength = m_edgeLengths[it.edge()];
+ if (it.isBoundary() || m_ignoreFaces[it.oppositeFace()]) {
boundaryLength += edgeLength;
} else {
- uint32_t neighborFaceId = edge->pair->face->id;
- if (faceChartArray[neighborFaceId] != chart->id) {
+ if (m_faceChartArray[it.oppositeFace()] != chart->id)
boundaryLength += edgeLength;
- } else {
+ else
boundaryLength -= edgeLength;
- }
}
}
- return std::max(0.0f, boundaryLength); // @@ Hack!
- }
-
- Vector3 evaluateChartNormalSum(ChartBuildData *chart, uint32_t f)
- {
- const halfedge::Face *face = mesh->faceAt(f);
- return chart->normalSum + face->triangleNormalAreaScaled();
+ return max(0.0f, boundaryLength); // @@ Hack!
}
- Vector3 evaluateChartCentroidSum(ChartBuildData *chart, uint32_t f)
+ Vector3 evaluateChartNormalSum(ChartBuildData *chart, uint32_t f) const
{
- const halfedge::Face *face = mesh->faceAt(f);
- return chart->centroidSum + face->centroid();
- }
-
- Vector3 computeChartCentroid(const ChartBuildData *chart)
- {
- Vector3 centroid(0);
- const uint32_t faceCount = chart->faces.size();
- for (uint32_t i = 0; i < faceCount; i++) {
- const halfedge::Face *face = mesh->faceAt(chart->faces[i]);
- centroid += face->triangleCenter();
- }
- return centroid / float(faceCount);
- }
-
- void fillHoles(float threshold)
- {
- while (facesLeft > 0)
- createRandomChart(threshold);
- }
-
- void mergeCharts()
- {
- std::vector<float> sharedBoundaryLengths;
- const uint32_t chartCount = chartArray.size();
- for (int c = chartCount - 1; c >= 0; c--) {
- sharedBoundaryLengths.clear();
- sharedBoundaryLengths.resize(chartCount, 0.0f);
- ChartBuildData *chart = chartArray[c];
- float externalBoundary = 0.0f;
- const uint32_t faceCount = chart->faces.size();
- for (uint32_t i = 0; i < faceCount; i++) {
- uint32_t f = chart->faces[i];
- const halfedge::Face *face = mesh->faceAt(f);
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- //float l = edge->length();
- float l = edgeLengths[edge->id / 2];
- if (edge->isBoundary()) {
- externalBoundary += l;
- } else {
- uint32_t neighborFace = edge->pair->face->id;
- uint32_t neighborChart = faceChartArray[neighborFace];
- if (neighborChart != (uint32_t)c) {
- if ((edge->isSeam() && (edge->isNormalSeam() || edge->isTextureSeam())) || neighborChart == -2) {
- externalBoundary += l;
- } else {
- sharedBoundaryLengths[neighborChart] += l;
- }
- }
- }
- }
- }
- for (int cc = chartCount - 1; cc >= 0; cc--) {
- if (cc == c)
- continue;
- ChartBuildData *chart2 = chartArray[cc];
- if (chart2 == NULL)
- continue;
- if (sharedBoundaryLengths[cc] > 0.8 * std::max(0.0f, chart->boundaryLength - externalBoundary)) {
- // Try to avoid degenerate configurations.
- if (chart2->boundaryLength > sharedBoundaryLengths[cc]) {
- if (dot(chart2->planeNormal, chart->planeNormal) > -0.25) {
- mergeChart(chart2, chart, sharedBoundaryLengths[cc]);
- delete chart;
- chartArray[c] = NULL;
- break;
- }
- }
- }
- if (sharedBoundaryLengths[cc] > 0.20 * std::max(0.0f, chart->boundaryLength - externalBoundary)) {
- // Compare proxies.
- if (dot(chart2->planeNormal, chart->planeNormal) > 0) {
- mergeChart(chart2, chart, sharedBoundaryLengths[cc]);
- delete chart;
- chartArray[c] = NULL;
- break;
- }
- }
- }
- }
- // Remove deleted charts.
- for (int c = 0; c < int32_t(chartArray.size()); /*do not increment if removed*/) {
- if (chartArray[c] == NULL) {
- chartArray.erase(chartArray.begin() + c);
- // Update faceChartArray.
- const uint32_t faceCount = faceChartArray.size();
- for (uint32_t i = 0; i < faceCount; i++) {
- xaDebugAssert (faceChartArray[i] != -1);
- xaDebugAssert (faceChartArray[i] != c);
- xaDebugAssert (faceChartArray[i] <= int32_t(chartArray.size()));
- if (faceChartArray[i] > c) {
- faceChartArray[i]--;
- }
- }
- } else {
- chartArray[c]->id = c;
- c++;
- }
- }
+ return chart->normalSum + m_mesh->triangleNormalAreaScaled(f);
}
// @@ Cleanup.
struct Candidate {
- uint32_t face;
ChartBuildData *chart;
+ uint32_t face;
float metric;
};
@@ -5570,48 +5466,48 @@ struct AtlasBuilder
{
uint32_t best = 0;
float bestCandidateMetric = FLT_MAX;
- const uint32_t candidateCount = candidateArray.size();
- xaAssert(candidateCount > 0);
+ const uint32_t candidateCount = m_candidateArray.size();
+ XA_ASSERT(candidateCount > 0);
for (uint32_t i = 0; i < candidateCount; i++) {
- const Candidate &candidate = candidateArray[i];
+ const Candidate &candidate = m_candidateArray[i];
if (candidate.metric < bestCandidateMetric) {
bestCandidateMetric = candidate.metric;
best = i;
}
}
- return candidateArray[best];
+ return m_candidateArray[best];
}
void removeCandidate(uint32_t f)
{
- int c = faceCandidateArray[f];
+ int c = m_faceCandidateArray[f];
if (c != -1) {
- faceCandidateArray[f] = (uint32_t)-1;
- if (c == int(candidateArray.size() - 1)) {
- candidateArray.pop_back();
+ m_faceCandidateArray[f] = (uint32_t)-1;
+ if (c == int(m_candidateArray.size() - 1)) {
+ m_candidateArray.pop_back();
} else {
// Replace with last.
- candidateArray[c] = candidateArray[candidateArray.size() - 1];
- candidateArray.pop_back();
- faceCandidateArray[candidateArray[c].face] = c;
+ m_candidateArray[c] = m_candidateArray[m_candidateArray.size() - 1];
+ m_candidateArray.pop_back();
+ m_faceCandidateArray[m_candidateArray[c].face] = c;
}
}
}
void updateCandidate(ChartBuildData *chart, uint32_t f, float metric)
{
- if (faceCandidateArray[f] == -1) {
- const uint32_t index = candidateArray.size();
- faceCandidateArray[f] = index;
- candidateArray.resize(index + 1);
- candidateArray[index].face = f;
- candidateArray[index].chart = chart;
- candidateArray[index].metric = metric;
+ if (m_faceCandidateArray[f] == (uint32_t)-1) {
+ const uint32_t index = m_candidateArray.size();
+ m_faceCandidateArray[f] = index;
+ m_candidateArray.resize(index + 1);
+ m_candidateArray[index].face = f;
+ m_candidateArray[index].chart = chart;
+ m_candidateArray[index].metric = metric;
} else {
- int c = faceCandidateArray[f];
- xaDebugAssert(c != -1);
- Candidate &candidate = candidateArray[c];
- xaDebugAssert(candidate.face == f);
+ const uint32_t c = m_faceCandidateArray[f];
+ XA_DEBUG_ASSERT(c != (uint32_t)-1);
+ Candidate &candidate = m_candidateArray[c];
+ XA_DEBUG_ASSERT(candidate.face == f);
if (metric < candidate.metric || chart == candidate.chart) {
candidate.metric = metric;
candidate.chart = chart;
@@ -5624,803 +5520,533 @@ struct AtlasBuilder
const uint32_t faceCount = chart->faces.size();
for (uint32_t i = 0; i < faceCount; i++) {
uint32_t f = chart->faces[i];
- xaDebugAssert(faceChartArray[f] == chart->id);
- faceChartArray[f] = owner->id;
+ XA_DEBUG_ASSERT(m_faceChartArray[f] == chart->id);
+ m_faceChartArray[f] = owner->id;
owner->faces.push_back(f);
}
// Update adjacencies?
owner->area += chart->area;
owner->boundaryLength += chart->boundaryLength - sharedBoundaryLength;
owner->normalSum += chart->normalSum;
- owner->centroidSum += chart->centroidSum;
updateProxy(owner);
- }
+ // Delete chart.
+ m_chartArray[chart->id] = nullptr;
+ chart->~ChartBuildData();
+ XA_FREE(chart);
+ }
+
+ const Mesh *m_mesh;
+ const Array<uint32_t> *m_meshFaces;
+ Array<bool> m_ignoreFaces;
+ Array<float> m_edgeLengths;
+ Array<float> m_faceAreas;
+ Array<Vector3> m_faceNormals;
+ Array<Vector2> m_texcoords;
+ Array<uint32_t> m_growFaces;
+ uint32_t m_facesLeft;
+ Array<int> m_faceChartArray;
+ Array<ChartBuildData *> m_chartArray;
+ Array<Candidate> m_candidateArray;
+ Array<uint32_t> m_faceCandidateArray; // Map face index to candidate index.
+ PriorityQueue m_bestTriangles;
+ KISSRng m_rand;
+ ChartOptions m_options;
+};
+// Estimate quality of existing parameterization.
+struct ParameterizationQuality
+{
+ uint32_t totalTriangleCount = 0;
+ uint32_t flippedTriangleCount = 0;
+ uint32_t zeroAreaTriangleCount = 0;
+ float parametricArea = 0.0f;
+ float geometricArea = 0.0f;
+ float stretchMetric = 0.0f;
+ float maxStretchMetric = 0.0f;
+ float conformalMetric = 0.0f;
+ float authalicMetric = 0.0f;
+ bool boundaryIntersection = false;
+};
- uint32_t chartCount() const { return chartArray.size(); }
- const std::vector<uint32_t> &chartFaces(uint32_t i) const { return chartArray[i]->faces; }
+static ParameterizationQuality calculateParameterizationQuality(const Mesh *mesh, Array<uint32_t> *flippedFaces)
+{
+ XA_DEBUG_ASSERT(mesh != nullptr);
+ ParameterizationQuality quality;
+ const uint32_t faceCount = mesh->faceCount();
+ uint32_t firstBoundaryEdge = UINT32_MAX;
+ for (uint32_t e = 0; e < mesh->edgeCount(); e++) {
+ if (mesh->isBoundaryEdge(e)) {
+ firstBoundaryEdge = e;
+ }
+ }
+ XA_DEBUG_ASSERT(firstBoundaryEdge != UINT32_MAX);
+ for (Mesh::BoundaryEdgeIterator it1(mesh, firstBoundaryEdge); !it1.isDone(); it1.advance()) {
+ const uint32_t edge1 = it1.edge();
+ for (Mesh::BoundaryEdgeIterator it2(mesh, firstBoundaryEdge); !it2.isDone(); it2.advance()) {
+ const uint32_t edge2 = it2.edge();
+ // Skip self and edges directly connected to edge1.
+ if (edge1 == edge2 || it1.nextEdge() == edge2 || it2.nextEdge() == edge1)
+ continue;
+ const Vector2 &a1 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex0(edge1)));
+ const Vector2 &a2 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex1(edge1)));
+ const Vector2 &b1 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex0(edge2)));
+ const Vector2 &b2 = mesh->texcoord(mesh->vertexAt(meshEdgeIndex1(edge2)));
+ if (linesIntersect(a1, a2, b1, b2, mesh->epsilon())) {
+ quality.boundaryIntersection = true;
+ break;
+ }
+ }
+ if (quality.boundaryIntersection)
+ break;
+ }
+ if (flippedFaces)
+ flippedFaces->clear();
+ for (uint32_t f = 0; f < faceCount; f++) {
+ Vector3 pos[3];
+ Vector2 texcoord[3];
+ for (int i = 0; i < 3; i++) {
+ const uint32_t v = mesh->vertexAt(f * 3 + i);
+ pos[i] = mesh->position(v);
+ texcoord[i] = mesh->texcoord(v);
+ }
+ quality.totalTriangleCount++;
+ // Evaluate texture stretch metric. See:
+ // - "Texture Mapping Progressive Meshes", Sander, Snyder, Gortler & Hoppe
+ // - "Mesh Parameterization: Theory and Practice", Siggraph'07 Course Notes, Hormann, Levy & Sheffer.
+ const float t1 = texcoord[0].x;
+ const float s1 = texcoord[0].y;
+ const float t2 = texcoord[1].x;
+ const float s2 = texcoord[1].y;
+ const float t3 = texcoord[2].x;
+ const float s3 = texcoord[2].y;
+ float parametricArea = ((s2 - s1) * (t3 - t1) - (s3 - s1) * (t2 - t1)) / 2;
+ if (isZero(parametricArea, kAreaEpsilon)) {
+ quality.zeroAreaTriangleCount++;
+ continue;
+ }
+ if (parametricArea < 0.0f) {
+ // Count flipped triangles.
+ quality.flippedTriangleCount++;
+ if (flippedFaces)
+ flippedFaces->push_back(f);
+ parametricArea = fabsf(parametricArea);
+ }
+ const float geometricArea = length(cross(pos[1] - pos[0], pos[2] - pos[0])) / 2;
+ const Vector3 Ss = (pos[0] * (t2 - t3) + pos[1] * (t3 - t1) + pos[2] * (t1 - t2)) / (2 * parametricArea);
+ const Vector3 St = (pos[0] * (s3 - s2) + pos[1] * (s1 - s3) + pos[2] * (s2 - s1)) / (2 * parametricArea);
+ const float a = dot(Ss, Ss); // E
+ const float b = dot(Ss, St); // F
+ const float c = dot(St, St); // G
+ // Compute eigen-values of the first fundamental form:
+ const float sigma1 = sqrtf(0.5f * max(0.0f, a + c - sqrtf(square(a - c) + 4 * square(b)))); // gamma uppercase, min eigenvalue.
+ const float sigma2 = sqrtf(0.5f * max(0.0f, a + c + sqrtf(square(a - c) + 4 * square(b)))); // gamma lowercase, max eigenvalue.
+ XA_ASSERT(sigma2 > sigma1 || equal(sigma1, sigma2, kEpsilon));
+ // isometric: sigma1 = sigma2 = 1
+ // conformal: sigma1 / sigma2 = 1
+ // authalic: sigma1 * sigma2 = 1
+ const float rmsStretch = sqrtf((a + c) * 0.5f);
+ const float rmsStretch2 = sqrtf((square(sigma1) + square(sigma2)) * 0.5f);
+ XA_DEBUG_ASSERT(equal(rmsStretch, rmsStretch2, 0.01f));
+ XA_UNUSED(rmsStretch2);
+ quality.stretchMetric += square(rmsStretch) * geometricArea;
+ quality.maxStretchMetric = max(quality.maxStretchMetric, sigma2);
+ if (!isZero(sigma1, 0.000001f)) {
+ // sigma1 is zero when geometricArea is zero.
+ quality.conformalMetric += (sigma2 / sigma1) * geometricArea;
+ }
+ quality.authalicMetric += (sigma1 * sigma2) * geometricArea;
+ // Accumulate total areas.
+ quality.geometricArea += geometricArea;
+ quality.parametricArea += parametricArea;
+ //triangleConformalEnergy(q, p);
+ }
+ if (quality.flippedTriangleCount + quality.zeroAreaTriangleCount == quality.totalTriangleCount) {
+ // If all triangles are flipped, then none are.
+ if (flippedFaces)
+ flippedFaces->clear();
+ quality.flippedTriangleCount = 0;
+ }
+ if (quality.flippedTriangleCount > quality.totalTriangleCount / 2)
+ {
+ // If more than half the triangles are flipped, reverse the flipped / not flipped classification.
+ quality.flippedTriangleCount = quality.totalTriangleCount - quality.flippedTriangleCount;
+ if (flippedFaces) {
+ Array<uint32_t> temp(*flippedFaces);
+ flippedFaces->clear();
+ for (uint32_t f = 0; f < faceCount; f++) {
+ bool match = false;
+ for (uint32_t ff = 0; ff < temp.size(); ff++) {
+ if (temp[ff] == f) {
+ match = true;
+ break;
+ }
+ }
+ if (!match)
+ flippedFaces->push_back(f);
+ }
+ }
+ }
+ XA_DEBUG_ASSERT(isFinite(quality.parametricArea) && quality.parametricArea >= 0);
+ XA_DEBUG_ASSERT(isFinite(quality.geometricArea) && quality.geometricArea >= 0);
+ XA_DEBUG_ASSERT(isFinite(quality.stretchMetric));
+ XA_DEBUG_ASSERT(isFinite(quality.maxStretchMetric));
+ XA_DEBUG_ASSERT(isFinite(quality.conformalMetric));
+ XA_DEBUG_ASSERT(isFinite(quality.authalicMetric));
+ if (quality.geometricArea <= 0.0f) {
+ quality.stretchMetric = 0.0f;
+ quality.maxStretchMetric = 0.0f;
+ quality.conformalMetric = 0.0f;
+ quality.authalicMetric = 0.0f;
+ } else {
+ const float normFactor = sqrtf(quality.parametricArea / quality.geometricArea);
+ quality.stretchMetric = sqrtf(quality.stretchMetric / quality.geometricArea) * normFactor;
+ quality.maxStretchMetric *= normFactor;
+ quality.conformalMetric = sqrtf(quality.conformalMetric / quality.geometricArea);
+ quality.authalicMetric = sqrtf(quality.authalicMetric / quality.geometricArea);
+ }
+ return quality;
+}
- const halfedge::Mesh *mesh;
- uint32_t facesLeft;
- std::vector<int> faceChartArray;
- std::vector<ChartBuildData *> chartArray;
- std::vector<float> shortestPaths;
- std::vector<float> edgeLengths;
- std::vector<float> faceAreas;
- std::vector<Candidate> candidateArray; //
- std::vector<uint32_t> faceCandidateArray; // Map face index to candidate index.
- MTRand rand;
- CharterOptions options;
+struct ChartWarningFlags
+{
+ enum Enum
+ {
+ CloseHolesFailed = 1<<1,
+ FixTJunctionsDuplicatedEdge = 1<<2,
+ FixTJunctionsFailed = 1<<3,
+ TriangulateDuplicatedEdge = 1<<4,
+ };
};
/// A chart is a connected set of faces with a certain topology (usually a disk).
class Chart
{
public:
- Chart() : m_isDisk(false), m_isVertexMapped(false) {}
-
- void build(const halfedge::Mesh *originalMesh, const std::vector<uint32_t> &faceArray)
+ Chart(const Mesh *originalMesh, const Array<uint32_t> &faceArray, const Basis &basis, uint32_t meshId, uint32_t chartGroupId, uint32_t chartId) : m_basis(basis), m_mesh(nullptr), m_unifiedMesh(nullptr), m_isDisk(false), m_isOrtho(false), m_isPlanar(false), m_warningFlags(0), m_closedHolesCount(0), m_fixedTJunctionsCount(0), m_faceArray(faceArray)
{
+ XA_UNUSED(meshId);
+ XA_UNUSED(chartGroupId);
+ XA_UNUSED(chartId);
// Copy face indices.
- m_faceArray = faceArray;
- const uint32_t meshVertexCount = originalMesh->vertexCount();
- m_chartMesh.reset(new halfedge::Mesh());
- m_unifiedMesh.reset(new halfedge::Mesh());
- std::vector<uint32_t> chartMeshIndices(meshVertexCount, (uint32_t)~0);
- std::vector<uint32_t> unifiedMeshIndices(meshVertexCount, (uint32_t)~0);
+ m_mesh = XA_NEW(MemTag::Mesh, Mesh, originalMesh->epsilon(), faceArray.size() * 3, faceArray.size());
+ m_unifiedMesh = XA_NEW(MemTag::Mesh, Mesh, originalMesh->epsilon(), faceArray.size() * 3, faceArray.size());
+ Array<uint32_t> chartMeshIndices;
+ chartMeshIndices.resize(originalMesh->vertexCount(), (uint32_t)~0);
+ Array<uint32_t> unifiedMeshIndices;
+ unifiedMeshIndices.resize(originalMesh->vertexCount(), (uint32_t)~0);
// Add vertices.
const uint32_t faceCount = faceArray.size();
for (uint32_t f = 0; f < faceCount; f++) {
- const halfedge::Face *face = originalMesh->faceAt(faceArray[f]);
- xaDebugAssert(face != NULL);
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Vertex *vertex = it.current()->vertex;
- const halfedge::Vertex *unifiedVertex = vertex->firstColocal();
- if (unifiedMeshIndices[unifiedVertex->id] == ~0) {
- unifiedMeshIndices[unifiedVertex->id] = m_unifiedMesh->vertexCount();
- xaDebugAssert(vertex->pos == unifiedVertex->pos);
- m_unifiedMesh->addVertex(vertex->pos);
+ for (uint32_t i = 0; i < 3; i++) {
+ const uint32_t vertex = originalMesh->vertexAt(faceArray[f] * 3 + i);
+ const uint32_t unifiedVertex = originalMesh->firstColocal(vertex);
+ if (unifiedMeshIndices[unifiedVertex] == (uint32_t)~0) {
+ unifiedMeshIndices[unifiedVertex] = m_unifiedMesh->vertexCount();
+ XA_DEBUG_ASSERT(equal(originalMesh->position(vertex), originalMesh->position(unifiedVertex), originalMesh->epsilon()));
+ m_unifiedMesh->addVertex(originalMesh->position(vertex));
}
- if (chartMeshIndices[vertex->id] == ~0) {
- chartMeshIndices[vertex->id] = m_chartMesh->vertexCount();
- // -- GODOT start --
- //m_chartToOriginalMap.push_back(vertex->id);
- m_chartToOriginalMap.push_back(vertex->original_id);
- // -- GODOT end --
- m_chartToUnifiedMap.push_back(unifiedMeshIndices[unifiedVertex->id]);
- halfedge::Vertex *v = m_chartMesh->addVertex(vertex->pos);
- v->nor = vertex->nor;
- v->tex = vertex->tex;
+ if (chartMeshIndices[vertex] == (uint32_t)~0) {
+ chartMeshIndices[vertex] = m_mesh->vertexCount();
+ m_chartToOriginalMap.push_back(vertex);
+ m_chartToUnifiedMap.push_back(unifiedMeshIndices[unifiedVertex]);
+ m_mesh->addVertex(originalMesh->position(vertex), Vector3(0.0f), originalMesh->texcoord(vertex));
}
}
}
- // This is ignoring the canonical map:
- // - Is it really necessary to link colocals?
- m_chartMesh->linkColocals();
- //m_unifiedMesh->linkColocals(); // Not strictly necessary, no colocals in the unified mesh. # Wrong.
- // This check is not valid anymore, if the original mesh vertices were linked with a canonical map, then it might have
- // some colocal vertices that were unlinked. So, the unified mesh might have some duplicate vertices, because firstColocal()
- // is not guaranteed to return the same vertex for two colocal vertices.
- //xaAssert(m_chartMesh->colocalVertexCount() == m_unifiedMesh->vertexCount());
- // Is that OK? What happens in meshes were that happens? Does anything break? Apparently not...
- std::vector<uint32_t> faceIndices;
- faceIndices.reserve(7);
// Add faces.
for (uint32_t f = 0; f < faceCount; f++) {
- const halfedge::Face *face = originalMesh->faceAt(faceArray[f]);
- xaDebugAssert(face != NULL);
- faceIndices.clear();
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Vertex *vertex = it.current()->vertex;
- xaDebugAssert(vertex != NULL);
- faceIndices.push_back(chartMeshIndices[vertex->id]);
- }
- m_chartMesh->addFace(faceIndices);
- faceIndices.clear();
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Vertex *vertex = it.current()->vertex;
- xaDebugAssert(vertex != NULL);
- vertex = vertex->firstColocal();
- faceIndices.push_back(unifiedMeshIndices[vertex->id]);
- }
- m_unifiedMesh->addFace(faceIndices);
- }
- m_chartMesh->linkBoundary();
- m_unifiedMesh->linkBoundary();
- //exportMesh(m_unifiedMesh.ptr(), "debug_input.obj");
- if (m_unifiedMesh->splitBoundaryEdges()) {
- m_unifiedMesh.reset(halfedge::unifyVertices(m_unifiedMesh.get()));
- }
- //exportMesh(m_unifiedMesh.ptr(), "debug_split.obj");
- // Closing the holes is not always the best solution and does not fix all the problems.
- // We need to do some analysis of the holes and the genus to:
- // - Find cuts that reduce genus.
- // - Find cuts to connect holes.
- // - Use minimal spanning trees or seamster.
- if (!closeHoles()) {
- /*static int pieceCount = 0;
- StringBuilder fileName;
- fileName.format("debug_hole_%d.obj", pieceCount++);
- exportMesh(m_unifiedMesh.ptr(), fileName.str());*/
- }
- m_unifiedMesh.reset(halfedge::triangulate(m_unifiedMesh.get()));
- //exportMesh(m_unifiedMesh.ptr(), "debug_triangulated.obj");
- // Analyze chart topology.
- halfedge::MeshTopology topology(m_unifiedMesh.get());
- m_isDisk = topology.isDisk();
- }
-
- void buildVertexMap(const halfedge::Mesh *originalMesh, const std::vector<uint32_t> &unchartedMaterialArray)
- {
- xaAssert(m_chartMesh.get() == NULL && m_unifiedMesh.get() == NULL);
- m_isVertexMapped = true;
- // Build face indices.
- m_faceArray.clear();
- const uint32_t meshFaceCount = originalMesh->faceCount();
- for (uint32_t f = 0; f < meshFaceCount; f++) {
- const halfedge::Face *face = originalMesh->faceAt(f);
- if (std::find(unchartedMaterialArray.begin(), unchartedMaterialArray.end(), face->material) != unchartedMaterialArray.end()) {
- m_faceArray.push_back(f);
- }
- }
- const uint32_t faceCount = m_faceArray.size();
- if (faceCount == 0) {
- return;
- }
- // @@ The chartMesh construction is basically the same as with regular charts, don't duplicate!
- const uint32_t meshVertexCount = originalMesh->vertexCount();
- m_chartMesh.reset(new halfedge::Mesh());
- std::vector<uint32_t> chartMeshIndices(meshVertexCount, (uint32_t)~0);
- // Vertex map mesh only has disconnected vertices.
- for (uint32_t f = 0; f < faceCount; f++) {
- const halfedge::Face *face = originalMesh->faceAt(m_faceArray[f]);
- xaDebugAssert(face != NULL);
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Vertex *vertex = it.current()->vertex;
- if (chartMeshIndices[vertex->id] == ~0) {
- chartMeshIndices[vertex->id] = m_chartMesh->vertexCount();
- // -- GODOT start --
- //m_chartToOriginalMap.push_back(vertex->id);
- m_chartToOriginalMap.push_back(vertex->original_id);
- // -- GODOT end --
- halfedge::Vertex *v = m_chartMesh->addVertex(vertex->pos);
- v->nor = vertex->nor;
- v->tex = vertex->tex; // @@ Not necessary.
- }
+ uint32_t indices[3], unifiedIndices[3];
+ for (uint32_t i = 0; i < 3; i++) {
+ const uint32_t vertex = originalMesh->vertexAt(faceArray[f] * 3 + i);
+ indices[i] = chartMeshIndices[vertex];
+ unifiedIndices[i] = unifiedMeshIndices[originalMesh->firstColocal(vertex)];
+ }
+ Mesh::AddFaceResult::Enum result = m_mesh->addFace(indices);
+ XA_UNUSED(result);
+ XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK);
+#if XA_DEBUG
+ // Unifying colocals may create degenerate edges. e.g. if two triangle vertices are colocal.
+ for (int i = 0; i < 3; i++) {
+ const uint32_t index1 = unifiedIndices[i];
+ const uint32_t index2 = unifiedIndices[(i + 1) % 3];
+ XA_DEBUG_ASSERT(index1 != index2);
}
- }
- // @@ Link colocals using the original mesh canonical map? Build canonical map on the fly? Do we need to link colocals at all for this?
- //m_chartMesh->linkColocals();
- std::vector<uint32_t> faceIndices;
- faceIndices.reserve(7);
- // Add faces.
- for (uint32_t f = 0; f < faceCount; f++) {
- const halfedge::Face *face = originalMesh->faceAt(m_faceArray[f]);
- xaDebugAssert(face != NULL);
- faceIndices.clear();
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Vertex *vertex = it.current()->vertex;
- xaDebugAssert(vertex != NULL);
- xaDebugAssert(chartMeshIndices[vertex->id] != ~0);
- faceIndices.push_back(chartMeshIndices[vertex->id]);
- }
- halfedge::Face *new_face = m_chartMesh->addFace(faceIndices);
- xaDebugAssert(new_face != NULL);
-#ifdef NDEBUG
- new_face = NULL; // silence unused parameter warning
#endif
- }
- m_chartMesh->linkBoundary();
- const uint32_t chartVertexCount = m_chartMesh->vertexCount();
- Box bounds;
- bounds.clearBounds();
- for (uint32_t i = 0; i < chartVertexCount; i++) {
- halfedge::Vertex *vertex = m_chartMesh->vertexAt(i);
- bounds.addPointToBounds(vertex->pos);
- }
- ProximityGrid grid;
- grid.init(bounds, chartVertexCount);
- for (uint32_t i = 0; i < chartVertexCount; i++) {
- halfedge::Vertex *vertex = m_chartMesh->vertexAt(i);
- grid.add(vertex->pos, i);
- }
- uint32_t texelCount = 0;
- const float positionThreshold = 0.01f;
- const float normalThreshold = 0.01f;
- uint32_t verticesVisited = 0;
- uint32_t cellsVisited = 0;
- std::vector<int> vertexIndexArray(chartVertexCount, -1); // Init all indices to -1.
- // Traverse vertices in morton order. @@ It may be more interesting to sort them based on orientation.
- const uint32_t cellCodeCount = grid.mortonCount();
- for (uint32_t cellCode = 0; cellCode < cellCodeCount; cellCode++) {
- int cell = grid.mortonIndex(cellCode);
- if (cell < 0) continue;
- cellsVisited++;
- const std::vector<uint32_t> &indexArray = grid.cellArray[cell].indexArray;
- for (uint32_t i = 0; i < indexArray.size(); i++) {
- uint32_t idx = indexArray[i];
- halfedge::Vertex *vertex = m_chartMesh->vertexAt(idx);
- xaDebugAssert(vertexIndexArray[idx] == -1);
- std::vector<uint32_t> neighbors;
- grid.gather(vertex->pos, positionThreshold, /*ref*/neighbors);
- // Compare against all nearby vertices, cluster greedily.
- for (uint32_t j = 0; j < neighbors.size(); j++) {
- uint32_t otherIdx = neighbors[j];
- if (vertexIndexArray[otherIdx] != -1) {
- halfedge::Vertex *otherVertex = m_chartMesh->vertexAt(otherIdx);
- if (distance(vertex->pos, otherVertex->pos) < positionThreshold &&
- distance(vertex->nor, otherVertex->nor) < normalThreshold) {
- vertexIndexArray[idx] = vertexIndexArray[otherIdx];
- break;
+ result = m_unifiedMesh->addFace(unifiedIndices);
+ XA_UNUSED(result);
+ XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK);
+ }
+ m_mesh->createBoundaries(); // For AtlasPacker::computeBoundingBox
+ m_unifiedMesh->createBoundaries();
+ m_unifiedMesh->linkBoundaries();
+ m_isPlanar = meshIsPlanar(*m_unifiedMesh);
+ if (m_isPlanar) {
+ m_isDisk = true;
+ } else {
+#if XA_DEBUG_EXPORT_OBJ_BEFORE_FIX_TJUNCTION
+ m_unifiedMesh->writeObjFile("debug_before_fix_tjunction.obj");
+#endif
+ bool duplicatedEdge = false, failed = false;
+ XA_PROFILE_START(fixChartMeshTJunctions)
+ Mesh *fixedUnifiedMesh = meshFixTJunctions(*m_unifiedMesh, &duplicatedEdge, &failed, &m_fixedTJunctionsCount);
+ XA_PROFILE_END(fixChartMeshTJunctions)
+ if (fixedUnifiedMesh) {
+ if (duplicatedEdge)
+ m_warningFlags |= ChartWarningFlags::FixTJunctionsDuplicatedEdge;
+ if (failed)
+ m_warningFlags |= ChartWarningFlags::FixTJunctionsFailed;
+ m_unifiedMesh->~Mesh();
+ XA_FREE(m_unifiedMesh);
+ m_unifiedMesh = fixedUnifiedMesh;
+ m_unifiedMesh->createBoundaries();
+ m_unifiedMesh->linkBoundaries();
+ }
+ // See if there are any holes that need closing.
+ Array<uint32_t> boundaryLoops;
+ meshGetBoundaryLoops(*m_unifiedMesh, boundaryLoops);
+ if (boundaryLoops.size() > 1) {
+#if XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR
+ const uint32_t faceCountBeforeHolesClosed = m_unifiedMesh->faceCount();
+#endif
+ // Closing the holes is not always the best solution and does not fix all the problems.
+ // We need to do some analysis of the holes and the genus to:
+ // - Find cuts that reduce genus.
+ // - Find cuts to connect holes.
+ // - Use minimal spanning trees or seamster.
+ Array<uint32_t> holeFaceCounts;
+ XA_PROFILE_START(closeChartMeshHoles)
+ failed = !meshCloseHoles(m_unifiedMesh, boundaryLoops, basis.normal, holeFaceCounts);
+ XA_PROFILE_END(closeChartMeshHoles)
+ m_unifiedMesh->createBoundaries();
+ m_unifiedMesh->linkBoundaries();
+ meshGetBoundaryLoops(*m_unifiedMesh, boundaryLoops);
+ if (failed || boundaryLoops.size() > 1)
+ m_warningFlags |= ChartWarningFlags::CloseHolesFailed;
+ m_closedHolesCount = holeFaceCounts.size();
+#if XA_DEBUG_EXPORT_OBJ_CLOSE_HOLES_ERROR
+ if (m_warningFlags & ChartWarningFlags::CloseHolesFailed) {
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_chart_%03u_close_holes_error.obj", meshId, chartGroupId, chartId);
+ FILE *file;
+ XA_FOPEN(file, filename, "w");
+ if (file) {
+ m_unifiedMesh->writeObjVertices(file);
+ fprintf(file, "s off\n");
+ fprintf(file, "o object\n");
+ for (uint32_t i = 0; i < faceCountBeforeHolesClosed; i++)
+ m_unifiedMesh->writeObjFace(file, i);
+ uint32_t face = faceCountBeforeHolesClosed;
+ for (uint32_t i = 0; i < holeFaceCounts.size(); i++) {
+ fprintf(file, "s off\n");
+ fprintf(file, "o hole%u\n", i);
+ for (uint32_t j = 0; j < holeFaceCounts[i]; j++) {
+ m_unifiedMesh->writeObjFace(file, face);
+ face++;
+ }
}
+ m_unifiedMesh->writeObjBoundaryEges(file);
+ m_unifiedMesh->writeObjLinkedBoundaries(file);
+ fclose(file);
}
}
- // If index not assigned, assign new one.
- if (vertexIndexArray[idx] == -1) {
- vertexIndexArray[idx] = texelCount++;
- }
- verticesVisited++;
- }
- }
- xaDebugAssert(cellsVisited == grid.cellArray.size());
- xaDebugAssert(verticesVisited == chartVertexCount);
- vertexMapWidth = ftoi_ceil(sqrtf(float(texelCount)));
- vertexMapWidth = (vertexMapWidth + 3) & ~3; // Width aligned to 4.
- vertexMapHeight = vertexMapWidth == 0 ? 0 : (texelCount + vertexMapWidth - 1) / vertexMapWidth;
- //vertexMapHeight = (vertexMapHeight + 3) & ~3; // Height aligned to 4.
- xaDebugAssert(vertexMapWidth >= vertexMapHeight);
- xaPrint("Reduced vertex count from %d to %d.\n", chartVertexCount, texelCount);
- // Lay down the clustered vertices in morton order.
- std::vector<uint32_t> texelCodes(texelCount);
- // For each texel, assign one morton code.
- uint32_t texelCode = 0;
- for (uint32_t i = 0; i < texelCount; i++) {
- uint32_t x, y;
- do {
- x = morton::decodeMorton2X(texelCode);
- y = morton::decodeMorton2Y(texelCode);
- texelCode++;
- } while (x >= uint32_t(vertexMapWidth) || y >= uint32_t(vertexMapHeight));
- texelCodes[i] = texelCode - 1;
- }
- for (uint32_t i = 0; i < chartVertexCount; i++) {
- halfedge::Vertex *vertex = m_chartMesh->vertexAt(i);
- int idx = vertexIndexArray[i];
- if (idx != -1) {
- uint32_t tc = texelCodes[idx];
- uint32_t x = morton::decodeMorton2X(tc);
- uint32_t y = morton::decodeMorton2Y(tc);
- vertex->tex.x = float(x);
- vertex->tex.y = float(y);
- }
- }
- }
-
- bool closeHoles()
- {
- xaDebugAssert(!m_isVertexMapped);
- std::vector<halfedge::Edge *> boundaryEdges;
- getBoundaryEdges(m_unifiedMesh.get(), boundaryEdges);
- uint32_t boundaryCount = boundaryEdges.size();
- if (boundaryCount <= 1) {
- // Nothing to close.
- return true;
- }
- // Compute lengths and areas.
- std::vector<float> boundaryLengths;
- for (uint32_t i = 0; i < boundaryCount; i++) {
- const halfedge::Edge *startEdge = boundaryEdges[i];
- xaAssert(startEdge->face == NULL);
- //float boundaryEdgeCount = 0;
- float boundaryLength = 0.0f;
- //Vector3 boundaryCentroid(zero);
- const halfedge::Edge *edge = startEdge;
- do {
- Vector3 t0 = edge->from()->pos;
- Vector3 t1 = edge->to()->pos;
- //boundaryEdgeCount++;
- boundaryLength += length(t1 - t0);
- //boundaryCentroid += edge->vertex()->pos;
- edge = edge->next;
- } while (edge != startEdge);
- boundaryLengths.push_back(boundaryLength);
- //boundaryCentroids.append(boundaryCentroid / boundaryEdgeCount);
- }
- // Find disk boundary.
- uint32_t diskBoundary = 0;
- float maxLength = boundaryLengths[0];
- for (uint32_t i = 1; i < boundaryCount; i++) {
- if (boundaryLengths[i] > maxLength) {
- maxLength = boundaryLengths[i];
- diskBoundary = i;
- }
- }
- // Close holes.
- for (uint32_t i = 0; i < boundaryCount; i++) {
- if (diskBoundary == i) {
- // Skip disk boundary.
- continue;
+#endif
}
- halfedge::Edge *startEdge = boundaryEdges[i];
- xaDebugAssert(startEdge != NULL);
- xaDebugAssert(startEdge->face == NULL);
- std::vector<halfedge::Vertex *> vertexLoop;
- std::vector<halfedge::Edge *> edgeLoop;
- halfedge::Edge *edge = startEdge;
- do {
- halfedge::Vertex *vertex = edge->next->vertex; // edge->to()
- uint32_t j;
- for (j = 0; j < vertexLoop.size(); j++) {
- if (vertex->isColocal(vertexLoop[j])) {
- break;
- }
- }
- bool isCrossing = (j != vertexLoop.size());
- if (isCrossing) {
- halfedge::Edge *prev = edgeLoop[j]; // Previous edge before the loop.
- halfedge::Edge *next = edge->next; // Next edge after the loop.
- xaDebugAssert(prev->to()->isColocal(next->from()));
- // Close loop.
- edgeLoop.push_back(edge);
- closeLoop(j + 1, edgeLoop);
- // Link boundary loop.
- prev->setNext(next);
- vertex->setEdge(next);
- // Start over again.
- vertexLoop.clear();
- edgeLoop.clear();
- edge = startEdge;
- vertex = edge->to();
- }
- vertexLoop.push_back(vertex);
- edgeLoop.push_back(edge);
- edge = edge->next;
- } while (edge != startEdge);
- closeLoop(0, edgeLoop);
+ // Note: MeshTopology needs linked boundaries.
+ MeshTopology topology(m_unifiedMesh);
+ m_isDisk = topology.isDisk();
+#if XA_DEBUG_EXPORT_OBJ_NOT_DISK
+ if (!m_isDisk) {
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_chart_%03u_not_disk.obj", meshId, chartGroupId, chartId);
+ m_unifiedMesh->writeObjFile(filename);
+ }
+#endif
}
- getBoundaryEdges(m_unifiedMesh.get(), boundaryEdges);
- boundaryCount = boundaryEdges.size();
- xaDebugAssert(boundaryCount == 1);
- return boundaryCount == 1;
- }
-
- bool isDisk() const
- {
- return m_isDisk;
- }
- bool isVertexMapped() const
- {
- return m_isVertexMapped;
}
- uint32_t vertexCount() const
+ ~Chart()
{
- return m_chartMesh->vertexCount();
- }
- uint32_t colocalVertexCount() const
- {
- return m_unifiedMesh->vertexCount();
- }
-
- uint32_t faceCount() const
- {
- return m_faceArray.size();
- }
- uint32_t faceAt(uint32_t i) const
- {
- return m_faceArray[i];
- }
-
- const halfedge::Mesh *chartMesh() const
- {
- return m_chartMesh.get();
- }
- halfedge::Mesh *chartMesh()
- {
- return m_chartMesh.get();
- }
- const halfedge::Mesh *unifiedMesh() const
- {
- return m_unifiedMesh.get();
- }
- halfedge::Mesh *unifiedMesh()
- {
- return m_unifiedMesh.get();
+ if (m_mesh) {
+ m_mesh->~Mesh();
+ XA_FREE(m_mesh);
+ }
+ if (m_unifiedMesh) {
+ m_unifiedMesh->~Mesh();
+ XA_FREE(m_unifiedMesh);
+ }
}
- //uint32_t vertexIndex(uint32_t i) const { return m_vertexIndexArray[i]; }
+ const Basis &basis() const { return m_basis; }
+ bool isDisk() const { return m_isDisk; }
+ bool isOrtho() const { return m_isOrtho; }
+ bool isPlanar() const { return m_isPlanar; }
+ uint32_t warningFlags() const { return m_warningFlags; }
+ uint32_t closedHolesCount() const { return m_closedHolesCount; }
+ uint32_t fixedTJunctionsCount() const { return m_fixedTJunctionsCount; }
+ const ParameterizationQuality &paramQuality() const { return m_paramQuality; }
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+ const Array<uint32_t> &paramFlippedFaces() const { return m_paramFlippedFaces; }
+#endif
+ uint32_t mapFaceToSourceFace(uint32_t i) const { return m_faceArray[i]; }
+ const Mesh *mesh() const { return m_mesh; }
+ Mesh *mesh() { return m_mesh; }
+ const Mesh *unifiedMesh() const { return m_unifiedMesh; }
+ Mesh *unifiedMesh() { return m_unifiedMesh; }
+ uint32_t mapChartVertexToOriginalVertex(uint32_t i) const { return m_chartToOriginalMap[i]; }
- uint32_t mapChartVertexToOriginalVertex(uint32_t i) const
- {
- return m_chartToOriginalMap[i];
- }
- uint32_t mapChartVertexToUnifiedVertex(uint32_t i) const
+ void evaluateOrthoParameterizationQuality()
{
- return m_chartToUnifiedMap[i];
+ XA_PROFILE_START(parameterizeChartsEvaluateQuality)
+ m_paramQuality = calculateParameterizationQuality(m_unifiedMesh, nullptr);
+ XA_PROFILE_END(parameterizeChartsEvaluateQuality)
+ // Use orthogonal parameterization if quality is acceptable.
+ if (!m_paramQuality.boundaryIntersection && m_paramQuality.geometricArea > 0.0f && m_paramQuality.stretchMetric <= 1.1f && m_paramQuality.maxStretchMetric <= 1.25f)
+ m_isOrtho = true;
}
- const std::vector<uint32_t> &faceArray() const
+ void evaluateParameterizationQuality()
{
- return m_faceArray;
+ XA_PROFILE_START(parameterizeChartsEvaluateQuality)
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+ m_paramQuality = calculateParameterizationQuality(m_unifiedMesh, &m_paramFlippedFaces);
+#else
+ m_paramQuality = calculateParameterizationQuality(m_unifiedMesh, nullptr);
+#endif
+ XA_PROFILE_END(parameterizeChartsEvaluateQuality)
}
// Transfer parameterization from unified mesh to chart mesh.
void transferParameterization()
{
- xaDebugAssert(!m_isVertexMapped);
- uint32_t vertexCount = m_chartMesh->vertexCount();
- for (uint32_t v = 0; v < vertexCount; v++) {
- halfedge::Vertex *vertex = m_chartMesh->vertexAt(v);
- halfedge::Vertex *unifiedVertex = m_unifiedMesh->vertexAt(mapChartVertexToUnifiedVertex(v));
- vertex->tex = unifiedVertex->tex;
- }
+ const uint32_t vertexCount = m_mesh->vertexCount();
+ for (uint32_t v = 0; v < vertexCount; v++)
+ m_mesh->texcoord(v) = m_unifiedMesh->texcoord(m_chartToUnifiedMap[v]);
}
float computeSurfaceArea() const
{
- return halfedge::computeSurfaceArea(m_chartMesh.get()) * scale;
+ return m_mesh->computeSurfaceArea();
}
float computeParametricArea() const
{
- // This only makes sense in parameterized meshes.
- xaDebugAssert(m_isDisk);
- xaDebugAssert(!m_isVertexMapped);
- return halfedge::computeParametricArea(m_chartMesh.get());
+ return m_mesh->computeParametricArea();
}
Vector2 computeParametricBounds() const
{
- // This only makes sense in parameterized meshes.
- xaDebugAssert(m_isDisk);
- xaDebugAssert(!m_isVertexMapped);
- Box bounds;
- bounds.clearBounds();
- uint32_t vertexCount = m_chartMesh->vertexCount();
+ Vector2 minCorner(FLT_MAX, FLT_MAX);
+ Vector2 maxCorner(-FLT_MAX, -FLT_MAX);
+ const uint32_t vertexCount = m_mesh->vertexCount();
for (uint32_t v = 0; v < vertexCount; v++) {
- halfedge::Vertex *vertex = m_chartMesh->vertexAt(v);
- bounds.addPointToBounds(Vector3(vertex->tex, 0));
+ minCorner = min(minCorner, m_mesh->texcoord(v));
+ maxCorner = max(maxCorner, m_mesh->texcoord(v));
}
- return bounds.extents().xy();
+ return (maxCorner - minCorner) * 0.5f;
}
- float scale = 1.0f;
- uint32_t vertexMapWidth;
- uint32_t vertexMapHeight;
- bool blockAligned = true;
-
private:
- bool closeLoop(uint32_t start, const std::vector<halfedge::Edge *> &loop)
- {
- const uint32_t vertexCount = loop.size() - start;
- xaDebugAssert(vertexCount >= 3);
- if (vertexCount < 3) return false;
- xaDebugAssert(loop[start]->vertex->isColocal(loop[start + vertexCount - 1]->to()));
- // If the hole is planar, then we add a single face that will be properly triangulated later.
- // If the hole is not planar, we add a triangle fan with a vertex at the hole centroid.
- // This is still a bit of a hack. There surely are better hole filling algorithms out there.
- std::vector<Vector3> points(vertexCount);
- for (uint32_t i = 0; i < vertexCount; i++) {
- points[i] = loop[start + i]->vertex->pos;
- }
- bool isPlanar = Fit::isPlanar(vertexCount, points.data());
- if (isPlanar) {
- // Add face and connect edges.
- halfedge::Face *face = m_unifiedMesh->addFace();
- for (uint32_t i = 0; i < vertexCount; i++) {
- halfedge::Edge *edge = loop[start + i];
- edge->face = face;
- edge->setNext(loop[start + (i + 1) % vertexCount]);
- }
- face->edge = loop[start];
- xaDebugAssert(face->isValid());
- } else {
- // If the polygon is not planar, we just cross our fingers, and hope this will work:
- // Compute boundary centroid:
- Vector3 centroidPos(0);
- for (uint32_t i = 0; i < vertexCount; i++) {
- centroidPos += points[i];
- }
- centroidPos *= (1.0f / vertexCount);
- halfedge::Vertex *centroid = m_unifiedMesh->addVertex(centroidPos);
- // Add one pair of edges for each boundary vertex.
- for (uint32_t j = vertexCount - 1, i = 0; i < vertexCount; j = i++) {
- halfedge::Face *face = m_unifiedMesh->addFace(centroid->id, loop[start + j]->vertex->id, loop[start + i]->vertex->id);
- xaDebugAssert(face != NULL);
-#ifdef NDEBUG
- face = NULL; // silence unused parameter warning
-#endif
- }
- }
- return true;
- }
-
- static void getBoundaryEdges(halfedge::Mesh *mesh, std::vector<halfedge::Edge *> &boundaryEdges)
- {
- xaDebugAssert(mesh != NULL);
- const uint32_t edgeCount = mesh->edgeCount();
- BitArray bitFlags(edgeCount);
- bitFlags.clearAll();
- boundaryEdges.clear();
- // Search for boundary edges. Mark all the edges that belong to the same boundary.
- for (uint32_t e = 0; e < edgeCount; e++) {
- halfedge::Edge *startEdge = mesh->edgeAt(e);
- if (startEdge != NULL && startEdge->isBoundary() && bitFlags.bitAt(e) == false) {
- xaDebugAssert(startEdge->face != NULL);
- xaDebugAssert(startEdge->pair->face == NULL);
- startEdge = startEdge->pair;
- const halfedge::Edge *edge = startEdge;
- do {
- xaDebugAssert(edge->face == NULL);
- xaDebugAssert(bitFlags.bitAt(edge->id / 2) == false);
- bitFlags.setBitAt(edge->id / 2);
- edge = edge->next;
- } while (startEdge != edge);
- boundaryEdges.push_back(startEdge);
- }
- }
- }
-
- // Chart mesh.
- std::auto_ptr<halfedge::Mesh> m_chartMesh;
+ Basis m_basis;
+ Mesh *m_mesh;
+ Mesh *m_unifiedMesh;
+ bool m_isDisk, m_isOrtho, m_isPlanar;
+ uint32_t m_warningFlags;
+ uint32_t m_closedHolesCount, m_fixedTJunctionsCount;
- std::auto_ptr<halfedge::Mesh> m_unifiedMesh;
- bool m_isDisk;
- bool m_isVertexMapped;
-
// List of faces of the original mesh that belong to this chart.
- std::vector<uint32_t> m_faceArray;
+ Array<uint32_t> m_faceArray;
// Map vertices of the chart mesh to vertices of the original mesh.
- std::vector<uint32_t> m_chartToOriginalMap;
+ Array<uint32_t> m_chartToOriginalMap;
- std::vector<uint32_t> m_chartToUnifiedMap;
+ Array<uint32_t> m_chartToUnifiedMap;
+
+ ParameterizationQuality m_paramQuality;
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+ Array<uint32_t> m_paramFlippedFaces;
+#endif
};
-// Estimate quality of existing parameterization.
-class ParameterizationQuality
+// Set of charts corresponding to mesh faces in the same face group.
+class ChartGroup
{
public:
- ParameterizationQuality()
- {
- m_totalTriangleCount = 0;
- m_flippedTriangleCount = 0;
- m_zeroAreaTriangleCount = 0;
- m_parametricArea = 0.0f;
- m_geometricArea = 0.0f;
- m_stretchMetric = 0.0f;
- m_maxStretchMetric = 0.0f;
- m_conformalMetric = 0.0f;
- m_authalicMetric = 0.0f;
- }
-
- ParameterizationQuality(const halfedge::Mesh *mesh)
- {
- xaDebugAssert(mesh != NULL);
- m_totalTriangleCount = 0;
- m_flippedTriangleCount = 0;
- m_zeroAreaTriangleCount = 0;
- m_parametricArea = 0.0f;
- m_geometricArea = 0.0f;
- m_stretchMetric = 0.0f;
- m_maxStretchMetric = 0.0f;
- m_conformalMetric = 0.0f;
- m_authalicMetric = 0.0f;
- const uint32_t faceCount = mesh->faceCount();
+ ChartGroup(uint32_t id, const Mesh *sourceMesh, uint32_t faceGroup) : m_sourceId(sourceMesh->id()), m_id(id), m_isVertexMap(faceGroup == UINT32_MAX), m_paramAddedChartsCount(0), m_paramDeletedChartsCount(0)
+ {
+ // Create new mesh from the source mesh, using faces that belong to this group.
+ const uint32_t sourceFaceCount = sourceMesh->faceCount();
+ for (uint32_t f = 0; f < sourceFaceCount; f++) {
+ if (sourceMesh->faceGroupAt(f) == faceGroup)
+ m_faceToSourceFaceMap.push_back(f);
+ }
+ // Only initial meshes have face groups and ignored faces. The only flag we care about is HasNormals.
+ const uint32_t faceCount = m_faceToSourceFaceMap.size();
+ m_mesh = XA_NEW(MemTag::Mesh, Mesh, sourceMesh->epsilon(), faceCount * 3, faceCount, sourceMesh->flags() & MeshFlags::HasNormals);
+ XA_DEBUG_ASSERT(faceCount > 0);
+ Array<uint32_t> meshIndices;
+ meshIndices.resize(sourceMesh->vertexCount(), (uint32_t)~0);
for (uint32_t f = 0; f < faceCount; f++) {
- const halfedge::Face *face = mesh->faceAt(f);
- const halfedge::Vertex *vertex0 = NULL;
- Vector3 p[3];
- Vector2 t[3];
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- if (vertex0 == NULL) {
- vertex0 = edge->vertex;
- p[0] = vertex0->pos;
- t[0] = vertex0->tex;
- } else if (edge->to() != vertex0) {
- p[1] = edge->from()->pos;
- p[2] = edge->to()->pos;
- t[1] = edge->from()->tex;
- t[2] = edge->to()->tex;
- processTriangle(p, t);
+ const uint32_t face = m_faceToSourceFaceMap[f];
+ for (uint32_t i = 0; i < 3; i++) {
+ const uint32_t vertex = sourceMesh->vertexAt(face * 3 + i);
+ if (meshIndices[vertex] == (uint32_t)~0) {
+ meshIndices[vertex] = m_mesh->vertexCount();
+ m_vertexToSourceVertexMap.push_back(vertex);
+ Vector3 normal(0.0f);
+ if (sourceMesh->flags() & MeshFlags::HasNormals)
+ normal = sourceMesh->normal(vertex);
+ m_mesh->addVertex(sourceMesh->position(vertex), normal, sourceMesh->texcoord(vertex));
}
}
}
- if (m_flippedTriangleCount + m_zeroAreaTriangleCount == faceCount) {
- // If all triangles are flipped, then none is.
- m_flippedTriangleCount = 0;
- }
- xaDebugAssert(std::isfinite(m_parametricArea) && m_parametricArea >= 0);
- xaDebugAssert(std::isfinite(m_geometricArea) && m_geometricArea >= 0);
- xaDebugAssert(std::isfinite(m_stretchMetric));
- xaDebugAssert(std::isfinite(m_maxStretchMetric));
- xaDebugAssert(std::isfinite(m_conformalMetric));
- xaDebugAssert(std::isfinite(m_authalicMetric));
- }
-
- bool isValid() const
- {
- return m_flippedTriangleCount == 0; // @@ Does not test for self-overlaps.
- }
-
- float rmsStretchMetric() const
- {
- if (m_geometricArea == 0) return 0.0f;
- float normFactor = sqrtf(m_parametricArea / m_geometricArea);
- return sqrtf(m_stretchMetric / m_geometricArea) * normFactor;
- }
-
- float maxStretchMetric() const
- {
- if (m_geometricArea == 0) return 0.0f;
- float normFactor = sqrtf(m_parametricArea / m_geometricArea);
- return m_maxStretchMetric * normFactor;
- }
-
- float rmsConformalMetric() const
- {
- if (m_geometricArea == 0) return 0.0f;
- return sqrtf(m_conformalMetric / m_geometricArea);
- }
-
- float maxAuthalicMetric() const
- {
- if (m_geometricArea == 0) return 0.0f;
- return sqrtf(m_authalicMetric / m_geometricArea);
- }
-
- void operator+=(const ParameterizationQuality &pq)
- {
- m_totalTriangleCount += pq.m_totalTriangleCount;
- m_flippedTriangleCount += pq.m_flippedTriangleCount;
- m_zeroAreaTriangleCount += pq.m_zeroAreaTriangleCount;
- m_parametricArea += pq.m_parametricArea;
- m_geometricArea += pq.m_geometricArea;
- m_stretchMetric += pq.m_stretchMetric;
- m_maxStretchMetric = std::max(m_maxStretchMetric, pq.m_maxStretchMetric);
- m_conformalMetric += pq.m_conformalMetric;
- m_authalicMetric += pq.m_authalicMetric;
- }
-
-private:
- void processTriangle(Vector3 q[3], Vector2 p[3])
- {
- m_totalTriangleCount++;
- // Evaluate texture stretch metric. See:
- // - "Texture Mapping Progressive Meshes", Sander, Snyder, Gortler & Hoppe
- // - "Mesh Parameterization: Theory and Practice", Siggraph'07 Course Notes, Hormann, Levy & Sheffer.
- float t1 = p[0].x;
- float s1 = p[0].y;
- float t2 = p[1].x;
- float s2 = p[1].y;
- float t3 = p[2].x;
- float s3 = p[2].y;
- float geometricArea = length(cross(q[1] - q[0], q[2] - q[0])) / 2;
- float parametricArea = ((s2 - s1) * (t3 - t1) - (s3 - s1) * (t2 - t1)) / 2;
- if (isZero(parametricArea)) {
- m_zeroAreaTriangleCount++;
- return;
- }
- Vector3 Ss = (q[0] * (t2 - t3) + q[1] * (t3 - t1) + q[2] * (t1 - t2)) / (2 * parametricArea);
- Vector3 St = (q[0] * (s3 - s2) + q[1] * (s1 - s3) + q[2] * (s2 - s1)) / (2 * parametricArea);
- float a = dot(Ss, Ss); // E
- float b = dot(Ss, St); // F
- float c = dot(St, St); // G
- // Compute eigen-values of the first fundamental form:
- float sigma1 = sqrtf(0.5f * std::max(0.0f, a + c - sqrtf(square(a - c) + 4 * square(b)))); // gamma uppercase, min eigenvalue.
- float sigma2 = sqrtf(0.5f * std::max(0.0f, a + c + sqrtf(square(a - c) + 4 * square(b)))); // gamma lowercase, max eigenvalue.
- xaAssert(sigma2 >= sigma1);
- // isometric: sigma1 = sigma2 = 1
- // conformal: sigma1 / sigma2 = 1
- // authalic: sigma1 * sigma2 = 1
- float rmsStretch = sqrtf((a + c) * 0.5f);
- float rmsStretch2 = sqrtf((square(sigma1) + square(sigma2)) * 0.5f);
- xaDebugAssert(equal(rmsStretch, rmsStretch2, 0.01f));
-#ifdef NDEBUG
- rmsStretch2 = 0; // silence unused parameter warning
+ // Add faces.
+ for (uint32_t f = 0; f < faceCount; f++) {
+ const uint32_t face = m_faceToSourceFaceMap[f];
+ uint32_t indices[3];
+ for (uint32_t i = 0; i < 3; i++) {
+ const uint32_t vertex = sourceMesh->vertexAt(face * 3 + i);
+ XA_DEBUG_ASSERT(meshIndices[vertex] != (uint32_t)~0);
+ indices[i] = meshIndices[vertex];
+ }
+ // Don't copy flags, it doesn't matter if a face is ignored after this point. All ignored faces get their own vertex map (m_isVertexMap) ChartGroup.
+ // Don't hash edges if m_isVertexMap, they may be degenerate.
+ Mesh::AddFaceResult::Enum result = m_mesh->addFace(indices, false, !m_isVertexMap);
+ XA_UNUSED(result);
+ XA_DEBUG_ASSERT(result == Mesh::AddFaceResult::OK);
+ }
+ if (!m_isVertexMap) {
+ m_mesh->createColocals();
+ m_mesh->createBoundaries();
+ m_mesh->linkBoundaries();
+ }
+#if XA_DEBUG_EXPORT_OBJ_CHART_GROUPS
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u.obj", m_sourceId, m_id);
+ m_mesh->writeObjFile(filename);
+#else
+ XA_UNUSED(m_id);
#endif
- if (parametricArea < 0.0f) {
- // Count flipped triangles.
- m_flippedTriangleCount++;
- parametricArea = fabsf(parametricArea);
- }
- m_stretchMetric += square(rmsStretch) * geometricArea;
- m_maxStretchMetric = std::max(m_maxStretchMetric, sigma2);
- if (!isZero(sigma1, 0.000001f)) {
- // sigma1 is zero when geometricArea is zero.
- m_conformalMetric += (sigma2 / sigma1) * geometricArea;
- }
- m_authalicMetric += (sigma1 * sigma2) * geometricArea;
- // Accumulate total areas.
- m_geometricArea += geometricArea;
- m_parametricArea += parametricArea;
- //triangleConformalEnergy(q, p);
}
- uint32_t m_totalTriangleCount;
- uint32_t m_flippedTriangleCount;
- uint32_t m_zeroAreaTriangleCount;
- float m_parametricArea;
- float m_geometricArea;
- float m_stretchMetric;
- float m_maxStretchMetric;
- float m_conformalMetric;
- float m_authalicMetric;
-};
-
-// Set of charts corresponding to a single mesh.
-class MeshCharts
-{
-public:
- MeshCharts(const halfedge::Mesh *mesh) : m_mesh(mesh) {}
-
- ~MeshCharts()
+ ~ChartGroup()
{
- for (size_t i = 0; i < m_chartArray.size(); i++)
- delete m_chartArray[i];
- }
-
- uint32_t chartCount() const
- {
- return m_chartArray.size();
- }
- uint32_t vertexCount () const
- {
- return m_totalVertexCount;
- }
-
- const Chart *chartAt(uint32_t i) const
- {
- return m_chartArray[i];
- }
- Chart *chartAt(uint32_t i)
- {
- return m_chartArray[i];
- }
-
- // Extract the charts of the input mesh.
- void extractCharts()
- {
- const uint32_t faceCount = m_mesh->faceCount();
- int first = 0;
- std::vector<uint32_t> queue;
- queue.reserve(faceCount);
- BitArray bitFlags(faceCount);
- bitFlags.clearAll();
- for (uint32_t f = 0; f < faceCount; f++) {
- if (bitFlags.bitAt(f) == false) {
- // Start new patch. Reset queue.
- first = 0;
- queue.clear();
- queue.push_back(f);
- bitFlags.setBitAt(f);
- while (first != (int)queue.size()) {
- const halfedge::Face *face = m_mesh->faceAt(queue[first]);
- // Visit face neighbors of queue[first]
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- const halfedge::Edge *edge = it.current();
- xaDebugAssert(edge->pair != NULL);
- if (!edge->isBoundary() && /*!edge->isSeam()*/
- //!(edge->from()->tex() != edge->pair()->to()->tex() || edge->to()->tex() != edge->pair()->from()->tex()))
- !(edge->from() != edge->pair->to() || edge->to() != edge->pair->from())) { // Preserve existing seams (not just texture seams).
- const halfedge::Face *neighborFace = edge->pair->face;
- xaDebugAssert(neighborFace != NULL);
- if (bitFlags.bitAt(neighborFace->id) == false) {
- queue.push_back(neighborFace->id);
- bitFlags.setBitAt(neighborFace->id);
- }
- }
- }
- first++;
- }
- Chart *chart = new Chart();
- chart->build(m_mesh, queue);
- m_chartArray.push_back(chart);
- }
+ m_mesh->~Mesh();
+ XA_FREE(m_mesh);
+ for (uint32_t i = 0; i < m_chartArray.size(); i++) {
+ m_chartArray[i]->~Chart();
+ XA_FREE(m_chartArray[i]);
}
}
+ uint32_t chartCount() const { return m_chartArray.size(); }
+ Chart *chartAt(uint32_t i) const { return m_chartArray[i]; }
+ uint32_t paramAddedChartsCount() const { return m_paramAddedChartsCount; }
+ uint32_t paramDeletedChartsCount() const { return m_paramDeletedChartsCount; }
+ bool isVertexMap() const { return m_isVertexMap; }
+ uint32_t mapFaceToSourceFace(uint32_t face) const { return m_faceToSourceFaceMap[face]; }
+ uint32_t mapVertexToSourceVertex(uint32_t i) const { return m_vertexToSourceVertexMap[i]; }
+ const Mesh *mesh() const { return m_mesh; }
+
/*
Compute charts using a simple segmentation algorithm.
@@ -6481,617 +6107,1122 @@ public:
- emphasize roundness metrics to prevent those cases.
- If interior self-overlaps: preserve boundary parameterization and use mean-value map.
*/
- void computeCharts(const CharterOptions &options, const std::vector<uint32_t> &unchartedMaterialArray)
- {
- Chart *vertexMap = NULL;
- if (unchartedMaterialArray.size() != 0) {
- vertexMap = new Chart();
- vertexMap->buildVertexMap(m_mesh, unchartedMaterialArray);
- if (vertexMap->faceCount() == 0) {
- delete vertexMap;
- vertexMap = NULL;
- }
- }
- AtlasBuilder builder(m_mesh);
- if (vertexMap != NULL) {
- // Mark faces that do not need to be charted.
- builder.markUnchartedFaces(vertexMap->faceArray());
- m_chartArray.push_back(vertexMap);
- }
- if (builder.facesLeft != 0) {
- // Tweak these values:
- const float maxThreshold = 2;
- const uint32_t growFaceCount = 32;
- const uint32_t maxIterations = 4;
- builder.options = options;
- //builder.options.proxyFitMetricWeight *= 0.75; // relax proxy fit weight during initial seed placement.
- //builder.options.roundnessMetricWeight = 0;
- //builder.options.straightnessMetricWeight = 0;
- // This seems a reasonable estimate.
- uint32_t maxSeedCount = std::max(6U, builder.facesLeft);
- // Create initial charts greedely.
- xaPrint("### Placing seeds\n");
- builder.placeSeeds(maxThreshold, maxSeedCount);
- xaPrint("### Placed %d seeds (max = %d)\n", builder.chartCount(), maxSeedCount);
- builder.updateProxies();
- builder.mergeCharts();
- #if 1
- xaPrint("### Relocating seeds\n");
- builder.relocateSeeds();
- xaPrint("### Reset charts\n");
- builder.resetCharts();
- if (vertexMap != NULL) {
- builder.markUnchartedFaces(vertexMap->faceArray());
- }
- builder.options = options;
- xaPrint("### Growing charts\n");
- // Restart process growing charts in parallel.
- uint32_t iteration = 0;
- while (true) {
- if (!builder.growCharts(maxThreshold, growFaceCount)) {
- xaPrint("### Can't grow anymore\n");
- // If charts cannot grow more: fill holes, merge charts, relocate seeds and start new iteration.
- xaPrint("### Filling holes\n");
- builder.fillHoles(maxThreshold);
- xaPrint("### Using %d charts now\n", builder.chartCount());
- builder.updateProxies();
- xaPrint("### Merging charts\n");
- builder.mergeCharts();
- xaPrint("### Using %d charts now\n", builder.chartCount());
- xaPrint("### Reseeding\n");
- if (!builder.relocateSeeds()) {
- xaPrint("### Cannot relocate seeds anymore\n");
- // Done!
- break;
- }
- if (iteration == maxIterations) {
- xaPrint("### Reached iteration limit\n");
- break;
- }
- iteration++;
- xaPrint("### Reset charts\n");
- builder.resetCharts();
- if (vertexMap != NULL) {
- builder.markUnchartedFaces(vertexMap->faceArray());
- }
- xaPrint("### Growing charts\n");
- }
- };
- #endif
- // Make sure no holes are left!
- xaDebugAssert(builder.facesLeft == 0);
- const uint32_t chartCount = builder.chartArray.size();
- for (uint32_t i = 0; i < chartCount; i++) {
- Chart *chart = new Chart();
- m_chartArray.push_back(chart);
- chart->build(m_mesh, builder.chartFaces(i));
- }
- }
- const uint32_t chartCount = m_chartArray.size();
- // Build face indices.
- m_faceChart.resize(m_mesh->faceCount());
- m_faceIndex.resize(m_mesh->faceCount());
+ void computeCharts(const ChartOptions &options)
+ {
+ m_chartOptions = options;
+ // This function may be called multiple times, so destroy existing charts.
+ for (uint32_t i = 0; i < m_chartArray.size(); i++) {
+ m_chartArray[i]->~Chart();
+ XA_FREE(m_chartArray[i]);
+ }
+ m_chartArray.clear();
+#if XA_DEBUG_SINGLE_CHART
+ Array<uint32_t> chartFaces;
+ chartFaces.resize(m_mesh->faceCount());
+ for (uint32_t i = 0; i < chartFaces.size(); i++)
+ chartFaces[i] = i;
+ Chart *chart = XA_NEW(MemTag::Default, Chart, m_mesh, chartFaces, m_sourceId, m_id, 0);
+ m_chartArray.push_back(chart);
+#else
+ XA_PROFILE_START(atlasBuilder)
+ AtlasBuilder builder(m_mesh, nullptr, options);
+ runAtlasBuilder(builder, options);
+ XA_PROFILE_END(atlasBuilder)
+ XA_PROFILE_START(createChartMeshes)
+ const uint32_t chartCount = builder.chartCount();
for (uint32_t i = 0; i < chartCount; i++) {
- const Chart *chart = m_chartArray[i];
- const uint32_t faceCount = chart->faceCount();
- for (uint32_t f = 0; f < faceCount; f++) {
- uint32_t idx = chart->faceAt(f);
- m_faceChart[idx] = i;
- m_faceIndex[idx] = f;
- }
+ Chart *chart = XA_NEW(MemTag::Default, Chart, m_mesh, builder.chartFaces(i), builder.chartBasis(i), m_sourceId, m_id, i);
+ m_chartArray.push_back(chart);
}
- // Build an exclusive prefix sum of the chart vertex counts.
- m_chartVertexCountPrefixSum.resize(chartCount);
- if (chartCount > 0) {
- m_chartVertexCountPrefixSum[0] = 0;
- for (uint32_t i = 1; i < chartCount; i++) {
- const Chart *chart = m_chartArray[i - 1];
- m_chartVertexCountPrefixSum[i] = m_chartVertexCountPrefixSum[i - 1] + chart->vertexCount();
+ XA_PROFILE_END(createChartMeshes)
+#endif
+#if XA_DEBUG_EXPORT_OBJ_CHARTS
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_charts.obj", m_sourceId, m_id);
+ FILE *file;
+ XA_FOPEN(file, filename, "w");
+ if (file) {
+ m_mesh->writeObjVertices(file);
+ for (uint32_t i = 0; i < chartCount; i++) {
+ fprintf(file, "o chart_%04d\n", i);
+ fprintf(file, "s off\n");
+ const Array<uint32_t> &faces = builder.chartFaces(i);
+ for (uint32_t f = 0; f < faces.size(); f++)
+ m_mesh->writeObjFace(file, faces[f]);
}
- m_totalVertexCount = m_chartVertexCountPrefixSum[chartCount - 1] + m_chartArray[chartCount - 1]->vertexCount();
- } else {
- m_totalVertexCount = 0;
+ m_mesh->writeObjBoundaryEges(file);
+ m_mesh->writeObjLinkedBoundaries(file);
+ fclose(file);
}
+#endif
}
- void parameterizeCharts()
+ void parameterizeCharts(ParameterizeFunc func)
{
- ParameterizationQuality globalParameterizationQuality;
- // Parameterize the charts.
- uint32_t diskCount = 0;
+#if XA_RECOMPUTE_CHARTS
+ Array<Chart *> invalidCharts;
const uint32_t chartCount = m_chartArray.size();
- for (uint32_t i = 0; i < chartCount; i++)
- {
+ for (uint32_t i = 0; i < chartCount; i++) {
Chart *chart = m_chartArray[i];
-
- bool isValid = false;
-
- if (chart->isVertexMapped())
- {
- continue;
- }
-
- if (chart->isDisk())
- {
- diskCount++;
- ParameterizationQuality chartParameterizationQuality;
- if (chart->faceCount() == 1) {
- computeSingleFaceMap(chart->unifiedMesh());
- chartParameterizationQuality = ParameterizationQuality(chart->unifiedMesh());
- } else {
- computeOrthogonalProjectionMap(chart->unifiedMesh());
- ParameterizationQuality orthogonalQuality(chart->unifiedMesh());
- computeLeastSquaresConformalMap(chart->unifiedMesh());
- ParameterizationQuality lscmQuality(chart->unifiedMesh());
- chartParameterizationQuality = lscmQuality;
- }
- isValid = chartParameterizationQuality.isValid();
- if (!isValid) {
- xaPrint("*** Invalid parameterization.\n");
+ parameterizeChart(chart, func);
+ const ParameterizationQuality &quality = chart->paramQuality();
+ if (quality.boundaryIntersection || quality.flippedTriangleCount > 0)
+ invalidCharts.push_back(chart);
+ }
+ // Recompute charts with invalid parameterizations.
+ Array<uint32_t> meshFaces;
+ for (uint32_t i = 0; i < invalidCharts.size(); i++) {
+ Chart *invalidChart = invalidCharts[i];
+ const Mesh *invalidMesh = invalidChart->mesh();
+ const uint32_t faceCount = invalidMesh->faceCount();
+ meshFaces.resize(faceCount);
+ float invalidChartArea = 0.0f;
+ for (uint32_t j = 0; j < faceCount; j++) {
+ meshFaces[j] = invalidChart->mapFaceToSourceFace(j);
+ invalidChartArea += invalidMesh->faceArea(j);
+ }
+ ChartOptions options = m_chartOptions;
+ options.maxChartArea = invalidChartArea * 0.2f;
+ options.maxThreshold = 0.25f;
+ options.maxIterations = 3;
+ AtlasBuilder builder(m_mesh, &meshFaces, options);
+ runAtlasBuilder(builder, options);
+ for (uint32_t j = 0; j < builder.chartCount(); j++) {
+ Chart *chart = XA_NEW(MemTag::Default, Chart, m_mesh, builder.chartFaces(j), builder.chartBasis(j), m_sourceId, m_id, m_chartArray.size());
+ m_chartArray.push_back(chart);
+ m_paramAddedChartsCount++;
+ }
+#if XA_DEBUG_EXPORT_OBJ_RECOMPUTED_CHARTS
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u_chartgroup_%03u_recomputed_chart_%u.obj", m_sourceId, m_id, i);
+ FILE *file;
+ XA_FOPEN(file, filename, "w");
+ if (file) {
+ m_mesh->writeObjVertices(file);
+ for (uint32_t j = 0; j < builder.chartCount(); j++) {
+ fprintf(file, "o chart_%04d\n", j);
+ fprintf(file, "s off\n");
+ const Array<uint32_t> &faces = builder.chartFaces(j);
+ for (uint32_t f = 0; f < faces.size(); f++)
+ m_mesh->writeObjFace(file, faces[f]);
}
- // @@ Check that parameterization quality is above a certain threshold.
- // @@ Detect boundary self-intersections.
- globalParameterizationQuality += chartParameterizationQuality;
+ fclose(file);
}
-
- // Transfer parameterization from unified mesh to chart mesh.
- chart->transferParameterization();
-
+#endif
+ }
+ // Parameterize the new charts.
+ for (uint32_t i = chartCount; i < m_chartArray.size(); i++)
+ parameterizeChart(m_chartArray[i], func);
+ // Remove and delete the invalid charts.
+ for (uint32_t i = 0; i < invalidCharts.size(); i++) {
+ Chart *chart = invalidCharts[i];
+ removeChart(chart);
+ chart->~Chart();
+ XA_FREE(chart);
+ m_paramDeletedChartsCount++;
}
- xaPrint(" Parameterized %d/%d charts.\n", diskCount, chartCount);
- xaPrint(" RMS stretch metric: %f\n", globalParameterizationQuality.rmsStretchMetric());
- xaPrint(" MAX stretch metric: %f\n", globalParameterizationQuality.maxStretchMetric());
- xaPrint(" RMS conformal metric: %f\n", globalParameterizationQuality.rmsConformalMetric());
- xaPrint(" RMS authalic metric: %f\n", globalParameterizationQuality.maxAuthalicMetric());
+#else
+ const uint32_t chartCount = m_chartArray.size();
+ for (uint32_t i = 0; i < chartCount; i++) {
+ Chart *chart = m_chartArray[i];
+ parameterizeChart(chart, func);
+ }
+#endif
}
- uint32_t faceChartAt(uint32_t i) const
- {
- return m_faceChart[i];
- }
- uint32_t faceIndexWithinChartAt(uint32_t i) const
+private:
+ void runAtlasBuilder(AtlasBuilder &builder, const ChartOptions &options)
{
- return m_faceIndex[i];
+ if (builder.facesLeft() == 0)
+ return;
+ // This seems a reasonable estimate.
+ XA_PROFILE_START(atlasBuilderCreateInitialCharts)
+ // Create initial charts greedely.
+ builder.placeSeeds(options.maxThreshold * 0.5f);
+ if (options.maxIterations == 0) {
+ XA_DEBUG_ASSERT(builder.facesLeft() == 0);
+ XA_PROFILE_END(atlasBuilderCreateInitialCharts)
+ return;
+ }
+ builder.updateProxies();
+ builder.relocateSeeds();
+ builder.resetCharts();
+ XA_PROFILE_END(atlasBuilderCreateInitialCharts)
+ // Restart process growing charts in parallel.
+ uint32_t iteration = 0;
+ while (true) {
+ if (!builder.growCharts(options.maxThreshold, options.growFaceCount)) {
+ // If charts cannot grow more: fill holes, merge charts, relocate seeds and start new iteration.
+ builder.fillHoles(options.maxThreshold * 0.5f);
+ builder.updateProxies();
+#if XA_MERGE_CHARTS
+ builder.mergeCharts();
+#endif
+ if (++iteration == options.maxIterations)
+ break;
+ if (!builder.relocateSeeds())
+ break;
+ builder.resetCharts();
+ }
+ }
+ // Make sure no holes are left!
+ XA_DEBUG_ASSERT(builder.facesLeft() == 0);
}
- uint32_t vertexCountBeforeChartAt(uint32_t i) const
+ void parameterizeChart(Chart *chart, ParameterizeFunc func)
{
- return m_chartVertexCountPrefixSum[i];
+ Mesh *mesh = chart->unifiedMesh();
+ XA_PROFILE_START(parameterizeChartsOrthogonal)
+#if 1
+ computeOrthogonalProjectionMap(mesh);
+#else
+ for (uint32_t i = 0; i < vertexCount; i++)
+ mesh->texcoord(i) = Vector2(dot(chart->basis().tangent, mesh->position(i)), dot(chart->basis().bitangent, mesh->position(i)));
+#endif
+ XA_PROFILE_END(parameterizeChartsOrthogonal)
+ chart->evaluateOrthoParameterizationQuality();
+ if (!chart->isOrtho() && !chart->isPlanar()) {
+ XA_PROFILE_START(parameterizeChartsLSCM)
+ if (func)
+ func(&mesh->position(0).x, &mesh->texcoord(0).x, mesh->vertexCount(), mesh->indices(), mesh->indexCount());
+ else if (chart->isDisk())
+ computeLeastSquaresConformalMap(mesh);
+ XA_PROFILE_END(parameterizeChartsLSCM)
+ chart->evaluateParameterizationQuality();
+ }
+ // @@ Check that parameterization quality is above a certain threshold.
+ // Transfer parameterization from unified mesh to chart mesh.
+ chart->transferParameterization();
+ }
+
+ void removeChart(const Chart *chart)
+ {
+ for (uint32_t i = 0; i < m_chartArray.size(); i++) {
+ if (m_chartArray[i] == chart) {
+ m_chartArray.removeAt(i);
+ return;
+ }
+ }
}
-private:
+ uint32_t m_sourceId, m_id;
+ bool m_isVertexMap;
+ Mesh *m_mesh;
+ Array<uint32_t> m_faceToSourceFaceMap; // List of faces of the source mesh that belong to this chart group.
+ Array<uint32_t> m_vertexToSourceVertexMap; // Map vertices of the mesh to vertices of the source mesh.
+ Array<Chart *> m_chartArray;
+ ChartOptions m_chartOptions;
+ uint32_t m_paramAddedChartsCount; // Number of new charts added by recomputing charts with invalid parameterizations.
+ uint32_t m_paramDeletedChartsCount; // Number of charts with invalid parameterizations that were deleted, after charts were recomputed.
+};
- const halfedge::Mesh *m_mesh;
+struct CreateChartGroupTaskArgs
+{
+ uint32_t faceGroup;
+ uint32_t groupId;
+ const Mesh *mesh;
+ ChartGroup **chartGroup;
+};
- std::vector<Chart *> m_chartArray;
+static void runCreateChartGroupTask(void *userData)
+{
+ XA_PROFILE_START(addMeshCreateChartGroups)
+ auto args = (CreateChartGroupTaskArgs *)userData;
+ *(args->chartGroup) = XA_NEW(MemTag::Default, ChartGroup, args->groupId, args->mesh, args->faceGroup);
+ XA_PROFILE_END(addMeshCreateChartGroups)
+}
- std::vector<uint32_t> m_chartVertexCountPrefixSum;
- uint32_t m_totalVertexCount;
+struct ComputeChartsTaskArgs
+{
+ ChartGroup *chartGroup;
+ const ChartOptions *options;
+ Progress *progress;
+};
+
+static void runComputeChartsJob(void *userData)
+{
+ ComputeChartsTaskArgs *args = (ComputeChartsTaskArgs *)userData;
+ if (args->progress->cancel)
+ return;
+ XA_PROFILE_START(computeCharts)
+ args->chartGroup->computeCharts(*args->options);
+ XA_PROFILE_END(computeCharts)
+ args->progress->value++;
+ args->progress->update();
+}
- std::vector<uint32_t> m_faceChart; // the chart of every face of the input mesh.
- std::vector<uint32_t> m_faceIndex; // the index within the chart for every face of the input mesh.
+struct ParameterizeChartsTaskArgs
+{
+ ChartGroup *chartGroup;
+ ParameterizeFunc func;
+ Progress *progress;
};
-/// An atlas is a set of charts.
+static void runParameterizeChartsJob(void *userData)
+{
+ ParameterizeChartsTaskArgs *args = (ParameterizeChartsTaskArgs *)userData;
+ if (args->progress->cancel)
+ return;
+ XA_PROFILE_START(parameterizeCharts)
+ args->chartGroup->parameterizeCharts(args->func);
+ XA_PROFILE_END(parameterizeCharts)
+ args->progress->value++;
+ args->progress->update();
+}
+
+/// An atlas is a set of chart groups.
class Atlas
{
public:
+ Atlas() : m_chartsComputed(false), m_chartsParameterized(false) {}
+
~Atlas()
{
- for (size_t i = 0; i < m_meshChartsArray.size(); i++)
- delete m_meshChartsArray[i];
+ for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+ m_chartGroups[i]->~ChartGroup();
+ XA_FREE(m_chartGroups[i]);
+ }
}
- uint32_t meshCount() const
- {
- return m_meshChartsArray.size();
- }
+ bool chartsComputed() const { return m_chartsComputed; }
+ bool chartsParameterized() const { return m_chartsParameterized; }
- const MeshCharts *meshAt(uint32_t i) const
+ uint32_t chartGroupCount(uint32_t mesh) const
{
- return m_meshChartsArray[i];
+ uint32_t count = 0;
+ for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+ if (m_chartGroupSourceMeshes[i] == mesh)
+ count++;
+ }
+ return count;
}
- MeshCharts *meshAt(uint32_t i)
+ const ChartGroup *chartGroupAt(uint32_t mesh, uint32_t group) const
{
- return m_meshChartsArray[i];
+ for (uint32_t c = 0; c < m_chartGroups.size(); c++) {
+ if (m_chartGroupSourceMeshes[c] != mesh)
+ continue;
+ if (group == 0)
+ return m_chartGroups[c];
+ group--;
+ }
+ return nullptr;
}
uint32_t chartCount() const
{
uint32_t count = 0;
- for (uint32_t c = 0; c < m_meshChartsArray.size(); c++) {
- count += m_meshChartsArray[c]->chartCount();
- }
+ for (uint32_t i = 0; i < m_chartGroups.size(); i++)
+ count += m_chartGroups[i]->chartCount();
return count;
}
- const Chart *chartAt(uint32_t i) const
+ Chart *chartAt(uint32_t i)
{
- for (uint32_t c = 0; c < m_meshChartsArray.size(); c++) {
- uint32_t count = m_meshChartsArray[c]->chartCount();
+ for (uint32_t c = 0; c < m_chartGroups.size(); c++) {
+ uint32_t count = m_chartGroups[c]->chartCount();
if (i < count) {
- return m_meshChartsArray[c]->chartAt(i);
+ return m_chartGroups[c]->chartAt(i);
}
i -= count;
}
- return NULL;
+ return nullptr;
}
- Chart *chartAt(uint32_t i)
+ // This function is thread safe.
+ void addMesh(TaskScheduler *taskScheduler, const Mesh *mesh)
{
- for (uint32_t c = 0; c < m_meshChartsArray.size(); c++) {
- uint32_t count = m_meshChartsArray[c]->chartCount();
- if (i < count) {
- return m_meshChartsArray[c]->chartAt(i);
+ // Get list of face groups.
+ const uint32_t faceCount = mesh->faceCount();
+ Array<uint32_t> faceGroups;
+ for (uint32_t f = 0; f < faceCount; f++) {
+ const uint32_t group = mesh->faceGroupAt(f);
+ bool exists = false;
+ for (uint32_t g = 0; g < faceGroups.size(); g++) {
+ if (faceGroups[g] == group) {
+ exists = true;
+ break;
+ }
+ }
+ if (!exists)
+ faceGroups.push_back(group);
+ }
+ // Create one chart group per face group.
+ // Chart group creation is slow since it copies a chunk of the source mesh, so use tasks.
+ Array<ChartGroup *> chartGroups;
+ chartGroups.resize(faceGroups.size());
+ Array<CreateChartGroupTaskArgs> taskArgs;
+ taskArgs.resize(chartGroups.size());
+ for (uint32_t g = 0; g < chartGroups.size(); g++) {
+ CreateChartGroupTaskArgs &args = taskArgs[g];
+ args.chartGroup = &chartGroups[g];
+ args.faceGroup = faceGroups[g];
+ args.groupId = g;
+ args.mesh = mesh;
+ }
+ TaskGroupHandle taskGroup;
+ for (uint32_t g = 0; g < chartGroups.size(); g++) {
+ Task task;
+ task.userData = &taskArgs[g];
+ task.func = runCreateChartGroupTask;
+ taskScheduler->run(&taskGroup, task);
+ }
+ taskScheduler->wait(&taskGroup);
+ // Thread-safe append.
+ m_addMeshMutex.lock();
+ for (uint32_t g = 0; g < chartGroups.size(); g++) {
+ m_chartGroups.push_back(chartGroups[g]);
+ m_chartGroupSourceMeshes.push_back(mesh->id());
+ }
+ m_addMeshMutex.unlock();
+ }
+
+ bool computeCharts(TaskScheduler *taskScheduler, const ChartOptions &options, ProgressFunc progressFunc, void *progressUserData)
+ {
+ m_chartsComputed = false;
+ m_chartsParameterized = false;
+ uint32_t taskCount = 0;
+ for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+ if (!m_chartGroups[i]->isVertexMap())
+ taskCount++;
+ }
+ Progress progress(ProgressCategory::ComputeCharts, progressFunc, progressUserData, taskCount);
+ Array<ComputeChartsTaskArgs> taskArgs;
+ taskArgs.reserve(taskCount);
+ for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+ if (!m_chartGroups[i]->isVertexMap()) {
+ ComputeChartsTaskArgs args;
+ args.chartGroup = m_chartGroups[i];
+ args.options = &options;
+ args.progress = &progress;
+ taskArgs.push_back(args);
+ }
+ }
+ TaskGroupHandle taskGroup;
+ for (uint32_t i = 0; i < taskCount; i++) {
+ Task task;
+ task.userData = &taskArgs[i];
+ task.func = runComputeChartsJob;
+ taskScheduler->run(&taskGroup, task);
+ }
+ taskScheduler->wait(&taskGroup);
+ if (progress.cancel)
+ return false;
+ m_chartsComputed = true;
+ return true;
+ }
+
+ bool parameterizeCharts(TaskScheduler *taskScheduler, ParameterizeFunc func, ProgressFunc progressFunc, void *progressUserData)
+ {
+ m_chartsParameterized = false;
+ uint32_t taskCount = 0;
+ for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+ if (!m_chartGroups[i]->isVertexMap())
+ taskCount++;
+ }
+ Progress progress(ProgressCategory::ParameterizeCharts, progressFunc, progressUserData, taskCount);
+ Array<ParameterizeChartsTaskArgs> taskArgs;
+ taskArgs.reserve(taskCount);
+ for (uint32_t i = 0; i < m_chartGroups.size(); i++) {
+ if (!m_chartGroups[i]->isVertexMap()) {
+ ParameterizeChartsTaskArgs args;
+ args.chartGroup = m_chartGroups[i];
+ args.func = func;
+ args.progress = &progress;
+ taskArgs.push_back(args);
}
- i -= count;
}
- return NULL;
+ TaskGroupHandle taskGroup;
+ for (uint32_t i = 0; i < taskCount; i++) {
+ Task task;
+ task.userData = &taskArgs[i];
+ task.func = runParameterizeChartsJob;
+ taskScheduler->run(&taskGroup, task);
+ }
+ taskScheduler->wait(&taskGroup);
+ if (progress.cancel)
+ return false;
+ // Save original texcoords so PackCharts can be called multiple times (packing overwrites the texcoords).
+ const uint32_t nCharts = chartCount();
+ m_originalChartTexcoords.resize(nCharts);
+ for (uint32_t i = 0; i < nCharts; i++) {
+ const Mesh *mesh = chartAt(i)->mesh();
+ m_originalChartTexcoords[i].resize(mesh->vertexCount());
+ for (uint32_t j = 0; j < mesh->vertexCount(); j++)
+ m_originalChartTexcoords[i][j] = mesh->texcoord(j);
+ }
+ m_chartsParameterized = true;
+ return true;
}
- // Add mesh charts and takes ownership.
- // Extract the charts and add to this atlas.
- void addMeshCharts(MeshCharts *meshCharts)
+ void restoreOriginalChartTexcoords()
{
- m_meshChartsArray.push_back(meshCharts);
+ const uint32_t nCharts = chartCount();
+ for (uint32_t i = 0; i < nCharts; i++) {
+ Mesh *mesh = chartAt(i)->mesh();
+ for (uint32_t j = 0; j < mesh->vertexCount(); j++)
+ mesh->texcoord(j) = m_originalChartTexcoords[i][j];
+ }
}
- void extractCharts(const halfedge::Mesh *mesh)
+private:
+ std::mutex m_addMeshMutex;
+ bool m_chartsComputed;
+ bool m_chartsParameterized;
+ Array<ChartGroup *> m_chartGroups;
+ Array<uint32_t> m_chartGroupSourceMeshes;
+ Array<Array<Vector2> > m_originalChartTexcoords;
+};
+
+} // namespace param
+
+namespace pack {
+
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+const uint8_t TGA_TYPE_RGB = 2;
+const uint8_t TGA_ORIGIN_UPPER = 0x20;
+
+#pragma pack(push, 1)
+struct TgaHeader
+{
+ uint8_t id_length;
+ uint8_t colormap_type;
+ uint8_t image_type;
+ uint16_t colormap_index;
+ uint16_t colormap_length;
+ uint8_t colormap_size;
+ uint16_t x_origin;
+ uint16_t y_origin;
+ uint16_t width;
+ uint16_t height;
+ uint8_t pixel_size;
+ uint8_t flags;
+ enum { Size = 18 };
+};
+#pragma pack(pop)
+
+static void WriteTga(const char *filename, const uint8_t *data, uint32_t width, uint32_t height)
+{
+ XA_DEBUG_ASSERT(sizeof(TgaHeader) == TgaHeader::Size);
+ FILE *f;
+ XA_FOPEN(f, filename, "wb");
+ if (!f)
+ return;
+ TgaHeader tga;
+ tga.id_length = 0;
+ tga.colormap_type = 0;
+ tga.image_type = TGA_TYPE_RGB;
+ tga.colormap_index = 0;
+ tga.colormap_length = 0;
+ tga.colormap_size = 0;
+ tga.x_origin = 0;
+ tga.y_origin = 0;
+ tga.width = (uint16_t)width;
+ tga.height = (uint16_t)height;
+ tga.pixel_size = 24;
+ tga.flags = TGA_ORIGIN_UPPER;
+ fwrite(&tga, sizeof(TgaHeader), 1, f);
+ fwrite(data, sizeof(uint8_t), width * height * 3, f);
+ fclose(f);
+}
+#endif
+
+class AtlasImage
+{
+public:
+ AtlasImage(uint32_t width, uint32_t height) : m_width(width), m_height(height)
{
- MeshCharts *meshCharts = new MeshCharts(mesh);
- meshCharts->extractCharts();
- addMeshCharts(meshCharts);
+ m_data.resize(m_width * m_height);
+ memset(m_data.data(), 0, sizeof(uint32_t) * m_data.size());
}
- void computeCharts(const halfedge::Mesh *mesh, const CharterOptions &options, const std::vector<uint32_t> &unchartedMaterialArray)
+ void resize(uint32_t width, uint32_t height)
{
- MeshCharts *meshCharts = new MeshCharts(mesh);
- meshCharts->computeCharts(options, unchartedMaterialArray);
- addMeshCharts(meshCharts);
+ Array<uint32_t> data;
+ data.resize(width * height);
+ memset(data.data(), 0, sizeof(uint32_t) * data.size());
+ for (uint32_t y = 0; y < min(m_height, height); y++)
+ memcpy(&data[y * width], &m_data[y * m_width], min(m_width, width) * sizeof(uint32_t));
+ m_width = width;
+ m_height = height;
+ swap(m_data, data);
}
- void parameterizeCharts()
+ void addChart(uint32_t chartIndex, const BitImage *image, bool imageHasPadding, int atlas_w, int atlas_h, int offset_x, int offset_y)
{
- for (uint32_t i = 0; i < m_meshChartsArray.size(); i++) {
- m_meshChartsArray[i]->parameterizeCharts();
+ const int w = image->width();
+ const int h = image->height();
+ for (int y = 0; y < h; y++) {
+ const int yy = y + offset_y;
+ if (yy < 0)
+ continue;
+ for (int x = 0; x < w; x++) {
+ const int xx = x + offset_x;
+ if (xx >= 0 && xx < atlas_w && yy < atlas_h && image->bitAt(x, y)) {
+ const uint32_t dataOffset = xx + yy * m_width;
+ if (m_data[dataOffset] != 0)
+ continue;
+ uint32_t value = chartIndex | kImageHasChartIndexBit;
+ if (imageHasPadding)
+ value |= kImageIsPaddingBit;
+ m_data[dataOffset] = value;
+ }
+ }
+ }
+ }
+
+ void copyTo(uint32_t *dest, uint32_t destWidth, uint32_t destHeight) const
+ {
+ for (uint32_t y = 0; y < destHeight; y++)
+ memcpy(&dest[y * destWidth], &m_data[y * m_width], destWidth * sizeof(uint32_t));
+ }
+
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+ void writeTga(const char *filename, uint32_t width, uint32_t height) const
+ {
+ Array<uint8_t> image;
+ image.resize(width * height * 3);
+ for (uint32_t y = 0; y < height; y++) {
+ if (y >= m_height)
+ continue;
+ for (uint32_t x = 0; x < width; x++) {
+ if (x >= m_width)
+ continue;
+ const uint32_t data = m_data[x + y * m_width];
+ if (!(data & kImageHasChartIndexBit))
+ continue;
+ const uint32_t chartIndex = data & kImageChartIndexMask;
+ uint8_t *color = &image[(x + y * width) * 3];
+ if (data & kImageIsPaddingBit) {
+ color[0] = 255;
+ color[1] = 0;
+ color[2] = 255;
+ } else {
+ const int mix = 192;
+ srand((unsigned int)chartIndex);
+ color[0] = uint8_t((rand() % 255 + mix) * 0.5f);
+ color[1] = uint8_t((rand() % 255 + mix) * 0.5f);
+ color[2] = uint8_t((rand() % 255 + mix) * 0.5f);
+ }
+ }
}
+ WriteTga(filename, image.data(), width, height);
}
+#endif
private:
- std::vector<MeshCharts *> m_meshChartsArray;
+ uint32_t m_width, m_height;
+ Array<uint32_t> m_data;
};
-struct AtlasPacker
+struct Chart
+{
+ int32_t atlasIndex;
+ uint32_t material;
+ uint32_t indexCount;
+ const uint32_t *indices;
+ float parametricArea;
+ float surfaceArea;
+ Vector2 *vertices;
+ uint32_t vertexCount;
+ Array<uint32_t> uniqueVertices;
+ bool allowRotate;
+ // bounding box
+ Vector2 majorAxis, minorAxis, minCorner, maxCorner;
+
+ Vector2 &uniqueVertexAt(uint32_t v) { return uniqueVertices.isEmpty() ? vertices[v] : vertices[uniqueVertices[v]]; }
+ uint32_t uniqueVertexCount() const { return uniqueVertices.isEmpty() ? vertexCount : uniqueVertices.size(); }
+};
+
+struct Atlas
{
- AtlasPacker(Atlas *atlas) : m_atlas(atlas), m_width(0), m_height(0)
+ ~Atlas()
{
- // Save the original uvs.
- m_originalChartUvs.resize(m_atlas->chartCount());
- for (uint32_t i = 0; i < m_atlas->chartCount(); i++) {
- const halfedge::Mesh *mesh = atlas->chartAt(i)->chartMesh();
- m_originalChartUvs[i].resize(mesh->vertexCount());
- for (uint32_t j = 0; j < mesh->vertexCount(); j++)
- m_originalChartUvs[i][j] = mesh->vertexAt(j)->tex;
+ for (uint32_t i = 0; i < m_bitImages.size(); i++) {
+ m_bitImages[i]->~BitImage();
+ XA_FREE(m_bitImages[i]);
+ }
+ for (uint32_t i = 0; i < m_charts.size(); i++) {
+ m_charts[i]->~Chart();
+ XA_FREE(m_charts[i]);
}
}
uint32_t getWidth() const { return m_width; }
uint32_t getHeight() const { return m_height; }
+ uint32_t getNumAtlases() const { return m_bitImages.size(); }
+ float getTexelsPerUnit() const { return m_texelsPerUnit; }
+ const Chart *getChart(uint32_t index) const { return m_charts[index]; }
+ uint32_t getChartCount() const { return m_charts.size(); }
+ const Array<AtlasImage *> &getImages() const { return m_atlasImages; }
+ float getUtilization(uint32_t atlas) const { return m_utilization[atlas]; }
+
+ void addChart(param::Chart *paramChart)
+ {
+ Mesh *mesh = paramChart->mesh();
+ Chart *chart = XA_NEW(MemTag::Default, Chart);
+ chart->atlasIndex = -1;
+ chart->material = 0;
+ chart->indexCount = mesh->indexCount();
+ chart->indices = mesh->indices();
+ chart->parametricArea = paramChart->computeParametricArea();
+ if (chart->parametricArea < kAreaEpsilon) {
+ // When the parametric area is too small we use a rough approximation to prevent divisions by very small numbers.
+ const Vector2 bounds = paramChart->computeParametricBounds();
+ chart->parametricArea = bounds.x * bounds.y;
+ }
+ chart->surfaceArea = paramChart->computeSurfaceArea();
+ chart->vertices = mesh->texcoords();
+ chart->vertexCount = mesh->vertexCount();
+ chart->allowRotate = true;
+ // Compute list of boundary vertices.
+ Array<Vector2> boundary;
+ boundary.reserve(16);
+ for (uint32_t v = 0; v < chart->vertexCount; v++) {
+ if (mesh->isBoundaryVertex(v))
+ boundary.push_back(mesh->texcoord(v));
+ }
+ XA_DEBUG_ASSERT(boundary.size() > 0);
+ // Compute bounding box of chart.
+ m_boundingBox.compute(boundary.data(), boundary.size(), mesh->texcoords(), mesh->vertexCount());
+ chart->majorAxis = m_boundingBox.majorAxis();
+ chart->minorAxis = m_boundingBox.minorAxis();
+ chart->minCorner = m_boundingBox.minCorner();
+ chart->maxCorner = m_boundingBox.maxCorner();
+ m_charts.push_back(chart);
+ }
+
+ void addUvMeshCharts(UvMeshInstance *mesh)
+ {
+ BitArray vertexUsed(mesh->texcoords.size());
+ Array<Vector2> boundary;
+ boundary.reserve(16);
+ for (uint32_t c = 0; c < mesh->mesh->charts.size(); c++) {
+ UvMeshChart *uvChart = mesh->mesh->charts[c];
+ Chart *chart = XA_NEW(MemTag::Default, Chart);
+ chart->atlasIndex = -1;
+ chart->material = uvChart->material;
+ chart->indexCount = uvChart->indices.size();
+ chart->indices = uvChart->indices.data();
+ chart->vertices = mesh->texcoords.data();
+ chart->vertexCount = mesh->texcoords.size();
+ chart->allowRotate = mesh->rotateCharts;
+ // Find unique vertices.
+ vertexUsed.clearAll();
+ for (uint32_t i = 0; i < chart->indexCount; i++) {
+ const uint32_t vertex = chart->indices[i];
+ if (!vertexUsed.bitAt(vertex)) {
+ vertexUsed.setBitAt(vertex);
+ chart->uniqueVertices.push_back(vertex);
+ }
+ }
+ // Compute parametric and surface areas.
+ chart->parametricArea = 0.0f;
+ for (uint32_t f = 0; f < chart->indexCount / 3; f++) {
+ const Vector2 &v1 = chart->vertices[chart->indices[f * 3 + 0]];
+ const Vector2 &v2 = chart->vertices[chart->indices[f * 3 + 1]];
+ const Vector2 &v3 = chart->vertices[chart->indices[f * 3 + 2]];
+ chart->parametricArea += fabsf(triangleArea(v1, v2, v3));
+ }
+ chart->parametricArea *= 0.5f;
+ chart->surfaceArea = chart->parametricArea; // Identical for UV meshes.
+ if (chart->parametricArea < kAreaEpsilon) {
+ // When the parametric area is too small we use a rough approximation to prevent divisions by very small numbers.
+ Vector2 minCorner(FLT_MAX, FLT_MAX);
+ Vector2 maxCorner(-FLT_MAX, -FLT_MAX);
+ for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++) {
+ minCorner = min(minCorner, chart->uniqueVertexAt(v));
+ maxCorner = max(maxCorner, chart->uniqueVertexAt(v));
+ }
+ const Vector2 bounds = (maxCorner - minCorner) * 0.5f;
+ chart->parametricArea = bounds.x * bounds.y;
+ }
+ // Compute list of boundary vertices.
+ // Using all unique vertices for simplicity, can compute real boundaries if this is too slow.
+ boundary.clear();
+ for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++)
+ boundary.push_back(chart->uniqueVertexAt(v));
+ XA_DEBUG_ASSERT(boundary.size() > 0);
+ // Compute bounding box of chart.
+ m_boundingBox.compute(boundary.data(), boundary.size(), boundary.data(), boundary.size());
+ chart->majorAxis = m_boundingBox.majorAxis();
+ chart->minorAxis = m_boundingBox.minorAxis();
+ chart->minCorner = m_boundingBox.minCorner();
+ chart->maxCorner = m_boundingBox.maxCorner();
+ m_charts.push_back(chart);
+ }
+ }
// Pack charts in the smallest possible rectangle.
- void packCharts(const PackerOptions &options)
- {
- const uint32_t chartCount = m_atlas->chartCount();
- if (chartCount == 0) return;
- float texelsPerUnit = 1;
- if (options.method == PackMethod::TexelArea)
- texelsPerUnit = options.texelArea;
- for (int iteration = 0;; iteration++) {
- m_rand = MTRand();
- std::vector<float> chartOrderArray(chartCount);
- std::vector<Vector2> chartExtents(chartCount);
+ bool packCharts(const PackOptions &options, ProgressFunc progressFunc, void *progressUserData)
+ {
+ if (progressFunc) {
+ if (!progressFunc(ProgressCategory::PackCharts, 0, progressUserData))
+ return false;
+ }
+ const uint32_t chartCount = m_charts.size();
+ XA_PRINT("Packing %u charts\n", chartCount);
+ if (chartCount == 0) {
+ if (progressFunc) {
+ if (!progressFunc(ProgressCategory::PackCharts, 100, progressUserData))
+ return false;
+ }
+ return true;
+ }
+ uint32_t resolution = options.resolution;
+ m_texelsPerUnit = options.texelsPerUnit;
+ if (resolution <= 0 || m_texelsPerUnit <= 0) {
+ if (resolution <= 0 && m_texelsPerUnit <= 0)
+ resolution = 1024;
float meshArea = 0;
- for (uint32_t c = 0; c < chartCount; c++) {
- Chart *chart = m_atlas->chartAt(c);
- if (!chart->isVertexMapped() && !chart->isDisk()) {
- chartOrderArray[c] = 0;
- // Skip non-disks.
- continue;
- }
- Vector2 extents(0.0f);
- if (chart->isVertexMapped()) {
- // Arrange vertices in a rectangle.
- extents.x = float(chart->vertexMapWidth);
- extents.y = float(chart->vertexMapHeight);
+ for (uint32_t c = 0; c < chartCount; c++)
+ meshArea += m_charts[c]->surfaceArea;
+ if (resolution <= 0) {
+ // Estimate resolution based on the mesh surface area and given texel scale.
+ const float texelCount = max(1.0f, meshArea * square(m_texelsPerUnit) / 0.75f); // Assume 75% utilization.
+ resolution = max(1u, nextPowerOfTwo(uint32_t(sqrtf(texelCount))));
+ }
+ if (m_texelsPerUnit <= 0) {
+ // Estimate a suitable texelsPerUnit to fit the given resolution.
+ const float texelCount = max(1.0f, meshArea / 0.75f); // Assume 75% utilization.
+ m_texelsPerUnit = sqrtf((resolution * resolution) / texelCount);
+ XA_PRINT(" Estimating texelsPerUnit as %g\n", m_texelsPerUnit);
+ }
+ }
+ Array<float> chartOrderArray;
+ chartOrderArray.resize(chartCount);
+ Array<Vector2> chartExtents;
+ chartExtents.resize(chartCount);
+ float minChartPerimeter = FLT_MAX, maxChartPerimeter = 0.0f;
+ for (uint32_t c = 0; c < chartCount; c++) {
+ Chart *chart = m_charts[c];
+ //chartOrderArray[c] = chart.surfaceArea;
+ // Compute chart scale
+ float scale = (chart->surfaceArea / chart->parametricArea) * m_texelsPerUnit;
+ if (chart->parametricArea == 0) { // < kAreaEpsilon)
+ scale = 0;
+ }
+ XA_ASSERT(isFinite(scale));
+ // Sort charts by perimeter. @@ This is sometimes producing somewhat unexpected results. Is this right?
+ //chartOrderArray[c] = ((chart->maxCorner.x - chart->minCorner.x) + (chart->maxCorner.y - chart->minCorner.y)) * scale;
+ // Translate, rotate and scale vertices. Compute extents.
+ Vector2 minCorner(FLT_MAX, FLT_MAX);
+ if (!chart->allowRotate) {
+ for (uint32_t i = 0; i < chart->uniqueVertexCount(); i++)
+ minCorner = min(minCorner, chart->uniqueVertexAt(i));
+ }
+ Vector2 extents(0.0f);
+ for (uint32_t i = 0; i < chart->uniqueVertexCount(); i++) {
+ Vector2 &texcoord = chart->uniqueVertexAt(i);
+ if (chart->allowRotate) {
+ const float x = dot(texcoord, chart->majorAxis);
+ const float y = dot(texcoord, chart->minorAxis);
+ texcoord.x = x;
+ texcoord.y = y;
+ texcoord -= chart->minCorner;
} else {
- // Compute surface area to sort charts.
- float chartArea = chart->computeSurfaceArea();
- meshArea += chartArea;
- //chartOrderArray[c] = chartArea;
- // Compute chart scale
- float parametricArea = fabsf(chart->computeParametricArea()); // @@ There doesn't seem to be anything preventing parametric area to be negative.
- if (parametricArea < NV_EPSILON) {
- // When the parametric area is too small we use a rough approximation to prevent divisions by very small numbers.
- Vector2 bounds = chart->computeParametricBounds();
- parametricArea = bounds.x * bounds.y;
- }
- float scale = (chartArea / parametricArea) * texelsPerUnit;
- if (parametricArea == 0) { // < NV_EPSILON)
- scale = 0;
- }
- xaAssert(std::isfinite(scale));
- // Compute bounding box of chart.
- Vector2 majorAxis, minorAxis, origin, end;
- computeBoundingBox(chart, &majorAxis, &minorAxis, &origin, &end);
- xaAssert(isFinite(majorAxis) && isFinite(minorAxis) && isFinite(origin));
- // Sort charts by perimeter. @@ This is sometimes producing somewhat unexpected results. Is this right?
- //chartOrderArray[c] = ((end.x - origin.x) + (end.y - origin.y)) * scale;
- // Translate, rotate and scale vertices. Compute extents.
- halfedge::Mesh *mesh = chart->chartMesh();
- const uint32_t vertexCount = mesh->vertexCount();
- for (uint32_t i = 0; i < vertexCount; i++) {
- halfedge::Vertex *vertex = mesh->vertexAt(i);
- //Vector2 t = vertex->tex - origin;
- Vector2 tmp;
- tmp.x = dot(vertex->tex, majorAxis);
- tmp.y = dot(vertex->tex, minorAxis);
- tmp -= origin;
- tmp *= scale;
- if (tmp.x < 0 || tmp.y < 0) {
- xaPrint("tmp: %f %f\n", tmp.x, tmp.y);
- xaPrint("scale: %f\n", scale);
- xaPrint("origin: %f %f\n", origin.x, origin.y);
- xaPrint("majorAxis: %f %f\n", majorAxis.x, majorAxis.y);
- xaPrint("minorAxis: %f %f\n", minorAxis.x, minorAxis.y);
- xaDebugAssert(false);
- }
- //xaAssert(tmp.x >= 0 && tmp.y >= 0);
- vertex->tex = tmp;
- xaAssert(std::isfinite(vertex->tex.x) && std::isfinite(vertex->tex.y));
- extents = max(extents, tmp);
- }
- xaDebugAssert(extents.x >= 0 && extents.y >= 0);
- // Limit chart size.
- if (extents.x > 1024 || extents.y > 1024) {
- float limit = std::max(extents.x, extents.y);
- scale = 1024 / (limit + 1);
- for (uint32_t i = 0; i < vertexCount; i++) {
- halfedge::Vertex *vertex = mesh->vertexAt(i);
- vertex->tex *= scale;
- }
- extents *= scale;
- xaDebugAssert(extents.x <= 1024 && extents.y <= 1024);
- }
- // Scale the charts to use the entire texel area available. So, if the width is 0.1 we could scale it to 1 without increasing the lightmap usage and making a better
- // use of it. In many cases this also improves the look of the seams, since vertices on the chart boundaries have more chances of being aligned with the texel centers.
- float scale_x = 1.0f;
- float scale_y = 1.0f;
- float divide_x = 1.0f;
- float divide_y = 1.0f;
- if (extents.x > 0) {
- int cw = ftoi_ceil(extents.x);
- if (options.blockAlign && chart->blockAligned) {
- // Align all chart extents to 4x4 blocks, but taking padding into account.
- if (options.conservative) {
- cw = align(cw + 2, 4) - 2;
- } else {
- cw = align(cw + 1, 4) - 1;
- }
- }
- scale_x = (float(cw) - NV_EPSILON);
- divide_x = extents.x;
- extents.x = float(cw);
- }
- if (extents.y > 0) {
- int ch = ftoi_ceil(extents.y);
- if (options.blockAlign && chart->blockAligned) {
- // Align all chart extents to 4x4 blocks, but taking padding into account.
- if (options.conservative) {
- ch = align(ch + 2, 4) - 2;
- } else {
- ch = align(ch + 1, 4) - 1;
- }
- }
- scale_y = (float(ch) - NV_EPSILON);
- divide_y = extents.y;
- extents.y = float(ch);
- }
- for (uint32_t v = 0; v < vertexCount; v++) {
- halfedge::Vertex *vertex = mesh->vertexAt(v);
- vertex->tex.x /= divide_x;
- vertex->tex.y /= divide_y;
- vertex->tex.x *= scale_x;
- vertex->tex.y *= scale_y;
- xaAssert(std::isfinite(vertex->tex.x) && std::isfinite(vertex->tex.y));
- }
+ texcoord -= minCorner;
+ }
+ texcoord *= scale;
+ XA_DEBUG_ASSERT(texcoord.x >= 0 && texcoord.y >= 0);
+ XA_DEBUG_ASSERT(isFinite(texcoord.x) && isFinite(texcoord.y));
+ extents = max(extents, texcoord);
+ }
+ XA_DEBUG_ASSERT(extents.x >= 0 && extents.y >= 0);
+ // Limit chart size.
+ const float maxChartSize = (float)options.maxChartSize;
+ if (extents.x > maxChartSize || extents.y > maxChartSize) {
+ const float limit = max(extents.x, extents.y);
+ scale = maxChartSize / (limit + 1.0f);
+ for (uint32_t i = 0; i < chart->uniqueVertexCount(); i++)
+ chart->uniqueVertexAt(i) *= scale;
+ extents *= scale;
+ XA_DEBUG_ASSERT(extents.x <= maxChartSize && extents.y <= maxChartSize);
+ }
+ // Scale the charts to use the entire texel area available. So, if the width is 0.1 we could scale it to 1 without increasing the lightmap usage and making a better
+ // use of it. In many cases this also improves the look of the seams, since vertices on the chart boundaries have more chances of being aligned with the texel centers.
+ float scale_x = 1.0f;
+ float scale_y = 1.0f;
+ float divide_x = 1.0f;
+ float divide_y = 1.0f;
+ if (extents.x > 0) {
+ int cw = ftoi_ceil(extents.x);
+ if (options.blockAlign) {
+ // Align all chart extents to 4x4 blocks, but taking padding into account.
+ cw = align(cw + 2, 4) - 2;
+ }
+ scale_x = (float(cw) - kEpsilon);
+ divide_x = extents.x;
+ extents.x = float(cw);
+ }
+ if (extents.y > 0) {
+ int ch = ftoi_ceil(extents.y);
+ if (options.blockAlign) {
+ // Align all chart extents to 4x4 blocks, but taking padding into account.
+ ch = align(ch + 2, 4) - 2;
+ }
+ scale_y = (float(ch) - kEpsilon);
+ divide_y = extents.y;
+ extents.y = float(ch);
+ }
+ for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++) {
+ Vector2 &texcoord = chart->uniqueVertexAt(v);
+ texcoord.x /= divide_x;
+ texcoord.y /= divide_y;
+ texcoord.x *= scale_x;
+ texcoord.y *= scale_y;
+ XA_ASSERT(isFinite(texcoord.x) && isFinite(texcoord.y));
+ }
+ chartExtents[c] = extents;
+ // Sort charts by perimeter.
+ chartOrderArray[c] = extents.x + extents.y;
+ minChartPerimeter = min(minChartPerimeter, chartOrderArray[c]);
+ maxChartPerimeter = max(maxChartPerimeter, chartOrderArray[c]);
+ }
+ // Sort charts by perimeter.
+ m_radix = RadixSort();
+ m_radix.sort(chartOrderArray);
+ const uint32_t *ranks = m_radix.ranks();
+ // Divide chart perimeter range into buckets.
+ const float chartPerimeterBucketSize = (maxChartPerimeter - minChartPerimeter) / 16.0f;
+ uint32_t currentChartBucket = 0;
+ Array<Vector2i> chartStartPositions; // per atlas
+ chartStartPositions.push_back(Vector2i(0, 0));
+ // Pack sorted charts.
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+ const bool createImage = true;
+#else
+ const bool createImage = options.createImage;
+#endif
+ BitImage chartBitImage, chartBitImageRotated;
+ int atlasWidth = 0, atlasHeight = 0;
+ const bool resizableAtlas = !(options.resolution > 0 && options.texelsPerUnit > 0.0f);
+ int progress = 0;
+ for (uint32_t i = 0; i < chartCount; i++) {
+ uint32_t c = ranks[chartCount - i - 1]; // largest chart first
+ Chart *chart = m_charts[c];
+ // @@ Add special cases for dot and line charts. @@ Lightmap rasterizer also needs to handle these special cases.
+ // @@ We could also have a special case for chart quads. If the quad surface <= 4 texels, align vertices with texel centers and do not add padding. May be very useful for foliage.
+ // @@ In general we could reduce the padding of all charts by one texel by using a rasterizer that takes into account the 2-texel footprint of the tent bilinear filter. For example,
+ // if we have a chart that is less than 1 texel wide currently we add one texel to the left and one texel to the right creating a 3-texel-wide bitImage. However, if we know that the
+ // chart is only 1 texel wide we could align it so that it only touches the footprint of two texels:
+ // | | <- Touches texels 0, 1 and 2.
+ // | | <- Only touches texels 0 and 1.
+ // \ \ / \ / /
+ // \ X X /
+ // \ / \ / \ /
+ // V V V
+ // 0 1 2
+ XA_PROFILE_START(packChartsRasterize)
+ // Leave room for padding.
+ chartBitImage.resize(ftoi_ceil(chartExtents[c].x) + 1 + options.padding * 2, ftoi_ceil(chartExtents[c].y) + 1 + options.padding * 2, true);
+ if (chart->allowRotate)
+ chartBitImageRotated.resize(chartBitImage.height(), chartBitImage.width(), true);
+ // Rasterize chart faces.
+ const uint32_t faceCount = chart->indexCount / 3;
+ for (uint32_t f = 0; f < faceCount; f++) {
+ // Offset vertices by padding.
+ Vector2 vertices[3];
+ for (uint32_t v = 0; v < 3; v++)
+ vertices[v] = chart->vertices[chart->indices[f * 3 + v]] + Vector2(0.5f) + Vector2(float(options.padding));
+ DrawTriangleCallbackArgs args;
+ args.chartBitImage = &chartBitImage;
+ args.chartBitImageRotated = chart->allowRotate ? &chartBitImageRotated : nullptr;
+ raster::drawTriangle(Vector2((float)chartBitImage.width(), (float)chartBitImage.height()), vertices, drawTriangleCallback, &args);
+ }
+ // Expand chart by padding pixels. (dilation)
+ BitImage chartBitImageNoPadding(chartBitImage), chartBitImageNoPaddingRotated(chartBitImageRotated);
+ if (options.padding > 0) {
+ XA_PROFILE_START(packChartsDilate)
+ chartBitImage.dilate(options.padding);
+ if (chart->allowRotate)
+ chartBitImageRotated.dilate(options.padding);
+ XA_PROFILE_END(packChartsDilate)
+ }
+ XA_PROFILE_END(packChartsRasterize)
+ // Update brute force bucketing.
+ if (options.bruteForce) {
+ if (chartOrderArray[c] > minChartPerimeter && chartOrderArray[c] <= maxChartPerimeter - (chartPerimeterBucketSize * (currentChartBucket + 1))) {
+ // Moved to a smaller bucket, reset start location.
+ for (uint32_t j = 0; j < chartStartPositions.size(); j++)
+ chartStartPositions[j] = Vector2i(0, 0);
+ currentChartBucket++;
}
- chartExtents[c] = extents;
- // Sort charts by perimeter.
- chartOrderArray[c] = extents.x + extents.y;
- }
- // @@ We can try to improve compression of small charts by sorting them by proximity like we do with vertex samples.
- // @@ How to do that? One idea: compute chart centroid, insert into grid, compute morton index of the cell, sort based on morton index.
- // @@ We would sort by morton index, first, then quantize the chart sizes, so that all small charts have the same size, and sort by size preserving the morton order.
- //xaPrint("Sorting charts.\n");
- // Sort charts by area.
- m_radix = RadixSort();
- m_radix.sort(chartOrderArray);
- const uint32_t *ranks = m_radix.ranks();
- // First iteration - guess texelsPerUnit.
- if (options.method != PackMethod::TexelArea && iteration == 0) {
- // Estimate size of the map based on the mesh surface area and given texel scale.
- const float texelCount = std::max(1.0f, meshArea * square(texelsPerUnit) / 0.75f); // Assume 75% utilization.
- texelsPerUnit = sqrt((options.resolution * options.resolution) / texelCount);
- resetUvs();
- continue;
}
- // Init bit map.
- m_bitmap.clearAll();
- m_bitmap.resize(options.resolution, options.resolution, false);
- int w = 0;
- int h = 0;
- // Add sorted charts to bitmap.
- for (uint32_t i = 0; i < chartCount; i++) {
- uint32_t c = ranks[chartCount - i - 1]; // largest chart first
- Chart *chart = m_atlas->chartAt(c);
- if (!chart->isVertexMapped() && !chart->isDisk()) continue;
- //float scale_x = 1;
- //float scale_y = 1;
- BitMap chart_bitmap;
- if (chart->isVertexMapped()) {
- chart->blockAligned = false;
- // Init all bits to 1.
- chart_bitmap.resize(ftoi_ceil(chartExtents[c].x), ftoi_ceil(chartExtents[c].y), /*initValue=*/true);
- // @@ Another alternative would be to try to map each vertex to a different texel trying to fill all the available unused texels.
- } else {
- // @@ Add special cases for dot and line charts. @@ Lightmap rasterizer also needs to handle these special cases.
- // @@ We could also have a special case for chart quads. If the quad surface <= 4 texels, align vertices with texel centers and do not add padding. May be very useful for foliage.
- // @@ In general we could reduce the padding of all charts by one texel by using a rasterizer that takes into account the 2-texel footprint of the tent bilinear filter. For example,
- // if we have a chart that is less than 1 texel wide currently we add one texel to the left and one texel to the right creating a 3-texel-wide bitmap. However, if we know that the
- // chart is only 1 texel wide we could align it so that it only touches the footprint of two texels:
- // | | <- Touches texels 0, 1 and 2.
- // | | <- Only touches texels 0 and 1.
- // \ \ / \ / /
- // \ X X /
- // \ / \ / \ /
- // V V V
- // 0 1 2
- if (options.conservative) {
- // Init all bits to 0.
- chart_bitmap.resize(ftoi_ceil(chartExtents[c].x) + 1 + options.padding, ftoi_ceil(chartExtents[c].y) + 1 + options.padding, /*initValue=*/false); // + 2 to add padding on both sides.
- // Rasterize chart and dilate.
- drawChartBitmapDilate(chart, &chart_bitmap, options.padding);
- } else {
- // Init all bits to 0.
- chart_bitmap.resize(ftoi_ceil(chartExtents[c].x) + 1, ftoi_ceil(chartExtents[c].y) + 1, /*initValue=*/false); // Add half a texels on each side.
- // Rasterize chart and dilate.
- drawChartBitmap(chart, &chart_bitmap, Vector2(1), Vector2(0.5));
- }
+ // Find a location to place the chart in the atlas.
+ uint32_t currentAtlas = 0;
+ int best_x = 0, best_y = 0;
+ int best_cw = 0, best_ch = 0;
+ int best_r = 0;
+ for (;;)
+ {
+ bool firstChartInBitImage = false;
+ if (currentAtlas + 1 > m_bitImages.size()) {
+ // Chart doesn't fit in the current bitImage, create a new one.
+ BitImage *bi = XA_NEW(MemTag::Default, BitImage);
+ bi->resize(resolution, resolution, true);
+ m_bitImages.push_back(bi);
+ firstChartInBitImage = true;
+ if (createImage)
+ m_atlasImages.push_back(XA_NEW(MemTag::Default, AtlasImage, resolution, resolution));
+ // Start positions are per-atlas, so create a new one of those too.
+ chartStartPositions.push_back(Vector2i(0, 0));
}
- int best_x, best_y;
- int best_cw, best_ch; // Includes padding now.
- int best_r;
- findChartLocation(options.quality, &chart_bitmap, chartExtents[c], w, h, &best_x, &best_y, &best_cw, &best_ch, &best_r, chart->blockAligned);
- /*if (w < best_x + best_cw || h < best_y + best_ch)
- {
- xaPrint("Resize extents to (%d, %d).\n", best_x + best_cw, best_y + best_ch);
- }*/
- // Update parametric extents.
- w = std::max(w, best_x + best_cw);
- h = std::max(h, best_y + best_ch);
- w = align(w, 4);
- h = align(h, 4);
- // Resize bitmap if necessary.
- if (uint32_t(w) > m_bitmap.width() || uint32_t(h) > m_bitmap.height()) {
- //xaPrint("Resize bitmap (%d, %d).\n", nextPowerOfTwo(w), nextPowerOfTwo(h));
- m_bitmap.resize(nextPowerOfTwo(uint32_t(w)), nextPowerOfTwo(uint32_t(h)), false);
+ XA_PROFILE_START(packChartsFindLocation)
+ const bool foundLocation = findChartLocation(chartStartPositions[currentAtlas], options.bruteForce, m_bitImages[currentAtlas], &chartBitImage, &chartBitImageRotated, atlasWidth, atlasHeight, &best_x, &best_y, &best_cw, &best_ch, &best_r, options.blockAlign, resizableAtlas, chart->allowRotate);
+ XA_PROFILE_END(packChartsFindLocation)
+ if (firstChartInBitImage && !foundLocation) {
+ // Chart doesn't fit in an empty, newly allocated bitImage. texelsPerUnit must be too large for the resolution.
+ XA_ASSERT(true && "chart doesn't fit");
+ break;
+ }
+ if (resizableAtlas) {
+ XA_DEBUG_ASSERT(foundLocation);
+ break;
+ }
+ if (foundLocation)
+ break;
+ // Chart doesn't fit in the current bitImage, try the next one.
+ currentAtlas++;
+ }
+ // Update brute force start location.
+ if (options.bruteForce) {
+ // Reset start location if the chart expanded the atlas.
+ if (best_x + best_cw > atlasWidth || best_y + best_ch > atlasHeight) {
+ for (uint32_t j = 0; j < chartStartPositions.size(); j++)
+ chartStartPositions[j] = Vector2i(0, 0);
}
- //xaPrint("Add chart at (%d, %d).\n", best_x, best_y);
- addChart(&chart_bitmap, w, h, best_x, best_y, best_r);
- //float best_angle = 2 * PI * best_r;
- // Translate and rotate chart texture coordinates.
- halfedge::Mesh *mesh = chart->chartMesh();
- const uint32_t vertexCount = mesh->vertexCount();
- for (uint32_t v = 0; v < vertexCount; v++) {
- halfedge::Vertex *vertex = mesh->vertexAt(v);
- Vector2 t = vertex->tex;
- if (best_r) std::swap(t.x, t.y);
- //vertex->tex.x = best_x + t.x * cosf(best_angle) - t.y * sinf(best_angle);
- //vertex->tex.y = best_y + t.x * sinf(best_angle) + t.y * cosf(best_angle);
- vertex->tex.x = best_x + t.x + 0.5f;
- vertex->tex.y = best_y + t.y + 0.5f;
- xaAssert(vertex->tex.x >= 0 && vertex->tex.y >= 0);
- xaAssert(std::isfinite(vertex->tex.x) && std::isfinite(vertex->tex.y));
+ else {
+ chartStartPositions[currentAtlas] = Vector2i(best_x, best_y);
}
}
- //w -= padding - 1; // Leave one pixel border!
- //h -= padding - 1;
- m_width = std::max(0, w);
- m_height = std::max(0, h);
- xaAssert(isAligned(m_width, 4));
- xaAssert(isAligned(m_height, 4));
- if (options.method == PackMethod::ExactResolution) {
- texelsPerUnit *= sqrt((options.resolution * options.resolution) / (float)(m_width * m_height));
- if (iteration > 1 && m_width <= options.resolution && m_height <= options.resolution) {
- m_width = m_height = options.resolution;
- return;
+ // Update parametric extents.
+ atlasWidth = max(atlasWidth, best_x + best_cw);
+ atlasHeight = max(atlasHeight, best_y + best_ch);
+ if (resizableAtlas) {
+ // Resize bitImage if necessary.
+ if (uint32_t(atlasWidth) > m_bitImages[0]->width() || uint32_t(atlasHeight) > m_bitImages[0]->height()) {
+ m_bitImages[0]->resize(nextPowerOfTwo(uint32_t(atlasWidth)), nextPowerOfTwo(uint32_t(atlasHeight)), false);
+ if (createImage)
+ m_atlasImages[0]->resize(m_bitImages[0]->width(), m_bitImages[0]->height());
}
- resetUvs();
} else {
- return;
+ atlasWidth = min((int)options.resolution, atlasWidth);
+ atlasHeight = min((int)options.resolution, atlasHeight);
+ }
+ XA_PROFILE_START(packChartsBlit)
+ addChart(m_bitImages[currentAtlas], &chartBitImage, &chartBitImageRotated, atlasWidth, atlasHeight, best_x, best_y, best_r);
+ XA_PROFILE_END(packChartsBlit)
+ if (createImage) {
+ m_atlasImages[currentAtlas]->addChart(c, best_r == 0 ? &chartBitImageNoPadding : &chartBitImageNoPaddingRotated, false, atlasWidth, atlasHeight, best_x, best_y);
+ m_atlasImages[currentAtlas]->addChart(c, best_r == 0 ? &chartBitImage : &chartBitImageRotated, true, atlasWidth, atlasHeight, best_x, best_y);
+ }
+ chart->atlasIndex = (int32_t)currentAtlas;
+ // Translate and rotate chart texture coordinates.
+ for (uint32_t v = 0; v < chart->uniqueVertexCount(); v++) {
+ Vector2 &texcoord = chart->uniqueVertexAt(v);
+ Vector2 t = texcoord;
+ if (best_r) {
+ XA_DEBUG_ASSERT(chart->allowRotate);
+ swap(t.x, t.y);
+ }
+ texcoord.x = best_x + t.x + 0.5f;
+ texcoord.y = best_y + t.y + 0.5f;
+ XA_ASSERT(texcoord.x >= 0 && texcoord.y >= 0);
+ XA_ASSERT(isFinite(texcoord.x) && isFinite(texcoord.y));
+ }
+ if (progressFunc) {
+ const int newProgress = int((i + 1) / (float)chartCount * 100.0f);
+ if (newProgress != progress) {
+ progress = newProgress;
+ if (!progressFunc(ProgressCategory::PackCharts, progress, progressUserData))
+ return false;
+ }
}
}
- }
-
- float computeAtlasUtilization() const
- {
- const uint32_t w = m_width;
- const uint32_t h = m_height;
- xaDebugAssert(w <= m_bitmap.width());
- xaDebugAssert(h <= m_bitmap.height());
- uint32_t count = 0;
- for (uint32_t y = 0; y < h; y++) {
- for (uint32_t x = 0; x < w; x++) {
- count += m_bitmap.bitAt(x, y);
+ if (resizableAtlas) {
+ m_width = max(0, atlasWidth - (int)options.padding * 2);
+ m_height = max(0, atlasHeight - (int)options.padding * 2);
+ } else {
+ m_width = m_height = options.resolution;
+ }
+ XA_PRINT(" %dx%d resolution\n", m_width, m_height);
+ m_utilization.resize(m_bitImages.size());
+ for (uint32_t i = 0; i < m_utilization.size(); i++) {
+ uint32_t count = 0;
+ for (uint32_t y = 0; y < m_height; y++) {
+ for (uint32_t x = 0; x < m_width; x++)
+ count += m_bitImages[i]->bitAt(x, y);
+ }
+ m_utilization[i] = float(count) / (m_width * m_height);
+ if (m_utilization.size() > 1) {
+ XA_PRINT(" %u: %f%% utilization\n", i, m_utilization[i] * 100.0f);
+ }
+ else {
+ XA_PRINT(" %f%% utilization\n", m_utilization[i] * 100.0f);
}
}
- return float(count) / (w * h);
- }
-
-private:
- void resetUvs()
- {
- for (uint32_t i = 0; i < m_atlas->chartCount(); i++) {
- halfedge::Mesh *mesh = m_atlas->chartAt(i)->chartMesh();
- for (uint32_t j = 0; j < mesh->vertexCount(); j++)
- mesh->vertexAt(j)->tex = m_originalChartUvs[i][j];
+#if XA_DEBUG_EXPORT_ATLAS_IMAGES
+ for (uint32_t i = 0; i < m_atlasImages.size(); i++) {
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_atlas_image%02u.tga", i);
+ m_atlasImages[i]->writeTga(filename, m_width, m_height);
+ }
+#endif
+ if (progressFunc && progress != 100) {
+ if (!progressFunc(ProgressCategory::PackCharts, 100, progressUserData))
+ return false;
}
+ return true;
}
+private:
// IC: Brute force is slow, and random may take too much time to converge. We start inserting large charts in a small atlas. Using brute force is lame, because most of the space
// is occupied at this point. At the end we have many small charts and a large atlas with sparse holes. Finding those holes randomly is slow. A better approach would be to
// start stacking large charts as if they were tetris pieces. Once charts get small try to place them randomly. It may be interesting to try a intermediate strategy, first try
// along one axis and then try exhaustively along that axis.
- void findChartLocation(int quality, const BitMap *bitmap, Vector2::Arg extents, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned)
- {
- int attempts = 256;
- if (quality == 1) attempts = 4096;
- if (quality == 2) attempts = 2048;
- if (quality == 3) attempts = 1024;
- if (quality == 4) attempts = 512;
- if (quality == 0 || w * h < attempts) {
- findChartLocation_bruteForce(bitmap, extents, w, h, best_x, best_y, best_w, best_h, best_r, blockAligned);
- } else {
- findChartLocation_random(bitmap, extents, w, h, best_x, best_y, best_w, best_h, best_r, attempts, blockAligned);
- }
+ bool findChartLocation(const Vector2i &startPosition, bool bruteForce, const BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned, bool resizableAtlas, bool allowRotate)
+ {
+ const int attempts = 4096;
+ if (bruteForce || attempts >= w * h)
+ return findChartLocation_bruteForce(startPosition, atlasBitImage, chartBitImage, chartBitImageRotated, w, h, best_x, best_y, best_w, best_h, best_r, blockAligned, resizableAtlas, allowRotate);
+ return findChartLocation_random(atlasBitImage, chartBitImage, chartBitImageRotated, w, h, best_x, best_y, best_w, best_h, best_r, attempts, blockAligned, resizableAtlas, allowRotate);
}
- void findChartLocation_bruteForce(const BitMap *bitmap, Vector2::Arg /*extents*/, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned)
+ bool findChartLocation_bruteForce(const Vector2i &startPosition, const BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, bool blockAligned, bool resizableAtlas, bool allowRotate)
{
+ bool result = false;
const int BLOCK_SIZE = 4;
int best_metric = INT_MAX;
int step_size = blockAligned ? BLOCK_SIZE : 1;
// Try two different orientations.
for (int r = 0; r < 2; r++) {
- int cw = bitmap->width();
- int ch = bitmap->height();
- if (r & 1) std::swap(cw, ch);
- for (int y = 0; y <= h + 1; y += step_size) { // + 1 to extend atlas in case atlas full.
- for (int x = 0; x <= w + 1; x += step_size) { // + 1 not really necessary here.
+ int cw = chartBitImage->width();
+ int ch = chartBitImage->height();
+ if (r == 1) {
+ if (allowRotate)
+ swap(cw, ch);
+ else
+ break;
+ }
+ for (int y = startPosition.y; y <= h + step_size; y += step_size) { // + 1 to extend atlas in case atlas full.
+ for (int x = (y == startPosition.y ? startPosition.x : 0); x <= w + step_size; x += step_size) { // + 1 not really necessary here.
+ if (!resizableAtlas && (x > (int)atlasBitImage->width() - cw || y > (int)atlasBitImage->height() - ch))
+ continue;
// Early out.
- int area = std::max(w, x + cw) * std::max(h, y + ch);
+ int area = max(w, x + cw) * max(h, y + ch);
//int perimeter = max(w, x+cw) + max(h, y+ch);
- int extents = std::max(std::max(w, x + cw), std::max(h, y + ch));
+ int extents = max(max(w, x + cw), max(h, y + ch));
int metric = extents * extents + area;
if (metric > best_metric) {
continue;
}
- if (metric == best_metric && std::max(x, y) >= std::max(*best_x, *best_y)) {
+ if (metric == best_metric && max(x, y) >= max(*best_x, *best_y)) {
// If metric is the same, pick the one closest to the origin.
continue;
}
- if (canAddChart(bitmap, w, h, x, y, r)) {
+ if (atlasBitImage->canBlit(r == 1 ? *chartBitImageRotated : *chartBitImage, x, y)) {
+ result = true;
best_metric = metric;
*best_x = x;
*best_y = y;
@@ -7107,241 +7238,81 @@ private:
}
}
done:
- xaDebugAssert (best_metric != INT_MAX);
+ XA_DEBUG_ASSERT (best_metric != INT_MAX);
+ return result;
}
- void findChartLocation_random(const BitMap *bitmap, Vector2::Arg /*extents*/, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, int minTrialCount, bool blockAligned)
+ bool findChartLocation_random(const BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int w, int h, int *best_x, int *best_y, int *best_w, int *best_h, int *best_r, int minTrialCount, bool blockAligned, bool resizableAtlas, bool allowRotate)
{
+ bool result = false;
const int BLOCK_SIZE = 4;
int best_metric = INT_MAX;
- for (int i = 0; i < minTrialCount || best_metric == INT_MAX; i++) {
- int r = m_rand.getRange(1);
- int x = m_rand.getRange(w + 1); // + 1 to extend atlas in case atlas full. We may want to use a higher number to increase probability of extending atlas.
- int y = m_rand.getRange(h + 1); // + 1 to extend atlas in case atlas full.
+ for (int i = 0; i < minTrialCount; i++) {
+ int cw = chartBitImage->width();
+ int ch = chartBitImage->height();
+ int r = allowRotate ? m_rand.getRange(1) : 0;
+ if (r == 1)
+ swap(cw, ch);
+ // + 1 to extend atlas in case atlas full. We may want to use a higher number to increase probability of extending atlas.
+ int xRange = w + 1;
+ int yRange = h + 1;
+ if (!resizableAtlas) {
+ xRange = min(xRange, (int)atlasBitImage->width() - cw);
+ yRange = min(yRange, (int)atlasBitImage->height() - ch);
+ }
+ int x = m_rand.getRange(xRange);
+ int y = m_rand.getRange(yRange);
if (blockAligned) {
x = align(x, BLOCK_SIZE);
y = align(y, BLOCK_SIZE);
+ if (!resizableAtlas && (x > (int)atlasBitImage->width() - cw || y > (int)atlasBitImage->height() - ch))
+ continue; // Block alignment pushed the chart outside the atlas.
}
- int cw = bitmap->width();
- int ch = bitmap->height();
- if (r & 1) std::swap(cw, ch);
// Early out.
- int area = std::max(w, x + cw) * std::max(h, y + ch);
+ int area = max(w, x + cw) * max(h, y + ch);
//int perimeter = max(w, x+cw) + max(h, y+ch);
- int extents = std::max(std::max(w, x + cw), std::max(h, y + ch));
+ int extents = max(max(w, x + cw), max(h, y + ch));
int metric = extents * extents + area;
if (metric > best_metric) {
continue;
}
- if (metric == best_metric && std::min(x, y) > std::min(*best_x, *best_y)) {
+ if (metric == best_metric && min(x, y) > min(*best_x, *best_y)) {
// If metric is the same, pick the one closest to the origin.
continue;
}
- if (canAddChart(bitmap, w, h, x, y, r)) {
+ if (atlasBitImage->canBlit(r == 1 ? *chartBitImageRotated : *chartBitImage, x, y)) {
+ result = true;
best_metric = metric;
*best_x = x;
*best_y = y;
*best_w = cw;
*best_h = ch;
- *best_r = r;
+ *best_r = allowRotate ? r : 0;
if (area == w * h) {
// Chart is completely inside, do not look at any other location.
break;
}
}
}
+ return result;
}
- void drawChartBitmapDilate(const Chart *chart, BitMap *bitmap, int padding)
- {
- const int w = bitmap->width();
- const int h = bitmap->height();
- const Vector2 extents = Vector2(float(w), float(h));
- // Rasterize chart faces, check that all bits are not set.
- const uint32_t faceCount = chart->faceCount();
- for (uint32_t f = 0; f < faceCount; f++) {
- const halfedge::Face *face = chart->chartMesh()->faceAt(f);
- Vector2 vertices[4];
- uint32_t edgeCount = 0;
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- if (edgeCount < 4) {
- vertices[edgeCount] = it.vertex()->tex + Vector2(0.5) + Vector2(float(padding), float(padding));
- }
- edgeCount++;
- }
- if (edgeCount == 3) {
- raster::drawTriangle(raster::Mode_Antialiased, extents, true, vertices, AtlasPacker::setBitsCallback, bitmap);
- } else {
- raster::drawQuad(raster::Mode_Antialiased, extents, true, vertices, AtlasPacker::setBitsCallback, bitmap);
- }
- }
- // Expand chart by padding pixels. (dilation)
- BitMap tmp(w, h);
- for (int i = 0; i < padding; i++) {
- tmp.clearAll();
- for (int y = 0; y < h; y++) {
- for (int x = 0; x < w; x++) {
- bool b = bitmap->bitAt(x, y);
- if (!b) {
- if (x > 0) {
- b |= bitmap->bitAt(x - 1, y);
- if (y > 0) b |= bitmap->bitAt(x - 1, y - 1);
- if (y < h - 1) b |= bitmap->bitAt(x - 1, y + 1);
- }
- if (y > 0) b |= bitmap->bitAt(x, y - 1);
- if (y < h - 1) b |= bitmap->bitAt(x, y + 1);
- if (x < w - 1) {
- b |= bitmap->bitAt(x + 1, y);
- if (y > 0) b |= bitmap->bitAt(x + 1, y - 1);
- if (y < h - 1) b |= bitmap->bitAt(x + 1, y + 1);
- }
- }
- if (b) tmp.setBitAt(x, y);
- }
- }
- std::swap(tmp, *bitmap);
- }
- }
-
- void drawChartBitmap(const Chart *chart, BitMap *bitmap, const Vector2 &scale, const Vector2 &offset)
+ void addChart(BitImage *atlasBitImage, const BitImage *chartBitImage, const BitImage *chartBitImageRotated, int atlas_w, int atlas_h, int offset_x, int offset_y, int r)
{
- const int w = bitmap->width();
- const int h = bitmap->height();
- const Vector2 extents = Vector2(float(w), float(h));
- static const Vector2 pad[4] = {
- Vector2(-0.5, -0.5),
- Vector2(0.5, -0.5),
- Vector2(-0.5, 0.5),
- Vector2(0.5, 0.5)
- };
- // Rasterize 4 times to add proper padding.
- for (int i = 0; i < 4; i++) {
- // Rasterize chart faces, check that all bits are not set.
- const uint32_t faceCount = chart->chartMesh()->faceCount();
- for (uint32_t f = 0; f < faceCount; f++) {
- const halfedge::Face *face = chart->chartMesh()->faceAt(f);
- Vector2 vertices[4];
- uint32_t edgeCount = 0;
- for (halfedge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
- if (edgeCount < 4) {
- vertices[edgeCount] = it.vertex()->tex * scale + offset + pad[i];
- xaAssert(ftoi_ceil(vertices[edgeCount].x) >= 0);
- xaAssert(ftoi_ceil(vertices[edgeCount].y) >= 0);
- xaAssert(ftoi_ceil(vertices[edgeCount].x) <= w);
- xaAssert(ftoi_ceil(vertices[edgeCount].y) <= h);
- }
- edgeCount++;
- }
- if (edgeCount == 3) {
- raster::drawTriangle(raster::Mode_Antialiased, extents, /*enableScissors=*/true, vertices, AtlasPacker::setBitsCallback, bitmap);
- } else {
- raster::drawQuad(raster::Mode_Antialiased, extents, /*enableScissors=*/true, vertices, AtlasPacker::setBitsCallback, bitmap);
- }
- }
- }
- // Expand chart by padding pixels. (dilation)
- BitMap tmp(w, h);
- tmp.clearAll();
+ XA_DEBUG_ASSERT(r == 0 || r == 1);
+ const BitImage *image = r == 0 ? chartBitImage : chartBitImageRotated;
+ const int w = image->width();
+ const int h = image->height();
for (int y = 0; y < h; y++) {
- for (int x = 0; x < w; x++) {
- bool b = bitmap->bitAt(x, y);
- if (!b) {
- if (x > 0) {
- b |= bitmap->bitAt(x - 1, y);
- if (y > 0) b |= bitmap->bitAt(x - 1, y - 1);
- if (y < h - 1) b |= bitmap->bitAt(x - 1, y + 1);
- }
- if (y > 0) b |= bitmap->bitAt(x, y - 1);
- if (y < h - 1) b |= bitmap->bitAt(x, y + 1);
- if (x < w - 1) {
- b |= bitmap->bitAt(x + 1, y);
- if (y > 0) b |= bitmap->bitAt(x + 1, y - 1);
- if (y < h - 1) b |= bitmap->bitAt(x + 1, y + 1);
- }
- }
- if (b) tmp.setBitAt(x, y);
- }
- }
- std::swap(tmp, *bitmap);
- }
-
- bool canAddChart(const BitMap *bitmap, int atlas_w, int atlas_h, int offset_x, int offset_y, int r)
- {
- xaDebugAssert(r == 0 || r == 1);
- // Check whether the two bitmaps overlap.
- const int w = bitmap->width();
- const int h = bitmap->height();
- if (r == 0) {
- for (int y = 0; y < h; y++) {
- int yy = y + offset_y;
- if (yy >= 0) {
- for (int x = 0; x < w; x++) {
- int xx = x + offset_x;
- if (xx >= 0) {
- if (bitmap->bitAt(x, y)) {
- if (xx < atlas_w && yy < atlas_h) {
- if (m_bitmap.bitAt(xx, yy)) return false;
- }
- }
- }
- }
- }
- }
- } else if (r == 1) {
- for (int y = 0; y < h; y++) {
- int xx = y + offset_x;
- if (xx >= 0) {
- for (int x = 0; x < w; x++) {
- int yy = x + offset_y;
- if (yy >= 0) {
- if (bitmap->bitAt(x, y)) {
- if (xx < atlas_w && yy < atlas_h) {
- if (m_bitmap.bitAt(xx, yy)) return false;
- }
- }
- }
- }
- }
- }
- }
- return true;
- }
-
- void addChart(const BitMap *bitmap, int atlas_w, int atlas_h, int offset_x, int offset_y, int r)
- {
- xaDebugAssert(r == 0 || r == 1);
- // Check whether the two bitmaps overlap.
- const int w = bitmap->width();
- const int h = bitmap->height();
- if (r == 0) {
- for (int y = 0; y < h; y++) {
- int yy = y + offset_y;
- if (yy >= 0) {
- for (int x = 0; x < w; x++) {
- int xx = x + offset_x;
- if (xx >= 0) {
- if (bitmap->bitAt(x, y)) {
- if (xx < atlas_w && yy < atlas_h) {
- xaDebugAssert(m_bitmap.bitAt(xx, yy) == false);
- m_bitmap.setBitAt(xx, yy);
- }
- }
- }
- }
- }
- }
- } else if (r == 1) {
- for (int y = 0; y < h; y++) {
- int xx = y + offset_x;
- if (xx >= 0) {
- for (int x = 0; x < w; x++) {
- int yy = x + offset_y;
- if (yy >= 0) {
- if (bitmap->bitAt(x, y)) {
- if (xx < atlas_w && yy < atlas_h) {
- xaDebugAssert(m_bitmap.bitAt(xx, yy) == false);
- m_bitmap.setBitAt(xx, yy);
- }
+ int yy = y + offset_y;
+ if (yy >= 0) {
+ for (int x = 0; x < w; x++) {
+ int xx = x + offset_x;
+ if (xx >= 0) {
+ if (image->bitAt(x, y)) {
+ if (xx < atlas_w && yy < atlas_h) {
+ XA_DEBUG_ASSERT(atlasBitImage->bitAt(xx, yy) == false);
+ atlasBitImage->setBitAt(xx, yy);
}
}
}
@@ -7350,458 +7321,992 @@ private:
}
}
- static bool setBitsCallback(void *param, int x, int y, Vector3::Arg, Vector3::Arg, Vector3::Arg, float area)
+ struct DrawTriangleCallbackArgs
{
- BitMap *bitmap = (BitMap * )param;
- if (area > 0.0) {
- bitmap->setBitAt(x, y);
- }
- return true;
- }
+ BitImage *chartBitImage;
+ BitImage *chartBitImageRotated;
+ };
- // Compute the convex hull using Graham Scan.
- static void convexHull(const std::vector<Vector2> &input, std::vector<Vector2> &output, float epsilon)
+ static bool drawTriangleCallback(void *param, int x, int y)
{
- const uint32_t inputCount = input.size();
- std::vector<float> coords(inputCount);
- for (uint32_t i = 0; i < inputCount; i++) {
- coords[i] = input[i].x;
- }
- RadixSort radix;
- radix.sort(coords);
- const uint32_t *ranks = radix.ranks();
- std::vector<Vector2> top;
- top.reserve(inputCount);
- std::vector<Vector2> bottom;
- bottom.reserve(inputCount);
- Vector2 P = input[ranks[0]];
- Vector2 Q = input[ranks[inputCount - 1]];
- float topy = std::max(P.y, Q.y);
- float boty = std::min(P.y, Q.y);
- for (uint32_t i = 0; i < inputCount; i++) {
- Vector2 p = input[ranks[i]];
- if (p.y >= boty) top.push_back(p);
- }
- for (uint32_t i = 0; i < inputCount; i++) {
- Vector2 p = input[ranks[inputCount - 1 - i]];
- if (p.y <= topy) bottom.push_back(p);
- }
- // Filter top list.
- output.clear();
- output.push_back(top[0]);
- output.push_back(top[1]);
- for (uint32_t i = 2; i < top.size(); ) {
- Vector2 a = output[output.size() - 2];
- Vector2 b = output[output.size() - 1];
- Vector2 c = top[i];
- float area = triangleArea(a, b, c);
- if (area >= -epsilon) {
- output.pop_back();
- }
- if (area < -epsilon || output.size() == 1) {
- output.push_back(c);
- i++;
- }
- }
- uint32_t top_count = output.size();
- output.push_back(bottom[1]);
- // Filter bottom list.
- for (uint32_t i = 2; i < bottom.size(); ) {
- Vector2 a = output[output.size() - 2];
- Vector2 b = output[output.size() - 1];
- Vector2 c = bottom[i];
- float area = triangleArea(a, b, c);
- if (area >= -epsilon) {
- output.pop_back();
- }
- if (area < -epsilon || output.size() == top_count) {
- output.push_back(c);
- i++;
- }
- }
- // Remove duplicate element.
- xaDebugAssert(output.front() == output.back());
- output.pop_back();
+ auto args = (DrawTriangleCallbackArgs *)param;
+ args->chartBitImage->setBitAt(x, y);
+ if (args->chartBitImageRotated)
+ args->chartBitImageRotated->setBitAt(y, x);
+ return true;
}
- // This should compute convex hull and use rotating calipers to find the best box. Currently it uses a brute force method.
- static void computeBoundingBox(Chart *chart, Vector2 *majorAxis, Vector2 *minorAxis, Vector2 *minCorner, Vector2 *maxCorner)
- {
- // Compute list of boundary points.
- std::vector<Vector2> points;
- points.reserve(16);
- halfedge::Mesh *mesh = chart->chartMesh();
- const uint32_t vertexCount = mesh->vertexCount();
- for (uint32_t i = 0; i < vertexCount; i++) {
- halfedge::Vertex *vertex = mesh->vertexAt(i);
- if (vertex->isBoundary()) {
- points.push_back(vertex->tex);
- }
- }
- xaDebugAssert(points.size() > 0);
- std::vector<Vector2> hull;
- convexHull(points, hull, 0.00001f);
- // @@ Ideally I should use rotating calipers to find the best box. Using brute force for now.
- float best_area = FLT_MAX;
- Vector2 best_min;
- Vector2 best_max;
- Vector2 best_axis;
- const uint32_t hullCount = hull.size();
- for (uint32_t i = 0, j = hullCount - 1; i < hullCount; j = i, i++) {
- if (equal(hull[i], hull[j])) {
- continue;
- }
- Vector2 axis = normalize(hull[i] - hull[j], 0.0f);
- xaDebugAssert(isFinite(axis));
- // Compute bounding box.
- Vector2 box_min(FLT_MAX, FLT_MAX);
- Vector2 box_max(-FLT_MAX, -FLT_MAX);
- for (uint32_t v = 0; v < hullCount; v++) {
- Vector2 point = hull[v];
- float x = dot(axis, point);
- if (x < box_min.x) box_min.x = x;
- if (x > box_max.x) box_max.x = x;
- float y = dot(Vector2(-axis.y, axis.x), point);
- if (y < box_min.y) box_min.y = y;
- if (y > box_max.y) box_max.y = y;
- }
- // Compute box area.
- float area = (box_max.x - box_min.x) * (box_max.y - box_min.y);
- if (area < best_area) {
- best_area = area;
- best_min = box_min;
- best_max = box_max;
- best_axis = axis;
- }
- }
- // Consider all points, not only boundary points, in case the input chart is malformed.
- for (uint32_t i = 0; i < vertexCount; i++) {
- halfedge::Vertex *vertex = mesh->vertexAt(i);
- Vector2 point = vertex->tex;
- float x = dot(best_axis, point);
- if (x < best_min.x) best_min.x = x;
- if (x > best_max.x) best_max.x = x;
- float y = dot(Vector2(-best_axis.y, best_axis.x), point);
- if (y < best_min.y) best_min.y = y;
- if (y > best_max.y) best_max.y = y;
- }
- *majorAxis = best_axis;
- *minorAxis = Vector2(-best_axis.y, best_axis.x);
- *minCorner = best_min;
- *maxCorner = best_max;
- }
-
- Atlas *m_atlas;
- BitMap m_bitmap;
+ Array<AtlasImage *> m_atlasImages;
+ Array<float> m_utilization;
+ Array<BitImage *> m_bitImages;
+ BoundingBox2D m_boundingBox;
+ Array<Chart *> m_charts;
RadixSort m_radix;
- uint32_t m_width;
- uint32_t m_height;
- MTRand m_rand;
- std::vector<std::vector<Vector2> > m_originalChartUvs;
+ uint32_t m_width = 0;
+ uint32_t m_height = 0;
+ float m_texelsPerUnit = 0.0f;
+ KISSRng m_rand;
};
-} // namespace param
+} // namespace pack
} // namespace internal
-struct Atlas
-{
- internal::param::Atlas atlas;
- std::vector<internal::halfedge::Mesh *> heMeshes;
- uint32_t width = 0;
- uint32_t height = 0;
- OutputMesh **outputMeshes = NULL;
+struct Context
+{
+ Atlas atlas;
+ uint32_t meshCount = 0;
+ internal::Progress *addMeshProgress = nullptr;
+ internal::TaskGroupHandle addMeshTaskGroup;
+ internal::param::Atlas paramAtlas;
+ ProgressFunc progressFunc = nullptr;
+ void *progressUserData = nullptr;
+ internal::TaskScheduler *taskScheduler;
+ internal::Array<internal::UvMesh *> uvMeshes;
+ internal::Array<internal::UvMeshInstance *> uvMeshInstances;
};
-void SetPrint(PrintFunc print)
+Atlas *Create()
{
- internal::s_print = print;
+ Context *ctx = XA_NEW(internal::MemTag::Default, Context);
+ memset(&ctx->atlas, 0, sizeof(Atlas));
+ ctx->taskScheduler = XA_NEW(internal::MemTag::Default, internal::TaskScheduler);
+ return &ctx->atlas;
}
-Atlas *Create()
-{
- Atlas *atlas = new Atlas();
- return atlas;
+static void DestroyOutputMeshes(Context *ctx)
+{
+ if (!ctx->atlas.meshes)
+ return;
+ for (int i = 0; i < (int)ctx->atlas.meshCount; i++) {
+ Mesh &mesh = ctx->atlas.meshes[i];
+ for (uint32_t j = 0; j < mesh.chartCount; j++) {
+ if (mesh.chartArray[j].indexArray)
+ XA_FREE(mesh.chartArray[j].indexArray);
+ }
+ if (mesh.chartArray)
+ XA_FREE(mesh.chartArray);
+ if (mesh.vertexArray)
+ XA_FREE(mesh.vertexArray);
+ if (mesh.indexArray)
+ XA_FREE(mesh.indexArray);
+ }
+ if (ctx->atlas.meshes)
+ XA_FREE(ctx->atlas.meshes);
+ ctx->atlas.meshes = nullptr;
}
void Destroy(Atlas *atlas)
{
- xaAssert(atlas);
- for (int i = 0; i < (int)atlas->heMeshes.size(); i++) {
- delete atlas->heMeshes[i];
- if (atlas->outputMeshes) {
- OutputMesh *outputMesh = atlas->outputMeshes[i];
- for (uint32_t j = 0; j < outputMesh->chartCount; j++)
- delete [] outputMesh->chartArray[j].indexArray;
- delete [] outputMesh->chartArray;
- delete [] outputMesh->vertexArray;
- delete [] outputMesh->indexArray;
- delete outputMesh;
- }
- }
- delete [] atlas->outputMeshes;
- delete atlas;
+ XA_DEBUG_ASSERT(atlas);
+ Context *ctx = (Context *)atlas;
+ if (atlas->utilization)
+ XA_FREE(atlas->utilization);
+ if (atlas->image)
+ XA_FREE(atlas->image);
+ DestroyOutputMeshes(ctx);
+ if (ctx->addMeshProgress) {
+ ctx->addMeshProgress->cancel = true;
+ AddMeshJoin(atlas); // frees addMeshProgress
+ }
+ ctx->taskScheduler->~TaskScheduler();
+ XA_FREE(ctx->taskScheduler);
+ for (uint32_t i = 0; i < ctx->uvMeshes.size(); i++) {
+ internal::UvMesh *mesh = ctx->uvMeshes[i];
+ for (uint32_t j = 0; j < mesh->charts.size(); j++) {
+ mesh->charts[j]->~UvMeshChart();
+ XA_FREE(mesh->charts[j]);
+ }
+ mesh->~UvMesh();
+ XA_FREE(mesh);
+ }
+ for (uint32_t i = 0; i < ctx->uvMeshInstances.size(); i++) {
+ internal::UvMeshInstance *mesh = ctx->uvMeshInstances[i];
+ mesh->~UvMeshInstance();
+ XA_FREE(mesh);
+ }
+ ctx->~Context();
+ XA_FREE(ctx);
+#if XA_DEBUG_HEAP
+ internal::ReportLeaks();
+#endif
}
-static internal::Vector3 DecodePosition(const InputMesh &mesh, uint32_t index)
+struct AddMeshTaskArgs
{
- xaAssert(mesh.vertexPositionData);
- return *((const internal::Vector3 *)&((const uint8_t *)mesh.vertexPositionData)[mesh.vertexPositionStride * index]);
+ Context *ctx;
+ internal::Mesh *mesh;
+};
+
+static void runAddMeshTask(void *userData)
+{
+ XA_PROFILE_START(addMesh)
+ auto args = (AddMeshTaskArgs *)userData; // Responsible for freeing this.
+ internal::Mesh *mesh = args->mesh;
+ internal::Progress *progress = args->ctx->addMeshProgress;
+ if (progress->cancel)
+ goto cleanup;
+ XA_PROFILE_START(addMeshCreateColocals)
+ mesh->createColocals();
+ XA_PROFILE_END(addMeshCreateColocals)
+ if (progress->cancel)
+ goto cleanup;
+ XA_PROFILE_START(addMeshCreateFaceGroups)
+ mesh->createFaceGroups();
+ XA_PROFILE_END(addMeshCreateFaceGroups)
+ if (progress->cancel)
+ goto cleanup;
+ XA_PROFILE_START(addMeshCreateBoundaries)
+ mesh->createBoundaries();
+ XA_PROFILE_END(addMeshCreateBoundaries)
+ if (progress->cancel)
+ goto cleanup;
+#if XA_DEBUG_EXPORT_OBJ_SOURCE_MESHES
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_mesh_%03u.obj", mesh->id());
+ FILE *file;
+ XA_FOPEN(file, filename, "w");
+ if (file) {
+ mesh->writeObjVertices(file);
+ // groups
+ uint32_t numGroups = 0;
+ for (uint32_t i = 0; i < mesh->faceGroupCount(); i++) {
+ if (mesh->faceGroupAt(i) != UINT32_MAX)
+ numGroups = internal::max(numGroups, mesh->faceGroupAt(i) + 1);
+ }
+ for (uint32_t i = 0; i < numGroups; i++) {
+ fprintf(file, "o group_%04d\n", i);
+ fprintf(file, "s off\n");
+ for (uint32_t f = 0; f < mesh->faceGroupCount(); f++) {
+ if (mesh->faceGroupAt(f) == i)
+ mesh->writeObjFace(file, f);
+ }
+ }
+ fprintf(file, "o group_ignored\n");
+ fprintf(file, "s off\n");
+ for (uint32_t f = 0; f < mesh->faceGroupCount(); f++) {
+ if (mesh->faceGroupAt(f) == UINT32_MAX)
+ mesh->writeObjFace(file, f);
+ }
+ mesh->writeObjBoundaryEges(file);
+ fclose(file);
+ }
+#endif
+ XA_PROFILE_START(addMeshCreateChartGroupsConcurrent)
+ args->ctx->paramAtlas.addMesh(args->ctx->taskScheduler, mesh); // addMesh is thread safe
+ XA_PROFILE_END(addMeshCreateChartGroupsConcurrent)
+ if (progress->cancel)
+ goto cleanup;
+ progress->value++;
+ progress->update();
+cleanup:
+ mesh->~Mesh();
+ XA_FREE(mesh);
+ args->~AddMeshTaskArgs();
+ XA_FREE(args);
+ XA_PROFILE_END(addMesh)
}
-static internal::Vector3 DecodeNormal(const InputMesh &mesh, uint32_t index)
+static internal::Vector3 DecodePosition(const MeshDecl &meshDecl, uint32_t index)
{
- xaAssert(mesh.vertexNormalData);
- return *((const internal::Vector3 *)&((const uint8_t *)mesh.vertexNormalData)[mesh.vertexNormalStride * index]);
+ XA_DEBUG_ASSERT(meshDecl.vertexPositionData);
+ XA_DEBUG_ASSERT(meshDecl.vertexPositionStride > 0);
+ return *((const internal::Vector3 *)&((const uint8_t *)meshDecl.vertexPositionData)[meshDecl.vertexPositionStride * index]);
}
-static internal::Vector2 DecodeUv(const InputMesh &mesh, uint32_t index)
+static internal::Vector3 DecodeNormal(const MeshDecl &meshDecl, uint32_t index)
{
- xaAssert(mesh.vertexUvData);
- return *((const internal::Vector2 *)&((const uint8_t *)mesh.vertexUvData)[mesh.vertexUvStride * index]);
+ XA_DEBUG_ASSERT(meshDecl.vertexNormalData);
+ XA_DEBUG_ASSERT(meshDecl.vertexNormalStride > 0);
+ return *((const internal::Vector3 *)&((const uint8_t *)meshDecl.vertexNormalData)[meshDecl.vertexNormalStride * index]);
}
-static uint32_t DecodeIndex(IndexFormat::Enum format, const void *indexData, uint32_t i)
+static internal::Vector2 DecodeUv(const MeshDecl &meshDecl, uint32_t index)
{
- if (format == IndexFormat::HalfFloat)
- return (uint32_t)((const uint16_t *)indexData)[i];
- return ((const uint32_t *)indexData)[i];
+ XA_DEBUG_ASSERT(meshDecl.vertexUvData);
+ XA_DEBUG_ASSERT(meshDecl.vertexUvStride > 0);
+ return *((const internal::Vector2 *)&((const uint8_t *)meshDecl.vertexUvData)[meshDecl.vertexUvStride * index]);
}
-static float EdgeLength(internal::Vector3 pos1, internal::Vector3 pos2)
+static uint32_t DecodeIndex(IndexFormat::Enum format, const void *indexData, int32_t offset, uint32_t i)
{
- return internal::length(pos2 - pos1);
+ XA_DEBUG_ASSERT(indexData);
+ if (format == IndexFormat::UInt16)
+ return uint16_t((int32_t)((const uint16_t *)indexData)[i] + offset);
+ return uint32_t((int32_t)((const uint32_t *)indexData)[i] + offset);
}
-AddMeshError AddMesh(Atlas *atlas, const InputMesh &mesh, bool useColocalVertices)
+AddMeshError::Enum AddMesh(Atlas *atlas, const MeshDecl &meshDecl, uint32_t meshCountHint)
{
- xaAssert(atlas);
- AddMeshError error;
- error.code = AddMeshErrorCode::Success;
- error.face = error.index0 = error.index1 = UINT32_MAX;
- // Expecting triangle faces.
- if ((mesh.indexCount % 3) != 0)
- {
- error.code = AddMeshErrorCode::InvalidIndexCount;
- return error;
- }
- // Check if any index is out of range.
- for (uint32_t j = 0; j < mesh.indexCount; j++) {
- const uint32_t index = DecodeIndex(mesh.indexFormat, mesh.indexData, j);
- if (index < 0 || index >= mesh.vertexCount) {
- error.code = AddMeshErrorCode::IndexOutOfRange;
- error.index0 = index;
- return error;
- }
- }
- // Build half edge mesh.
- internal::halfedge::Mesh *heMesh = new internal::halfedge::Mesh;
- std::vector<uint32_t> canonicalMap;
- canonicalMap.reserve(mesh.vertexCount);
- for (uint32_t i = 0; i < mesh.vertexCount; i++) {
- internal::halfedge::Vertex *vertex = heMesh->addVertex(DecodePosition(mesh, i));
- if (mesh.vertexNormalData)
- vertex->nor = DecodeNormal(mesh, i);
- if (mesh.vertexUvData)
- vertex->tex = DecodeUv(mesh, i);
- // Link colocals. You probably want to do this more efficiently! Sort by one axis or use a hash or grid.
- uint32_t firstColocal = i;
- if (useColocalVertices) {
- for (uint32_t j = 0; j < i; j++) {
- if (vertex->pos != DecodePosition(mesh, j))
- continue;
-#if 0
- if (mesh.vertexNormalData && vertex->nor != DecodeNormal(mesh, j))
- continue;
+ XA_DEBUG_ASSERT(atlas);
+ if (!atlas) {
+ XA_PRINT_WARNING("AddMesh: atlas is null.\n");
+ return AddMeshError::Error;
+ }
+ Context *ctx = (Context *)atlas;
+ if (!ctx->uvMeshes.isEmpty()) {
+ XA_PRINT_WARNING("AddMesh: Meshes and UV meshes cannot be added to the same atlas.\n");
+ return AddMeshError::Error;
+ }
+ // Don't know how many times AddMesh will be called, so progress needs to adjusted each time.
+ if (!ctx->addMeshProgress) {
+ ctx->addMeshProgress = XA_NEW(internal::MemTag::Default, internal::Progress, ProgressCategory::AddMesh, ctx->progressFunc, ctx->progressUserData, 1);
+#if XA_PROFILE
+ internal::s_profile.addMeshConcurrent = clock();
#endif
- if (mesh.vertexUvData && vertex->tex != DecodeUv(mesh, j))
- continue;
- firstColocal = j;
- break;
- }
- }
- canonicalMap.push_back(firstColocal);
}
- heMesh->linkColocalsWithCanonicalMap(canonicalMap);
- for (uint32_t i = 0; i < mesh.indexCount / 3; i++) {
+ else {
+ ctx->addMeshProgress->setMaxValue(internal::max(ctx->meshCount + 1, meshCountHint));
+ }
+ bool decoded = (meshDecl.indexCount <= 0);
+ uint32_t indexCount = decoded ? meshDecl.vertexCount : meshDecl.indexCount;
+ XA_PRINT("Adding mesh %d: %u vertices, %u triangles\n", ctx->meshCount, meshDecl.vertexCount, indexCount / 3);
+ XA_PROFILE_START(addMesh)
+ // Expecting triangle faces.
+ if ((indexCount % 3) != 0)
+ return AddMeshError::InvalidIndexCount;
+ if (!decoded) {
+ // Check if any index is out of range.
+ for (uint32_t i = 0; i < indexCount; i++) {
+ const uint32_t index = DecodeIndex(meshDecl.indexFormat, meshDecl.indexData, meshDecl.indexOffset, i);
+ if (index >= meshDecl.vertexCount)
+ return AddMeshError::IndexOutOfRange;
+ }
+ }
+ uint32_t meshFlags = internal::MeshFlags::HasFaceGroups | internal::MeshFlags::HasIgnoredFaces;
+ if (meshDecl.vertexNormalData)
+ meshFlags |= internal::MeshFlags::HasNormals;
+ internal::Mesh *mesh = XA_NEW(internal::MemTag::Mesh, internal::Mesh, meshDecl.epsilon, meshDecl.vertexCount, indexCount / 3, meshFlags, ctx->meshCount);
+ for (uint32_t i = 0; i < meshDecl.vertexCount; i++) {
+ internal::Vector3 normal(0.0f);
+ internal::Vector2 texcoord(0.0f);
+ if (meshDecl.vertexNormalData)
+ normal = DecodeNormal(meshDecl, i);
+ if (meshDecl.vertexUvData)
+ texcoord = DecodeUv(meshDecl, i);
+ mesh->addVertex(DecodePosition(meshDecl, i), normal, texcoord);
+ }
+ for (uint32_t i = 0; i < indexCount / 3; i++) {
uint32_t tri[3];
for (int j = 0; j < 3; j++)
- tri[j] = DecodeIndex(mesh.indexFormat, mesh.indexData, i * 3 + j);
- // Check for zero length edges.
+ tri[j] = decoded ? i * 3 + j : DecodeIndex(meshDecl.indexFormat, meshDecl.indexData, meshDecl.indexOffset, i * 3 + j);
+ bool ignore = false;
+ // Check for degenerate or zero length edges.
for (int j = 0; j < 3; j++) {
- const uint32_t edges[6] = { 0, 1, 1, 2, 2, 0 };
- const uint32_t index1 = tri[edges[j * 2 + 0]];
- const uint32_t index2 = tri[edges[j * 2 + 1]];
- const internal::Vector3 pos1 = DecodePosition(mesh, index1);
- const internal::Vector3 pos2 = DecodePosition(mesh, index2);
- if (EdgeLength(pos1, pos2) <= 0.0f) {
- delete heMesh;
- error.code = AddMeshErrorCode::ZeroLengthEdge;
- error.face = i;
- error.index0 = index1;
- error.index1 = index2;
- return error;
- }
- }
- // Check for zero area faces.
- {
- const internal::Vector3 a = DecodePosition(mesh, tri[0]);
- const internal::Vector3 b = DecodePosition(mesh, tri[1]);
- const internal::Vector3 c = DecodePosition(mesh, tri[2]);
- const float area = internal::length(internal::cross(b - a, c - a)) * 0.5f;
- if (area <= 0.0f) {
- delete heMesh;
- error.code = AddMeshErrorCode::ZeroAreaFace;
- error.face = i;
- return error;
- }
- }
- internal::halfedge::Face *face = heMesh->addFace(tri[0], tri[1], tri[2]);
-
- // -- GODOT start --
- if (!face && heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::AlreadyAddedEdge) {
- //there is still hope for this, no reason to not add, at least add as separate
- face = heMesh->addUniqueFace(tri[0], tri[1], tri[2]);
- }
- // -- GODOT end --
-
- if (!face) {
- if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::AlreadyAddedEdge)
- error.code = AddMeshErrorCode::AlreadyAddedEdge;
- else if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::DegenerateColocalEdge)
- error.code = AddMeshErrorCode::DegenerateColocalEdge;
- else if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::DegenerateEdge)
- error.code = AddMeshErrorCode::DegenerateEdge;
- else if (heMesh->errorCode == internal::halfedge::Mesh::ErrorCode::DuplicateEdge)
- error.code = AddMeshErrorCode::DuplicateEdge;
- error.face = i;
- error.index0 = heMesh->errorIndex0;
- error.index1 = heMesh->errorIndex1;
- delete heMesh;
- return error;
- }
- if (mesh.faceMaterialData)
- face->material = mesh.faceMaterialData[i];
- }
- heMesh->linkBoundary();
- atlas->heMeshes.push_back(heMesh);
- return error;
+ const uint32_t index1 = tri[j];
+ const uint32_t index2 = tri[(j + 1) % 3];
+ if (index1 == index2) {
+ ignore = true;
+ XA_PRINT(" Degenerate edge: index %d, index %d\n", index1, index2);
+ break;
+ }
+ const internal::Vector3 &pos1 = mesh->position(index1);
+ const internal::Vector3 &pos2 = mesh->position(index2);
+ if (internal::length(pos2 - pos1) <= 0.0f) {
+ ignore = true;
+ XA_PRINT(" Zero length edge: index %d position (%g %g %g), index %d position (%g %g %g)\n", index1, pos1.x, pos1.y, pos1.z, index2, pos2.x, pos2.y, pos2.z);
+ break;
+ }
+ }
+ const internal::Vector3 &a = mesh->position(tri[0]);
+ const internal::Vector3 &b = mesh->position(tri[1]);
+ const internal::Vector3 &c = mesh->position(tri[2]);
+ // Check for zero area faces. Don't bother if a degenerate or zero length edge was already detected.
+ float area = 0.0f;
+ if (!ignore) {
+ area = internal::length(internal::cross(b - a, c - a)) * 0.5f;
+ if (area <= internal::kAreaEpsilon) {
+ ignore = true;
+ XA_PRINT(" Zero area face: %d, indices (%d %d %d), area is %f\n", i, tri[0], tri[1], tri[2], area);
+ }
+ }
+ if (!ignore) {
+ if (internal::equal(a, b, meshDecl.epsilon) || internal::equal(a, c, meshDecl.epsilon) || internal::equal(b, c, meshDecl.epsilon)) {
+ ignore = true;
+ XA_PRINT(" Degenerate face: %d, area is %f\n", i, area);
+ }
+ }
+ if (meshDecl.faceIgnoreData && meshDecl.faceIgnoreData[i])
+ ignore = true;
+ mesh->addFace(tri[0], tri[1], tri[2], ignore);
+ }
+ AddMeshTaskArgs *taskArgs = XA_NEW(internal::MemTag::Default, AddMeshTaskArgs); // The task frees this.
+ taskArgs->ctx = ctx;
+ taskArgs->mesh = mesh;
+ internal::Task task;
+ task.userData = taskArgs;
+ task.func = runAddMeshTask;
+ ctx->taskScheduler->run(&ctx->addMeshTaskGroup, task);
+ ctx->meshCount++;
+ XA_PROFILE_END(addMesh)
+ return AddMeshError::Success;
+}
+
+void AddMeshJoin(Atlas *atlas)
+{
+ XA_DEBUG_ASSERT(atlas);
+ if (!atlas) {
+ XA_PRINT_WARNING("AddMeshJoin: atlas is null.\n");
+ return;
+ }
+ Context *ctx = (Context *)atlas;
+ if (!ctx->addMeshProgress)
+ return;
+ ctx->taskScheduler->wait(&ctx->addMeshTaskGroup);
+ ctx->addMeshProgress->~Progress();
+ XA_FREE(ctx->addMeshProgress);
+ ctx->addMeshProgress = nullptr;
+#if XA_PROFILE
+ XA_PRINT("Added %u meshes\n", ctx->meshCount);
+ internal::s_profile.addMeshConcurrent = clock() - internal::s_profile.addMeshConcurrent;
+#endif
+ XA_PROFILE_PRINT(" Total (concurrent): ", addMeshConcurrent)
+ XA_PROFILE_PRINT(" Total: ", addMesh)
+ XA_PROFILE_PRINT(" Create colocals: ", addMeshCreateColocals)
+ XA_PROFILE_PRINT(" Create face groups: ", addMeshCreateFaceGroups)
+ XA_PROFILE_PRINT(" Create boundaries: ", addMeshCreateBoundaries)
+ XA_PROFILE_PRINT(" Create chart groups (concurrent): ", addMeshCreateChartGroupsConcurrent)
+ XA_PROFILE_PRINT(" Create chart groups: ", addMeshCreateChartGroups)
+ XA_PRINT_MEM_USAGE
+}
+
+struct EdgeKey
+{
+ EdgeKey() {}
+ EdgeKey(const EdgeKey &k) : v0(k.v0), v1(k.v1) {}
+ EdgeKey(uint32_t v0, uint32_t v1) : v0(v0), v1(v1) {}
+
+ void operator=(const EdgeKey &k)
+ {
+ v0 = k.v0;
+ v1 = k.v1;
+ }
+ bool operator==(const EdgeKey &k) const
+ {
+ return v0 == k.v0 && v1 == k.v1;
+ }
+
+ uint32_t v0;
+ uint32_t v1;
+};
+
+AddMeshError::Enum AddUvMesh(Atlas *atlas, const UvMeshDecl &decl)
+{
+ XA_DEBUG_ASSERT(atlas);
+ if (!atlas) {
+ XA_PRINT_WARNING("AddUvMesh: atlas is null.\n");
+ return AddMeshError::Error;
+ }
+ Context *ctx = (Context *)atlas;
+ if (ctx->meshCount > 0) {
+ XA_PRINT_WARNING("AddUvMesh: Meshes and UV meshes cannot be added to the same atlas.\n");
+ return AddMeshError::Error;
+ }
+ const bool decoded = (decl.indexCount <= 0);
+ const uint32_t indexCount = decoded ? decl.vertexCount : decl.indexCount;
+ XA_PRINT("Adding UV mesh %d: %u vertices, %u triangles\n", ctx->uvMeshes.size(), decl.vertexCount, indexCount / 3);
+ // Expecting triangle faces.
+ if ((indexCount % 3) != 0)
+ return AddMeshError::InvalidIndexCount;
+ if (!decoded) {
+ // Check if any index is out of range.
+ for (uint32_t i = 0; i < indexCount; i++) {
+ const uint32_t index = DecodeIndex(decl.indexFormat, decl.indexData, decl.indexOffset, i);
+ if (index >= decl.vertexCount)
+ return AddMeshError::IndexOutOfRange;
+ }
+ }
+ internal::UvMeshInstance *meshInstance = XA_NEW(internal::MemTag::Default, internal::UvMeshInstance);
+ meshInstance->texcoords.resize(decl.vertexCount);
+ for (uint32_t i = 0; i < decl.vertexCount; i++)
+ meshInstance->texcoords[i] = *((const internal::Vector2 *)&((const uint8_t *)decl.vertexUvData)[decl.vertexStride * i]);
+ meshInstance->rotateCharts = decl.rotateCharts;
+ // See if this is an instance of an already existing mesh.
+ internal::UvMesh *mesh = nullptr;
+ for (uint32_t m = 0; m < ctx->uvMeshes.size(); m++) {
+ if (memcmp(&ctx->uvMeshes[m]->decl, &decl, sizeof(UvMeshDecl)) == 0) {
+ meshInstance->mesh = mesh = ctx->uvMeshes[m];
+ break;
+ }
+ }
+ if (!mesh) {
+ // Copy geometry to mesh.
+ meshInstance->mesh = mesh = XA_NEW(internal::MemTag::Default, internal::UvMesh);
+ mesh->decl = decl;
+ mesh->indices.resize(decl.indexCount);
+ for (uint32_t i = 0; i < indexCount; i++)
+ mesh->indices[i] = decoded ? i : DecodeIndex(decl.indexFormat, decl.indexData, decl.indexOffset, i);
+ mesh->vertexToChartMap.resize(decl.vertexCount);
+ for (uint32_t i = 0; i < mesh->vertexToChartMap.size(); i++)
+ mesh->vertexToChartMap[i] = UINT32_MAX;
+ // Calculate charts (incident faces).
+ internal::HashMap<internal::Vector2, uint32_t> vertexToFaceMap(internal::MemTag::Default, indexCount);
+ const uint32_t faceCount = indexCount / 3;
+ for (uint32_t i = 0; i < indexCount; i++)
+ vertexToFaceMap.add(meshInstance->texcoords[mesh->indices[i]], i / 3);
+ internal::BitArray faceAssigned(faceCount);
+ faceAssigned.clearAll();
+ internal::Array<uint32_t> chartFaces;
+ for (uint32_t f = 0; f < faceCount; f++) {
+ if (faceAssigned.bitAt(f))
+ continue;
+ // Found an unassigned face, create a new chart.
+ internal::UvMeshChart *chart = XA_NEW(internal::MemTag::Default, internal::UvMeshChart);
+ chart->material = decl.faceMaterialData ? decl.faceMaterialData[f] : 0;
+ // Walk incident faces and assign them to the chart.
+ faceAssigned.setBitAt(f);
+ chartFaces.clear();
+ chartFaces.push_back(f);
+ for (;;) {
+ bool newFaceAssigned = false;
+ const uint32_t faceCount2 = chartFaces.size();
+ for (uint32_t f2 = 0; f2 < faceCount2; f2++) {
+ const uint32_t face = chartFaces[f2];
+ for (uint32_t i = 0; i < 3; i++) {
+ const internal::Vector2 &texcoord = meshInstance->texcoords[meshInstance->mesh->indices[face * 3 + i]];
+ uint32_t mapFaceIndex = vertexToFaceMap.get(texcoord);
+ while (mapFaceIndex != UINT32_MAX) {
+ const uint32_t face2 = vertexToFaceMap.value(mapFaceIndex);
+ // Materials must match.
+ if (!faceAssigned.bitAt(face2) && (!decl.faceMaterialData || decl.faceMaterialData[face] == decl.faceMaterialData[face2])) {
+ faceAssigned.setBitAt(face2);
+ chartFaces.push_back(face2);
+ newFaceAssigned = true;
+ }
+ mapFaceIndex = vertexToFaceMap.getNext(mapFaceIndex);
+ }
+ }
+ }
+ if (!newFaceAssigned)
+ break;
+ }
+ for (uint32_t i = 0; i < chartFaces.size(); i++) {
+ for (uint32_t j = 0; j < 3; j++) {
+ const uint32_t vertex = meshInstance->mesh->indices[chartFaces[i] * 3 + j];
+ chart->indices.push_back(vertex);
+ mesh->vertexToChartMap[vertex] = mesh->charts.size();
+ }
+ }
+ mesh->charts.push_back(chart);
+ }
+ ctx->uvMeshes.push_back(mesh);
+ } else {
+ XA_PRINT(" instance of a previous UV mesh\n");
+ }
+ XA_PRINT(" %u charts\n", meshInstance->mesh->charts.size());
+ ctx->uvMeshInstances.push_back(meshInstance);
+ return AddMeshError::Success;
+}
+
+void ComputeCharts(Atlas *atlas, ChartOptions chartOptions)
+{
+ if (!atlas) {
+ XA_PRINT_WARNING("ComputeCharts: atlas is null.\n");
+ return;
+ }
+ Context *ctx = (Context *)atlas;
+ if (!ctx->uvMeshInstances.isEmpty()) {
+ XA_PRINT_WARNING("ComputeCharts: This function should not be called with UV meshes.\n");
+ return;
+ }
+ AddMeshJoin(atlas);
+ if (ctx->meshCount == 0) {
+ XA_PRINT_WARNING("ComputeCharts: No meshes. Call AddMesh first.\n");
+ return;
+ }
+ XA_PRINT("Computing charts\n");
+ uint32_t chartCount = 0, chartsWithHolesCount = 0, holesCount = 0, chartsWithTJunctionsCount = 0, tJunctionsCount = 0;
+ XA_PROFILE_START(computeChartsConcurrent)
+ if (!ctx->paramAtlas.computeCharts(ctx->taskScheduler, chartOptions, ctx->progressFunc, ctx->progressUserData)) {
+ XA_PRINT(" Cancelled by user\n");
+ return;
+ }
+ XA_PROFILE_END(computeChartsConcurrent)
+ // Count charts and print warnings.
+ for (uint32_t i = 0; i < ctx->meshCount; i++) {
+ for (uint32_t j = 0; j < ctx->paramAtlas.chartGroupCount(i); j++) {
+ const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, j);
+ if (chartGroup->isVertexMap())
+ continue;
+ for (uint32_t k = 0; k < chartGroup->chartCount(); k++) {
+ const internal::param::Chart *chart = chartGroup->chartAt(k);
+ if (chart->warningFlags() & internal::param::ChartWarningFlags::CloseHolesFailed)
+ XA_PRINT_WARNING(" Chart %u (mesh %u, group %u, id %u): failed to close holes\n", chartCount, i, j, k);
+ if (chart->warningFlags() & internal::param::ChartWarningFlags::FixTJunctionsDuplicatedEdge)
+ XA_PRINT_WARNING(" Chart %u (mesh %u, group %u, id %u): fixing t-junctions created non-manifold geometry\n", chartCount, i, j, k);
+ if (chart->warningFlags() & internal::param::ChartWarningFlags::FixTJunctionsFailed)
+ XA_PRINT_WARNING(" Chart %u (mesh %u, group %u, id %u): fixing t-junctions failed\n", chartCount, i, j, k);
+ if (chart->warningFlags() & internal::param::ChartWarningFlags::TriangulateDuplicatedEdge)
+ XA_PRINT_WARNING(" Chart %u (mesh %u, group %u, id %u): triangulation created non-manifold geometry\n", chartCount, i, j, k);
+ if (!chart->isDisk())
+ XA_PRINT_WARNING(" Chart %u (mesh %u, group %u, id %u): doesn't have disk topology\n", chartCount, i, j, k);
+ holesCount += chart->closedHolesCount();
+ if (chart->closedHolesCount() > 0)
+ chartsWithHolesCount++;
+ tJunctionsCount += chart->fixedTJunctionsCount();
+ if (chart->fixedTJunctionsCount() > 0)
+ chartsWithTJunctionsCount++;
+ chartCount++;
+ }
+ }
+ }
+ if (holesCount > 0)
+ XA_PRINT(" Closed %u holes in %u charts\n", holesCount, chartsWithHolesCount);
+ if (tJunctionsCount > 0)
+ XA_PRINT(" Fixed %u t-junctions in %u charts\n", tJunctionsCount, chartsWithTJunctionsCount);
+ XA_PRINT(" %u charts\n", chartCount);
+ XA_PROFILE_PRINT(" Total (concurrent): ", computeChartsConcurrent)
+ XA_PROFILE_PRINT(" Total: ", computeCharts)
+ XA_PROFILE_PRINT(" Atlas builder: ", atlasBuilder)
+ XA_PROFILE_PRINT(" Init: ", atlasBuilderInit)
+ XA_PROFILE_PRINT(" Create initial charts: ", atlasBuilderCreateInitialCharts)
+ XA_PROFILE_PRINT(" Grow charts: ", atlasBuilderGrowCharts)
+ XA_PROFILE_PRINT(" Merge charts: ", atlasBuilderMergeCharts)
+ XA_PROFILE_PRINT(" Create chart meshes: ", createChartMeshes)
+ XA_PROFILE_PRINT(" Fix t-junctions: ", fixChartMeshTJunctions);
+ XA_PROFILE_PRINT(" Close holes: ", closeChartMeshHoles)
+ XA_PRINT_MEM_USAGE
}
-void Generate(Atlas *atlas, CharterOptions charterOptions, PackerOptions packerOptions)
-{
- xaAssert(atlas);
- xaAssert(packerOptions.texelArea > 0);
- // Chart meshes.
- for (int i = 0; i < (int)atlas->heMeshes.size(); i++) {
- std::vector<uint32_t> uncharted_materials;
- atlas->atlas.computeCharts(atlas->heMeshes[i], charterOptions, uncharted_materials);
- }
- atlas->atlas.parameterizeCharts();
- internal::param::AtlasPacker packer(&atlas->atlas);
- packer.packCharts(packerOptions);
- //float utilization = return packer.computeAtlasUtilization();
- atlas->width = packer.getWidth();
- atlas->height = packer.getHeight();
- // Build output meshes.
- atlas->outputMeshes = new OutputMesh*[atlas->heMeshes.size()];
- for (int i = 0; i < (int)atlas->heMeshes.size(); i++) {
- const internal::halfedge::Mesh *heMesh = atlas->heMeshes[i];
- OutputMesh *outputMesh = atlas->outputMeshes[i] = new OutputMesh;
- const internal::param::MeshCharts *charts = atlas->atlas.meshAt(i);
- // Vertices.
- outputMesh->vertexCount = charts->vertexCount();
- outputMesh->vertexArray = new OutputVertex[outputMesh->vertexCount];
- for (uint32_t i = 0; i < charts->chartCount(); i++) {
- const internal::param::Chart *chart = charts->chartAt(i);
- const uint32_t vertexOffset = charts->vertexCountBeforeChartAt(i);
- for (uint32_t v = 0; v < chart->vertexCount(); v++) {
- OutputVertex &output_vertex = outputMesh->vertexArray[vertexOffset + v];
- output_vertex.xref = chart->mapChartVertexToOriginalVertex(v);
- internal::Vector2 uv = chart->chartMesh()->vertexAt(v)->tex;
- output_vertex.uv[0] = uv.x;
- output_vertex.uv[1] = uv.y;
- }
- }
- // Indices.
- outputMesh->indexCount = heMesh->faceCount() * 3;
- outputMesh->indexArray = new uint32_t[outputMesh->indexCount];
- for (uint32_t f = 0; f < heMesh->faceCount(); f++) {
- const uint32_t c = charts->faceChartAt(f);
- const uint32_t i = charts->faceIndexWithinChartAt(f);
- const uint32_t vertexOffset = charts->vertexCountBeforeChartAt(c);
- const internal::param::Chart *chart = charts->chartAt(c);
- xaDebugAssert(i < chart->chartMesh()->faceCount());
- xaDebugAssert(chart->faceAt(i) == f);
- const internal::halfedge::Face *face = chart->chartMesh()->faceAt(i);
- const internal::halfedge::Edge *edge = face->edge;
- outputMesh->indexArray[3 * f + 0] = vertexOffset + edge->vertex->id;
- outputMesh->indexArray[3 * f + 1] = vertexOffset + edge->next->vertex->id;
- outputMesh->indexArray[3 * f + 2] = vertexOffset + edge->next->next->vertex->id;
- }
- // Charts.
- outputMesh->chartCount = charts->chartCount();
- outputMesh->chartArray = new OutputChart[outputMesh->chartCount];
- for (uint32_t i = 0; i < charts->chartCount(); i++) {
- OutputChart *outputChart = &outputMesh->chartArray[i];
- const internal::param::Chart *chart = charts->chartAt(i);
- const uint32_t vertexOffset = charts->vertexCountBeforeChartAt(i);
- const internal::halfedge::Mesh *mesh = chart->chartMesh();
- outputChart->indexCount = mesh->faceCount() * 3;
- outputChart->indexArray = new uint32_t[outputChart->indexCount];
- for (uint32_t j = 0; j < mesh->faceCount(); j++) {
- const internal::halfedge::Face *face = mesh->faceAt(j);
- const internal::halfedge::Edge *edge = face->edge;
- outputChart->indexArray[3 * j + 0] = vertexOffset + edge->vertex->id;
- outputChart->indexArray[3 * j + 1] = vertexOffset + edge->next->vertex->id;
- outputChart->indexArray[3 * j + 2] = vertexOffset + edge->next->next->vertex->id;
+void ParameterizeCharts(Atlas *atlas, ParameterizeFunc func)
+{
+ if (!atlas) {
+ XA_PRINT_WARNING("ParameterizeCharts: atlas is null.\n");
+ return;
+ }
+ Context *ctx = (Context *)atlas;
+ if (!ctx->uvMeshInstances.isEmpty()) {
+ XA_PRINT_WARNING("ParameterizeCharts: This function should not be called with UV meshes.\n");
+ return;
+ }
+ if (!ctx->paramAtlas.chartsComputed()) {
+ XA_PRINT_WARNING("ParameterizeCharts: ComputeCharts must be called first.\n");
+ return;
+ }
+ atlas->atlasCount = 0;
+ atlas->height = 0;
+ atlas->texelsPerUnit = 0;
+ atlas->width = 0;
+ if (atlas->utilization) {
+ XA_FREE(atlas->utilization);
+ atlas->utilization = nullptr;
+ }
+ if (atlas->image) {
+ XA_FREE(atlas->image);
+ atlas->image = nullptr;
+ }
+ DestroyOutputMeshes(ctx);
+ XA_PRINT("Parameterizing charts\n");
+ XA_PROFILE_START(parameterizeChartsConcurrent)
+ if (!ctx->paramAtlas.parameterizeCharts(ctx->taskScheduler, func, ctx->progressFunc, ctx->progressUserData)) {
+ XA_PRINT(" Cancelled by user\n");
+ return;
+ }
+ XA_PROFILE_END(parameterizeChartsConcurrent)
+ uint32_t chartCount = 0, orthoChartsCount = 0, planarChartsCount = 0, chartsAddedCount = 0, chartsDeletedCount = 0;
+ for (uint32_t i = 0; i < ctx->meshCount; i++) {
+ for (uint32_t j = 0; j < ctx->paramAtlas.chartGroupCount(i); j++) {
+ const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, j);
+ if (chartGroup->isVertexMap())
+ continue;
+ for (uint32_t k = 0; k < chartGroup->chartCount(); k++) {
+ const internal::param::Chart *chart = chartGroup->chartAt(k);
+ if (chart->isPlanar())
+ planarChartsCount++;
+ else if (chart->isOrtho())
+ orthoChartsCount++;
+ }
+ chartCount += chartGroup->chartCount();
+ chartsAddedCount += chartGroup->paramAddedChartsCount();
+ chartsDeletedCount += chartGroup->paramDeletedChartsCount();
+ }
+ }
+ XA_PRINT(" %u planar charts, %u ortho charts, %u other\n", planarChartsCount, orthoChartsCount, chartCount - (planarChartsCount + orthoChartsCount));
+ if (chartsDeletedCount > 0) {
+ XA_PRINT(" %u charts deleted due to invalid parameterizations, %u new charts added\n", chartsDeletedCount, chartsAddedCount);
+ XA_PRINT(" %u charts\n", ctx->paramAtlas.chartCount());
+ }
+ uint32_t chartIndex = 0, invalidParamCount = 0;
+ for (uint32_t i = 0; i < ctx->meshCount; i++) {
+ for (uint32_t j = 0; j < ctx->paramAtlas.chartGroupCount(i); j++) {
+ const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, j);
+ if (chartGroup->isVertexMap())
+ continue;
+ for (uint32_t k = 0; k < chartGroup->chartCount(); k++) {
+ const internal::param::Chart *chart = chartGroup->chartAt(k);
+ const internal::param::ParameterizationQuality &quality = chart->paramQuality();
+#if XA_DEBUG_EXPORT_OBJ_CHARTS_AFTER_PARAMETERIZATION
+ {
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_chart_%03u_after_parameterization.obj", chartIndex);
+ chart->unifiedMesh()->writeObjFile(filename);
+ }
+#endif
+ bool invalid = false;
+ if (quality.boundaryIntersection) {
+ invalid = true;
+ XA_PRINT_WARNING(" Chart %u (mesh %u, group %u, id %u) (%s): invalid parameterization, self-intersecting boundary.\n", chartIndex, i, j, k, chart->isPlanar() ? "planar" : chart->isOrtho() ? "ortho" : "other");
+ }
+ if (quality.flippedTriangleCount > 0) {
+ invalid = true;
+ XA_PRINT_WARNING(" Chart %u (mesh %u, group %u, id %u) (%s): invalid parameterization, %u / %u flipped triangles.\n", chartIndex, i, j, k, chart->isPlanar() ? "planar" : chart->isOrtho() ? "ortho" : "other", quality.flippedTriangleCount, quality.totalTriangleCount);
+ }
+ if (invalid)
+ invalidParamCount++;
+#if XA_DEBUG_EXPORT_OBJ_INVALID_PARAMETERIZATION
+ if (invalid) {
+ char filename[256];
+ XA_SPRINTF(filename, sizeof(filename), "debug_chart_%03u_invalid_parameterization.obj", chartIndex);
+ const internal::Mesh *mesh = chart->unifiedMesh();
+ FILE *file;
+ XA_FOPEN(file, filename, "w");
+ if (file) {
+ mesh->writeObjVertices(file);
+ fprintf(file, "s off\n");
+ fprintf(file, "o object\n");
+ for (uint32_t f = 0; f < mesh->faceCount(); f++)
+ mesh->writeObjFace(file, f);
+ if (!chart->paramFlippedFaces().isEmpty()) {
+ fprintf(file, "o flipped_faces\n");
+ for (uint32_t f = 0; f < chart->paramFlippedFaces().size(); f++)
+ mesh->writeObjFace(file, chart->paramFlippedFaces()[f]);
+ }
+ mesh->writeObjBoundaryEges(file);
+ mesh->writeObjLinkedBoundaries(file);
+ fclose(file);
+ }
+ }
+#endif
+ chartIndex++;
}
}
}
+ if (invalidParamCount > 0)
+ XA_PRINT_WARNING(" %u charts with invalid parameterizations\n", invalidParamCount);
+ XA_PROFILE_PRINT(" Total (concurrent): ", parameterizeChartsConcurrent)
+ XA_PROFILE_PRINT(" Total: ", parameterizeCharts)
+ XA_PROFILE_PRINT(" Orthogonal: ", parameterizeChartsOrthogonal)
+ XA_PROFILE_PRINT(" LSCM: ", parameterizeChartsLSCM)
+ XA_PROFILE_PRINT(" Evaluate quality: ", parameterizeChartsEvaluateQuality)
+ XA_PRINT_MEM_USAGE
}
-uint32_t GetWidth(const Atlas *atlas)
+void PackCharts(Atlas *atlas, PackOptions packOptions)
{
- xaAssert(atlas);
- return atlas->width;
+ // Validate arguments and context state.
+ if (!atlas) {
+ XA_PRINT_WARNING("PackCharts: atlas is null.\n");
+ return;
+ }
+ Context *ctx = (Context *)atlas;
+ if (ctx->meshCount == 0 && ctx->uvMeshInstances.isEmpty()) {
+ XA_PRINT_WARNING("PackCharts: No meshes. Call AddMesh or AddUvMesh first.\n");
+ return;
+ }
+ if (ctx->uvMeshInstances.isEmpty()) {
+ if (!ctx->paramAtlas.chartsComputed()) {
+ XA_PRINT_WARNING("PackCharts: ComputeCharts must be called first.\n");
+ return;
+ }
+ if (!ctx->paramAtlas.chartsParameterized()) {
+ XA_PRINT_WARNING("PackCharts: ParameterizeCharts must be called first.\n");
+ return;
+ }
+ }
+ if (packOptions.texelsPerUnit < 0.0f) {
+ XA_PRINT_WARNING("PackCharts: PackOptions::texelsPerUnit is negative.\n");
+ packOptions.texelsPerUnit = 0.0f;
+ }
+ // Cleanup atlas.
+ DestroyOutputMeshes(ctx);
+ if (atlas->utilization) {
+ XA_FREE(atlas->utilization);
+ atlas->utilization = nullptr;
+ }
+ if (atlas->image) {
+ XA_FREE(atlas->image);
+ atlas->image = nullptr;
+ }
+ atlas->meshCount = 0;
+ // Pack charts.
+ internal::pack::Atlas packAtlas;
+ if (!ctx->uvMeshInstances.isEmpty()) {
+ for (uint32_t i = 0; i < ctx->uvMeshInstances.size(); i++)
+ packAtlas.addUvMeshCharts(ctx->uvMeshInstances[i]);
+ }
+ else if (ctx->paramAtlas.chartCount() > 0) {
+ ctx->paramAtlas.restoreOriginalChartTexcoords();
+ for (uint32_t i = 0; i < ctx->paramAtlas.chartCount(); i++)
+ packAtlas.addChart(ctx->paramAtlas.chartAt(i));
+ }
+ XA_PROFILE_START(packCharts)
+ if (!packAtlas.packCharts(packOptions, ctx->progressFunc, ctx->progressUserData))
+ return;
+ XA_PROFILE_END(packCharts)
+ // Populate atlas object with pack results.
+ atlas->atlasCount = packAtlas.getNumAtlases();
+ atlas->chartCount = packAtlas.getChartCount();
+ atlas->width = packAtlas.getWidth();
+ atlas->height = packAtlas.getHeight();
+ atlas->texelsPerUnit = packAtlas.getTexelsPerUnit();
+ if (atlas->atlasCount > 0) {
+ atlas->utilization = XA_ALLOC_ARRAY(internal::MemTag::Default, float, atlas->atlasCount);
+ for (uint32_t i = 0; i < atlas->atlasCount; i++)
+ atlas->utilization[i] = packAtlas.getUtilization(i);
+ }
+ if (packOptions.createImage) {
+ atlas->image = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, atlas->atlasCount * atlas->width * atlas->height);
+ for (uint32_t i = 0; i < atlas->atlasCount; i++)
+ packAtlas.getImages()[i]->copyTo(&atlas->image[atlas->width * atlas->height * i], atlas->width, atlas->height);
+ }
+ XA_PROFILE_PRINT(" Total: ", packCharts)
+ XA_PROFILE_PRINT(" Rasterize: ", packChartsRasterize)
+ XA_PROFILE_PRINT(" Dilate (padding): ", packChartsDilate)
+ XA_PROFILE_PRINT(" Find location: ", packChartsFindLocation)
+ XA_PROFILE_PRINT(" Blit: ", packChartsBlit)
+ XA_PRINT_MEM_USAGE
+#if XA_PROFILE
+ internal::s_profile.packCharts = 0;
+ internal::s_profile.packChartsRasterize = 0;
+ internal::s_profile.packChartsDilate = 0;
+ internal::s_profile.packChartsFindLocation = 0;
+ internal::s_profile.packChartsBlit = 0;
+#endif
+ XA_PRINT("Building output meshes\n");
+ int progress = 0;
+ if (ctx->progressFunc) {
+ if (!ctx->progressFunc(ProgressCategory::BuildOutputMeshes, 0, ctx->progressUserData))
+ return;
+ }
+ if (ctx->uvMeshInstances.isEmpty())
+ atlas->meshCount = ctx->meshCount;
+ else
+ atlas->meshCount = ctx->uvMeshInstances.size();
+ atlas->meshes = XA_ALLOC_ARRAY(internal::MemTag::Default, Mesh, atlas->meshCount);
+ memset(atlas->meshes, 0, sizeof(Mesh) * atlas->meshCount);
+ if (ctx->uvMeshInstances.isEmpty()) {
+ uint32_t chartIndex = 0;
+ for (uint32_t i = 0; i < ctx->meshCount; i++) {
+ Mesh &outputMesh = atlas->meshes[i];
+ // Count and alloc arrays. Ignore vertex mapped chart groups in Mesh::chartCount, since they're ignored faces.
+ for (uint32_t cg = 0; cg < ctx->paramAtlas.chartGroupCount(i); cg++) {
+ const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, cg);
+ if (chartGroup->isVertexMap()) {
+ outputMesh.vertexCount += chartGroup->mesh()->vertexCount();
+ outputMesh.indexCount += chartGroup->mesh()->faceCount() * 3;
+ } else {
+ for (uint32_t c = 0; c < chartGroup->chartCount(); c++) {
+ const internal::param::Chart *chart = chartGroup->chartAt(c);
+ outputMesh.vertexCount += chart->mesh()->vertexCount();
+ outputMesh.indexCount += chart->mesh()->faceCount() * 3;
+ outputMesh.chartCount++;
+ }
+ }
+ }
+ outputMesh.vertexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Vertex, outputMesh.vertexCount);
+ outputMesh.indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputMesh.indexCount);
+ outputMesh.chartArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Chart, outputMesh.chartCount);
+ XA_PRINT(" mesh %u: %u vertices, %u triangles, %u charts\n", i, outputMesh.vertexCount, outputMesh.indexCount / 3, outputMesh.chartCount);
+ // Copy mesh data.
+ uint32_t firstVertex = 0;
+ uint32_t meshChartIndex = 0;
+ for (uint32_t cg = 0; cg < ctx->paramAtlas.chartGroupCount(i); cg++) {
+ const internal::param::ChartGroup *chartGroup = ctx->paramAtlas.chartGroupAt(i, cg);
+ if (chartGroup->isVertexMap()) {
+ const internal::Mesh *mesh = chartGroup->mesh();
+ // Vertices.
+ for (uint32_t v = 0; v < mesh->vertexCount(); v++) {
+ Vertex &vertex = outputMesh.vertexArray[firstVertex + v];
+ vertex.atlasIndex = -1;
+ vertex.chartIndex = -1;
+ vertex.uv[0] = vertex.uv[1] = 0.0f;
+ vertex.xref = chartGroup->mapVertexToSourceVertex(v);
+ }
+ // Indices.
+ for (uint32_t f = 0; f < mesh->faceCount(); f++) {
+ const uint32_t indexOffset = chartGroup->mapFaceToSourceFace(f) * 3;
+ for (uint32_t j = 0; j < 3; j++)
+ outputMesh.indexArray[indexOffset + j] = firstVertex + mesh->vertexAt(f * 3 + j);
+ }
+ firstVertex += mesh->vertexCount();
+ } else {
+ for (uint32_t c = 0; c < chartGroup->chartCount(); c++) {
+ const internal::param::Chart *chart = chartGroup->chartAt(c);
+ const internal::Mesh *mesh = chart->mesh();
+ // Vertices.
+ for (uint32_t v = 0; v < mesh->vertexCount(); v++) {
+ Vertex &vertex = outputMesh.vertexArray[firstVertex + v];
+ vertex.atlasIndex = packAtlas.getChart(chartIndex)->atlasIndex;
+ XA_DEBUG_ASSERT(vertex.atlasIndex >= 0);
+ vertex.chartIndex = (int32_t)chartIndex;
+ const internal::Vector2 &uv = mesh->texcoord(v);
+ vertex.uv[0] = internal::max(0.0f, uv.x);
+ vertex.uv[1] = internal::max(0.0f, uv.y);
+ vertex.xref = chartGroup->mapVertexToSourceVertex(chart->mapChartVertexToOriginalVertex(v));
+ }
+ // Indices.
+ for (uint32_t f = 0; f < mesh->faceCount(); f++) {
+ const uint32_t indexOffset = chartGroup->mapFaceToSourceFace(chart->mapFaceToSourceFace(f)) * 3;
+ for (uint32_t j = 0; j < 3; j++)
+ outputMesh.indexArray[indexOffset + j] = firstVertex + mesh->vertexAt(f * 3 + j);
+ }
+ // Charts.
+ Chart *outputChart = &outputMesh.chartArray[meshChartIndex];
+ const int32_t atlasIndex = packAtlas.getChart(chartIndex)->atlasIndex;
+ XA_DEBUG_ASSERT(atlasIndex >= 0);
+ outputChart->atlasIndex = (uint32_t)atlasIndex;
+ outputChart->flags = 0;
+ if (chart->paramQuality().boundaryIntersection || chart->paramQuality().flippedTriangleCount > 0)
+ outputChart->flags |= ChartFlags::Invalid;
+ outputChart->indexCount = mesh->faceCount() * 3;
+ outputChart->indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputChart->indexCount);
+ for (uint32_t f = 0; f < mesh->faceCount(); f++) {
+ for (uint32_t j = 0; j < 3; j++)
+ outputChart->indexArray[3 * f + j] = firstVertex + mesh->vertexAt(f * 3 + j);
+ }
+ outputChart->material = 0;
+ meshChartIndex++;
+ chartIndex++;
+ firstVertex += chart->mesh()->vertexCount();
+ }
+ }
+ }
+ XA_DEBUG_ASSERT(outputMesh.vertexCount == firstVertex);
+ XA_DEBUG_ASSERT(outputMesh.chartCount == meshChartIndex);
+ if (ctx->progressFunc) {
+ const int newProgress = int((i + 1) / (float)atlas->meshCount * 100.0f);
+ if (newProgress != progress) {
+ progress = newProgress;
+ if (!ctx->progressFunc(ProgressCategory::BuildOutputMeshes, progress, ctx->progressUserData))
+ return;
+ }
+ }
+ }
+ } else {
+ uint32_t chartIndex = 0;
+ for (uint32_t m = 0; m < ctx->uvMeshInstances.size(); m++) {
+ Mesh &outputMesh = atlas->meshes[m];
+ const internal::UvMeshInstance *mesh = ctx->uvMeshInstances[m];
+ // Alloc arrays.
+ outputMesh.vertexCount = mesh->texcoords.size();
+ outputMesh.indexCount = mesh->mesh->indices.size();
+ outputMesh.chartCount = mesh->mesh->charts.size();
+ outputMesh.vertexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Vertex, outputMesh.vertexCount);
+ outputMesh.indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputMesh.indexCount);
+ outputMesh.chartArray = XA_ALLOC_ARRAY(internal::MemTag::Default, Chart, outputMesh.chartCount);
+ XA_PRINT(" UV mesh %u: %u vertices, %u triangles, %u charts\n", m, outputMesh.vertexCount, outputMesh.indexCount / 3, outputMesh.chartCount);
+ // Copy mesh data.
+ // Vertices.
+ for (uint32_t v = 0; v < mesh->texcoords.size(); v++) {
+ Vertex &vertex = outputMesh.vertexArray[v];
+ vertex.uv[0] = mesh->texcoords[v].x;
+ vertex.uv[1] = mesh->texcoords[v].y;
+ vertex.xref = v;
+ const uint32_t meshChartIndex = mesh->mesh->vertexToChartMap[v];
+ if (meshChartIndex == UINT32_MAX) {
+ // Vertex doesn't exist in any chart.
+ vertex.atlasIndex = -1;
+ vertex.chartIndex = -1;
+ } else {
+ const internal::pack::Chart *chart = packAtlas.getChart(chartIndex + meshChartIndex);
+ vertex.atlasIndex = chart->atlasIndex;
+ vertex.chartIndex = (int32_t)chartIndex + meshChartIndex;
+ }
+ }
+ // Indices.
+ memcpy(outputMesh.indexArray, mesh->mesh->indices.data(), mesh->mesh->indices.size() * sizeof(uint32_t));
+ // Charts.
+ for (uint32_t c = 0; c < mesh->mesh->charts.size(); c++) {
+ Chart *outputChart = &outputMesh.chartArray[c];
+ const internal::pack::Chart *chart = packAtlas.getChart(chartIndex);
+ XA_DEBUG_ASSERT(chart->atlasIndex >= 0);
+ outputChart->atlasIndex = (uint32_t)chart->atlasIndex;
+ outputChart->indexCount = chart->indexCount;
+ outputChart->indexArray = XA_ALLOC_ARRAY(internal::MemTag::Default, uint32_t, outputChart->indexCount);
+ outputChart->material = chart->material;
+ memcpy(outputChart->indexArray, chart->indices, chart->indexCount * sizeof(uint32_t));
+ chartIndex++;
+ }
+ if (ctx->progressFunc) {
+ const int newProgress = int((m + 1) / (float)atlas->meshCount * 100.0f);
+ if (newProgress != progress) {
+ progress = newProgress;
+ if (!ctx->progressFunc(ProgressCategory::BuildOutputMeshes, progress, ctx->progressUserData))
+ return;
+ }
+ }
+ }
+ }
+ if (ctx->progressFunc && progress != 100)
+ ctx->progressFunc(ProgressCategory::BuildOutputMeshes, 100, ctx->progressUserData);
+ XA_PRINT_MEM_USAGE
+}
+
+void Generate(Atlas *atlas, ChartOptions chartOptions, ParameterizeFunc paramFunc, PackOptions packOptions)
+{
+ if (!atlas) {
+ XA_PRINT_WARNING("Generate: atlas is null.\n");
+ return;
+ }
+ Context *ctx = (Context *)atlas;
+ if (!ctx->uvMeshInstances.isEmpty()) {
+ XA_PRINT_WARNING("Generate: This function should not be called with UV meshes.\n");
+ return;
+ }
+ if (ctx->meshCount == 0) {
+ XA_PRINT_WARNING("Generate: No meshes. Call AddMesh first.\n");
+ return;
+ }
+ ComputeCharts(atlas, chartOptions);
+ ParameterizeCharts(atlas, paramFunc);
+ PackCharts(atlas, packOptions);
}
-uint32_t GetHeight(const Atlas *atlas)
+void SetProgressCallback(Atlas *atlas, ProgressFunc progressFunc, void *progressUserData)
{
- xaAssert(atlas);
- return atlas->height;
+ if (!atlas) {
+ XA_PRINT_WARNING("SetProgressCallback: atlas is null.\n");
+ return;
+ }
+ Context *ctx = (Context *)atlas;
+ ctx->progressFunc = progressFunc;
+ ctx->progressUserData = progressUserData;
}
-uint32_t GetNumCharts(const Atlas *atlas)
+void SetRealloc(ReallocFunc reallocFunc)
{
- xaAssert(atlas);
- return atlas->atlas.chartCount();
+ internal::s_realloc = reallocFunc;
+}
+
+void SetPrint(PrintFunc print, bool verbose)
+{
+ internal::s_print = print;
+ internal::s_printVerbose = verbose;
}
-const OutputMesh * const *GetOutputMeshes(const Atlas *atlas)
+const char *StringForEnum(AddMeshError::Enum error)
{
- xaAssert(atlas);
- return atlas->outputMeshes;
+ if (error == AddMeshError::Error)
+ return "Unspecified error";
+ if (error == AddMeshError::IndexOutOfRange)
+ return "Index out of range";
+ if (error == AddMeshError::InvalidIndexCount)
+ return "Invalid index count";
+ return "Success";
}
-const char *StringForEnum(AddMeshErrorCode::Enum error)
-{
- if (error == AddMeshErrorCode::AlreadyAddedEdge)
- return "already added edge";
- if (error == AddMeshErrorCode::DegenerateColocalEdge)
- return "degenerate colocal edge";
- if (error == AddMeshErrorCode::DegenerateEdge)
- return "degenerate edge";
- if (error == AddMeshErrorCode::DuplicateEdge)
- return "duplicate edge";
- if (error == AddMeshErrorCode::IndexOutOfRange)
- return "index out of range";
- if (error == AddMeshErrorCode::InvalidIndexCount)
- return "invalid index count";
- if (error == AddMeshErrorCode::ZeroAreaFace)
- return "zero area face";
- if (error == AddMeshErrorCode::ZeroLengthEdge)
- return "zero length edge";
- return "success";
+const char *StringForEnum(ProgressCategory::Enum category)
+{
+ if (category == ProgressCategory::AddMesh)
+ return "Adding mesh(es)";
+ if (category == ProgressCategory::ComputeCharts)
+ return "Computing charts";
+ if (category == ProgressCategory::ParameterizeCharts)
+ return "Parameterizing charts";
+ if (category == ProgressCategory::PackCharts)
+ return "Packing charts";
+ if (category == ProgressCategory::BuildOutputMeshes)
+ return "Building output meshes";
+ return "";
}
} // namespace xatlas
diff --git a/thirdparty/xatlas/xatlas.h b/thirdparty/xatlas/xatlas.h
index dbf8ca08c7..c123e800b4 100644
--- a/thirdparty/xatlas/xatlas.h
+++ b/thirdparty/xatlas/xatlas.h
@@ -1,176 +1,254 @@
-// This code is in the public domain -- castanyo@yahoo.es
+/*
+MIT License
+
+Copyright (c) 2018-2019 Jonathan Young
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+/*
+thekla_atlas
+MIT License
+https://github.com/Thekla/thekla_atlas
+Copyright (c) 2013 Thekla, Inc
+Copyright NVIDIA Corporation 2006 -- Ignacio Castano <icastano@nvidia.com>
+*/
#pragma once
#ifndef XATLAS_H
#define XATLAS_H
-#include <float.h> // FLT_MAX
-// -- GODOT start --
-#include <limits.h> // INT_MAX, UINT_MAX
-// -- GODOT end --
+#include <stdint.h>
namespace xatlas {
-typedef void (*PrintFunc)(const char *, ...);
+struct ChartFlags
+{
+ enum
+ {
+ Invalid = 1 << 0
+ };
+};
-struct Atlas;
+// A group of connected faces, belonging to a single atlas.
+struct Chart
+{
+ uint32_t atlasIndex; // Sub-atlas index.
+ uint32_t flags;
+ uint32_t *indexArray;
+ uint32_t indexCount;
+ uint32_t material;
+};
-struct CharterOptions
+// Output vertex.
+struct Vertex
{
- float proxyFitMetricWeight;
- float roundnessMetricWeight;
- float straightnessMetricWeight;
- float normalSeamMetricWeight;
- float textureSeamMetricWeight;
- float maxChartArea;
- float maxBoundaryLength;
-
- CharterOptions()
- {
- // These are the default values we use on The Witness.
- proxyFitMetricWeight = 2.0f;
- roundnessMetricWeight = 0.01f;
- straightnessMetricWeight = 6.0f;
- normalSeamMetricWeight = 4.0f;
- textureSeamMetricWeight = 0.5f;
- /*
- proxyFitMetricWeight = 1.0f;
- roundnessMetricWeight = 0.1f;
- straightnessMetricWeight = 0.25f;
- normalSeamMetricWeight = 1.0f;
- textureSeamMetricWeight = 0.1f;
- */
- maxChartArea = FLT_MAX;
- maxBoundaryLength = FLT_MAX;
- }
+ int32_t atlasIndex; // Sub-atlas index. -1 if the vertex doesn't exist in any atlas.
+ int32_t chartIndex; // -1 if the vertex doesn't exist in any chart.
+ float uv[2]; // Not normalized - values are in Atlas width and height range.
+ uint32_t xref; // Index of input vertex from which this output vertex originated.
};
-struct PackMethod
+// Output mesh.
+struct Mesh
{
- enum Enum
- {
- TexelArea, // texel_area determines resolution
- ApproximateResolution, // guess texel_area to approximately match desired resolution
- ExactResolution // run the packer multiple times to exactly match the desired resolution (slow)
- };
+ Chart *chartArray;
+ uint32_t chartCount;
+ uint32_t *indexArray;
+ uint32_t indexCount;
+ Vertex *vertexArray;
+ uint32_t vertexCount;
};
-struct PackerOptions
+static const uint32_t kImageChartIndexMask = 0x3FFFFFFF;
+static const uint32_t kImageHasChartIndexBit = 0x40000000;
+static const uint32_t kImageIsPaddingBit = 0x80000000;
+
+// Empty on creation. Populated after charts are packed.
+struct Atlas
{
- PackMethod::Enum method;
-
- // 0 - brute force
- // 1 - 4096 attempts
- // 2 - 2048
- // 3 - 1024
- // 4 - 512
- // other - 256
- // Avoid brute force packing, since it can be unusably slow in some situations.
- int quality;
-
- float texelArea; // This is not really texel area, but 1 / texel width?
- uint32_t resolution;
- bool blockAlign; // Align charts to 4x4 blocks.
- bool conservative; // Pack charts with extra padding.
- int padding;
-
- PackerOptions()
- {
- method = PackMethod::ApproximateResolution;
- quality = 1;
- texelArea = 8;
- resolution = 512;
- blockAlign = false;
- conservative = false;
- padding = 0;
- }
+ uint32_t width; // Atlas width in texels.
+ uint32_t height; // Atlas height in texels.
+ uint32_t atlasCount; // Number of sub-atlases. Equal to 0 unless PackOptions resolution is changed from default (0).
+ uint32_t chartCount; // Total number of charts in all meshes.
+ uint32_t meshCount; // Number of output meshes. Equal to the number of times AddMesh was called.
+ Mesh *meshes; // The output meshes, corresponding to each AddMesh call.
+ float *utilization; // Normalized atlas texel utilization array. E.g. a value of 0.8 means 20% empty space. atlasCount in length.
+ float texelsPerUnit; // Equal to PackOptions texelsPerUnit if texelsPerUnit > 0, otherwise an estimated value to match PackOptions resolution.
+ uint32_t *image;
};
-struct AddMeshErrorCode
+// Create an empty atlas.
+Atlas *Create();
+
+void Destroy(Atlas *atlas);
+
+struct IndexFormat
{
enum Enum
{
- Success,
- AlreadyAddedEdge, // index0 and index1 are the edge indices
- DegenerateColocalEdge, // index0 and index1 are the edge indices
- DegenerateEdge, // index0 and index1 are the edge indices
- DuplicateEdge, // index0 and index1 are the edge indices
- IndexOutOfRange, // index0 is the index
- InvalidIndexCount, // not evenly divisible by 3 - expecting triangles
- ZeroAreaFace,
- ZeroLengthEdge // index0 and index1 are the edge indices
+ UInt16,
+ UInt32
};
};
-struct AddMeshError
+// Input mesh declaration.
+struct MeshDecl
{
- AddMeshErrorCode::Enum code;
- uint32_t face;
- uint32_t index0, index1;
+ uint32_t vertexCount = 0;
+ const void *vertexPositionData = nullptr;
+ uint32_t vertexPositionStride = 0;
+ const void *vertexNormalData = nullptr; // optional
+ uint32_t vertexNormalStride = 0; // optional
+ const void *vertexUvData = nullptr; // optional. The input UVs are provided as a hint to the chart generator.
+ uint32_t vertexUvStride = 0; // optional
+ uint32_t indexCount = 0;
+ const void *indexData = nullptr; // optional
+ int32_t indexOffset = 0; // optional. Add this offset to all indices.
+ IndexFormat::Enum indexFormat = IndexFormat::UInt16;
+
+ // Optional. indexCount / 3 (triangle count) in length.
+ // Don't atlas faces set to true. Ignored faces still exist in the output meshes, Vertex uv is set to (0, 0) and Vertex atlasIndex to -1.
+ const bool *faceIgnoreData = nullptr;
+
+ // Vertex positions within epsilon distance of each other are considered colocal.
+ float epsilon = 1.192092896e-07F;
};
-struct IndexFormat
+struct AddMeshError
{
enum Enum
{
- HalfFloat,
- Float
+ Success, // No error.
+ Error, // Unspecified error.
+ IndexOutOfRange, // An index is >= MeshDecl vertexCount.
+ InvalidIndexCount // Not evenly divisible by 3 - expecting triangles.
};
};
-struct InputMesh
-{
- uint32_t vertexCount;
- const void *vertexPositionData;
- uint32_t vertexPositionStride;
- const void *vertexNormalData; // optional
- uint32_t vertexNormalStride; // optional
-
- // optional
- // The input UVs are provided as a hint to the chart generator.
- const void *vertexUvData;
- uint32_t vertexUvStride;
+// Add a mesh to the atlas. MeshDecl data is copied, so it can be freed after AddMesh returns.
+AddMeshError::Enum AddMesh(Atlas *atlas, const MeshDecl &meshDecl, uint32_t meshCountHint = 0);
- uint32_t indexCount;
- const void *indexData;
- IndexFormat::Enum indexFormat;
+// Wait for AddMesh async processing to finish. ComputeCharts / Generate call this internally.
+void AddMeshJoin(Atlas *atlas);
- // optional. indexCount / 3 in length.
- // Charter also uses material boundaries as a hint to cut charts.
- const uint16_t *faceMaterialData;
+struct UvMeshDecl
+{
+ uint32_t vertexCount = 0;
+ uint32_t vertexStride = 0;
+ const void *vertexUvData = nullptr;
+ uint32_t indexCount = 0;
+ const void *indexData = nullptr; // optional
+ int32_t indexOffset = 0; // optional. Add this offset to all indices.
+ IndexFormat::Enum indexFormat = IndexFormat::UInt16;
+ const uint32_t *faceMaterialData = nullptr; // Optional. Faces with different materials won't be assigned to the same chart. Must be indexCount / 3 in length.
+ bool rotateCharts = true;
};
-struct OutputChart
+AddMeshError::Enum AddUvMesh(Atlas *atlas, const UvMeshDecl &decl);
+
+struct ChartOptions
{
- uint32_t *indexArray;
- uint32_t indexCount;
+ float maxChartArea = 0.0f; // Don't grow charts to be larger than this. 0 means no limit.
+ float maxBoundaryLength = 0.0f; // Don't grow charts to have a longer boundary than this. 0 means no limit.
+
+ // Weights determine chart growth. Higher weights mean higher cost for that metric.
+ float proxyFitMetricWeight = 2.0f; // Angle between face and average chart normal.
+ float roundnessMetricWeight = 0.01f;
+ float straightnessMetricWeight = 6.0f;
+ float normalSeamMetricWeight = 4.0f; // If > 1000, normal seams are fully respected.
+ float textureSeamMetricWeight = 0.5f;
+
+ float maxThreshold = 2.0f; // If total of all metrics * weights > maxThreshold, don't grow chart. Lower values result in more charts.
+ uint32_t growFaceCount = 32; // Grow this many faces at a time.
+ uint32_t maxIterations = 1; // Number of iterations of the chart growing and seeding phases. Higher values result in better charts.
};
-struct OutputVertex
+// Call after all AddMesh calls. Can be called multiple times to recompute charts with different options.
+void ComputeCharts(Atlas *atlas, ChartOptions chartOptions = ChartOptions());
+
+// Custom parameterization function. texcoords initial values are an orthogonal parameterization.
+typedef void (*ParameterizeFunc)(const float *positions, float *texcoords, uint32_t vertexCount, const uint32_t *indices, uint32_t indexCount);
+
+// Call after ComputeCharts. Can be called multiple times to re-parameterize charts with a different ParameterizeFunc.
+void ParameterizeCharts(Atlas *atlas, ParameterizeFunc func = nullptr);
+
+struct PackOptions
{
- float uv[2];
- uint32_t xref; // Index of input vertex from which this output vertex originated.
+ // Slower, but gives the best result. If false, use random chart placement.
+ bool bruteForce = false;
+
+ // Create Atlas::image
+ bool createImage = false;
+
+ // Unit to texel scale. e.g. a 1x1 quad with texelsPerUnit of 32 will take up approximately 32x32 texels in the atlas.
+ // If 0, an estimated value will be calculated to approximately match the given resolution.
+ // If resolution is also 0, the estimated value will approximately match a 1024x1024 atlas.
+ float texelsPerUnit = 0.0f;
+
+ // If 0, generate a single atlas with texelsPerUnit determining the final resolution.
+ // If not 0, and texelsPerUnit is not 0, generate one or more atlases with that exact resolution.
+ // If not 0, and texelsPerUnit is 0, texelsPerUnit is estimated to approximately match the resolution.
+ uint32_t resolution = 0;
+
+ // Charts larger than this will be scaled down.
+ uint32_t maxChartSize = 1024;
+
+ // Align charts to 4x4 blocks. Also improves packing speed, since there are fewer possible chart locations to consider.
+ bool blockAlign = false;
+
+ // Number of pixels to pad charts with.
+ uint32_t padding = 0;
};
-struct OutputMesh
+// Call after ParameterizeCharts. Can be called multiple times to re-pack charts with different options.
+void PackCharts(Atlas *atlas, PackOptions packOptions = PackOptions());
+
+// Equivalent to calling ComputeCharts, ParameterizeCharts and PackCharts in sequence. Can be called multiple times to regenerate with different options.
+void Generate(Atlas *atlas, ChartOptions chartOptions = ChartOptions(), ParameterizeFunc paramFunc = nullptr, PackOptions packOptions = PackOptions());
+
+// Progress tracking.
+struct ProgressCategory
{
- OutputChart *chartArray;
- uint32_t chartCount;
- uint32_t *indexArray;
- uint32_t indexCount;
- OutputVertex *vertexArray;
- uint32_t vertexCount;
+ enum Enum
+ {
+ AddMesh,
+ ComputeCharts,
+ ParameterizeCharts,
+ PackCharts,
+ BuildOutputMeshes
+ };
};
-void SetPrint(PrintFunc print);
-Atlas *Create();
-void Destroy(Atlas *atlas);
-// useColocalVertices - generates fewer charts (good), but is more sensitive to bad geometry.
-AddMeshError AddMesh(Atlas *atlas, const InputMesh &mesh, bool useColocalVertices = true);
-void Generate(Atlas *atlas, CharterOptions charterOptions = CharterOptions(), PackerOptions packerOptions = PackerOptions());
-uint32_t GetWidth(const Atlas *atlas);
-uint32_t GetHeight(const Atlas *atlas);
-uint32_t GetNumCharts(const Atlas *atlas);
-const OutputMesh * const *GetOutputMeshes(const Atlas *atlas);
-const char *StringForEnum(AddMeshErrorCode::Enum error);
+// May be called from any thread. Return false to cancel.
+typedef bool (*ProgressFunc)(ProgressCategory::Enum category, int progress, void *userData);
+
+void SetProgressCallback(Atlas *atlas, ProgressFunc progressFunc = nullptr, void *progressUserData = nullptr);
+
+// Custom memory allocation.
+typedef void *(*ReallocFunc)(void *, size_t);
+void SetRealloc(ReallocFunc reallocFunc);
+
+// Custom print function.
+typedef int (*PrintFunc)(const char *, ...);
+void SetPrint(PrintFunc print, bool verbose);
+
+// Helper functions for error messages.
+const char *StringForEnum(AddMeshError::Enum error);
+const char *StringForEnum(ProgressCategory::Enum category);
} // namespace xatlas
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 21:24:38 +0000