Magnum::MeshTools namespace

enum class Magnum::MeshTools::CompileFlag: UnsignedByte new in 2019.10

#include <Magnum/MeshTools/Compile.h>

Mesh compilation flag.

enum class Magnum::MeshTools::InterleaveFlag: UnsignedInt new in Git master

#include <Magnum/MeshTools/InterleaveFlags.h>

Interleaving behavior flag.

typedef Containers::EnumSet<CompileFlag> Magnum::MeshTools::CompileFlags new in 2019.10

#include <Magnum/MeshTools/Compile.h>

Mesh compilation flags.

typedef Containers::EnumSet<InterleaveFlag> Magnum::MeshTools::InterleaveFlags new in Git master

#include <Magnum/MeshTools/InterleaveFlags.h>

Interleaving behavior flags.

Range3D Magnum::MeshTools::boundingRange(const Containers::StridedArrayView1D<const Vector3>& positions) new in Git master

#include <Magnum/MeshTools/BoundingVolume.h>

Calculate a bounding range.

Same as Math::minmax(const Containers::StridedArrayView1D<const T>&).

Containers::Pair<Vector3, Float> Magnum::MeshTools::boundingSphereBouncingBubble(const Containers::StridedArrayView1D<const Vector3>& positions) new in Git master

#include <Magnum/MeshTools/BoundingVolume.h>

Calculate an approximate bounding sphere using the Bouncing Bubble algorithm.

The resulting bounding sphere is not usually minimal. According to the author, a 1% to 2% error can be expected. Due to the nature of the algorithm, the radius is never below Math::TypeTraits::epsilon(), even for empty or entirely overlapping lists of points. NaNs are ignored, unless the first position is NaN in which case it is propagated. Algorithm used: Bo Tian — Bouncing Bubble: A fast algorithm for Minimal Enclosing Ball problem, 2012, https://www.grin.com/document/204869.

Trade::MeshData Magnum::MeshTools::combineIndexedAttributes(const Containers::Iterable<const Trade::MeshData>& meshes) new in 2020.06

#include <Magnum/MeshTools/Combine.h>

Combine differently indexed attributes into a single mesh.

Assuming all meshes contain only unique vertex data, creates an indexed mesh that contains all attributes from meshes combined, with duplicate vertices removed. For example, when you have a position and a normal array, each indexed with separate indices like this:

{pA, pB, pC, pD, pE, pF}        // positions
{nA, nB, nC, nD, nE, nF, nG}    // normals

{0, 2, 5, 0, 0, 1, 3, 2, 2}     // position indices
{1, 3, 4, 1, 4, 6, 1, 3, 1}     // normal indices

Then the first triangle in the mesh is defined as {pA, nB}, {pC, nD}, {pF, nE}. When combined together using this function, the resulting mesh stays the same but there's just one index array, indexing both positions and normals:

{{pA, nB}, {pC, nD}, {pF, nE}, {pA, nE}, {pB, nG}, {pD, nB}, {pC, nB}}
                                // unique pairs of positions and normals

{0, 1, 2, 0, 3, 4, 5, 1, 6}     // unified indices

The function preserves all attribute data including repeated or custom attributes. The resulting mesh is interleaved, with all attributes packed tightly together. If you need to add specific padding for alignment preservation, pass the result to interleave() and specify the paddings between attributes manually. Similarly, for simplicity the resulting mesh has always MeshIndexType::UnsignedInt — use compressIndices(const Trade::MeshData&, MeshIndexType) if you want to have it compressed to a smaller type.

Vertex data unreferenced by the index buffers are discarded. This means the function can be also called with just a single argument to compact a mesh with a sparse index buffer.

Expects that meshes is non-empty and all data have the same primitive and index count. All inputs have to be indexed. For non-indexed attributes combining can be done much more efficiently using duplicate(const Trade::MeshData&, Containers::ArrayView<const Trade::MeshAttributeData>), alternatively you can turn a non-indexed attribute to an indexed one first using removeDuplicatesInPlace() and then call this function. Index buffers and attributes in all meshes are expected to not have an implementation-specific format.

Trade::MeshData Magnum::MeshTools::combineFaceAttributes(const Trade::MeshData& mesh, const Trade::MeshData& faceAttributes) new in 2020.06

#include <Magnum/MeshTools/Combine.h>

Combine per-face attributes into an existing mesh.

The resulting mesh will have all per-face attributes turned into per-vertex attributes, leaving only unique combinations and adjusting the index buffer accordingly. The resulting mesh has the same amount of indices, but likely more vertices.

Expects that mesh is indexed MeshPrimitive::Triangles and faceAttributes is MeshPrimitive::Faces, with face element count of the latter corresponding to triangle count of the former. If faceAttributes is indexed, it's assumed to have the data unique; if it's not indexed, it's first made unique using removeDuplicates() and in that case it's expected to be interleaved. Index buffers and attributes in both meshes are expected to not have an implementation-specific format.

Trade::MeshData Magnum::MeshTools::combineFaceAttributes(const Trade::MeshData& mesh, Containers::ArrayView<const Trade::MeshAttributeData> faceAttributes) new in 2020.06

#include <Magnum/MeshTools/Combine.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Same as above with faceAttributes wrapped in a Trade::MeshData with MeshPrimitive::Faces and no index buffer. Same as in the above case, faceAttributes is expected to be interleaved. Note that offset-only Trade::MeshAttributeData instances are not supported in the faceAttributes array.

Trade::MeshData Magnum::MeshTools::combineFaceAttributes(const Trade::MeshData& mesh, std::initializer_list<Trade::MeshAttributeData> faceAttributes) new in 2020.06

#include <Magnum/MeshTools/Combine.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

std::vector<UnsignedInt> Magnum::MeshTools::combineIndexArrays(const std::vector<std::reference_wrapper<std::vector<UnsignedInt>>>& arrays)

#include <Magnum/MeshTools/CombineIndexedArrays.h>

Combine index arrays.

Creates new combined index array and updates the original ones with translation to new ones. For example, when you have position and normal array, each indexed with separate indices and you want to index both of them with single index array:

a b c d e f         // positions
A B C D E F G       // normals

0 2 5 0 0 1 3 2 2   // position indices
1 3 4 1 4 6 1 3 1   // normal indices

In particular, first triangle in the mesh will have positions a c f and normals B D E. You can see that not all combinations are unique and also that there are some vertices unused. When you pass the two index arrays above to this function, the following combined index array is returned:

0 1 2 0 3 4 5 1 6

And the original arrays are cleaned up to have only unique combinations:

0 2 5 0 1 3 2
1 3 4 4 6 1 1

You can use these as translation table to create new vertex and normal arrays which can be then indexed with the combined index array:

a c f a b d c
B D E E G B B

Again, first triangle in the mesh will have positions a c f and normals B D E.

This function calls combineIndexArrays(const std::vector<UnsignedInt>&, UnsignedInt) internally. See also combineIndexedArrays() which does the vertex data reordering automatically.

std::vector<UnsignedInt> Magnum::MeshTools::combineIndexArrays(std::initializer_list<std::reference_wrapper<std::vector<UnsignedInt>>> arrays)

#include <Magnum/MeshTools/CombineIndexedArrays.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

