Catcrafts/Crafter.Math
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Crafter.Math/interfaces/Crafter.Math-Vector.cppm

474 lines
No EOL
14 KiB
C++
Executable file
Raw Blame History

/*
Crafter®.Math
Copyright (C) 2026 Catcrafts®
catcrafts.net
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation;
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
export module Crafter.Math:Vector;
import std;
namespace Crafter {
template <typename T, std::uint32_t Len, std::uint32_t Aligment>
struct __attribute__((packed)) VectorBase {
T v[Aligment];
};
template <typename T, std::uint32_t Aligment>
struct __attribute__((packed)) VectorBase<T, 1, Aligment> {
union {
T v[Aligment];
T x, r;
};
};
template <typename T, std::uint32_t Aligment>
struct __attribute__((packed)) VectorBase<T, 2, Aligment> {
union {
T v[Aligment];
struct __attribute__((packed)) {
T x, y;
};
struct __attribute__((packed)) {
T r, g;
};
};
constexpr VectorBase<T, 2, Aligment>(float x, float y): x(x), y(y) {
}
constexpr VectorBase<T, 2, Aligment>() = default;
};
template <typename T, std::uint32_t Aligment>
struct __attribute__((packed)) VectorBase<T, 3, Aligment> {
union {
T v[Aligment];
struct __attribute__((packed)) {
T x, y, z;
};
struct __attribute__((packed)) {
T r, g, b;
};
};
constexpr VectorBase<T, 3, Aligment>(float x, float y, float z): x(x), y(y), z(z) {
}
constexpr VectorBase<T, 3, Aligment>() = default;
};
template <typename T, std::uint32_t Aligment>
struct __attribute__((packed)) VectorBase<T, 4, Aligment> {
union {
T v[Aligment];
struct __attribute__((packed)) {
T x, y, z, w;
};
struct __attribute__((packed)) {
T r, g, b, a;
};
};
constexpr VectorBase<T, 4, Aligment>(float x, float y, float z, float w): x(x), y(y), z(z), w(w) {
}
constexpr VectorBase<T, 4, Aligment>() = default;
};
template <typename T, std::uint32_t Len>
struct VectorBase<T, Len, 0> {
T v[Len];
};
template <typename T>
struct VectorBase<T, 1, 0> {
union {
T v[1];
T x, r;
};
};
template <typename T>
struct VectorBase<T, 2, 0> {
union {
T v[2];
struct {
T x, y;
};
struct {
T r, g;
};
};
constexpr VectorBase<T, 2, 0>(float x, float y): x(x), y(y) {
}
constexpr VectorBase<T, 2, 0>() = default;
};
template <typename T>
struct VectorBase<T, 3, 0> {
union {
T v[3];
struct {
T x, y, z;
};
struct {
T r, g, b;
};
};
constexpr VectorBase<T, 3, 0>(float x, float y, float z): x(x), y(y), z(z) {
}
constexpr VectorBase<T, 3, 0>() = default;
};
template <typename T>
struct VectorBase<T, 4, 0> {
union {
T v[4];
struct {
T x, y, z, w;
};
struct {
T r, g, b, a;
};
};
constexpr VectorBase<T, 4, 0>(float x, float y, float z, float w): x(x), y(y), z(z), w(w) {
}
constexpr VectorBase<T, 4, 0>() = default;
};
export template <typename T, std::uint32_t Len, std::uint32_t Aligment>
class Vector : public VectorBase<T, Len, Aligment> {
public:
constexpr Vector(float x, float y, float z, float w ) requires(std::same_as<T, float> && Len == 4) : VectorBase<T, Len, Aligment>(x, y, z, w) {
}
constexpr Vector(float x, float y, float z) requires(std::same_as<T, float> && Len == 3) : VectorBase<T, Len, Aligment>(x, y, z) {
}
constexpr Vector(float x, float y) requires(std::same_as<T, float> && Len == 2) : VectorBase<T, Len, Aligment>(x, y) {
}
template<std::uint32_t BLen, std::uint32_t BAlign>
constexpr Vector(const Vector<T, BLen, BAlign>& b) {
for(std::uint32_t i = 0; i < std::min(Len, BLen); i++) {
this->v[i] = b.v[i];
}
}
constexpr Vector() = default;
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr Vector<T, Len, Aligment> operator+(Vector<T, Blen, BAlignment> b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
resultVector.v[i] = this->v[i]+b.v[i];
}
return resultVector;
}
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr Vector<T, Len, Aligment> operator-(Vector<T, Blen, BAlignment> b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
resultVector.v[i] = this->v[i]-b.v[i];
}
return resultVector;
}
constexpr Vector<T, Len, Aligment> operator-(){
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < Len; i++) {
resultVector.v[i] = -this->v[i];
}
return resultVector;
}
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr Vector<T, Len, Aligment> operator*(Vector<T, Blen, BAlignment> b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
resultVector.v[i] = this->v[i]*b.v[i];
}
return resultVector;
}
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr Vector<T, Len, Aligment> operator/(Vector<T, Blen, BAlignment> b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
resultVector.v[i] = this->v[i]/b.v[i];
}
return resultVector;
}
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr void operator+=(Vector<T, Blen, BAlignment> b){
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
this->v[i]+=b.v[i];
}
}
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr void operator-=(Vector<T, Blen, BAlignment> b){
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
this->v[i]-=b.v[i];
}
}
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr void operator*=(Vector<T, Blen, BAlignment> b){
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
this->v[i]*=b.v[i];
}
}
template <std::uint32_t Blen, std::uint32_t BAlignment>
constexpr void operator/=(Vector<T, Blen, BAlignment> b){
for(std::uint32_t i = 0; i < std::min(Len, Blen); i++) {
this->v[i]/=b.v[i];
}
}
template <typename BT>
constexpr Vector<T, Len, Aligment> operator+(BT b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < Len; i++) {
resultVector.v[i] = this->v[i] + b;
}
return resultVector;
}
template <typename BT>
constexpr Vector<T, Len, Aligment> operator-(BT b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < Len; i++) {
resultVector.v[i] = this->v[i] - b;
}
return resultVector;
}
template <typename BT>
constexpr Vector<T, Len, Aligment> operator*(BT b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < Len; i++) {
resultVector.v[i] = this->v[i] * b;
}
return resultVector;
}
template <typename BT>
constexpr Vector<T, Len, Aligment> operator/(BT b) const {
Vector<T, Len, Aligment> resultVector;
for(std::uint32_t i = 0; i < Len; i++) {
resultVector.v[i] = this->v[i] / b;
}
return resultVector;
}
template <typename BT>
constexpr void operator+=(BT b){
for(std::uint32_t i = 0; i < Len; i++) {
this->v[i] += b;
}
}
template <typename BT>
constexpr void operator-=(BT b){
for(std::uint32_t i = 0; i < Len; i++) {
this->v[i] -= b;
}
}
template <typename BT>
constexpr void operator*=(BT b){
for(std::uint32_t i = 0; i < Len; i++) {
this->v[i] *= b;
}
}
template <typename BT>
constexpr void operator/=(BT b){
for(std::uint32_t i = 0; i < Len; i++) {
this->v[i] /= b;
}
}
template <std::uint32_t BAlignment>
operator Vector<T, Len, BAlignment>() const {
Vector<T, Len, BAlignment> returnVector;
for(std::uint32_t i = 0; i < Len; i++) {
returnVector.v[i] = this->v[i];
}
return returnVector;
}
template <typename BT>
constexpr bool operator==(BT b) const {
for(std::uint32_t i = 0; i < Len; i++) {
if(this->v[i] != this->v[i]) {
return false;
}
}
return true;
}
template <typename BT>
constexpr bool operator!=(BT b) const {
for(std::uint32_t i = 0; i < Len; i++) {
if(this->v[i] != this->v[i]) {
return true;
}
}
return false;
}
constexpr void Normalize() {
float fLength = Length();
if (fLength > 0) {
fLength = 1.0f / fLength;
}
for(std::uint32_t i = 0; i < Len; i++) {
this->v[i] *= fLength;
}
}
constexpr void Invert() {
for(std::uint32_t i = 0; i < Len; i++) {
this->v[i] = -this->v[i];
}
}
constexpr float Length() const {
float Result = LengthSq();
return std::sqrtf(Result);
}
constexpr float LengthSq() const {
return Dot(*this, *this);
}
template <typename AT, std::uint32_t Alen, std::uint32_t AAlignment, typename BT, std::uint32_t Blen, std::uint32_t BAlignment>
constexpr static Vector<T, Len, Aligment> Cross(Vector<AT, Alen, AAlignment> a, Vector<BT, Blen, BAlignment> b) requires(Len == 3 && Alen >= 3 && Blen >= 3) {
return Vector<T, Len, Aligment>(
(a.v[1] * b.v[2]) - (a.v[2] * b.v[1]),
(a.v[2] * b.v[0]) - (a.v[0] * b.v[2]),
(a.v[0] * b.v[1]) - (a.v[1] * b.v[0])
);
}
template <typename AT, std::uint32_t Alen, std::uint32_t AAlignment>
constexpr static Vector<T, Len, Aligment> Normalize(Vector<AT, Alen, AAlignment> a) requires(Len == Alen) {
Vector<T, 3, 0> returned;
float fLength = a.Length();
if (fLength > 0) {
fLength = 1.0f / fLength;
}
for(std::uint32_t i = 0; i < Len; i++) {
returned.v[i] = a.v[i] * fLength;
}
return returned;
}
template <typename AT, std::uint32_t Alen, std::uint32_t AAlignment, typename BT, std::uint32_t Blen, std::uint32_t BAlignment>
constexpr static float Dot(Vector<AT, Alen, AAlignment> a, Vector<BT, Blen, BAlignment> b) requires(Alen >= Len && Blen >= Len) {
float accumulate = a.v[0] * b.v[0];
for(std::uint32_t i = 1; i < Len; i++) {
accumulate += a.v[i] * b.v[i];
}
return accumulate;
}
template <typename AT, std::uint32_t AAlignment, typename BT, std::uint32_t BAlignment>
constexpr static Vector<T, 3, Aligment> Rotate(Vector<AT, 3, AAlignment> v, Vector<BT, 4, BAlignment> q) requires(Len == 3) {
Vector<T, 3, 0> qv(q.x, q.y, q.z);
Vector<T, 3, 0> t = Vector<T, 3, Aligment>::Cross(qv, v) * T(2);
return v + t * q.w + Vector<T, 3, Aligment>::Cross(qv, t);
}
template <typename AT, std::uint32_t AAlignment, typename BT, std::uint32_t BAlignment, typename CT, std::uint32_t CAlignment>
constexpr static Vector<T, 4, Aligment> QuanternionFromBasis(Vector<AT, 3, AAlignment> right, Vector<BT, 3, BAlignment> up, Vector<CT, 3, CAlignment> forward) requires(Len == 4) {
T m00 = right.x;
T m01 = up.x;
T m02 = forward.x;
T m10 = right.y;
T m11 = up.y;
T m12 = forward.y;
T m20 = right.z;
T m21 = up.z;
T m22 = forward.z;
T trace = m00 + m11 + m22;
Vector<T, 4, Aligment> q;
if (trace > std::numeric_limits<T>::epsilon()) {
T s = std::sqrt(trace + T(1)) * T(2);
q.w = T(0.25) * s;
q.x = (m21 - m12) / s;
q.y = (m02 - m20) / s;
q.z = (m10 - m01) / s;
}
else if ((m00 > m11) && (m00 > m22)) {
T s = std::sqrt(T(1) + m00 - m11 - m22) * T(2);
q.w = (m21 - m12) / s;
q.x = T(0.25) * s;
q.y = (m01 + m10) / s;
q.z = (m02 + m20) / s;
}
else if (m11 > m22) {
T s = std::sqrt(T(1) + m11 - m00 - m22) * T(2);
q.w = (m02 - m20) / s;
q.x = (m01 + m10) / s;
q.y = T(0.25) * s;
q.z = (m12 + m21) / s;
}
else {
T s = std::sqrt(T(1) + m22 - m00 - m11) * T(2);
q.w = (m10 - m01) / s;
q.x = (m02 + m20) / s;
q.y = (m12 + m21) / s;
q.z = T(0.25) * s;
}
q.Normalize();
return q;
}
};
}
template <typename T, std::uint32_t Aligment>
struct std::formatter<Crafter::Vector<T, 2, Aligment>> : std::formatter<std::string> {
auto format(const Crafter::Vector<T, 2, Aligment>& obj, format_context& ctx) const {
return std::formatter<std::string>::format(std::format("{{{}, {}}}",
obj.x, obj.y
), ctx);
}
};
template <typename T, std::uint32_t Aligment>
struct std::formatter<Crafter::Vector<T, 3, Aligment>> : std::formatter<std::string> {
auto format(const Crafter::Vector<T, 3, Aligment>& obj, format_context& ctx) const {
return std::formatter<std::string>::format(std::format("{{{}, {}, {}}}",
obj.x, obj.y, obj.z
), ctx);
}
};
template <typename T, std::uint32_t Aligment>
struct std::formatter<Crafter::Vector<T, 4, Aligment>> : std::formatter<std::string> {
auto format(const Crafter::Vector<T, 4, Aligment>& obj, format_context& ctx) const {
return std::formatter<std::string>::format(std::format("{{{}, {}, {}, {}}}",
obj.x, obj.y, obj.z, obj.w
), ctx);
}
};
template <typename T, std::uint32_t Len, std::uint32_t Aligment, typename BT>
constexpr Crafter::Vector<T, Len, Aligment> operator*(BT b, const Crafter::Vector<T, Len, Aligment>& v) {
return v * b;
}
Reference in a new issue View git blame Copy permalink