ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7789 Commits
21 Branches
19 Tags
70 MiB
Tree: 0c3a7fabae
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0c3a7fabae'
${ noResults }
magnum/src/Magnum/Trade/MeshData.cpp

820 lines
54 KiB
Raw Normal View History Unescape

Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
Vladimír Vondruš <mosra@centrum.cz>
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.
*/
#include "MeshData.h"
#include <Corrade/Utility/Algorithms.h>
#include "Magnum/Math/Color.h"
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
#include "Magnum/Math/PackingBatch.h"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#include "Magnum/Trade/Implementation/arrayUtilities.h"
namespace Magnum { namespace Trade {
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
MeshIndexData::MeshIndexData(const MeshIndexType type, const Containers::ArrayView<const void> data) noexcept: _type{type}, _data{data} {
Trade: make MeshIndexData constexpr. First step towards an ability to expose data compiled into an executable through MeshData without having to allocate anything.
6 years ago
/* Yes, this calls into a constexpr function defined in the header --
because I feel that makes more sense than duplicating the full assert
logic */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_ASSERT(data.size()%meshIndexTypeSize(type) == 0,
"Trade::MeshIndexData: view size" << data.size() << "does not correspond to" << type, );
}
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
MeshIndexData::MeshIndexData(const Containers::StridedArrayView2D<const char>& data) noexcept {
if(data.size()[1] == 4) _type = MeshIndexType::UnsignedInt;
else if(data.size()[1] == 2) _type = MeshIndexType::UnsignedShort;
else if(data.size()[1] == 1) _type = MeshIndexType::UnsignedByte;
else CORRADE_ASSERT(false, "Trade::MeshIndexData: expected index type size 1, 2 or 4 but got" << data.size()[1], );
CORRADE_ASSERT(data.isContiguous(), "Trade::MeshIndexData: view is not contiguous", );
_data = data.asContiguous();
}
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData::MeshAttributeData(const MeshAttribute name, const VertexFormat format, UnsignedShort arraySize, const Containers::StridedArrayView1D<const void>& data) noexcept: MeshAttributeData{name, format, arraySize, data, nullptr} {
Trade: make MeshAttributeData constexpr. This makes it possible to have fully allocation-less MeshData, with statically defined indices and attributes. Only the final MeshData construction needs to be done at runtime because Array is not constexpr, but that isn't anything heavy anyway.
6 years ago
/* Yes, this calls into a constexpr function defined in the header --
because I feel that makes more sense than duplicating the full assert
logic */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/** @todo support zero / negative stride? would be hard to transfer to GL */
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
CORRADE_ASSERT(data.empty() || isVertexFormatImplementationSpecific(format) || std::ptrdiff_t(vertexFormatSize(format)) <= data.stride(),
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
"Trade::MeshAttributeData: expected stride to be positive and enough to fit" << format << Debug::nospace << ", got" << data.stride(), );
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData::MeshAttributeData(const MeshAttribute name, const VertexFormat format, UnsignedShort arraySize, const Containers::StridedArrayView2D<const char>& data) noexcept: MeshAttributeData{name, format, arraySize, Containers::StridedArrayView1D<const void>{{data.data(), ~std::size_t{}}, data.size()[0], data.stride()[0]}, nullptr} {
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
/* Yes, this calls into a constexpr function defined in the header --
because I feel that makes more sense than duplicating the full assert
logic */
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
#ifndef CORRADE_NO_ASSERT
if(arraySize) CORRADE_ASSERT(data.empty()[0] || isVertexFormatImplementationSpecific(format) || data.size()[1] == vertexFormatSize(format)*arraySize,
"Trade::MeshAttributeData: second view dimension size" << data.size()[1] << "doesn't match" << format << "and array size" << arraySize, );
else CORRADE_ASSERT(data.empty()[0] || isVertexFormatImplementationSpecific(format) || data.size()[1] == vertexFormatSize(format),
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
"Trade::MeshAttributeData: second view dimension size" << data.size()[1] << "doesn't match" << format, );
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
#endif
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
CORRADE_ASSERT(data.isContiguous<1>(),
"Trade::MeshAttributeData: second view dimension is not contiguous", );
}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
Containers::Array<MeshAttributeData> meshAttributeDataNonOwningArray(const Containers::ArrayView<const MeshAttributeData> view) {
/* Ugly, eh? */
return Containers::Array<Trade::MeshAttributeData>{const_cast<Trade::MeshAttributeData*>(view.data()), view.size(), reinterpret_cast<void(*)(Trade::MeshAttributeData*, std::size_t)>(Trade::Implementation::nonOwnedArrayDeleter)};
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, Containers::Array<char>&& indexData, const MeshIndexData& indices, Containers::Array<char>&& vertexData, Containers::Array<MeshAttributeData>&& attributes, const UnsignedInt vertexCount, const void* const importerState) noexcept: _indexType{indices._type}, _primitive{primitive}, _indexDataFlags{DataFlag::Owned|DataFlag::Mutable}, _vertexDataFlags{DataFlag::Owned|DataFlag::Mutable}, _importerState{importerState}, _indexData{std::move(indexData)}, _vertexData{std::move(vertexData)}, _attributes{std::move(attributes)}, _indices{Containers::arrayCast<const char>(indices._data)} {
/* Save vertex count. If it's passed explicitly, use that (but still check
that all attributes have the same vertex count for safety), otherwise
expect at least one attribute */
#ifndef CORRADE_NO_ASSERT
UnsignedInt expectedAttributeVertexCount;
#endif
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
if(_attributes.empty()) {
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_ASSERT(vertexCount != ImplicitVertexCount,
"Trade::MeshData: vertex count can't be implicit if there are no attributes", );
_vertexCount = vertexCount;
/* No attributes, so we won't be checking anything */
} else if(vertexCount != ImplicitVertexCount) {
_vertexCount = vertexCount;
#ifndef CORRADE_NO_ASSERT
expectedAttributeVertexCount = _attributes[0]._vertexCount;
#endif
} else {
_vertexCount = _attributes[0]._vertexCount;
#ifndef CORRADE_NO_ASSERT
expectedAttributeVertexCount = _vertexCount;
#endif
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
CORRADE_ASSERT(!_indices.empty() || _indexData.empty(),
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData: indexData passed for a non-indexed mesh", );
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
CORRADE_ASSERT(!_indices || (_indices.begin() >= _indexData.begin() && _indices.end() <= _indexData.end()),
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData: indices [" << Debug::nospace << static_cast<const void*>(_indices.begin()) << Debug::nospace << ":" << Debug::nospace << static_cast<const void*>(_indices.end()) << Debug::nospace << "] are not contained in passed indexData array [" << Debug::nospace << static_cast<const void*>(_indexData.begin()) << Debug::nospace << ":" << Debug::nospace << static_cast<const void*>(_indexData.end()) << Debug::nospace << "]", );
#ifndef CORRADE_NO_ASSERT
/* Not checking what's already checked in MeshIndexData / MeshAttributeData
constructors */
for(std::size_t i = 0; i != _attributes.size(); ++i) {
const MeshAttributeData& attribute = _attributes[i];
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
CORRADE_ASSERT(attribute._format != VertexFormat{},
"Trade::MeshData: attribute" << i << "doesn't specify anything", );
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_ASSERT(attribute._vertexCount == expectedAttributeVertexCount,
"Trade::MeshData: attribute" << i << "has" << attribute._vertexCount << "vertices but" << expectedAttributeVertexCount << "expected", );
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
/* Check that the view fits into the provided vertex data array. For
implementation-specific formats we don't know the size so use 0 to
check at least partially. */
const UnsignedInt typeSize =
isVertexFormatImplementationSpecific(attribute._format) ? 0 :
vertexFormatSize(attribute._format);
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
if(attribute._isOffsetOnly) {
const std::size_t size = attribute._data.offset + (_vertexCount - 1)*attribute._stride + typeSize;
CORRADE_ASSERT(!_vertexCount || size <= _vertexData.size(),
"Trade::MeshData: offset attribute" << i << "spans" << size << "bytes but passed vertexData array has only" << _vertexData.size(), );
} else {
const void* const begin = static_cast<const char*>(attribute._data.pointer);
const void* const end = static_cast<const char*>(attribute._data.pointer) + (_vertexCount - 1)*attribute._stride + typeSize;
CORRADE_ASSERT(!_vertexCount || (begin >= _vertexData.begin() && end <= _vertexData.end()),
"Trade::MeshData: attribute" << i << "[" << Debug::nospace << begin << Debug::nospace << ":" << Debug::nospace << end << Debug::nospace << "] is not contained in passed vertexData array [" << Debug::nospace << static_cast<const void*>(_vertexData.begin()) << Debug::nospace << ":" << Debug::nospace << static_cast<const void*>(_vertexData.end()) << Debug::nospace << "]", );
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
#endif
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, Containers::Array<char>&& indexData, const MeshIndexData& indices, Containers::Array<char>&& vertexData, std::initializer_list<MeshAttributeData> attributes, const UnsignedInt vertexCount, const void* const importerState): MeshData{primitive, std::move(indexData), indices, std::move(vertexData), Implementation::initializerListToArrayWithDefaultDeleter(attributes), vertexCount, importerState} {}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const DataFlags indexDataFlags, const Containers::ArrayView<const void> indexData, const MeshIndexData& indices, const DataFlags vertexDataFlags, const Containers::ArrayView<const void> vertexData, Containers::Array<MeshAttributeData>&& attributes, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(indexData.data())), indexData.size(), Implementation::nonOwnedArrayDeleter}, indices, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(vertexData.data())), vertexData.size(), Implementation::nonOwnedArrayDeleter}, std::move(attributes), vertexCount, importerState} {
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_ASSERT(!(indexDataFlags & DataFlag::Owned),
"Trade::MeshData: can't construct with non-owned index data but" << indexDataFlags, );
CORRADE_ASSERT(!(vertexDataFlags & DataFlag::Owned),
"Trade::MeshData: can't construct with non-owned vertex data but" << vertexDataFlags, );
_indexDataFlags = indexDataFlags;
_vertexDataFlags = vertexDataFlags;
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const DataFlags indexDataFlags, const Containers::ArrayView<const void> indexData, const MeshIndexData& indices, const DataFlags vertexDataFlags, const Containers::ArrayView<const void> vertexData, const std::initializer_list<MeshAttributeData> attributes, const UnsignedInt vertexCount, const void* const importerState): MeshData{primitive, indexDataFlags, indexData, indices, vertexDataFlags, vertexData, Implementation::initializerListToArrayWithDefaultDeleter(attributes), vertexCount, importerState} {}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const DataFlags indexDataFlags, const Containers::ArrayView<const void> indexData, const MeshIndexData& indices, Containers::Array<char>&& vertexData, Containers::Array<MeshAttributeData>&& attributes, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(indexData.data())), indexData.size(), Implementation::nonOwnedArrayDeleter}, indices, std::move(vertexData), std::move(attributes), vertexCount, importerState} {
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_ASSERT(!(indexDataFlags & DataFlag::Owned),
"Trade::MeshData: can't construct with non-owned index data but" << indexDataFlags, );
_indexDataFlags = indexDataFlags;
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const DataFlags indexDataFlags, const Containers::ArrayView<const void> indexData, const MeshIndexData& indices, Containers::Array<char>&& vertexData, const std::initializer_list<MeshAttributeData> attributes, const UnsignedInt vertexCount, const void* const importerState): MeshData{primitive, indexDataFlags, indexData, indices, std::move(vertexData), Implementation::initializerListToArrayWithDefaultDeleter(attributes), vertexCount, importerState} {}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, Containers::Array<char>&& indexData, const MeshIndexData& indices, const DataFlags vertexDataFlags, Containers::ArrayView<const void> vertexData, Containers::Array<MeshAttributeData>&& attributes, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, std::move(indexData), indices, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(vertexData.data())), vertexData.size(), Implementation::nonOwnedArrayDeleter}, std::move(attributes), vertexCount, importerState} {
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_ASSERT(!(vertexDataFlags & DataFlag::Owned),
"Trade::MeshData: can't construct with non-owned vertex data but" << vertexDataFlags, );
_vertexDataFlags = vertexDataFlags;
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, Containers::Array<char>&& indexData, const MeshIndexData& indices, const DataFlags vertexDataFlags, const Containers::ArrayView<const void> vertexData, const std::initializer_list<MeshAttributeData> attributes, const UnsignedInt vertexCount, const void* const importerState): MeshData{primitive, std::move(indexData), indices, vertexDataFlags, vertexData, Implementation::initializerListToArrayWithDefaultDeleter(attributes), vertexCount, importerState} {}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, Containers::Array<char>&& vertexData, Containers::Array<MeshAttributeData>&& attributes, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, {}, MeshIndexData{}, std::move(vertexData), std::move(attributes), vertexCount, importerState} {}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, Containers::Array<char>&& vertexData, const std::initializer_list<MeshAttributeData> attributes, const UnsignedInt vertexCount, const void* const importerState): MeshData{primitive, std::move(vertexData), Implementation::initializerListToArrayWithDefaultDeleter(attributes), vertexCount, importerState} {}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const DataFlags vertexDataFlags, Containers::ArrayView<const void> vertexData, Containers::Array<MeshAttributeData>&& attributes, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(vertexData.data())), vertexData.size(), Implementation::nonOwnedArrayDeleter}, std::move(attributes), vertexCount, importerState} {
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_ASSERT(!(vertexDataFlags & DataFlag::Owned),
"Trade::MeshData: can't construct with non-owned vertex data but" << vertexDataFlags, );
_vertexDataFlags = vertexDataFlags;
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const DataFlags vertexDataFlags, Containers::ArrayView<const void> vertexData, std::initializer_list<MeshAttributeData> attributes, const UnsignedInt vertexCount, const void* const importerState): MeshData{primitive, vertexDataFlags, vertexData, Implementation::initializerListToArrayWithDefaultDeleter(attributes), vertexCount, importerState} {}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, Containers::Array<char>&& indexData, const MeshIndexData& indices, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, std::move(indexData), indices, {}, {}, vertexCount, importerState} {}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const DataFlags indexDataFlags, const Containers::ArrayView<const void> indexData, const MeshIndexData& indices, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(indexData.data())), indexData.size(), Implementation::nonOwnedArrayDeleter}, indices, vertexCount, importerState} {
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_ASSERT(!(indexDataFlags & DataFlag::Owned),
"Trade::MeshData: can't construct with non-owned index data but" << indexDataFlags, );
_indexDataFlags = indexDataFlags;
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData::MeshData(const MeshPrimitive primitive, const UnsignedInt vertexCount, const void* const importerState) noexcept: MeshData{primitive, {}, MeshIndexData{}, {}, {}, vertexCount, importerState} {}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData::~MeshData() = default;
MeshData::MeshData(MeshData&&) noexcept = default;
MeshData& MeshData::operator=(MeshData&&) noexcept = default;
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
Containers::ArrayView<char> MeshData::mutableIndexData() & {
CORRADE_ASSERT(_indexDataFlags & DataFlag::Mutable,
"Trade::MeshData::mutableIndexData(): index data not mutable", {});
return _indexData;
}
Containers::ArrayView<char> MeshData::mutableVertexData() & {
CORRADE_ASSERT(_vertexDataFlags & DataFlag::Mutable,
"Trade::MeshData::mutableVertexData(): vertex data not mutable", {});
return _vertexData;
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
UnsignedInt MeshData::indexCount() const {
CORRADE_ASSERT(isIndexed(),
"Trade::MeshData::indexCount(): the mesh is not indexed", {});
return _indices.size()/meshIndexTypeSize(_indexType);
}
MeshIndexType MeshData::indexType() const {
CORRADE_ASSERT(isIndexed(),
"Trade::MeshData::indexType(): the mesh is not indexed", {});
return _indexType;
}
Trade: add a convenience MeshData::indexOffset() getter.
6 years ago
std::size_t MeshData::indexOffset() const {
CORRADE_ASSERT(isIndexed(),
"Trade::MeshData::indexOffset(): the mesh is not indexed", {});
return _indices.data() - _indexData.data();
}
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
Containers::StridedArrayView2D<const char> MeshData::indices() const {
CORRADE_ASSERT(isIndexed(),
"Trade::MeshData::indices(): the mesh is not indexed", {});
const std::size_t indexTypeSize = meshIndexTypeSize(_indexType);
/* Build a 2D view using information about attribute type size */
return {_indices, {_indices.size()/indexTypeSize, indexTypeSize}};
}
Containers::StridedArrayView2D<char> MeshData::mutableIndices() {
CORRADE_ASSERT(_indexDataFlags & DataFlag::Mutable,
"Trade::MeshData::mutableIndices(): index data not mutable", {});
CORRADE_ASSERT(isIndexed(),
"Trade::MeshData::mutableIndices(): the mesh is not indexed", {});
const std::size_t indexTypeSize = meshIndexTypeSize(_indexType);
/* Build a 2D view using information about attribute type size */
Containers::StridedArrayView2D<const char> out{_indices, {_indices.size()/indexTypeSize, indexTypeSize}};
/** @todo some arrayConstCast? UGH */
return Containers::StridedArrayView2D<char>{
/* The view size is there only for a size assert, we're pretty sure the
view is valid */
{static_cast<char*>(const_cast<void*>(out.data())), ~std::size_t{}},
out.size(), out.stride()};
}
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
MeshAttributeData MeshData::attributeData(UnsignedInt id) const {
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::attributeData(): index" << id << "out of range for" << _attributes.size() << "attributes", MeshAttributeData{});
const MeshAttributeData& attribute = _attributes[id];
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
return MeshAttributeData{attribute._name, attribute._format, attributeDataViewInternal(attribute)};
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshAttribute MeshData::attributeName(UnsignedInt id) const {
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::attributeName(): index" << id << "out of range for" << _attributes.size() << "attributes", {});
Trade: expose getters in MeshAttributeData.
6 years ago
return _attributes[id]._name;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
VertexFormat MeshData::attributeFormat(UnsignedInt id) const {
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::attributeFormat(): index" << id << "out of range for" << _attributes.size() << "attributes", {});
Trade: expose getters in MeshAttributeData.
6 years ago
return _attributes[id]._format;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
std::size_t MeshData::attributeOffset(UnsignedInt id) const {
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::attributeOffset(): index" << id << "out of range for" << _attributes.size() << "attributes", {});
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
return _attributes[id]._isOffsetOnly ? _attributes[id]._data.offset :
static_cast<const char*>(_attributes[id]._data.pointer) - _vertexData.data();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
UnsignedInt MeshData::attributeStride(UnsignedInt id) const {
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::attributeStride(): index" << id << "out of range for" << _attributes.size() << "attributes", {});
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
return _attributes[id]._stride;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
UnsignedShort MeshData::attributeArraySize(UnsignedInt id) const {
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::attributeArraySize(): index" << id << "out of range for" << _attributes.size() << "attributes", {});
return _attributes[id]._arraySize;
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
UnsignedInt MeshData::attributeCount(const MeshAttribute name) const {
UnsignedInt count = 0;
for(const MeshAttributeData& attribute: _attributes)
Trade: expose getters in MeshAttributeData.
6 years ago
if(attribute._name == name) ++count;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
return count;
}
UnsignedInt MeshData::attributeFor(const MeshAttribute name, UnsignedInt id) const {
for(std::size_t i = 0; i != _attributes.size(); ++i) {
Trade: expose getters in MeshAttributeData.
6 years ago
if(_attributes[i]._name != name) continue;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
if(id-- == 0) return i;
}
#ifdef CORRADE_NO_ASSERT
CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
#else
return ~UnsignedInt{};
#endif
}
Trade: added MeshData::attributeId(). Useful for quick localization of named attribs when dealing with attributeData() (for example in MeshTools).
6 years ago
UnsignedInt MeshData::attributeId(const MeshAttribute name, UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(name, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::attributeId(): index" << id << "out of range for" << attributeCount(name) << name << "attributes", {});
return attributeId;
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
VertexFormat MeshData::attributeFormat(MeshAttribute name, UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(name, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::attributeFormat(): index" << id << "out of range for" << attributeCount(name) << name << "attributes", {});
return attributeFormat(attributeId);
}
std::size_t MeshData::attributeOffset(MeshAttribute name, UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(name, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::attributeOffset(): index" << id << "out of range for" << attributeCount(name) << name << "attributes", {});
return attributeOffset(attributeId);
}
UnsignedInt MeshData::attributeStride(MeshAttribute name, UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(name, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::attributeStride(): index" << id << "out of range for" << attributeCount(name) << name << "attributes", {});
return attributeStride(attributeId);
}
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
UnsignedShort MeshData::attributeArraySize(MeshAttribute name, UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(name, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::attributeArraySize(): index" << id << "out of range for" << attributeCount(name) << name << "attributes", {});
return attributeArraySize(attributeId);
}
Primitives: use offset-only attribs for Line and Gradient. One less allocation for each.
6 years ago
Containers::StridedArrayView1D<const void> MeshData::attributeDataViewInternal(const MeshAttributeData& attribute) const {
return Containers::StridedArrayView1D<const void>{
/* We're *sure* the view is correct, so faking the view size */
/** @todo better ideas for the StridedArrayView API? */
{attribute._isOffsetOnly ? _vertexData.data() + attribute._data.offset :
attribute._data.pointer, ~std::size_t{}},
/* Not using attribute._vertexCount because that gets stale after
releaseVertexData() gets called, and then we would need to slice the
result inside attribute() and elsewhere anyway */
_vertexCount, attribute._stride};
}
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
Containers::StridedArrayView2D<const char> MeshData::attribute(UnsignedInt id) const {
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::attribute(): index" << id << "out of range for" << _attributes.size() << "attributes", nullptr);
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
const MeshAttributeData& attribute = _attributes[id];
Primitives: use offset-only attribs for Line and Gradient. One less allocation for each.
6 years ago
/* Build a 2D view using information about attribute type size */
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
return Containers::arrayCast<2, const char>(
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
attributeDataViewInternal(attribute),
isVertexFormatImplementationSpecific(attribute._format) ?
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
attribute._stride : vertexFormatSize(attribute._format)*
(attribute._arraySize ? attribute._arraySize : 1));
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
}
Containers::StridedArrayView2D<char> MeshData::mutableAttribute(UnsignedInt id) {
CORRADE_ASSERT(_vertexDataFlags & DataFlag::Mutable,
"Trade::MeshData::mutableAttribute(): vertex data not mutable", {});
CORRADE_ASSERT(id < _attributes.size(),
"Trade::MeshData::mutableAttribute(): index" << id << "out of range for" << _attributes.size() << "attributes", nullptr);
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
const MeshAttributeData& attribute = _attributes[id];
Primitives: use offset-only attribs for Line and Gradient. One less allocation for each.
6 years ago
/* Build a 2D view using information about attribute type size */
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
auto out = Containers::arrayCast<2, const char>(
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
attributeDataViewInternal(attribute),
isVertexFormatImplementationSpecific(attribute._format) ?
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
attribute._stride : vertexFormatSize(attribute._format)*
(attribute._arraySize ? attribute._arraySize : 1));
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
/** @todo some arrayConstCast? UGH */
return Containers::StridedArrayView2D<char>{
/* The view size is there only for a size assert, we're pretty sure the
view is valid */
{static_cast<char*>(const_cast<void*>(out.data())), ~std::size_t{}},
out.size(), out.stride()};
}
Containers::StridedArrayView2D<const char> MeshData::attribute(MeshAttribute name, UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(name, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::attribute(): index" << id << "out of range for" << attributeCount(name) << name << "attributes", {});
return attribute(attributeId);
}
Containers::StridedArrayView2D<char> MeshData::mutableAttribute(MeshAttribute name, UnsignedInt id) {
CORRADE_ASSERT(_vertexDataFlags & DataFlag::Mutable,
"Trade::MeshData::mutableAttribute(): vertex data not mutable", {});
const UnsignedInt attributeId = attributeFor(name, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::mutableAttribute(): index" << id << "out of range for" << attributeCount(name) << name << "attributes", {});
return mutableAttribute(attributeId);
}
Trade: support strided arrays in MeshData::indicesInto(). There's no point in restricting this.
6 years ago
void MeshData::indicesInto(const Containers::StridedArrayView1D<UnsignedInt> destination) const {
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_ASSERT(isIndexed(),
"Trade::MeshData::indicesInto(): the mesh is not indexed", );
CORRADE_ASSERT(destination.size() == indexCount(), "Trade::MeshData::indicesInto(): expected a view with" << indexCount() << "elements but got" << destination.size(), );
Trade: use Math::castInto() inside indicesInto(). This code was apparently done before the batch casters were a thing. Now it's no reason to do the same in two places, additionally in the future the castInto() could get SIMD-optimized and this can benefit from that.
6 years ago
auto destination1ui = Containers::arrayCast<2, UnsignedInt>(destination);
if(_indexType == MeshIndexType::UnsignedInt)
return Utility::copy(Containers::arrayCast<const UnsignedInt>(_indices), destination);
else if(_indexType == MeshIndexType::UnsignedShort)
return Math::castInto(Containers::arrayCast<2, const UnsignedShort>(Containers::arrayCast<const UnsignedShort>(_indices)), destination1ui);
else if(_indexType == MeshIndexType::UnsignedByte)
return Math::castInto(Containers::arrayCast<2, const UnsignedByte>(Containers::arrayCast<const UnsignedByte>(_indices)), destination1ui);
else CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Containers::Array<UnsignedInt> MeshData::indicesAsArray() const {
/* Repeating the assert here because otherwise it would fire in
indexCount() which may be confusing */
CORRADE_ASSERT(isIndexed(), "Trade::MeshData::indicesAsArray(): the mesh is not indexed", {});
Containers::Array<UnsignedInt> output{indexCount()};
indicesInto(output);
return output;
}
void MeshData::positions2DInto(const Containers::StridedArrayView1D<Vector2> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::Position, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::positions2DInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::Position) << "position attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::positions2DInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::positions2DInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
const Containers::StridedArrayView1D<const void> attributeData = attributeDataViewInternal(attribute);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
const auto destination2f = Containers::arrayCast<2, Float>(destination);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/* Copy 2D positions as-is, for 3D positions ignore Z */
Trade: expose getters in MeshAttributeData.
6 years ago
if(attribute._format == VertexFormat::Vector2 ||
attribute._format == VertexFormat::Vector3)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Utility::copy(Containers::arrayCast<const Vector2>(attributeData), destination);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2h ||
attribute._format == VertexFormat::Vector3h)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2ub ||
attribute._format == VertexFormat::Vector3ub)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2b ||
attribute._format == VertexFormat::Vector3b)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Byte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2us ||
attribute._format == VertexFormat::Vector3us)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2s ||
attribute._format == VertexFormat::Vector3s)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Short>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2ubNormalized ||
attribute._format == VertexFormat::Vector3ubNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2bNormalized ||
attribute._format == VertexFormat::Vector3bNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Byte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2usNormalized ||
attribute._format == VertexFormat::Vector3usNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2sNormalized ||
attribute._format == VertexFormat::Vector3sNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Short>(attributeData, 2), destination2f);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
else CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}
Containers::Array<Vector2> MeshData::positions2DAsArray(const UnsignedInt id) const {
Containers::Array<Vector2> out{_vertexCount};
positions2DInto(out, id);
return out;
}
void MeshData::positions3DInto(const Containers::StridedArrayView1D<Vector3> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::Position, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::positions3DInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::Position) << "position attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::positions3DInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::positions3DInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
const Containers::StridedArrayView1D<const void> attributeData = attributeDataViewInternal(attribute);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
const Containers::StridedArrayView2D<Float> destination2f = Containers::arrayCast<2, Float>(Containers::arrayCast<Vector2>(destination));
const Containers::StridedArrayView2D<Float> destination3f = Containers::arrayCast<2, Float>(destination);
/* For 2D positions copy the XY part to the first two components */
if(attribute._format == VertexFormat::Vector2)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Utility::copy(Containers::arrayCast<const Vector2>(attributeData),
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::arrayCast<Vector2>(destination));
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2h)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2ub)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2b)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Byte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2us)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2s)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Short>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2ubNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2bNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Byte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2usNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2sNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Short>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
/* Copy 3D positions as-is */
else if(attribute._format == VertexFormat::Vector3)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Utility::copy(Containers::arrayCast<const Vector3>(attributeData), destination);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3h)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3ub)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3b)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Byte>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3us)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3s)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Short>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3ubNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3bNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Byte>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3usNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3sNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Short>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
/* For 2D positions finally fill the Z with a single value */
if(attribute._format == VertexFormat::Vector2 ||
attribute._format == VertexFormat::Vector2h ||
attribute._format == VertexFormat::Vector2ub ||
attribute._format == VertexFormat::Vector2b ||
attribute._format == VertexFormat::Vector2us ||
attribute._format == VertexFormat::Vector2s ||
attribute._format == VertexFormat::Vector2ubNormalized ||
attribute._format == VertexFormat::Vector2bNormalized ||
attribute._format == VertexFormat::Vector2usNormalized ||
attribute._format == VertexFormat::Vector2sNormalized) {
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
constexpr Float z[1]{0.0f};
Utility::copy(
Containers::stridedArrayView(z).broadcasted<0>(_vertexCount),
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
destination3f.transposed<0, 1>()[2]);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Containers::Array<Vector3> MeshData::positions3DAsArray(const UnsignedInt id) const {
Containers::Array<Vector3> out{_vertexCount};
positions3DInto(out, id);
return out;
}
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
namespace {
void tangentsOrNormalsInto(const Containers::StridedArrayView1D<const void> attributeData, const Containers::StridedArrayView1D<Vector3> destination, VertexFormat format) {
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
const auto destination3f = Containers::arrayCast<2, Float>(destination);
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
if(format == VertexFormat::Vector3)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Utility::copy(Containers::arrayCast<const Vector3>(attributeData), destination);
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
else if(format == VertexFormat::Vector3h)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 3), destination3f);
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
else if(format == VertexFormat::Vector3bNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Byte>(attributeData, 3), destination3f);
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
else if(format == VertexFormat::Vector3sNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Short>(attributeData, 3), destination3f);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
else CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
}
void MeshData::tangentsInto(const Containers::StridedArrayView1D<Vector3> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::Tangent, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::tangentsInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::Tangent) << "tangent attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::tangentsInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::tangentsInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
/* If the tangent is four-component, ignore the last component; otherwise
copy/unpack given format directly */
VertexFormat format;
if(attribute._format == VertexFormat::Vector4)
format = VertexFormat::Vector3;
else if(attribute._format == VertexFormat::Vector4h)
format = VertexFormat::Vector3h;
else if(attribute._format == VertexFormat::Vector4ubNormalized)
format = VertexFormat::Vector3ubNormalized;
else if(attribute._format == VertexFormat::Vector4usNormalized)
format = VertexFormat::Vector3usNormalized;
else format = attribute._format;
tangentsOrNormalsInto(attributeDataViewInternal(attribute), destination, format);
}
Containers::Array<Vector3> MeshData::tangentsAsArray(const UnsignedInt id) const {
Containers::Array<Vector3> out{_vertexCount};
tangentsInto(out, id);
return out;
}
void MeshData::bitangentSignsInto(const Containers::StridedArrayView1D<Float> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::Tangent, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::bitangentSignsInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::Tangent) << "tangent attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::bitangentSignsInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::bitangentSignsInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
const Containers::StridedArrayView1D<const void> attributeData = attributeDataViewInternal(attribute);
const auto destination1f = Containers::arrayCast<2, Float>(destination);
if(attribute._format == VertexFormat::Vector4)
Utility::copy(Containers::arrayCast<2, const Float>(attributeData, 4).transposed<0, 1>()[3], destination);
else if(attribute._format == VertexFormat::Vector4h)
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 4).suffix({0, 3}), destination1f);
else if(attribute._format == VertexFormat::Vector4bNormalized)
Math::unpackInto(Containers::arrayCast<2, const Byte>(attributeData, 4).suffix({0, 3}), destination1f);
else if(attribute._format == VertexFormat::Vector4sNormalized)
Math::unpackInto(Containers::arrayCast<2, const Short>(attributeData, 4).suffix({0, 3}), destination1f);
else CORRADE_ASSERT(false, "Trade::MeshData::bitangentSignsInto(): expected four-component tangents, but got" << attribute._format, );
}
Containers::Array<Float> MeshData::bitangentSignsAsArray(const UnsignedInt id) const {
Containers::Array<Float> out{_vertexCount};
bitangentSignsInto(out, id);
return out;
}
void MeshData::bitangentsInto(const Containers::StridedArrayView1D<Vector3> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::Bitangent, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::bitangentsInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::Bitangent) << "bitangent attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::bitangentsInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::bitangentsInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
tangentsOrNormalsInto(attributeDataViewInternal(attribute), destination, attribute._format);
}
Containers::Array<Vector3> MeshData::bitangentsAsArray(const UnsignedInt id) const {
Containers::Array<Vector3> out{_vertexCount};
bitangentsInto(out, id);
return out;
}
void MeshData::normalsInto(const Containers::StridedArrayView1D<Vector3> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::Normal, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::normalsInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::Normal) << "normal attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::normalsInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::normalsInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
tangentsOrNormalsInto(attributeDataViewInternal(attribute), destination, attribute._format);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<Vector3> MeshData::normalsAsArray(const UnsignedInt id) const {
Containers::Array<Vector3> out{_vertexCount};
normalsInto(out, id);
return out;
}
void MeshData::textureCoordinates2DInto(const Containers::StridedArrayView1D<Vector2> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::TextureCoordinates, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::textureCoordinates2DInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::TextureCoordinates) << "texture coordinate attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::textureCoordinates2DInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::textureCoordinatesInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
const Containers::StridedArrayView1D<const void> attributeData = attributeDataViewInternal(attribute);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
const auto destination2f = Containers::arrayCast<2, Float>(destination);
Trade: expose getters in MeshAttributeData.
6 years ago
if(attribute._format == VertexFormat::Vector2)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Utility::copy(Containers::arrayCast<const Vector2>(attributeData), destination);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2h)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2ub)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2b)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Byte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2us)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2s)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::castInto(Containers::arrayCast<2, const Short>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2ubNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2bNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Byte>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2usNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 2), destination2f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector2sNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const Short>(attributeData, 2), destination2f);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
else CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}
Containers::Array<Vector2> MeshData::textureCoordinates2DAsArray(const UnsignedInt id) const {
Containers::Array<Vector2> out{_vertexCount};
textureCoordinates2DInto(out, id);
return out;
}
void MeshData::colorsInto(const Containers::StridedArrayView1D<Color4> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::Color, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::colorsInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::Color) << "color attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::colorsInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::colorsInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
const Containers::StridedArrayView1D<const void> attributeData = attributeDataViewInternal(attribute);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
const Containers::StridedArrayView2D<Float> destination3f = Containers::arrayCast<2, Float>(Containers::arrayCast<Vector3>(destination));
const Containers::StridedArrayView2D<Float> destination4f = Containers::arrayCast<2, Float>(destination);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/* For three-component colors copy the RGB part to the first three
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
components */
if(attribute._format == VertexFormat::Vector3)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Utility::copy(Containers::arrayCast<const Vector3>(attributeData),
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::arrayCast<Vector3>(destination));
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3h)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3ubNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector3usNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 3), destination3f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/* Copy four-component colors as-is */
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector4)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Utility::copy(Containers::arrayCast<const Vector4>(attributeData),
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::arrayCast<Vector4>(destination));
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector4h)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackHalfInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 4), destination4f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector4ubNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 4), destination4f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else if(attribute._format == VertexFormat::Vector4usNormalized)
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
Math::unpackInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 4), destination4f);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
else CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
/* For three-component colors finally fill the alpha with a single value */
if(attribute._format == VertexFormat::Vector3 ||
attribute._format == VertexFormat::Vector3h ||
attribute._format == VertexFormat::Vector3ubNormalized ||
attribute._format == VertexFormat::Vector3usNormalized) {
constexpr Float alpha[1]{1.0f};
Utility::copy(
Containers::stridedArrayView(alpha).broadcasted<0>(_vertexCount),
destination4f.transposed<0, 1>()[3]);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Containers::Array<Color4> MeshData::colorsAsArray(const UnsignedInt id) const {
Containers::Array<Color4> out{_vertexCount};
colorsInto(out, id);
return out;
}
Trade: implement support for object IDs in MeshData.
6 years ago
void MeshData::objectIdsInto(const Containers::StridedArrayView1D<UnsignedInt> destination, const UnsignedInt id) const {
const UnsignedInt attributeId = attributeFor(MeshAttribute::ObjectId, id);
CORRADE_ASSERT(attributeId != ~UnsignedInt{}, "Trade::MeshData::objectIdsInto(): index" << id << "out of range for" << attributeCount(MeshAttribute::ObjectId) << "object ID attributes", );
CORRADE_ASSERT(destination.size() == _vertexCount, "Trade::MeshData::objectIdsInto(): expected a view with" << _vertexCount << "elements but got" << destination.size(), );
const MeshAttributeData& attribute = _attributes[attributeId];
CORRADE_ASSERT(!isVertexFormatImplementationSpecific(attribute._format),
"Trade::MeshData::objectIdsInto(): can't extract data out of an implementation-specific vertex format" << reinterpret_cast<void*>(vertexFormatUnwrap(attribute._format)), );
const Containers::StridedArrayView1D<const void> attributeData = attributeDataViewInternal(attribute);
const auto destination1ui = Containers::arrayCast<2, UnsignedInt>(destination);
if(attribute._format == VertexFormat::UnsignedInt)
Utility::copy(Containers::arrayCast<const UnsignedInt>(attributeData), destination);
else if(attribute._format == VertexFormat::UnsignedShort)
Math::castInto(Containers::arrayCast<2, const UnsignedShort>(attributeData, 1), destination1ui);
else if(attribute._format == VertexFormat::UnsignedByte)
Math::castInto(Containers::arrayCast<2, const UnsignedByte>(attributeData, 1), destination1ui);
else CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}
Containers::Array<UnsignedInt> MeshData::objectIdsAsArray(const UnsignedInt id) const {
Containers::Array<UnsignedInt> out{_vertexCount};
objectIdsInto(out, id);
return out;
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> MeshData::releaseIndexData() {
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
_indices = {_indices.data(), 0};
Containers::Array<char> out = std::move(_indexData);
_indexData = Containers::Array<char>{out.data(), 0, Implementation::nonOwnedArrayDeleter};
return out;
}
Containers::Array<MeshAttributeData> MeshData::releaseAttributeData() {
return std::move(_attributes);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Containers::Array<char> MeshData::releaseVertexData() {
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
_vertexCount = 0;
Containers::Array<char> out = std::move(_vertexData);
_vertexData = Containers::Array<char>{out.data(), 0, Implementation::nonOwnedArrayDeleter};
return out;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Debug& operator<<(Debug& debug, const MeshAttribute value) {
debug << "Trade::MeshAttribute" << Debug::nospace;
if(UnsignedShort(value) >= UnsignedShort(MeshAttribute::Custom))
return debug << "::Custom(" << Debug::nospace << (UnsignedShort(value) - UnsignedShort(MeshAttribute::Custom)) << Debug::nospace << ")";
switch(value) {
/* LCOV_EXCL_START */
#define _c(value) case MeshAttribute::value: return debug << "::" << Debug::nospace << #value;
_c(Position)
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
_c(Tangent)
_c(Bitangent)
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
_c(Normal)
_c(TextureCoordinates)
_c(Color)
Trade: implement support for object IDs in MeshData.
6 years ago
_c(ObjectId)
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#undef _c
/* LCOV_EXCL_STOP */
/* To silence compiler warning about unhandled values */
case MeshAttribute::Custom: CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}
return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedShort(value)) << Debug::nospace << ")";
}
}}