LoginSignup
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

More than 3 years have passed since last update.

@HnniTns(Tns Hnni)

XMINT君が面倒くさい！！

Last updated at Posted at 2020-12-02

初めに

　前回の続きです。リア友にXMINT版とXMUINT版も出してくれと言われたので、記事を上げることにしました。

早速

XMINT

XMINT_Helper.h

# pragma once

# include <DirectXMath.h>
# include <initializer_list>

//-------------------------------------------------------------------------------------------------------------
//. XMINT4系
//-------------------------------------------------------------------------------------------------------------

static inline void operator+= (DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	v1.x += v2.x;
	v1.y += v2.y;
	v1.z += v2.z;
	v1.w += v2.w;
}

static inline void operator-= (DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	v1.x -= v2.x;
	v1.y -= v2.y;
	v1.z -= v2.z;
	v1.w -= v2.w;
}

static inline void operator/= (DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	v1.x /= v2.x;
	v1.y /= v2.y;
	v1.z /= v2.z;
	v1.w /= v2.w;
}

static inline void operator*= (DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	v1.x *= v2.x;
	v1.y *= v2.y;
	v1.z *= v2.z;
	v1.w *= v2.w;
}

static inline void operator%= (DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	v1.x %= v2.x;
	v1.y %= v2.y;
	v1.z %= v2.z;
	v1.w %= v2.w;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	return DirectX::XMINT4{ v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.w + v2.w };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	return DirectX::XMINT4{ v1.x - v2.x, v1.y - v2.y, v1.z - v2.z, v1.w - v2.w };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	return DirectX::XMINT4{ v1.x * v2.x, v1.y * v2.y, v1.z * v2.z, v1.w * v2.w };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	return DirectX::XMINT4{ v1.x / v2.x, v1.y / v2.y, v1.z / v2.z, v1.w / v2.w };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	return DirectX::XMINT4{ (v1.x % v2.x), (v1.y % v2.y), (v1.z % v2.z), (v1.w % v2.w) };
}

static inline void operator+= (DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x += *itr;
	itr++;
	v1.y += *itr;
	itr++;
	v1.z += *itr;
	itr++;
	v1.w += *itr;
}

static inline void operator-= (DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x -= *itr;
	itr++;
	v1.y -= *itr;
	itr++;
	v1.z -= *itr;
	itr++;
	v1.w -= *itr;
}

static inline void operator/= (DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x /= *itr;
	itr++;
	v1.y /= *itr;
	itr++;
	v1.z /= *itr;
	itr++;
	v1.w /= *itr;
}

static inline void operator*= (DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
	itr++;
	v1.z *= *itr;
	itr++;
	v1.w *= *itr;
}

static inline void operator%= (DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x %= *itr;
	itr++;
	v1.y %= *itr;
	itr++;
	v1.z %= *itr;
	itr++;
	v1.w %= *itr;
}

_NODISCARD static inline auto operator+ (const DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x += *itr;
	itr++;
	temp.y += *itr;
	itr++;
	temp.z += *itr;
	itr++;
	temp.w += *itr;

	return temp;
}

_NODISCARD static inline auto operator- (const DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x -= *itr;
	itr++;
	temp.y -= *itr;
	itr++;
	temp.z -= *itr;
	itr++;
	temp.w -= *itr;

	return temp;
}

_NODISCARD static inline auto operator* (const DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;
	itr++;
	temp.z *= *itr;
	itr++;
	temp.w *= *itr;

	return temp;
}

_NODISCARD static inline auto operator/ (const DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x /= *itr;
	itr++;
	temp.y /= *itr;
	itr++;
	temp.z /= *itr;
	itr++;
	temp.w /= *itr;

	return temp;
}

_NODISCARD static inline auto operator% (const DirectX::XMINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x %= *itr;
	itr++;
	temp.y %= *itr;
	itr++;
	temp.z %= *itr;
	itr++;
	temp.w %= *itr;

	return temp;
}