std::pair<std::vector<UnsignedInt>, std::vector<UnsignedInt>> Magnum::MeshTools::combineIndexArrays(const std::vector<UnsignedInt>& interleavedArrays, UnsignedInt stride)

#include <Magnum/MeshTools/CombineIndexedArrays.h>

Combine interleaved index arrays.

Unlike above, this function takes one interleaved array instead of separate index arrays. Continuing with the above example, you would call this function with the following array (odd value is vertex index, even is normal index, stride is thus 2):

0 1 2 3 5 4 0 1 0 4 1 6 3 1 2 3 2 1

Similarly to above this function will return the following combined index array as first pair value:

0 1 2 0 3 4 5 1 6

And second pair value is the cleaned up interleaved array:

0 1 2 3 5 4 0 4 1 6 3 1 2 1

#include <Magnum/MeshTools/CombineIndexedArrays.h>

template<class ... T>

std::vector<UnsignedInt> Magnum::MeshTools::combineIndexedArrays(const std::pair<const std::vector<UnsignedInt>&, std::vector<T>&>&... indexedArrays)

Combine indexed arrays.

Creates new combined index array and reorders original attribute arrays so they can be indexed with the new single index array.

The index array must be passed as const reference (to avoid copying) and attribute array as reference, so it can be replaced with combined data. To avoid explicit verbose specification of tuple type, you can write it with help of some STL functions like shown below. Also if one index array is shared by more than one attribute array, just pass the index array more times. Example:

std::vector<UnsignedInt> vertexIndices;
std::vector<Vector3> positions;
std::vector<UnsignedInt> normalTextureIndices;
std::vector<Vector3> normals;
std::vector<Vector2> textureCoordinates;

std::vector<UnsignedInt> indices = MeshTools::combineIndexedArrays(
    std::make_pair(std::cref(vertexIndices), std::ref(positions)),
    std::make_pair(std::cref(normalTextureIndices), std::ref(normals)),
    std::make_pair(std::cref(normalTextureIndices), std::ref(textureCoordinates))
);

See combineIndexArrays() documentation for more information about the procedure.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData& mesh, CompileFlags flags) new in 2020.06

#include <Magnum/MeshTools/Compile.h>

Compile OpenGL mesh data.

Configures a mesh for a Shaders::GenericGL shader with a vertex buffer and possibly also an index buffer, if the mesh is indexed.

• If the mesh contains Trade::MeshAttribute::Position, these are bound to the Shaders::GenericGL2D::Position attribute if they are 2D or to Shaders::GenericGL3D::Position if they are 3D.
• If the mesh contains Trade::MeshAttribute::Tangent, these are bound to Shaders::GenericGL3D::Tangent4 or Shaders::GenericGL3D::Tangent based on their type.
• If the mesh contains Trade::MeshAttribute::Bitangent, these are bound to Shaders::GenericGL3D::Bitangent. However, if the mesh contains a Trade::MeshAttribute::ObjectId as well, only the first appearing of the two is bound. The second is ignored with a warning as they share the same binding slot.
• If the mesh contains Trade::MeshAttribute::Normal or if CompileFlag::GenerateFlatNormals / CompileFlag::GenerateSmoothNormals is set, these are bound to Shaders::GenericGL3D::Normal.
• If the mesh contains Trade::MeshAttribute::TextureCoordinates, these are bound to Shaders::GenericGL::TextureCoordinates.
• If the mesh contains Trade::MeshAttribute::Color, these are bound to Shaders::GenericGL::Color3 / Color4 based on their type.
• If the mesh contains Trade::MeshAttribute::JointIds and Trade::MeshAttribute::Weights, these are bound to Shaders::GenericGL::JointIds / SecondaryJointIds and Weights / SecondaryWeights according to rules described in compiledPerVertexJointCount().
• If the mesh contains Trade::MeshAttribute::ObjectId, these are bound to Shaders::GenericGL::ObjectId. However, if the mesh contains a Trade::MeshAttribute::Bitangent as well, only the first appearing of the two is bound. The second is ignored with a warning as they share the same binding slot.
• Custom attributes and known attributes of implementation-specific vertex formats are ignored with a warning. See compile(const Trade::MeshData&, GL::Buffer&, GL::Buffer&) for an example showing how to bind them manually, and CompileFlag::NoWarnOnCustomAttributes to suppress the warning.
• Implementation-specific Magnum::MeshPrimitive and Magnum::MeshIndexType values are passed as-is with meshPrimitiveUnwrap() and meshIndexTypeUnwrap(). It's the user responsibility to ensure an implementation-specific value is valid in this context.
• The index buffer is expected to be contiguous (size of the index type equal to Trade::MeshData::indexStride()). OpenGL doesn't support interleaved index buffers. In case the MeshIndexType is implementation-specific, this condition can't be checked and the buffer is assumed to be contiguous.
• Stride of all attributes is expected to be positive. OpenGL doesn't support zero and negative strides.

If normal generation is not requested, Trade::MeshData::indexData() and Trade::MeshData::vertexData() are uploaded as-is without any further modifications, keeping the original layout and vertex formats. If CompileFlag::GenerateSmoothNormals is requested, vertex data is interleaved together with the generated normals; if CompileFlag::GenerateFlatNormals is requested, the mesh is first deindexed and then the vertex data is interleaved together with the generated normals.

The generated mesh owns the index and vertex buffers and there's no possibility to access them afterwards. For alternative solutions see the compile(const Trade::MeshData&, GL::Buffer&, GL::Buffer&) overloads.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData& mesh) new in 2020.06

#include <Magnum/MeshTools/Compile.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData& mesh, GL::Buffer& indices, GL::Buffer& vertices) new in 2020.06

#include <Magnum/MeshTools/Compile.h>

Compile mesh data using external buffers.

Assumes the whole vertex / index data are already uploaded to indices / vertices and sets up the mesh using those. Can be used to have a single index/vertex buffer when multiple Trade::MeshData instances share the same data arrays, or to allow buffer access later. For example:

GL::Buffer indices{meshData.indexData()};
GL::Buffer vertices{meshData.vertexData()};
GL::Mesh mesh = MeshTools::compile(meshData, indices, vertices);

Another use case is specifying additional vertex attributes that are not recognized by the function itself. You can choose among various r-value overloads depending on whether you want to have the index/vertex buffers owned by the mesh or not:

struct MyShader: GL::AbstractShaderProgram {
    typedef GL::Attribute<…> MyCustomAttribute;

    …
};
Trade::MeshAttribute myCustomAttribute = …;

GL::Buffer indices{meshData.indexData()};
GL::Buffer vertices{meshData.vertexData()};

/* Let compile() handle the usual attributes and configure custom ones after */
GL::Mesh mesh = MeshTools::compile(meshData, std::move(indices), vertices);
mesh.addVertexBuffer(std::move(vertices),
    meshData.attributeOffset(myCustomAttribute),
    meshData.attributeStride(myCustomAttribute),
    GL::DynamicAttribute{
        MyShader::MyCustomAttribute{},
        meshData.attributeFormat(myCustomAttribute)
    });

If mesh is not indexed, the indices parameter is ignored — in that case you can pass a NoCreate-d instance to avoid allocating an unnecessary OpenGL buffer object.

