diff --git a/src/ReDIVA/meshoptimizer/meshoptimizer.h b/src/ReDIVA/meshoptimizer/meshoptimizer.h deleted file mode 100644 index 3cfae6f3..00000000 --- a/src/ReDIVA/meshoptimizer/meshoptimizer.h +++ /dev/null @@ -1,144 +0,0 @@ -/** - * meshoptimizer - version 0.18 - * - * Copyright (C) 2016-2023, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com) - * Report bugs and download new versions at https://github.com/zeux/meshoptimizer - * - * This library is distributed under the MIT License. See notice at the end of this file. - */ -#pragma once - -#include -#include - -/* Version macro; major * 1000 + minor * 10 + patch */ -#define MESHOPTIMIZER_VERSION 180 /* 0.18 */ - -/* If no API is defined, assume default */ -#ifndef MESHOPTIMIZER_API -#define MESHOPTIMIZER_API -#endif - -/* Set the calling-convention for alloc/dealloc function pointers */ -#ifndef MESHOPTIMIZER_ALLOC_CALLCONV -#ifdef _MSC_VER -#define MESHOPTIMIZER_ALLOC_CALLCONV __cdecl -#else -#define MESHOPTIMIZER_ALLOC_CALLCONV -#endif -#endif - -/* Experimental APIs have unstable interface and might have implementation that's not fully tested or optimized */ -#define MESHOPTIMIZER_EXPERIMENTAL MESHOPTIMIZER_API - -/* C interface */ -#ifdef __cplusplus -extern "C" { -#endif - -/** - * Vertex attribute stream - * Each element takes size bytes, beginning at data, with stride controlling the spacing between successive elements (stride >= size). - */ -struct meshopt_Stream -{ - const void* data; - size_t size; - size_t stride; -}; - -/** - * Mesh stripifier - * Converts a previously vertex cache optimized triangle list to triangle strip, stitching strips using restart index or degenerate triangles - * Returns the number of indices in the resulting strip, with destination containing new index data - * For maximum efficiency the index buffer being converted has to be optimized for vertex cache first. - * Using restart indices can result in ~10% smaller index buffers, but on some GPUs restart indices may result in decreased performance. - * - * destination must contain enough space for the target index buffer, worst case can be computed with meshopt_stripifyBound - * restart_index should be 0xffff or 0xffffffff depending on index size, or 0 to use degenerate triangles - */ -MESHOPTIMIZER_API size_t meshopt_stripify(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, unsigned int restart_index); -MESHOPTIMIZER_API size_t meshopt_stripifyBound(size_t index_count); - -/** - * Mesh unstripifier - * Converts a triangle strip to a triangle list - * Returns the number of indices in the resulting list, with destination containing new index data - * - * destination must contain enough space for the target index buffer, worst case can be computed with meshopt_unstripifyBound - */ -MESHOPTIMIZER_API size_t meshopt_unstripify(unsigned int* destination, const unsigned int* indices, size_t index_count, unsigned int restart_index); -MESHOPTIMIZER_API size_t meshopt_unstripifyBound(size_t index_count); - -#ifdef __cplusplus -} /* extern "C" */ -#endif - -/* Internal implementation helpers */ -#ifdef __cplusplus -class meshopt_Allocator -{ -public: - template - struct StorageT - { - static void* (MESHOPTIMIZER_ALLOC_CALLCONV *allocate)(size_t); - static void (MESHOPTIMIZER_ALLOC_CALLCONV *deallocate)(void*); - }; - - typedef StorageT Storage; - - meshopt_Allocator() - : blocks() - , count(0) - { - } - - ~meshopt_Allocator() - { - for (size_t i = count; i > 0; --i) - Storage::deallocate(blocks[i - 1]); - } - - template T* allocate(size_t size) - { - assert(count < sizeof(blocks) / sizeof(blocks[0])); - T* result = static_cast(Storage::allocate(size > size_t(-1) / sizeof(T) ? size_t(-1) : size * sizeof(T))); - blocks[count++] = result; - return result; - } - -private: - void* blocks[24]; - size_t count; -}; - -// This makes sure that allocate/deallocate are lazily generated in translation units that need them and are deduplicated by the linker -template void* (MESHOPTIMIZER_ALLOC_CALLCONV *meshopt_Allocator::StorageT::allocate)(size_t) = operator new; -template void (MESHOPTIMIZER_ALLOC_CALLCONV *meshopt_Allocator::StorageT::deallocate)(void*) = operator delete; -#endif - -/** - * Copyright (c) 2016-2023 Arseny Kapoulkine - * - * 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. - */ diff --git a/src/ReDIVA/meshoptimizer/stripifier.cpp b/src/ReDIVA/meshoptimizer/stripifier.cpp deleted file mode 100644 index 8ce17ef3..00000000 --- a/src/ReDIVA/meshoptimizer/stripifier.cpp +++ /dev/null @@ -1,295 +0,0 @@ -// This file is part of meshoptimizer library; see meshoptimizer.h for version/license details -#include "meshoptimizer.h" - -#include -#include -#include - -// This work is based on: -// Francine Evans, Steven Skiena and Amitabh Varshney. Optimizing Triangle Strips for Fast Rendering. 1996 -namespace meshopt -{ - -static unsigned int findStripFirst(const unsigned int buffer[][3], unsigned int buffer_size, const unsigned int* valence) -{ - unsigned int index = 0; - unsigned int iv = ~0u; - - for (size_t i = 0; i < buffer_size; ++i) - { - unsigned int va = valence[buffer[i][0]], vb = valence[buffer[i][1]], vc = valence[buffer[i][2]]; - unsigned int v = (va < vb && va < vc) ? va : (vb < vc) ? vb : vc; - - if (v < iv) - { - index = unsigned(i); - iv = v; - } - } - - return index; -} - -static int findStripNext(const unsigned int buffer[][3], unsigned int buffer_size, unsigned int e0, unsigned int e1) -{ - for (size_t i = 0; i < buffer_size; ++i) - { - unsigned int a = buffer[i][0], b = buffer[i][1], c = buffer[i][2]; - - if (e0 == a && e1 == b) - return (int(i) << 2) | 2; - else if (e0 == b && e1 == c) - return (int(i) << 2) | 0; - else if (e0 == c && e1 == a) - return (int(i) << 2) | 1; - } - - return -1; -} - -} // namespace meshopt - -size_t meshopt_stripify(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, unsigned int restart_index) -{ - assert(destination != indices); - assert(index_count % 3 == 0); - - using namespace meshopt; - - meshopt_Allocator allocator; - - const size_t buffer_capacity = 8; - - unsigned int buffer[buffer_capacity][3] = {}; - unsigned int buffer_size = 0; - - size_t index_offset = 0; - - unsigned int strip[2] = {}; - unsigned int parity = 0; - - size_t strip_size = 0; - - // compute vertex valence; this is used to prioritize starting triangle for strips - unsigned int* valence = allocator.allocate(vertex_count); - memset(valence, 0, vertex_count * sizeof(unsigned int)); - - for (size_t i = 0; i < index_count; ++i) - { - unsigned int index = indices[i]; - assert(index < vertex_count); - - valence[index]++; - } - - int next = -1; - - while (buffer_size > 0 || index_offset < index_count) - { - assert(next < 0 || (size_t(next >> 2) < buffer_size && (next & 3) < 3)); - - // fill triangle buffer - while (buffer_size < buffer_capacity && index_offset < index_count) - { - buffer[buffer_size][0] = indices[index_offset + 0]; - buffer[buffer_size][1] = indices[index_offset + 1]; - buffer[buffer_size][2] = indices[index_offset + 2]; - - buffer_size++; - index_offset += 3; - } - - assert(buffer_size > 0); - - if (next >= 0) - { - unsigned int i = next >> 2; - unsigned int a = buffer[i][0], b = buffer[i][1], c = buffer[i][2]; - unsigned int v = buffer[i][next & 3]; - - // ordered removal from the buffer - memmove(buffer[i], buffer[i + 1], (buffer_size - i - 1) * sizeof(buffer[0])); - buffer_size--; - - // update vertex valences for strip start heuristic - valence[a]--; - valence[b]--; - valence[c]--; - - // find next triangle (note that edge order flips on every iteration) - // in some cases we need to perform a swap to pick a different outgoing triangle edge - // for [a b c], the default strip edge is [b c], but we might want to use [a c] - int cont = findStripNext(buffer, buffer_size, parity ? strip[1] : v, parity ? v : strip[1]); - int swap = cont < 0 ? findStripNext(buffer, buffer_size, parity ? v : strip[0], parity ? strip[0] : v) : -1; - - if (cont < 0 && swap >= 0) - { - // [a b c] => [a b a c] - destination[strip_size++] = strip[0]; - destination[strip_size++] = v; - - // next strip has same winding - // ? a b => b a v - strip[1] = v; - - next = swap; - } - else - { - // emit the next vertex in the strip - destination[strip_size++] = v; - - // next strip has flipped winding - strip[0] = strip[1]; - strip[1] = v; - parity ^= 1; - - next = cont; - } - } - else - { - // if we didn't find anything, we need to find the next new triangle - // we use a heuristic to maximize the strip length - unsigned int i = findStripFirst(buffer, buffer_size, &valence[0]); - unsigned int a = buffer[i][0], b = buffer[i][1], c = buffer[i][2]; - - // ordered removal from the buffer - memmove(buffer[i], buffer[i + 1], (buffer_size - i - 1) * sizeof(buffer[0])); - buffer_size--; - - // update vertex valences for strip start heuristic - valence[a]--; - valence[b]--; - valence[c]--; - - // we need to pre-rotate the triangle so that we will find a match in the existing buffer on the next iteration - int ea = findStripNext(buffer, buffer_size, c, b); - int eb = findStripNext(buffer, buffer_size, a, c); - int ec = findStripNext(buffer, buffer_size, b, a); - - // in some cases we can have several matching edges; since we can pick any edge, we pick the one with the smallest - // triangle index in the buffer. this reduces the effect of stripification on ACMR and additionally - for unclear - // reasons - slightly improves the stripification efficiency - int mine = INT_MAX; - mine = (ea >= 0 && mine > ea) ? ea : mine; - mine = (eb >= 0 && mine > eb) ? eb : mine; - mine = (ec >= 0 && mine > ec) ? ec : mine; - - if (ea == mine) - { - // keep abc - next = ea; - } - else if (eb == mine) - { - // abc -> bca - unsigned int t = a; - a = b, b = c, c = t; - - next = eb; - } - else if (ec == mine) - { - // abc -> cab - unsigned int t = c; - c = b, b = a, a = t; - - next = ec; - } - - if (restart_index) - { - if (strip_size) - destination[strip_size++] = restart_index; - - destination[strip_size++] = a; - destination[strip_size++] = b; - destination[strip_size++] = c; - - // new strip always starts with the same edge winding - strip[0] = b; - strip[1] = c; - parity = 1; - } - else - { - if (strip_size) - { - // connect last strip using degenerate triangles - destination[strip_size++] = strip[1]; - destination[strip_size++] = a; - } - - // note that we may need to flip the emitted triangle based on parity - // we always end up with outgoing edge "cb" in the end - unsigned int e0 = parity ? c : b; - unsigned int e1 = parity ? b : c; - - destination[strip_size++] = a; - destination[strip_size++] = e0; - destination[strip_size++] = e1; - - strip[0] = e0; - strip[1] = e1; - parity ^= 1; - } - } - } - - return strip_size; -} - -size_t meshopt_stripifyBound(size_t index_count) -{ - assert(index_count % 3 == 0); - - // worst case without restarts is 2 degenerate indices and 3 indices per triangle - // worst case with restarts is 1 restart index and 3 indices per triangle - return (index_count / 3) * 5; -} - -size_t meshopt_unstripify(unsigned int* destination, const unsigned int* indices, size_t index_count, unsigned int restart_index) -{ - assert(destination != indices); - - size_t offset = 0; - size_t start = 0; - - for (size_t i = 0; i < index_count; ++i) - { - if (restart_index && indices[i] == restart_index) - { - start = i + 1; - } - else if (i - start >= 2) - { - unsigned int a = indices[i - 2], b = indices[i - 1], c = indices[i]; - - // flip winding for odd triangles - if ((i - start) & 1) - { - unsigned int t = a; - a = b, b = t; - } - - // although we use restart indices, strip swaps still produce degenerate triangles, so skip them - if (a != b && a != c && b != c) - { - destination[offset + 0] = a; - destination[offset + 1] = b; - destination[offset + 2] = c; - offset += 3; - } - } - } - - return offset; -} - -size_t meshopt_unstripifyBound(size_t index_count) -{ - assert(index_count == 0 || index_count >= 3); - - return (index_count == 0) ? 0 : (index_count - 2) * 3; -}