.. _stdlib_meshoptimizer: =============================================================== Mesh remapping, optimization, and buffer codecs (meshoptimizer) =============================================================== .. das:module:: meshoptimizer Checked array bindings for meshoptimizer 1.2 vertex remapping, vertex-cache and vertex-fetch optimization, and vertex and index buffer codecs. The API accepts triangle-list ``uint`` indices and packed vertex bytes with a nonzero, 4-byte-aligned stride of at most 256 bytes. ++++++++++++++++ Vertex remapping ++++++++++++++++ * :ref:`meshopt_generate_remap (remap: array\; indices: array\; vertices: array\; stride: uint) : uint ` * :ref:`meshopt_remap_indices (output: array\; indices: array\; remap: array\) ` * :ref:`meshopt_remap_vertices (output: array\; vertices: array\; remap: array\; stride: uint; count: uint) ` .. _function-meshoptimizer_meshopt_generate_remap_array_ls_uint_gr__array_ls_uint_gr__array_ls_uint8_gr__uint: .. das:function:: meshopt_generate_remap(remap: array; indices: array; vertices: array; stride: uint) : uint Build a vertex remap table from triangle-list ``indices`` and packed ``vertices``, returning the number of unique vertices. ``stride`` must be nonzero, 4-byte aligned, at most 256 bytes, and divide the vertex byte count; every index must be in range, and ``remap`` must not alias ``indices``. :Arguments: * **remap** : array implicit * **indices** : array implicit * **vertices** : array implicit * **stride** : uint .. _function-meshoptimizer_meshopt_remap_indices_array_ls_uint_gr__array_ls_uint_gr__array_ls_uint_gr_: .. das:function:: meshopt_remap_indices(output: array; indices: array; remap: array) Apply a vertex remap table to triangle-list ``indices`` and resize ``output`` to the index count. Every input index must address the remap table, and ``output`` must not alias ``remap``. :Arguments: * **output** : array implicit * **indices** : array implicit * **remap** : array implicit .. _function-meshoptimizer_meshopt_remap_vertices_array_ls_uint8_gr__array_ls_uint8_gr__array_ls_uint_gr__uint_uint: .. das:function:: meshopt_remap_vertices(output: array; vertices: array; remap: array; stride: uint; count: uint) Apply ``remap`` to packed ``vertices`` and resize ``output`` to ``count * stride`` bytes. The remap table must contain one entry per input vertex, each entry must be less than ``count`` or the unused value ``0xffffffff``, and ``output`` must not alias ``vertices``. :Arguments: * **output** : array implicit * **vertices** : array implicit * **remap** : array implicit * **stride** : uint * **count** : uint +++++++++++++++++ Mesh optimization +++++++++++++++++ * :ref:`meshopt_optimize_cache (indices: array\; count: uint) ` * :ref:`meshopt_optimize_fetch (indices: array\; vertices: array\; stride: uint) : uint ` .. _function-meshoptimizer_meshopt_optimize_cache_array_ls_uint_gr__uint: .. das:function:: meshopt_optimize_cache(indices: array; count: uint) Reorder triangle-list ``indices`` in place to improve post-transform vertex-cache locality while preserving each triangle's orientation. Every index must be less than ``count``. :Arguments: * **indices** : array implicit * **count** : uint .. _function-meshoptimizer_meshopt_optimize_fetch_array_ls_uint_gr__array_ls_uint8_gr__uint: .. das:function:: meshopt_optimize_fetch(indices: array; vertices: array; stride: uint) : uint Reorder ``indices`` and packed ``vertices`` in place for sequential vertex fetch, discard unreferenced vertices, and return the resulting vertex count. The vertex stride and all triangle-list indices are validated before either array is modified. :Arguments: * **indices** : array implicit * **vertices** : array implicit * **stride** : uint ++++++++++++ Vertex codec ++++++++++++ * :ref:`meshopt_decode_vertices (output: array\; encoded: array\; count: uint; stride: uint) : bool ` * :ref:`meshopt_encode_vertices (output: array\; vertices: array\; stride: uint) ` .. _function-meshoptimizer_meshopt_decode_vertices_array_ls_uint8_gr__array_ls_uint8_gr__uint_uint: .. das:function:: meshopt_decode_vertices(output: array; encoded: array; count: uint; stride: uint) : bool Decode ``count`` packed vertex records of ``stride`` bytes into ``output`` and return true on success. Invalid codec data returns false and clears ``output``; invalid stride, oversized output, or aliasing ``encoded`` raises an error. :Arguments: * **output** : array implicit * **encoded** : array implicit * **count** : uint * **stride** : uint .. _function-meshoptimizer_meshopt_encode_vertices_array_ls_uint8_gr__array_ls_uint8_gr__uint: .. das:function:: meshopt_encode_vertices(output: array; vertices: array; stride: uint) Encode packed vertex records into the meshoptimizer vertex codec and resize ``output`` to the encoded byte count. ``stride`` must be nonzero, 4-byte aligned, at most 256 bytes, and divide the input size; ``output`` must not alias ``vertices``. :Arguments: * **output** : array implicit * **vertices** : array implicit * **stride** : uint +++++++++++ Index codec +++++++++++ * :ref:`meshopt_decode_indices (output: array\; encoded: array\; count: uint) : bool ` * :ref:`meshopt_encode_indices (output: array\; indices: array\; count: uint) ` .. _function-meshoptimizer_meshopt_decode_indices_array_ls_uint_gr__array_ls_uint8_gr__uint: .. das:function:: meshopt_decode_indices(output: array; encoded: array; count: uint) : bool Decode exactly ``count`` triangle-list indices into ``output`` and return true on success. ``count`` must be divisible by three; invalid codec data returns false and clears ``output``. :Arguments: * **output** : array implicit * **encoded** : array implicit * **count** : uint .. _function-meshoptimizer_meshopt_encode_indices_array_ls_uint8_gr__array_ls_uint_gr__uint: .. das:function:: meshopt_encode_indices(output: array; indices: array; count: uint) Encode triangle-list ``indices`` with the meshoptimizer index codec and resize ``output`` to the encoded byte count. Every index must be less than the supplied vertex ``count``. Triangle order and winding are preserved, but the three indices within each triangle may be cyclically rotated. :Arguments: * **output** : array implicit * **indices** : array implicit * **count** : uint