Compared to compile(const Trade::MeshData&, CompileFlags), this function implicitly enables the CompileFlag::NoWarnOnCustomAttributes flag, assuming that custom attributes and attributes with implementation-specific formats are explicitly handled on the application side.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData& mesh, GL::Buffer& indices, GL::Buffer&& vertices) new in 2020.06

#include <Magnum/MeshTools/Compile.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData& mesh, GL::Buffer&& indices, GL::Buffer& vertices) new in 2020.06

#include <Magnum/MeshTools/Compile.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData& mesh, GL::Buffer&& indices, GL::Buffer&& vertices) new in 2020.06

#include <Magnum/MeshTools/Compile.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData2D& meshData)

#include <Magnum/MeshTools/Compile.h>

Compile 2D mesh data.

Configures a mesh for Shaders::GenericGL2D shader with vertex buffer and possibly also an index buffer, if the mesh is indexed. Positions are bound to Shaders::GenericGL2D::Position attribute. If the mesh contains texture coordinates, these are bound to Shaders::GenericGL2D::TextureCoordinates attribute. If the mesh contains colors, these are bound to Shaders::GenericGL3D::Color4 attribute. No data compression or index optimization (except for index buffer packing) is done, both the vertex buffer and the index buffer (if any) is owned by the mesh, both created with GL::BufferUsage::StaticDraw.

This is just a convenience function for creating generic meshes, you might want to use interleave() and compressIndices() functions together with GL::Mesh::setPrimitive(), GL::Mesh::setCount(), GL::Mesh::addVertexBuffer(), GL::Mesh::setIndexBuffer() instead for greater flexibility.

GL::Mesh Magnum::MeshTools::compile(const Trade::MeshData3D& meshData, CompileFlags flags = {})

#include <Magnum/MeshTools/Compile.h>

Compile 3D mesh data.

Configures mesh for Shaders::GenericGL3D shader with vertex buffer and possibly also index buffer, if the mesh is indexed. Positions are bound to Shaders::GenericGL3D::Position attribute. If the mesh contains normals, they are bound to Shaders::GenericGL3D::Normal attribute, texture coordinates are bound to Shaders::GenericGL3D::TextureCoordinates attribute. If the mesh contains colors, they are bound to Shaders::GenericGL3D::Color4 attribute. No data compression or index optimization (except for index buffer packing) is done, both the vertex buffer and the index buffer (if any) is owned by the mesh, both created with GL::BufferUsage::StaticDraw.

This is just a convenience function for creating generic meshes, you might want to use interleave() and compressIndices() functions together with GL::Mesh::setPrimitive(), GL::Mesh::setCount(), GL::Mesh::addVertexBuffer(), GL::Mesh::setIndexBuffer() instead for greater flexibility.

Containers::Pair<UnsignedInt, UnsignedInt> Magnum::MeshTools::compiledPerVertexJointCount(const Trade::MeshData& mesh) new in Git master

#include <Magnum/MeshTools/Compile.h>

Compiled per-vertex joint count for given mesh data.

Returns the count of bound primary and secondary per-vertex joint IDs and weights that a mesh returned from compile(const Trade::MeshData&, CompileFlags) would contain. The function goes over all Trade::MeshAttribute::JointIds and Weights attributes present in the mesh and assigns them to the primary and secondary binding points:

• If the mesh contains just one instance of joint ID and weight attributes and their Trade::MeshData::attributeArraySize() is not larger than 4, they occupy just the primary binding slot. The second returned value is 0.
• If the mesh contains more than one instance of joint ID and weight attributes and array size of the first instance is not larger than 4, the first instance goes to the primary binding slot and the first up to 4 array components of the second instance go to the secondary slot. Remaining array components of the second instance and all remaining instances of joint ID and weight attributes are ignored.
• If array size of the first instance of joint ID and weight attributes is larger than 4, the first slot uses the first 4 array components and the second the next up to 4 array components. Remaining array components of the first instance and all remaining instances of joint ID and weight attributes are ignored.

Useful to get subsequently fed to Shaders::FlatGL::Configuration::setJointCount() or to Shaders::FlatGL::setPerVertexJointCount() if Shaders::FlatGL::Flag::DynamicPerVertexJointCount is enabled, and similarly with other builtin shaders.

GL::Mesh Magnum::MeshTools::compileLines(const Trade::MeshData& mesh) new in Git master

#include <Magnum/MeshTools/CompileLines.h>

Compile a line mesh for use with Shaders::LineGL.

Expects that the mesh is returned from generateLines(), see its documentation for more information.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

Compress an index array.

This function compresses indices to the smallest possible size. For example when your indices have the maximum vertex index 463, it's wasteful to store them in array of 32-bit integers, array of 16-bit integers is sufficient. The atLeast parameter allows you to specify the smallest type to use and it defaults to MeshIndexType::UnsignedShort as 8-bit types are not friendly to many GPUs (and for example unextended Vulkan or D3D12 don't even support them). It's also possible to choose a type larger than the input type to "inflate" an index buffer of a smaller type. Example usage:

Containers::Array<UnsignedInt> indices;

Containers::Pair<Containers::Array<char>, MeshIndexType> compressed =
    MeshTools::compressIndices(indices);

GL::Buffer indexBuffer;
indexBuffer.setData(compressed.first());

GL::Mesh mesh;
mesh.setCount(indices.size())
    .setIndexBuffer(indexBuffer, 0, compressed.second());

In case the indices all start from a large offset, the offset parameter can be used to subtract it, allowing them to be compressed even further. For example, if all indices are in range (which fits only into a 32-bit type), subtracting 75000 makes them in range which fits into 16 bits. Note that you also need to update vertex attribute offsets accordingly. Example:

Containers::ArrayView<const UnsignedInt> indices;
UnsignedInt offset = Math::min(indices);
Containers::Pair<Containers::Array<char>, MeshIndexType> compressed =
    MeshTools::compressIndices(indices, offset);

// use `offset` to adjust vertex attribute offset …

A negative offset value will do an operation inverse to the above. See also compressIndices(const Trade::MeshData&, MeshIndexType) that can do this operation directly on a Trade::MeshData instance.

The atLeast parameter is expected to not be an implementation-specific type.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, Long offset) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Same as compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>&, MeshIndexType, Long) with atLeast set to MeshIndexType::UnsignedShort.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, Long offset) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Same as compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>&, MeshIndexType, Long) with atLeast set to MeshIndexType::UnsignedShort.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, Long offset) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Same as compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>&, MeshIndexType, Long) with atLeast set to MeshIndexType::UnsignedShort.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView2D<const char>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

Compress a type-erased index array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>&, MeshIndexType, Long) etc. overloads.

The atLeast parameter is expected to not be an implementation-specific type.

Containers::Pair<Containers::Array<char>, MeshIndexType> Magnum::MeshTools::compressIndices(const Containers::StridedArrayView2D<const char>& indices, Long offset) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Same as compressIndices(const Containers::StridedArrayView2D<const char>&, MeshIndexType, Long) with atLeast set to MeshIndexType::UnsignedShort.

Trade::MeshData Magnum::MeshTools::compressIndices(const Trade::MeshData& mesh, MeshIndexType atLeast = MeshIndexType::UnsignedShort) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

Compress mesh data indices.

Does the same as compressIndices(const Containers::StridedArrayView2D<const char>&, MeshIndexType, Long), but together with adjusting vertex attribute offsets in the passed Trade::MeshData instance. This function will unconditionally make a copy of all vertex data, use compressIndices(Trade::MeshData&&, MeshIndexType) to avoid that copy.

