summaryrefslogtreecommitdiffstats
path: root/src/core/math
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/math')
-rw-r--r--src/core/math/CMakeLists.txt8
-rw-r--r--src/core/math/aabb.hh111
-rw-r--r--src/core/math/angles.hh103
-rw-r--r--src/core/math/concepts.hh11
-rw-r--r--src/core/math/constexpr.hh72
-rw-r--r--src/core/math/crc64.cc76
-rw-r--r--src/core/math/crc64.hh9
-rw-r--r--src/core/math/vectors.hh43
8 files changed, 433 insertions, 0 deletions
diff --git a/src/core/math/CMakeLists.txt b/src/core/math/CMakeLists.txt
new file mode 100644
index 0000000..bcb45aa
--- /dev/null
+++ b/src/core/math/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(core PRIVATE
+ "${CMAKE_CURRENT_LIST_DIR}/aabb.hh"
+ "${CMAKE_CURRENT_LIST_DIR}/angles.hh"
+ "${CMAKE_CURRENT_LIST_DIR}/concepts.hh"
+ "${CMAKE_CURRENT_LIST_DIR}/constexpr.hh"
+ "${CMAKE_CURRENT_LIST_DIR}/crc64.cc"
+ "${CMAKE_CURRENT_LIST_DIR}/crc64.hh"
+ "${CMAKE_CURRENT_LIST_DIR}/vectors.hh")
diff --git a/src/core/math/aabb.hh b/src/core/math/aabb.hh
new file mode 100644
index 0000000..a235a9b
--- /dev/null
+++ b/src/core/math/aabb.hh
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "core/math/concepts.hh"
+
+namespace math
+{
+template<arithmetic T>
+class AABB {
+public:
+ using value_type = T;
+ using vector_type = glm::vec<3, T>;
+
+ constexpr AABB(void) = default;
+ constexpr explicit AABB(const vector_type& start, const vector_type& end);
+ virtual ~AABB(void) = default;
+
+ constexpr void set_bounds(const vector_type& start, const vector_type& end);
+ constexpr void set_offset(const vector_type& base, const vector_type& size);
+
+ constexpr bool contains(const vector_type& point) const;
+ constexpr bool intersect(const AABB<value_type>& other_box) const;
+
+ constexpr AABB<value_type> combine(const AABB<value_type>& other_box) const;
+ constexpr AABB<value_type> multiply(const AABB<value_type>& other_box) const;
+ constexpr AABB<value_type> push(const vector_type& vector) const;
+
+public:
+ vector_type min {};
+ vector_type max {};
+};
+} // namespace math
+
+namespace math
+{
+using AABBf = AABB<float>;
+} // namespace math
+
+template<math::arithmetic T>
+constexpr math::AABB<T>::AABB(const vector_type& start, const vector_type& end)
+{
+ set_bounds(start, end);
+}
+
+template<math::arithmetic T>
+constexpr void math::AABB<T>::set_bounds(const vector_type& start, const vector_type& end)
+{
+ min = start;
+ max = end;
+}
+
+template<math::arithmetic T>
+constexpr void math::AABB<T>::set_offset(const vector_type& base, const vector_type& size)
+{
+ min = base;
+ max = base + size;
+}
+
+template<math::arithmetic T>
+constexpr bool math::AABB<T>::contains(const vector_type& point) const
+{
+ auto result = true;
+ result = result && (point.x >= min.x) && (point.x <= max.x);
+ result = result && (point.y >= min.y) && (point.y <= max.y);
+ result = result && (point.z >= min.z) && (point.z <= max.z);
+ return result;
+}
+
+template<math::arithmetic T>
+constexpr bool math::AABB<T>::intersect(const AABB<value_type>& other_box) const
+{
+ auto result = true;
+ result = result && (min.x <= other_box.max.x) && (max.x >= other_box.min.x);
+ result = result && (min.y <= other_box.max.y) && (max.y >= other_box.min.y);
+ result = result && (min.z <= other_box.max.z) && (max.z >= other_box.min.z);
+ return result;
+}
+
+template<math::arithmetic T>
+constexpr math::AABB<T> math::AABB<T>::combine(const AABB<value_type>& other_box) const
+{
+ AABB<value_type> result;
+ result.min.x = glm::min(min.x, other_box.min.x);
+ result.min.y = glm::min(min.y, other_box.min.y);
+ result.min.z = glm::min(min.z, other_box.min.z);
+ result.max.x = glm::max(max.x, other_box.max.x);
+ result.max.y = glm::max(max.y, other_box.max.y);
+ result.max.z = glm::max(max.z, other_box.max.z);
+ return result;
+}
+
+template<math::arithmetic T>
+constexpr math::AABB<T> math::AABB<T>::multiply(const AABB<value_type>& other_box) const
+{
+ AABB<value_type> result;
+ result.min.x = glm::max(min.x, other_box.min.x);
+ result.min.y = glm::max(min.y, other_box.min.y);
+ result.min.z = glm::max(min.z, other_box.min.z);
+ result.max.x = glm::min(max.x, other_box.max.x);
+ result.max.y = glm::min(max.y, other_box.max.y);
+ result.max.z = glm::min(max.z, other_box.max.z);
+ return result;
+}
+
+template<math::arithmetic T>
+constexpr math::AABB<T> math::AABB<T>::push(const vector_type& vector) const
+{
+ AABB<value_type> result;
+ result.min = min + vector;
+ result.max = max + vector;
+ return result;
+}
diff --git a/src/core/math/angles.hh b/src/core/math/angles.hh
new file mode 100644
index 0000000..174f320
--- /dev/null
+++ b/src/core/math/angles.hh
@@ -0,0 +1,103 @@
+#pragma once
+
+#include "core/math/constexpr.hh"
+
+constexpr float A180 = math::radians(180.0f);
+constexpr float A360 = math::radians(360.0f);
+
+namespace math
+{
+float wrap_180(float angle);
+float wrap_360(float angle);
+} // namespace math
+
+namespace math
+{
+glm::fvec3 wrap_180(const glm::fvec3& angles);
+glm::fvec3 wrap_360(const glm::fvec3& angles);
+} // namespace math
+
+namespace math
+{
+void vectors(const glm::fvec3& angles, glm::fvec3& forward);
+void vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up);
+} // namespace math
+
+inline float math::wrap_180(float angle)
+{
+ const auto result = std::fmod(angle + A180, A360);
+
+ if(result < 0.0f) {
+ return result + A180;
+ }
+
+ return result - A180;
+}
+
+inline float math::wrap_360(float angle)
+{
+ return std::fmod(std::fmod(angle, A360) + A360, A360);
+}
+
+inline glm::fvec3 math::wrap_180(const glm::fvec3& angles)
+{
+ return glm::fvec3 {
+ math::wrap_180(angles.x),
+ math::wrap_180(angles.y),
+ math::wrap_180(angles.z),
+ };
+}
+
+inline glm::fvec3 math::wrap_360(const glm::fvec3& angles)
+{
+ return glm::fvec3 {
+ math::wrap_360(angles.x),
+ math::wrap_360(angles.y),
+ math::wrap_360(angles.z),
+ };
+}
+
+inline void math::vectors(const glm::fvec3& angles, glm::fvec3& forward)
+{
+ const float cosp = std::cos(angles.x);
+ const float cosy = std::cos(angles.y);
+ const float sinp = std::sin(angles.x);
+ const float siny = std::sin(angles.y);
+
+ forward.x = cosp * siny * (-1.0f);
+ forward.y = sinp;
+ forward.z = cosp * cosy * (-1.0f);
+}
+
+inline void math::vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up)
+{
+ if(!forward && !right && !up) {
+ // There's no point in figuring out
+ // direction vectors if nothing is passed
+ // in the function to store that stuff in
+ return;
+ }
+
+ const auto pcv = glm::cos(angles);
+ const auto psv = glm::sin(angles);
+ const auto ncv = pcv * (-1.0f);
+ const auto nsv = psv * (-1.0f);
+
+ if(forward) {
+ forward->x = pcv.x * nsv.y;
+ forward->y = psv.x;
+ forward->z = pcv.x * ncv.y;
+ }
+
+ if(right) {
+ right->x = pcv.z * pcv.y;
+ right->y = psv.z * pcv.y;
+ right->z = nsv.y;
+ }
+
+ if(up) {
+ up->x = psv.x * psv.y * pcv.z + ncv.y * psv.z;
+ up->y = pcv.x * pcv.z;
+ up->z = nsv.x * ncv.y * pcv.z + psv.y * psv.z;
+ }
+}
diff --git a/src/core/math/concepts.hh b/src/core/math/concepts.hh
new file mode 100644
index 0000000..6ad5cb7
--- /dev/null
+++ b/src/core/math/concepts.hh
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace math
+{
+template<typename type>
+concept arithmetic = std::is_arithmetic_v<type>;
+template<typename type>
+concept signed_arithmetic = std::is_arithmetic_v<type> && std::is_signed_v<type>;
+template<typename type>
+concept unsigned_arithmetic = std::is_arithmetic_v<type> && std::is_unsigned_v<type>;
+} // namespace math
diff --git a/src/core/math/constexpr.hh b/src/core/math/constexpr.hh
new file mode 100644
index 0000000..4158803
--- /dev/null
+++ b/src/core/math/constexpr.hh
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "core/math/concepts.hh"
+
+namespace math
+{
+template<typename type, std::size_t size>
+constexpr std::size_t array_size(const type (&)[size]);
+} // namespace math
+
+namespace math
+{
+template<std::integral scalar>
+constexpr scalar log2(const scalar x);
+template<std::signed_integral scalar>
+constexpr scalar mod_signed(const scalar x, const scalar m);
+template<math::signed_arithmetic result_scalar, math::arithmetic scalar>
+constexpr result_scalar sign(const scalar x);
+} // namespace math
+
+namespace math
+{
+template<math::arithmetic scalar>
+constexpr scalar degrees(const scalar x);
+template<math::arithmetic scalar>
+constexpr scalar radians(const scalar x);
+} // namespace math
+
+template<typename type, std::size_t size>
+constexpr std::size_t math::array_size(const type (&)[size])
+{
+ return size;
+}
+
+template<std::integral scalar>
+constexpr scalar math::log2(const scalar x)
+{
+ if(x < static_cast<scalar>(2))
+ return static_cast<scalar>(0);
+ return math::log2<scalar>((x + static_cast<scalar>(1)) >> 1) + static_cast<scalar>(1);
+}
+
+template<std::signed_integral scalar>
+constexpr scalar math::mod_signed(const scalar x, const scalar m)
+{
+ auto result = static_cast<scalar>(x % m);
+ if(result < static_cast<scalar>(0))
+ return result + m;
+ return result;
+}
+
+template<math::signed_arithmetic result_scalar, math::arithmetic scalar>
+constexpr result_scalar math::sign(const scalar x)
+{
+ if(x < static_cast<scalar>(0))
+ return static_cast<result_scalar>(-1);
+ if(x > static_cast<scalar>(0))
+ return static_cast<result_scalar>(+1);
+ return static_cast<result_scalar>(0);
+}
+
+template<math::arithmetic scalar>
+constexpr scalar math::degrees(const scalar x)
+{
+ return static_cast<scalar>(static_cast<double>(x) * 180.0 / M_PI);
+}
+
+template<math::arithmetic scalar>
+constexpr scalar math::radians(const scalar x)
+{
+ return static_cast<scalar>(static_cast<double>(x) * M_PI / 180.0);
+}
diff --git a/src/core/math/crc64.cc b/src/core/math/crc64.cc
new file mode 100644
index 0000000..99a4b20
--- /dev/null
+++ b/src/core/math/crc64.cc
@@ -0,0 +1,76 @@
+#include "core/pch.hh"
+
+#include "core/math/crc64.hh"
+
+// The lookup table for CRC64 checksum; this lookup
+// table is generated using ECMA-182 compilant parameters:
+// - Polynomial: `0x42F0E1EBA9EA3693`
+// - Initial value: `0x0000000000000000`
+// - Final xor: `0x0000000000000000`
+// CRC Calculator: https://www.sunshine2k.de/coding/javascript/crc/crc_js.html
+constexpr static const std::uint64_t crc_table[256] = { 0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5,
+ 0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D,
+ 0x17870F5D4F51B498, 0x5577EEB6E6BB820B, 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4,
+ 0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A, 0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3,
+ 0xAAEFDD6DCD770416, 0xE81F3C86649D3285, 0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4,
+ 0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B, 0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D,
+ 0x499B3228721766F8, 0x0B6BD3C3DBFD506B, 0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4,
+ 0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5, 0x172F5B3033043EBF, 0x55DFBADB9AEE082C,
+ 0x92CE98E760D05399, 0xD03E790CC93A650A, 0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584,
+ 0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B, 0x3821458AADA7578F, 0x7AD1A461044D611C,
+ 0xBDC0865DFE733AA9, 0xFF3067B657990C3A, 0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5,
+ 0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A, 0x93366450E42ECDF0, 0xD1C685BB4DC4FB63,
+ 0x16D7A787B7FAA0D6, 0x5427466C1E109645, 0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324,
+ 0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB, 0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253,
+ 0x39D9B93D2959C9E6, 0x7B2958D680B3FF75, 0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA,
+ 0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB, 0x676DD025684A91A1, 0x259D31CEC1A0A732,
+ 0xE28C13F23B9EFC87, 0xA07CF2199274CA14, 0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144,
+ 0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B, 0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC,
+ 0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA, 0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425,
+ 0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB, 0x3971ED50550C43C1, 0x7B810CBBFCE67552,
+ 0xBC902E8706D82EE7, 0xFE60CF6CAF321874, 0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15,
+ 0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA, 0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E,
+ 0x731B26172EE619EB, 0x31EBC7FC870C2F78, 0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7,
+ 0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6, 0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F,
+ 0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19, 0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97,
+ 0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648, 0x02A151B5F156289C, 0x4051B05E58BC1E0F,
+ 0x87409262A28245BA, 0xC5B073890B687329, 0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6,
+ 0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6, 0x73B3727A52B393CC, 0x31439391FB59A55F,
+ 0xF652B1AD0167FEEA, 0xB4A25046A88DC879, 0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18,
+ 0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7, 0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F,
+ 0xD95CAF179FC497DA, 0x9BAC4EFC362EA149, 0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96,
+ 0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7, 0x87E8C60FDED7CF9D, 0xC51827E4773DF90E,
+ 0x020905D88D03A2BB, 0x40F9E43324E99428, 0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57,
+ 0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288, 0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF,
+ 0x3B78E888D80FE17A, 0x7988096371E5D7E9, 0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36,
+ 0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8, 0x03F1F96F09FD3CD2, 0x41011884A0170A41,
+ 0x86103AB85A2951F4, 0xC4E0DB53F3C36767, 0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206,
+ 0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9, 0xE085162AB69D5E3C, 0xA275F7C11F7768AF,
+ 0x6564D5FDE549331A, 0x279434164CA30589, 0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956,
+ 0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37, 0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE,
+ 0xBE317F32F78E067B, 0xFCC19ED95E6430E8, 0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066,
+ 0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9, 0x14DEA25F3AF9026D, 0x562E43B4931334FE,
+ 0x913F6188692D6F4B, 0xD3CF8063C0C759D8, 0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507 };
+
+std::uint64_t math::crc64(const void* buffer, std::size_t size, std::uint64_t combine)
+{
+ auto data = reinterpret_cast<const std::uint8_t*>(buffer);
+ for(std::size_t i = 0; i < size; ++i)
+ combine = crc_table[((combine >> 56) ^ data[i]) & 0xFF] ^ (combine << 8);
+ return combine;
+}
+
+std::uint64_t math::crc64(const std::vector<std::byte>& buffer, std::uint64_t combine)
+{
+ return math::crc64(buffer.data(), buffer.size(), combine);
+}
+
+std::uint64_t math::crc64(const std::string& buffer, std::uint64_t combine)
+{
+ return math::crc64(buffer.data(), buffer.size(), combine);
+}
+
+std::uint64_t math::crc64(std::string_view buffer, std::uint64_t combine)
+{
+ return math::crc64(buffer.data(), buffer.size(), combine);
+}
diff --git a/src/core/math/crc64.hh b/src/core/math/crc64.hh
new file mode 100644
index 0000000..3ece0df
--- /dev/null
+++ b/src/core/math/crc64.hh
@@ -0,0 +1,9 @@
+#pragma once
+
+namespace math
+{
+std::uint64_t crc64(const void* buffer, std::size_t size, std::uint64_t combine = UINT64_C(0));
+std::uint64_t crc64(const std::vector<std::byte>& buffer, std::uint64_t combine = UINT64_C(0));
+std::uint64_t crc64(const std::string& buffer, std::uint64_t combine = UINT64_C(0));
+std::uint64_t crc64(std::string_view buffer, std::uint64_t combine = UINT64_C(0));
+} // namespace math
diff --git a/src/core/math/vectors.hh b/src/core/math/vectors.hh
new file mode 100644
index 0000000..bc11dd0
--- /dev/null
+++ b/src/core/math/vectors.hh
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "core/math/concepts.hh"
+
+// core/vectors.hh - because NO ONE would POSSIBLY
+// need integer-based distance calculations in a
+// game about voxels. That would be INSANE! :D
+
+namespace math
+{
+template<math::arithmetic T>
+constexpr static inline const T length2(const glm::vec<2, T>& vector);
+template<math::arithmetic T>
+constexpr static inline const T length2(const glm::vec<3, T>& vector);
+template<math::arithmetic T>
+constexpr static inline const T distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b);
+template<math::arithmetic T>
+constexpr static inline const T distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b);
+} // namespace math
+
+template<math::arithmetic T>
+constexpr static inline const T math::length2(const glm::vec<2, T>& vector)
+{
+ return (vector.x * vector.x) + (vector.y * vector.y);
+}
+
+template<math::arithmetic T>
+constexpr static inline const T math::length2(const glm::vec<3, T>& vector)
+{
+ return (vector.x * vector.x) + (vector.y * vector.y) + (vector.z * vector.z);
+}
+
+template<math::arithmetic T>
+constexpr static inline const T math::distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b)
+{
+ return math::length2(vector_a - vector_b);
+}
+
+template<math::arithmetic T>
+constexpr static inline const T math::distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b)
+{
+ return math::length2(vector_a - vector_b);
+}
generated by cgit (git 2.34.1) at 2026-02-14 12:21:22 +0000