static inline void operator+= (DirectX::XMINT4& v1, const int num)
{
	v1.x += num;
	v1.y += num;
	v1.z += num;
	v1.w += num;
}

static inline void operator-= (DirectX::XMINT4& v1, const int num)
{
	v1.x -= num;
	v1.y -= num;
	v1.z -= num;
	v1.w -= num;
}

static inline void operator/= (DirectX::XMINT4& v1, const int num)
{
	v1.x /= num;
	v1.y /= num;
	v1.z /= num;
	v1.w /= num;
}

static inline void operator*= (DirectX::XMINT4& v1, const int num)
{
	v1.x *= num;
	v1.y *= num;
	v1.z *= num;
	v1.w *= num;
}

static inline void operator%= (DirectX::XMINT4& v1, const int num)
{
	v1.x %= num;
	v1.y %= num;
	v1.z %= num;
	v1.w %= num;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMINT4& v1, const int num)
{
	return DirectX::XMINT4{ v1.x + num, v1.y + num, v1.z + num, v1.w + num };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMINT4& v1, const int num)
{
	return DirectX::XMINT4{ v1.x - num, v1.y - num, v1.z - num, v1.w - num };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMINT4& v1, const int num)
{
	return DirectX::XMINT4{ v1.x * num, v1.y * num, v1.z * num, v1.w * num };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMINT4& v1, const int num)
{
	return DirectX::XMINT4{ v1.x / num, v1.y / num, v1.z / num, v1.w / num };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMINT4& v1, const int num)
{
	return DirectX::XMINT4{ (v1.x % num), (v1.y % num), (v1.z % num), (v1.w % num) };
}

_NODISCARD static inline constexpr bool operator== (const DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
}

_NODISCARD static inline constexpr bool operator!= (const DirectX::XMINT4& v1, const DirectX::XMINT4& v2)
{
	return !((v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w));
}

//-------------------------------------------------------------------------------------------------------------
//. XMINT3系
//-------------------------------------------------------------------------------------------------------------

static inline void operator+= (DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x += *itr;
	itr++;
	v1.y += *itr;
	itr++;
	v1.z += *itr;
}

static inline void operator-= (DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x -= *itr;
	itr++;
	v1.y -= *itr;
	itr++;
	v1.z -= *itr;
}

static inline void operator/= (DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x /= *itr;
	itr++;
	v1.y /= *itr;
	itr++;
	v1.z /= *itr;
}

static inline void operator*= (DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
	itr++;
	v1.z *= *itr;
}

static inline void operator%= (DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
	itr++;
	v1.z *= *itr;
}

_NODISCARD static inline auto operator+ (const DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x += *itr;
	itr++;
	temp.y += *itr;
	itr++;
	temp.z += *itr;

	return temp;
}

_NODISCARD static inline auto operator- (const DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x -= *itr;
	itr++;
	temp.y -= *itr;
	itr++;
	temp.z -= *itr;

	return temp;
}

_NODISCARD static inline auto operator* (const DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;
	itr++;
	temp.z *= *itr;

	return temp;
}

_NODISCARD static inline auto operator/ (const DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x /= *itr;
	itr++;
	temp.y /= *itr;
	itr++;
	temp.z /= *itr;

	return temp;
}

_NODISCARD static inline auto operator% (const DirectX::XMINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;
	itr++;
	temp.z *= *itr;

	return temp;
}

static inline void operator+= (DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	v1.x += v2.x;
	v1.y += v2.y;
	v1.z += v2.z;
}

static inline void operator-= (DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	v1.x -= v2.x;
	v1.y -= v2.y;
	v1.z -= v2.z;
}

static inline void operator*= (DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	v1.x *= v2.x;
	v1.y *= v2.y;
	v1.z *= v2.z;
}

static inline void operator/= (DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	v1.x /= v2.x;
	v1.y /= v2.y;
	v1.z /= v2.z;
}