The mesh is expected to be indexed and the index type and the atLeast parameter is expected to not be implementation-specific type.

Trade::MeshData Magnum::MeshTools::compressIndices(Trade::MeshData&& mesh, MeshIndexType atLeast = MeshIndexType::UnsignedShort) new in 2020.06

#include <Magnum/MeshTools/CompressIndices.h>

Compress mesh data indices.

Compared to compressIndices(const Trade::MeshData&, MeshIndexType) this function can transfer ownership of data vertex buffer (in case it is owned) to the returned instance instead of making a copy of it. Index and attribute data are copied always.

std::tuple<Containers::Array<char>, MeshIndexType, UnsignedInt, UnsignedInt> Magnum::MeshTools::compressIndices(const std::vector<UnsignedInt>& indices)

#include <Magnum/MeshTools/CompressIndices.h>

Compress vertex indices.

This function takes index array and outputs them compressed to smallest possible size. For example when your indices have maximum number 463, it's wasteful to store them in array of 32bit integers, array of 16bit integers is sufficient.

Example usage:

std::vector<UnsignedInt> indices;

Containers::Array<char> indexData;
MeshIndexType indexType;
UnsignedInt indexStart, indexEnd;
std::tie(indexData, indexType, indexStart, indexEnd) =
    MeshTools::compressIndices(indices);

GL::Buffer indexBuffer;
indexBuffer.setData(indexData, GL::BufferUsage::StaticDraw);

GL::Mesh mesh;
mesh.setCount(indices.size())
    .setIndexBuffer(indexBuffer, 0, indexType, indexStart, indexEnd);

#include <Magnum/MeshTools/CompressIndices.h>

template<class T>

Containers::Array<T> Magnum::MeshTools::compressIndicesAs(const std::vector<UnsignedInt>& indices)

Compress vertex indices as given type.

The type can be either UnsignedByte, UnsignedShort or UnsignedInt. Values in the index array are expected to be representable with given type.

Example usage:

std::vector<UnsignedInt> indices;
Containers::Array<UnsignedShort> indexData =
    MeshTools::compressIndicesAs<UnsignedShort>(indices);

Trade::MeshData Magnum::MeshTools::concatenate(const Containers::Iterable<const Trade::MeshData>& meshes, InterleaveFlags flags = InterleaveFlag::PreserveInterleavedAttributes) new in 2020.06

#include <Magnum/MeshTools/Concatenate.h>

Concatenate meshes together.

The returned mesh contains vertices from all meshes concatenated together. If any mesh is indexed (expected to not have an implementation-specific index type), the resulting mesh is indexed as well, with indices adjusted for vertex offsets of particular meshes. The behavior is undefined if any mesh has indices out of range for its particular vertex count. Meshes with MeshPrimitive::LineStrip, MeshPrimitive::LineLoop, MeshPrimitive::TriangleStrip and MeshPrimitive::TriangleFan can't be concatenated — use generateIndices() to turn them into MeshPrimitive::Lines or MeshPrimitive::Triangles first. The meshes array is expected to have at least one item.

All attributes from the first mesh are taken, expected to not have an implementation-specific format. For each following mesh attributes present in the first are copied, superfluous attributes ignored and missing attributes zeroed out. Matching attributes are expected to have the same type, all meshes are expected to have the same primitive. In case of array attributes, attributes in subsequent meshes are expected to be arrays as well and have the same or smaller array size. Unused components at the end are zeroed out. The vertex data are concatenated in the same order as passed, with no duplicate removal. Returned instance vertex and index data flags always have both Trade::DataFlag::Owned and Trade::DataFlag::Mutable to guarante mutable access to particular parts of the concatenated mesh — for example for applying transformations.

The data layouting is done by interleavedLayout() with the flags parameter propagated to it, see its documentation for detailed behavior description.

If an index buffer is needed, MeshIndexType::UnsignedInt is always used. Call compressIndices(const Trade::MeshData&, MeshIndexType) on the result to compress it to a smaller type, if desired.

#include <Magnum/MeshTools/Concatenate.h>

template<template<class> class Allocator = Containers::ArrayAllocator>

void Magnum::MeshTools::concatenateInto(Trade::MeshData& destination, const Containers::Iterable<const Trade::MeshData>& meshes, InterleaveFlags flags = InterleaveFlag::PreserveInterleavedAttributes) new in 2020.06

Concatenate a list of meshes into a pre-existing destination, enlarging it if necessary.

Compared to concatenate(const Containers::Iterable<const Trade::MeshData>&, InterleaveFlags) this function resizes existing index and vertex buffers in destination using Containers::arrayResize() and given allocator, and reuses its atttribute data array instead of always allocating new ones. Only the attribute layout from destination is used, all vertex/index data are taken from meshes. Expects that meshes contains at least one item.

Trade::MeshData Magnum::MeshTools::copy(const Trade::MeshData& mesh) new in Git master

#include <Magnum/MeshTools/Copy.h>

Make an owned copy of the mesh.

Allocates a copy of Trade::MeshData::indexData(), vertexData() and attributeData() and returns a new mesh with them. All other properties such as the primitive or importer state are passed through unchanged, the data layout isn't changed in any way. The resulting Trade::MeshData::indexDataFlags() and vertexDataFlags() are always Trade::DataFlag::Owned and Trade::DataFlag::Mutable. Attributes that were offset-only before are kept offset-only, others have offsets recalculated against the newly-allocated vertex data.

Trade::MeshData Magnum::MeshTools::copy(Trade::MeshData&& mesh) new in Git master

#include <Magnum/MeshTools/Copy.h>

Make a mesh with owned data.

If Trade::MeshData::indexDataFlags() or vertexDataFlags() are not Trade::DataFlag::Owned and Trade::DataFlag::Mutable or the attribute data don't have the default deleter, allocates a copy of Trade::MeshData::indexData(), vertexData() or attributeData(), otherwise transfers their ownership. The resulting data are always owned and mutable, the data layout isn't changed in any way. Attributes that were offset-only before are kept offset-only, others have offsets recalculated against the potentially-newly-allocated vertex data.

Trade::MeshData Magnum::MeshTools::reference(const Trade::MeshData& mesh) new in 2020.06

#include <Magnum/MeshTools/Copy.h>

Create an immutable reference on a Trade::MeshData.

The returned instance has empty Trade::MeshData::indexDataFlags() and Trade::MeshData::vertexDataFlags() and references attribute data from the mesh as well. The function performs no allocation or data copy. Use copy() for an inverse operation.

Trade::MeshData Magnum::MeshTools::mutableReference(Trade::MeshData& mesh) new in 2020.06

#include <Magnum/MeshTools/Copy.h>

Create a mutable reference on a Trade::MeshData.

The returned instance has Trade::MeshData::indexDataFlags() and Trade::MeshData::vertexDataFlags() set to Trade::DataFlag::Mutable. The function performs no allocation or data copy. Use copy() for an inverse operation. Expects that mesh is mutable.

#include <Magnum/MeshTools/Duplicate.h>

template<class IndexType, class T>

Containers::Array<T> Magnum::MeshTools::duplicate(const Containers::StridedArrayView1D<const IndexType>& indices, const Containers::StridedArrayView1D<const T>& data) new in 2019.10

