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.
11364 Commits
21 Branches
19 Tags
70 MiB
Tree: bc430c2eee
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'bc430c2eee'
${ noResults }
magnum/src/Magnum/Math/PackingBatch.cpp

535 lines
23 KiB
Raw Normal View History Unescape

Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Here we go again.
1 year ago
2020, 2021, 2022, 2023, 2024, 2025
It's October already?!
2 years ago
Vladimír Vondruš <mosra@centrum.cz>
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
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 "PackingBatch.h"
#include <Corrade/Containers/StridedArrayView.h>
singles: expose batch Math APIs and a subset of MeshTools.
1 year ago
#ifndef MAGNUM_SINGLES_NO_UTILITY_ALGORITHMS_DEPENDENCY
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
#include <Corrade/Utility/Algorithms.h>
singles: expose batch Math APIs and a subset of MeshTools.
1 year ago
#endif
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
#include <Corrade/Utility/Assert.h>
#include "Magnum/Math/Packing.h"
Math: batch table-based half-float packing/unpacking. It's a lot of code, but it still seems to be the fastest option of all we have. This was the original idea when implementing half-float support in 2016 but then I shelved it in favor of a simpler (but slower) code, keeping the table only for the benchmark, calculated at runtime. But now we need a batch version of this, so this comes handy.
6 years ago
#include "Magnum/Math/Implementation/halfTables.hpp"
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
namespace Magnum { namespace Math {
namespace {
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
template<class T> inline void unpackUnsignedIntoImplementation(const Containers::StridedArrayView2D<const T>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
CORRADE_ASSERT(src.size() == dst.size(),
"Math::unpackInto(): wrong destination size, got" << dst.size() << "but expected" << src.size(), );
Math: make {un,}pack{Half,}Into() and castInto() assertions clearer. Say which of the two is non-contiguous, whether the source or the destination.
4 years ago
CORRADE_ASSERT(src.template isContiguous<1>(),
"Math::unpackInto(): second source view dimension is not contiguous", );
CORRADE_ASSERT(dst.isContiguous<1>(),
"Math::unpackInto(): second destination view dimension is not contiguous", );
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
/** @todo SSE/NEON implementations exploiting second dimension size/stride,
contiguity etc */
/* Caching values to avoid inline function calls in ebug builds */
constexpr Float bitMax = Implementation::bitMax<T>();
const char* srcPtr = reinterpret_cast<const char*>(src.data());
char* dstPtr = reinterpret_cast<char*>(dst.data());
const std::ptrdiff_t srcStride = src.stride()[0];
const std::ptrdiff_t dstStride = dst.stride()[0];
const std::size_t maxJ = src.size()[1];
for(std::size_t i = 0, maxI = src.size()[0]; i != maxI; ++i) {
const T* srcPtrI = reinterpret_cast<const T*>(srcPtr);
Float* dstPtrI = reinterpret_cast<Float*>(dstPtr);
for(std::size_t j = 0; j != maxJ; ++j)
*dstPtrI++ = *srcPtrI++/bitMax;
srcPtr += srcStride;
dstPtr += dstStride;
}
}
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void unpackInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
unpackUnsignedIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void unpackInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
unpackUnsignedIntoImplementation(src, dst);
}
namespace {
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
template<class T> inline void unpackSignedIntoImplementation(const Containers::StridedArrayView2D<const T>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
CORRADE_ASSERT(src.size() == dst.size(),
"Math::unpackInto(): wrong destination size, got" << dst.size() << "but expected" << src.size(), );
Math: make {un,}pack{Half,}Into() and castInto() assertions clearer. Say which of the two is non-contiguous, whether the source or the destination.
4 years ago
CORRADE_ASSERT(src.template isContiguous<1>(),
"Math::unpackInto(): second source view dimension is not contiguous", );
CORRADE_ASSERT(dst.isContiguous<1>(),
"Math::unpackInto(): second destination view dimension is not contiguous", );
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
/** @todo SSE/NEON implementations exploiting second dimension size/stride,
contiguity etc */
/* Caching values to avoid inline function calls in debug builds */
constexpr Float bitMax = Implementation::bitMax<T>();
const char* srcPtr = reinterpret_cast<const char*>(src.data());
char* dstPtr = reinterpret_cast<char*>(dst.data());
const std::ptrdiff_t srcStride = src.stride()[0];
const std::ptrdiff_t dstStride = dst.stride()[0];
const std::size_t maxJ = src.size()[1];
for(std::size_t i = 0, maxI = src.size()[0]; i != maxI; ++i) {
const T* srcPtrI = reinterpret_cast<const T*>(srcPtr);
Float* dstPtrI = reinterpret_cast<Float*>(dstPtr);
for(std::size_t j = 0; j != maxJ; ++j) {
const Float value = *srcPtrI++/bitMax;
/* Avoiding a max() call in Debug */
*dstPtrI++ = value < -1.0f ? -1.0f : value;
}
srcPtr += srcStride;
dstPtr += dstStride;
}
}
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void unpackInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
unpackSignedIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void unpackInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
unpackSignedIntoImplementation(src, dst);
}
namespace {
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
template<class T> inline void packIntoImplementation(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<T>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
CORRADE_ASSERT(src.size() == dst.size(),
"Math::packInto(): wrong destination size, got" << dst.size() << "but expected" << src.size(), );
Math: make {un,}pack{Half,}Into() and castInto() assertions clearer. Say which of the two is non-contiguous, whether the source or the destination.
4 years ago
CORRADE_ASSERT(src.isContiguous<1>(),
"Math::packInto(): second source view dimension is not contiguous", );
CORRADE_ASSERT(dst.template isContiguous<1>(),
"Math::packInto(): second destination view dimension is not contiguous", );
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
/** @todo SSE/NEON implementations exploiting second dimension size/stride,
contiguity etc */
/* Caching values to avoid inline function calls in debug builds */
constexpr Float bitMax = Implementation::bitMax<T>();
const char* srcPtr = reinterpret_cast<const char*>(src.data());
char* dstPtr = reinterpret_cast<char*>(dst.data());
const std::ptrdiff_t srcStride = src.stride()[0];
const std::ptrdiff_t dstStride = dst.stride()[0];
const std::size_t maxJ = src.size()[1];
for(std::size_t i = 0, maxI = src.size()[0]; i != maxI; ++i) {
const Float* srcPtrI = reinterpret_cast<const Float*>(srcPtr);
T* dstPtrI = reinterpret_cast<T*>(dstPtr);
for(std::size_t j = 0; j != maxJ; ++j)
/** @todo provide a version that doesn't do rounding */
*dstPtrI++ = std::round(*srcPtrI++*bitMax);
srcPtr += srcStride;
dstPtr += dstStride;
}
}
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
packIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
packIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Byte>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
packIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Short>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
packIntoImplementation(src, dst);
}
namespace {
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
template<class T, class U> inline void castIntoImplementation(const Containers::StridedArrayView2D<const T>& src, const Containers::StridedArrayView2D<U>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
CORRADE_ASSERT(src.size() == dst.size(),
"Math::castInto(): wrong destination size, got" << dst.size() << "but expected" << src.size(), );
Math: make {un,}pack{Half,}Into() and castInto() assertions clearer. Say which of the two is non-contiguous, whether the source or the destination.
4 years ago
CORRADE_ASSERT(src.template isContiguous<1>(),
"Math::castInto(): second source view dimension is not contiguous", );
CORRADE_ASSERT(dst.template isContiguous<1>(),
"Math::castInto(): second destination view dimension is not contiguous", );
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
/** @todo SSE/NEON implementations exploiting second dimension size/stride,
contiguity etc */
/* Caching values to avoid inline function calls in debug buílds */
const char* srcPtr = reinterpret_cast<const char*>(src.data());
char* dstPtr = reinterpret_cast<char*>(dst.data());
const std::ptrdiff_t srcStride = src.stride()[0];
const std::ptrdiff_t dstStride = dst.stride()[0];
const std::size_t maxJ = src.size()[1];
for(std::size_t i = 0, maxI = src.size()[0]; i != maxI; ++i) {
const T* srcPtrI = reinterpret_cast<const T*>(srcPtr);
U* dstPtrI = reinterpret_cast<U*>(dstPtr);
for(std::size_t j = 0; j != maxJ; ++j)
*dstPtrI++ = U(*srcPtrI++);
srcPtr += srcStride;
dstPtr += dstStride;
}
}
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Byte>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Short>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Int>& dst) {
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Byte>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Short>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Int>& dst) {
Math: add castInto() variants for Double<->integer. Because yes of course dealing with a JSON just isn't possible without having to make decisions between insufficiently imprecise integers and unnecessarly overprecise doubles.
4 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Short>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Int>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Int>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Long>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Long>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Long>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Int>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Short>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) {
Math: add castInto() variants for UnsignedLong/Long. There's now 24 overloads for unsigned types and 24 for signed types, which is all possible combinations. Not adding an ability to cast between signed and unsigned as I'm not sure what should be done there.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Byte>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Short>& dst) {
Math: add integer-to-integer castInto() variants also. Currently one of the types is always 32-bit and preserving signedness, because that's what I need right now. Other variants might get added later.
6 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) {
Math: add [Unsigned]Byte/[Unsigned]Short variants of castInto().
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Byte>& dst) {
Math: add [Unsigned]Byte/[Unsigned]Short variants of castInto().
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) {
Math: add [Unsigned]Byte/[Unsigned]Short variants of castInto().
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Byte>& dst) {
Math: add [Unsigned]Byte/[Unsigned]Short variants of castInto().
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add castInto() overloads for Float and Double.
5 years ago
castIntoImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add castInto() overloads for Float and Double.
5 years ago
castIntoImplementation(src, dst);
}
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
namespace {
singles: expose batch Math APIs and a subset of MeshTools.
1 year ago
#ifndef MAGNUM_SINGLES_NO_UTILITY_ALGORITHMS_DEPENDENCY
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
template<class T> inline void copyImplementation(const Containers::StridedArrayView2D<const T>& src, const Containers::StridedArrayView2D<T>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
/* Utility::copy() has its own assertions, but those are debug-only for
perf reasons and don't require the second dimension to be contiguous.
Here the use case is different and the behavior should be consistent
with other castInto() overloads to avoid surprises. */
CORRADE_ASSERT(src.size() == dst.size(),
"Math::castInto(): wrong destination size, got" << dst.size() << "but expected" << src.size(), );
CORRADE_ASSERT(src.template isContiguous<1>(),
"Math::castInto(): second source view dimension is not contiguous", );
CORRADE_ASSERT(dst.template isContiguous<1>(),
"Math::castInto(): second destination view dimension is not contiguous", );
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
Utility::copy(src, dst);
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
}
singles: expose batch Math APIs and a subset of MeshTools.
1 year ago
#else
/* Not as great because it doesn't have a fast memcpy codepath but more
acceptable than excluding the APIs altogether */
template<class T> inline void copyImplementation(const Containers::StridedArrayView2D<const T>& src, const Containers::StridedArrayView2D<T>& dst) {
castIntoImplementation(src, dst);
}
#endif
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Byte>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Short>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Int>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Long>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Double>& dst) {
Math: add also castInto(T[], T[]) overloads. For generic code, which would otherwise have to invent some SFINAE "use castInto() if the types are different and Utility::copy() otherwise" nastiness in every such case, and that's just annoying.
3 years ago
copyImplementation(src, dst);
}
Math: batch table-based half-float packing/unpacking. It's a lot of code, but it still seems to be the fastest option of all we have. This was the original idea when implementing half-float support in 2016 but then I shelved it in favor of a simpler (but slower) code, keeping the table only for the benchmark, calculated at runtime. But now we need a batch version of this, so this comes handy.
6 years ago
static_assert(sizeof(HalfMantissaTable) + sizeof(HalfOffsetTable) + sizeof(HalfExponentTable) == 8576,
"improper size of half->float conversion tables");
static_assert(sizeof(HalfBaseTable) + sizeof(HalfShiftTable) == 1536,
"improper size of float->half conversion tables");
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void unpackHalfInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) {
Math: batch table-based half-float packing/unpacking. It's a lot of code, but it still seems to be the fastest option of all we have. This was the original idea when implementing half-float support in 2016 but then I shelved it in favor of a simpler (but slower) code, keeping the table only for the benchmark, calculated at runtime. But now we need a batch version of this, so this comes handy.
6 years ago
CORRADE_ASSERT(src.size() == dst.size(),
"Math::unpackHalfInto(): wrong destination size, got" << dst.size() << "but expected" << src.size(), );
Math: make {un,}pack{Half,}Into() and castInto() assertions clearer. Say which of the two is non-contiguous, whether the source or the destination.
4 years ago
CORRADE_ASSERT(src.isContiguous<1>(),
"Math::unpackHalfInto(): second source view dimension is not contiguous", );
CORRADE_ASSERT(dst.isContiguous<1>(),
"Math::unpackHalfInto(): second destination view dimension is not contiguous", );
Math: batch table-based half-float packing/unpacking. It's a lot of code, but it still seems to be the fastest option of all we have. This was the original idea when implementing half-float support in 2016 but then I shelved it in favor of a simpler (but slower) code, keeping the table only for the benchmark, calculated at runtime. But now we need a batch version of this, so this comes handy.
6 years ago
/* Caching values to avoid inline function calls in debug builds */
const char* srcPtr = reinterpret_cast<const char*>(src.data());
char* dstPtr = reinterpret_cast<char*>(dst.data());
const std::ptrdiff_t srcStride = src.stride()[0];
const std::ptrdiff_t dstStride = dst.stride()[0];
const std::size_t maxJ = src.size()[1];
for(std::size_t i = 0, maxI = src.size()[0]; i != maxI; ++i) {
const UnsignedShort* srcPtrI = reinterpret_cast<const UnsignedShort*>(srcPtr);
UnsignedInt* dstPtrI = reinterpret_cast<UnsignedInt*>(dstPtr);
for(std::size_t j = 0; j != maxJ; ++j) {
const UnsignedShort h = *srcPtrI++;
*dstPtrI++ = HalfMantissaTable[HalfOffsetTable[h >> 10] + (h & 0x3ff)] + HalfExponentTable[h >> 10];
}
srcPtr += srcStride;
dstPtr += dstStride;
}
}
Math: stop wasting time with the explicit Corrade:: prefix. I did this back in 2010 because it "felt like the right thing to do", given that all of Magnum depended on Math and not vice versa. But, strictly speaking, Math already uses typedefs from Magnum/Types.h so why it couldn't also bring in the Corrade namespace, and the Debug/Warning/Error names too. Having to type out Corrade:: in all these was really just a waste of time, weird inconsistency in docs and an extra roadblock for whoever might want to contribute anything there.
3 years ago
void packHalfInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) {
Math: batch table-based half-float packing/unpacking. It's a lot of code, but it still seems to be the fastest option of all we have. This was the original idea when implementing half-float support in 2016 but then I shelved it in favor of a simpler (but slower) code, keeping the table only for the benchmark, calculated at runtime. But now we need a batch version of this, so this comes handy.
6 years ago
CORRADE_ASSERT(src.size() == dst.size(),
"Math::packHalfInto(): wrong destination size, got" << dst.size() << "but expected" << src.size(), );
Math: make {un,}pack{Half,}Into() and castInto() assertions clearer. Say which of the two is non-contiguous, whether the source or the destination.
4 years ago
CORRADE_ASSERT(src.isContiguous<1>(),
"Math::packHalfInto(): second source view dimension is not contiguous", );
CORRADE_ASSERT(dst.isContiguous<1>(),
"Math::packHalfInto(): second destination view dimension is not contiguous", );
Math: batch table-based half-float packing/unpacking. It's a lot of code, but it still seems to be the fastest option of all we have. This was the original idea when implementing half-float support in 2016 but then I shelved it in favor of a simpler (but slower) code, keeping the table only for the benchmark, calculated at runtime. But now we need a batch version of this, so this comes handy.
6 years ago
/* Caching values to avoid inline function calls in debug builds */
const char* srcPtr = reinterpret_cast<const char*>(src.data());
char* dstPtr = reinterpret_cast<char*>(dst.data());
const std::ptrdiff_t srcStride = src.stride()[0];
const std::ptrdiff_t dstStride = dst.stride()[0];
const std::size_t maxJ = src.size()[1];
for(std::size_t i = 0, maxI = src.size()[0]; i != maxI; ++i) {
const UnsignedInt* srcPtrI = reinterpret_cast<const UnsignedInt*>(srcPtr);
UnsignedShort* dstPtrI = reinterpret_cast<UnsignedShort*>(dstPtr);
for(std::size_t j = 0; j != maxJ; ++j) {
const UnsignedInt f = *srcPtrI++;
*dstPtrI++ = HalfBaseTable[(f >> 23) & 0x1ff] + ((f & 0x007fffff) >> HalfShiftTable[(f >> 23) & 0x1ff]);
}
srcPtr += srcStride;
dstPtr += dstStride;
}
}
Math: add batch integer packing/unpacking and casting functions. To be used for conversion of the upcoming mesh attribute types.
6 years ago
}}