tri11paragon
/
BLT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

vectors now use correct ops + ret is statically calculated now. vec_cast is a thing

v2
Brett 2024-11-15 12:53:27 -05:00
parent 1c931b2515
commit 0431106b7e
3 changed files with 127 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,6 +1,6 @@
cmake_minimum_required(VERSION 3.20)
include(cmake/color.cmake)
set(BLT_VERSION 2.1.9)
set(BLT_VERSION 2.1.10)
set(BLT_TARGET BLT)

142
include/blt/math/vectors.h
View File

@ -297,107 +297,107 @@ namespace blt
}
};
template<typename T, blt::u32 size>
inline constexpr vec<T, size> operator+(const vec<T, size>& left, const vec<T, size>& right)
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
inline constexpr vec<R, size> operator+(const vec<T, size>& left, const vec<G, size>& right)
{
vec<T, size> initializer{};
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = left[i] + right[i];
initializer[i] = static_cast<R>(left[i]) + static_cast<R>(right[i]);
return initializer;
}
template<typename T, blt::u32 size>
inline constexpr vec<T, size> operator-(const vec<T, size>& left, const vec<T, size>& right)
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
inline constexpr vec<R, size> operator-(const vec<T, size>& left, const vec<G, size>& right)
{
vec<T, size> initializer{};
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = left[i] - right[i];
initializer[i] = static_cast<R>(left[i]) - static_cast<R>(right[i]);
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator+(const vec<T, size>& left, G right)
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
inline constexpr vec<R, size> operator+(const vec<T, size>& left, G right)
{
vec<T, size> initializer{};
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = left[i] + static_cast<T>(right);
initializer[i] = static_cast<R>(left[i]) + static_cast<R>(right);
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator-(const vec<T, size>& left, G right)
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
inline constexpr vec<R, size> operator-(const vec<T, size>& left, G right)
{
vec<T, size> initializer{};
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = left[i] + static_cast<T>(right);
initializer[i] = static_cast<R>(left[i]) - static_cast<R>(right);
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator+(G left, const vec<T, size>& right)
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
inline constexpr vec<R, size> operator+(G left, const vec<T, size>& right)
{
vec<T, size> initializer{};
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<T>(left) + right[i];
initializer[i] = static_cast<R>(left) + static_cast<R>(right[i]);
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator-(G left, const vec<T, size>& right)
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
inline constexpr vec<R, size> operator-(G left, const vec<T, size>& right)
{
vec<T, size> initializer{};
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<T>(left) - right[i];
return initializer;
}
template<typename T, blt::u32 size>
inline constexpr vec<T, size> operator*(const vec<T, size>& left, const vec<T, size>& right)
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
inline constexpr vec<R, size> operator*(const vec<T, size>& left, const vec<G, size>& right)
{
vec<T, size> initializer{};
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = left[i] * right[i];
initializer[i] = static_cast<R>(left[i]) * static_cast<R>(right[i]);
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
inline constexpr vec<R, size> operator*(const vec<T, size>& left, G right)
{
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<R>(left[i]) * static_cast<R>(right);
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
inline constexpr vec<R, size> operator*(G left, const vec<T, size>& right)
{
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<R>(left) * static_cast<R>(right[i]);
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
inline constexpr vec<R, size> operator/(const vec<T, size>& left, G right)
{
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<R>(left[i]) / static_cast<R>(right);
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
inline constexpr vec<R, size> operator/(G left, const vec<T, size>& right)
{
vec<R, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<R>(left) / static_cast<R>(right[i]);
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator*(const vec<T, size>& left, G right)
{
vec<T, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = left[i] * static_cast<T>(right);
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator*(G left, const vec<T, size>& right)
{
vec<T, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<T>(left) * right[i];
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator/(const vec<T, size>& left, G right)
{
vec<T, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = left[i] / static_cast<T>(right);
return initializer;
}
template<typename T, typename G, blt::u32 size>
inline constexpr vec<T, size> operator/(G left, const vec<T, size>& right)
{
vec<T, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
initializer[i] = static_cast<T>(left) / right[i];
return initializer;
}
template<typename T, blt::u32 size>
inline constexpr bool operator==(const vec<T, size>& left, const vec<T, size>& right)
inline constexpr bool operator==(const vec<T, size>& left, const vec<G, size>& right)
{
constexpr double E = std::numeric_limits<T>::epsilon();
for (blt::u32 i = 0; i < size; i++)
@ -409,19 +409,19 @@ namespace blt
return true;
}
template<typename T, blt::u32 size>
inline constexpr bool operator!=(const vec<T, size>& left, const vec<T, size>& right)
template<typename T, typename G, blt::u32 size>
inline constexpr bool operator!=(const vec<T, size>& left, const vec<G, size>& right)
{
return !(left == right);
}
template<typename T, blt::u32 size>
inline constexpr bool operator&&(const vec<T, size>& left, const vec<T, size>& right)
template<typename Ret, typename T, blt::u32 size>
inline constexpr vec<Ret, size> vec_cast(const vec<T, size>& conv)
{
vec<Ret, size> initializer{};
for (blt::u32 i = 0; i < size; i++)
if (!f_equal(left[i], right[i]))
return false;
return true;
initializer[i] = static_cast<Ret>(conv[i]);
return initializer;
}
using vec2f = vec<float, 2>;

55
include/blt/meta/codegen.h Normal file
View File

@ -0,0 +1,55 @@
#pragma once
/*
* Copyright (C) 2024 Brett Terpstra
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef BLT_META_CODEGEN_H
#define BLT_META_CODEGEN_H
namespace blt
{
#define BLT_CONST_LVALUE_GETTER(TYPE, NAME) const TYPE& get_##NAME() const { return NAME; }
#define BLT_LVALUE_GETTER(TYPE, NAME) TYPE& get_##NAME() { return NAME; }
#define BLT_PRVALUE_GETTER(TYPE, NAME) TYPE get_##NAME() const { return NAME; }
#define BLT_GLVALUE_GETTER(TYPE, NAME) \
BLT_CONST_LVALUE_GETTER(TYPE, NAME) \
BLT_LVALUE_GETTER(TYPE, NAME)
#define BLT_PRVALUE_SETTER(TYPE, NAME) \
auto& set_##NAME(TYPE new_##NAME) \
{ \
NAME = new_##NAME; \
return *this; \
}
#define BLT_PRVALUE_MOVE_SETTER(TYPE, NAME) \
auto& set_##NAME(TYPE new_##NAME) \
{ \
NAME = std::move(new_##NAME); \
return *this; \
}
#define BLT_LVALUE_SETTER(TYPE, NAME) \
auto& set_##NAME(const TYPE& new_##NAME) \
{ \
NAME = new_##NAME; \
return *this; \
}
}
#endif //BLT_META_CODEGEN_H