Duplicate data using given index array.

Converts indexed array to non-indexed, for example data {a, b, c, d} with index array {1, 1, 0, 3, 2, 2} will be converted to {b, b, a, d, c, c}. The resulting array size is the same as size of indices, expects that all indices are in range for the data array.

If you want to fill an existing memory (or, for example a std::vector), use duplicateInto().

#include <Magnum/MeshTools/Duplicate.h>

template<class T>

std::vector<T> Magnum::MeshTools::duplicate(const std::vector<UnsignedInt>& indices, const std::vector<T>& data)

Duplicate data using given index array.

#include <Magnum/MeshTools/Duplicate.h>

template<class IndexType, class T>

void Magnum::MeshTools::duplicateInto(const Containers::StridedArrayView1D<const IndexType>& indices, const Containers::StridedArrayView1D<const T>& data, const Containers::StridedArrayView1D<T>& out) new in 2019.10

Duplicate data using an index array into given output array.

A variant of duplicate() that fills existing memory instead of allocating a new array. Expects that out has the same size as indices and all indices are in range for the data array.

void Magnum::MeshTools::duplicateInto(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Containers::StridedArrayView2D<const char>& data, const Containers::StridedArrayView2D<char>& out) new in 2020.06

#include <Magnum/MeshTools/Duplicate.h>

Duplicate type-erased data using an index array into given output array.

Compared to duplicateInto(const Containers::StridedArrayView1D<const IndexType>&, const Containers::StridedArrayView1D<const T>&, const Containers::StridedArrayView1D<T>&) accepts a 2D view, where the second dimension spans the actual type. Expects that out has the same size as indices and all indices are in range for the data array, and that the second dimension of both data and out is contiguous and has the same size.

void Magnum::MeshTools::duplicateInto(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Containers::StridedArrayView2D<const char>& data, const Containers::StridedArrayView2D<char>& out) new in 2020.06

#include <Magnum/MeshTools/Duplicate.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::duplicateInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView2D<const char>& data, const Containers::StridedArrayView2D<char>& out) new in 2020.06

#include <Magnum/MeshTools/Duplicate.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::duplicateInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView2D<const char>& data, const Containers::StridedArrayView2D<char>& out) new in 2020.06

#include <Magnum/MeshTools/Duplicate.h>

Duplicate type-erased data using a type-erased index array into given output array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the duplicateInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView2D<const char>&, const Containers::StridedArrayView2D<char>&) etc. overloads.

Trade::MeshData Magnum::MeshTools::duplicate(const Trade::MeshData& mesh, Containers::ArrayView<const Trade::MeshAttributeData> extra = {}) new in 2020.06

#include <Magnum/MeshTools/Duplicate.h>

Duplicate indexed mesh data.

Returns a copy of mesh that's not indexed and has all attributes interleaved and duplicated according to mesh's index buffer. The extra attributes, if any, are duplicated and interleaved together with existing attributes (or, in case the attribute view is empty, only the corresponding space for given attribute type is reserved, with memory left uninitialized). The data layouting is done by interleavedLayout(), see its documentation for detailed behavior description. Note that offset-only Trade::MeshAttributeData instances are not supported in the extra array.

Expects that mesh is indexed with a non-implementation-specific index type and each attribute in extra has either the same amount of elements as mesh vertex count (not index count) or has none. All attributes are expected to not have an implementation-specific format.

Trade::MeshData Magnum::MeshTools::duplicate(const Trade::MeshData& mesh, std::initializer_list<Trade::MeshAttributeData> extra) new in 2020.06

#include <Magnum/MeshTools/Duplicate.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Trade::MeshData Magnum::MeshTools::filterAttributes(const Trade::MeshData& mesh, Containers::BitArrayView attributesToKeep) new in Git master

#include <Magnum/MeshTools/Filter.h>

Filter a mesh to contain only the selected subset of attributes.

Returns a non-owning reference to the vertex and index buffer from mesh with only the attributes for which the corresponding bit in attributesToKeep was set. The index buffer, if present, is left untouched. The size of attributesToKeep is expected to be equal to Trade::MeshData::attributeCount().

This function only operates on the attribute metadata — if you'd like to have the vertex data repacked to contain just the remaining attributes as well, pass the output to interleave() without InterleaveFlag::PreserveInterleavedAttributes set.

Trade::MeshData Magnum::MeshTools::filterOnlyAttributes(const Trade::MeshData& mesh, Containers::ArrayView<const Trade::MeshAttribute> attributes) new in Git master

#include <Magnum/MeshTools/Filter.h>

Filter a mesh to contain only the selected subset of named attributes.

Returns a non-owning reference to the vertex and index buffer from mesh with only the attributes that are listed in attributes. The index buffer, if present, is left untouched. Attributes from the list that are not present in mesh are skipped, duplicates in the list are treated the same as if given attribute was listed just once. If given attribute is present multiple times in the mesh (such as secondary colors or texture coordinates), all its occurences are kept — if you want a different behavior, use the filterOnlyAttributes(const Trade::MeshData&, Containers::ArrayView<const UnsignedInt>) overload and pick attributes by their IDs instead.

This function only operates on the attribute metadata — if you'd like to have the vertex data repacked to contain just the remaining attributes as well, pass the output to interleave() without InterleaveFlag::PreserveInterleavedAttributes set.

Trade::MeshData Magnum::MeshTools::filterOnlyAttributes(const Trade::MeshData& mesh, std::initializer_list<Trade::MeshAttribute> attributes) new in Git master

#include <Magnum/MeshTools/Filter.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Trade::MeshData Magnum::MeshTools::filterExceptAttributes(const Trade::MeshData& mesh, Containers::ArrayView<const Trade::MeshAttribute> attributes) new in Git master

#include <Magnum/MeshTools/Filter.h>

Filter a mesh to contain everything except the selected subset of named attributes.

Returns a non-owning reference to the vertex and index buffer from mesh with only the attributes that are not listed in attributes. The index buffer, if present, is left untouched. Attributes from the list that are not present in mesh are skipped, duplicates in the list are treated the same as if given attribute was listed just once. If given attribute is present multiple times in the mesh (such as secondary colors or texture coordinates), all its occurences are removed — if you want a different behavior, use the filterOnlyAttributes(const Trade::MeshData&, Containers::ArrayView<const UnsignedInt>) overload and pick attributes by their IDs instead.

This function only operates on the attribute metadata — if you'd like to have the vertex mesh repacked to contain just the remaining attributes as well, pass the output to interleave() without InterleaveFlag::PreserveInterleavedAttributes set.

Trade::MeshData Magnum::MeshTools::filterExceptAttributes(const Trade::MeshData& mesh, std::initializer_list<Trade::MeshAttribute> attributes) new in Git master

#include <Magnum/MeshTools/Filter.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Trade::MeshData Magnum::MeshTools::filterOnlyAttributes(const Trade::MeshData& mesh, Containers::ArrayView<const UnsignedInt> attributes)

#include <Magnum/MeshTools/FilterAttributes.h>

Filter a mesh to contain only the selected subset of attributes.

Returns a non-owning reference to the vertex and index buffer from mesh with only the attribute IDs listed in attributes. IDs specified more than once don't result in given attribute being added multiple times. The index buffer, if present, is left untouched. All attribute IDs are expected to be smaller than Trade::MeshData::attributeCount() const.

