antkeeper
/
source


								/*

								 * Copyright (C) 2021  Christopher J. Howard

								 *

								 * This file is part of Antkeeper source code.

								 *

								 * Antkeeper source code 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.

								 *

								 * Antkeeper source code 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 Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.

								 */


								#ifndef ANTKEEPER_FUNDAMENTAL_TYPES_HPP

								#define ANTKEEPER_FUNDAMENTAL_TYPES_HPP


								#include "math/vector-type.hpp"

								#include "math/vector-operators.hpp"

								#include "math/matrix-type.hpp"

								#include "math/matrix-operators.hpp"


								/// 2D vector of bools

								using bool2 = math::vector<bool, 2>;


								/// 3D vector of bools

								using bool3 = math::vector<bool, 3>;


								/// 4D vector of bools

								using bool4 = math::vector<bool, 4>;


								/// 2D vector of chars

								using char2 = math::vector<char, 2>;


								/// 3D vector of chars

								using char3 = math::vector<char, 3>;


								/// 4D vector of chars

								using char4 = math::vector<char, 4>;


								/// 2D vector of unsigned chars

								using uchar2 = math::vector<unsigned char, 2>;


								/// 3D vector of unsigned chars

								using uchar3 = math::vector<unsigned char, 3>;


								/// 4D vector of unsigned chars

								using uchar4 = math::vector<unsigned char, 4>;


								/// 2D vector of shorts

								using short2 = math::vector<short, 2>;


								/// 3D vector of shorts

								using short3 = math::vector<short, 3>;


								/// 4D vector of shorts

								using short4 = math::vector<short, 4>;


								/// 2D vector of unsigned shorts

								using ushort2 = math::vector<unsigned short, 2>;


								/// 3D vector of unsigned shorts

								using ushort3 = math::vector<unsigned short, 3>;


								/// 4D vector of unsigned shorts

								using ushort4 = math::vector<unsigned short, 4>;


								/// 2D vector of ints

								using int2 = math::vector<int, 2>;


								/// 3D vector of ints

								using int3 = math::vector<int, 3>;


								/// 4D vector of ints

								using int4 = math::vector<int, 4>;


								/// 2D vector of unsigned ints

								using uint2 = math::vector<unsigned int, 2>;


								/// 3D vector of unsigned ints

								using uint3 = math::vector<unsigned int, 3>;


								/// 4D vector of unsigned ints

								using uint4 = math::vector<unsigned int, 4>;


								/// 2D vector of longs

								using long2 = math::vector<long, 2>;


								/// 3D vector of longs

								using long3 = math::vector<long, 3>;


								/// 4D vector of longs

								using long4 = math::vector<long, 4>;


								/// 2D vector of unsigned longs

								using ulong2 = math::vector<unsigned long, 2>;


								/// 3D vector of unsigned longs

								using ulong3 = math::vector<unsigned long, 3>;


								/// 4D vector of unsigned longs

								using ulong4 = math::vector<unsigned long, 4>;


								/// 2D vector of floats

								using float2 = math::vector<float, 2>;


								/// 3D vector of floats

								using float3 = math::vector<float, 3>;


								/// 4D vector of floats

								using float4 = math::vector<float, 4>;


								/// 2D vector of doubles

								using double2 = math::vector<double, 2>;


								/// 3D vector of doubles

								using double3 = math::vector<double, 3>;


								/// 4D vector of doubles

								using double4 = math::vector<double, 4>;


								/// 2x2 matrix of bools

								using bool2x2 = math::matrix<bool, 2, 2>;


								/// 3x3 matrix of bools

								using bool3x3 = math::matrix<bool, 3, 3>;


								/// 4x4 matrix of bools

								using bool4x4 = math::matrix<bool, 4, 4>;


								/// 2x2 matrix of chars

								using char2x2 = math::matrix<char, 2, 2>;


								/// 3x3 matrix of chars

								using char3x3 = math::matrix<char, 3, 3>;


								/// 4x4 matrix of chars

								using char4x4 = math::matrix<char, 4, 4>;


								/// 2x2 matrix of unsigned chars

								using uchar2x2 = math::matrix<unsigned char, 2, 2>;


								/// 3x3 matrix of unsigned chars

								using uchar3x3 = math::matrix<unsigned char, 3, 3>;


								/// 4x4 matrix of unsigned chars

								using uchar4x4 = math::matrix<unsigned char, 4, 4>;


								/// 2x2 matrix of shorts

								using short2x2 = math::matrix<short, 2, 2>;


								/// 3x3 matrix of shorts

								using short3x3 = math::matrix<short, 3, 3>;


								/// 4x4 matrix of shorts

								using short4x4 = math::matrix<short, 4, 4>;


								/// 2x2 matrix of unsigned shorts

								using ushort2x2 = math::matrix<unsigned short, 2, 2>;


								/// 3x3 matrix of unsigned shorts

								using ushort3x3 = math::matrix<unsigned short, 3, 3>;


								/// 4x4 matrix of unsigned shorts

								using ushort4x4 = math::matrix<unsigned short, 4, 4>;


								/// 2x2 matrix of ints

								using int2x2 = math::matrix<int, 2, 2>;


								/// 3x3 matrix of ints

								using int3x3 = math::matrix<int, 3, 3>;


								/// 4x4 matrix of ints

								using int4x4 = math::matrix<int, 4, 4>;


								/// 2x2 matrix of unsigned ints

								using uint2x2 = math::matrix<unsigned int, 2, 2>;


								/// 3x3 matrix of unsigned ints

								using uint3x3 = math::matrix<unsigned int, 3, 3>;


								/// 4x4 matrix of unsigned ints

								using uint4x4 = math::matrix<unsigned int, 4, 4>;


								/// 2x2 matrix of longs

								using long2x2 = math::matrix<long, 2, 2>;


								/// 3x3 matrix of longs

								using long3x3 = math::matrix<long, 3, 3>;


								/// 4x4 matrix of longs

								using long4x4 = math::matrix<long, 4, 4>;


								/// 2x2 matrix of unsigned longs

								using ulong2x2 = math::matrix<unsigned long, 2, 2>;


								/// 3x3 matrix of unsigned longs

								using ulong3x3 = math::matrix<unsigned long, 3, 3>;


								/// 4x4 matrix of unsigned longs

								using ulong4x4 = math::matrix<unsigned long, 4, 4>;


								/// 2x2 matrix of floats

								using float2x2 = math::matrix<float, 2, 2>;


								/// 3x3 matrix of floats

								using float3x3 = math::matrix<float, 3, 3>;


								/// 4x4 matrix of floats

								using float4x4 = math::matrix<float, 4, 4>;


								/// 2x2 matrix of doubles

								using double2x2 = math::matrix<double, 2, 2>;


								/// 3x3 matrix of doubles

								using double3x3 = math::matrix<double, 3, 3>;


								/// 4x4 matrix of doubles

								using double4x4 = math::matrix<double, 4, 4>;


								#endif // ANTKEEPER_FUNDAMENTAL_TYPES_HPP