static inline void operator%= (DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	v1.x %= v2.x;
	v1.y %= v2.y;
	v1.z %= v2.z;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	return DirectX::XMINT3{ v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	return DirectX::XMINT3{ v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	return DirectX::XMINT3{ v1.x * v2.x, v1.y * v2.y, v1.z * v2.z };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	return DirectX::XMINT3{ v1.x / v2.x, v1.y / v2.y, v1.z / v2.z };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	return DirectX::XMINT3{ (v1.x % v2.x), (v1.y % v2.y), (v1.z % v2.z) };
}

static inline void operator+= (DirectX::XMINT3& v1, const int num)
{
	v1.x += num;
	v1.y += num;
	v1.z += num;
}

static inline void operator-= (DirectX::XMINT3& v1, const int num)
{
	v1.x -= num;
	v1.y -= num;
	v1.z -= num;
}

static inline void operator/= (DirectX::XMINT3& v1, const int num)
{
	v1.x /= num;
	v1.y /= num;
	v1.z /= num;
}

static inline void operator*= (DirectX::XMINT3& v1, const int num)
{
	v1.x *= num;
	v1.y *= num;
	v1.z *= num;
}

static inline void operator%= (DirectX::XMINT3& v1, const int num)
{
	v1.x %= num;
	v1.y %= num;
	v1.z %= num;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMINT3& v1, const int num)
{
	return DirectX::XMINT3{ v1.x + num, v1.y + num, v1.z + num };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMINT3& v1, const int num)
{
	return DirectX::XMINT3{ v1.x - num, v1.y - num, v1.z - num };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMINT3& v1, const int num)
{
	return DirectX::XMINT3{ v1.x * num, v1.y * num, v1.z * num };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMINT3& v1, const int num)
{
	return DirectX::XMINT3{ (v1.x % num), (v1.y % num), (v1.z % num) };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMINT3& v1, const int num)
{
	return DirectX::XMINT3{ v1.x / num, v1.y / num, v1.z / num };
}

_NODISCARD static inline constexpr bool operator== (const DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	return ((v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z));
}

_NODISCARD static inline constexpr bool operator!= (const DirectX::XMINT3& v1, const DirectX::XMINT3& v2)
{
	return !((v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z));
}

//-------------------------------------------------------------------------------------------------------------
//. XMINT2系
//-------------------------------------------------------------------------------------------------------------

static inline void operator+= (DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x += *itr;
	itr++;
	v1.y += *itr;
}

static inline void operator-= (DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x -= *itr;
	itr++;
	v1.y -= *itr;
}

static inline void operator/= (DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x /= *itr;
	itr++;
	v1.y /= *itr;
}

static inline void operator*= (DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
}

static inline void operator%= (DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x %= *itr;
	itr++;
	v1.y %= *itr;
}

_NODISCARD static inline auto operator+ (const DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x += *itr;
	itr++;
	temp.y += *itr;

	return temp;
}

_NODISCARD static inline auto operator- (const DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x -= *itr;
	itr++;
	temp.y -= *itr;

	return temp;
}

_NODISCARD static inline auto operator* (const DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;

	return temp;
}

_NODISCARD static inline auto operator/ (const DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x /= *itr;
	itr++;
	temp.y /= *itr;

	return temp;
}

_NODISCARD static inline auto operator% (const DirectX::XMINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x %= *itr;
	itr++;
	temp.y %= *itr;

	return temp;
}

static inline void operator+= (DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	v1.x += v2.x;
	v1.y += v2.y;
}

static inline void operator-= (DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	v1.x -= v2.x;
	v1.y -= v2.y;
}

static inline void operator/= (DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	v1.x /= v2.x;
	v1.y /= v2.y;
}

static inline void operator*= (DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	v1.x *= v2.x;
	v1.y *= v2.y;
}

static inline void operator%= (DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	v1.x %= v2.x;
	v1.y %= v2.y;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	return DirectX::XMINT2{ v1.x + v2.x, v1.y + v2.y };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	return DirectX::XMINT2{ v1.x - v2.x, v1.y - v2.y };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	return DirectX::XMINT2{ v1.x * v2.x, v1.y * v2.y };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	return DirectX::XMINT2{ v1.x / v2.x, v1.y / v2.y };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	return DirectX::XMINT2{ (v1.x % v2.x), (v1.y % v2.y) };
}

static inline void operator+= (DirectX::XMINT2& v1, const int num)
{
	v1.x += num;
	v1.y += num;
}

static inline void operator-= (DirectX::XMINT2& v1, const int num)
{
	v1.x -= num;
	v1.y -= num;
}

static inline void operator/= (DirectX::XMINT2& v1, const int num)
{
	v1.x /= num;
	v1.y /= num;
}

static inline void operator*= (DirectX::XMINT2& v1, const int num)
{
	v1.x *= num;
	v1.y *= num;
}

static inline void operator%= (DirectX::XMINT2& v1, const int num)
{
	v1.x %= num;
	v1.y %= num;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMINT2& v1, const int num)
{
	return DirectX::XMINT2{ v1.x + num, v1.y + num };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMINT2& v1, const int num)
{
	return DirectX::XMINT2{ v1.x - num, v1.y - num };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMINT2& v1, const int num)
{
	return DirectX::XMINT2{ v1.x * num, v1.y * num };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMINT2& v1, const int num)
{
	return DirectX::XMINT2{ v1.x / num, v1.y / num };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMINT2& v1, const int num)
{
	return DirectX::XMINT2{ (v1.x % num), (v1.y % num) };
}

_NODISCARD static inline constexpr bool operator== (const DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	return ((v1.x == v2.x) && (v1.y == v2.y));
}

_NODISCARD static inline constexpr bool operator!= (const DirectX::XMINT2& v1, const DirectX::XMINT2& v2)
{
	return !((v1.x == v2.x) && (v1.y == v2.y));
}

//-------------------------------------------------------------------------------------------------------------
// 特殊変換関数
//-------------------------------------------------------------------------------------------------------------

inline namespace XmintHelpter
{
	// 型上げ-----------------------------------------------------------------------------------------------

	_NODISCARD static inline auto RaiseToXMint4(const DirectX::XMINT3& vec, const int w_component = 0.f)
	{
		return DirectX::XMINT4{ vec.x, vec.y, vec.z, w_component };
	}

	_NODISCARD static inline auto RaiseToXMint4(const DirectX::XMINT2& vec, const int z_component = 0.f, const int w_component = 0.f)
	{
		return DirectX::XMINT4{ vec.x, vec.y, z_component, w_component };
	}

	_NODISCARD static inline auto RaiseToXMINT3(const DirectX::XMINT2& vec, const int z_component = 0.f)
	{
		return DirectX::XMINT3{ vec.x, vec.y, z_component };
	}

	// 型下げ-----------------------------------------------------------------------------------------------

	// W, Z成分が切り捨てられる
	_NODISCARD static inline auto LowerToXMint2(const DirectX::XMINT4& vec)
	{
		return DirectX::XMINT2{ vec.x, vec.y };
	}

	// Z成分が切り捨てられる
	_NODISCARD static inline auto LowerToXMint2(const DirectX::XMINT3& vec)
	{
		return DirectX::XMINT2{ vec.x, vec.y };
	}

	// W成分が切り捨てられる
	_NODISCARD static inline auto LowerToXMINT3(const DirectX::XMINT4& vec)
	{
		return DirectX::XMINT3{ vec.x, vec.y, vec.z };
	}
}

XMUINT

XMUINT_Helper.h
# pragma once

# include <DirectXMath.h>
# include <initializer_list>

//-------------------------------------------------------------------------------------------------------------
//. XUMINT4系
//-------------------------------------------------------------------------------------------------------------

static inline void operator+= (DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	v1.x += v2.x;
	v1.y += v2.y;
	v1.z += v2.z;
	v1.w += v2.w;
}

static inline void operator-= (DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	v1.x -= v2.x;
	v1.y -= v2.y;
	v1.z -= v2.z;
	v1.w -= v2.w;
}

static inline void operator/= (DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	v1.x /= v2.x;
	v1.y /= v2.y;
	v1.z /= v2.z;
	v1.w /= v2.w;
}

static inline void operator*= (DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	v1.x *= v2.x;
	v1.y *= v2.y;
	v1.z *= v2.z;
	v1.w *= v2.w;
}

static inline void operator%= (DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	v1.x %= v2.x;
	v1.y %= v2.y;
	v1.z %= v2.z;
	v1.w %= v2.w;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	return DirectX::XMUINT4{ v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.w + v2.w };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	return DirectX::XMUINT4{ v1.x - v2.x, v1.y - v2.y, v1.z - v2.z, v1.w - v2.w };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	return DirectX::XMUINT4{ v1.x * v2.x, v1.y * v2.y, v1.z * v2.z, v1.w * v2.w };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	return DirectX::XMUINT4{ v1.x / v2.x, v1.y / v2.y, v1.z / v2.z, v1.w / v2.w };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	return DirectX::XMUINT4{ (v1.x % v2.x), (v1.y % v2.y), (v1.z % v2.z), (v1.w % v2.w) };
}

static inline void operator+= (DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x += *itr;
	itr++;
	v1.y += *itr;
	itr++;
	v1.z += *itr;
	itr++;
	v1.w += *itr;
}

static inline void operator-= (DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x -= *itr;
	itr++;
	v1.y -= *itr;
	itr++;
	v1.z -= *itr;
	itr++;
	v1.w -= *itr;
}

static inline void operator/= (DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x /= *itr;
	itr++;
	v1.y /= *itr;
	itr++;
	v1.z /= *itr;
	itr++;
	v1.w /= *itr;
}

static inline void operator*= (DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
	itr++;
	v1.z *= *itr;
	itr++;
	v1.w *= *itr;
}

static inline void operator%= (DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x %= *itr;
	itr++;
	v1.y %= *itr;
	itr++;
	v1.z %= *itr;
	itr++;
	v1.w %= *itr;
}

_NODISCARD static inline auto operator+ (const DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMUINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x += *itr;
	itr++;
	temp.y += *itr;
	itr++;
	temp.z += *itr;
	itr++;
	temp.w += *itr;

	return temp;
}

_NODISCARD static inline auto operator- (const DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMUINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x -= *itr;
	itr++;
	temp.y -= *itr;
	itr++;
	temp.z -= *itr;
	itr++;
	temp.w -= *itr;

	return temp;
}

_NODISCARD static inline auto operator* (const DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMUINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;
	itr++;
	temp.z *= *itr;
	itr++;
	temp.w *= *itr;

	return temp;
}

_NODISCARD static inline auto operator/ (const DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMUINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x /= *itr;
	itr++;
	temp.y /= *itr;
	itr++;
	temp.z /= *itr;
	itr++;
	temp.w /= *itr;

	return temp;
}

_NODISCARD static inline auto operator% (const DirectX::XMUINT4& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 4u && "不正なイニシャライザーリスト");

	DirectX::XMUINT4 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x %= *itr;
	itr++;
	temp.y %= *itr;
	itr++;
	temp.z %= *itr;
	itr++;
	temp.w %= *itr;

	return temp;
}

static inline void operator+= (DirectX::XMUINT4& v1, const int num)
{
	v1.x += num;
	v1.y += num;
	v1.z += num;
	v1.w += num;
}

static inline void operator-= (DirectX::XMUINT4& v1, const int num)
{
	v1.x -= num;
	v1.y -= num;
	v1.z -= num;
	v1.w -= num;
}

static inline void operator/= (DirectX::XMUINT4& v1, const int num)
{
	v1.x /= num;
	v1.y /= num;
	v1.z /= num;
	v1.w /= num;
}

static inline void operator*= (DirectX::XMUINT4& v1, const int num)
{
	v1.x *= num;
	v1.y *= num;
	v1.z *= num;
	v1.w *= num;
}

static inline void operator%= (DirectX::XMUINT4& v1, const int num)
{
	v1.x %= num;
	v1.y %= num;
	v1.z %= num;
	v1.w %= num;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMUINT4& v1, const int num)
{
	return DirectX::XMUINT4{ v1.x + num, v1.y + num, v1.z + num, v1.w + num };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMUINT4& v1, const int num)
{
	return DirectX::XMUINT4{ v1.x - num, v1.y - num, v1.z - num, v1.w - num };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMUINT4& v1, const int num)
{
	return DirectX::XMUINT4{ v1.x * num, v1.y * num, v1.z * num, v1.w * num };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMUINT4& v1, const int num)
{
	return DirectX::XMUINT4{ v1.x / num, v1.y / num, v1.z / num, v1.w / num };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMUINT4& v1, const int num)
{
	return DirectX::XMUINT4{ (v1.x % num), (v1.y % num), (v1.z % num), (v1.w % num) };
}

_NODISCARD static inline constexpr bool operator== (const DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
}

_NODISCARD static inline constexpr bool operator!= (const DirectX::XMUINT4& v1, const DirectX::XMUINT4& v2)
{
	return !((v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w));
}

//-------------------------------------------------------------------------------------------------------------
//. XMUINT3系
//-------------------------------------------------------------------------------------------------------------

static inline void operator+= (DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x += *itr;
	itr++;
	v1.y += *itr;
	itr++;
	v1.z += *itr;
}

static inline void operator-= (DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x -= *itr;
	itr++;
	v1.y -= *itr;
	itr++;
	v1.z -= *itr;
}

static inline void operator/= (DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x /= *itr;
	itr++;
	v1.y /= *itr;
	itr++;
	v1.z /= *itr;
}

static inline void operator*= (DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
	itr++;
	v1.z *= *itr;
}

static inline void operator%= (DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
	itr++;
	v1.z *= *itr;
}

_NODISCARD static inline auto operator+ (const DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMUINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x += *itr;
	itr++;
	temp.y += *itr;
	itr++;
	temp.z += *itr;

	return temp;
}

_NODISCARD static inline auto operator- (const DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMUINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x -= *itr;
	itr++;
	temp.y -= *itr;
	itr++;
	temp.z -= *itr;

	return temp;
}

_NODISCARD static inline auto operator* (const DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMUINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;
	itr++;
	temp.z *= *itr;

	return temp;
}

_NODISCARD static inline auto operator/ (const DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMUINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x /= *itr;
	itr++;
	temp.y /= *itr;
	itr++;
	temp.z /= *itr;

	return temp;
}

_NODISCARD static inline auto operator% (const DirectX::XMUINT3& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 3u && "不正なイニシャライザーリスト");

	DirectX::XMUINT3 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;
	itr++;
	temp.z *= *itr;

	return temp;
}