This function only operates on the attribute metadata — if you'd like to have the vertex data repacked to contain just the remaining attributes as well, pass the output to interleave() without InterleaveFlag::PreserveInterleavedAttributes set.

Trade::MeshData Magnum::MeshTools::filterOnlyAttributes(const Trade::MeshData& mesh, std::initializer_list<UnsignedInt> attributes)

#include <Magnum/MeshTools/FilterAttributes.h>

Filter a mesh to contain only the selected subset of attributes.

Trade::MeshData Magnum::MeshTools::filterExceptAttributes(const Trade::MeshData& mesh, Containers::ArrayView<const UnsignedInt> attributes)

#include <Magnum/MeshTools/FilterAttributes.h>

Filter a mesh to contain everything except the selected subset of attributes.

Returns a non-owning reference to the vertex and index buffer from mesh with only the attribute IDs that are not listed in attributes. IDs specified multiple times behave like if specified just once. The index buffer, if present, is left untouched. All attribute IDs are expected to be smaller than Trade::MeshData::attributeCount() const. If attributes is empty, the behavior is equivalent to reference().

This function only operates on the attribute metadata — if you'd like to have the vertex data repacked to contain just the remaining attributes as well, pass the output to interleave() without InterleaveFlag::PreserveInterleavedAttributes set.

Trade::MeshData Magnum::MeshTools::filterExceptAttributes(const Trade::MeshData& mesh, std::initializer_list<UnsignedInt> attributes)

#include <Magnum/MeshTools/FilterAttributes.h>

Filter a mesh to contain everything except the selected subset of attributes.

void Magnum::MeshTools::flipNormalsInPlace(const Containers::StridedArrayView1D<UnsignedInt>& indices, const Containers::StridedArrayView1D<Vector3>& normals) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

Flip mesh normals and face winding in-place.

Flips normal vectors and face winding in index array for face culling to work properly too. See also flipNormalsInPlace(const Containers::StridedArrayView1D<Vector3>&) and flipFaceWindingInPlace(), which flip normals or face winding only. Expects a triangle mesh, thus the index count has to be divisible by 3.

void Magnum::MeshTools::flipNormalsInPlace(const Containers::StridedArrayView1D<UnsignedShort>& indices, const Containers::StridedArrayView1D<Vector3>& normals) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::flipNormalsInPlace(const Containers::StridedArrayView1D<UnsignedByte>& indices, const Containers::StridedArrayView1D<Vector3>& normals) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::flipNormalsInPlace(const Containers::StridedArrayView2D<char>& indices, const Containers::StridedArrayView1D<Vector3>& normals) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

Flip mesh normals and face winding in-place on a type-erased index array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the flipNormalsInPlace(const Containers::StridedArrayView1D<UnsignedInt>&, const Containers::StridedArrayView1D<Vector3>&) etc. overloads.

void Magnum::MeshTools::flipNormals(std::vector<UnsignedInt>& indices, std::vector<Vector3>& normals)

#include <Magnum/MeshTools/FlipNormals.h>

Flip mesh normals and face winding in-place.

void Magnum::MeshTools::flipFaceWindingInPlace(const Containers::StridedArrayView1D<UnsignedInt>& indices) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

Flip face winding in-place.

Same as flipNormalsInPlace(const Containers::StridedArrayView1D<UnsignedInt>&, const Containers::StridedArrayView1D<Vector3>&), but flips only face winding. Expects a triangle mesh, thus the index count has to be divisible by 3.

void Magnum::MeshTools::flipFaceWindingInPlace(const Containers::StridedArrayView1D<UnsignedShort>& indices) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::flipFaceWindingInPlace(const Containers::StridedArrayView1D<UnsignedByte>& indices) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::flipFaceWindingInPlace(const Containers::StridedArrayView2D<char>& indices) new in 2020.06

#include <Magnum/MeshTools/FlipNormals.h>

Flip face winding in-place on a type-erased index array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the flipFaceWindingInPlace(const Containers::StridedArrayView1D<UnsignedInt>&) etc. overloads.

void Magnum::MeshTools::flipFaceWinding(std::vector<UnsignedInt>& indices)

#include <Magnum/MeshTools/FlipNormals.h>

Flip face winding in-place.

void Magnum::MeshTools::flipNormalsInPlace(const Containers::StridedArrayView1D<Vector3>& normals)

#include <Magnum/MeshTools/FlipNormals.h>

Flip mesh normals in-place.

Same as flipNormalsInPlace(const Containers::StridedArrayView1D<UnsignedInt>&, const Containers::StridedArrayView1D<Vector3>&), but flips only normals, not face winding.

void Magnum::MeshTools::flipNormals(std::vector<Vector3>& normals)

#include <Magnum/MeshTools/FlipNormals.h>

Flip mesh normals in-place.

GL::Mesh Magnum::MeshTools::fullScreenTriangle(GL::Version version)

#include <Magnum/MeshTools/FullScreenTriangle.h>

Full screen triangle mesh.

Returns a pre-configured mesh along with vertex buffer which can be used for full-screen post-processing effects. The mesh is a single triangle covering whole screen area ( in both dimensions) and provides only vertex positions, as other attributes (such as texture coordinates) can be calculated from them. The vertex positions are, in order:

Based on the version parameter, on OpenGL 2.1, OpenGL ES 2.0 and WebGL 1 the vertex positions are passed explicitly as attribute 0, contained in a vertex buffer owned by the mesh. On OpenGL 3.0+, OpenGL ES 3.0+ and WebGL 2 the mesh is attribute-less and the vertex positions can be calculated using the gl_VertexID builtin shader variable.

Calculating positions in the shader in a portable way can be done like this. For OpenGL 2.1 and OpenGL ES 2.0 you then need to bind location of the position attribute to 0.

#if (!defined(GL_ES) && __VERSION__ >= 130) || (defined(GL_ES) && __VERSION__ >= 300)
#define NEW_GLSL
#endif

#ifndef NEW_GLSL
attribute lowp vec4 position;
#endif

void main() {
    #ifdef NEW_GLSL
    gl_Position = vec4((gl_VertexID == 2) ?  3.0 : -1.0,
                       (gl_VertexID == 1) ? -3.0 :  1.0, 0.0, 1.0);
    #else
    gl_Position = position;
    #endif
}

GL::Mesh Magnum::MeshTools::fullScreenTriangle()

#include <Magnum/MeshTools/FullScreenTriangle.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

This function implicitly uses current context version.

UnsignedInt Magnum::MeshTools::primitiveCount(MeshPrimitive primitive, UnsignedInt elementCount) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Actual primitive count for given primitive type and element count.

Returns how many primitives is generated for given primitive and elementCount, for example for MeshPrimitive::Triangles returns elementCount/3. Expects that primitive is valid, elementCount is either zero or at least 2 for a line-based primitive and at least 3 for a triangle-based primitive, is divisible by 2 for MeshPrimitive::Lines and by 3 for MeshPrimitive::Triangles.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTrivialIndices(UnsignedInt vertexCount) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create a trivial index buffer.

Generates a 0, 1, 2, 3, 4, 5, ... sequence, i.e. what std::iota() would produce. Can be used to turn a non-indexed mesh into indexed.

