670 lines
21 KiB
C++
670 lines
21 KiB
C++
/**
|
|
* @file
|
|
*
|
|
* @author Mamadou Babaei <mamadou@senseglove.com>
|
|
*
|
|
* @section LICENSE
|
|
*
|
|
* (The MIT License)
|
|
*
|
|
* Copyright (c) 2020 - 2022 SenseGlove
|
|
*
|
|
* 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.
|
|
*
|
|
* @section DESCRIPTION
|
|
*
|
|
*
|
|
*/
|
|
|
|
|
|
#pragma once
|
|
|
|
#include <vector>
|
|
|
|
#include "SGCoordinates.h"
|
|
#include "Containers/Array.h"
|
|
#include "Templates/UnrealTemplate.h"
|
|
|
|
#include "SGUtils/SGUnits.h"
|
|
|
|
class SENSEGLOVEUTILS_API FSGArrayUtils final
|
|
{
|
|
public:
|
|
template<typename T>
|
|
static FORCEINLINE TArray<T> FromStdVector(const std::vector<T>& Vector)
|
|
{
|
|
TArray<T> Array(&Vector[0], Vector.size());
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
/// NOTE
|
|
/// std::vector<bool> is a non conforming container. Since it packs bools to be stored in one bit,
|
|
/// it cannot provide a bool reference. Thus, FSGArrayUtils::FromStdVector<bool>() cannot be used.
|
|
/// Hence, the specialization.
|
|
static TArray<bool> FromStdVector(const std::vector<bool>& Vector)
|
|
{
|
|
TArray<bool> Array;
|
|
|
|
for (const bool bValue: Vector)
|
|
{
|
|
Array.Add(bValue);
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename T>
|
|
static TArray<TArray<T>> FromStdVector(const std::vector<std::vector<T>>& NestedVector)
|
|
{
|
|
TArray<TArray<T>> NestedArray;
|
|
|
|
for (const std::vector<T>& InnerVector: NestedVector)
|
|
{
|
|
TArray<T> InnerArray{FromStdVector<T>(InnerVector)};
|
|
NestedArray.Add(MoveTemp(InnerArray));
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
static TArray<T2> FromStdVector(const std::vector<T1>& Vector)
|
|
{
|
|
TArray<T2> Array;
|
|
|
|
for (const T1& T1Element: Vector)
|
|
{
|
|
T2 T2Element(T1Element);
|
|
Array.Add(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
static TArray<TArray<T2>> FromStdVector(const std::vector<std::vector<T1>>& NestedVector)
|
|
{
|
|
TArray<TArray<T2>> NestedArray;
|
|
|
|
for (const std::vector<T1>& InnerVector: NestedVector)
|
|
{
|
|
TArray<T2> InnerArray{FromStdVector<T1, T2>(InnerVector)};
|
|
NestedArray.Add(MoveTemp(InnerArray));
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, typename IntermediateImpl, T2(IntermediateImpl::*ToT2TypeMethod)() const>
|
|
static TArray<T2> FromStdVector(const std::vector<T1>& Vector)
|
|
{
|
|
TArray<T2> Array;
|
|
|
|
for (const T1& T1Element: Vector)
|
|
{
|
|
IntermediateImpl ImplElement(T1Element);
|
|
T2 T2Element((ImplElement.*ToT2TypeMethod)());
|
|
Array.Add(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename T1, typename T2, typename IntermediateImpl, T2(IntermediateImpl::*ToT2TypeMethod)() const>
|
|
static TArray<TArray<T2>> FromStdVector(const std::vector<std::vector<T1>>& NestedVector)
|
|
{
|
|
TArray<TArray<T2>> NestedArray;
|
|
|
|
for (const std::vector<T1>& InnerVector: NestedVector)
|
|
{
|
|
TArray<T2> InnerArray{FromStdVector<T1, T2, IntermediateImpl, ToT2TypeMethod>(InnerVector)};
|
|
NestedArray.Add(MoveTemp(InnerArray));
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
template<typename T>
|
|
static FORCEINLINE std::vector<T> ToStdVector(const TArray<T>& Array)
|
|
{
|
|
std::vector<T> Vector(&Array[0], &Array[0] + Array.Num());
|
|
return MoveTemp(Vector);
|
|
}
|
|
|
|
template<typename T>
|
|
static std::vector<std::vector<T>> ToStdVector(const TArray<TArray<T>>& NestedArray)
|
|
{
|
|
std::vector<std::vector<T>> NestedVector;
|
|
|
|
for (const TArray<T>& InnerArray: NestedArray)
|
|
{
|
|
std::vector<T> InnerVector{ToStdVector<T>(InnerArray)};
|
|
NestedVector.emplace_back(MoveTemp(InnerVector));
|
|
}
|
|
|
|
return MoveTemp(NestedVector);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
|
|
static std::vector<T2> ToStdVector(const TArray<T1>& Array)
|
|
{
|
|
std::vector<T2> Vector;
|
|
|
|
for (const T1& T1Element: Array)
|
|
{
|
|
T2 T2Element((T1Element.*ToUnderlyingTypeMethod)());
|
|
Vector.emplace_back(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(Vector);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
|
|
static std::vector<std::vector<T2>> ToStdVector(const TArray<TArray<T1>>& NestedArray)
|
|
{
|
|
std::vector<std::vector<T2>> NestedVector;
|
|
|
|
for (const TArray<T1>& InnerArray: NestedArray)
|
|
{
|
|
std::vector<T2> InnerVector{ToStdVector<T1, T2, ToUnderlyingTypeMethod>(InnerArray)};
|
|
NestedVector.emplace_back(MoveTemp(InnerVector));
|
|
}
|
|
|
|
return MoveTemp(NestedVector);
|
|
}
|
|
|
|
template<typename T1, typename T2, typename IntermediateImpl,
|
|
const T2&(IntermediateImpl::*ToUnderlyingTypeMethod)() const>
|
|
static std::vector<T2> ToStdVector(const TArray<T1>& Array)
|
|
{
|
|
std::vector<T2> Vector;
|
|
|
|
for (const T1& T1Element: Array)
|
|
{
|
|
IntermediateImpl ImplElement(T1Element);
|
|
T2 T2Element((ImplElement.*ToUnderlyingTypeMethod)());
|
|
Vector.emplace_back(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(Vector);
|
|
}
|
|
|
|
template<typename T1, typename T2, typename IntermediateImpl,
|
|
const T2&(IntermediateImpl::*ToUnderlyingTypeMethod)() const>
|
|
static std::vector<std::vector<T2>> ToStdVector(const TArray<TArray<T1>>& NestedArray)
|
|
{
|
|
std::vector<std::vector<T2>> NestedVector;
|
|
|
|
for (const TArray<T1>& InnerArray: NestedArray)
|
|
{
|
|
std::vector<T2> InnerVector{ToStdVector<T1, T2, IntermediateImpl, ToUnderlyingTypeMethod>(InnerArray)};
|
|
NestedVector.emplace_back(MoveTemp(InnerVector));
|
|
}
|
|
|
|
return MoveTemp(NestedVector);
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
static TArray<T2> FromImplType(const TArray<T1>& ImplArray)
|
|
{
|
|
TArray<T2> Array;
|
|
|
|
for (const T1& T1Element: ImplArray)
|
|
{
|
|
T2 T2Element(T1Element);
|
|
Array.Add(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename T1, typename T2, T2*(*NewObjectMethod)(UObject*, const T1&)>
|
|
static TArray<T2*> FromImplType(UObject* Outer, const TArray<T1>& ImplArray)
|
|
{
|
|
TArray<T2*> Array;
|
|
|
|
for (const T1& T1Element: ImplArray)
|
|
{
|
|
T2* T2Element(NewObjectMethod(Outer, T1Element));
|
|
Array.Add(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
static TArray<TArray<T2>> FromImplType(const TArray<TArray<T1>>& NestedImplArray)
|
|
{
|
|
TArray<TArray<T2>> NestedArray;
|
|
|
|
for (const TArray<T1>& InnerImplArray: NestedImplArray)
|
|
{
|
|
TArray<T2> InnerArray{FromImplType<T1, T2>(InnerImplArray)};
|
|
NestedArray.Add(MoveTemp(InnerArray));
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, T2*(*NewObjectMethod)(UObject*, const T1&)>
|
|
static TArray<TArray<T2*>> FromImplType(UObject* Outer, const TArray<TArray<T1>>& NestedImplArray)
|
|
{
|
|
TArray<TArray<T2*>> NestedArray;
|
|
|
|
for (const TArray<T1>& InnerImplArray: NestedImplArray)
|
|
{
|
|
TArray<T2*> InnerArray{FromImplType<T1, T2, NewObjectMethod>(Outer, InnerImplArray)};
|
|
NestedArray.Add(MoveTemp(InnerArray));
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, typename S>
|
|
static TArray<S> FromImplType(const TArray<TArray<T1>>& NestedImplArray)
|
|
{
|
|
TArray<S> NestedBPArray;
|
|
|
|
for (const TArray<T1>& InnerImplArray: NestedImplArray)
|
|
{
|
|
TArray<T2> InnerArray{FromImplType<T1, T2>(InnerImplArray)};
|
|
S InnerArrayContainer{MoveTemp(InnerArray)};
|
|
NestedBPArray.Add(MoveTemp(InnerArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(NestedBPArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, typename S, T2*(*NewObjectMethod)(UObject*, const T1&)>
|
|
static TArray<S> FromImplType(UObject* Outer, const TArray<TArray<T1>>& ImplArray)
|
|
{
|
|
TArray<S> Array;
|
|
|
|
for (const TArray<T1>& InnerImplArray: ImplArray)
|
|
{
|
|
TArray<T2*> InnerArray{FromImplType<T1, T2, NewObjectMethod>(Outer, InnerImplArray)};
|
|
S InnerArrayContainer{MoveTemp(InnerArray)};
|
|
Array.Add(MoveTemp(InnerArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename T1, typename T2, typename S>
|
|
static TArray<S> FromImplType(const TArray<TArray<T1*>>& ImplArray)
|
|
{
|
|
TArray<S> Array;
|
|
|
|
for (const TArray<T1>& InnerImplArray: ImplArray)
|
|
{
|
|
TArray<T2> InnerArray{FromImplType<T1, T2>(InnerImplArray)};
|
|
S InnerArrayContainer{MoveTemp(InnerArray)};
|
|
Array.Add(MoveTemp(InnerArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
|
|
static TArray<T2> ToImplType(const TArray<T1>& Array)
|
|
{
|
|
TArray<T2> ImplArray;
|
|
|
|
for (const T1& T1Element: Array)
|
|
{
|
|
T2 T2Element((T1Element.*ToUnderlyingTypeMethod)());
|
|
ImplArray.Add(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(ImplArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
|
|
static TArray<T2> ToImplType(const TArray<T1*>& Array)
|
|
{
|
|
TArray<T2> ImplArray;
|
|
|
|
for (const T1* T1Element: Array)
|
|
{
|
|
T2 T2Element((T1Element->*ToUnderlyingTypeMethod)());
|
|
ImplArray.Add(MoveTemp(T2Element));
|
|
}
|
|
|
|
return MoveTemp(ImplArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
|
|
static TArray<TArray<T2>> ToImplType(const TArray<TArray<T1>>& Array)
|
|
{
|
|
TArray<TArray<T2>> ImplArray;
|
|
|
|
for (const TArray<T1>& InnerArray: Array)
|
|
{
|
|
TArray<T2> InnerImplArray{ToImplType<T1, T2, ToUnderlyingTypeMethod>(InnerArray)};
|
|
ImplArray.Add(MoveTemp(InnerImplArray));
|
|
}
|
|
|
|
return MoveTemp(ImplArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
|
|
static TArray<TArray<T2>> ToImplType(const TArray<TArray<T1*>>& Array)
|
|
{
|
|
TArray<TArray<T2>> ImplArray;
|
|
|
|
for (const TArray<T1*>& InnerArray: Array)
|
|
{
|
|
TArray<T2> InnerImplArray{ToImplType<T1, T2, ToUnderlyingTypeMethod>(InnerArray)};
|
|
ImplArray.Add(MoveTemp(InnerImplArray));
|
|
}
|
|
|
|
return MoveTemp(ImplArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const, typename S, TArray<T1> S::*
|
|
InnerArray>
|
|
static TArray<TArray<T2>> ToImplType(const TArray<S>& Array)
|
|
{
|
|
TArray<TArray<T2>> ImplArray;
|
|
|
|
for (const S& InnerArrayContainer: Array)
|
|
{
|
|
TArray<T2> InnerImplArray{ToImplType<T1, T2, ToUnderlyingTypeMethod>(InnerArrayContainer.*InnerArray)};
|
|
ImplArray.Add(MoveTemp(InnerImplArray));
|
|
}
|
|
|
|
return MoveTemp(ImplArray);
|
|
}
|
|
|
|
template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const, typename S, TArray<T1*> S::*
|
|
InnerArray>
|
|
static TArray<TArray<T2>> ToImplType(const TArray<S>& Array)
|
|
{
|
|
TArray<TArray<T2>> ImplArray;
|
|
|
|
for (const S& InnerArrayContainer: Array)
|
|
{
|
|
TArray<T2> InnerImplArray{ToImplType<T1, T2, ToUnderlyingTypeMethod>(InnerArrayContainer.*InnerArray)};
|
|
ImplArray.Add(MoveTemp(InnerImplArray));
|
|
}
|
|
|
|
return MoveTemp(ImplArray);
|
|
}
|
|
|
|
template<typename T, typename S, TArray<T> S::*InnerArray>
|
|
static TArray<TArray<T>> FromNestedBPArray(const TArray<S>& NestedBPArray)
|
|
{
|
|
TArray<TArray<T>> NestedArray;
|
|
|
|
for (const S& InnerBPArrayContainer: NestedBPArray)
|
|
{
|
|
NestedArray.Add(InnerBPArrayContainer.*InnerArray);
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
template<typename T, typename S>
|
|
static TArray<S> ToNestedBPArray(const TArray<TArray<T>>& Array)
|
|
{
|
|
TArray<S> NestedBPArray;
|
|
|
|
for (const TArray<T>& InnerArray: Array)
|
|
{
|
|
S InnerBPArrayContainer{InnerArray};
|
|
NestedBPArray.Add(MoveTemp(InnerBPArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(NestedBPArray);
|
|
}
|
|
|
|
template<typename T, typename S>
|
|
static TArray<S> ToNestedBPArray(const TArray<TArray<T*>>& NestedArray)
|
|
{
|
|
TArray<S> NestedBPArray;
|
|
|
|
for (const TArray<T*>& InnerArray: NestedArray)
|
|
{
|
|
S InnerBPArrayContainer{InnerArray};
|
|
NestedBPArray.Add(MoveTemp(InnerBPArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(NestedBPArray);
|
|
}
|
|
|
|
static TArray<FRotator> QuatsToRotators(const TArray<FQuat>& QuatsArray);
|
|
static TArray<TArray<FRotator>> QuatsToRotators(const TArray<TArray<FQuat>>& QuatsArray);
|
|
|
|
template<typename S, TArray<FQuat> S::*InnerArray>
|
|
static TArray<TArray<FRotator>> QuatsToRotators(const TArray<S>& QuatsNestedArray)
|
|
{
|
|
TArray<TArray<FRotator>> RotatorsArray;
|
|
|
|
for (const S& QuatsInnerBPArrayContainer: QuatsNestedArray)
|
|
{
|
|
RotatorsArray.Add(QuatsToRotators(QuatsInnerBPArrayContainer.*InnerArray));
|
|
}
|
|
|
|
return MoveTemp(RotatorsArray);
|
|
}
|
|
|
|
template<typename S>
|
|
static TArray<S> QuatsToRotators(const TArray<TArray<FQuat>>& QuatsArray)
|
|
{
|
|
TArray<S> RotatorsNestedBPArray;
|
|
|
|
for (const TArray<FQuat>& QuatsInnerArray: QuatsArray)
|
|
{
|
|
S RotatorsInnerBPArrayContainer{QuatsToRotators(QuatsInnerArray)};
|
|
RotatorsNestedBPArray.Add(MoveTemp(RotatorsInnerBPArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(RotatorsNestedBPArray);
|
|
}
|
|
|
|
template<typename Q, typename R, TArray<FQuat> Q::*InnerArray>
|
|
static TArray<R> QuatsToRotators(const TArray<Q>& QuatsNestedArray)
|
|
{
|
|
TArray<R> RotatorsNestedBPArray;
|
|
|
|
for (const Q& QuatsInnerArrayContainer: QuatsNestedArray)
|
|
{
|
|
R RotatorsInnerBPArrayContainer{QuatsToRotators(QuatsInnerArrayContainer.*InnerArray)};
|
|
RotatorsNestedBPArray.Add(MoveTemp(RotatorsInnerBPArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(RotatorsNestedBPArray);
|
|
}
|
|
|
|
static TArray<FQuat> RotatorsToQuats(const TArray<FRotator>& RotatorsNestedArray);
|
|
static TArray<TArray<FQuat>> RotatorsToQuats(const TArray<TArray<FRotator>>& RotatorsNestedArray);
|
|
|
|
template<typename S, TArray<FRotator> S::*InnerArray>
|
|
static TArray<TArray<FQuat>> RotatorsToQuats(const TArray<S>& RotatorsNestedArray)
|
|
{
|
|
TArray<TArray<FQuat>> QuatsArray;
|
|
|
|
for (const S& RotatorsInnerBPArrayContainer: RotatorsNestedArray)
|
|
{
|
|
QuatsArray.Add(RotatorsToQuats(RotatorsInnerBPArrayContainer.*InnerArray));
|
|
}
|
|
|
|
return MoveTemp(QuatsArray);
|
|
}
|
|
|
|
template<typename S>
|
|
static TArray<S> RotatorsToQuats(const TArray<TArray<FRotator>>& RotatorsNestedArray)
|
|
{
|
|
TArray<S> QuatsNestedBPArray;
|
|
|
|
for (const TArray<FRotator>& RotatorsInnerArray: RotatorsNestedArray)
|
|
{
|
|
S QuatsInnerBPArrayContainer{RotatorsToQuats(RotatorsInnerArray)};
|
|
QuatsNestedBPArray.Add(MoveTemp(QuatsInnerBPArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(QuatsNestedBPArray);
|
|
}
|
|
|
|
template<typename Q, typename R, TArray<FRotator> Q::*InnerArray>
|
|
static TArray<R> RotatorsToQuats(const TArray<Q>& RotatorsNestedArray)
|
|
{
|
|
TArray<R> QuatsNestedBPArray;
|
|
|
|
for (const Q& RotatorsInnerArrayContainer: RotatorsNestedArray)
|
|
{
|
|
R QuatsInnerBPArrayContainer{RotatorsToQuats(RotatorsInnerArrayContainer.*InnerArray)};
|
|
QuatsNestedBPArray.Add(MoveTemp(QuatsInnerBPArrayContainer));
|
|
}
|
|
|
|
return MoveTemp(QuatsNestedBPArray);
|
|
}
|
|
|
|
static TArray<float> FromMillimeters(const std::vector<float>& Vector);
|
|
static TArray<TArray<float>> FromMillimeters(const std::vector<std::vector<float>>& NestedVector);
|
|
|
|
template<typename V3D, typename V3DImpl>
|
|
static TArray<FVector> FromMillimeters(const std::vector<V3D>& Vector)
|
|
{
|
|
TArray<FVector> Array;
|
|
|
|
for (const V3D& Value: Vector)
|
|
{
|
|
Array.Add(FSGUnits::MillimetersToCentimeters<V3D, V3DImpl>(Value));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename V3D, typename V3DImpl>
|
|
static TArray<TArray<FVector>> FromMillimeters(const std::vector<std::vector<V3D>>& NestedVector)
|
|
{
|
|
TArray<TArray<FVector>> NestedArray;
|
|
|
|
for (const std::vector<V3D>& InnerVector: NestedVector)
|
|
{
|
|
TArray<FVector> InnerArray{FromMillimeters<V3D, V3DImpl>(InnerVector)};
|
|
NestedArray.Add(MoveTemp(InnerArray));
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
static std::vector<float> ToMillimeters(const TArray<float>& Array);
|
|
static std::vector<std::vector<float>> ToMillimeters(const TArray<TArray<float>>& NestedArray);
|
|
|
|
template<typename S, TArray<float> S::*InnerArray>
|
|
static std::vector<std::vector<float>> ToMillimeters(const TArray<S>& NestedBPArray)
|
|
{
|
|
std::vector<std::vector<float>> NestedVector;
|
|
|
|
for (const S& InnerBPArrayContainer: NestedBPArray)
|
|
{
|
|
std::vector<float> InnerVector{ToMillimeters(InnerBPArrayContainer.*InnerArray)};
|
|
NestedVector.emplace_back(MoveTemp(InnerVector));
|
|
}
|
|
|
|
return MoveTemp(NestedVector);
|
|
}
|
|
|
|
template<typename V3D, typename V3DImpl>
|
|
static std::vector<V3D> ToMillimeters(const TArray<FVector>& Array)
|
|
{
|
|
std::vector<V3D> Vector;
|
|
|
|
for (const FVector& Value: Array)
|
|
{
|
|
Vector.emplace_back(FSGUnits::CentimetersToMillimeters<V3D, V3DImpl>(Value));
|
|
}
|
|
|
|
return MoveTemp(Vector);
|
|
}
|
|
|
|
template<typename V3D, typename V3DImpl>
|
|
static std::vector<std::vector<V3D>> ToMillimeters(const TArray<TArray<FVector>>& NestedArray)
|
|
{
|
|
std::vector<std::vector<V3D>> NestedVector;
|
|
|
|
for (const TArray<FVector>& InnerArray: NestedArray)
|
|
{
|
|
std::vector<V3D> InnerVector{ToMillimeters<V3D, V3DImpl>(InnerArray)};
|
|
NestedVector.emplace_back(MoveTemp(InnerVector));
|
|
}
|
|
|
|
return MoveTemp(NestedVector);
|
|
}
|
|
|
|
template<typename V3D>
|
|
static std::vector<V3D> ToSenseGloveAngles(const TArray<FVector>& Array)
|
|
{
|
|
std::vector<V3D> Vector;
|
|
|
|
for (const FVector& Value: Array)
|
|
{
|
|
Vector.emplace_back(FSGCoordinates::TransformToSenseGlove<V3D>(Value));
|
|
}
|
|
|
|
return MoveTemp(Vector);
|
|
}
|
|
|
|
template<typename V3D>
|
|
static std::vector<std::vector<V3D>> ToSenseGloveAngles(const TArray<TArray<FVector>>& NestedArray)
|
|
{
|
|
std::vector<std::vector<V3D>> NestedVector;
|
|
|
|
for (const TArray<FVector>& InnerArray: NestedArray)
|
|
{
|
|
std::vector<V3D> InnerVector{ToSenseGloveAngles<V3D>(InnerArray)};
|
|
NestedVector.emplace_back(MoveTemp(InnerVector));
|
|
}
|
|
|
|
return MoveTemp(NestedVector);
|
|
}
|
|
|
|
template<typename V3D>
|
|
static TArray<FVector> FromSenseGloveAngles(const std::vector<V3D>& Vector)
|
|
{
|
|
TArray<FVector> Array;
|
|
|
|
for (const V3D& Value: Vector)
|
|
{
|
|
Array.Add(FSGCoordinates::TransformToUnreal<V3D>(Value));
|
|
}
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
template<typename V3D>
|
|
static TArray<TArray<FVector>> FromSenseGloveAngles(const std::vector<std::vector<V3D>>& NestedVector)
|
|
{
|
|
TArray<TArray<FVector>> NestedArray;
|
|
|
|
for (const std::vector<V3D>& InnerVector: NestedVector)
|
|
{
|
|
TArray<FVector> InnerArray{FromSenseGloveAngles<V3D>(InnerVector)};
|
|
NestedArray.Add(MoveTemp(InnerArray));
|
|
}
|
|
|
|
return MoveTemp(NestedArray);
|
|
}
|
|
|
|
public:
|
|
FSGArrayUtils() = delete;
|
|
virtual ~FSGArrayUtils() = delete;
|
|
}; |