106 lines
2.6 KiB
C++
106 lines
2.6 KiB
C++
/**
|
|
* Copyright (c) 2014-present, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <vector>
|
|
|
|
#include <fbxsdk.h>
|
|
|
|
#include <mathfu/matrix.h>
|
|
#include <mathfu/quaternion.h>
|
|
#include <mathfu/rect.h>
|
|
#include <mathfu/vector.h>
|
|
|
|
/**
|
|
* All the mathfu:: implementations of our core data types.
|
|
*/
|
|
|
|
template <class T, int d>
|
|
struct Bounds {
|
|
mathfu::Vector<T, d> min;
|
|
mathfu::Vector<T, d> max;
|
|
bool initialized = false;
|
|
|
|
void Clear() {
|
|
min = mathfu::Vector<T, d>();
|
|
max = mathfu::Vector<T, d>();
|
|
initialized = false;
|
|
}
|
|
|
|
void AddPoint(const mathfu::Vector<T, d>& p) {
|
|
if (initialized) {
|
|
for (int ii = 0; ii < d; ii++) {
|
|
min(ii) = std::min(min(ii), p(ii));
|
|
max(ii) = std::max(max(ii), p(ii));
|
|
}
|
|
} else {
|
|
min = p;
|
|
max = p;
|
|
initialized = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
typedef mathfu::Vector<uint16_t, 4> Vec4i;
|
|
typedef mathfu::Matrix<uint16_t, 4> Mat4i;
|
|
typedef mathfu::Vector<float, 2> Vec2f;
|
|
typedef mathfu::Vector<float, 3> Vec3f;
|
|
typedef mathfu::Vector<float, 4> Vec4f;
|
|
typedef mathfu::Matrix<float, 2> Mat2f;
|
|
typedef mathfu::Matrix<float, 3> Mat3f;
|
|
typedef mathfu::Matrix<float, 4> Mat4f;
|
|
typedef mathfu::Quaternion<float> Quatf;
|
|
typedef Bounds<float, 3> Boundsf;
|
|
|
|
#define VEC3F_ONE (Vec3f{1.0f})
|
|
#define VEC3F_ZERO (Vec3f{0.0f})
|
|
#define VEC4F_ONE (Vec4f{1.0f})
|
|
#define VEC4F_ZERO (Vec4f{0.0f})
|
|
|
|
template <class T, int d>
|
|
inline std::vector<T> toStdVec(const mathfu::Vector<T, d>& vec) {
|
|
std::vector<T> result(d);
|
|
for (int ii = 0; ii < d; ii++) {
|
|
result[ii] = vec[ii];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template <class T>
|
|
std::vector<T> toStdVec(const mathfu::Quaternion<T>& quat) {
|
|
return std::vector<T>{quat.vector()[0], quat.vector()[1], quat.vector()[2], quat.scalar()};
|
|
}
|
|
|
|
inline Vec3f toVec3f(const FbxDouble3& v) {
|
|
return Vec3f((float)v[0], (float)v[1], (float)v[2]);
|
|
}
|
|
|
|
inline Vec3f toVec3f(const FbxVector4& v) {
|
|
return Vec3f((float)v[0], (float)v[1], (float)v[2]);
|
|
}
|
|
|
|
inline Vec4f toVec4f(const FbxVector4& v) {
|
|
return Vec4f((float)v[0], (float)v[1], (float)v[2], (float)v[3]);
|
|
}
|
|
|
|
inline Mat4f toMat4f(const FbxAMatrix& m) {
|
|
auto result = Mat4f();
|
|
for (int row = 0; row < 4; row++) {
|
|
for (int col = 0; col < 4; col++) {
|
|
result(row, col) = (float)m[row][col];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
inline Quatf toQuatf(const FbxQuaternion& q) {
|
|
return Quatf((float)q[3], (float)q[0], (float)q[1], (float)q[2]);
|
|
}
|