void Magnum::MeshTools::generateTrivialIndicesInto(const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create a trivial index buffer into an existing array.

A variant of generateTrivialIndices() that fills existing memory instead of allocating a new array.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineStripIndices(UnsignedInt vertexCount) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line strip primitive.

Generates a 0, 1, 1, 2, 3, 4, ... sequence. Can be used to convert a MeshPrimitive::LineStrip mesh to MeshPrimitive::Lines. The vertexCount is expected to be either 0 or at least 2. Primitive restart is not supported. If the mesh is already indexed, use generateLineStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) and overloads instead.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed line strip primitive.

Like generateLineStripIndices(UnsignedInt), but merges indices into the generated line strip index buffer.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineStripIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineStripIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineStripIndices(const Containers::StridedArrayView2D<const char>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line strip primitive with a type-erased index buffer.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateLineStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) etc. overloads.

void Magnum::MeshTools::generateLineStripIndicesInto(UnsignedInt vertexCount, const Containers::StridedArrayView1D<UnsignedInt>& output) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line strip primitive into an existing array.

A variant of generateLineStripIndices() that fills existing memory instead of allocating a new array. The vertexCount is expected to be either 0 or at least 2, the output array is expected to have a size of 2*(vertexCount - 1). Primitive restart is not supported. If the mesh is already indexed, use generateLineStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) and overloads instead.

void Magnum::MeshTools::generateLineStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed line strip primitive into an existing array.

Like generateLineStripIndicesInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&), but merges indices into the generated line strip index buffer.

void Magnum::MeshTools::generateLineStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateLineStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateLineStripIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line strip primitive with a type-erased index buffer into an existing array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateLineStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) etc. overloads.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineLoopIndices(UnsignedInt vertexCount) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line loop primitive.

Generates a 0, 1, 1, 2, 3, ..., 0 sequence. Can be used to convert a MeshPrimitive::LineLoop mesh to MeshPrimitive::Lines. The vertexCount is expected to be either 0 or at least 2. Primitive restart is not supported. If the mesh is already indexed, use generateLineLoopIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) and overloads instead.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineLoopIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed line loop primitive.

Like generateLineLoopIndices(UnsignedInt), but merges indices into the generated line loop index buffer.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineLoopIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineLoopIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateLineLoopIndices(const Containers::StridedArrayView2D<const char>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line loop primitive with a type-erased index buffer.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateLineLoopIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) etc. overloads.

void Magnum::MeshTools::generateLineLoopIndicesInto(UnsignedInt vertexCount, const Containers::StridedArrayView1D<UnsignedInt>& output) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line loop primitive into an existing array.

A variant of generateLineLoopIndices() that fills existing memory instead of allocating a new array. The vertexCount is expected to be either 0 or at least 2, the output array is expected to have a size of 2*vertexCount. Primitive restart is not supported.If the mesh is already indexed, use generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) and overloads instead.

void Magnum::MeshTools::generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed line loop primitive into an existing array.

Like generateLineLoopIndicesInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&), but merges indices into the generated line loop index buffer.

void Magnum::MeshTools::generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateLineLoopIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a line loop primitive with a type-erased index buffer into an existing array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) etc. overloads.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleStripIndices(UnsignedInt vertexCount) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle strip primitive.

Generates a 0, 1, 2, 2, 1, 3, 2, 3, 4, ... sequence. Can be used to convert a MeshPrimitive::TriangleStrip mesh to MeshPrimitive::Triangles. The vertexCount is expected to be either 0 or at least 3. Primitive restart is not supported. If the mesh is already indexed, use generateTriangleStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) and overloads instead.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed triangle strip primitive.

Like generateTriangleStripIndices(UnsignedInt), but merges indices into the generated triangle strip index buffer.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleStripIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleStripIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleStripIndices(const Containers::StridedArrayView2D<const char>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle strip primitive with a type-erased index buffer.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateTriangleStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) etc. overloads.

void Magnum::MeshTools::generateTriangleStripIndicesInto(UnsignedInt vertexCount, const Containers::StridedArrayView1D<UnsignedInt>& output) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle strip primitive into an existing array.

A variant of generateTriangleStripIndices() that fills existing memory instead of allocating a new array. The vertexCount is expected to be either 0 or at least 3, the output array is expected to have a size of 3*(vertexCount - 2). Primitive restart is not supported. If the mesh is already indexed, use generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) and overloads instead.

void Magnum::MeshTools::generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed triangle strip primitive into an existing array.

Like generateTriangleStripIndicesInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&), but merges indices into the generated triangle strip index buffer.

void Magnum::MeshTools::generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateTriangleStripIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle strip primitive with a type-erased index buffer into an existing array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) etc. overloads.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleFanIndices(UnsignedInt vertexCount) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle fan primitive.

Generates a 0, 1, 2, 0, 2, 3, 0, 3, 4, ... sequence. Can be used to convert a MeshPrimitive::TriangleFan mesh to MeshPrimitive::Triangles. The vertexCount is expected to be either 0 or at least 3. Primitive restart is not supported. If the mesh is already indexed, use generateTriangleFanIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) and overloads instead.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleFanIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed triangle fan primitive.

Like generateTriangleFanIndices(UnsignedInt), but merges indices into the generated triangle fan index buffer.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleFanIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleFanIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateTriangleFanIndices(const Containers::StridedArrayView2D<const char>& indices) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle fan primitive with a type-erased index buffer.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateTriangleFanIndices(const Containers::StridedArrayView1D<const UnsignedInt>&) etc. overloads.

void Magnum::MeshTools::generateTriangleFanIndicesInto(UnsignedInt vertexCount, const Containers::StridedArrayView1D<UnsignedInt>& output) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle fan primitive into an existing array.

A variant of generateTriangleFanIndices() that fills existing memory instead of allocating a new array. The vertexCount is expected to be either 0 or at least 3, the output array is expected to have a size of 3*(vertexCount - 2). Primitive restart is not supported. If the mesh is already indexed, use generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) and overloads instead.

void Magnum::MeshTools::generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for an indexed triangle fan primitive into an existing array.

Like generateTriangleFanIndicesInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&), but merges indices into the generated triangle fan index buffer.

void Magnum::MeshTools::generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateTriangleFanIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create index buffer for a triangle fan primitive with a type-erased index buffer into an existing array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&) etc. overloads.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedInt>& quads) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create a triangle index buffer for quad primitives.

For each quad ABCD gives a pair of triangles that is either ABC ACD or DAB DBC, correctly handling cases of non-convex quads and avoiding thin triangles where possible. Loosely based on this SO question:

1. If normals of triangles ABC and ACD point in opposite direction and DAB DBC not (which is equivalent to points D and B being on the same side of a diagonal AC in a two-dimensional case), split as DAB DBC
2. Otherwise, if normals of triangles DAB and DBC point in opposite direction and ABC ACD not (which is equivalent to points A and C being on the same side of a diagonal DB in a two-dimensional case), split as ABC ACD
3. Otherwise the normals either point in the same direction in both cases or the quad is non-planar and ambiguous, pick the case where the diagonal is shorter

