Revision control
++ /**
++ * meshoptimizer - version 1.2
++ *
++ * Copyright (C) 2016-2026, 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 <assert.h>
++ #include <stddef.h>
++
++ /* Version macro; major * 1000 + minor * 10 + patch */
++ #define MESHOPTIMIZER_VERSION 1020 /* 1.2 */
++
++ /* 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 */
++ #ifndef MESHOPTIMIZER_EXPERIMENTAL
++ #define MESHOPTIMIZER_EXPERIMENTAL MESHOPTIMIZER_API
++ #endif
++
++ /* 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;
++ };
++
++ /**
++ * Generates a vertex remap table from the vertex buffer and an optional index buffer and returns number of unique vertices
++ * As a result, all vertices that are binary equivalent map to the same (new) location, with no gaps in the resulting sequence.
++ * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer/meshopt_remapIndexBuffer.
++ * Note that binary equivalence considers all vertex_size bytes, including padding which should be zero-initialized.
++ *
++ * destination must contain enough space for the resulting remap table (vertex_count elements)
++ * indices can be NULL if the input is unindexed
++ */
++ MESHOPTIMIZER_API size_t meshopt_generateVertexRemap(unsigned int* destination, const unsigned int* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
++
++ /**
++ * Generates a vertex remap table from multiple vertex streams and an optional index buffer and returns number of unique vertices
++ * As a result, all vertices that are binary equivalent map to the same (new) location, with no gaps in the resulting sequence.
++ * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer/meshopt_remapIndexBuffer.
++ * To remap vertex buffers, you will need to call meshopt_remapVertexBuffer for each vertex stream.
++ * Note that binary equivalence considers all size bytes in each stream, including padding which should be zero-initialized.
++ *
++ * destination must contain enough space for the resulting remap table (vertex_count elements)
++ * indices can be NULL if the input is unindexed
++ * stream_count must be <= 16
++ */
++ MESHOPTIMIZER_API size_t meshopt_generateVertexRemapMulti(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
++
++ /**
++ * Generates a vertex remap table from the vertex buffer and an optional index buffer and returns number of unique vertices
++ * As a result, all vertices that are equivalent map to the same (new) location, with no gaps in the resulting sequence.
++ * Equivalence is checked in two steps: vertex positions are compared for equality, and then the user-specified equality function is called (if provided).
++ * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer/meshopt_remapIndexBuffer.
++ *
++ * destination must contain enough space for the resulting remap table (vertex_count elements)
++ * indices can be NULL if the input is unindexed
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * callback can be NULL if no additional equality check is needed; otherwise, it should return 1 if vertices with specified indices are equivalent and 0 if they are not
++ */
++ MESHOPTIMIZER_API size_t meshopt_generateVertexRemapCustom(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, int (*callback)(void*, unsigned int, unsigned int), void* context);
++
++ /**
++ * Generates vertex buffer from the source vertex buffer and remap table generated by meshopt_generateVertexRemap
++ *
++ * destination must contain enough space for the resulting vertex buffer (unique_vertex_count elements, returned by meshopt_generateVertexRemap)
++ * vertex_count should be the initial vertex count and not the value returned by meshopt_generateVertexRemap
++ */
++ MESHOPTIMIZER_API void meshopt_remapVertexBuffer(void* destination, const void* vertices, size_t vertex_count, size_t vertex_size, const unsigned int* remap);
++
++ /**
++ * Generate index buffer from the source index buffer and remap table generated by meshopt_generateVertexRemap
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ * indices can be NULL if the input is unindexed
++ */
++ MESHOPTIMIZER_API void meshopt_remapIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const unsigned int* remap);
++
++ /**
++ * Experimental: Filter out redundant triangles from the index buffer and return the number of remaining indices
++ * Triangles are considered redundant if they are degenerate (two vertices have the same vertex key) or duplicate (matching triangle was present earlier).
++ * First vertex_size bytes of every vertex are compared for equality; typically vertex_size should be set to the size of the position attribute.
++ * Note that duplicate triangles with opposite windings are preserved, as they may be needed for double-sided rendering.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ */
++ MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_filterIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride);
++
++ /**
++ * Experimental: Filter out redundant triangles from the index buffer and return the number of remaining indices
++ * Triangles are considered redundant if they are degenerate (two vertices have the same vertex key) or duplicate (matching triangle was present earlier).
++ * All bytes in specified streams are compared for equality; streams should include attributes relevant for position transform (e.g. bone influences).
++ * Note that duplicate triangles with opposite windings are preserved, as they may be needed for double-sided rendering.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ * stream_count must be <= 16
++ */
++ MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_filterIndexBufferMulti(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
++
++ /**
++ * Generate index buffer that can be used for more efficient rendering when only a subset of the vertex attributes is necessary
++ * All vertices that are binary equivalent (wrt first vertex_size bytes) map to the first vertex in the original vertex buffer.
++ * This makes it possible to use the index buffer for Z pre-pass or shadowmap rendering, while using the original index buffer for regular rendering.
++ * Note that binary equivalence considers all vertex_size bytes, including padding which should be zero-initialized.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ */
++ MESHOPTIMIZER_API void meshopt_generateShadowIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride);
++
++ /**
++ * Generate index buffer that can be used for more efficient rendering when only a subset of the vertex attributes is necessary
++ * All vertices that are binary equivalent (wrt specified streams) map to the first vertex in the original vertex buffer.
++ * This makes it possible to use the index buffer for Z pre-pass or shadowmap rendering, while using the original index buffer for regular rendering.
++ * Note that binary equivalence considers all size bytes in each stream, including padding which should be zero-initialized.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ * stream_count must be <= 16
++ */
++ MESHOPTIMIZER_API void meshopt_generateShadowIndexBufferMulti(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
++
++ /**
++ * Generates a remap table that maps all vertices with the same position to the same (existing) index.
++ * Similarly to meshopt_generateShadowIndexBuffer, this can be helpful to pre-process meshes for position-only rendering.
++ * This can also be used to implement algorithms that require positional-only connectivity, such as hierarchical simplification.
++ *
++ * destination must contain enough space for the resulting remap table (vertex_count elements)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API void meshopt_generatePositionRemap(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ /**
++ * Generate index buffer that can be used as a geometry shader input with triangle adjacency topology
++ * Each triangle is converted into a 6-vertex patch with the following layout:
++ * - 0, 2, 4: original triangle vertices
++ * - 1, 3, 5: vertices adjacent to edges 02, 24 and 40
++ * The resulting patch can be rendered with geometry shaders using e.g. VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY.
++ * This can be used to implement algorithms like silhouette detection/expansion and other forms of GS-driven rendering.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count*2 elements)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API void meshopt_generateAdjacencyIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ /**
++ * Generate index buffer that can be used for PN-AEN tessellation with crack-free displacement
++ * Each triangle is converted into a 12-vertex patch with the following layout:
++ * - 0, 1, 2: original triangle vertices
++ * - 3, 4: opposing edge for edge 0, 1
++ * - 5, 6: opposing edge for edge 1, 2
++ * - 7, 8: opposing edge for edge 2, 0
++ * - 9, 10, 11: dominant vertices for corners 0, 1, 2
++ * The resulting patch can be rendered with hardware tessellation using PN-AEN and displacement mapping.
++ * See "Tessellation on Any Budget" (John McDonald, GDC 2011) for implementation details.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count*4 elements)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API void meshopt_generateTessellationIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ /**
++ * Generate index buffer that can be used for visibility buffer rendering and returns the size of the reorder table
++ * Each triangle's provoking vertex index is equal to primitive id; this allows passing it to the fragment shader using flat/nointerpolation attribute.
++ * This is important for performance on hardware where primitive id can't be accessed efficiently in fragment shader.
++ * The reorder table stores the original vertex id for each vertex in the new index buffer, and should be used in the vertex shader to load vertex data.
++ * The provoking vertex is assumed to be the first vertex in the triangle; if this is not the case (OpenGL), rotate each triangle (abc -> bca) before rendering.
++ * For maximum efficiency the input index buffer should be optimized for vertex cache first.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ * reorder must contain enough space for the worst case reorder table (vertex_count + index_count/3 elements)
++ */
++ MESHOPTIMIZER_API size_t meshopt_generateProvokingIndexBuffer(unsigned int* destination, unsigned int* reorder, const unsigned int* indices, size_t index_count, size_t vertex_count);
++
++ /**
++ * Vertex transform cache optimizer
++ * Reorders indices to reduce the number of GPU vertex shader invocations
++ * If index buffer contains multiple ranges for multiple draw calls, this function needs to be called on each range individually.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ */
++ MESHOPTIMIZER_API void meshopt_optimizeVertexCache(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count);
++
++ /**
++ * Vertex transform cache optimizer for strip-like caches
++ * Produces inferior results to meshopt_optimizeVertexCache from the GPU vertex cache perspective
++ * However, the resulting index order is more optimal if the goal is to reduce the triangle strip length or improve compression efficiency
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ */
++ MESHOPTIMIZER_API void meshopt_optimizeVertexCacheStrip(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count);
++
++ /**
++ * Vertex transform cache optimizer for FIFO caches
++ * Reorders indices to reduce the number of GPU vertex shader invocations
++ * Generally takes ~3x less time to optimize meshes but produces inferior results compared to meshopt_optimizeVertexCache
++ * If index buffer contains multiple ranges for multiple draw calls, this function needs to be called on each range individually.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ * cache_size should be less than the actual GPU cache size to avoid cache thrashing
++ */
++ MESHOPTIMIZER_API void meshopt_optimizeVertexCacheFifo(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, unsigned int cache_size);
++
++ /**
++ * Overdraw optimizer
++ * Reorders indices to reduce the number of GPU vertex shader invocations and the pixel overdraw
++ * If index buffer contains multiple ranges for multiple draw calls, this function needs to be called on each range individually.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ * indices must contain index data that is the result of meshopt_optimizeVertexCache (*not* the original mesh indices!)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * threshold indicates how much the overdraw optimizer can degrade vertex cache efficiency (1.05 = up to 5%) to reduce overdraw more efficiently
++ */
++ MESHOPTIMIZER_API void meshopt_optimizeOverdraw(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold);
++
++ /**
++ * Vertex fetch cache optimizer
++ * Reorders vertices and changes indices to reduce the amount of GPU memory fetches during vertex processing
++ * Returns the number of unique vertices, which is the same as input vertex count unless some vertices are unused
++ * This function works for a single vertex stream; for multiple vertex streams, use meshopt_optimizeVertexFetchRemap + meshopt_remapVertexBuffer for each stream.
++ *
++ * destination must contain enough space for the resulting vertex buffer (vertex_count elements)
++ * indices is used both as an input and as an output index buffer
++ */
++ MESHOPTIMIZER_API size_t meshopt_optimizeVertexFetch(void* destination, unsigned int* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
++
++ /**
++ * Vertex fetch cache optimizer
++ * Generates vertex remap to reduce the amount of GPU memory fetches during vertex processing
++ * Returns the number of unique vertices, which is the same as input vertex count unless some vertices are unused
++ * The resulting remap table should be used to reorder vertex/index buffers using meshopt_remapVertexBuffer/meshopt_remapIndexBuffer
++ *
++ * destination must contain enough space for the resulting remap table (vertex_count elements)
++ */
++ MESHOPTIMIZER_API size_t meshopt_optimizeVertexFetchRemap(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count);
++
++ /**
++ * Index buffer encoder
++ * Encodes index data into an array of bytes that is generally much smaller (<1.5 bytes/triangle) and compresses better (<1 bytes/triangle) compared to original.
++ * Input index buffer must represent a triangle list.
++ * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
++ * For maximum efficiency the index buffer being encoded has to be optimized for vertex cache and vertex fetch first.
++ *
++ * buffer must contain enough space for the encoded index buffer (use meshopt_encodeIndexBufferBound to compute worst case size)
++ */
++ MESHOPTIMIZER_API size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const unsigned int* indices, size_t index_count);
++ MESHOPTIMIZER_API size_t meshopt_encodeIndexBufferBound(size_t index_count, size_t vertex_count);
++
++ /**
++ * Set index encoder format version (defaults to 1)
++ * This function is not thread safe and must not be called concurrently with meshopt_encodeIndexBuffer/meshopt_encodeIndexSequence.
++ *
++ * version must specify the data format version to encode; valid values are 0 (decodable by all library versions) and 1 (decodable by 0.14+)
++ */
++ MESHOPTIMIZER_API void meshopt_encodeIndexVersion(int version);
++
++ /**
++ * Index buffer decoder
++ * Decodes index data from an array of bytes generated by meshopt_encodeIndexBuffer
++ * Returns 0 if decoding was successful, and an error code otherwise
++ * The decoder is safe to use for untrusted input, but it may produce garbage data (e.g. out of range indices).
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ */
++ MESHOPTIMIZER_API int meshopt_decodeIndexBuffer(void* destination, size_t index_count, size_t index_size, const unsigned char* buffer, size_t buffer_size);
++
++ /**
++ * Get encoded index format version
++ * Returns format version of the encoded index buffer/sequence, or -1 if the buffer header is invalid
++ * Note that a non-negative value doesn't guarantee that the buffer will be decoded correctly if the input is malformed.
++ */
++ MESHOPTIMIZER_API int meshopt_decodeIndexVersion(const unsigned char* buffer, size_t buffer_size);
++
++ /**
++ * Index sequence encoder
++ * Encodes index sequence into an array of bytes that is generally smaller and compresses better compared to original.
++ * Input index sequence can represent arbitrary topology; for triangle lists meshopt_encodeIndexBuffer is likely to be better.
++ * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
++ *
++ * buffer must contain enough space for the encoded index sequence (use meshopt_encodeIndexSequenceBound to compute worst case size)
++ */
++ MESHOPTIMIZER_API size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const unsigned int* indices, size_t index_count);
++ MESHOPTIMIZER_API size_t meshopt_encodeIndexSequenceBound(size_t index_count, size_t vertex_count);
++
++ /**
++ * Index sequence decoder
++ * Decodes index data from an array of bytes generated by meshopt_encodeIndexSequence
++ * Returns 0 if decoding was successful, and an error code otherwise
++ * The decoder is safe to use for untrusted input, but it may produce garbage data (e.g. out of range indices).
++ *
++ * destination must contain enough space for the resulting index sequence (index_count elements)
++ */
++ MESHOPTIMIZER_API int meshopt_decodeIndexSequence(void* destination, size_t index_count, size_t index_size, const unsigned char* buffer, size_t buffer_size);
++
++ /**
++ * Meshlet encoder
++ * Encodes meshlet data into an array of bytes that is generally smaller and compresses better compared to original.
++ * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
++ * This function encodes a single meshlet; when encoding multiple meshlets, additional headers may be necessary to store vertex/triangle count and encoded size.
++ * For maximum efficiency the meshlet being encoded should be optimized using meshopt_optimizeMeshletLevel with level 1+ (3 recommended); additionally, vertex reference data should be optimized for locality (fetch).
++ *
++ * buffer must contain enough space for the encoded meshlet (use meshopt_encodeMeshletBound to compute worst case size)
++ * vertices may be NULL, in which case vertex_count must be 0 and only triangle data is encoded
++ * vertex_count and triangle_count must be <= 256.
++ */
++ MESHOPTIMIZER_API size_t meshopt_encodeMeshlet(unsigned char* buffer, size_t buffer_size, const unsigned int* vertices, size_t vertex_count, const unsigned char* triangles, size_t triangle_count);
++ MESHOPTIMIZER_API size_t meshopt_encodeMeshletBound(size_t max_vertices, size_t max_triangles);
++
++ /**
++ * Meshlet decoder
++ * Decodes meshlet data from an array of bytes generated by meshopt_encodeMeshlet
++ * Returns 0 if decoding was successful, and an error code otherwise
++ * The decoder is safe to use for untrusted input, but it may produce garbage data.
++ *
++ * vertices must contain enough space for the resulting vertex data, aligned to 4 bytes (align(vertex_count * vertex_size, 4) bytes)
++ * vertex_size must be 2 (16-bit vertex references) or 4 (32-bit vertex references)
++ * triangles must contain enough space for the resulting triangle data, aligned to 4 bytes (align(triangle_count * triangle_size, 4) bytes)
++ * triangle_size must be 3 (8-bit triangle indices) or 4 (32-bit packed triangles, stored as (a) | (b << 8) | (c << 16))
++ * vertex_count, triangle_count match those used during encoding exactly; buffer_size must be equal to the encoded size returned by meshopt_encodeMeshlet.
++ * vertices may be NULL, in which case vertex_count must be 0 and the meshlet must contain just triangle data
++ *
++ * When using "raw" decoding (meshopt_decodeMeshletRaw), both vertices and triangles should have available space further aligned to 16 bytes for efficient SIMD decoding.
++ */
++ MESHOPTIMIZER_API int meshopt_decodeMeshlet(void* vertices, size_t vertex_count, size_t vertex_size, void* triangles, size_t triangle_count, size_t triangle_size, const unsigned char* buffer, size_t buffer_size);
++ MESHOPTIMIZER_API int meshopt_decodeMeshletRaw(unsigned int* vertices, size_t vertex_count, unsigned int* triangles, size_t triangle_count, const unsigned char* buffer, size_t buffer_size);
++
++ /**
++ * Vertex buffer encoder
++ * Encodes vertex data into an array of bytes that is generally smaller and compresses better compared to original.
++ * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
++ * This function works for a single vertex stream; for multiple vertex streams, call meshopt_encodeVertexBuffer for each stream.
++ * Note that all vertex_size bytes of each vertex are encoded verbatim, including padding which should be zero-initialized.
++ * For maximum efficiency the vertex buffer being encoded has to be quantized and optimized for locality of reference (cache/fetch) first.
++ *
++ * buffer must contain enough space for the encoded vertex buffer (use meshopt_encodeVertexBufferBound to compute worst case size)
++ * vertex_size must be a multiple of 4 (and <= 256)
++ */
++ MESHOPTIMIZER_API size_t meshopt_encodeVertexBuffer(unsigned char* buffer, size_t buffer_size, const void* vertices, size_t vertex_count, size_t vertex_size);
++ MESHOPTIMIZER_API size_t meshopt_encodeVertexBufferBound(size_t vertex_count, size_t vertex_size);
++
++ /**
++ * Vertex buffer encoder
++ * Encodes vertex data just like meshopt_encodeVertexBuffer, but allows to override compression level.
++ * For compression level to take effect, the vertex encoding version must be set to 1.
++ * The default compression level implied by meshopt_encodeVertexBuffer is 2.
++ *
++ * buffer must contain enough space for the encoded vertex buffer (use meshopt_encodeVertexBufferBound to compute worst case size)
++ * vertex_size must be a multiple of 4 (and <= 256)
++ * level should be in the range [0, 3] with 0 being the fastest and 3 being the slowest and producing the best compression ratio.
++ * version should be -1 to use the default version (specified via meshopt_encodeVertexVersion), or 0/1 to override the version; per above, level won't take effect if version is 0.
++ */
++ MESHOPTIMIZER_API size_t meshopt_encodeVertexBufferLevel(unsigned char* buffer, size_t buffer_size, const void* vertices, size_t vertex_count, size_t vertex_size, int level, int version);
++
++ /**
++ * Set vertex encoder format version (defaults to 1)
++ * This function is not thread safe and must not be called concurrently with meshopt_encodeVertexBuffer/meshopt_encodeVertexBufferLevel.
++ *
++ * version must specify the data format version to encode; valid values are 0 (decodable by all library versions) and 1 (decodable by 0.23+)
++ */
++ MESHOPTIMIZER_API void meshopt_encodeVertexVersion(int version);
++
++ /**
++ * Vertex buffer decoder
++ * Decodes vertex data from an array of bytes generated by meshopt_encodeVertexBuffer
++ * Returns 0 if decoding was successful, and an error code otherwise
++ * The decoder is safe to use for untrusted input, but it may produce garbage data.
++ *
++ * destination must contain enough space for the resulting vertex buffer (vertex_count * vertex_size bytes)
++ * vertex_size must be a multiple of 4 (and <= 256)
++ */
++ MESHOPTIMIZER_API int meshopt_decodeVertexBuffer(void* destination, size_t vertex_count, size_t vertex_size, const unsigned char* buffer, size_t buffer_size);
++
++ /**
++ * Get encoded vertex format version
++ * Returns format version of the encoded vertex buffer, or -1 if the buffer header is invalid
++ * Note that a non-negative value doesn't guarantee that the buffer will be decoded correctly if the input is malformed.
++ */
++ MESHOPTIMIZER_API int meshopt_decodeVertexVersion(const unsigned char* buffer, size_t buffer_size);
++
++ /**
++ * Vertex buffer filters
++ * These functions can be used to filter output of meshopt_decodeVertexBuffer in-place.
++ *
++ * meshopt_decodeFilterOct decodes octahedral encoding of a unit vector with K-bit signed X/Y as an input; Z must store 1.0f.
++ * Each component is stored as an 8-bit or 16-bit normalized integer; stride must be equal to 4 or 8. W is preserved as is.
++ *
++ * meshopt_decodeFilterQuat decodes 3-component quaternion encoding with K-bit component encoding and a 2-bit component index indicating which component to reconstruct.
++ * Each component is stored as a 16-bit integer; stride must be equal to 8.
++ *
++ * meshopt_decodeFilterExp decodes exponential encoding of floating-point data with 8-bit exponent and 24-bit integer mantissa as 2^E*M.
++ * Each 32-bit component is decoded in isolation; stride must be divisible by 4.
++ *
++ * meshopt_decodeFilterColor decodes RGBA colors from YCoCg (+A) color encoding where RGB is converted to YCoCg space with K-bit component encoding, and A is stored using K-1 bits.
++ * Each component is stored as an 8-bit or 16-bit normalized integer; stride must be equal to 4 or 8.
++ */
++ MESHOPTIMIZER_API void meshopt_decodeFilterOct(void* buffer, size_t count, size_t stride);
++ MESHOPTIMIZER_API void meshopt_decodeFilterQuat(void* buffer, size_t count, size_t stride);
++ MESHOPTIMIZER_API void meshopt_decodeFilterExp(void* buffer, size_t count, size_t stride);
++ MESHOPTIMIZER_API void meshopt_decodeFilterColor(void* buffer, size_t count, size_t stride);
++
++ /**
++ * Vertex buffer filter encoders
++ * These functions can be used to encode data in a format that meshopt_decodeFilter can decode
++ *
++ * meshopt_encodeFilterOct encodes unit vectors with K-bit (2 <= K <= 16) signed X/Y as an output.
++ * Each component is stored as an 8-bit or 16-bit normalized integer; stride must be equal to 4 (K <= 8) or 8 (K <= 16). Z will store 1.0f, W is preserved as is.
++ * Input data must contain 4 floats for every vector (count*4 total).
++ *
++ * meshopt_encodeFilterQuat encodes unit quaternions with K-bit (4 <= K <= 16) component encoding.
++ * Each component is stored as a 16-bit integer; stride must be equal to 8.
++ * Input data must contain 4 floats for every quaternion (count*4 total).
++ *
++ * meshopt_encodeFilterExp encodes arbitrary (finite) floating-point data with 8-bit exponent and K-bit integer mantissa (1 <= K <= 24).
++ * Exponent can be shared between all components of a given vector as defined by stride or all values of a given component; stride must be divisible by 4 (and <= 256).
++ * Input data must contain stride/4 floats for every vector (count*stride/4 total).
++ *
++ * meshopt_encodeFilterColor encodes RGBA color data by converting RGB to YCoCg color space with K-bit (2 <= K <= 16) component encoding; A is stored using K-1 bits.
++ * Each component is stored as an 8-bit or 16-bit integer; stride must be equal to 4 (K <= 8) or 8 (K <= 16).
++ * Input data must contain 4 floats for every color (count*4 total).
++ */
++ enum meshopt_EncodeExpMode
++ {
++ /* When encoding exponents, use separate values for each component (maximum quality) */
++ meshopt_EncodeExpSeparate,
++ /* When encoding exponents, use shared value for all components of each vector (better compression) */
++ meshopt_EncodeExpSharedVector,
++ /* When encoding exponents, use shared value for each component of all vectors (best compression) */
++ meshopt_EncodeExpSharedComponent,
++ /* When encoding exponents, use separate values for each component, but clamp to 0 (good quality if very small values are not important) */
++ meshopt_EncodeExpClamped,
++ };
++
++ MESHOPTIMIZER_API void meshopt_encodeFilterOct(void* destination, size_t count, size_t stride, int bits, const float* data);
++ MESHOPTIMIZER_API void meshopt_encodeFilterQuat(void* destination, size_t count, size_t stride, int bits, const float* data);
++ MESHOPTIMIZER_API void meshopt_encodeFilterExp(void* destination, size_t count, size_t stride, int bits, const float* data, enum meshopt_EncodeExpMode mode);
++ MESHOPTIMIZER_API void meshopt_encodeFilterColor(void* destination, size_t count, size_t stride, int bits, const float* data);
++
++ /**
++ * Simplification options
++ */
++ enum
++ {
++ /* Do not move vertices that are located on the topological border (vertices on triangle edges that don't have a paired triangle). Useful for simplifying portions of the larger mesh. */
++ meshopt_SimplifyLockBorder = 1 << 0,
++ /* Improve simplification performance assuming input indices are a sparse subset of the mesh. Note that error becomes relative to subset extents. */
++ meshopt_SimplifySparse = 1 << 1,
++ /* Treat error limit and resulting error as absolute instead of relative to mesh extents. */
++ meshopt_SimplifyErrorAbsolute = 1 << 2,
++ /* Remove disconnected parts of the mesh during simplification incrementally, regardless of the topological restrictions inside components. */
++ meshopt_SimplifyPrune = 1 << 3,
++ /* Produce more regular triangle sizes and shapes during simplification, at some cost to geometric and attribute quality. */
++ meshopt_SimplifyRegularize = 1 << 4,
++ /* Experimental: Allow collapses across attribute discontinuities, except for vertices that are tagged with meshopt_SimplifyVertex_Protect in vertex_lock. */
++ meshopt_SimplifyPermissive = 1 << 5,
++ /* Produce more regular triangle sizes and shapes during simplification, at a small cost to geometric and attribute quality. */
++ meshopt_SimplifyRegularizeLight = 1 << 6,
++ };
++
++ /**
++ * Simplification vertex flags/locks, for use in `vertex_lock` arrays in simplification APIs
++ */
++ enum
++ {
++ /* Do not move this vertex. */
++ meshopt_SimplifyVertex_Lock = 1 << 0,
++ /* Protect attribute discontinuity at this vertex; must be used together with meshopt_SimplifyPermissive option. */
++ meshopt_SimplifyVertex_Protect = 1 << 1,
++ /* Increase priority for this vertex, making it more likely that it's preserved during simplification. */
++ meshopt_SimplifyVertex_Priority = 1 << 2,
++ };
++
++ /**
++ * Mesh simplifier
++ * Reduces the number of triangles in the mesh, attempting to preserve mesh appearance as much as possible
++ * The algorithm tries to preserve mesh topology and can stop short of the target goal based on topology constraints or target error.
++ * If not all attributes from the input mesh are needed, it's recommended to reindex the mesh without them prior to simplification.
++ * Returns the number of indices after simplification, with destination containing new index data
++ *
++ * The resulting index buffer references vertices from the original vertex buffer.
++ * If the original vertex data isn't needed, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
++ *
++ * destination must contain enough space for the target index buffer, worst case is index_count elements (*not* target_index_count)!
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * target_error represents the error relative to mesh extents that can be tolerated, e.g. 0.01 = 1% deformation (unless absolute error option is used)
++ * options must be a bitmask composed of meshopt_SimplifyX options; 0 is a safe default
++ * result_error can be NULL; when it's not NULL, it will contain the resulting (relative/absolute) error after simplification
++ */
++ MESHOPTIMIZER_API size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, unsigned int options, float* result_error);
++
++ /**
++ * Mesh simplifier with attribute metric
++ * Reduces the number of triangles in the mesh, attempting to preserve mesh appearance as much as possible.
++ * Similar to meshopt_simplify, but incorporates attribute values into the error metric used to prioritize simplification order.
++ * The algorithm tries to preserve mesh topology and can stop short of the target goal based on topology constraints or target error.
++ * If not all attributes from the input mesh are needed, it's recommended to reindex the mesh without them prior to simplification.
++ * Returns the number of indices after simplification, with destination containing new index data
++ *
++ * The resulting index buffer references vertices from the original vertex buffer.
++ * If the original vertex data isn't needed, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
++ * Note that the number of attributes with non-zero weights affects memory requirements and running time.
++ *
++ * destination must contain enough space for the target index buffer, worst case is index_count elements (*not* target_index_count)!
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * vertex_attributes should have attribute_count floats for each vertex
++ * attribute_weights should have attribute_count floats in total; the weights determine relative priority of attributes between each other and wrt position
++ * attribute_count must be <= 32
++ * vertex_lock can be NULL; when it's not NULL, it should have a value for each vertex composed of meshopt_SimplifyVertex_* flags
++ * target_error represents the error relative to mesh extents that can be tolerated, e.g. 0.01 = 1% deformation (unless absolute error option is used)
++ * options must be a bitmask composed of meshopt_SimplifyX options; 0 is a safe default
++ * result_error can be NULL; when it's not NULL, it will contain the resulting (relative/absolute) error after simplification
++ */
++ MESHOPTIMIZER_API size_t meshopt_simplifyWithAttributes(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, const unsigned char* vertex_lock, size_t target_index_count, float target_error, unsigned int options, float* result_error);
++
++ /**
++ * Mesh simplifier with position/attribute update
++ * Reduces the number of triangles in the mesh, attempting to preserve mesh appearance as much as possible.
++ * Similar to meshopt_simplifyWithAttributes, but destructively updates positions and attribute values for optimal appearance.
++ * The algorithm tries to preserve mesh topology and can stop short of the target goal based on topology constraints or target error.
++ * If not all attributes from the input mesh are needed, it's recommended to reindex the mesh without them prior to simplification.
++ * Returns the number of indices after simplification, indices are destructively updated with new index data
++ *
++ * The updated index buffer references vertices from the original vertex buffer, however the vertex positions and attributes are updated in-place.
++ * Creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended; if the original vertex data is needed, it should be copied before simplification.
++ * Note that the number of attributes with non-zero weights affects memory requirements and running time. Attributes with zero weights are not updated.
++ *
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * vertex_attributes should have attribute_count floats for each vertex
++ * attribute_weights should have attribute_count floats in total; the weights determine relative priority of attributes between each other and wrt position
++ * attribute_count must be <= 32
++ * vertex_lock can be NULL; when it's not NULL, it should have a value for each vertex composed of meshopt_SimplifyVertex_* flags
++ * target_error represents the error relative to mesh extents that can be tolerated, e.g. 0.01 = 1% deformation (unless absolute error option is used)
++ * options must be a bitmask composed of meshopt_SimplifyX options; 0 is a safe default
++ * result_error can be NULL; when it's not NULL, it will contain the resulting (relative/absolute) error after simplification
++ */
++ MESHOPTIMIZER_API size_t meshopt_simplifyWithUpdate(unsigned int* indices, size_t index_count, float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, const unsigned char* vertex_lock, size_t target_index_count, float target_error, unsigned int options, float* result_error);
++
++ /**
++ * Mesh simplifier (sloppy)
++ * Reduces the number of triangles in the mesh, sacrificing mesh appearance for simplification performance
++ * The algorithm doesn't preserve mesh topology but can stop short of the target goal based on target error.
++ * Returns the number of indices after simplification, with destination containing new index data
++ * The resulting index buffer references vertices from the original vertex buffer.
++ * If the original vertex data isn't needed, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
++ *
++ * destination must contain enough space for the target index buffer, worst case is index_count elements (*not* target_index_count)!
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * vertex_lock can be NULL; when it's not NULL, it should have a value for each vertex; vertices that can't be moved should set 1 consistently for all indices with the same position
++ * target_error represents the error relative to mesh extents that can be tolerated, e.g. 0.01 = 1% deformation; value range [0..1]
++ * result_error can be NULL; when it's not NULL, it will contain the resulting (relative) error after simplification
++ */
++ MESHOPTIMIZER_API size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const unsigned char* vertex_lock, size_t target_index_count, float target_error, float* result_error);
++
++ /**
++ * Mesh simplifier (pruner)
++ * Reduces the number of triangles in the mesh by removing small isolated parts of the mesh
++ * Returns the number of indices after simplification, with destination containing new index data
++ * The resulting index buffer references vertices from the original vertex buffer.
++ * If the original vertex data isn't needed, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
++ *
++ * destination must contain enough space for the target index buffer, worst case is index_count elements
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * target_error represents the error relative to mesh extents that can be tolerated, e.g. 0.01 = 1% deformation; value range [0..1]
++ */
++ MESHOPTIMIZER_API size_t meshopt_simplifyPrune(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float target_error);
++
++ /**
++ * Point cloud simplifier
++ * Reduces the number of points in the cloud to reach the given target
++ * Returns the number of points after simplification, with destination containing new index data
++ * The resulting index buffer references vertices from the original vertex buffer.
++ * If the original vertex data isn't needed, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
++ *
++ * destination must contain enough space for the target index buffer (target_vertex_count elements)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * vertex_colors can be NULL; when it's not NULL, it should have float3 color in the first 12 bytes of each vertex
++ * color_weight determines relative priority of color wrt position; 1.0 is a safe default
++ */
++ MESHOPTIMIZER_API size_t meshopt_simplifyPoints(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_colors, size_t vertex_colors_stride, float color_weight, size_t target_vertex_count);
++
++ /**
++ * Returns the error scaling factor used by the simplifier to convert between absolute and relative extents
++ *
++ * Absolute error must be *divided* by the scaling factor before passing it to meshopt_simplify as target_error
++ * Relative error returned by meshopt_simplify via result_error must be *multiplied* by the scaling factor to get absolute error.
++ */
++ MESHOPTIMIZER_API float meshopt_simplifyScale(const float* vertex_positions, size_t vertex_count, size_t vertex_positions_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);
++
++ struct meshopt_VertexCacheStatistics
++ {
++ unsigned int vertices_transformed;
++ unsigned int warps_executed;
++ float acmr; /* transformed vertices / triangle count; best case 0.5, worst case 3.0, optimum depends on topology */
++ float atvr; /* transformed vertices / vertex count; best case 1.0, worst case 6.0, optimum is 1.0 (each vertex is transformed once) */
++ };
++
++ /**
++ * Vertex transform cache analyzer
++ * Returns cache hit statistics using a simplified FIFO model
++ * Results may not match actual GPU performance
++ */
++ MESHOPTIMIZER_API struct meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const unsigned int* indices, size_t index_count, size_t vertex_count, unsigned int cache_size, unsigned int warp_size, unsigned int primgroup_size);
++
++ struct meshopt_VertexFetchStatistics
++ {
++ unsigned int bytes_fetched;
++ float overfetch; /* fetched bytes / vertex buffer size; best case 1.0 (each byte is fetched once) */
++ };
++
++ /**
++ * Vertex fetch cache analyzer
++ * Returns cache hit statistics using a simplified direct mapped model
++ * Results may not match actual GPU performance
++ */
++ MESHOPTIMIZER_API struct meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const unsigned int* indices, size_t index_count, size_t vertex_count, size_t vertex_size);
++
++ struct meshopt_OverdrawStatistics
++ {
++ unsigned int pixels_covered;
++ unsigned int pixels_shaded;
++ float overdraw; /* shaded pixels / covered pixels; best case 1.0 */
++ };
++
++ /**
++ * Overdraw analyzer
++ * Returns overdraw statistics using a software rasterizer
++ * Results may not match actual GPU performance
++ *
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API struct meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ struct meshopt_CoverageStatistics
++ {
++ float coverage[3];
++ float extent; /* viewport size in mesh coordinates */
++ };
++
++ /**
++ * Coverage analyzer
++ * Returns coverage statistics (ratio of viewport pixels covered from each axis) using a software rasterizer
++ *
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API struct meshopt_CoverageStatistics meshopt_analyzeCoverage(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ /**
++ * Meshlet is a small mesh cluster (subset) that consists of:
++ * - triangles, an 8-bit micro triangle (index) buffer, that for each triangle specifies three local vertices to use;
++ * - vertices, a 32-bit vertex indirection buffer, that for each local vertex specifies which mesh vertex to fetch vertex attributes from.
++ *
++ * For efficiency, meshlet triangles and vertices are packed into two large arrays; this structure contains offsets and counts to access the data.
++ */
++ struct meshopt_Meshlet
++ {
++ /* offsets within meshlet_vertices and meshlet_triangles arrays with meshlet data */
++ unsigned int vertex_offset;
++ unsigned int triangle_offset;
++
++ /* number of vertices and triangles used in the meshlet; data is stored in consecutive range [offset..offset+count) for vertices and [offset..offset+count*3) for triangles */
++ unsigned int vertex_count;
++ unsigned int triangle_count;
++ };
++
++ /**
++ * Meshlet builder
++ * Splits the mesh into a set of meshlets where each meshlet has a micro index buffer indexing into meshlet vertices that refer to the original vertex buffer
++ * The resulting data can be used to render meshes using NVidia programmable mesh shading pipeline, or in other cluster-based renderers.
++ * When targeting mesh shading hardware, for maximum efficiency meshlets should be further optimized using meshopt_optimizeMeshlet.
++ * When using buildMeshlets, vertex positions need to be provided to minimize the size of the resulting clusters.
++ * When using buildMeshletsScan, for maximum efficiency the index buffer being converted has to be optimized for vertex cache first.
++ *
++ * meshlets must contain enough space for all meshlets, worst case size can be computed with meshopt_buildMeshletsBound
++ * meshlet_vertices must contain enough space for all meshlets, worst case is index_count elements (*not* vertex_count!)
++ * meshlet_triangles must contain enough space for all meshlets, worst case is index_count elements
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * max_vertices and max_triangles must not exceed implementation limits (max_vertices <= 256, max_triangles <= 512)
++ * cone_weight should be set to 0 when cone culling is not used, and a value between 0 and 1 otherwise to balance between cluster size and cone culling efficiency
++ */
++ MESHOPTIMIZER_API size_t meshopt_buildMeshlets(struct meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t max_triangles, float cone_weight);
++ MESHOPTIMIZER_API size_t meshopt_buildMeshletsScan(struct meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
++ MESHOPTIMIZER_API size_t meshopt_buildMeshletsBound(size_t index_count, size_t max_vertices, size_t max_triangles);
++
++ /**
++ * Meshlet builder with flexible cluster sizes
++ * Splits the mesh into a set of meshlets, similarly to meshopt_buildMeshlets, but allows to specify minimum and maximum number of triangles per meshlet.
++ * Clusters between min and max triangle counts are split when the cluster size would have exceeded the expected cluster size by more than split_factor.
++ *
++ * meshlets must contain enough space for all meshlets, worst case size can be computed with meshopt_buildMeshletsBound using min_triangles (*not* max!)
++ * meshlet_vertices must contain enough space for all meshlets, worst case is index_count elements (*not* vertex_count!)
++ * meshlet_triangles must contain enough space for all meshlets, worst case is index_count elements
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * max_vertices, min_triangles and max_triangles must not exceed implementation limits (max_vertices <= 256, max_triangles <= 512; min_triangles <= max_triangles)
++ * cone_weight should be set to 0 when cone culling is not used, and a value between 0 and 1 otherwise to balance between cluster size and cone culling efficiency
++ * split_factor should be set to a non-negative value; when greater than 0, clusters that have large bounds may be split unless they are under the min_triangles threshold
++ */
++ MESHOPTIMIZER_API size_t meshopt_buildMeshletsFlex(struct meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t min_triangles, size_t max_triangles, float cone_weight, float split_factor);
++
++ /**
++ * Meshlet builder that produces clusters optimized for raytracing
++ * Splits the mesh into a set of meshlets, similarly to meshopt_buildMeshlets, but optimizes cluster subdivision for raytracing and allows to specify minimum and maximum number of triangles per meshlet.
++ *
++ * meshlets must contain enough space for all meshlets, worst case size can be computed with meshopt_buildMeshletsBound using min_triangles (*not* max!)
++ * meshlet_vertices must contain enough space for all meshlets, worst case is index_count elements (*not* vertex_count!)
++ * meshlet_triangles must contain enough space for all meshlets, worst case is index_count elements
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * max_vertices, min_triangles and max_triangles must not exceed implementation limits (max_vertices <= 256, max_triangles <= 512; min_triangles <= max_triangles)
++ * fill_weight allows to prioritize clusters that are closer to maximum size at some cost to SAH quality; 0.5 is a safe default
++ */
++ MESHOPTIMIZER_API size_t meshopt_buildMeshletsSpatial(struct meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t min_triangles, size_t max_triangles, float fill_weight);
++
++ /**
++ * Meshlet optimizer
++ * Reorders meshlet vertices and triangles to maximize locality which can improve rasterizer throughput or ray tracing performance when using fast-build modes.
++ *
++ * meshlet_triangles and meshlet_vertices must refer to meshlet data; when buildMeshlets* is used, these need to be computed from meshlet's vertex_offset and triangle_offset
++ * triangle_count and vertex_count must not exceed implementation limits (vertex_count <= 256, triangle_count <= 512)
++ */
++ MESHOPTIMIZER_API void meshopt_optimizeMeshlet(unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, size_t triangle_count, size_t vertex_count);
++
++ /**
++ * Meshlet optimizer
++ * Reorders meshlet vertices and triangles to maximize locality, with higher levels resulting in smaller compressed size at the cost of optimization time.
++ * At level 0 the result is equivalent to meshopt_optimizeMeshlet; levels >= 1 may rotate triangle corners to improve compression (which can change provoking vertex and affect OMM data).
++ *
++ * level should be in the range [0, 9] with 0 equivalent to meshopt_optimizeMeshlet and 9 being the slowest; the sweet spot for compression ratio is around 3
++ */
++ MESHOPTIMIZER_API void meshopt_optimizeMeshletLevel(unsigned int* meshlet_vertices, size_t vertex_count, unsigned char* meshlet_triangles, size_t triangle_count, int level);
++
++ struct meshopt_Bounds
++ {
++ /* bounding sphere, useful for frustum and occlusion culling */
++ float center[3];
++ float radius;
++
++ /* normal cone, useful for backface culling */
++ float cone_apex[3];
++ float cone_axis[3];
++ float cone_cutoff; /* = cos(angle/2) */
++
++ /* normal cone axis and cutoff, stored in 8-bit SNORM format; decode using x/127.0 */
++ signed char cone_axis_s8[3];
++ signed char cone_cutoff_s8;
++ };
++
++ /**
++ * Cluster bounds generator
++ * Creates bounding volumes that can be used for frustum, backface and occlusion culling.
++ *
++ * For backface culling with orthographic projection, use the following formula to reject backfacing clusters:
++ * dot(view, cone_axis) >= cone_cutoff
++ *
++ * For perspective projection, you can use the formula that needs cone apex in addition to axis & cutoff:
++ * dot(normalize(cone_apex - camera_position), cone_axis) >= cone_cutoff
++ *
++ * Alternatively, you can use the formula that doesn't need cone apex and uses bounding sphere instead:
++ * dot(normalize(center - camera_position), cone_axis) >= cone_cutoff + radius / length(center - camera_position)
++ * or an equivalent formula that doesn't have a singularity at center = camera_position:
++ * dot(center - camera_position, cone_axis) >= cone_cutoff * length(center - camera_position) + radius
++ *
++ * The formula that uses the apex is slightly more accurate but needs the apex; if you are already using bounding sphere
++ * to do frustum/occlusion culling, the formula that doesn't use the apex may be preferable (for derivation see
++ * Real-Time Rendering 4th Edition, section 19.3).
++ *
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * vertex_count should specify the number of vertices in the entire mesh, not cluster or meshlet
++ * indices should have at most 256 unique vertex indices
++ * index_count/3 and triangle_count must not exceed implementation limits (<= 512)
++ */
++ MESHOPTIMIZER_API struct meshopt_Bounds meshopt_computeClusterBounds(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++ MESHOPTIMIZER_API struct meshopt_Bounds meshopt_computeMeshletBounds(const unsigned int* meshlet_vertices, const unsigned char* meshlet_triangles, size_t triangle_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ /**
++ * Sphere bounds generator
++ * Creates bounding sphere around a set of points or a set of spheres; returns the center and radius of the sphere, with other fields of the result set to 0.
++ *
++ * positions should have float3 position in the first 12 bytes of each element
++ * radii can be NULL; when it's not NULL, it should have a non-negative float radius in the first 4 bytes of each element
++ */
++ MESHOPTIMIZER_API struct meshopt_Bounds meshopt_computeSphereBounds(const float* positions, size_t count, size_t positions_stride, const float* radii, size_t radii_stride);
++
++ /**
++ * Extract meshlet-local vertex and triangle indices from absolute cluster indices.
++ * Fills triangles[] and vertices[] such that vertices[triangles[i]] == indices[i], and returns the number of unique vertices.
++ *
++ * vertices must contain enough space for the resulting references (up to 256 elements)
++ * triangles must contain enough space for local indices (index_count elements)
++ * indices should have at most 256 unique vertex indices
++ * index_count/3 must not exceed implementation limits (<= 512)
++ */
++ MESHOPTIMIZER_API size_t meshopt_extractMeshletIndices(unsigned int* vertices, unsigned char* triangles, const unsigned int* indices, size_t index_count);
++
++ /**
++ * Cluster partitioner
++ * Partitions clusters into groups of similar size, prioritizing grouping clusters that share vertices or are close to each other.
++ * When vertex positions are not provided, only clusters that share vertices will be grouped together, which may result in small partitions for some inputs.
++ *
++ * destination must contain enough space for the resulting partition data (cluster_count elements)
++ * destination[i] will contain the partition id for cluster i, with the total number of partitions returned by the function
++ * cluster_indices should have the vertex indices referenced by each cluster, stored sequentially
++ * cluster_index_counts should have the number of indices in each cluster; sum of all cluster_index_counts must be equal to total_index_count
++ * vertex_positions can be NULL; when it's not NULL, it should have float3 position in the first 12 bytes of each vertex
++ * target_partition_size is a target size for each partition, in clusters; the resulting partitions may be smaller or larger (up to target + target/3)
++ */
++ MESHOPTIMIZER_API size_t meshopt_partitionClusters(unsigned int* destination, const unsigned int* cluster_indices, size_t total_index_count, const unsigned int* cluster_index_counts, size_t cluster_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_partition_size);
++
++ /**
++ * Spatial sorter
++ * Generates a remap table that can be used to reorder points for spatial locality.
++ * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer.
++ *
++ * destination must contain enough space for the resulting remap table (vertex_count elements)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API void meshopt_spatialSortRemap(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ /**
++ * Spatial sorter
++ * Reorders triangles for spatial locality, and generates a new index buffer. The resulting index buffer can be used with other functions like optimizeVertexCache.
++ *
++ * destination must contain enough space for the resulting index buffer (index_count elements)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API void meshopt_spatialSortTriangles(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++
++ /**
++ * Spatial clusterizer
++ * Reorders points into clusters optimized for spatial locality, and generates a new index buffer.
++ * Ensures the output can be split into cluster_size chunks where each chunk has good positional locality. Only the last chunk will be smaller than cluster_size.
++ *
++ * destination must contain enough space for the resulting index buffer (vertex_count elements)
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ */
++ MESHOPTIMIZER_API void meshopt_spatialClusterPoints(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t cluster_size);
++
++ /**
++ * Experimental: Opacity micromap generator (measure)
++ * Computes a subdivision level for each input triangle, as well as deduplicating the triangles that reference the same UVs to reduce rasterization requests.
++ * Returns the number of OMM entries.
++ *
++ * levels and sources must contain enough space for the worst case output (index_count/3 elements, one per resulting OMM entry)
++ * levels[i] will contain the subdivision level for entry i, with the total number of entries returned by the function; each entry should be rasterized from triangle index sources[i]
++ * omm_indices must contain enough space for the resulting OMM indices (index_count/3 elements, one per triangle)
++ * vertex_uvs should have float2 texture coordinate in the first 8 bytes of each vertex
++ * max_level specifies the maximum subdivision level (0..12)
++ * target_edge can be 0; when >0, triangle subdivision is adaptive and targets target_edge^2 texel area
++ */
++ MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_opacityMapMeasure(unsigned char* levels, unsigned int* sources, int* omm_indices, const unsigned int* indices, size_t index_count, const float* vertex_uvs, size_t vertex_count, size_t vertex_uvs_stride, unsigned int texture_width, unsigned int texture_height, int max_level, float target_edge);
++
++ /**
++ * Experimental: Opacity micromap generator (rasterize)
++ * Rasterizes opacity state for a single triangle entry by sampling the alpha texture, using bilinear filtering and 0.5 alpha cutoff.
++ *
++ * result should contain enough space for the output opacity data (which can be computed using meshopt_opacityMapEntrySize)
++ * level specifies the subdivision level (0..12)
++ * states should be 2 for 2-state format (opaque/transparent) and 4 for 4-state format (opaque/transparent/unknown)
++ * uv0/uv1/uv2 should refer to a float2 texture coordinate for each triangle corner; note that micromap data is sensitive to the corner order
++ * texture_data should point to the alpha channel of the first pixel, encoded as UNORM8
++ * texture_stride specifies the distance in bytes between consecutive pixels, e.g. 4 for RGBA input
++ * texture_pitch specifies the distance in bytes between consecutive rows, e.g. 4*texture_width for tightly packed RGBA input
++ */
++ MESHOPTIMIZER_EXPERIMENTAL void meshopt_opacityMapRasterize(unsigned char* result, int level, int states, const float* uv0, const float* uv1, const float* uv2, const unsigned char* texture_data, size_t texture_stride, size_t texture_pitch, unsigned int texture_width, unsigned int texture_height);
++ MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_opacityMapEntrySize(int level, int states);
++
++ /**
++ * Experimental: Opacity micromap generator (compact)
++ * Compacts and deduplicates opacity data, merging identical micromap entries and replacing micromap states with special indices (-4..-1) when possible.
++ * Returns the number of OMM entries after compaction; the data array should be trimmed using the last offset/size.
++ *
++ * data should contain opacity data for all input/output entries
++ * levels should contain subdivision levels for all input/output entries
++ * offsets should contain offset into data[] for each entry
++ * levels[i] and offsets[i] will be updated with post-compaction level/offset for entry i, with the total number of entries returned by the function
++ * omm_indices should contain indices into the original OMM data, and will be updated with a new index or a special index (-4..-1) when possible
++ * states should be 2 for 2-state format (opaque/transparent) and 4 for 4-state format (opaque/transparent/unknown)
++ */
++ MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_opacityMapCompact(unsigned char* data, size_t data_size, unsigned char* levels, unsigned int* offsets, size_t omm_count, int* omm_indices, size_t triangle_count, int states);
++
++ /**
++ * Tangent generation options
++ */
++ enum
++ {
++ /* Produce tangents compatible with MikkTSpace (same weighting and fallbacks) at the cost of reduced quality. Not recommended unless normal maps are baked. */
++ meshopt_TangentCompatible = 1 << 0,
++ /* Experimental: For vertices only connected to degenerate triangles, output zero tangents instead of an arbitrary fallback. */
++ meshopt_TangentZeroFallback = 1 << 1,
++ };
++
++ /**
++ * Experimental: Tangent space generator
++ * Computes per-corner tangent vectors; for each corner, computes normalized tangent vector (xyz) and orientation (w, +/-1).
++ * Bitangent can be reconstructed via cross(normal, tangent.xyz) * tangent.w.
++ * To apply tangents to the mesh, either deindex and reindex it with the tangent stream, or copy tangents to existing vertex data while duplicating
++ * vertices with different tangent vectors (e.g. on UV mirror seams).
++ * Input can be indexed or unindexed (indices=NULL); this does not affect the resulting tangents, but indexed inputs are ~30% faster to process.
++ *
++ * result must contain enough space for the output tangent data (index_count*4 elements)
++ * indices can be NULL if the input is unindexed
++ * vertex_positions should have float3 position in the first 12 bytes of each vertex
++ * vertex_normals should have unit float3 normal in the first 12 bytes of each vertex
++ * vertex_uvs should have float2 texture coordinate in the first 8 bytes of each vertex
++ */
++ MESHOPTIMIZER_EXPERIMENTAL void meshopt_generateTangents(float* result, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_normals, size_t vertex_normals_stride, const float* vertex_uvs, size_t vertex_uvs_stride, unsigned int options);
++
++ /**
++ * Quantize a float into half-precision (as defined by IEEE-754 fp16) floating point value
++ * Generates +-inf for overflow, preserves NaN, flushes denormals to zero, rounds to nearest
++ * Representable magnitude range: [6e-5; 65504]
++ * Maximum relative reconstruction error: 5e-4
++ */
++ MESHOPTIMIZER_API unsigned short meshopt_quantizeHalf(float v);
++
++ /**
++ * Quantize a float into a floating point value with a limited number of significant mantissa bits, preserving the IEEE-754 fp32 binary representation
++ * Preserves infinities/NaN, flushes denormals to zero, rounds to nearest
++ * Assumes N is in a valid mantissa precision range, which is 1..23
++ */
++ MESHOPTIMIZER_API float meshopt_quantizeFloat(float v, int N);
++
++ /**
++ * Reverse quantization of a half-precision (as defined by IEEE-754 fp16) floating point value
++ * Preserves Inf/NaN, flushes denormals to zero
++ */
++ MESHOPTIMIZER_API float meshopt_dequantizeHalf(unsigned short h);
++
++ /**
++ * Experimental: Compute shared exponent suitable for mesh/cluster position quantization
++ * Given mesh or cluster bounds, compute a shared exponent that can be used to quantize any position inside the bounds to a 24-bit integer grid.
++ * The resulting output can be stored as a compact bit-stream to be decoded directly in shaders, or to be used as an input to RT BVH builders,
++ * for example via D3D12_VERTEX_FORMAT_COMPRESSED1 in DXR2 (max_bits=16).
++ *
++ * To quantize positions, compute:
++ * scale = pow(2, exponent)
++ * iv = int(round(v / scale))
++ * The resulting integer can be stored as signed 24-bit, or as an unsigned offset from a signed 24-bit anchor value, shared between all positions.
++ *
++ * minv/maxv specify the axis-aligned bounding box of the mesh or cluster; each should refer to a float3 value
++ * min_exp specifies the minimum value for the returned exponent, limiting precision to reduce size; e.g. min_exp = -10 will produce minimum error of 1mm given metric units
++ * max_bits specifies the maximum allowed number of bits for the quantized integer range (offset from anchor is an unsigned integer up to 2^max_bits-1)
++ */
++ MESHOPTIMIZER_EXPERIMENTAL int meshopt_computePositionExponent(const float* minv, const float* maxv, int min_exp, int max_bits);
++
++ /**
++ * Set allocation callbacks
++ * These callbacks will be used instead of the default operator new/operator delete for all temporary allocations in the library.
++ * Note that all algorithms only allocate memory for temporary use.
++ * allocate/deallocate are always called in a stack-like order - last pointer to be allocated is deallocated first.
++ * This function is not thread safe and must not be called concurrently with any other meshopt_ function.
++ *
++ * In shared library builds, allocations from templated index wrappers in this header will only be redirected if MESHOPTIMIZER_ALLOC_EXPORT is defined.
++ */
++ MESHOPTIMIZER_API void meshopt_setAllocator(void* (MESHOPTIMIZER_ALLOC_CALLCONV* allocate)(size_t), void (MESHOPTIMIZER_ALLOC_CALLCONV* deallocate)(void*));
++
++ #ifdef __cplusplus
++ } /* extern "C" */
++ #endif
++
++ /* Quantization into fixed point normalized formats; these are only available as inline C++ functions */
++ #ifdef __cplusplus
++ /**
++ * Quantize a float in [0..1] range into an N-bit fixed point unorm value
++ * Assumes reconstruction function (q / (2^N-1)), which is the case for fixed-function normalized fixed point conversion
++ * Maximum reconstruction error: 1/2^(N+1)
++ */
++ inline int meshopt_quantizeUnorm(float v, int N);
++
++ /**
++ * Quantize a float in [-1..1] range into an N-bit fixed point snorm value
++ * Assumes reconstruction function (q / (2^(N-1)-1)), which is the case for fixed-function normalized fixed point conversion (except early OpenGL versions)
++ * Maximum reconstruction error: 1/2^N
++ */
++ inline int meshopt_quantizeSnorm(float v, int N);
++ #endif
++
++ /**
++ * C++ template interface
++ *
++ * These functions mirror the C interface the library provides, providing template-based overloads so that
++ * the caller can use an arbitrary type for the index data, both for input and output.
++ * When the supplied type is the same size as that of unsigned int, the wrappers are zero-cost; when it's not,
++ * the wrappers end up allocating memory and copying index data to convert from one type to another.
++ */
++ #if defined(__cplusplus) && !defined(MESHOPTIMIZER_NO_WRAPPERS)
++ template <typename T>
++ inline size_t meshopt_generateVertexRemap(unsigned int* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
++ template <typename T>
++ inline size_t meshopt_generateVertexRemapMulti(unsigned int* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count);
++ template <typename F>
++ inline size_t meshopt_generateVertexRemapCustom(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, F callback);
++ template <typename T, typename F>
++ inline size_t meshopt_generateVertexRemapCustom(unsigned int* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, F callback);
++ template <typename T>
++ inline void meshopt_remapIndexBuffer(T* destination, const T* indices, size_t index_count, const unsigned int* remap);
++ template <typename T>
++ inline size_t meshopt_filterIndexBuffer(T* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride);
++ template <typename T>
++ inline size_t meshopt_filterIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
++ template <typename T>
++ inline void meshopt_generateShadowIndexBuffer(T* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride);
++ template <typename T>
++ inline void meshopt_generateShadowIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count);
++ template <typename T>
++ inline void meshopt_generateAdjacencyIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++ template <typename T>
++ inline void meshopt_generateTessellationIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++ template <typename T>
++ inline size_t meshopt_generateProvokingIndexBuffer(T* destination, unsigned int* reorder, const T* indices, size_t index_count, size_t vertex_count);
++ template <typename T>
++ inline void meshopt_optimizeVertexCache(T* destination, const T* indices, size_t index_count, size_t vertex_count);
++ template <typename T>
++ inline void meshopt_optimizeVertexCacheStrip(T* destination, const T* indices, size_t index_count, size_t vertex_count);
++ template <typename T>
++ inline void meshopt_optimizeVertexCacheFifo(T* destination, const T* indices, size_t index_count, size_t vertex_count, unsigned int cache_size);
++ template <typename T>
++ inline void meshopt_optimizeOverdraw(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold);
++ template <typename T>
++ inline size_t meshopt_optimizeVertexFetchRemap(unsigned int* destination, const T* indices, size_t index_count, size_t vertex_count);
++ template <typename T>
++ inline size_t meshopt_optimizeVertexFetch(void* destination, T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
++ template <typename T>
++ inline size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count);
++ template <typename T>
++ inline int meshopt_decodeIndexBuffer(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size);
++ template <typename T>
++ inline size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count);
++ template <typename T>
++ inline int meshopt_decodeIndexSequence(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size);
++ template <typename V, typename T>
++ inline int meshopt_decodeMeshlet(V* vertices, size_t vertex_count, T* triangles, size_t triangle_count, const unsigned char* buffer, size_t buffer_size);
++ inline size_t meshopt_encodeVertexBufferLevel(unsigned char* buffer, size_t buffer_size, const void* vertices, size_t vertex_count, size_t vertex_size, int level);
++ template <typename T>
++ inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, unsigned int options = 0, float* result_error = NULL);
++ template <typename T>
++ inline size_t meshopt_simplifyWithAttributes(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, const unsigned char* vertex_lock, size_t target_index_count, float target_error, unsigned int options = 0, float* result_error = NULL);
++ template <typename T>
++ inline size_t meshopt_simplifyWithUpdate(T* indices, size_t index_count, float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, const unsigned char* vertex_lock, size_t target_index_count, float target_error, unsigned int options = 0, float* result_error = NULL);
++ template <typename T>
++ inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, float* result_error = NULL);
++ template <typename T>
++ inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const unsigned char* vertex_lock, size_t target_index_count, float target_error, float* result_error = NULL);
++ template <typename T>
++ inline size_t meshopt_simplifyPrune(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float target_error);
++ template <typename T>
++ inline size_t meshopt_stripify(T* destination, const T* indices, size_t index_count, size_t vertex_count, T restart_index);
++ template <typename T>
++ inline size_t meshopt_unstripify(T* destination, const T* indices, size_t index_count, T restart_index);
++ template <typename T>
++ inline meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const T* indices, size_t index_count, size_t vertex_count, unsigned int cache_size, unsigned int warp_size, unsigned int primgroup_size);
++ template <typename T>
++ inline meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const T* indices, size_t index_count, size_t vertex_count, size_t vertex_size);
++ template <typename T>
++ inline meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++ template <typename T>
++ inline meshopt_CoverageStatistics meshopt_analyzeCoverage(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++ template <typename T>
++ inline size_t meshopt_buildMeshlets(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t max_triangles, float cone_weight);
++ template <typename T>
++ inline size_t meshopt_buildMeshletsScan(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
++ template <typename T>
++ inline size_t meshopt_buildMeshletsFlex(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t min_triangles, size_t max_triangles, float cone_weight, float split_factor);
++ template <typename T>
++ inline size_t meshopt_buildMeshletsSpatial(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t min_triangles, size_t max_triangles, float fill_weight);
++ template <typename T>
++ inline meshopt_Bounds meshopt_computeClusterBounds(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++ template <typename T>
++ inline size_t meshopt_partitionClusters(unsigned int* destination, const T* cluster_indices, size_t total_index_count, const unsigned int* cluster_index_counts, size_t cluster_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_partition_size);
++ template <typename T>
++ inline void meshopt_spatialSortTriangles(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
++ template <typename T>
++ inline void meshopt_generateTangents(float* result, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_normals, size_t vertex_normals_stride, const float* vertex_uvs, size_t vertex_uvs_stride, unsigned int options = 0);
++ #endif
++
++ /* Inline implementation */
++ #ifdef __cplusplus
++ inline int meshopt_quantizeUnorm(float v, int N)
++ {
++ const float scale = float((1 << N) - 1);
++
++ v = (v >= 0) ? v : 0;
++ v = (v <= 1) ? v : 1;
++
++ return int(v * scale + 0.5f);
++ }
++
++ inline int meshopt_quantizeSnorm(float v, int N)
++ {
++ const float scale = float((1 << (N - 1)) - 1);
++
++ float round = (v >= 0 ? 0.5f : -0.5f);
++
++ v = (v >= -1) ? v : -1;
++ v = (v <= +1) ? v : +1;
++
++ return int(v * scale + round);
++ }
++ #endif
++
++ /* Internal implementation helpers */
++ #ifdef __cplusplus
++ class meshopt_Allocator
++ {
++ public:
++ struct Storage
++ {
++ void* (MESHOPTIMIZER_ALLOC_CALLCONV* allocate)(size_t);
++ void (MESHOPTIMIZER_ALLOC_CALLCONV* deallocate)(void*);
++ };
++
++ #ifdef MESHOPTIMIZER_ALLOC_EXPORT
++ MESHOPTIMIZER_API static Storage& storage();
++ #else
++ static Storage& storage()
++ {
++ static Storage s = {::operator new, ::operator delete };
++ return s;
++ }
++ #endif
++
++ meshopt_Allocator()
++ : blocks()
++ , count(0)
++ {
++ }
++
++ ~meshopt_Allocator()
++ {
++ for (size_t i = count; i > 0; --i)
++ storage().deallocate(blocks[i - 1]);
++ }
++
++ template <typename T>
++ T* allocate(size_t size)
++ {
++ assert(count < sizeof(blocks) / sizeof(blocks[0]));
++ T* result = static_cast<T*>(storage().allocate(size > size_t(-1) / sizeof(T) ? size_t(-1) : size * sizeof(T)));
++ blocks[count++] = result;
++ return result;
++ }
++
++ void deallocate(void* ptr)
++ {
++ assert(count > 0 && blocks[count - 1] == ptr);
++ storage().deallocate(ptr);
++ count--;
++ }
++
++ private:
++ void* blocks[24];
++ size_t count;
++ };
++ #endif
++
++ /* Inline implementation for C++ templated wrappers */
++ #if defined(__cplusplus) && !defined(MESHOPTIMIZER_NO_WRAPPERS)
++ template <typename T, bool ZeroCopy = sizeof(T) == sizeof(unsigned int)>
++ struct meshopt_IndexAdapter;
++
++ template <typename T>
++ struct meshopt_IndexAdapter<T, false>
++ {
++ T* result;
++ unsigned int* data;
++ size_t count;
++
++ meshopt_IndexAdapter(T* result_, const T* input, size_t count_)
++ : result(result_)
++ , data(NULL)
++ , count(count_)
++ {
++ size_t size = count > size_t(-1) / sizeof(unsigned int) ? size_t(-1) : count * sizeof(unsigned int);
++
++ data = static_cast<unsigned int*>(meshopt_Allocator::storage().allocate(size));
++
++ if (input)
++ {
++ for (size_t i = 0; i < count; ++i)
++ data[i] = input[i];
++ }
++ }
++
++ ~meshopt_IndexAdapter()
++ {
++ if (result)
++ {
++ for (size_t i = 0; i < count; ++i)
++ result[i] = T(data[i]);
++ }
++
++ meshopt_Allocator::storage().deallocate(data);
++ }
++ };
++
++ template <typename T>
++ struct meshopt_IndexAdapter<T, true>
++ {
++ unsigned int* data;
++
++ meshopt_IndexAdapter(T* result, const T* input, size_t)
++ : data(reinterpret_cast<unsigned int*>(result ? result : const_cast<T*>(input)))
++ {
++ }
++ };
++
++ template <typename T>
++ inline size_t meshopt_generateVertexRemap(unsigned int* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
++
++ return meshopt_generateVertexRemap(destination, indices ? in.data : NULL, index_count, vertices, vertex_count, vertex_size);
++ }
++
++ template <typename T>
++ inline size_t meshopt_generateVertexRemapMulti(unsigned int* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
++
++ return meshopt_generateVertexRemapMulti(destination, indices ? in.data : NULL, index_count, vertex_count, streams, stream_count);
++ }
++
++ template <typename F>
++ inline size_t meshopt_generateVertexRemapCustom(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, F callback)
++ {
++ struct Call
++ {
++ static int compare(void* context, unsigned int lhs, unsigned int rhs) { return (*static_cast<F*>(context))(lhs, rhs) ? 1 : 0; }
++ };
++
++ return meshopt_generateVertexRemapCustom(destination, indices, index_count, vertex_positions, vertex_count, vertex_positions_stride, &Call::compare, &callback);
++ }
++
++ template <typename T, typename F>
++ inline size_t meshopt_generateVertexRemapCustom(unsigned int* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, F callback)
++ {
++ struct Call
++ {
++ static int compare(void* context, unsigned int lhs, unsigned int rhs) { return (*static_cast<F*>(context))(lhs, rhs) ? 1 : 0; }
++ };
++
++ meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
++
++ return meshopt_generateVertexRemapCustom(destination, indices ? in.data : NULL, index_count, vertex_positions, vertex_count, vertex_positions_stride, &Call::compare, &callback);
++ }
++
++ template <typename T>
++ inline void meshopt_remapIndexBuffer(T* destination, const T* indices, size_t index_count, const unsigned int* remap)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_remapIndexBuffer(out.data, indices ? in.data : NULL, index_count, remap);
++ }
++
++ template <typename T>
++ inline size_t meshopt_filterIndexBuffer(T* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ return meshopt_filterIndexBuffer(out.data, in.data, index_count, vertices, vertex_count, vertex_size, vertex_stride);
++ }
++
++ template <typename T>
++ inline size_t meshopt_filterIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ return meshopt_filterIndexBufferMulti(out.data, in.data, index_count, vertex_count, streams, stream_count);
++ }
++
++ template <typename T>
++ inline void meshopt_generateShadowIndexBuffer(T* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_generateShadowIndexBuffer(out.data, in.data, index_count, vertices, vertex_count, vertex_size, vertex_stride);
++ }
++
++ template <typename T>
++ inline void meshopt_generateShadowIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_generateShadowIndexBufferMulti(out.data, in.data, index_count, vertex_count, streams, stream_count);
++ }
++
++ template <typename T>
++ inline void meshopt_generateAdjacencyIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count * 2);
++
++ meshopt_generateAdjacencyIndexBuffer(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
++ }
++
++ template <typename T>
++ inline void meshopt_generateTessellationIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count * 4);
++
++ meshopt_generateTessellationIndexBuffer(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
++ }
++
++ template <typename T>
++ inline size_t meshopt_generateProvokingIndexBuffer(T* destination, unsigned int* reorder, const T* indices, size_t index_count, size_t vertex_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ size_t bound = vertex_count + (index_count / 3);
++ assert(bound == 0 || size_t(T(bound - 1)) == bound - 1); // bound - 1 must fit in T
++ (void)bound;
++
++ return meshopt_generateProvokingIndexBuffer(out.data, reorder, in.data, index_count, vertex_count);
++ }
++
++ template <typename T>
++ inline void meshopt_optimizeVertexCache(T* destination, const T* indices, size_t index_count, size_t vertex_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_optimizeVertexCache(out.data, in.data, index_count, vertex_count);
++ }
++
++ template <typename T>
++ inline void meshopt_optimizeVertexCacheStrip(T* destination, const T* indices, size_t index_count, size_t vertex_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_optimizeVertexCacheStrip(out.data, in.data, index_count, vertex_count);
++ }
++
++ template <typename T>
++ inline void meshopt_optimizeVertexCacheFifo(T* destination, const T* indices, size_t index_count, size_t vertex_count, unsigned int cache_size)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_optimizeVertexCacheFifo(out.data, in.data, index_count, vertex_count, cache_size);
++ }
++
++ template <typename T>
++ inline void meshopt_optimizeOverdraw(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_optimizeOverdraw(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, threshold);
++ }
++
++ template <typename T>
++ inline size_t meshopt_optimizeVertexFetchRemap(unsigned int* destination, const T* indices, size_t index_count, size_t vertex_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_optimizeVertexFetchRemap(destination, in.data, index_count, vertex_count);
++ }
++
++ template <typename T>
++ inline size_t meshopt_optimizeVertexFetch(void* destination, T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size)
++ {
++ meshopt_IndexAdapter<T> inout(indices, indices, index_count);
++
++ return meshopt_optimizeVertexFetch(destination, inout.data, index_count, vertices, vertex_count, vertex_size);
++ }
++
++ template <typename T>
++ inline size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_encodeIndexBuffer(buffer, buffer_size, in.data, index_count);
++ }
++
++ template <typename T>
++ inline int meshopt_decodeIndexBuffer(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size)
++ {
++ char index_size_valid[sizeof(T) == 2 || sizeof(T) == 4 ? 1 : -1];
++ (void)index_size_valid;
++
++ return meshopt_decodeIndexBuffer(destination, index_count, sizeof(T), buffer, buffer_size);
++ }
++
++ template <typename T>
++ inline size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_encodeIndexSequence(buffer, buffer_size, in.data, index_count);
++ }
++
++ template <typename T>
++ inline int meshopt_decodeIndexSequence(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size)
++ {
++ char index_size_valid[sizeof(T) == 2 || sizeof(T) == 4 ? 1 : -1];
++ (void)index_size_valid;
++
++ return meshopt_decodeIndexSequence(destination, index_count, sizeof(T), buffer, buffer_size);
++ }
++
++ template <typename V, typename T>
++ inline int meshopt_decodeMeshlet(V* vertices, size_t vertex_count, T* triangles, size_t triangle_count, const unsigned char* buffer, size_t buffer_size)
++ {
++ char types_valid[(sizeof(V) == 2 || sizeof(V) == 4) && (sizeof(T) == 1 || sizeof(T) == 4) ? 1 : -1];
++ (void)types_valid;
++
++ return meshopt_decodeMeshlet(vertices, vertex_count, sizeof(V), triangles, triangle_count, sizeof(T) == 1 ? 3 : 4, buffer, buffer_size);
++ }
++
++ inline size_t meshopt_encodeVertexBufferLevel(unsigned char* buffer, size_t buffer_size, const void* vertices, size_t vertex_count, size_t vertex_size, int level)
++ {
++ return meshopt_encodeVertexBufferLevel(buffer, buffer_size, vertices, vertex_count, vertex_size, level, -1);
++ }
++
++ template <typename T>
++ inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, unsigned int options, float* result_error)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ return meshopt_simplify(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_index_count, target_error, options, result_error);
++ }
++
++ template <typename T>
++ inline size_t meshopt_simplifyWithAttributes(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, const unsigned char* vertex_lock, size_t target_index_count, float target_error, unsigned int options, float* result_error)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ return meshopt_simplifyWithAttributes(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, vertex_attributes, vertex_attributes_stride, attribute_weights, attribute_count, vertex_lock, target_index_count, target_error, options, result_error);
++ }
++
++ template <typename T>
++ inline size_t meshopt_simplifyWithUpdate(T* indices, size_t index_count, float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, const unsigned char* vertex_lock, size_t target_index_count, float target_error, unsigned int options, float* result_error)
++ {
++ meshopt_IndexAdapter<T> inout(indices, indices, index_count);
++
++ return meshopt_simplifyWithUpdate(inout.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, vertex_attributes, vertex_attributes_stride, attribute_weights, attribute_count, vertex_lock, target_index_count, target_error, options, result_error);
++ }
++
++ template <typename T>
++ inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, float* result_error)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ return meshopt_simplifySloppy(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, NULL, target_index_count, target_error, result_error);
++ }
++
++ template <typename T>
++ inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const unsigned char* vertex_lock, size_t target_index_count, float target_error, float* result_error)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ return meshopt_simplifySloppy(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, vertex_lock, target_index_count, target_error, result_error);
++ }
++
++ template <typename T>
++ inline size_t meshopt_simplifyPrune(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float target_error)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ return meshopt_simplifyPrune(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_error);
++ }
++
++ template <typename T>
++ inline size_t meshopt_stripify(T* destination, const T* indices, size_t index_count, size_t vertex_count, T restart_index)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, (index_count / 3) * 5);
++
++ return meshopt_stripify(out.data, in.data, index_count, vertex_count, unsigned(restart_index));
++ }
++
++ template <typename T>
++ inline size_t meshopt_unstripify(T* destination, const T* indices, size_t index_count, T restart_index)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count == 0 ? 0 : (index_count - 2) * 3);
++
++ return meshopt_unstripify(out.data, in.data, index_count, unsigned(restart_index));
++ }
++
++ template <typename T>
++ inline meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const T* indices, size_t index_count, size_t vertex_count, unsigned int cache_size, unsigned int warp_size, unsigned int primgroup_size)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_analyzeVertexCache(in.data, index_count, vertex_count, cache_size, warp_size, primgroup_size);
++ }
++
++ template <typename T>
++ inline meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const T* indices, size_t index_count, size_t vertex_count, size_t vertex_size)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_analyzeVertexFetch(in.data, index_count, vertex_count, vertex_size);
++ }
++
++ template <typename T>
++ inline meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_analyzeOverdraw(in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
++ }
++
++ template <typename T>
++ inline meshopt_CoverageStatistics meshopt_analyzeCoverage(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_analyzeCoverage(in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
++ }
++
++ template <typename T>
++ inline size_t meshopt_buildMeshlets(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t max_triangles, float cone_weight)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_buildMeshlets(meshlets, meshlet_vertices, meshlet_triangles, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, max_vertices, max_triangles, cone_weight);
++ }
++
++ template <typename T>
++ inline size_t meshopt_buildMeshletsScan(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_buildMeshletsScan(meshlets, meshlet_vertices, meshlet_triangles, in.data, index_count, vertex_count, max_vertices, max_triangles);
++ }
++
++ template <typename T>
++ inline size_t meshopt_buildMeshletsFlex(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t min_triangles, size_t max_triangles, float cone_weight, float split_factor)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_buildMeshletsFlex(meshlets, meshlet_vertices, meshlet_triangles, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, max_vertices, min_triangles, max_triangles, cone_weight, split_factor);
++ }
++
++ template <typename T>
++ inline size_t meshopt_buildMeshletsSpatial(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t min_triangles, size_t max_triangles, float fill_weight)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_buildMeshletsSpatial(meshlets, meshlet_vertices, meshlet_triangles, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, max_vertices, min_triangles, max_triangles, fill_weight);
++ }
++
++ template <typename T>
++ inline meshopt_Bounds meshopt_computeClusterBounds(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++
++ return meshopt_computeClusterBounds(in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
++ }
++
++ template <typename T>
++ inline size_t meshopt_partitionClusters(unsigned int* destination, const T* cluster_indices, size_t total_index_count, const unsigned int* cluster_index_counts, size_t cluster_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_partition_size)
++ {
++ meshopt_IndexAdapter<T> in(NULL, cluster_indices, total_index_count);
++
++ return meshopt_partitionClusters(destination, in.data, total_index_count, cluster_index_counts, cluster_count, vertex_positions, vertex_count, vertex_positions_stride, target_partition_size);
++ }
++
++ template <typename T>
++ inline void meshopt_spatialSortTriangles(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, index_count);
++ meshopt_IndexAdapter<T> out(destination, NULL, index_count);
++
++ meshopt_spatialSortTriangles(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
++ }
++
++ template <typename T>
++ inline void meshopt_generateTangents(float* result, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_normals, size_t vertex_normals_stride, const float* vertex_uvs, size_t vertex_uvs_stride, unsigned int options)
++ {
++ meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
++
++ meshopt_generateTangents(result, indices ? in.data : NULL, index_count, vertex_positions, vertex_count, vertex_positions_stride, vertex_normals, vertex_normals_stride, vertex_uvs, vertex_uvs_stride, options);
++ }
++ #endif
++
++ /**
++ * Copyright (c) 2016-2026 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.
++ */