mirror of
https://github.com/harfang3d/harfang3d.git
synced 2024-07-01 01:39:42 +00:00
186 lines
5.3 KiB
C++
186 lines
5.3 KiB
C++
// HARFANG(R) Copyright (C) 2021 Emmanuel Julien, NWNC HARFANG. Released under GPL/LGPL/Commercial Licence, see licence.txt for details.
|
|
|
|
#pragma once
|
|
|
|
#include <cstddef>
|
|
|
|
namespace hg {
|
|
|
|
template <typename T> struct tVec2;
|
|
struct Vec4;
|
|
struct Mat3;
|
|
struct Mat4;
|
|
|
|
/// 3-Component vector
|
|
struct Vec3 {
|
|
static const Vec3 Zero;
|
|
static const Vec3 One;
|
|
static const Vec3 Left, Right, Up, Down, Front, Back;
|
|
static const Vec3 Min, Max;
|
|
|
|
Vec3() = default;
|
|
Vec3(float x, float y, float z);
|
|
|
|
explicit Vec3(const tVec2<int> &v);
|
|
explicit Vec3(const tVec2<float> &v);
|
|
explicit Vec3(const float &v);
|
|
explicit Vec3(const Vec4 &v);
|
|
|
|
inline Vec3 &operator+=(const Vec3 &b) {
|
|
x += b.x;
|
|
y += b.y;
|
|
z += b.z;
|
|
return *this;
|
|
}
|
|
inline Vec3 &operator+=(const float k) {
|
|
x += k;
|
|
y += k;
|
|
z += k;
|
|
return *this;
|
|
}
|
|
inline Vec3 &operator-=(const Vec3 &b) {
|
|
x -= b.x;
|
|
y -= b.y;
|
|
z -= b.z;
|
|
return *this;
|
|
}
|
|
inline Vec3 &operator-=(const float k) {
|
|
x -= k;
|
|
y -= k;
|
|
z -= k;
|
|
return *this;
|
|
}
|
|
inline Vec3 &operator*=(const Vec3 &b) {
|
|
x *= b.x;
|
|
y *= b.y;
|
|
z *= b.z;
|
|
return *this;
|
|
}
|
|
inline Vec3 &operator*=(const float k) {
|
|
x *= k;
|
|
y *= k;
|
|
z *= k;
|
|
return *this;
|
|
}
|
|
inline Vec3 &operator/=(const Vec3 &b) {
|
|
x /= b.x;
|
|
y /= b.y;
|
|
z /= b.z;
|
|
return *this;
|
|
}
|
|
inline Vec3 &operator/=(const float k) {
|
|
const float k_ = k != 0.f ? 1.f / k : 0.f;
|
|
x *= k_;
|
|
y *= k_;
|
|
z *= k_;
|
|
return *this;
|
|
}
|
|
|
|
inline float operator[](size_t n) const { return (&x)[n]; }
|
|
inline float &operator[](size_t n) { return (&x)[n]; }
|
|
|
|
float x, y, z;
|
|
};
|
|
|
|
inline bool operator==(const Vec3 &a, const Vec3 &b) { return a.x == b.x && a.y == b.y && a.z == b.z; }
|
|
inline bool operator!=(const Vec3 &a, const Vec3 &b) { return a.x != b.x || a.y != b.y || a.z != b.z; }
|
|
|
|
inline Vec3 operator+(const Vec3 &a, const Vec3 &b) { return {a.x + b.x, a.y + b.y, a.z + b.z}; }
|
|
inline Vec3 operator+(const Vec3 &a, const float v) { return {a.x + v, a.y + v, a.z + v}; }
|
|
inline Vec3 operator-(const Vec3 &a, const Vec3 &b) { return {a.x - b.x, a.y - b.y, a.z - b.z}; }
|
|
inline Vec3 operator-(const Vec3 &a, const float v) { return {a.x - v, a.y - v, a.z - v}; }
|
|
inline Vec3 operator*(const Vec3 &a, const Vec3 &b) { return {a.x * b.x, a.y * b.y, a.z * b.z}; }
|
|
inline Vec3 operator*(const Vec3 &a, const float v) { return {a.x * v, a.y * v, a.z * v}; }
|
|
inline Vec3 operator*(const float v, const Vec3 &a) { return a * v; }
|
|
inline Vec3 operator/(const Vec3 &a, const Vec3 &b) { return {a.x / b.x, a.y / b.y, a.z / b.z}; }
|
|
inline Vec3 operator/(const Vec3 &a, const float v) { return {a.x / v, a.y / v, a.z / v}; }
|
|
|
|
Vec3 operator*(const Vec3 &a, const Mat3 &m);
|
|
Vec3 operator*(const Vec3 &a, const Mat4 &m);
|
|
|
|
/// Return a random vector.
|
|
Vec3 RandomVec3(float min = -1.f, float max = 1.f);
|
|
Vec3 RandomVec3(const Vec3 &min, const Vec3 &max);
|
|
|
|
bool AlmostEqual(const Vec3 &a, const Vec3 &b, float epsilon);
|
|
|
|
/**
|
|
@short Vector base to Euler.
|
|
@note base convention u = {0,0,1}, v = {1,0,0}, second axis is optional.
|
|
*/
|
|
Vec3 BaseToEuler(const Vec3 &u);
|
|
Vec3 BaseToEuler(const Vec3 &u, const Vec3 &v);
|
|
|
|
/// Return hash of a vector.S
|
|
int Hash(const Vec3 &v);
|
|
|
|
/// Vector squared distance.
|
|
float Dist2(const Vec3 &a, const Vec3 &b);
|
|
/// Vector distance.
|
|
float Dist(const Vec3 &a, const Vec3 &b);
|
|
|
|
/// Squared vector length.
|
|
float Len2(const Vec3 &v);
|
|
/// Vector length.
|
|
float Len(const Vec3 &v);
|
|
|
|
/// Minimum of two vectors.
|
|
Vec3 Min(const Vec3 &a, const Vec3 &b);
|
|
/// Maximum of two vectors.
|
|
Vec3 Max(const Vec3 &a, const Vec3 &b);
|
|
|
|
/// Dot product.
|
|
inline float Dot(const Vec3 &a, const Vec3 &b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
|
|
/// Cross product.
|
|
inline Vec3 Cross(const Vec3 &a, const Vec3 &b) { return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; }
|
|
|
|
/// Reverse a vector.
|
|
inline Vec3 Reverse(const Vec3 &v) { return {-v.x, -v.y, -v.z}; }
|
|
/// Inverse a vector.
|
|
inline Vec3 Inverse(const Vec3 &v) { return {1.f / v.x, 1.f / v.y, 1.f / v.z}; }
|
|
|
|
/// Normalize a vector.
|
|
Vec3 Normalize(const Vec3 &v);
|
|
|
|
/// Clamp vector.
|
|
Vec3 Clamp(const Vec3 &v, float min, float max);
|
|
/// Clamp vector component-wise.
|
|
Vec3 Clamp(const Vec3 &v, const Vec3 &min, const Vec3 &max);
|
|
/// Clamp vector length.
|
|
Vec3 ClampLen(const Vec3 &v, float min, float max);
|
|
|
|
/// Absolute vector.
|
|
Vec3 Abs(const Vec3 &v);
|
|
/// Sign vector.
|
|
Vec3 Sign(const Vec3 &v);
|
|
|
|
/// Return a unit vector reflected by a normal vector.
|
|
Vec3 Reflect(const Vec3 &v, const Vec3 &n);
|
|
/// Return a unit vector refracted around a normal vector.S
|
|
Vec3 Refract(const Vec3 &v, const Vec3 &n, float k_in = 1.f, float k_out = 1.f);
|
|
|
|
Vec3 Floor(const Vec3 &v);
|
|
Vec3 Ceil(const Vec3 &v);
|
|
|
|
/**
|
|
@short Return a vector which is facing a given direction.
|
|
Returns a copy of this vector if it is already facing the given
|
|
direction or the opposite of this vector otherwise.
|
|
*/
|
|
Vec3 FaceForward(const Vec3 &v, const Vec3 &d);
|
|
|
|
Vec3 MakeVec3(const Vec4 &v);
|
|
|
|
Vec3 Quantize(const Vec3 &v, float qx, float qy, float qz);
|
|
Vec3 Quantize(const Vec3 &v, float q);
|
|
|
|
/// Convert a triplet of angle in degrees to the Harfang unit system.
|
|
Vec3 Deg3(float x, float y, float z);
|
|
/// Convert a triplet of angle in radians to the Harfang unit system.
|
|
Vec3 Rad3(float x, float y, float z);
|
|
|
|
/// Return a vector from integer value in the [0;255] range.
|
|
inline Vec3 Vec3I(int x, int y, int z) { return {float(x) / 255.f, float(y) / 255.f, float(z) / 255.f}; }
|
|
|
|
} // namespace hg
|