Size of quads is expected to be divisible by 4 and all indices being in bounds of the positions view.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedShort>& quads) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<UnsignedInt> Magnum::MeshTools::generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedByte>& quads) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateQuadIndicesInto(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedInt>& quads, const Containers::StridedArrayView1D<UnsignedInt>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

Create a triangle index buffer for quad primitives into an existing array.

A variant of generateQuadIndices() that fills existing memory instead of allocating a new array. Size of quads is expected to be divisible by 4 and output should have a size that's quads.size()*6/4.

void Magnum::MeshTools::generateQuadIndicesInto(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedShort>& quads, const Containers::StridedArrayView1D<UnsignedShort>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::MeshTools::generateQuadIndicesInto(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedByte>& quads, const Containers::StridedArrayView1D<UnsignedByte>& output) new in Git master

#include <Magnum/MeshTools/GenerateIndices.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Trade::MeshData Magnum::MeshTools::generateIndices(const Trade::MeshData& mesh) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Convert a mesh to plain indexed lines or triangles.

If mesh is one of MeshPrimitive::LineStrip, MeshPrimitive::LineLoop, MeshPrimitive::TriangleStrip or MeshPrimitive::TriangleFan primitives, calls one of generateLineStripIndices(), generateLineLoopIndices(), generateTriangleStripIndices() or generateTriangleFanIndices() functions or their indexed overloads to generate the index buffer. In that case expects that the mesh has either 0 vertices or at least 2 vertices for a line-based primitive and 3 vertices for a triangle-based primitive. If mesh is a different MeshPrimitive, it's passed through unchanged if already indexed, and with indices generated using generateTrivialIndices() otherwise.

If mesh is already indexed, the index type is expected to be non-implementation-specific.

The resulting mesh always has MeshIndexType::UnsignedInt, call compressIndices(const Trade::MeshData&, MeshIndexType) on the result to compress it to a smaller type, if desired. This function will unconditionally make a copy of all vertex data, use generateIndices(Trade::MeshData&&) to avoid that copy.

Trade::MeshData Magnum::MeshTools::generateIndices(Trade::MeshData&& mesh) new in 2020.06

#include <Magnum/MeshTools/GenerateIndices.h>

Convert a mesh to plain indexed lines or triangles.

Compared to generateIndices(const Trade::MeshData&) this function can transfer ownership of mesh vertex buffer (in case it is owned) to the returned instance instead of making a copy of it, and index buffer as well if it's owned, doesn't need expanding and is already with MeshIndexType::UnsignedInt. Attribute data is copied always.

Trade::MeshData Magnum::MeshTools::generateLines(const Trade::MeshData& lineMesh) new in Git master

#include <Magnum/MeshTools/GenerateLines.h>

Generate a line mesh for use with Shaders::LineGL.

Creates a MeshPrimitive::Triangles mesh with MeshIndexType::UnsignedInt indices, all input attributes preserved in their original format, and additionally with custom attributes corresponding to Shaders::LineGL::PreviousPosition and Shaders::LineGL::NextPosition added in the same format as the input Trade::MeshAttribute::Position, and a custom attribute corresponding to the Shaders::LineGL::Annotation attribute as VertexFormat::UnsignedInt. See documentation of the shader for details about the internal representation.

Each line segment in the input vertices is converted to a quad, with first two vertices inheriting vertex data from the first point of the segment and second two vertices inheriting data from the second point of the segment. If the input mesh is indexed, it's deindexed first. Neighbor information from a MeshPrimitive::LineStrip or MeshPrimitive::LineLoop mesh is used to form a single contiguous strip or a loop, MeshPrimitive::Lines is treated as loose segments.

For compatibility with shaders other than Shaders::LineGL, the output mesh can be also interpreted as indexed MeshPrimitive::Lines — out of every six indices forming a quad, two will form a line segment between the two original points, and the remaining four collapse into two degenerate line segments.

Expects that the mesh contains at least a Trade::MeshAttribute::Position and is a line MeshPrimitive.

The returned Trade::MeshData instance is meant to be passed to compileLines() for use with the shader. It can however be also processed with other MeshTools first, such as compressIndices(const Trade::MeshData&, MeshIndexType) or concatenate().

Containers::Array<Vector3> Magnum::MeshTools::generateFlatNormals(const Containers::StridedArrayView1D<const Vector3>& positions) new in 2019.10

#include <Magnum/MeshTools/GenerateNormals.h>

Generate flat normals.

All vertices in each triangle face get the same normal vector. Expects that the position count is divisible by 3. If you need to generate flat normals for an indexed mesh, duplicate() the vertices first, after the operation you might want to remove the duplicates again using removeDuplicatesInPlace(). Example usage:

Containers::ArrayView<UnsignedInt> indices;
Containers::ArrayView<Vector3> indexedPositions;

Containers::Array<Vector3> positions =
    MeshTools::duplicate<UnsignedInt, Vector3>(indices, indexedPositions);

Containers::Array<Vector3> normals =
    MeshTools::generateFlatNormals(positions);

void Magnum::MeshTools::generateFlatNormalsInto(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<Vector3>& normals) new in 2019.10

#include <Magnum/MeshTools/GenerateNormals.h>

Generate flat normals into an existing array.

A variant of generateFlatNormals() that fills existing memory instead of allocating a new array. The normals array is expected to have the same size as positions.

Useful when you need to interface for example with STL containers — in that case #include Corrade/Containers/ArrayViewStl.h to get implicit conversions:

#include <Corrade/Containers/ArrayViewStl.h>

// …

std::vector<Vector3> positions;

std::vector<Vector3> normals{positions.size()};
MeshTools::generateFlatNormalsInto(positions, normals);

std::pair<std::vector<UnsignedInt>, std::vector<Vector3>> Magnum::MeshTools::generateFlatNormals(const std::vector<UnsignedInt>& indices, const std::vector<Vector3>& positions)

#include <Magnum/MeshTools/GenerateNormals.h>

Generate flat normals.

All vertices in each triangle face get the same normal vector. Removes duplicates before returning. Expects that the position count is divisible by 3.

Containers::Array<Vector3> Magnum::MeshTools::generateSmoothNormals(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) new in 2019.10

#include <Magnum/MeshTools/GenerateNormals.h>

Generate smooth normals.

Uses the indices array to discover adjacent triangles and then for each vertex position calculates a normal averaged from all triangles that share it. The normal is weighted according to adjacent triangle area and angle at given vertex; hard edges are preserved where adjacent triangles don't share vertices. Triangles with zero area or triangles containing invalid positions (NaNs) don't contribute to calculated vertex normals.

Implementation is based on the article Weighted Vertex Normals by Martijn Buijs.

Containers::Array<Vector3> Magnum::MeshTools::generateSmoothNormals(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) new in 2019.10

#include <Magnum/MeshTools/GenerateNormals.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<Vector3> Magnum::MeshTools::generateSmoothNormals(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) new in 2019.10

#include <Magnum/MeshTools/GenerateNormals.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Containers::Array<Vector3> Magnum::MeshTools::generateSmoothNormals(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) new in 2020.06

#include <Magnum/MeshTools/GenerateNormals.h>

Generate smooth normals using a type-erased index array.

Expects that the second dimension of indices is contiguous and represents the actual 1/2/4-byte index type. Based on its size then calls one of the generateSmoothNormals(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<const Vector3>&) etc. overloads.