static inline void operator+= (DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	v1.x += v2.x;
	v1.y += v2.y;
	v1.z += v2.z;
}

static inline void operator-= (DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	v1.x -= v2.x;
	v1.y -= v2.y;
	v1.z -= v2.z;
}

static inline void operator*= (DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	v1.x *= v2.x;
	v1.y *= v2.y;
	v1.z *= v2.z;
}

static inline void operator/= (DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	v1.x /= v2.x;
	v1.y /= v2.y;
	v1.z /= v2.z;
}

static inline void operator%= (DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	v1.x %= v2.x;
	v1.y %= v2.y;
	v1.z %= v2.z;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	return DirectX::XMUINT3{ v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	return DirectX::XMUINT3{ v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	return DirectX::XMUINT3{ v1.x * v2.x, v1.y * v2.y, v1.z * v2.z };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	return DirectX::XMUINT3{ v1.x / v2.x, v1.y / v2.y, v1.z / v2.z };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	return DirectX::XMUINT3{ (v1.x % v2.x), (v1.y % v2.y), (v1.z % v2.z) };
}

static inline void operator+= (DirectX::XMUINT3& v1, const int num)
{
	v1.x += num;
	v1.y += num;
	v1.z += num;
}

static inline void operator-= (DirectX::XMUINT3& v1, const int num)
{
	v1.x -= num;
	v1.y -= num;
	v1.z -= num;
}

static inline void operator/= (DirectX::XMUINT3& v1, const int num)
{
	v1.x /= num;
	v1.y /= num;
	v1.z /= num;
}

static inline void operator*= (DirectX::XMUINT3& v1, const int num)
{
	v1.x *= num;
	v1.y *= num;
	v1.z *= num;
}

static inline void operator%= (DirectX::XMUINT3& v1, const int num)
{
	v1.x %= num;
	v1.y %= num;
	v1.z %= num;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMUINT3& v1, const int num)
{
	return DirectX::XMUINT3{ v1.x + num, v1.y + num, v1.z + num };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMUINT3& v1, const int num)
{
	return DirectX::XMUINT3{ v1.x - num, v1.y - num, v1.z - num };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMUINT3& v1, const int num)
{
	return DirectX::XMUINT3{ v1.x * num, v1.y * num, v1.z * num };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMUINT3& v1, const int num)
{
	return DirectX::XMUINT3{ (v1.x % num), (v1.y % num), (v1.z % num) };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMUINT3& v1, const int num)
{
	return DirectX::XMUINT3{ v1.x / num, v1.y / num, v1.z / num };
}

_NODISCARD static inline constexpr bool operator== (const DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	return ((v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z));
}

_NODISCARD static inline constexpr bool operator!= (const DirectX::XMUINT3& v1, const DirectX::XMUINT3& v2)
{
	return !((v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z));
}

//-------------------------------------------------------------------------------------------------------------
//. XMUINT2系
//-------------------------------------------------------------------------------------------------------------

static inline void operator+= (DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x += *itr;
	itr++;
	v1.y += *itr;
}

static inline void operator-= (DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x -= *itr;
	itr++;
	v1.y -= *itr;
}

static inline void operator/= (DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x /= *itr;
	itr++;
	v1.y /= *itr;
}

static inline void operator*= (DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x *= *itr;
	itr++;
	v1.y *= *itr;
}

static inline void operator%= (DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	auto itr{ v2.begin() };
	v1.x %= *itr;
	itr++;
	v1.y %= *itr;
}

_NODISCARD static inline auto operator+ (const DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMUINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x += *itr;
	itr++;
	temp.y += *itr;

	return temp;
}

_NODISCARD static inline auto operator- (const DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMUINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x -= *itr;
	itr++;
	temp.y -= *itr;

	return temp;
}

_NODISCARD static inline auto operator* (const DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMUINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x *= *itr;
	itr++;
	temp.y *= *itr;

	return temp;
}

_NODISCARD static inline auto operator/ (const DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMUINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x /= *itr;
	itr++;
	temp.y /= *itr;

	return temp;
}

_NODISCARD static inline auto operator% (const DirectX::XMUINT2& v1, const std::initializer_list<int>& v2)
{
	assert(v2.size() == 2u && "不正なイニシャライザーリスト");

	DirectX::XMUINT2 temp{ v1 };
	auto itr{ v2.begin() };

	temp.x %= *itr;
	itr++;
	temp.y %= *itr;

	return temp;
}

static inline void operator+= (DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	v1.x += v2.x;
	v1.y += v2.y;
}

static inline void operator-= (DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	v1.x -= v2.x;
	v1.y -= v2.y;
}

static inline void operator/= (DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	v1.x /= v2.x;
	v1.y /= v2.y;
}

static inline void operator*= (DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	v1.x *= v2.x;
	v1.y *= v2.y;
}

static inline void operator%= (DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	v1.x %= v2.x;
	v1.y %= v2.y;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	return DirectX::XMUINT2{ v1.x + v2.x, v1.y + v2.y };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	return DirectX::XMUINT2{ v1.x - v2.x, v1.y - v2.y };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	return DirectX::XMUINT2{ v1.x * v2.x, v1.y * v2.y };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	return DirectX::XMUINT2{ v1.x / v2.x, v1.y / v2.y };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	return DirectX::XMUINT2{ (v1.x % v2.x), (v1.y % v2.y) };
}

static inline void operator+= (DirectX::XMUINT2& v1, const int num)
{
	v1.x += num;
	v1.y += num;
}

static inline void operator-= (DirectX::XMUINT2& v1, const int num)
{
	v1.x -= num;
	v1.y -= num;
}

static inline void operator/= (DirectX::XMUINT2& v1, const int num)
{
	v1.x /= num;
	v1.y /= num;
}

static inline void operator*= (DirectX::XMUINT2& v1, const int num)
{
	v1.x *= num;
	v1.y *= num;
}

static inline void operator%= (DirectX::XMUINT2& v1, const int num)
{
	v1.x %= num;
	v1.y %= num;
}

_NODISCARD static inline constexpr auto operator+ (const DirectX::XMUINT2& v1, const int num)
{
	return DirectX::XMUINT2{ v1.x + num, v1.y + num };
}

_NODISCARD static inline constexpr auto operator- (const DirectX::XMUINT2& v1, const int num)
{
	return DirectX::XMUINT2{ v1.x - num, v1.y - num };
}

_NODISCARD static inline constexpr auto operator* (const DirectX::XMUINT2& v1, const int num)
{
	return DirectX::XMUINT2{ v1.x * num, v1.y * num };
}

_NODISCARD static inline constexpr auto operator/ (const DirectX::XMUINT2& v1, const int num)
{
	return DirectX::XMUINT2{ v1.x / num, v1.y / num };
}

_NODISCARD static inline constexpr auto operator% (const DirectX::XMUINT2& v1, const int num)
{
	return DirectX::XMUINT2{ (v1.x % num), (v1.y % num) };
}

_NODISCARD static inline constexpr bool operator== (const DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	return ((v1.x == v2.x) && (v1.y == v2.y));
}

_NODISCARD static inline constexpr bool operator!= (const DirectX::XMUINT2& v1, const DirectX::XMUINT2& v2)
{
	return !((v1.x == v2.x) && (v1.y == v2.y));
}

//-------------------------------------------------------------------------------------------------------------
// 特殊変換関数
//-------------------------------------------------------------------------------------------------------------

inline namespace XmuintHelper
{
	// 型上げ-----------------------------------------------------------------------------------------------

	_NODISCARD static inline auto RaiseToXMUINT4(const DirectX::XMUINT3& vec, const uint32_t w_component = 0u)
	{
		return DirectX::XMUINT4{ vec.x, vec.y, vec.z, w_component };
	}

	_NODISCARD static inline auto RaiseToXMUINT4(const DirectX::XMUINT2& vec, const uint32_t z_component = 0u, const uint32_t w_component = 0u)
	{
		return DirectX::XMUINT4{ vec.x, vec.y, z_component, w_component };
	}

	_NODISCARD static inline auto RaiseToXMUINT3(const DirectX::XMUINT2& vec, const uint32_t z_component = 0u)
	{
		return DirectX::XMUINT3{ vec.x, vec.y, z_component };
	}

	// 型下げ-----------------------------------------------------------------------------------------------

	// W, Z成分が切り捨てられる
	_NODISCARD static inline auto LowerToXMUINT2(const DirectX::XMUINT4& vec)
	{
		return DirectX::XMUINT2{ vec.x, vec.y };
	}

	// Z成分が切り捨てられる
	_NODISCARD static inline auto LowerToXMUINT2(const DirectX::XMUINT3& vec)
	{
		return DirectX::XMUINT2{ vec.x, vec.y };
	}

	// W成分が切り捨てられる
	_NODISCARD static inline auto LowerToXMUINT3(const DirectX::XMUINT4& vec)
	{
		return DirectX::XMUINT3{ vec.x, vec.y, vec.z };
	}
}

最後に

　相変わらずコードが長いですが、皆さんが不要だと思うコードは削除・変更して使ってください。

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?